None\\n new_value = value\\n if key in self._ifAttributes['bridge-opts']:\\n new_value = self._ifAttributes['bridge-opts'][key] + value\\n self.replaceBropt(key, new_value)\",\n \"def add(counts):\\n if counts:\\n for k in grammar.keys():\\n grammar[k] = grammar[k] + counts[k]\",\n \"def buildDict(self, dict):\\n for word in dict:\\n self.add(word)\",\n \"def buildDict(self, dict):\\n for word in dict:\\n self.s.add(word)\\n self.length_set = set([len(word) for word in dict])\",\n \"def copy_forward_mapping(self) -> Dict[str, Set[str]]:\\n return deepcopy(self._forward_mapping)\",\n \"def insert(self, word):\\r\\n t = self.trie\\r\\n \\r\\n for w in word: \\r\\n if w not in t: \\r\\n t[w] = {}\\r\\n t = t[w]\\r\\n t['#'] = True\\r\\n print(self.trie)\",\n \"def buildDict(self, dict):\\n self.all_words = set(dict)\\n self.wc_dict = collections.defaultdict(int)\\n for w in dict:\\n for wc in self.get_wildcards(w):\\n self.wc_dict[wc] += 1\",\n \"def buildDict(self, words):\\n self.dict = collections.defaultdict(set)\\n for word in words:\\n for i in xrange(len(word)):\\n self.dict[word[:i] + '*' + word[i+1:]].add(word[i])\",\n \"def add_ngrams(mydict,sentence):\\n ngrams = get_ngrams(sentence,2,3)\\n for ngram in ngrams:\\n if ngram in mydict:\\n mydict[ngram]+=1\\n else:\\n mydict[ngram]=1\\n return mydict\",\n \"def addWord(self, word: str) -> None:\\n curr = self.trie\\n for char in word:\\n if char not in curr:\\n curr[char] = {}\\n curr = curr[char]\\n curr['$'] = {}\",\n \"def buildDict(self, words):\\n for word in words:\\n length = len(word)\\n key = \\\"{}/{}\\\".format(length, word[0])\\n ls = self.origin.get(key, [])\\n ls.append(word)\\n self.origin[key] = ls\",\n \"def _add_dictionary(self, current, added):\\n for key in added:\\n if key in current and isinstance(current[key], collections.Mapping):\\n self._add_dictionary(current[key], added[key])\\n else:\\n current[key] = added[key]\",\n \"def make_chains(corpus):\\n c_dict = {}\\n\\n for x in range(len(corpus)):\\n if x < (len(corpus)-2): # not in edge\\n bigram_tuple = tuple([corpus[x],corpus[x+1]])\\n if bigram_tuple in c_dict:\\n c_dict[bigram_tuple].append(corpus[x+2])\\n else:\\n c_dict[bigram_tuple] = [corpus[x+2]]\\n else:\\n bigram_tuple = tuple([corpus[-2],corpus[-1]]) # ran twice. Why?\\n c_dict.setdefault(bigram_tuple) # could set a default word? Empty list?\\n\\n return c_dict\",\n \"def addWord(self, word: str) -> None:\\n trie = self.trie\\n for c in word:\\n if c not in trie:\\n trie[c] = dict()\\n trie = trie[c]\\n trie['#'] = '#'\",\n \"def intents_clustering(self):\\n self.phrs2intents = {}\\n number_of_other = 10000;\\n for i in range(len(self.data)):\\n for ut in self.data[i]['utterances']:\\n if ut['speaker'] == 'USER':\\n if 'segments' in ut.keys():\\n for seg in ut['segments']:\\n if 'annotations' in seg.keys():\\n for anno in seg['annotations']:\\n name = anno['name']\\n if ut['text'] not in self.phrs2intents.keys():\\n self.phrs2intents[ ut['text'] ] = [name]\\n elif name not in self.phrs2intents[ ut['text'] ]:\\n self.phrs2intents[ ut['text'] ].append(name)\\n else:\\n if number_of_other > 0:\\n self.phrs2intents[ ut['text'] ] = ['other']\\n number_of_other -= 1\\n self.X = np.array(list(self.phrs2intents.keys()))\",\n \"def _create_connections(self):\\n self.predecessors = {}\\n self.successors = {}\\n for nd in self.nodes:\\n self.predecessors[nd.name] = []\\n self.successors[nd.name] = []\\n\\n for (nd_out, nd_in) in self.edges:\\n self.predecessors[nd_in.name].append(nd_out)\\n self.successors[nd_out.name].append(nd_in)\",\n \"def create_tunnel(cave_from, cave_to):\\n caves[cave_from].append(cave_to)\\n caves[cave_to].append(cave_from)\",\n \"def update_adj_dict(self,word2,same_line):\\n if word2 in self.adj_dict:\\n if same_line:\\n self.adj_dict[word2] = (self.adj_dict[word2][0]+1,\\n self.adj_dict[word2][1])\\n else:\\n self.adj_dict[word2] = (self.adj_dict[word2][0], \\n self.adj_dict[word2][1]+1)\\n else:\\n if same_line: \\n self.adj_dict[word2] = (1, 0)\\n else:\\n self.adj_dict[word2] = (0, 1)\",\n \"def addWord(self, word: 'str') -> 'None':\\n p=self.dictword\\n for s in word:\\n if s not in p:\\n p[s]={}\\n p=p[s]\\n else:\\n p=p[s]\\n p['#']=None\",\n \"def _set_hop(self, v, load=False):\\n try:\\n t = YANGDynClass(v,base=YANGListType(\\\"hop_id\\\",yc_hop_pyangbind_example__input_LocatorRecord_rloc_explicit_locator_path_hop, yang_name=\\\"hop\\\", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper), is_container='list', yang_name=\\\"hop\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"\\\"\\\"hop must be of a type compatible with base=YANGListType(\\\"hop_id\\\",yc_hop_pyangbind_example__input_LocatorRecord_rloc_explicit_locator_path_hop, yang_name=\\\"hop\\\", parent=self, is_container='list', user_ordered=True, path_helper=self._path_helper), is_container='list', yang_name=\\\"hop\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True\\\"\\\"\\\")\\n self.__hop = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def add_children_to_parents(self, mutated_pop_dict, mating_pop_dict):\\n\\n print('Combining parent and child generations')\\n\\n merged_networks_dict = OrderedDict()\\n\\n for id, G in mutated_pop_dict.items():\\n new_id = ''.join(\\n [random.choice(string.ascii_letters + string.digits)\\n for i in range(10)]\\n )\\n merged_networks_dict[new_id] = copy.deepcopy(G)\\n for id, G in mating_pop_dict.items():\\n merged_networks_dict[id] = copy.deepcopy(G)\\n\\n return merged_networks_dict\",\n \"def _add_state(self, prefix):\\n for i in range(len(self.states)):\\n self.states[i] = prefix + self.states[i]\\n\\n self.q_0 = prefix + self.q_0\\n\\n for i in range(len(self.final)):\\n self.final[i] = prefix + self.final[i]\\n\\n keys = list(self.transition.keys())\\n for key in keys:\\n new_key = prefix + key\\n self.transition[new_key] = []\\n for i in range(len(self.transition[key])):\\n self.transition[new_key].append(prefix + self.transition[key][i])\\n del self.transition[key]\",\n \"def insert(self, word: str) -> None:\\n curr_chars = self.chars\\n for c in list(word):\\n if c not in curr_chars:\\n curr_chars[c] = {}\\n curr_chars = curr_chars[c]\\n\\n curr_chars[self.end_of_word] = self.end_of_word\",\n \"def add_vertex(self, v):\\n self[v] = {}\",\n \"def add_vertex(self, v):\\n self[v] = {}\",\n \"def _set_hop_id(self, v, load=False):\\n parent = getattr(self, \\\"_parent\\\", None)\\n if parent is not None and load is False:\\n raise AttributeError(\\\"Cannot set keys directly when\\\" +\\n \\\" within an instantiated list\\\")\\n\\n try:\\n t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name=\\\"hop-id\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"\\\"\\\"hop_id must be of a type compatible with base=unicode, is_leaf=True, yang_name=\\\"hop-id\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True\\\"\\\"\\\")\\n self.__hop_id = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def __init__(self,directed=False):\\n self._outgoing = {}\\n # only create second map for directed graph; use alias for undirected\\n self._incoming = {} if directed else self._outgoing\",\n \"def __init__(self, dictionary):\\n self.d = {}\\n for word in dictionary:\\n abbr = self.getAbbr(word)\\n if abbr in self.d:\\n self.d[abbr] += word,\\n else:\\n self.d[abbr] = [word]\",\n \"def enrich_params(self):\\n\\n self.params['nmaps'] = len(self.params['probes']) + np.sum(self.params['spins'] == 2)\\n\\n pass\",\n \"def encode(self):\\n\\n ret = {}\\n ret[DC] = ''.join(encode_huffman(v, self.layer_type)\\n for v in self.diff_dc)\\n ret[AC] = ''.join(encode_huffman(v, self.layer_type)\\n for v in self.run_length_ac)\\n return ret\",\n \"def add_edge(self, edge):\\n edge = set(edge)\\n (vertex1, vertex2) = tuple(edge)\\n if vertex1 not in self.__graph_dict:\\n self.__graph_dict[vertex1] = []\\n dbg_str = \\\"Vertex being initialized ..\\\" + str(vertex1)\\n # logging.debug(dbg_str)\\n if vertex2 not in self.__graph_dict:\\n self.__graph_dict[vertex2] = []\\n dbg_str = \\\"Vertex being initialized ..\\\" + str(vertex2)\\n # logging.debug(dbg_str)\\n if vertex2 not in self.__graph_dict[vertex1]:\\n self.__graph_dict[vertex1].append(vertex2)\\n dbg_str = \\\"Appending .. \\\" + str(vertex2), \\\"to ->\\\" +str(vertex1)\\n # logging.debug(dbg_str)\\n\\n if vertex1 not in self.__graph_dict[vertex2]:\\n self.__graph_dict[vertex2].append(vertex1)\\n dbg_str = \\\"Appending .. \\\" + str(vertex1), \\\"to ->\\\" +str(vertex2)\\n # logging.debug(dbg_str)\",\n \"def consolidate_other(self):\\n for set in [self.clients, self.shutdown_clients]:\\n for c in set:\\n client_other = set[c].get('other', {})\\n for k in client_other.keys():\\n if k == 'prefix_paths':\\n if not self.other.get('prefix_paths'):\\n self.other['prefix_paths'] = []\\n # Repeatedly converting the array to a dict and back is inefficient\\n # but this will happen only once per client and the number of prefix\\n # paths should be small so overall impact should be very low\\n pp = client_other.get('prefix_paths', [])\\n if pp:\\n self.other['prefix_paths'].extend(pp)\\n self.other['prefix_paths'] = sorted(list(dict.fromkeys(self.other['prefix_paths'])))\",\n \"def _get_hop(self):\\n return self.__hop\",\n \"def insert(self, word):\\n level = self.trie\\n for c in word:\\n if c in level:\\n level = level[c]\\n else:\\n level[c] = {}\\n level = level[c]\\n level[self.end] = 1\",\n \"def add_rule_to_dict(rule_dict, lhs, rhs):\\n if rhs not in rule_dict:\\n rule_dict[rhs] = list()\\n rule_dict[rhs].append(lhs) \\n return rule_dict\",\n \"def add_prefix(self, state_dict, prefix):\\n print('add prefix \\\\'{}\\\\''.format(prefix))\\n f = lambda x: x + prefix # 去除带有prefix的名字\\n return {f(key): value for key, value in state_dict.items()}\",\n \"def add_vertex(self, vertex):\\n self[vertex] = {}\",\n \"def add(self, key):\\r\\n if key not in self.map:\\r\\n end = self.end\\r\\n curr = end[PREV]\\r\\n curr[NEXT] = end[PREV] = self.map[key] = [key, curr, end]\",\n \"def cyclic_conjugates(self):\\n return {self.cyclic_subword(i, i+len(self)) for i in range(len(self))}\",\n \"def dictionary(word_list):\\n word_list.append(\\\"\\\")\\n for i in range(len(word_list)-2):\\n prob_dict.setdefault(word_list[i], []).append(word_list[i+1])\",\n \"def update(self, other):\\n for (ngram, value) in other.items():\\n self[ngram] = value\",\n \"def enrich_with_phrases(segue, kind):\\n phrase_n1 = phrase(segue['n1'], segue['compare_function'], kind)\\n phrase_n2 = phrase(segue['n2'], segue['compare_function'], kind)\\n if phrase_n1 is not None:\\n segue = {**{'phrase_n1': phrase_n1(segue['n1'], segue)}, **segue}\\n if phrase_n2 is not None:\\n segue = {**{'phrase_n2': phrase_n2(segue['n2'], segue)}, **segue}\\n return segue\",\n \"def add_new_haloprops(self, galaxy_table):\\n if hasattr(self, 'new_haloprop_func_dict'):\\n d = self.new_haloprop_func_dict\\n for key, func in d.iteritems():\\n if key not in galaxy_table.keys():\\n galaxy_table[key] = func(galaxy_table=galaxy_table)\",\n \"def insert(self, word):\\n curr = self.trie\\n for i,ch in enumerate(word):\\n if curr.get(ch, {}):\\n curr = curr[ch]\\n if i==len(word)-1:\\n curr['\\\\0'] = {}\\n else:\\n if i<len(word)-1:\\n curr[ch] = {}\\n curr = curr[ch]\\n else:\\n curr[ch] = {\\n '\\\\0':{}\\n }\",\n \"def __init__(self, hop_interval=0):\\n\\n self.hop_interval = hop_interval\",\n \"def addAll(self, c):\\n self.knownStrings.update(c)\",\n \"def __add_current_state_to_state_dict(self):\\n board_fen = self.board_fen()\\n if board_fen not in self.states:\\n self.states[self.board_fen()] = GameState(self.board_array())\",\n \"def buildDict(self, words: List[str]) -> None:\\n for word in words:\\n self.buckets[len(word)].append(word)\",\n \"def buildDict(self, words):\\r\\n for word in words:\\r\\n self.trie.addWord(word)\",\n \"def __iadd__(self, other):\\n if not isinstance(other, dict):\\n msg = 'Can not concatenate Dict and {}'.format(type(other))\\n raise TypeError(msg)\\n for key, val in other.items():\\n if key in self:\\n self._append_key(key, val)\\n else:\\n self[key] = val\\n return self\",\n \"def harmonize_keys(self):\\n self._data.key_regex_replacements = _key_regex_replacements\\n self._data.key_replacements = _key_replacements\",\n \"def __init__(self, adjacency={}):\\r\\n self.d = dict(adjacency)\",\n \"def replicate ( self ):\\n\\t\\tto_be_returned = Phenotype ( self.phenotypes )\\n\\t\\tto_be_returned.counts = dict( self.get_counts().items() )\\n\\n\\t\\treturn to_be_returned\",\n \"def addVertex(self, v):\\r\\n self.adjacent.setdefault(v, list())\",\n \"def adjPopulate(adjDict,adjFlag):\\n# adjectives with enhancements starting with 'a' will go into dictionaries for weapons\\n# similarly, adjective enhancements leading with 'd' go to shields and 'h' for helmets\\n# Returns a dictionary corresponding to the key/values that match the flag\\n passDict = {}\\n\\n for key in adjDict:\\n if adjDict[key][0] == adjFlag:\\n passDict[key] = adjDict[key]\\n\\n return passDict\",\n \"def prep_coco_cats():\\n for coco_cat_id, transformed_cat_id_p1 in get_label_map().items():\\n transformed_cat_id = transformed_cat_id_p1 - 1\\n coco_cats[transformed_cat_id] = coco_cat_id\\n coco_cats_inv[coco_cat_id] = transformed_cat_id\",\n \"def buildDict(self, dict):\\n for x in dict:\\n self.EntireSet.append(x)\\n print self.EntireSet\",\n \"def topo_conf():\\n for k in switches.keys():\\n switches_ip[k] = IPAddr((192<<24)+int(k))\\n switches_mac[k] = EthAddr(\\\"aa\\\"+ \\\"%010d\\\"%(k))\",\n \"def update_below(self):\\n for comp in list(self.networks.keys()) + list(self.outputs.keys()):\\n if comp in self.comps_below:\\n below = self.comp_by_input(comp)\\n self.comps_below[comp] += [bel for bel in below if bel not in self.comps_below[comp]]\\n else:\\n self.comps_below[comp] = self.comp_by_input(comp)\",\n \"def add_vertex(self, vertex):\\r\\n if vertex not in self.__graph_dict:\\r\\n self.__graph_dict[vertex] = {}\",\n \"def hot_phrases(self):\\r\\n return self._get('hot_phrases', {})\",\n \"def connotation_dump(path, sentence, value):\\n try:\\n word_connotations = basicutils.import_json(path)\\n sentence = re.sub(r'[^\\\\w\\\\s]','', sentence)\\n proper_nouns = basic_ner(sentence, power = False, locations = True)\\n split_sent = sentence.split()\\n for word in split_sent:\\n if word in proper_nouns:\\n pass\\n else: \\n word = word.lower()\\n try:\\n word_connotations[word].append(value)\\n except KeyError:\\n word_connotations[word] = [value]\\n if nltk_enabled:\\n for bigram_tuple in bigrams(split_sent):\\n if any([word for word in bigram_tuple \\n for p_noun in proper_nouns \\n if word == p_noun]):\\n pass\\n else:\\n bigram_tuple = ' '.join([word.lower() \\n for word in bigram_tuple])\\n try:\\n word_connotations[bigram_tuple].append(value)\\n except KeyError:\\n word_connotations[bigram_tuple] = [value]\\n basicutils.json_dump(path, word_connotations)\\n except:\\n print('Failed to dump data at {}'.format(path))\",\n \"def add_word_to_dict(self, word):\\n\\n # if the word already exist in the dict\\n # we increment 1 the value\\n if word in self.words_to_counts:\\n self.words_to_counts[word] += 1\\n\\n # if the word in the dict is capitalize\\n # we add the new word lower case, with the value of the\\n # capitalize word plus 1\\n # and delete the old capitalize word\\n elif word.capitalize() in self.words_to_counts:\\n self.words_to_counts[word] = self.words_to_counts[\\n word.capitalize()] + 1\\n del self.words_to_counts[word.capitalize()]\\n\\n # if the word in the dict is lower case but the input\\n # is capitalize, we just increment the value of the word by 1\\n elif word.lower() in self.words_to_counts:\\n self.words_to_counts[word] += 1\\n\\n # if the word doen't exist in the dict, we add the new word\\n else:\\n self.words_to_counts[word] = 1\",\n \"def connection_extra_lower(self) -> dict:\\n conn = self.get_connection(getattr(self, self.conn_name_attr))\\n return {k.lower(): v for k, v in conn.extra_dejson.items()}\",\n \"def _stream_dict_add(sb, n, i=None):\\n if i is None:\\n key = n\\n else:\\n key = \\\"{}[{}]\\\".format(n, i)\\n stream_dict[key] = sb\",\n \"def _announce(self):\\n \\n \\\"Create dictionary to hold key: router, value: all the distances to it\\\"\\n shortestDises = dict()\\n\\n \\\"Fill in shortestDises by going through all the values in routing table\\\" \\n for disToDests in self.routingTable.values():\\n for dest in disToDests:\\n shortestDises[dest] = min(shortestDises.get(dest, (100, 100)), disToDests[dest])\\n \\n \\\"Send the update packet to self's neighbors\\\"\\n for neighbor in self.routingTable:\\n updatePacket = RoutingUpdate()\\n disPortToNeighbor = self.routingTable[neighbor][neighbor]\\n \\n \\\"Add destinations(except neighbor) and shortest distances into the update packet\\\"\\n for dest in shortestDises:\\n if dest != neighbor:\\n \\n \\\"Poison reverse\\\"\\n if shortestDises[dest][1] == disPortToNeighbor[1]:\\n distance = 100\\n else:\\n distance = shortestDises[dest][0]\\n \\n updatePacket.add_destination(dest, distance)\\n \\n \\\"Sending update packet after construction\\\"\\n self.send(updatePacket, disPortToNeighbor[1], False)\",\n \"def add_immigrants_landscape(self):\\n self.herb_pop.extend(self.herb_immigrants)\\n self.carn_pop.extend(self.carn_immigrants)\\n self.herb_immigrants = []\\n self.carn_immigrants = []\",\n \"def generate_antonym_pairs(config: SettingConfig) -> dict:\\n print(f\\\"Generating initial antonym pairs from RoWordNet @ {datetime.now()}\\\")\\n wn = rwn.RoWordNet()\\n\\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\\n # the PoS and the value is a set of pairs of words of PoS specified by the key\\n pairs = dict()\\n\\n # Iterate over the selected parts of speech\\n for part_of_speech in config.pos.values():\\n\\n pos_pairs = list()\\n\\n # Return all synsets corresponding to the PoS\\n synset_ids = wn.synsets(pos=part_of_speech)\\n\\n # Iterate all the synsets for the current PoS\\n for synset_id in synset_ids:\\n\\n # Get the synset object specified by synset_id\\n synset = wn.synset(synset_id)\\n\\n # Get the outbound relations of type antonym from\\n outbound_relations = filter(lambda x: x[1] == 'near_antonym', wn.outbound_relations(synset_id))\\n\\n # Iterate outbound relations\\n for relation in outbound_relations:\\n # Get the synset corresponding to the target of the outbound relation\\n target_synset = wn.synset(relation[0])\\n\\n # Get all the pairs, sort them by first word to keep set entries unique\\n current_iteration_pairs = get_cross_synset_pairs(synset, target_synset)\\n\\n # Add the current set of pairs\\n pos_pairs.extend(current_iteration_pairs)\\n\\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\\n for key, value in config.pos.items():\\n if value == part_of_speech:\\n pairs[key] = unique(pos_pairs)\\n\\n # Return the whole dictionary\\n print(f\\\"Successfully generated antonym paris @ {datetime.now()}\\\")\\n return pairs\",\n \"def add_skip_connections(self):\\n for term_ in self.inverted_index.keys():\\n postingsList=self.inverted_index[term_]\\n postingsList.add_skip_connections()\",\n \"def add(self, key):\\r\\n if key not in self.map:\\r\\n end = self.end\\r\\n curr = end[PREV]\\r\\n curr[NEXT] = end[PREV] = self.map[key] = [key, curr, end]\\r\\n if self.emitter:\\r\\n self.emitter.emit()\",\n \"def make_keydict(self, analyte=None):\\n if analyte is None:\\n analyte = self.analytes\\n elif isinstance(analyte, str):\\n analyte = [analyte]\\n\\n out = {}\\n for a in analyte:\\n key = []\\n for f in self.components.keys():\\n if self.switches[a][f]:\\n key.append(f)\\n out[a] = ' & '.join(sorted(key))\\n self.keydict = out\\n return out\",\n \"def add_edge(self, edge):\\r\\n edge = set(edge)\\r\\n (vertex1, vertex2) = tuple(edge)\\r\\n \\r\\n if vertex1 in self.__graph_dict.keys() and vertex2 in self.__graph_dict.keys():\\r\\n if vertex2 in self.__graph_dict[vertex1] and vertex1 in self.__graph_dict[vertex2]:\\r\\n return\\r\\n self.__graph_dict[vertex1].add(vertex2)\\r\\n self.__graph_dict[vertex2].add(vertex1)\\r\\n elif vertex1 not in self.__graph_dict.keys() and vertex2 in self.__graph_dict.keys():\\r\\n self.__graph_dict[vertex1] = {vertex2}\\r\\n self.__graph_dict[vertex2].add(vertex1)\\r\\n elif vertex1 in self.__graph_dict.keys() and vertex2 not in self.__graph_dict.keys():\\r\\n self.__graph_dict[vertex2] = {vertex1}\\r\\n self.__graph_dict[vertex1].add(vertex2)\\r\\n else:\\r\\n self.__graph_dict[vertex1] = {vertex2}\\r\\n self.__graph_dict[vertex2] = {vertex1}\",\n \"def add_connections(self, user_data):\\n self.__check_opts()\\n self.user_data = user_data\\n for ssid in Config.ssids:\\n self.__delete_existing_connection(ssid)\\n self.__add_connection(ssid)\\n for ssid in Config.del_ssids:\\n self.__delete_existing_connection(ssid)\",\n \"def gibber(self): \\n for x in self.consonants:\\n if (x in self.sentence):\\n \\t self.sentence = self.sentence.replace(x, x+'o'+unicode(x).lower())\",\n \"def _addToKnowledge(pop):\\n perspective = pop.getPerspectiveName()\\n if perspective not in _byPerspective:\\n _byPerspective[perspective] = []\\n _byPerspective[perspective].append(pop)\\n nodeOid = pop.getNodeOid()\\n if nodeOid not in _byNodeOid:\\n _byNodeOid[nodeOid] = sets.Set()\\n _byNodeOid[nodeOid].add(perspective)\\n apoOid = pop.getApoOid()\\n if apoOid not in _byApoOid:\\n _byApoOid[apoOid] = {}\\n _byApoOid[apoOid][perspective] = pop\",\n \"def add_edge(self, edge):\\n edge = set(edge)\\n (vertex1, vertex2) = tuple(edge)\\n if vertex1 in self.__graph_dict:\\n self.__graph_dict[vertex1].append(vertex2)\\n else:\\n self.__graph_dict[vertex1] = [vertex2]\",\n \"def dictogram_dictlist(self):\\n for key, value in self.word_dict.items():\\n self.word_dict[key] = dictogram.Dictogram(value)\\n # print(\\\"self.word_dict\\\", self.word_dict)\",\n \"def addNeighbor(self, neighbor):\",\n \"def to_dict(self) -> Dict:\\n _dict = {}\\n if hasattr(self, 'gateways') and self.gateways is not None:\\n _dict['gateways'] = [x.to_dict() for x in self.gateways]\\n return _dict\",\n \"def merge_nw_nnw(self):\\n nw_nnw = {}\\n nw_dict = self.ontology.heirs_network_dictionary\\n nnw_dict = self.model.networks_w_namednw_dict\\n for label, things in nw_dict.items():\\n nw_nnw[label] = things\\n if label in nnw_dict.keys():\\n nw_nnw[label] = set(nnw_dict[label])\\n return nw_nnw\",\n \"def add_edge(self, edge):\\n edge = set(edge)\\n (vertex1, vertex2) = tuple(edge)\\n if vertex1 in self.graph_dict:\\n self.graph_dict[vertex1].append(vertex2)\\n else:\\n self.graph_dict[vertex1] = [vertex2]\",\n \"def add_to_trie(self, frame2, pad, lb, *args):\\n global FLAG\\n FLAG = 1\\n frame2.pack_forget()\\n pad.edit_separator()\\n r = pad.get('1.0', GUI.END)\\n r = map(str, r.split())\\n if not MyDict.contains(r[-1]):\\n MyDict.insert(self.remove_punc(r[-1]))\",\n \"def insert(self, word: str) -> None:\\r\\n curr = self.root\\r\\n for letter in word:\\r\\n if letter not in curr:\\r\\n curr[letter] = {}\\r\\n curr = curr[letter]\\r\\n curr.setdefault(\\\"end\\\", True)\",\n \"def add_dict(dest, src):\\n for key in src.keys():\\n if key in dest.keys():\\n dest[key] += src[key]\\n else:\\n dest[key] = src[key]\",\n \"def analyzeChords(self):\\n prevChord = None\\n\\n for chord in self.chords:\\n if prevChord is not None:\\n if prevChord in self.chain:\\n if chord in self.chain[prevChord]:\\n # chord exists count it\\n self.chain[prevChord][chord] += 1.\\n else:\\n # chord not yet in chain as dest add it\\n self.chain[prevChord][chord] = 1.\\n else:\\n # chord not yet in chain add it and dest chord\\n self.chain[prevChord] = {}\\n self.chain[prevChord][chord] = 1.\\n\\n prevChord = chord\\n #pprint(self.chain)\",\n \"def __str__(self):\\n lst = []\\n for key in self.forward:\\n for val in self.forward[key]:\\n lst.append((key, val))\\n return str(lst)\",\n \"def add_goal(self, goal):\\n self.sys_da_array = []\\n self.usr_da_array = []\\n self.goal = deepcopy(goal)\\n \\n for domain in self.belief_domains:\\n if 'final' in self.goal[domain]: #If 'final' key is present in goal\\n for key in self.goal[domain]['final']:\\n self.goal[domain][key] = self.goal[domain]['final'][key]\\n del(self.goal[domain]['final'])\\n self.cur_domain = ''\\n self.complete_domain = []\\n # self.booked = self._init_dict_booked()\",\n \"def edge_mapping(self):\\n ...\",\n \"def add_word_to_dictionary(self, word: str):\\n self.trie.add_word(word)\",\n \"def productions(self):\\n P = {}\\n for line in self.grammar.split(sep=';'):\\n left, right = [s.strip() for s in line.split(sep='=', maxsplit=1)]\\n right = [s.strip() for s in right.split(sep='|')]\\n P[left] = right\\n for N in P:\\n if '[' + N + ']' in self.grammar:\\n P[N].append('eps')\\n return P\",\n \"def add_extra_syn_to_dict(df, pos):\\n\\tsyn_dict = get_syn_dict(pos)\\n\\tfor index, row in df.iterrows():\\n\\t\\tsource = row['source']\\n\\t\\ttarget = row['target']\\n\\t\\tif row['pos'] == pos and target not in syn_dict[source]:\\n\\t\\t\\tsyn_dict[source].append(target)\\n\\treturn syn_dict\",\n \"def adj(self, leg):\\n adj = self.metacopy()\\n\\n # Substitute the loose leg by a new leg, if not ortho center\\n nleg = Leg(leg=leg) if leg else None\\n # Assign new internal legs\\n ilegs = [Leg(leg=ll) for ll in self.internallegs]\\n scoup = self.substitutelegs(self.internallegs + [leg]\\n if self.internallegs else [leg],\\n ilegs + [nleg])\\n # Change the coupling flows appropriately\\n adj._coupling = tuple(tuple((c[0], not c[1]) for c in reversed(x))\\n for x in scoup)\\n adj._indexes = tuple(x if x != leg else nleg for x in adj._indexes)\\n\\n prefdict = sls._prefAdj(self.coupling, leg)\\n\\n def prefactorf(key):\\n return np.prod([prefdict.get(ss, lambda x: 1.)(\\n tuple(tuple(x[ii] for x in y) for y in key)\\n ) for ii, ss in enumerate(self.symmetries)])\\n\\n adj._data = {}\\n for key in self:\\n adj[tuple(tuple(x for x in reversed(k)) for k in key)] = \\\\\\n self[key] * prefactorf(key)\\n return adj\",\n \"def insert_conf(src_ip):\\n from settings import GRE_TUNNEL_CONF\\n return insert_route(src_ip, GRE_TUNNEL_CONF)\",\n \"def _makeimap(self):\\n self.map_[\\\"source\\\"] = \\\"nasa\\\"\\n self.map_[\\\"instrument\\\"] = \\\"goes\\\"\\n self.map_[\\\"physobs\\\"] = \\\"irradiance\\\"\\n self.map_[\\\"provider\\\"] = \\\"sdac\\\"\",\n \"def to_dict(self):\\n\\n out = super().to_dict()\\n out[\\\"connections\\\"] = self.connections\\n return out\",\n \"def add_poss(self, sqs=None, gates=None):\\n if sqs:\\n self.orig_sqs.update(set(sqs))\\n if gates:\\n self.orig_gates.update(set(gates))\\n self.recalc()\\n self.reset_hints()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5047579","0.5037985","0.502265","0.5007653","0.49975562","0.49723896","0.49697816","0.48349583","0.48268276","0.48259962","0.48032284","0.47840226","0.4778364","0.47758386","0.47497863","0.4746505","0.47428873","0.4741161","0.47241557","0.47111377","0.4697564","0.46961874","0.46941915","0.46901202","0.46575382","0.46238127","0.46138385","0.460321","0.460321","0.458946","0.4585198","0.45817828","0.45763108","0.45603994","0.4551454","0.4539636","0.45386896","0.4529527","0.45222","0.4519687","0.45166686","0.4510327","0.45036867","0.45000908","0.44994783","0.44989112","0.4497232","0.44885588","0.44655436","0.4463475","0.44631267","0.44594735","0.44542235","0.4452842","0.44496566","0.44492933","0.44413263","0.44318765","0.442526","0.4413766","0.4404852","0.44037133","0.43926823","0.43921396","0.4391376","0.4389354","0.43890288","0.4386789","0.43856537","0.43832546","0.4379912","0.43769386","0.43733376","0.43675384","0.43550736","0.4355066","0.43530306","0.43508875","0.4350481","0.43447256","0.43437013","0.43411404","0.43381962","0.43321472","0.43310443","0.43299899","0.43289992","0.4323384","0.43196854","0.4313594","0.43122444","0.43102154","0.43099177","0.43000302","0.42984617","0.42979762","0.42979118","0.42976356","0.42958167","0.42867765"],"string":"[\n \"0.5047579\",\n \"0.5037985\",\n \"0.502265\",\n \"0.5007653\",\n \"0.49975562\",\n \"0.49723896\",\n \"0.49697816\",\n \"0.48349583\",\n \"0.48268276\",\n \"0.48259962\",\n \"0.48032284\",\n \"0.47840226\",\n \"0.4778364\",\n \"0.47758386\",\n \"0.47497863\",\n \"0.4746505\",\n \"0.47428873\",\n \"0.4741161\",\n \"0.47241557\",\n \"0.47111377\",\n \"0.4697564\",\n \"0.46961874\",\n \"0.46941915\",\n \"0.46901202\",\n \"0.46575382\",\n \"0.46238127\",\n \"0.46138385\",\n \"0.460321\",\n \"0.460321\",\n \"0.458946\",\n \"0.4585198\",\n \"0.45817828\",\n \"0.45763108\",\n \"0.45603994\",\n \"0.4551454\",\n \"0.4539636\",\n \"0.45386896\",\n \"0.4529527\",\n \"0.45222\",\n \"0.4519687\",\n \"0.45166686\",\n \"0.4510327\",\n \"0.45036867\",\n \"0.45000908\",\n \"0.44994783\",\n \"0.44989112\",\n \"0.4497232\",\n \"0.44885588\",\n \"0.44655436\",\n \"0.4463475\",\n \"0.44631267\",\n \"0.44594735\",\n \"0.44542235\",\n \"0.4452842\",\n \"0.44496566\",\n \"0.44492933\",\n \"0.44413263\",\n \"0.44318765\",\n \"0.442526\",\n \"0.4413766\",\n \"0.4404852\",\n \"0.44037133\",\n \"0.43926823\",\n \"0.43921396\",\n \"0.4391376\",\n \"0.4389354\",\n \"0.43890288\",\n \"0.4386789\",\n \"0.43856537\",\n \"0.43832546\",\n \"0.4379912\",\n \"0.43769386\",\n \"0.43733376\",\n \"0.43675384\",\n \"0.43550736\",\n \"0.4355066\",\n \"0.43530306\",\n \"0.43508875\",\n \"0.4350481\",\n \"0.43447256\",\n \"0.43437013\",\n \"0.43411404\",\n \"0.43381962\",\n \"0.43321472\",\n \"0.43310443\",\n \"0.43299899\",\n \"0.43289992\",\n \"0.4323384\",\n \"0.43196854\",\n \"0.4313594\",\n \"0.43122444\",\n \"0.43102154\",\n \"0.43099177\",\n \"0.43000302\",\n \"0.42984617\",\n \"0.42979762\",\n \"0.42979118\",\n \"0.42976356\",\n \"0.42958167\",\n \"0.42867765\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65367895"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10793,"cells":{"query":{"kind":"string","value":"Add a gaussian noise to to the result of Dense layer. The added gaussian noise is not related to the origin input."},"document":{"kind":"string","value":"def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):\n super().__init__()\n for u in hidden_units:\n self.add(GaussianNoise(0.4)) # Or use kwargs\n self.add(Dense(u, act_fn))\n if out_layer:\n self.add(GaussianNoise(0.4))\n self.add(Dense(output_shape, out_activation))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_gaussian_noise(x, std):\n noise = x.new_zeros(x.size()).normal_(std=std)\n return x + noise","def add_gaussian_noise(X, mu=0, sigma=0.1):\n noise = np.random.normal(0.0, sigma, size=X.size)\n return X + noise.reshape(X.shape)","def add_gaussian_noise(self, samples):\n\n if 'sigma' in self.gaussian_component:\n sigma = self.gaussian_component['sigma']\n return samples + self.random_state.normal(size=samples.shape) * sigma\n if 'sigmas' in self.gaussian_component:\n sigmas = self.gaussian_component['sigmas']\n return samples + self.random_state.normal(size=samples.shape) * sigmas\n\n return samples","def gaussian_noise_layer(input_layer, std):\r\n\r\n noise = tf.random_normal(tf.shape(input_layer), mean=0.0, stddev=std, dtype=tf.float32)\r\n\r\n output = tf.add_n([input_layer, noise])\r\n\r\n return output","def _gaussian_for_learn_denosing_model(image):\n return add_gaussian_noise(image, 0, 0.2)","def gaussian_noise(tensor, mean, stddev):\n noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))\n return tensor + noise","def task_gaussian_noise(input_array, noise_factor):\n return(np.random.normal(0, noise_factor, input_array.shape))","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\n self.image += self.noise\n return","def add_gaussian_noise(projections, noise_var):\n noise_sigma = noise_var**0.5\n nproj,row,col = projections.shape\n gauss_noise = np.random.normal(0, noise_sigma, (nproj, row, col))\n gauss_noise = gauss_noise.reshape(nproj, row, col) \n projections = projections + gauss_noise\n return projections","def add_gaussian_noise(\n key: Array,\n action: Array,\n stddev: float\n) -> Array:\n chex.assert_type(action, float)\n\n noise = jax.random.normal(key, shape=action.shape) * stddev\n return action + noise","def gaussian_noise(self, tensor):\n return tensor.new_empty(tensor.size()).normal_(std=self._discreteness)","def additive_gaussian_noise(img, seed=None, std=(0, 0.4)):\n if seed is None:\n random_state = np.random.RandomState(None)\n else:\n random_state = np.random.RandomState(seed)\n sigma = std[0] + random_state.rand() * std[1]\n gaussian_noise = random_state.randn(*img.shape) * sigma\n noisy_img = img + gaussian_noise\n # noisy_img = np.clip(noisy_img, 0, 1)\n return noisy_img","def add_noise(Y, sigma):\r\n return Y + np.random.normal(0, sigma, Y.shape)","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\n self.im += self.noise\n return","def model_gauss_noise(sigma, nx, ny=1, nz=1):\n\te = EMData()\n\te.set_size(nx, ny, nz)\n\te.process_inplace(\"testimage.noise.gauss\", {\"sigma\":sigma})\n\treturn e","def addGaussian(ax, ismulti):\n shape = (96, 288) #ax.shape[:2]\n intensity_noise = np.random.uniform(low=0, high=0.05)\n if ismulti:\n ax[:,:,0] = ax[:,:,0]*(1+ intensity_noise*np.random.normal(loc=0, scale=1, size=shape[0]*shape[1]).reshape(shape[0],shape[1]))\n else:\n ax[:,:,0] = ax[:,:,0] + intensity_noise*np.random.normal(loc=0, scale=1, size=shape[0]*shape[1]).reshape(shape[0],shape[1])\n return ax","def addNoise(self, sigma=1.0):\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\n self.image += noise\n return","def noise(self, stddev):\n #add noise to weights\n pass","def add_noise(image):\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\n \n return image","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def add_gaussian_noise(images: list, var: list, random_var: float=None, gauss_noise: list=None):\n if random_var is None:\n random_var = np.random.uniform(var[0], var[1])\n mean = 0\n new_images = []\n gauss_noise_out = []\n for i,image in enumerate(images):\n row, col, c = image.shape\n if gauss_noise is None or \\\n (gauss_noise is not None and row*col*c !=\n gauss_noise[i].shape[0]*gauss_noise[i].shape[1] * gauss_noise[i].shape[2]):\n gauss = np.random.normal(mean, random_var * 127.5, (row, col, c))\n else:\n gauss = gauss_noise[i]\n gauss_noise_out.append(gauss)\n gauss = gauss.reshape(row, col, c)\n image1 = np.clip(image + gauss, 0., 255.)\n new_images.append(image1)\n return new_images, random_var, gauss_noise_out","def _gauss_noise(self, shape):\n\n n = np.random.normal(0, 1, shape)\n return self.e*n","def all_views_gaussian_noise_layer(input_layer, std):\r\n\r\n input_l_cc, input_r_cc = input_layer\r\n\r\n output_l_cc = gaussian_noise_layer(input_l_cc, std)\r\n output_r_cc = gaussian_noise_layer(input_r_cc, std)\r\n\r\n\r\n output = (output_l_cc, output_r_cc)\r\n\r\n return output","def gaussian_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.06, channel_wise=1):\n if stddev is None:\n stddev = torch.rand(channel_wise) * sigma_max\n stddev = torch.tensor(stddev, device=inputs.device)\n if DATA_FORMAT == 'channels_first':\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\n else:\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\n noise_map = torch.randn_like(inputs) * stddev\n return noise_map","def gaussian(gp_link=None, variance=2, D=None, N=None):\r\n if gp_link is None:\r\n gp_link = noise_models.gp_transformations.Identity()\r\n analytical_mean = True\r\n analytical_variance = True # ?\r\n return noise_models.gaussian_noise.Gaussian(gp_link, analytical_mean,\r\n analytical_variance, variance=variance, D=D, N=N)","def gaussian_noise(shape, mean, std):\n return tf.random.normal(shape=shape, mean=mean, stddev=std, dtype=tf.float32)","def add_gaussian_noise(image, min_sigma, max_sigma):\n assert(max_sigma >= min_sigma)\n sigma = np.random.uniform(min_sigma, max_sigma)\n noise = np.random.normal(loc=0, scale=sigma, size=image.shape)\n noisy_im = np.floor((image + noise) * 255) / 255\n noisy_im = np.clip(noisy_im, 0, 1)\n return noisy_im","def sampleGaussian(self, mu, log_sigma):\n # reparameterization trick\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\"epsilon\")\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)","def add_noise(arr, sigma):\n dims = arr.shape\n arr += sigma * noise(*dims)","def generate_gaussian():\n amp = 10 * numpy.random.chisquare(3)\n width = numpy.random.chisquare(3)\n mean = numpy.random.uniform(-10 + width, 10 - width)\n x = numpy.linspace(-10, 10, 500)\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\n add_noise(y, 0.1)\n return x, y","def gauss_noise(_spec, stdev):\n t, f = _spec.shape\n awgn = np.random.normal(0, stdev, (t, f))\n # gauss = gauss.reshape(t, f)\n _spec_noise = _spec + awgn\n return _spec_noise","def add_weight_noise(self, std):\n with torch.no_grad():\n param_vector = parameters_to_vector(self.parameters())\n normal_dist = torch.distributions.Normal(loc=torch.tensor([0.0]), scale=torch.tensor([std]))\n noise = normal_dist.sample(param_vector.size())\n if self.device_id >= 0:\n noise = noise\n param_vector.add_(noise[0])\n vector_to_parameters(param_vector, self.parameters())","def _add_noise(X, n_noise, random_state=None):\n np.random.seed(random_state)\n noise = np.random.randn(X.shape[0], n_noise)\n return np.hstack((X, noise))","def add_gaussian_noise(self, stdev, iteration, method = 'absolute', normalize = \"on\"):\n for time in self.mdvtc.keys():\n self.mdvtc[time].add_gaussian_noise(stdev, iteration, method, normalize)","def sample_gaussian(self, batch_size):\n return Variable(t.randn([batch_size, self.params.latent_variable_size])) # Dimension [batch_size x latent_dim]","def add_noise(self):\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\n self.noise *= torch.sqrt(2 *\n self.vars['T']*torch.tensor(self.vars['dt']))","def add_gaussian_noise(image, min_sigma, max_sigma):\r\n sigma = np.random.uniform(min_sigma, max_sigma)\r\n corrupted_im = image + np.random.normal(0, sigma, image.shape)\r\n rounded_im = (np.round(corrupted_im * MAX_PIXEL_NUMBER)) / MAX_PIXEL_NUMBER\r\n return np.clip(rounded_im, 0, 1).astype(np.float64)","def __call__(self, input: torch.Tensor) -> torch.Tensor:\n # Get noise\n noise = self.mean + torch.randn_like(input) * self.std\n # Apply nose to image\n input = input + noise\n return input","def add_gaussian(self, A=1000, sigma=(200, 200), x0=None):\n if x0 is None:\n x0 = self._beam_position\n \n self.map += np.asarray(np.round(\n gaussian2d(self._X, self._Y, A, sigma, x0)), dtype=np.int32)","def noise_data(self, x):\n return x + np.random.normal(size=x.shape)","def gnoise(mag, sigma, mu):\n noise = np.random.normal(mu,sigma,n)\n mag = mag + noise\n return mag, noise","def random_gaussian_noise(image ):\n sigma = image.std()\n for ch in range(image.shape[2] ):\n sigma = min(sigma, image[:,:,ch].std() )\n image = random_noise(image, var = sigma**2)\n return image","def add_noise(emg):\n MAX_AMPLITUDE = 32767\n\n # Sampling\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\n Ts = 1/EMG_F_SAMPLE\n\n # Time vector\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\n\n # Noise\n randAmplitudeScale = np.random.random()*0.1\n randOffset = np.random.random() * 2*np.pi\n \n fNoise = 50; # Frequency [Hz]\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\n\n # Add noise to signal\n for channel in [\"emg1\", \"emg2\", \"emg3\", \"emg4\", \"emg5\", \"emg6\"]:\n emg[channel] += noise\n return emg","def add_noise(image, noise, rate=0.05):\n\n if noise == \"gaussian\":\n row, col = image.shape\n var = ndimage.laplace(image).var()\n sigma = (var*rate) ** 0.5\n print(var, sigma)\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\n noisy = image + gauss\n # noisy = image + gauss\n return noisy\n\n elif noise == \"salt_pepper\":\n output = image.copy()\n black = 0\n white = 255\n probs = np.random.random(image.shape[:2])\n output[probs < (rate / 2)] = black\n output[probs > 1 - (rate / 2)] = white\n\n return output\n\n else:\n return image","def naive_gaussian_noise(true_depth: np.ndarray) -> np.ndarray:\n return true_depth + np.random.normal(0, 0.0012 + 0.0019 * np.square(true_depth - 0.4))","def gen_noise(sample_size, latent):\r\n\treturn Variable(torch.randn(sample_size, latent))","def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\n -np.power(\n (x - mu) / sigma, 2) / 2)","def GaussianKernel(radius, std):\n size = 2 * radius + 1\n weight = torch.ones(size, size)\n weight.requires_grad = False\n for i in range(-radius, radius+1):\n for j in range(-radius, radius+1):\n dis = (i * i) + (j * j)\n weight[i+radius][j+radius] = np.exp(-dis / (2 * std * std))\n weight = weight / weight.sum()\n return weight","def gaussianise_series(self, train_x):\n\n n_batches = train_x.shape[0]\n\n for batch in range(n_batches):\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\n\n return train_x","def add_image_noise(\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\n if random_seed is not None:\n np.random.seed(random_seed)\n shape = self.signal.axes_manager.shape\n noise = normal(mu, sigma, shape)\n if only_positive:\n self._image_noise = np.absolute(noise)\n else:\n self._image_noise = noise","def add_gaussian(self, high, center, stdev):\n if callable(high):\n high = high()\n assert stdev > 0\n self.Y += high * np.exp(-0.5 * (self.Xnum-center)**2 / stdev**2)","def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)","def gaussian_gen(ngaussian, nd, batchSize, seed, random=True):\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n means, covars, weights = get_means_covars(nd, ngaussian, random)\n while True:\n # yield multi_normal.sample((batchSize,))\n yield mm_gaussian(batchSize, means, covars, weights) / 1.414","def gaussian(x, *parameters):\n position, sigma, amplitude, background = parameters\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background","def addNoise(img, sigma=2.0, mean=0):\n img2 = np.random.normal(mean, sigma, size=img.shape)\n\n img2 += img\n img2 = np.uint8(img2.clip(0, 255))\n return img2","def gaussian_kernel(training_ex, landmark, sigma=0.1):\n return np.exp(-(np.linalg.norm(training_ex - landmark) ** 2 / (2 * (sigma ** 2))))","def gaussian(amp, fwhm, mean, x):\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def gaussian(mu, wid, x):\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)","def add_noise(np_image, amount):\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\n norm_noise = abs(noise/np.max(noise))\n np_image = np_image + norm_noise*np.max(np_image)*amount\n \n return np_image","def SampleFromGaussian(shape, noise_mean=0., noise_std=1., name='gaussian-sample'):\n def instantiate(args):\n mean, log_var = args\n return layers.Lambda(gaussian_noise(noise_mean=noise_mean, noise_std=noise_std),\n output_shape=shape,\n name=name)([mean, log_var])\n return instantiate","def noise(x: np.ndarray) -> np.ndarray:\n\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)","def add_noise(self, u):\n noise = torch.randn_like(u)\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\n\n # bias repeatability (without in run bias stability)\n b0 = self.uni.sample(u[:, 0].shape).cuda()\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\n u = u + noise + b0.transpose(1, 2)\n return u","def set_gaussian(self, X, sigma=0):\n sigma = float(sigma)\n if sigma < 0:\n raise ValueError('sigma should be positive')\n self.set_euclidian(X)\n d = self.weights\n\n if sigma == 0:\n sigma = (d ** 2).mean()\n\n w = np.exp(- (d ** 2) / (2 * sigma))\n self.weights = w","def apply_noise(self, input):\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \n noisy_input = mask * input\n \n return noisy_input","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def model_gauss(xsigma, nx, ny=1, nz=1, ysigma=None, zsigma=None, xcenter=None, ycenter=None, zcenter=None):\n\te = EMData()\n\te.set_size(nx, ny, nz)\n\tif( ysigma == None ) : ysigma = xsigma\n\tif( zsigma == None ) : zsigma = xsigma\n\tif( xcenter == None ) : xcenter = nx//2\n\tif( ycenter == None ) : ycenter = ny//2\n\tif( zcenter == None ) : zcenter = nz//2\n\te.process_inplace(\"testimage.puregaussian\", {\"x_sigma\":xsigma,\"y_sigma\":ysigma,\"z_sigma\":zsigma,\"x_center\":xcenter,\"y_center\":ycenter,\"z_center\":zcenter} )\n\treturn e","def noiseReduction(self):\n pass","def _get_add_noise(stddev, seed: int = None):\n if distutils.version.LooseVersion(\n tf.__version__) < distutils.version.LooseVersion('2.0.0'):\n\n # The seed should be only used for testing purpose.\n if seed is not None:\n tf.random.set_seed(seed)\n\n def add_noise(v):\n return v + tf.random.normal(\n tf.shape(input=v), stddev=stddev, dtype=v.dtype)\n else:\n random_normal = tf.random_normal_initializer(stddev=stddev, seed=seed)\n\n def add_noise(v):\n return v + tf.cast(random_normal(tf.shape(input=v)), dtype=v.dtype)\n\n return add_noise","def generate_noise_vector(self, ):\n self.noise.resize_(\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???","def gaussianOneSample(self, mu=0., sig=1., size=1):\n\n thisSample = np.random.normal(mu, sig, size)\n\n return thisSample","def get_noise(batch_size, total_continuous_noise_dims):\n # Get unstructurd noise.\n noise = tf.random_normal(\n [batch_size, total_continuous_noise_dims])\n\n return noise","def grad(w, f, noise):\n f -= f.mean()\n f /= f.std() # standardize the rewards to be N(0,1) gaussian\n g = np.dot(f, noise)\n return g","def random_gaussian_noise(self, img, p = 0.5):\n if self.decision(p):\n mean = 30.0\n std = 80.0\n img = img + np.random.normal(mean, std, img.shape)\n\n img = np.clip(img, 0, 255).astype('uint8')\n return img","def gaussian_ep(gp_link=None,variance=1.):\r\n if gp_link is None:\r\n gp_link = noise_models.gp_transformations.Identity()\r\n #else:\r\n # assert isinstance(gp_link,noise_models.gp_transformations.GPTransformation), 'gp_link function is not valid.'\r\n\r\n analytical_mean = False\r\n analytical_variance = False\r\n return noise_models.gaussian_noise.Gaussian(gp_link,analytical_mean,analytical_variance,variance)","def sample(self):\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\n x = self.x_prev\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\n self.dt\n ) * np.random.normal(size=self.mu.shape)\n self.x_prev = x + dx\n return self.x_prev","def _addNoise(self):\n self.dispNoise = self.dispRaw.copy()\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\n return","def add_noise(self, data):","def add_noise(self, noise):\n if noise > 0.0:\n for key in self.counts:\n self.counts[key] *= 1.0 + noise * np.random.random_sample()","def gaussian(amp, fwhm, mean):\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)","def sampling(z_mean, z_log_var):\n\n # by default, random_normal has mean=0 and std=1.0\n epsilon = fluid.layers.gaussian_random_batch_size_like(z_mean, shape=[-1, latent_dim])\n epsilon.stop_gradient = True\n return z_mean + fluid.layers.exp(0.5 * z_log_var) * epsilon","def addGaussian(self, xwidth=100., ywidth=100., xcen=None, ycen=None, value=1.0):\n if xcen == None:\n xcen = self.nx/2.0\n if ycen == None:\n ycen = self.ny/2.0\n self.fimage = None\n gaussian = numpy.exp(-(self.xx-xcen)**2/(2.0*xwidth**2) - (self.yy-ycen)**2/(2.0*ywidth**2))\n self.image += gaussian * value / gaussian.max()\n return","def _apply_observation_noise(self, state: RobotState,\n config: RobotGroupConfig):\n if config.sim_observation_noise is None or self.random_state is None:\n return\n\n # Define the noise calculation.\n def noise(value_range: np.ndarray):\n amplitude = config.sim_observation_noise * np.ptp(\n value_range, axis=1)\n return amplitude * self.random_state.uniform(\n low=-0.5, high=0.5, size=value_range.shape[0])\n\n if config.qpos_range is not None:\n state.qpos += noise(config.qpos_range)\n if config.qvel_range is not None:\n state.qvel += noise(config.qvel_range)","def add_gaussian_noise(self, stdev, iteration = 1, method = 'absolute', normalize = \"on\"):\n\n self.number_of_replicate = iteration\n for fragment in self.fragments_for_mdv_calculation:\n number_of_mass_data = max(self.mdv[fragment].keys()) + 1\n noise = numpy.zeros((number_of_mass_data, iteration))\n for i in range(iteration):\n for number in range(number_of_mass_data):\n if method == 'relative':\n noise[number, i] = (numpy.random.randn() * stdev + 1) * self.mdv[fragment][number]['ratio']\n else:\n noise[number, i] = (numpy.random.randn() * stdev) + self.mdv[fragment][number]['ratio']\n if noise[number, i] < 0.0:\n noise[number, i] = 0.0\n #各フラグメント毎に総和を１にする。\n if normalize == \"on\":\n sumvalue = sum(noise[:,i])\n noise[:,i] = noise[:,i] / sumvalue\n for number in range(number_of_mass_data):\n self.mdv[fragment][number]['ratio']= sum(noise[number,:])/iteration\n #self.mdv[fragment][number]['std'] = numpy.std(noise[number,:])\n self.mdv[fragment][number]['data'] = numpy.array(noise[number,:])","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def gaussian(x, x0=0.0, fwhm=1.0, ampl=1.0):\n return ampl * np.exp(-4 * np.log(2) * ((x - x0) / fwhm) ** 2)","def global_noise(self, seed=42, **kwargs):\n # Random perturbations, initialized globally for same results in parallel\n gshape = self.domain.dist.grid_layout.global_shape(scales=self.domain.dealias)\n slices = self.domain.dist.grid_layout.slices(scales=self.domain.dealias)\n rand = np.random.RandomState(seed=seed)\n noise = rand.standard_normal(gshape)[slices]\n\n # filter in k-space\n noise_field = self._new_field()\n noise_field.set_scales(self.domain.dealias, keep_data=False)\n noise_field['g'] = noise\n self.filter_field(noise_field, **kwargs)\n\n return noise_field","def gaussian(x, mean, sigma):\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))","def reparameterize(self, mean, logvar):\n if self.training:\n std = torch.exp(0.5 * logvar)\n # std = torch.zeros_like(mean) + 0.25\n eps = torch.randn_like(std)\n return mean + std * eps\n else:\n return mean","def gaussian1d(x, x0, w0, A, offset):\n if w0 == 0:\n return 0\n return A * np.exp(-2 * (x - x0) ** 2 / (w0 ** 2)) + offset","def gaussian_dataset(ngaussian, nd, nsample, random=True):\n means, covars, weights = get_means_covars(nd, ngaussian, random)\n return mm_gaussian(nsample, means, covars, weights)","def reparameterize(self, mu, log_var):\n std = torch.exp(0.5 * log_var)\n eps = torch.randn_like(std)\n return eps * std + mu","def reparameterize(self, mu, logvar):\n std = torch.exp(0.5 * logvar)\n eps = torch.randn_like(std)\n return eps * std + mu","def reparameterize(self, mu, logvar):\n std = torch.exp(0.5 * logvar)\n eps = torch.randn_like(std)\n return eps * std + mu","def random_glove_generator(emb_mean, emb_stddev):\n x = np.random.normal(loc=0.0, scale=1.0, size=len(emb_mean))\n x_rand = np.multiply(x, emb_stddev) + emb_mean\n return x_rand","def gaussianOne(self, x=np.array([]), mu=0., sig=1.):\n\n lnConst = -0.5 * np.log(2.0 * np.pi)\n lnVar = -np.log(sig)\n lnBrack = -0.5 * ((x - mu) / sig)**2\n\n ### safety valve\n ###bBad = np.abs(lnBrack) > 7.\n ###lnBrack[bBad] = -np.inf\n\n return lnConst + lnVar + lnBrack","def gaussian(window_size, sigma):\n gauss = torch.Tensor([math.exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])\n return gauss/gauss.sum()","def gaussian_denoiser(z_noisy, u, size):\n\n a1 = tf.Variable(0. * tf.ones([size]), name='a1')\n a2 = tf.Variable(1. * tf.ones([size]), name='a2')\n a3 = tf.Variable(0. * tf.ones([size]), name='a3')\n a4 = tf.Variable(0. * tf.ones([size]), name='a4')\n a5 = tf.Variable(0. * tf.ones([size]), name='a5')\n\n # v\n a6 = tf.Variable(0. * tf.ones([size]), name='a6')\n a7 = tf.Variable(1. * tf.ones([size]), name='a7')\n a8 = tf.Variable(0. * tf.ones([size]), name='a8')\n a9 = tf.Variable(0. * tf.ones([size]), name='a9')\n a10 = tf.Variable(0. * tf.ones([size]), name='a10')\n\n mu = a1 * tf.sigmoid(a2 * u + a3) + a4 * u + a5\n v = a6 * tf.sigmoid(a7 * u + a8) + a9 * u + a10\n\n z = (z_noisy - mu) * v + mu\n return z","def gaussian_filter(x):\n return _gaussian_filter(x, 3)","def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:\n std = torch.exp(0.5*logvar)\n # eps=N(0,I), where the I is an identity matrix of same size as std\n eps = torch.randn_like(std)\n return mu + std*eps"],"string":"[\n \"def add_gaussian_noise(x, std):\\n noise = x.new_zeros(x.size()).normal_(std=std)\\n return x + noise\",\n \"def add_gaussian_noise(X, mu=0, sigma=0.1):\\n noise = np.random.normal(0.0, sigma, size=X.size)\\n return X + noise.reshape(X.shape)\",\n \"def add_gaussian_noise(self, samples):\\n\\n if 'sigma' in self.gaussian_component:\\n sigma = self.gaussian_component['sigma']\\n return samples + self.random_state.normal(size=samples.shape) * sigma\\n if 'sigmas' in self.gaussian_component:\\n sigmas = self.gaussian_component['sigmas']\\n return samples + self.random_state.normal(size=samples.shape) * sigmas\\n\\n return samples\",\n \"def gaussian_noise_layer(input_layer, std):\\r\\n\\r\\n noise = tf.random_normal(tf.shape(input_layer), mean=0.0, stddev=std, dtype=tf.float32)\\r\\n\\r\\n output = tf.add_n([input_layer, noise])\\r\\n\\r\\n return output\",\n \"def _gaussian_for_learn_denosing_model(image):\\n return add_gaussian_noise(image, 0, 0.2)\",\n \"def gaussian_noise(tensor, mean, stddev):\\n noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))\\n return tensor + noise\",\n \"def task_gaussian_noise(input_array, noise_factor):\\n return(np.random.normal(0, noise_factor, input_array.shape))\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\\n self.image += self.noise\\n return\",\n \"def add_gaussian_noise(projections, noise_var):\\n noise_sigma = noise_var**0.5\\n nproj,row,col = projections.shape\\n gauss_noise = np.random.normal(0, noise_sigma, (nproj, row, col))\\n gauss_noise = gauss_noise.reshape(nproj, row, col) \\n projections = projections + gauss_noise\\n return projections\",\n \"def add_gaussian_noise(\\n key: Array,\\n action: Array,\\n stddev: float\\n) -> Array:\\n chex.assert_type(action, float)\\n\\n noise = jax.random.normal(key, shape=action.shape) * stddev\\n return action + noise\",\n \"def gaussian_noise(self, tensor):\\n return tensor.new_empty(tensor.size()).normal_(std=self._discreteness)\",\n \"def additive_gaussian_noise(img, seed=None, std=(0, 0.4)):\\n if seed is None:\\n random_state = np.random.RandomState(None)\\n else:\\n random_state = np.random.RandomState(seed)\\n sigma = std[0] + random_state.rand() * std[1]\\n gaussian_noise = random_state.randn(*img.shape) * sigma\\n noisy_img = img + gaussian_noise\\n # noisy_img = np.clip(noisy_img, 0, 1)\\n return noisy_img\",\n \"def add_noise(Y, sigma):\\r\\n return Y + np.random.normal(0, sigma, Y.shape)\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\\n self.im += self.noise\\n return\",\n \"def model_gauss_noise(sigma, nx, ny=1, nz=1):\\n\\te = EMData()\\n\\te.set_size(nx, ny, nz)\\n\\te.process_inplace(\\\"testimage.noise.gauss\\\", {\\\"sigma\\\":sigma})\\n\\treturn e\",\n \"def addGaussian(ax, ismulti):\\n shape = (96, 288) #ax.shape[:2]\\n intensity_noise = np.random.uniform(low=0, high=0.05)\\n if ismulti:\\n ax[:,:,0] = ax[:,:,0]*(1+ intensity_noise*np.random.normal(loc=0, scale=1, size=shape[0]*shape[1]).reshape(shape[0],shape[1]))\\n else:\\n ax[:,:,0] = ax[:,:,0] + intensity_noise*np.random.normal(loc=0, scale=1, size=shape[0]*shape[1]).reshape(shape[0],shape[1])\\n return ax\",\n \"def addNoise(self, sigma=1.0):\\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\\n self.image += noise\\n return\",\n \"def noise(self, stddev):\\n #add noise to weights\\n pass\",\n \"def add_noise(image):\\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\\n \\n return image\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def add_gaussian_noise(images: list, var: list, random_var: float=None, gauss_noise: list=None):\\n if random_var is None:\\n random_var = np.random.uniform(var[0], var[1])\\n mean = 0\\n new_images = []\\n gauss_noise_out = []\\n for i,image in enumerate(images):\\n row, col, c = image.shape\\n if gauss_noise is None or \\\\\\n (gauss_noise is not None and row*col*c !=\\n gauss_noise[i].shape[0]*gauss_noise[i].shape[1] * gauss_noise[i].shape[2]):\\n gauss = np.random.normal(mean, random_var * 127.5, (row, col, c))\\n else:\\n gauss = gauss_noise[i]\\n gauss_noise_out.append(gauss)\\n gauss = gauss.reshape(row, col, c)\\n image1 = np.clip(image + gauss, 0., 255.)\\n new_images.append(image1)\\n return new_images, random_var, gauss_noise_out\",\n \"def _gauss_noise(self, shape):\\n\\n n = np.random.normal(0, 1, shape)\\n return self.e*n\",\n \"def all_views_gaussian_noise_layer(input_layer, std):\\r\\n\\r\\n input_l_cc, input_r_cc = input_layer\\r\\n\\r\\n output_l_cc = gaussian_noise_layer(input_l_cc, std)\\r\\n output_r_cc = gaussian_noise_layer(input_r_cc, std)\\r\\n\\r\\n\\r\\n output = (output_l_cc, output_r_cc)\\r\\n\\r\\n return output\",\n \"def gaussian_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.06, channel_wise=1):\\n if stddev is None:\\n stddev = torch.rand(channel_wise) * sigma_max\\n stddev = torch.tensor(stddev, device=inputs.device)\\n if DATA_FORMAT == 'channels_first':\\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\\n else:\\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\\n noise_map = torch.randn_like(inputs) * stddev\\n return noise_map\",\n \"def gaussian(gp_link=None, variance=2, D=None, N=None):\\r\\n if gp_link is None:\\r\\n gp_link = noise_models.gp_transformations.Identity()\\r\\n analytical_mean = True\\r\\n analytical_variance = True # ?\\r\\n return noise_models.gaussian_noise.Gaussian(gp_link, analytical_mean,\\r\\n analytical_variance, variance=variance, D=D, N=N)\",\n \"def gaussian_noise(shape, mean, std):\\n return tf.random.normal(shape=shape, mean=mean, stddev=std, dtype=tf.float32)\",\n \"def add_gaussian_noise(image, min_sigma, max_sigma):\\n assert(max_sigma >= min_sigma)\\n sigma = np.random.uniform(min_sigma, max_sigma)\\n noise = np.random.normal(loc=0, scale=sigma, size=image.shape)\\n noisy_im = np.floor((image + noise) * 255) / 255\\n noisy_im = np.clip(noisy_im, 0, 1)\\n return noisy_im\",\n \"def sampleGaussian(self, mu, log_sigma):\\n # reparameterization trick\\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\\\"epsilon\\\")\\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)\",\n \"def add_noise(arr, sigma):\\n dims = arr.shape\\n arr += sigma * noise(*dims)\",\n \"def generate_gaussian():\\n amp = 10 * numpy.random.chisquare(3)\\n width = numpy.random.chisquare(3)\\n mean = numpy.random.uniform(-10 + width, 10 - width)\\n x = numpy.linspace(-10, 10, 500)\\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\\n add_noise(y, 0.1)\\n return x, y\",\n \"def gauss_noise(_spec, stdev):\\n t, f = _spec.shape\\n awgn = np.random.normal(0, stdev, (t, f))\\n # gauss = gauss.reshape(t, f)\\n _spec_noise = _spec + awgn\\n return _spec_noise\",\n \"def add_weight_noise(self, std):\\n with torch.no_grad():\\n param_vector = parameters_to_vector(self.parameters())\\n normal_dist = torch.distributions.Normal(loc=torch.tensor([0.0]), scale=torch.tensor([std]))\\n noise = normal_dist.sample(param_vector.size())\\n if self.device_id >= 0:\\n noise = noise\\n param_vector.add_(noise[0])\\n vector_to_parameters(param_vector, self.parameters())\",\n \"def _add_noise(X, n_noise, random_state=None):\\n np.random.seed(random_state)\\n noise = np.random.randn(X.shape[0], n_noise)\\n return np.hstack((X, noise))\",\n \"def add_gaussian_noise(self, stdev, iteration, method = 'absolute', normalize = \\\"on\\\"):\\n for time in self.mdvtc.keys():\\n self.mdvtc[time].add_gaussian_noise(stdev, iteration, method, normalize)\",\n \"def sample_gaussian(self, batch_size):\\n return Variable(t.randn([batch_size, self.params.latent_variable_size])) # Dimension [batch_size x latent_dim]\",\n \"def add_noise(self):\\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\\n self.noise *= torch.sqrt(2 *\\n self.vars['T']*torch.tensor(self.vars['dt']))\",\n \"def add_gaussian_noise(image, min_sigma, max_sigma):\\r\\n sigma = np.random.uniform(min_sigma, max_sigma)\\r\\n corrupted_im = image + np.random.normal(0, sigma, image.shape)\\r\\n rounded_im = (np.round(corrupted_im * MAX_PIXEL_NUMBER)) / MAX_PIXEL_NUMBER\\r\\n return np.clip(rounded_im, 0, 1).astype(np.float64)\",\n \"def __call__(self, input: torch.Tensor) -> torch.Tensor:\\n # Get noise\\n noise = self.mean + torch.randn_like(input) * self.std\\n # Apply nose to image\\n input = input + noise\\n return input\",\n \"def add_gaussian(self, A=1000, sigma=(200, 200), x0=None):\\n if x0 is None:\\n x0 = self._beam_position\\n \\n self.map += np.asarray(np.round(\\n gaussian2d(self._X, self._Y, A, sigma, x0)), dtype=np.int32)\",\n \"def noise_data(self, x):\\n return x + np.random.normal(size=x.shape)\",\n \"def gnoise(mag, sigma, mu):\\n noise = np.random.normal(mu,sigma,n)\\n mag = mag + noise\\n return mag, noise\",\n \"def random_gaussian_noise(image ):\\n sigma = image.std()\\n for ch in range(image.shape[2] ):\\n sigma = min(sigma, image[:,:,ch].std() )\\n image = random_noise(image, var = sigma**2)\\n return image\",\n \"def add_noise(emg):\\n MAX_AMPLITUDE = 32767\\n\\n # Sampling\\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\\n Ts = 1/EMG_F_SAMPLE\\n\\n # Time vector\\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\\n\\n # Noise\\n randAmplitudeScale = np.random.random()*0.1\\n randOffset = np.random.random() * 2*np.pi\\n \\n fNoise = 50; # Frequency [Hz]\\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\\n\\n # Add noise to signal\\n for channel in [\\\"emg1\\\", \\\"emg2\\\", \\\"emg3\\\", \\\"emg4\\\", \\\"emg5\\\", \\\"emg6\\\"]:\\n emg[channel] += noise\\n return emg\",\n \"def add_noise(image, noise, rate=0.05):\\n\\n if noise == \\\"gaussian\\\":\\n row, col = image.shape\\n var = ndimage.laplace(image).var()\\n sigma = (var*rate) ** 0.5\\n print(var, sigma)\\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\\n noisy = image + gauss\\n # noisy = image + gauss\\n return noisy\\n\\n elif noise == \\\"salt_pepper\\\":\\n output = image.copy()\\n black = 0\\n white = 255\\n probs = np.random.random(image.shape[:2])\\n output[probs < (rate / 2)] = black\\n output[probs > 1 - (rate / 2)] = white\\n\\n return output\\n\\n else:\\n return image\",\n \"def naive_gaussian_noise(true_depth: np.ndarray) -> np.ndarray:\\n return true_depth + np.random.normal(0, 0.0012 + 0.0019 * np.square(true_depth - 0.4))\",\n \"def gen_noise(sample_size, latent):\\r\\n\\treturn Variable(torch.randn(sample_size, latent))\",\n \"def _gaussian_distribution(self, x: ndarray, mu: float, sigma: float) -> ndarray:\\n return 1 / (np.sqrt(2 * np.pi) * sigma) * np.exp(\\n -np.power(\\n (x - mu) / sigma, 2) / 2)\",\n \"def GaussianKernel(radius, std):\\n size = 2 * radius + 1\\n weight = torch.ones(size, size)\\n weight.requires_grad = False\\n for i in range(-radius, radius+1):\\n for j in range(-radius, radius+1):\\n dis = (i * i) + (j * j)\\n weight[i+radius][j+radius] = np.exp(-dis / (2 * std * std))\\n weight = weight / weight.sum()\\n return weight\",\n \"def gaussianise_series(self, train_x):\\n\\n n_batches = train_x.shape[0]\\n\\n for batch in range(n_batches):\\n train_x[batch, :, :] = gaussianise(train_x[batch, :, :], target_sigma=1.0)\\n\\n return train_x\",\n \"def add_image_noise(\\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n shape = self.signal.axes_manager.shape\\n noise = normal(mu, sigma, shape)\\n if only_positive:\\n self._image_noise = np.absolute(noise)\\n else:\\n self._image_noise = noise\",\n \"def add_gaussian(self, high, center, stdev):\\n if callable(high):\\n high = high()\\n assert stdev > 0\\n self.Y += high * np.exp(-0.5 * (self.Xnum-center)**2 / stdev**2)\",\n \"def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)\",\n \"def gaussian_gen(ngaussian, nd, batchSize, seed, random=True):\\n torch.manual_seed(seed)\\n np.random.seed(seed)\\n\\n means, covars, weights = get_means_covars(nd, ngaussian, random)\\n while True:\\n # yield multi_normal.sample((batchSize,))\\n yield mm_gaussian(batchSize, means, covars, weights) / 1.414\",\n \"def gaussian(x, *parameters):\\n position, sigma, amplitude, background = parameters\\n return amplitude * np.exp(-(x - position)**2 / (2.0 * sigma**2)) + background\",\n \"def addNoise(img, sigma=2.0, mean=0):\\n img2 = np.random.normal(mean, sigma, size=img.shape)\\n\\n img2 += img\\n img2 = np.uint8(img2.clip(0, 255))\\n return img2\",\n \"def gaussian_kernel(training_ex, landmark, sigma=0.1):\\n return np.exp(-(np.linalg.norm(training_ex - landmark) ** 2 / (2 * (sigma ** 2))))\",\n \"def gaussian(amp, fwhm, mean, x):\\n return amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def gaussian(mu, wid, x):\\n return np.exp(-((x - mu) / (0.6005612 * wid))**2)\",\n \"def add_noise(np_image, amount):\\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\\n norm_noise = abs(noise/np.max(noise))\\n np_image = np_image + norm_noise*np.max(np_image)*amount\\n \\n return np_image\",\n \"def SampleFromGaussian(shape, noise_mean=0., noise_std=1., name='gaussian-sample'):\\n def instantiate(args):\\n mean, log_var = args\\n return layers.Lambda(gaussian_noise(noise_mean=noise_mean, noise_std=noise_std),\\n output_shape=shape,\\n name=name)([mean, log_var])\\n return instantiate\",\n \"def noise(x: np.ndarray) -> np.ndarray:\\n\\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)\",\n \"def add_noise(self, u):\\n noise = torch.randn_like(u)\\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\\n\\n # bias repeatability (without in run bias stability)\\n b0 = self.uni.sample(u[:, 0].shape).cuda()\\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\\n u = u + noise + b0.transpose(1, 2)\\n return u\",\n \"def set_gaussian(self, X, sigma=0):\\n sigma = float(sigma)\\n if sigma < 0:\\n raise ValueError('sigma should be positive')\\n self.set_euclidian(X)\\n d = self.weights\\n\\n if sigma == 0:\\n sigma = (d ** 2).mean()\\n\\n w = np.exp(- (d ** 2) / (2 * sigma))\\n self.weights = w\",\n \"def apply_noise(self, input):\\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \\n noisy_input = mask * input\\n \\n return noisy_input\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def model_gauss(xsigma, nx, ny=1, nz=1, ysigma=None, zsigma=None, xcenter=None, ycenter=None, zcenter=None):\\n\\te = EMData()\\n\\te.set_size(nx, ny, nz)\\n\\tif( ysigma == None ) : ysigma = xsigma\\n\\tif( zsigma == None ) : zsigma = xsigma\\n\\tif( xcenter == None ) : xcenter = nx//2\\n\\tif( ycenter == None ) : ycenter = ny//2\\n\\tif( zcenter == None ) : zcenter = nz//2\\n\\te.process_inplace(\\\"testimage.puregaussian\\\", {\\\"x_sigma\\\":xsigma,\\\"y_sigma\\\":ysigma,\\\"z_sigma\\\":zsigma,\\\"x_center\\\":xcenter,\\\"y_center\\\":ycenter,\\\"z_center\\\":zcenter} )\\n\\treturn e\",\n \"def noiseReduction(self):\\n pass\",\n \"def _get_add_noise(stddev, seed: int = None):\\n if distutils.version.LooseVersion(\\n tf.__version__) < distutils.version.LooseVersion('2.0.0'):\\n\\n # The seed should be only used for testing purpose.\\n if seed is not None:\\n tf.random.set_seed(seed)\\n\\n def add_noise(v):\\n return v + tf.random.normal(\\n tf.shape(input=v), stddev=stddev, dtype=v.dtype)\\n else:\\n random_normal = tf.random_normal_initializer(stddev=stddev, seed=seed)\\n\\n def add_noise(v):\\n return v + tf.cast(random_normal(tf.shape(input=v)), dtype=v.dtype)\\n\\n return add_noise\",\n \"def generate_noise_vector(self, ):\\n self.noise.resize_(\\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???\",\n \"def gaussianOneSample(self, mu=0., sig=1., size=1):\\n\\n thisSample = np.random.normal(mu, sig, size)\\n\\n return thisSample\",\n \"def get_noise(batch_size, total_continuous_noise_dims):\\n # Get unstructurd noise.\\n noise = tf.random_normal(\\n [batch_size, total_continuous_noise_dims])\\n\\n return noise\",\n \"def grad(w, f, noise):\\n f -= f.mean()\\n f /= f.std() # standardize the rewards to be N(0,1) gaussian\\n g = np.dot(f, noise)\\n return g\",\n \"def random_gaussian_noise(self, img, p = 0.5):\\n if self.decision(p):\\n mean = 30.0\\n std = 80.0\\n img = img + np.random.normal(mean, std, img.shape)\\n\\n img = np.clip(img, 0, 255).astype('uint8')\\n return img\",\n \"def gaussian_ep(gp_link=None,variance=1.):\\r\\n if gp_link is None:\\r\\n gp_link = noise_models.gp_transformations.Identity()\\r\\n #else:\\r\\n # assert isinstance(gp_link,noise_models.gp_transformations.GPTransformation), 'gp_link function is not valid.'\\r\\n\\r\\n analytical_mean = False\\r\\n analytical_variance = False\\r\\n return noise_models.gaussian_noise.Gaussian(gp_link,analytical_mean,analytical_variance,variance)\",\n \"def sample(self):\\n # CITATION corrected by : https://github.com/l5shi/Multi-DDPG-with-parameter-noise/blob/master/Multi_DDPG_with_parameter_noise.ipynb\\n x = self.x_prev\\n dx = self.theta * (self.mu - x) * self.dt + self.sigma * np.sqrt(\\n self.dt\\n ) * np.random.normal(size=self.mu.shape)\\n self.x_prev = x + dx\\n return self.x_prev\",\n \"def _addNoise(self):\\n self.dispNoise = self.dispRaw.copy()\\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\\n return\",\n \"def add_noise(self, data):\",\n \"def add_noise(self, noise):\\n if noise > 0.0:\\n for key in self.counts:\\n self.counts[key] *= 1.0 + noise * np.random.random_sample()\",\n \"def gaussian(amp, fwhm, mean):\\n return lambda x: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\",\n \"def sampling(z_mean, z_log_var):\\n\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = fluid.layers.gaussian_random_batch_size_like(z_mean, shape=[-1, latent_dim])\\n epsilon.stop_gradient = True\\n return z_mean + fluid.layers.exp(0.5 * z_log_var) * epsilon\",\n \"def addGaussian(self, xwidth=100., ywidth=100., xcen=None, ycen=None, value=1.0):\\n if xcen == None:\\n xcen = self.nx/2.0\\n if ycen == None:\\n ycen = self.ny/2.0\\n self.fimage = None\\n gaussian = numpy.exp(-(self.xx-xcen)**2/(2.0*xwidth**2) - (self.yy-ycen)**2/(2.0*ywidth**2))\\n self.image += gaussian * value / gaussian.max()\\n return\",\n \"def _apply_observation_noise(self, state: RobotState,\\n config: RobotGroupConfig):\\n if config.sim_observation_noise is None or self.random_state is None:\\n return\\n\\n # Define the noise calculation.\\n def noise(value_range: np.ndarray):\\n amplitude = config.sim_observation_noise * np.ptp(\\n value_range, axis=1)\\n return amplitude * self.random_state.uniform(\\n low=-0.5, high=0.5, size=value_range.shape[0])\\n\\n if config.qpos_range is not None:\\n state.qpos += noise(config.qpos_range)\\n if config.qvel_range is not None:\\n state.qvel += noise(config.qvel_range)\",\n \"def add_gaussian_noise(self, stdev, iteration = 1, method = 'absolute', normalize = \\\"on\\\"):\\n\\n self.number_of_replicate = iteration\\n for fragment in self.fragments_for_mdv_calculation:\\n number_of_mass_data = max(self.mdv[fragment].keys()) + 1\\n noise = numpy.zeros((number_of_mass_data, iteration))\\n for i in range(iteration):\\n for number in range(number_of_mass_data):\\n if method == 'relative':\\n noise[number, i] = (numpy.random.randn() * stdev + 1) * self.mdv[fragment][number]['ratio']\\n else:\\n noise[number, i] = (numpy.random.randn() * stdev) + self.mdv[fragment][number]['ratio']\\n if noise[number, i] < 0.0:\\n noise[number, i] = 0.0\\n #各フラグメント毎に総和を１にする。\\n if normalize == \\\"on\\\":\\n sumvalue = sum(noise[:,i])\\n noise[:,i] = noise[:,i] / sumvalue\\n for number in range(number_of_mass_data):\\n self.mdv[fragment][number]['ratio']= sum(noise[number,:])/iteration\\n #self.mdv[fragment][number]['std'] = numpy.std(noise[number,:])\\n self.mdv[fragment][number]['data'] = numpy.array(noise[number,:])\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def gaussian(x, x0=0.0, fwhm=1.0, ampl=1.0):\\n return ampl * np.exp(-4 * np.log(2) * ((x - x0) / fwhm) ** 2)\",\n \"def global_noise(self, seed=42, **kwargs):\\n # Random perturbations, initialized globally for same results in parallel\\n gshape = self.domain.dist.grid_layout.global_shape(scales=self.domain.dealias)\\n slices = self.domain.dist.grid_layout.slices(scales=self.domain.dealias)\\n rand = np.random.RandomState(seed=seed)\\n noise = rand.standard_normal(gshape)[slices]\\n\\n # filter in k-space\\n noise_field = self._new_field()\\n noise_field.set_scales(self.domain.dealias, keep_data=False)\\n noise_field['g'] = noise\\n self.filter_field(noise_field, **kwargs)\\n\\n return noise_field\",\n \"def gaussian(x, mean, sigma):\\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))\",\n \"def reparameterize(self, mean, logvar):\\n if self.training:\\n std = torch.exp(0.5 * logvar)\\n # std = torch.zeros_like(mean) + 0.25\\n eps = torch.randn_like(std)\\n return mean + std * eps\\n else:\\n return mean\",\n \"def gaussian1d(x, x0, w0, A, offset):\\n if w0 == 0:\\n return 0\\n return A * np.exp(-2 * (x - x0) ** 2 / (w0 ** 2)) + offset\",\n \"def gaussian_dataset(ngaussian, nd, nsample, random=True):\\n means, covars, weights = get_means_covars(nd, ngaussian, random)\\n return mm_gaussian(nsample, means, covars, weights)\",\n \"def reparameterize(self, mu, log_var):\\n std = torch.exp(0.5 * log_var)\\n eps = torch.randn_like(std)\\n return eps * std + mu\",\n \"def reparameterize(self, mu, logvar):\\n std = torch.exp(0.5 * logvar)\\n eps = torch.randn_like(std)\\n return eps * std + mu\",\n \"def reparameterize(self, mu, logvar):\\n std = torch.exp(0.5 * logvar)\\n eps = torch.randn_like(std)\\n return eps * std + mu\",\n \"def random_glove_generator(emb_mean, emb_stddev):\\n x = np.random.normal(loc=0.0, scale=1.0, size=len(emb_mean))\\n x_rand = np.multiply(x, emb_stddev) + emb_mean\\n return x_rand\",\n \"def gaussianOne(self, x=np.array([]), mu=0., sig=1.):\\n\\n lnConst = -0.5 * np.log(2.0 * np.pi)\\n lnVar = -np.log(sig)\\n lnBrack = -0.5 * ((x - mu) / sig)**2\\n\\n ### safety valve\\n ###bBad = np.abs(lnBrack) > 7.\\n ###lnBrack[bBad] = -np.inf\\n\\n return lnConst + lnVar + lnBrack\",\n \"def gaussian(window_size, sigma):\\n gauss = torch.Tensor([math.exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])\\n return gauss/gauss.sum()\",\n \"def gaussian_denoiser(z_noisy, u, size):\\n\\n a1 = tf.Variable(0. * tf.ones([size]), name='a1')\\n a2 = tf.Variable(1. * tf.ones([size]), name='a2')\\n a3 = tf.Variable(0. * tf.ones([size]), name='a3')\\n a4 = tf.Variable(0. * tf.ones([size]), name='a4')\\n a5 = tf.Variable(0. * tf.ones([size]), name='a5')\\n\\n # v\\n a6 = tf.Variable(0. * tf.ones([size]), name='a6')\\n a7 = tf.Variable(1. * tf.ones([size]), name='a7')\\n a8 = tf.Variable(0. * tf.ones([size]), name='a8')\\n a9 = tf.Variable(0. * tf.ones([size]), name='a9')\\n a10 = tf.Variable(0. * tf.ones([size]), name='a10')\\n\\n mu = a1 * tf.sigmoid(a2 * u + a3) + a4 * u + a5\\n v = a6 * tf.sigmoid(a7 * u + a8) + a9 * u + a10\\n\\n z = (z_noisy - mu) * v + mu\\n return z\",\n \"def gaussian_filter(x):\\n return _gaussian_filter(x, 3)\",\n \"def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:\\n std = torch.exp(0.5*logvar)\\n # eps=N(0,I), where the I is an identity matrix of same size as std\\n eps = torch.randn_like(std)\\n return mu + std*eps\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7656182","0.7478594","0.71226805","0.7062763","0.7007418","0.69041336","0.66500264","0.66093963","0.65894604","0.65828973","0.65525967","0.6540314","0.65288055","0.65264595","0.64818","0.64335525","0.6431225","0.6427232","0.64240474","0.6390431","0.6390431","0.6382558","0.6377498","0.6297472","0.628499","0.62606996","0.62099755","0.6204954","0.61918074","0.6186501","0.61724967","0.61285555","0.612298","0.6114542","0.61070466","0.61064863","0.607504","0.6065023","0.60619897","0.6042337","0.60319054","0.60280174","0.60170066","0.6008962","0.60013354","0.59853595","0.59737265","0.5963329","0.5954838","0.59537953","0.59523976","0.5948393","0.59263265","0.59039485","0.5891418","0.58893985","0.5872476","0.58713293","0.5864229","0.5850847","0.5846816","0.58406115","0.58186835","0.58036286","0.57899857","0.5788179","0.5788179","0.57851535","0.5773993","0.5772764","0.57669926","0.5754904","0.5753514","0.5747157","0.5743828","0.5742462","0.57200986","0.56859046","0.56726414","0.5655134","0.56487966","0.5632667","0.5614849","0.5612998","0.56044716","0.55951124","0.55897707","0.55681324","0.55531657","0.554534","0.55252874","0.55138564","0.55113393","0.5508858","0.5508858","0.55088204","0.55066824","0.5506351","0.55035925","0.5502518","0.5499638"],"string":"[\n \"0.7656182\",\n \"0.7478594\",\n \"0.71226805\",\n \"0.7062763\",\n \"0.7007418\",\n \"0.69041336\",\n \"0.66500264\",\n \"0.66093963\",\n \"0.65894604\",\n \"0.65828973\",\n \"0.65525967\",\n \"0.6540314\",\n \"0.65288055\",\n \"0.65264595\",\n \"0.64818\",\n \"0.64335525\",\n \"0.6431225\",\n \"0.6427232\",\n \"0.64240474\",\n \"0.6390431\",\n \"0.6390431\",\n \"0.6382558\",\n \"0.6377498\",\n \"0.6297472\",\n \"0.628499\",\n \"0.62606996\",\n \"0.62099755\",\n \"0.6204954\",\n \"0.61918074\",\n \"0.6186501\",\n \"0.61724967\",\n \"0.61285555\",\n \"0.612298\",\n \"0.6114542\",\n \"0.61070466\",\n \"0.61064863\",\n \"0.607504\",\n \"0.6065023\",\n \"0.60619897\",\n \"0.6042337\",\n \"0.60319054\",\n \"0.60280174\",\n \"0.60170066\",\n \"0.6008962\",\n \"0.60013354\",\n \"0.59853595\",\n \"0.59737265\",\n \"0.5963329\",\n \"0.5954838\",\n \"0.59537953\",\n \"0.59523976\",\n \"0.5948393\",\n \"0.59263265\",\n \"0.59039485\",\n \"0.5891418\",\n \"0.58893985\",\n \"0.5872476\",\n \"0.58713293\",\n \"0.5864229\",\n \"0.5850847\",\n \"0.5846816\",\n \"0.58406115\",\n \"0.58186835\",\n \"0.58036286\",\n \"0.57899857\",\n \"0.5788179\",\n \"0.5788179\",\n \"0.57851535\",\n \"0.5773993\",\n \"0.5772764\",\n \"0.57669926\",\n \"0.5754904\",\n \"0.5753514\",\n \"0.5747157\",\n \"0.5743828\",\n \"0.5742462\",\n \"0.57200986\",\n \"0.56859046\",\n \"0.56726414\",\n \"0.5655134\",\n \"0.56487966\",\n \"0.5632667\",\n \"0.5614849\",\n \"0.5612998\",\n \"0.56044716\",\n \"0.55951124\",\n \"0.55897707\",\n \"0.55681324\",\n \"0.55531657\",\n \"0.554534\",\n \"0.55252874\",\n \"0.55138564\",\n \"0.55113393\",\n \"0.5508858\",\n \"0.5508858\",\n \"0.55088204\",\n \"0.55066824\",\n \"0.5506351\",\n \"0.55035925\",\n \"0.5502518\",\n \"0.5499638\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10794,"cells":{"query":{"kind":"string","value":"Shift input ids one token to the right, and wrap the last non pad token (usually )."},"document":{"kind":"string","value":"def shift_tokens_right(self, input_ids, pad_token_id):\n prev_output_tokens = input_ids.clone()\n index_of_eos = (input_ids.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)\n prev_output_tokens[:, 0] = input_ids.gather(1, index_of_eos).squeeze()\n prev_output_tokens[:, 1:] = input_ids[:, :-1]\n return prev_output_tokens"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def shift_tokens_right(input_ids, pad_token_id):\r\n prev_output_tokens = input_ids.clone()\r\n index_of_eos = (input_ids.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)\r\n prev_output_tokens[:, 0] = input_ids.gather(1, index_of_eos).squeeze()\r\n prev_output_tokens[:, 1:] = input_ids[:, :-1]\r\n return prev_output_tokens","def shift_tokens_right(self,input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):\n shifted_input_ids = input_ids.new_zeros(input_ids.shape)\n shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()\n shifted_input_ids[:, 0] = decoder_start_token_id\n\n assert pad_token_id is not None, \"self.model.config.pad_token_id has to be defined.\"\n # replace possible -100 values in labels by `pad_token_id`\n shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)\n\n return shifted_input_ids","def shift_tokens_right(input_ids: jnp.array, pad_token_id: int, decoder_start_token_id: int) -> jnp.ndarray:\n shifted_input_ids = jnp.zeros_like(input_ids)\n shifted_input_ids = shifted_input_ids.at[:, 1:].set(input_ids[:, :-1])\n shifted_input_ids = shifted_input_ids.at[:, 0].set(decoder_start_token_id)\n\n shifted_input_ids = jnp.where(shifted_input_ids == -100, pad_token_id, shifted_input_ids)\n return shifted_input_ids","def pad_tokens(x, max_length, pad_token_id,\n truncate_from=\"left\",\n pad_from=\"left\"):\n assert truncate_from in (\"left\", \"right\")\n assert pad_from in (\"left\", \"right\")\n if len(x) > max_length:\n if truncate_from == \"left\":\n return x[-max_length:]\n else:\n return x[:max_length]\n elif len(x) < max_length:\n padding = [pad_token_id] * (max_length - len(x))\n if pad_from == \"left\":\n return padding + x\n else:\n return x + padding\n else:\n return x","def shift_right(input, pad=2):\n return tf.concat((tf.ones_like(input[:, :1]) * pad, input[:, :-1]), 1)","def align_tokens(tokens, target_token_index):\n seq_len = self.seq_len - 2\n if len(tokens) > seq_len:\n start_index = max(0, int(target_token_index - seq_len / 2 + middle_shift))\n start_index = min(start_index, len(tokens) - seq_len)\n while tokens[start_index].startswith('#') and start_index + seq_len > target_token_index + 1:\n start_index -= 1\n start_index = max(0, start_index)\n tokens = tokens[start_index : start_index + seq_len]\n target_token_index -= start_index\n tokens = ['[CLS]', ] + tokens + ['[SEP]', ]\n target_token_index += 1\n return tokens, target_token_index","def wrap_pad(input, size):\n M1 = tf.concat([input[:, :, -size[1]:, :], input, input[:, :, 0:size[1], :]], 2)\n M1 = tf.concat([M1[:, -size[0]:, :, :], M1, M1[:, 0:size[0], :, :]], 1)\n return M1","def unpad(plain):\n return plain[:-ord(plain[-1])]","def truncate_sequences(\n self,\n ids: List[int],\n token_boxes: List[List[int]],\n pair_ids: Optional[List[int]] = None,\n pair_token_boxes: Optional[List[List[int]]] = None,\n labels: Optional[List[int]] = None,\n num_tokens_to_remove: int = 0,\n truncation_strategy: Union[str, TruncationStrategy] = \"longest_first\",\n stride: int = 0,\n ) -> Tuple[List[int], List[int], List[int]]:\n if num_tokens_to_remove <= 0:\n return ids, token_boxes, pair_ids, pair_token_boxes, labels, [], [], []\n\n if not isinstance(truncation_strategy, TruncationStrategy):\n truncation_strategy = TruncationStrategy(truncation_strategy)\n\n overflowing_tokens = []\n overflowing_token_boxes = []\n overflowing_labels = []\n if truncation_strategy == TruncationStrategy.LONGEST_FIRST:\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) > len(pair_ids):\n if not overflowing_tokens:\n window_len = min(len(ids), stride + 1)\n else:\n window_len = 1\n overflowing_tokens.extend(ids[-window_len:])\n overflowing_token_boxes.extend(token_boxes[-window_len:])\n overflowing_labels.extend(labels[-window_len:])\n ids = ids[:-1]\n token_boxes = token_boxes[:-1]\n labels = labels[:-1]\n else:\n if not overflowing_tokens:\n window_len = min(len(pair_ids), stride + 1)\n else:\n window_len = 1\n overflowing_tokens.extend(pair_ids[-window_len:])\n overflowing_token_boxes.extend(pair_token_boxes[-window_len:])\n pair_ids = pair_ids[:-1]\n pair_token_boxes = pair_token_boxes[:-1]\n elif truncation_strategy == TruncationStrategy.ONLY_FIRST:\n if len(ids) > num_tokens_to_remove:\n window_len = min(len(ids), stride + num_tokens_to_remove)\n overflowing_tokens = ids[-window_len:]\n overflowing_token_boxes = token_boxes[-window_len:]\n overflowing_labels = labels[-window_len:]\n ids = ids[:-num_tokens_to_remove]\n token_boxes = token_boxes[:-num_tokens_to_remove]\n labels = labels[:-num_tokens_to_remove]\n else:\n logger.error(\n f\"We need to remove {num_tokens_to_remove} to truncate the input \"\n f\"but the first sequence has a length {len(ids)}. \"\n f\"Please select another truncation strategy than {truncation_strategy}, \"\n \"for instance 'longest_first' or 'only_second'.\"\n )\n elif truncation_strategy == TruncationStrategy.ONLY_SECOND and pair_ids is not None:\n if len(pair_ids) > num_tokens_to_remove:\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\n overflowing_tokens = pair_ids[-window_len:]\n overflowing_token_boxes = pair_token_boxes[-window_len:]\n pair_ids = pair_ids[:-num_tokens_to_remove]\n pair_token_boxes = pair_token_boxes[:-num_tokens_to_remove]\n else:\n logger.error(\n f\"We need to remove {num_tokens_to_remove} to truncate the input \"\n f\"but the second sequence has a length {len(pair_ids)}. \"\n f\"Please select another truncation strategy than {truncation_strategy}, \"\n \"for instance 'longest_first' or 'only_first'.\"\n )\n\n return (\n ids,\n token_boxes,\n pair_ids,\n pair_token_boxes,\n labels,\n overflowing_tokens,\n overflowing_token_boxes,\n overflowing_labels,\n )","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def pad_decoder_inp_targ(self, max_len, pad_id):\n\t\twhile len(self.dec_input) < max_len:\n\t\t\tself.dec_input.append(pad_id)\n\t\twhile len(self.target) < max_len:\n\t\t\tself.target.append(pad_id)","def shift(self, t, word):\n return t[1:] + (word,)","def pad_batch(self, ids):\r\n max_len = max([len(x) for x in ids])\r\n return [x + [0] * (max_len - len(x)) for x in ids]","def shift(t, word):\n return t[1:] + (word,)","def pad_query_input(self, max_len, pad_id):\n\t\twhile len(self.query_input) < max_len:\n\t\t\tself.query_input.append(pad_id)","def pad_encoder_input(self, max_len, pad_id):\n while len(self.enc_input) < max_len:\n self.enc_input.append(pad_id)","def collate_tokens(\n values,\n pad_idx,\n eos_idx=None,\n left_pad=False,\n move_eos_to_beginning=False,\n pad_to_length=None,\n pad_to_multiple=1,\n):\n size = max(v.size(0) for v in values)\n size = size if pad_to_length is None else max(size, pad_to_length)\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\n res = values[0].new(len(values), size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n if eos_idx is None:\n # if no eos_idx is specified, then use the last token in src\n dst[0] = src[-1]\n else:\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v):] if left_pad else res[i][:len(v)])\n return res","def _dynamic_padding(self, batch_data, pad_id):\n pad_p_len = min(self.max_p_len, max(batch_data['passage_length']))\n pad_q_len = min(self.max_q_len, max(batch_data['question_length']))\n batch_data['passage_token_ids'] = [(ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\n for ids in batch_data['passage_token_ids']]\n batch_data['question_token_ids'] = [(ids + [pad_id] * (pad_q_len - len(ids)))[: pad_q_len]\n for ids in batch_data['question_token_ids']]\n return batch_data, pad_p_len, pad_q_len","def truncate_sequences(self,\n ids,\n pair_ids=None,\n num_tokens_to_remove=0,\n truncation_strategy='longest_first',\n stride=0):\n if num_tokens_to_remove <= 0:\n return ids, pair_ids, []\n\n if truncation_strategy == 'longest_first':\n overflowing_tokens = []\n if pair_ids is None or len(ids) <= len(pair_ids):\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) >= len(pair_ids):\n overflowing_tokens = [ids[-1]] + overflowing_tokens\n ids = ids[:-1]\n else:\n pair_ids = pair_ids[:-1]\n window_len = min(len(ids), stride)\n else:\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) > len(pair_ids):\n overflowing_tokens = [ids[-1]] + overflowing_tokens\n ids = ids[:-1]\n else:\n pair_ids = pair_ids[:-1]\n window_len = min(len(ids), stride)\n if window_len > 0:\n overflowing_tokens = ids[-window_len:] + overflowing_tokens\n elif truncation_strategy == 'only_first':\n assert len(ids) > num_tokens_to_remove\n window_len = min(len(ids), stride + num_tokens_to_remove)\n overflowing_tokens = ids[-window_len:]\n ids = ids[:-num_tokens_to_remove]\n elif truncation_strategy == 'only_second':\n assert pair_ids is not None and len(pair_ids) > num_tokens_to_remove\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\n overflowing_tokens = pair_ids[-window_len:]\n pair_ids = pair_ids[:-num_tokens_to_remove]\n elif truncation_strategy == 'do_not_truncate':\n raise ValueError(\n \"Input sequence are too long for max_length. Please select a truncation strategy.\"\n )\n else:\n raise ValueError(\n \"Truncation_strategy should be selected in ['longest_first', 'only_first', 'only_second', 'do_not_truncate']\"\n )\n return (ids, pair_ids, overflowing_tokens)","def trim_input_ids(input_ids: torch.tensor, pad_token_id, mask_token_id, num_masks: int):\n assert input_ids.shape[0] == 1\n input_ids_without_pad = [x for x in input_ids[0] if x != pad_token_id]\n\n trimmed_input_ids = []\n mask_count = 0\n for input_id in input_ids_without_pad:\n if input_id == mask_token_id:\n if mask_count >= num_masks:\n continue\n mask_count += 1\n trimmed_input_ids.append(input_id)\n\n return torch.tensor([trimmed_input_ids], dtype=torch.long, device=input_ids.device)","def build_inputs_with_special_tokens(\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\n ) -> List[int]:\n\n if token_ids_1 is None:\n return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]\n cls = [self.cls_token_id]\n sep = [self.sep_token_id]\n return cls + token_ids_0 + sep + sep + token_ids_1 + sep","def normalise_tag_id(input_id):\n return input_id.replace(\" \", \"\").replace(\"\\n\", \"\").replace(\"\\r\", \"\")","def pad_encoder_input(self, max_sen_len, pad_id):\n while len(self.enc_input) < max_sen_len:\n self.enc_input.append(pad_id)","def collate_tokens(values, pad_idx, eos_idx, left_pad, move_eos_to_beginning=False, pad_sequence=1):\n #size = max(v.size(0) for v in values)\n orig_size = max(v.size(0) for v in values)\n size = 0\n if pad_sequence > 1:\n size = orig_size // pad_sequence * pad_sequence\n if orig_size % pad_sequence > 0:\n size += pad_sequence\n else:\n size = orig_size\n res = values[0].new(len(values), size).fill_(pad_idx)\n\n def copy_tensor(src, dst):\n assert dst.numel() == src.numel()\n if move_eos_to_beginning:\n assert src[-1] == eos_idx\n dst[0] = eos_idx\n dst[1:] = src[:-1]\n else:\n dst.copy_(src)\n\n for i, v in enumerate(values):\n copy_tensor(v, res[i][size - len(v):] if left_pad else res[i][:len(v)])\n return res","def cn_whole_word_mask(input_tokens, ref_ids):\n\n for i in range(len(input_tokens)):\n if i in ref_ids:\n # We move it back by -1 as the ref_ids start at 1, not 0\n input_tokens[i-1] = \"##\" + input_tokens[i-1]\n\n input_tokens = _whole_word_mask(input_tokens)\n\n return input_tokens","def pad_seq(seq, max_seq_len=0):\n if max_seq_len:\n pad_len = max_seq_len - len(seq)\n if pad_len > 0:\n return np.concatenate([seq, np.zeros(pad_len, dtype=np.int64)])\n elif pad_len < 0: # chop to fit\n two_last_tokens = seq[-2:]\n out = seq[:max_seq_len]\n out[-2:] = two_last_tokens\n return out.astype(np.int64)\n return seq.astype(np.int64)","def full_tokens(tokens):\n target_length = roundup2(len(tokens))\n padding_length = target_length - len(tokens)\n tokens = [PADDING_TOKEN] * padding_length + tokens\n return tokens","def shift_right(self):\n self.pointer = (self.pointer + 1) % len(self.data)","def remove_pad(x, pad_remover, mode):\n # Concatenate all tokens (without padding)\n x = flatten_all_but_last(x)\n\n # Remove padding for training and eval\n if mode != ModeKeys.PREDICT:\n # This is a hack to allows inference when the <go> token\n # is detected as padding and removed. This works for now because there is\n # no padding at inference.\n x = pad_remover.remove(x)\n\n x = tf.expand_dims(x, axis=0) # Now batch_size=1\n return x","def embed_input_ids(\n self, input_ids: torch.Tensor, next_token_ids: torch.Tensor, prefix_ids: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\n batch_size = len(input_ids)\n if prefix_ids is None:\n prefix_ids = self.prefix_ids\n prefix_embedding = self.prefix_embedding\n \n else:\n prefix_embedding = self.token_embedding.forward(prefix_ids)\n\n # concatenate preprefix (fixed) + prefix (learned) + example\n prefix_ids = prefix_ids[None].to(device).repeat((batch_size, 1)).to(device)\n preprefix_ids = self.preprefix_ids[None].to(device).repeat((batch_size, 1)).to(device)\n\n if self.prefix_before_input:\n full_input_ids = torch.cat(\n (preprefix_ids, prefix_ids, input_ids, next_token_ids), dim=1\n )\n outputs = torch.cat(\n (\n self.token_embedding.forward(preprefix_ids),\n prefix_embedding[None].repeat((batch_size, 1, 1)),\n self.token_embedding.forward(input_ids),\n self.token_embedding.forward(next_token_ids),\n ), dim=1\n )\n else:\n full_input_ids = torch.cat(\n (input_ids, preprefix_ids, prefix_ids, next_token_ids), dim=1\n )\n outputs = torch.cat(\n (\n self.token_embedding.forward(input_ids),\n self.token_embedding.forward(preprefix_ids),\n prefix_embedding[None].repeat((batch_size, 1, 1)),\n self.token_embedding.forward(next_token_ids),\n ), dim=1\n )\n return full_input_ids, outputs","def padding_input(sents, pad_token=\"<pad>\", tgt_len=-1):\n if tgt_len == -1:\n tgt_len = max(len(s) for s in sents)\n batch_size = len(sents)\n seqs = []\n for i in range(batch_size):\n seqs.append(sents[i][0:tgt_len] + [pad_token] * (tgt_len - len(sents[i])))\n return seqs","def merged_tokens(self, i, tokenizer):\n out = []\n counts = []\n last_id = None\n tokens = tokenizer.convert_ids_to_tokens(self.token_ids[i].tolist())\n for token, current_id in zip(tokens[1:-1], self.conll_ids[i]):\n if last_id == current_id.item():\n if token.startswith(\"##\"):\n out[-1] += (token[2:])\n else:\n out[-1] += token\n counts[-1] += 1\n else:\n out.append(token)\n counts.append(1)\n last_id = current_id\n return out, counts","def justify_token(tok, col_width):\n get_len = tools.display_len if PY3 else len\n tok_len = get_len(tok)\n diff_len = tok_len - len(tok) if PY3 else 0\n\n cols = (int(math.ceil(float(tok_len) / col_width))\n if col_width < tok_len + 4 else 1)\n\n if cols > 1:\n return tok.ljust((col_width * cols) + (4 * cols) - diff_len)\n else:\n return tok.ljust(col_width + 4 - diff_len)","def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):\n if token_ids_1 is None:\n return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]\n _cls = [self.cls_token_id]\n _sep = [self.sep_token_id]\n return _cls + token_ids_0 + _sep + _sep + token_ids_1 + _sep","def _pad_or_cut_to_max_seq_len(x,\n max_seq_len):\n # Shape of x (n_crops, num_patches, c)\n assert len(tf.shape(x)) == 3\n # Padding makes sure that # patches > max_seq_length. Note that it also\n # makes the input mask zero for shorter input.\n paddings = tf.zeros([tf.shape(x)[0], max_seq_len,\n tf.shape(x)[-1]],\n dtype=x.dtype)\n x = tf.concat([x, paddings], axis=1)\n # Cuts to max_seq_len number of patches.\n x = x[:, :max_seq_len, :]\n return x","def _truncate_tokens(tokens_a, tokens_b, max_length):\n while len(tokens_a) + len(tokens_b) > max_length:\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop(0)\n else:\n tokens_b.pop()\n return tokens_a, tokens_b","def _shiftSecrets(cmd, secrets, shift):\n if secrets:\n for i in range(len(secrets), 0, -1):\n cmd = cmd.replace(f':{i+shift-2}:', f':{i+shift-1}:')\n return cmd","def build_tokens_types_paddings_from_ids(text_ids, max_seq_length,\n cls_id, sep_id, pad_id):\n enc_ids = []\n tokentypes_enc = []\n\n # [CLS].\n enc_ids.append(cls_id)\n tokentypes_enc.append(0)\n\n # A.\n len_src = len(text_ids)\n enc_ids.extend(text_ids)\n tokentypes_enc.extend([0] * len_src)\n\n # Cap the size.\n if len(enc_ids) > max_seq_length - 1:\n enc_ids = enc_ids[0: max_seq_length - 1]\n tokentypes_enc = tokentypes_enc[0: max_seq_length - 1]\n\n # [SEP].\n enc_ids.append(sep_id)\n tokentypes_enc.append(0)\n\n num_tokens_enc = len(enc_ids)\n # Padding.\n padding_length = max_seq_length - len(enc_ids)\n if padding_length > 0:\n enc_ids.extend([pad_id] * padding_length)\n tokentypes_enc.extend([pad_id] * padding_length)\n\n pad_mask = ([1] * num_tokens_enc) + ([0] * padding_length)\n pad_mask = np.array(pad_mask, dtype=np.int64)\n\n return enc_ids, tokentypes_enc, pad_mask","def __unpad(self, data):\n return data[0:-ord(data[-1])]","def pad_sentence_batch(sentence_batch, pad_int):\n max_sentence = max([len(sentence) for sentence in sentence_batch])\n return [sentence + [pad_int] * (max_sentence - len(sentence)) for sentence in sentence_batch]","def shift(self, length: int) -> str:\n result: str = ''\n total = 0\n line_pos = 0\n line_nb_chars = self._line_width - len(os.linesep)\n while total < length:\n if self.reminder == 0:\n return result\n if line_pos < line_nb_chars:\n result += self._data[0:1][0]\n self._data = self._data[1:]\n if self.reminder == 0:\n return result\n total += 1\n self._current_index += 1\n line_pos += 1\n continue\n result += os.linesep\n total += len(os.linesep)\n line_pos = 0\n return result","def make_padded_output_inp_tensor(exs, output_indexer, max_len):\n return np.array([[ex.y_indexed_inp[i] if i < len(ex.y_indexed_inp) else output_indexer.index_of(PAD_SYMBOL) for i in range(0, max_len)] for ex in exs])","def pad_snt(snt_ids_trunc, max_len):\n\n snt_ids_trunc_pad = snt_ids_trunc + [PAD_ID] * (max_len - len(snt_ids_trunc))\n\n return snt_ids_trunc_pad","def pad_encoder_input(self, max_len, pad_id):\n\t\twhile len(self.enc_input) < max_len:\n\t\t\tself.enc_input.append(pad_id)\n\t\tif self.hps.pointer_gen.value:\n\t\t\twhile len(self.enc_input_extend_vocab) < max_len:\n\t\t\t\tself.enc_input_extend_vocab.append(pad_id)","def wrap_pad_rows(x, n=1):\n out = tf.concat([x[:, -n:, :, :],\n x,\n x[:, :n, :, :]], axis=1)\n\n return tf.pad(out, [[0, 0], [0, 0], [1, 1], [0, 0]])","def tokenize_with_offsets(self, input): # pylint: disable=redefined-builtin\n name = None\n with ops.name_scope(name, \"WhitespaceTokenize\", [input]):\n input_tensor = ragged_tensor.convert_to_tensor_or_ragged_tensor(input)\n if input_tensor.shape.ndims is None:\n raise ValueError(\"Rank of input_tensor must be statically known.\")\n if ragged_tensor.is_ragged(input_tensor):\n if input_tensor.flat_values.shape.ndims > 1:\n # If the flat_values of our ragged tensor is multi-dimensional, we can\n # process it separately and our output will have the same nested\n # splits as our input.\n (tokens, starts,\n ends) = self.tokenize_with_offsets(input_tensor.flat_values)\n return (input_tensor.with_flat_values(tokens),\n input_tensor.with_flat_values(starts),\n input_tensor.with_flat_values(ends))\n else:\n # Recursively process the values of the ragged tensor.\n (tokens, starts,\n ends) = self.tokenize_with_offsets(input_tensor.values)\n return (input_tensor.with_values(tokens),\n input_tensor.with_values(starts),\n input_tensor.with_values(ends))\n else:\n if input_tensor.shape.ndims > 1:\n # Convert the input tensor to ragged and process it.\n return self.tokenize_with_offsets(\n ragged_conversion_ops.from_tensor(input_tensor))\n elif input_tensor.shape.ndims == 0:\n (tokens, starts, ends) = self.tokenize_with_offsets(\n array_ops_stack.stack([input_tensor]))\n return tokens.values, starts.values, ends.values\n else:\n # Our rank 1 tensor is the correct shape, so we can process it as\n # normal.\n return self._whitespace_tokenize_with_offsets(input_tensor)","def index_to_input(X, maxlen_sent, maxlen_doc):\n X = [pad_sequences(i, maxlen=maxlen_sent, padding='post') for i in X]\n X = pad_2Dsequences(X, maxlen=maxlen_doc)\n return X","def tokenize(tokenizer, max_length, stride, row):\r\n # The input data must be tokenized in the order dictated by the side the\r\n # selected checkpoint apply the padding\r\n pad_on_right = tokenizer.padding_side == \"right\"\r\n \r\n return tokenizer(\r\n row[\"question\" if pad_on_right else \"context\"],\r\n row[\"context\" if pad_on_right else \"question\"],\r\n max_length=max_length,\r\n truncation=\"only_second\" if pad_on_right else \"only_first\",\r\n return_overflowing_tokens=True,\r\n return_offsets_mapping=True,\r\n stride=stride,\r\n padding=\"max_length\",\r\n )","def map_ids_to_tokens(self, ids: List[int], filter_padding=True):\n tokens = [self.map_id_to_token(id) for id in ids]\n if filter_padding:\n tokens = [t for t in tokens if t != self._pad_token]\n return tokens","def _pad_shorter(sequence: str) -> str:\n return sequence.ljust(3, \"X\")","def move_right(self) -> None:\n if not self.buffer:\n return\n\n if self.index == self.buffer.end:\n return\n\n if self.buffer[self.index] != '\\n':\n self.index += 1","def __rlshift__(self, *args):\n return _libsbml.string___rlshift__(self, *args)","def _dynamic_padding(self, batch_data, pad_id = 0 ):\n #print 'dynamic _padding...'\n #print 'pad_id' + str(pad_id)\n max_p_len = 1000\n max_q_len =1000\n pad_p_len = min(max_p_len, max(batch_data['passage_length']))+1\n #print 'pad_p_len' + str(pad_p_len)\n pad_q_len = min(max_q_len, max(batch_data['question_length']))\n #print 'pad_q_len' + str(pad_q_len)\n #for ids in batch_data['passage_token_ids'] :\n #print 'padding: '\n #print (ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\n batch_data['passage_token_ids'] = [(ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\n for ids in batch_data['passage_token_ids']]\n batch_data['question_token_ids'] = [(ids + [pad_id] * (pad_q_len - len(ids)))[: pad_q_len]\n for ids in batch_data['question_token_ids']]\n return batch_data, pad_p_len, pad_q_len","def pad_dataset(dataset, padding=0):\n max_l = max(len(x) for x in dataset[\"input_ids\"])\n for name in PADDED_INPUTS:\n dataset[name] = [x + [padding if name != \"lm_labels\" else -100] * (max_l - len(x)) for x in dataset[name]]\n return dataset","def right_shift(key,shift):\n if shift > len(key):\n shift = shift % len(key)\n return key[-shift:] + key[:-shift]","def _get_token_ids(self, tokens):\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n pad_amount = self.max_seq_length - len(tokens)\n input_ids = token_ids + [0] * pad_amount\n return np.array(input_ids)","def _truncate_seq_pair(self, tokens_a: str, tokens_b: str, max_length: int):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def pad(input, pad_size):\n if not pad_size:\n return input\n return tf.pad(input, [[0,0],[pad_size, pad_size],[pad_size, pad_size],[0,0]], 'REFLECT')","def edit_tokens (input_words):\n length = len(input_words)\n for i, w in enumerate(input_words):\n if (w == \"{\"):\n if (i+2 < length):\n if (input_words[i+2] == \"}\"):\n input_words[i:i+3] = [''.join(input_words[i:i+3])]\n return input_words","def _get_token_mask(input_ids: Tensor, pad_token_id: int, sep_token_id: int, cls_token_id: int) ->Tensor:\n token_mask = input_ids.eq(pad_token_id) | input_ids.eq(sep_token_id) | input_ids.eq(cls_token_id)\n return ~token_mask","def post_forward(self, output):\n output = output[:2] + (None, )+ output[3:]\n return output","def add_tokens(self, tokens):\n if self.pad:\n tokens = [START_OF_SEQ] * self.order + tokens + [END_OF_SEQ]\n\n for i in range(len(tokens) - self.order):\n current_state = tuple(tokens[i:i + self.order])\n next_state = tokens[i + self.order]\n self.add_state(current_state, next_state)","def pad_sentence_batch(sentence_batch):\n max_sentence = max([len(sentence) for sentence in sentence_batch])\n return [sentence + [CODES['<PAD>']] * (max_sentence - len(sentence))\n for sentence in sentence_batch]","def create_token_type_ids_from_sequences(\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\n ) -> List[int]:\n # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method\n if token_ids_1 is None:\n # [CLS] X [SEP]\n return (len(token_ids_0) + 2) * [0]\n\n # [CLS] A [SEP] [SEP] B [SEP]\n return [0] * (len(token_ids_0) + 1) + [1] * (len(token_ids_1) + 3)","def pad_model_inputs(input, max_seq_length, pad_value=0): # pylint: disable=redefined-builtin\n with ops.name_scope(\"pad_model_inputs\"):\n # Verify that everything is a RaggedTensor\n if not isinstance(input, ragged_tensor.RaggedTensor):\n raise TypeError(\"Expecting a `RaggedTensor`, instead found: \" +\n str(input))\n\n # Flatten down to `merge_axis`\n input = input.merge_dims(1, -1) if input.ragged_rank > 1 else input\n\n # Pad to fixed Tensor\n target_shape = math_ops.cast([-1, max_seq_length], dtypes.int64)\n padded_input = input.to_tensor(shape=target_shape, default_value=pad_value)\n\n # Get padded input mask\n input_mask = array_ops.ones_like(input)\n padded_input_mask = input_mask.to_tensor(shape=target_shape)\n\n return padded_input, padded_input_mask","def convert_single_example(tokenizer, example, max_seq_length=512):\n\n if isinstance(example, PaddingInputExample):\n input_ids = [0] * max_seq_length\n input_mask = [0] * max_seq_length\n segment_ids = [0] * max_seq_length\n label = 0\n return input_ids, input_mask, segment_ids, label\n\n tokens_a = tokenizer.tokenize(example.text_a)\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0 : (max_seq_length - 2)]\n\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n \n #print(tokens)\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n return input_ids, input_mask, segment_ids, example.label","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def shift(self, el):\n self.register.pop(0)\n self.register.append(el)","def incr_id(id, n):\n return id[:-1] + (id[-1] + n,)","def int_padding(length, val, direction=\">\"):\n return '{0:0{direction}{fill}}'.format(val, direction=direction, fill=length)","def pad_batches(self, ids):\n\n batches = []\n for batch_elem_len, batch_sent_ids in zip(self.batch_elem_lengths, self.batch_sent_ids):\n batch = self.tokenizer.pad_id * np.ones((len(batch_sent_ids), batch_elem_len), dtype=np.int)\n for i, sentence_idx in enumerate(batch_sent_ids):\n batch[i][: len(ids[sentence_idx])] = ids[sentence_idx]\n batches.append(batch)\n return batches","def input_transpose_max_len(sents, pad_token,MAX_LEN):\n\n batch_size = len(sents)\n\n sents_t = []\n for i in range(MAX_LEN):\n sents_t.append([sents[k][i] if len(sents[k]) > i else pad_token for k in range(batch_size)])\n\n return sents_t","def wrap(self, ind, text, rhs=0):\n l = 79 - ind * self.indSize - rhs\n return textwrap.wrap(text, l)","def __radd__(self, other):\n return Token(\n other + self.text, self.position - len(other), self.category)","def rotate(str):\r\n return str[-1] + str[0:-1]","def _padright(width, s):\n fmt = \"{0:<%ds}\" % width\n return fmt.format(s)","def _mutateToken(t1, p, t2):\n if not isinstance(p, int): \n raise ValueError(\"p must be integer\")\n if(p < 0): \n raise ValueError(\"p may not be smaller than 0\")\n if(p > t1[0]-1): \n raise ValueError(\"p may not be larger than t1 length - 1\")\n\n x1 = t1[1] # Type of changed token\n l1 = t1[0] # Length of changed token\n x2 = t2[1] # Type of change\n l2 = t2[0] # Length of change\n q = l1 - p \n\n if l2 < 0: \n raise ValueError(\"length of t2 cannot be negative\")\n if x1 in ['S','H'] or x2 in ['S', 'H']:\n raise ValueError(\"CIGAR tokens S (soft-clip) or H (hard-clip) \"+\n \"are not supported!\")\n if x1 in ['P', 'N'] or x2 in ['P', 'N']:\n raise ValueError(\"CIGAR tokens P (reference padding) or \"+\n \"N (skip reference) are not supported!\")\n\n # Example: Insertion in MMM \n # x1 = M, l1 = 12, x2 = I, l2 = 2\n # p = 5 => q = 7\n # MMMMMMMMMMMM\n # └─p─┘└──q──┘ p + q = l1\n # -> MMMMMIIMMMMMMM\n\n # --- Library of different possible function return values\n # These functions use the variables p, q, l1, l2, x1 and x2.\n\n # (######, 3, ++++) -> (##+++,+) (replace per-character)\n replaceT1 = lambda: ( [ (max(0, p ), x1)\n , (min(q, l2 ), x2 ) \n , (max(0, q-l2), x1) ]\n , (max(0, l2-q), x2) )\n # (######, 3, ++++) -> (######,+) \n absorbT2 = lambda: ( [t1], (max(0, l2-q), x2) )\n # (######, 3, ++++) -> (###++++###, ) \n insertT2 = lambda: ( [ (max(0, p), x1)\n , t2\n , (max(0, q), x1)]\n , ())\n # (######, 3, ++++) -> (###, +) \n shortenT1 = lambda: ( [(p + max(0, q-l2), x1)]\n , (max(0, l2-q), x2))\n # (######, 3, ++++) -> (##########, ) \n elongateT1 = lambda: ( [(l1 + l2, x1)], ())\n # (######, 3, ++++) -> (######, ++++) \n postponeT2 = lambda: ( [t1], t2 )\n\n res = None\n # Zero-length action\n if l2 == 0: \n res = ([t1],())\n # --- Mutate... ------------------------------------------------\n elif x2 == 'M': # 1-to-1 base change\n # Remaining length of the change if this token is done\n if x1 in ['M', 'I']:\n res = absorbT2()\n elif x1 == 'D':\n res = postponeT2()\n elif x1 in ['=', 'X']:\n res = replaceT1()\n # --- Insert... ------------------------------------------------\n elif x2 == 'I':\n if x1 in ['M', '=', 'X']:\n res = insertT2()\n elif x1 == 'I':\n res = elongateT1()\n elif x1 == 'D':\n res = shortenT1()\n # --- Delete... ------------------------------------------------\n elif x2 == 'D':\n if x1 in ['M', '=', 'X']:\n res = replaceT1()\n elif x1 == 'D':\n res = postponeT2()\n elif x1 == 'I':\n res = shortenT1()\n\n assert res != None\n\n filterZeroTokens = lambda r: \\\n ( [ t for t in r[0] if t[0] > 0 ] \n , r[1] if len(r[1]) > 0 and r[1][0] > 0 else () \n )\n return filterZeroTokens(res)","def buffer_before_token(self):\n r = \"\".join(i for i in map(lambda x: x.decode(\"utf-8\"), self.buffer))\n self.buffer = []\n return r","def pad_sequence(self, arr, max_length_tweet):\n # padding a list of indices with 0 until a maximum length (max_length_tweet)\n if max_length_tweet>len(arr):\n trailing_zeros = [0]*(max_length_tweet-len(arr))\n arr.extend(trailing_zeros)\n return arr[:max_length_tweet]","def ids_to_toks(self,ids,remove_pads=True):\n ids = list(ids)\n index = len(ids)\n if remove_pads:\n if self.bom() == ids[0]:\n ids = ids[1:]\n if self.eom() in ids:\n index = ids.index(self.eom())\n if self.pad() in ids and ids.index(self.pad()) < index:\n index = ids.index(self.pad())\n \n return [self._id_to_tok[i] for i in ids[:index]]","def get_dec_inp_targ_seqs(self, sequence, max_len, start_id, stop_id):\n\t\tinp = [start_id] + sequence[:]\n\t\ttarget = sequence[:]\n\t\tif len(inp) > max_len: # truncate\n\t\t\tinp = inp[:max_len]\n\t\t\ttarget = target[:max_len] # no end_token\n\t\telse: # no truncation\n\t\t\ttarget.append(stop_id) # end token\n\t\tassert len(inp) == len(target)\n\t\treturn inp, target","def __UnPad(self, padded):\n pad = ord(padded[-1])\n return padded[:-pad]","def truncate_seq_pair(tokens_a, tokens_b, max_length=509):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _padleft(width, s):\n fmt = \"{0:>%ds}\" % width\n return fmt.format(s)","def create_position_ids_from_input_ids(self, x):\r\n mask = x.ne(self.padding_idx).long()\r\n incremental_indicies = torch.cumsum(mask, dim=1) * mask\r\n return incremental_indicies + self.padding_idx","def adjustl(self):\n s = self._val.lstrip()\n pad_str = self.padding(len(s))\n return s + pad_str","def right_pad(message, pad_to=20, pad_with=' '):\n message = str(message)\n while len(message) < pad_to:\n message = message + pad_with\n return message","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop(0) #For dialogue context\r\n else:\r\n tokens_b.pop()","def convert_single_example(tokenizer, example, max_seq_length=256):\n\n if isinstance(example, PaddingInputExample):\n input_ids = [0] * max_seq_length\n input_mask = [0] * max_seq_length\n segment_ids = [0] * max_seq_length\n label = 0\n return input_ids, input_mask, segment_ids, label\n\n tokens_a = tokenizer.tokenize(example.text_a)\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[0: (max_seq_length - 2)]\n\n tokens = []\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n for token in tokens_a:\n tokens.append(token)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n # print('Tokens', tokens[:3])\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n return input_ids, input_mask, segment_ids, example.label","def pad_question(words,m_word, pad_char):\n return [i+''.join([pad_char]*(m_word-len(i))) for i in words]","def rotate(s, index):\n # we'll have to split the list from index so that we can only rotate the charaters starting after index\n left = s[:index]\n right = s[index:]\n\n # shift each character to the left\n # \"abcd\" => \"bcda\"\n rotated = right[1:]\n #rotated.append(right[0])\n rotated += right[0]\n # merged the rotated and left to form a complete word\n s = left + rotated\n return s","def pad_sequence(sequence, max_length, pad):\n padN = max(max_length - len(sequence), 0)\n result = sequence[:max_length - padN] + [pad] * padN\n return result","def trim_batch(\n input_ids,\n pad_token_id,\n attention_mask=None,\n):\n keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)\n if attention_mask is None:\n return input_ids[:, keep_column_mask]\n else:\n return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])","def _pad_tensors_to_same_length(x, y):\n with tf.compat.v1.name_scope(\"pad_to_same_length\"):\n x_length = tf.shape(input=x)[1]\n y_length = tf.shape(input=y)[1]\n\n max_length = tf.maximum(x_length, y_length)\n\n x = tf.pad(tensor=x, paddings=[[0, 0], [0, max_length - x_length], [0, 0]])\n y = tf.pad(tensor=y, paddings=[[0, 0], [0, max_length - y_length]])\n return x, y","def paddingSequence(X_train, X_test, maxLen=30):\r\n #######equalize list of seq\r\n X_train = pad_sequences(X_train, maxLen, padding='post', truncating='post')\r\n X_test = pad_sequences(X_test, maxLen, padding='post', truncating='post')\r\n return X_train, X_test","def _whitespace_tokenize_with_offsets(self, input_tensor):\n (values, row_splits, start_offsets, end_offsets) = (\n gen_whitespace_tokenizer_v2.tf_text_whitespace_tokenize_with_offsets_v2(\n input_values=input_tensor, input_config=self._config))\n values = RaggedTensor.from_nested_row_splits(\n flat_values=values,\n nested_row_splits=[row_splits])\n start_offsets = RaggedTensor.from_nested_row_splits(\n flat_values=start_offsets,\n nested_row_splits=[row_splits])\n end_offsets = RaggedTensor.from_nested_row_splits(\n flat_values=end_offsets,\n nested_row_splits=[row_splits])\n return (values, start_offsets, end_offsets)","def lws_pad_lr(x, fsize, fshift):\n M = lws_num_frames(len(x), fsize, fshift)\n pad = (fsize - fshift)\n T = len(x) + 2 * pad\n r = (M - 1) * fshift + fsize - T\n return pad, pad + r"],"string":"[\n \"def shift_tokens_right(input_ids, pad_token_id):\\r\\n prev_output_tokens = input_ids.clone()\\r\\n index_of_eos = (input_ids.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)\\r\\n prev_output_tokens[:, 0] = input_ids.gather(1, index_of_eos).squeeze()\\r\\n prev_output_tokens[:, 1:] = input_ids[:, :-1]\\r\\n return prev_output_tokens\",\n \"def shift_tokens_right(self,input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):\\n shifted_input_ids = input_ids.new_zeros(input_ids.shape)\\n shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()\\n shifted_input_ids[:, 0] = decoder_start_token_id\\n\\n assert pad_token_id is not None, \\\"self.model.config.pad_token_id has to be defined.\\\"\\n # replace possible -100 values in labels by `pad_token_id`\\n shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)\\n\\n return shifted_input_ids\",\n \"def shift_tokens_right(input_ids: jnp.array, pad_token_id: int, decoder_start_token_id: int) -> jnp.ndarray:\\n shifted_input_ids = jnp.zeros_like(input_ids)\\n shifted_input_ids = shifted_input_ids.at[:, 1:].set(input_ids[:, :-1])\\n shifted_input_ids = shifted_input_ids.at[:, 0].set(decoder_start_token_id)\\n\\n shifted_input_ids = jnp.where(shifted_input_ids == -100, pad_token_id, shifted_input_ids)\\n return shifted_input_ids\",\n \"def pad_tokens(x, max_length, pad_token_id,\\n truncate_from=\\\"left\\\",\\n pad_from=\\\"left\\\"):\\n assert truncate_from in (\\\"left\\\", \\\"right\\\")\\n assert pad_from in (\\\"left\\\", \\\"right\\\")\\n if len(x) > max_length:\\n if truncate_from == \\\"left\\\":\\n return x[-max_length:]\\n else:\\n return x[:max_length]\\n elif len(x) < max_length:\\n padding = [pad_token_id] * (max_length - len(x))\\n if pad_from == \\\"left\\\":\\n return padding + x\\n else:\\n return x + padding\\n else:\\n return x\",\n \"def shift_right(input, pad=2):\\n return tf.concat((tf.ones_like(input[:, :1]) * pad, input[:, :-1]), 1)\",\n \"def align_tokens(tokens, target_token_index):\\n seq_len = self.seq_len - 2\\n if len(tokens) > seq_len:\\n start_index = max(0, int(target_token_index - seq_len / 2 + middle_shift))\\n start_index = min(start_index, len(tokens) - seq_len)\\n while tokens[start_index].startswith('#') and start_index + seq_len > target_token_index + 1:\\n start_index -= 1\\n start_index = max(0, start_index)\\n tokens = tokens[start_index : start_index + seq_len]\\n target_token_index -= start_index\\n tokens = ['[CLS]', ] + tokens + ['[SEP]', ]\\n target_token_index += 1\\n return tokens, target_token_index\",\n \"def wrap_pad(input, size):\\n M1 = tf.concat([input[:, :, -size[1]:, :], input, input[:, :, 0:size[1], :]], 2)\\n M1 = tf.concat([M1[:, -size[0]:, :, :], M1, M1[:, 0:size[0], :, :]], 1)\\n return M1\",\n \"def unpad(plain):\\n return plain[:-ord(plain[-1])]\",\n \"def truncate_sequences(\\n self,\\n ids: List[int],\\n token_boxes: List[List[int]],\\n pair_ids: Optional[List[int]] = None,\\n pair_token_boxes: Optional[List[List[int]]] = None,\\n labels: Optional[List[int]] = None,\\n num_tokens_to_remove: int = 0,\\n truncation_strategy: Union[str, TruncationStrategy] = \\\"longest_first\\\",\\n stride: int = 0,\\n ) -> Tuple[List[int], List[int], List[int]]:\\n if num_tokens_to_remove <= 0:\\n return ids, token_boxes, pair_ids, pair_token_boxes, labels, [], [], []\\n\\n if not isinstance(truncation_strategy, TruncationStrategy):\\n truncation_strategy = TruncationStrategy(truncation_strategy)\\n\\n overflowing_tokens = []\\n overflowing_token_boxes = []\\n overflowing_labels = []\\n if truncation_strategy == TruncationStrategy.LONGEST_FIRST:\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) > len(pair_ids):\\n if not overflowing_tokens:\\n window_len = min(len(ids), stride + 1)\\n else:\\n window_len = 1\\n overflowing_tokens.extend(ids[-window_len:])\\n overflowing_token_boxes.extend(token_boxes[-window_len:])\\n overflowing_labels.extend(labels[-window_len:])\\n ids = ids[:-1]\\n token_boxes = token_boxes[:-1]\\n labels = labels[:-1]\\n else:\\n if not overflowing_tokens:\\n window_len = min(len(pair_ids), stride + 1)\\n else:\\n window_len = 1\\n overflowing_tokens.extend(pair_ids[-window_len:])\\n overflowing_token_boxes.extend(pair_token_boxes[-window_len:])\\n pair_ids = pair_ids[:-1]\\n pair_token_boxes = pair_token_boxes[:-1]\\n elif truncation_strategy == TruncationStrategy.ONLY_FIRST:\\n if len(ids) > num_tokens_to_remove:\\n window_len = min(len(ids), stride + num_tokens_to_remove)\\n overflowing_tokens = ids[-window_len:]\\n overflowing_token_boxes = token_boxes[-window_len:]\\n overflowing_labels = labels[-window_len:]\\n ids = ids[:-num_tokens_to_remove]\\n token_boxes = token_boxes[:-num_tokens_to_remove]\\n labels = labels[:-num_tokens_to_remove]\\n else:\\n logger.error(\\n f\\\"We need to remove {num_tokens_to_remove} to truncate the input \\\"\\n f\\\"but the first sequence has a length {len(ids)}. \\\"\\n f\\\"Please select another truncation strategy than {truncation_strategy}, \\\"\\n \\\"for instance 'longest_first' or 'only_second'.\\\"\\n )\\n elif truncation_strategy == TruncationStrategy.ONLY_SECOND and pair_ids is not None:\\n if len(pair_ids) > num_tokens_to_remove:\\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\\n overflowing_tokens = pair_ids[-window_len:]\\n overflowing_token_boxes = pair_token_boxes[-window_len:]\\n pair_ids = pair_ids[:-num_tokens_to_remove]\\n pair_token_boxes = pair_token_boxes[:-num_tokens_to_remove]\\n else:\\n logger.error(\\n f\\\"We need to remove {num_tokens_to_remove} to truncate the input \\\"\\n f\\\"but the second sequence has a length {len(pair_ids)}. \\\"\\n f\\\"Please select another truncation strategy than {truncation_strategy}, \\\"\\n \\\"for instance 'longest_first' or 'only_first'.\\\"\\n )\\n\\n return (\\n ids,\\n token_boxes,\\n pair_ids,\\n pair_token_boxes,\\n labels,\\n overflowing_tokens,\\n overflowing_token_boxes,\\n overflowing_labels,\\n )\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def pad_decoder_inp_targ(self, max_len, pad_id):\\n\\t\\twhile len(self.dec_input) < max_len:\\n\\t\\t\\tself.dec_input.append(pad_id)\\n\\t\\twhile len(self.target) < max_len:\\n\\t\\t\\tself.target.append(pad_id)\",\n \"def shift(self, t, word):\\n return t[1:] + (word,)\",\n \"def pad_batch(self, ids):\\r\\n max_len = max([len(x) for x in ids])\\r\\n return [x + [0] * (max_len - len(x)) for x in ids]\",\n \"def shift(t, word):\\n return t[1:] + (word,)\",\n \"def pad_query_input(self, max_len, pad_id):\\n\\t\\twhile len(self.query_input) < max_len:\\n\\t\\t\\tself.query_input.append(pad_id)\",\n \"def pad_encoder_input(self, max_len, pad_id):\\n while len(self.enc_input) < max_len:\\n self.enc_input.append(pad_id)\",\n \"def collate_tokens(\\n values,\\n pad_idx,\\n eos_idx=None,\\n left_pad=False,\\n move_eos_to_beginning=False,\\n pad_to_length=None,\\n pad_to_multiple=1,\\n):\\n size = max(v.size(0) for v in values)\\n size = size if pad_to_length is None else max(size, pad_to_length)\\n if pad_to_multiple != 1 and size % pad_to_multiple != 0:\\n size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple)\\n res = values[0].new(len(values), size).fill_(pad_idx)\\n\\n def copy_tensor(src, dst):\\n assert dst.numel() == src.numel()\\n if move_eos_to_beginning:\\n if eos_idx is None:\\n # if no eos_idx is specified, then use the last token in src\\n dst[0] = src[-1]\\n else:\\n dst[0] = eos_idx\\n dst[1:] = src[:-1]\\n else:\\n dst.copy_(src)\\n\\n for i, v in enumerate(values):\\n copy_tensor(v, res[i][size - len(v):] if left_pad else res[i][:len(v)])\\n return res\",\n \"def _dynamic_padding(self, batch_data, pad_id):\\n pad_p_len = min(self.max_p_len, max(batch_data['passage_length']))\\n pad_q_len = min(self.max_q_len, max(batch_data['question_length']))\\n batch_data['passage_token_ids'] = [(ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\\n for ids in batch_data['passage_token_ids']]\\n batch_data['question_token_ids'] = [(ids + [pad_id] * (pad_q_len - len(ids)))[: pad_q_len]\\n for ids in batch_data['question_token_ids']]\\n return batch_data, pad_p_len, pad_q_len\",\n \"def truncate_sequences(self,\\n ids,\\n pair_ids=None,\\n num_tokens_to_remove=0,\\n truncation_strategy='longest_first',\\n stride=0):\\n if num_tokens_to_remove <= 0:\\n return ids, pair_ids, []\\n\\n if truncation_strategy == 'longest_first':\\n overflowing_tokens = []\\n if pair_ids is None or len(ids) <= len(pair_ids):\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) >= len(pair_ids):\\n overflowing_tokens = [ids[-1]] + overflowing_tokens\\n ids = ids[:-1]\\n else:\\n pair_ids = pair_ids[:-1]\\n window_len = min(len(ids), stride)\\n else:\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) > len(pair_ids):\\n overflowing_tokens = [ids[-1]] + overflowing_tokens\\n ids = ids[:-1]\\n else:\\n pair_ids = pair_ids[:-1]\\n window_len = min(len(ids), stride)\\n if window_len > 0:\\n overflowing_tokens = ids[-window_len:] + overflowing_tokens\\n elif truncation_strategy == 'only_first':\\n assert len(ids) > num_tokens_to_remove\\n window_len = min(len(ids), stride + num_tokens_to_remove)\\n overflowing_tokens = ids[-window_len:]\\n ids = ids[:-num_tokens_to_remove]\\n elif truncation_strategy == 'only_second':\\n assert pair_ids is not None and len(pair_ids) > num_tokens_to_remove\\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\\n overflowing_tokens = pair_ids[-window_len:]\\n pair_ids = pair_ids[:-num_tokens_to_remove]\\n elif truncation_strategy == 'do_not_truncate':\\n raise ValueError(\\n \\\"Input sequence are too long for max_length. Please select a truncation strategy.\\\"\\n )\\n else:\\n raise ValueError(\\n \\\"Truncation_strategy should be selected in ['longest_first', 'only_first', 'only_second', 'do_not_truncate']\\\"\\n )\\n return (ids, pair_ids, overflowing_tokens)\",\n \"def trim_input_ids(input_ids: torch.tensor, pad_token_id, mask_token_id, num_masks: int):\\n assert input_ids.shape[0] == 1\\n input_ids_without_pad = [x for x in input_ids[0] if x != pad_token_id]\\n\\n trimmed_input_ids = []\\n mask_count = 0\\n for input_id in input_ids_without_pad:\\n if input_id == mask_token_id:\\n if mask_count >= num_masks:\\n continue\\n mask_count += 1\\n trimmed_input_ids.append(input_id)\\n\\n return torch.tensor([trimmed_input_ids], dtype=torch.long, device=input_ids.device)\",\n \"def build_inputs_with_special_tokens(\\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\\n ) -> List[int]:\\n\\n if token_ids_1 is None:\\n return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]\\n cls = [self.cls_token_id]\\n sep = [self.sep_token_id]\\n return cls + token_ids_0 + sep + sep + token_ids_1 + sep\",\n \"def normalise_tag_id(input_id):\\n return input_id.replace(\\\" \\\", \\\"\\\").replace(\\\"\\\\n\\\", \\\"\\\").replace(\\\"\\\\r\\\", \\\"\\\")\",\n \"def pad_encoder_input(self, max_sen_len, pad_id):\\n while len(self.enc_input) < max_sen_len:\\n self.enc_input.append(pad_id)\",\n \"def collate_tokens(values, pad_idx, eos_idx, left_pad, move_eos_to_beginning=False, pad_sequence=1):\\n #size = max(v.size(0) for v in values)\\n orig_size = max(v.size(0) for v in values)\\n size = 0\\n if pad_sequence > 1:\\n size = orig_size // pad_sequence * pad_sequence\\n if orig_size % pad_sequence > 0:\\n size += pad_sequence\\n else:\\n size = orig_size\\n res = values[0].new(len(values), size).fill_(pad_idx)\\n\\n def copy_tensor(src, dst):\\n assert dst.numel() == src.numel()\\n if move_eos_to_beginning:\\n assert src[-1] == eos_idx\\n dst[0] = eos_idx\\n dst[1:] = src[:-1]\\n else:\\n dst.copy_(src)\\n\\n for i, v in enumerate(values):\\n copy_tensor(v, res[i][size - len(v):] if left_pad else res[i][:len(v)])\\n return res\",\n \"def cn_whole_word_mask(input_tokens, ref_ids):\\n\\n for i in range(len(input_tokens)):\\n if i in ref_ids:\\n # We move it back by -1 as the ref_ids start at 1, not 0\\n input_tokens[i-1] = \\\"##\\\" + input_tokens[i-1]\\n\\n input_tokens = _whole_word_mask(input_tokens)\\n\\n return input_tokens\",\n \"def pad_seq(seq, max_seq_len=0):\\n if max_seq_len:\\n pad_len = max_seq_len - len(seq)\\n if pad_len > 0:\\n return np.concatenate([seq, np.zeros(pad_len, dtype=np.int64)])\\n elif pad_len < 0: # chop to fit\\n two_last_tokens = seq[-2:]\\n out = seq[:max_seq_len]\\n out[-2:] = two_last_tokens\\n return out.astype(np.int64)\\n return seq.astype(np.int64)\",\n \"def full_tokens(tokens):\\n target_length = roundup2(len(tokens))\\n padding_length = target_length - len(tokens)\\n tokens = [PADDING_TOKEN] * padding_length + tokens\\n return tokens\",\n \"def shift_right(self):\\n self.pointer = (self.pointer + 1) % len(self.data)\",\n \"def remove_pad(x, pad_remover, mode):\\n # Concatenate all tokens (without padding)\\n x = flatten_all_but_last(x)\\n\\n # Remove padding for training and eval\\n if mode != ModeKeys.PREDICT:\\n # This is a hack to allows inference when the <go> token\\n # is detected as padding and removed. This works for now because there is\\n # no padding at inference.\\n x = pad_remover.remove(x)\\n\\n x = tf.expand_dims(x, axis=0) # Now batch_size=1\\n return x\",\n \"def embed_input_ids(\\n self, input_ids: torch.Tensor, next_token_ids: torch.Tensor, prefix_ids: Optional[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\\n batch_size = len(input_ids)\\n if prefix_ids is None:\\n prefix_ids = self.prefix_ids\\n prefix_embedding = self.prefix_embedding\\n \\n else:\\n prefix_embedding = self.token_embedding.forward(prefix_ids)\\n\\n # concatenate preprefix (fixed) + prefix (learned) + example\\n prefix_ids = prefix_ids[None].to(device).repeat((batch_size, 1)).to(device)\\n preprefix_ids = self.preprefix_ids[None].to(device).repeat((batch_size, 1)).to(device)\\n\\n if self.prefix_before_input:\\n full_input_ids = torch.cat(\\n (preprefix_ids, prefix_ids, input_ids, next_token_ids), dim=1\\n )\\n outputs = torch.cat(\\n (\\n self.token_embedding.forward(preprefix_ids),\\n prefix_embedding[None].repeat((batch_size, 1, 1)),\\n self.token_embedding.forward(input_ids),\\n self.token_embedding.forward(next_token_ids),\\n ), dim=1\\n )\\n else:\\n full_input_ids = torch.cat(\\n (input_ids, preprefix_ids, prefix_ids, next_token_ids), dim=1\\n )\\n outputs = torch.cat(\\n (\\n self.token_embedding.forward(input_ids),\\n self.token_embedding.forward(preprefix_ids),\\n prefix_embedding[None].repeat((batch_size, 1, 1)),\\n self.token_embedding.forward(next_token_ids),\\n ), dim=1\\n )\\n return full_input_ids, outputs\",\n \"def padding_input(sents, pad_token=\\\"<pad>\\\", tgt_len=-1):\\n if tgt_len == -1:\\n tgt_len = max(len(s) for s in sents)\\n batch_size = len(sents)\\n seqs = []\\n for i in range(batch_size):\\n seqs.append(sents[i][0:tgt_len] + [pad_token] * (tgt_len - len(sents[i])))\\n return seqs\",\n \"def merged_tokens(self, i, tokenizer):\\n out = []\\n counts = []\\n last_id = None\\n tokens = tokenizer.convert_ids_to_tokens(self.token_ids[i].tolist())\\n for token, current_id in zip(tokens[1:-1], self.conll_ids[i]):\\n if last_id == current_id.item():\\n if token.startswith(\\\"##\\\"):\\n out[-1] += (token[2:])\\n else:\\n out[-1] += token\\n counts[-1] += 1\\n else:\\n out.append(token)\\n counts.append(1)\\n last_id = current_id\\n return out, counts\",\n \"def justify_token(tok, col_width):\\n get_len = tools.display_len if PY3 else len\\n tok_len = get_len(tok)\\n diff_len = tok_len - len(tok) if PY3 else 0\\n\\n cols = (int(math.ceil(float(tok_len) / col_width))\\n if col_width < tok_len + 4 else 1)\\n\\n if cols > 1:\\n return tok.ljust((col_width * cols) + (4 * cols) - diff_len)\\n else:\\n return tok.ljust(col_width + 4 - diff_len)\",\n \"def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):\\n if token_ids_1 is None:\\n return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]\\n _cls = [self.cls_token_id]\\n _sep = [self.sep_token_id]\\n return _cls + token_ids_0 + _sep + _sep + token_ids_1 + _sep\",\n \"def _pad_or_cut_to_max_seq_len(x,\\n max_seq_len):\\n # Shape of x (n_crops, num_patches, c)\\n assert len(tf.shape(x)) == 3\\n # Padding makes sure that # patches > max_seq_length. Note that it also\\n # makes the input mask zero for shorter input.\\n paddings = tf.zeros([tf.shape(x)[0], max_seq_len,\\n tf.shape(x)[-1]],\\n dtype=x.dtype)\\n x = tf.concat([x, paddings], axis=1)\\n # Cuts to max_seq_len number of patches.\\n x = x[:, :max_seq_len, :]\\n return x\",\n \"def _truncate_tokens(tokens_a, tokens_b, max_length):\\n while len(tokens_a) + len(tokens_b) > max_length:\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop(0)\\n else:\\n tokens_b.pop()\\n return tokens_a, tokens_b\",\n \"def _shiftSecrets(cmd, secrets, shift):\\n if secrets:\\n for i in range(len(secrets), 0, -1):\\n cmd = cmd.replace(f':{i+shift-2}:', f':{i+shift-1}:')\\n return cmd\",\n \"def build_tokens_types_paddings_from_ids(text_ids, max_seq_length,\\n cls_id, sep_id, pad_id):\\n enc_ids = []\\n tokentypes_enc = []\\n\\n # [CLS].\\n enc_ids.append(cls_id)\\n tokentypes_enc.append(0)\\n\\n # A.\\n len_src = len(text_ids)\\n enc_ids.extend(text_ids)\\n tokentypes_enc.extend([0] * len_src)\\n\\n # Cap the size.\\n if len(enc_ids) > max_seq_length - 1:\\n enc_ids = enc_ids[0: max_seq_length - 1]\\n tokentypes_enc = tokentypes_enc[0: max_seq_length - 1]\\n\\n # [SEP].\\n enc_ids.append(sep_id)\\n tokentypes_enc.append(0)\\n\\n num_tokens_enc = len(enc_ids)\\n # Padding.\\n padding_length = max_seq_length - len(enc_ids)\\n if padding_length > 0:\\n enc_ids.extend([pad_id] * padding_length)\\n tokentypes_enc.extend([pad_id] * padding_length)\\n\\n pad_mask = ([1] * num_tokens_enc) + ([0] * padding_length)\\n pad_mask = np.array(pad_mask, dtype=np.int64)\\n\\n return enc_ids, tokentypes_enc, pad_mask\",\n \"def __unpad(self, data):\\n return data[0:-ord(data[-1])]\",\n \"def pad_sentence_batch(sentence_batch, pad_int):\\n max_sentence = max([len(sentence) for sentence in sentence_batch])\\n return [sentence + [pad_int] * (max_sentence - len(sentence)) for sentence in sentence_batch]\",\n \"def shift(self, length: int) -> str:\\n result: str = ''\\n total = 0\\n line_pos = 0\\n line_nb_chars = self._line_width - len(os.linesep)\\n while total < length:\\n if self.reminder == 0:\\n return result\\n if line_pos < line_nb_chars:\\n result += self._data[0:1][0]\\n self._data = self._data[1:]\\n if self.reminder == 0:\\n return result\\n total += 1\\n self._current_index += 1\\n line_pos += 1\\n continue\\n result += os.linesep\\n total += len(os.linesep)\\n line_pos = 0\\n return result\",\n \"def make_padded_output_inp_tensor(exs, output_indexer, max_len):\\n return np.array([[ex.y_indexed_inp[i] if i < len(ex.y_indexed_inp) else output_indexer.index_of(PAD_SYMBOL) for i in range(0, max_len)] for ex in exs])\",\n \"def pad_snt(snt_ids_trunc, max_len):\\n\\n snt_ids_trunc_pad = snt_ids_trunc + [PAD_ID] * (max_len - len(snt_ids_trunc))\\n\\n return snt_ids_trunc_pad\",\n \"def pad_encoder_input(self, max_len, pad_id):\\n\\t\\twhile len(self.enc_input) < max_len:\\n\\t\\t\\tself.enc_input.append(pad_id)\\n\\t\\tif self.hps.pointer_gen.value:\\n\\t\\t\\twhile len(self.enc_input_extend_vocab) < max_len:\\n\\t\\t\\t\\tself.enc_input_extend_vocab.append(pad_id)\",\n \"def wrap_pad_rows(x, n=1):\\n out = tf.concat([x[:, -n:, :, :],\\n x,\\n x[:, :n, :, :]], axis=1)\\n\\n return tf.pad(out, [[0, 0], [0, 0], [1, 1], [0, 0]])\",\n \"def tokenize_with_offsets(self, input): # pylint: disable=redefined-builtin\\n name = None\\n with ops.name_scope(name, \\\"WhitespaceTokenize\\\", [input]):\\n input_tensor = ragged_tensor.convert_to_tensor_or_ragged_tensor(input)\\n if input_tensor.shape.ndims is None:\\n raise ValueError(\\\"Rank of input_tensor must be statically known.\\\")\\n if ragged_tensor.is_ragged(input_tensor):\\n if input_tensor.flat_values.shape.ndims > 1:\\n # If the flat_values of our ragged tensor is multi-dimensional, we can\\n # process it separately and our output will have the same nested\\n # splits as our input.\\n (tokens, starts,\\n ends) = self.tokenize_with_offsets(input_tensor.flat_values)\\n return (input_tensor.with_flat_values(tokens),\\n input_tensor.with_flat_values(starts),\\n input_tensor.with_flat_values(ends))\\n else:\\n # Recursively process the values of the ragged tensor.\\n (tokens, starts,\\n ends) = self.tokenize_with_offsets(input_tensor.values)\\n return (input_tensor.with_values(tokens),\\n input_tensor.with_values(starts),\\n input_tensor.with_values(ends))\\n else:\\n if input_tensor.shape.ndims > 1:\\n # Convert the input tensor to ragged and process it.\\n return self.tokenize_with_offsets(\\n ragged_conversion_ops.from_tensor(input_tensor))\\n elif input_tensor.shape.ndims == 0:\\n (tokens, starts, ends) = self.tokenize_with_offsets(\\n array_ops_stack.stack([input_tensor]))\\n return tokens.values, starts.values, ends.values\\n else:\\n # Our rank 1 tensor is the correct shape, so we can process it as\\n # normal.\\n return self._whitespace_tokenize_with_offsets(input_tensor)\",\n \"def index_to_input(X, maxlen_sent, maxlen_doc):\\n X = [pad_sequences(i, maxlen=maxlen_sent, padding='post') for i in X]\\n X = pad_2Dsequences(X, maxlen=maxlen_doc)\\n return X\",\n \"def tokenize(tokenizer, max_length, stride, row):\\r\\n # The input data must be tokenized in the order dictated by the side the\\r\\n # selected checkpoint apply the padding\\r\\n pad_on_right = tokenizer.padding_side == \\\"right\\\"\\r\\n \\r\\n return tokenizer(\\r\\n row[\\\"question\\\" if pad_on_right else \\\"context\\\"],\\r\\n row[\\\"context\\\" if pad_on_right else \\\"question\\\"],\\r\\n max_length=max_length,\\r\\n truncation=\\\"only_second\\\" if pad_on_right else \\\"only_first\\\",\\r\\n return_overflowing_tokens=True,\\r\\n return_offsets_mapping=True,\\r\\n stride=stride,\\r\\n padding=\\\"max_length\\\",\\r\\n )\",\n \"def map_ids_to_tokens(self, ids: List[int], filter_padding=True):\\n tokens = [self.map_id_to_token(id) for id in ids]\\n if filter_padding:\\n tokens = [t for t in tokens if t != self._pad_token]\\n return tokens\",\n \"def _pad_shorter(sequence: str) -> str:\\n return sequence.ljust(3, \\\"X\\\")\",\n \"def move_right(self) -> None:\\n if not self.buffer:\\n return\\n\\n if self.index == self.buffer.end:\\n return\\n\\n if self.buffer[self.index] != '\\\\n':\\n self.index += 1\",\n \"def __rlshift__(self, *args):\\n return _libsbml.string___rlshift__(self, *args)\",\n \"def _dynamic_padding(self, batch_data, pad_id = 0 ):\\n #print 'dynamic _padding...'\\n #print 'pad_id' + str(pad_id)\\n max_p_len = 1000\\n max_q_len =1000\\n pad_p_len = min(max_p_len, max(batch_data['passage_length']))+1\\n #print 'pad_p_len' + str(pad_p_len)\\n pad_q_len = min(max_q_len, max(batch_data['question_length']))\\n #print 'pad_q_len' + str(pad_q_len)\\n #for ids in batch_data['passage_token_ids'] :\\n #print 'padding: '\\n #print (ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\\n batch_data['passage_token_ids'] = [(ids + [pad_id] * (pad_p_len - len(ids)))[: pad_p_len]\\n for ids in batch_data['passage_token_ids']]\\n batch_data['question_token_ids'] = [(ids + [pad_id] * (pad_q_len - len(ids)))[: pad_q_len]\\n for ids in batch_data['question_token_ids']]\\n return batch_data, pad_p_len, pad_q_len\",\n \"def pad_dataset(dataset, padding=0):\\n max_l = max(len(x) for x in dataset[\\\"input_ids\\\"])\\n for name in PADDED_INPUTS:\\n dataset[name] = [x + [padding if name != \\\"lm_labels\\\" else -100] * (max_l - len(x)) for x in dataset[name]]\\n return dataset\",\n \"def right_shift(key,shift):\\n if shift > len(key):\\n shift = shift % len(key)\\n return key[-shift:] + key[:-shift]\",\n \"def _get_token_ids(self, tokens):\\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\\n pad_amount = self.max_seq_length - len(tokens)\\n input_ids = token_ids + [0] * pad_amount\\n return np.array(input_ids)\",\n \"def _truncate_seq_pair(self, tokens_a: str, tokens_b: str, max_length: int):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def pad(input, pad_size):\\n if not pad_size:\\n return input\\n return tf.pad(input, [[0,0],[pad_size, pad_size],[pad_size, pad_size],[0,0]], 'REFLECT')\",\n \"def edit_tokens (input_words):\\n length = len(input_words)\\n for i, w in enumerate(input_words):\\n if (w == \\\"{\\\"):\\n if (i+2 < length):\\n if (input_words[i+2] == \\\"}\\\"):\\n input_words[i:i+3] = [''.join(input_words[i:i+3])]\\n return input_words\",\n \"def _get_token_mask(input_ids: Tensor, pad_token_id: int, sep_token_id: int, cls_token_id: int) ->Tensor:\\n token_mask = input_ids.eq(pad_token_id) | input_ids.eq(sep_token_id) | input_ids.eq(cls_token_id)\\n return ~token_mask\",\n \"def post_forward(self, output):\\n output = output[:2] + (None, )+ output[3:]\\n return output\",\n \"def add_tokens(self, tokens):\\n if self.pad:\\n tokens = [START_OF_SEQ] * self.order + tokens + [END_OF_SEQ]\\n\\n for i in range(len(tokens) - self.order):\\n current_state = tuple(tokens[i:i + self.order])\\n next_state = tokens[i + self.order]\\n self.add_state(current_state, next_state)\",\n \"def pad_sentence_batch(sentence_batch):\\n max_sentence = max([len(sentence) for sentence in sentence_batch])\\n return [sentence + [CODES['<PAD>']] * (max_sentence - len(sentence))\\n for sentence in sentence_batch]\",\n \"def create_token_type_ids_from_sequences(\\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\\n ) -> List[int]:\\n # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method\\n if token_ids_1 is None:\\n # [CLS] X [SEP]\\n return (len(token_ids_0) + 2) * [0]\\n\\n # [CLS] A [SEP] [SEP] B [SEP]\\n return [0] * (len(token_ids_0) + 1) + [1] * (len(token_ids_1) + 3)\",\n \"def pad_model_inputs(input, max_seq_length, pad_value=0): # pylint: disable=redefined-builtin\\n with ops.name_scope(\\\"pad_model_inputs\\\"):\\n # Verify that everything is a RaggedTensor\\n if not isinstance(input, ragged_tensor.RaggedTensor):\\n raise TypeError(\\\"Expecting a `RaggedTensor`, instead found: \\\" +\\n str(input))\\n\\n # Flatten down to `merge_axis`\\n input = input.merge_dims(1, -1) if input.ragged_rank > 1 else input\\n\\n # Pad to fixed Tensor\\n target_shape = math_ops.cast([-1, max_seq_length], dtypes.int64)\\n padded_input = input.to_tensor(shape=target_shape, default_value=pad_value)\\n\\n # Get padded input mask\\n input_mask = array_ops.ones_like(input)\\n padded_input_mask = input_mask.to_tensor(shape=target_shape)\\n\\n return padded_input, padded_input_mask\",\n \"def convert_single_example(tokenizer, example, max_seq_length=512):\\n\\n if isinstance(example, PaddingInputExample):\\n input_ids = [0] * max_seq_length\\n input_mask = [0] * max_seq_length\\n segment_ids = [0] * max_seq_length\\n label = 0\\n return input_ids, input_mask, segment_ids, label\\n\\n tokens_a = tokenizer.tokenize(example.text_a)\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0 : (max_seq_length - 2)]\\n\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n \\n #print(tokens)\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n return input_ids, input_mask, segment_ids, example.label\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def shift(self, el):\\n self.register.pop(0)\\n self.register.append(el)\",\n \"def incr_id(id, n):\\n return id[:-1] + (id[-1] + n,)\",\n \"def int_padding(length, val, direction=\\\">\\\"):\\n return '{0:0{direction}{fill}}'.format(val, direction=direction, fill=length)\",\n \"def pad_batches(self, ids):\\n\\n batches = []\\n for batch_elem_len, batch_sent_ids in zip(self.batch_elem_lengths, self.batch_sent_ids):\\n batch = self.tokenizer.pad_id * np.ones((len(batch_sent_ids), batch_elem_len), dtype=np.int)\\n for i, sentence_idx in enumerate(batch_sent_ids):\\n batch[i][: len(ids[sentence_idx])] = ids[sentence_idx]\\n batches.append(batch)\\n return batches\",\n \"def input_transpose_max_len(sents, pad_token,MAX_LEN):\\n\\n batch_size = len(sents)\\n\\n sents_t = []\\n for i in range(MAX_LEN):\\n sents_t.append([sents[k][i] if len(sents[k]) > i else pad_token for k in range(batch_size)])\\n\\n return sents_t\",\n \"def wrap(self, ind, text, rhs=0):\\n l = 79 - ind * self.indSize - rhs\\n return textwrap.wrap(text, l)\",\n \"def __radd__(self, other):\\n return Token(\\n other + self.text, self.position - len(other), self.category)\",\n \"def rotate(str):\\r\\n return str[-1] + str[0:-1]\",\n \"def _padright(width, s):\\n fmt = \\\"{0:<%ds}\\\" % width\\n return fmt.format(s)\",\n \"def _mutateToken(t1, p, t2):\\n if not isinstance(p, int): \\n raise ValueError(\\\"p must be integer\\\")\\n if(p < 0): \\n raise ValueError(\\\"p may not be smaller than 0\\\")\\n if(p > t1[0]-1): \\n raise ValueError(\\\"p may not be larger than t1 length - 1\\\")\\n\\n x1 = t1[1] # Type of changed token\\n l1 = t1[0] # Length of changed token\\n x2 = t2[1] # Type of change\\n l2 = t2[0] # Length of change\\n q = l1 - p \\n\\n if l2 < 0: \\n raise ValueError(\\\"length of t2 cannot be negative\\\")\\n if x1 in ['S','H'] or x2 in ['S', 'H']:\\n raise ValueError(\\\"CIGAR tokens S (soft-clip) or H (hard-clip) \\\"+\\n \\\"are not supported!\\\")\\n if x1 in ['P', 'N'] or x2 in ['P', 'N']:\\n raise ValueError(\\\"CIGAR tokens P (reference padding) or \\\"+\\n \\\"N (skip reference) are not supported!\\\")\\n\\n # Example: Insertion in MMM \\n # x1 = M, l1 = 12, x2 = I, l2 = 2\\n # p = 5 => q = 7\\n # MMMMMMMMMMMM\\n # └─p─┘└──q──┘ p + q = l1\\n # -> MMMMMIIMMMMMMM\\n\\n # --- Library of different possible function return values\\n # These functions use the variables p, q, l1, l2, x1 and x2.\\n\\n # (######, 3, ++++) -> (##+++,+) (replace per-character)\\n replaceT1 = lambda: ( [ (max(0, p ), x1)\\n , (min(q, l2 ), x2 ) \\n , (max(0, q-l2), x1) ]\\n , (max(0, l2-q), x2) )\\n # (######, 3, ++++) -> (######,+) \\n absorbT2 = lambda: ( [t1], (max(0, l2-q), x2) )\\n # (######, 3, ++++) -> (###++++###, ) \\n insertT2 = lambda: ( [ (max(0, p), x1)\\n , t2\\n , (max(0, q), x1)]\\n , ())\\n # (######, 3, ++++) -> (###, +) \\n shortenT1 = lambda: ( [(p + max(0, q-l2), x1)]\\n , (max(0, l2-q), x2))\\n # (######, 3, ++++) -> (##########, ) \\n elongateT1 = lambda: ( [(l1 + l2, x1)], ())\\n # (######, 3, ++++) -> (######, ++++) \\n postponeT2 = lambda: ( [t1], t2 )\\n\\n res = None\\n # Zero-length action\\n if l2 == 0: \\n res = ([t1],())\\n # --- Mutate... ------------------------------------------------\\n elif x2 == 'M': # 1-to-1 base change\\n # Remaining length of the change if this token is done\\n if x1 in ['M', 'I']:\\n res = absorbT2()\\n elif x1 == 'D':\\n res = postponeT2()\\n elif x1 in ['=', 'X']:\\n res = replaceT1()\\n # --- Insert... ------------------------------------------------\\n elif x2 == 'I':\\n if x1 in ['M', '=', 'X']:\\n res = insertT2()\\n elif x1 == 'I':\\n res = elongateT1()\\n elif x1 == 'D':\\n res = shortenT1()\\n # --- Delete... ------------------------------------------------\\n elif x2 == 'D':\\n if x1 in ['M', '=', 'X']:\\n res = replaceT1()\\n elif x1 == 'D':\\n res = postponeT2()\\n elif x1 == 'I':\\n res = shortenT1()\\n\\n assert res != None\\n\\n filterZeroTokens = lambda r: \\\\\\n ( [ t for t in r[0] if t[0] > 0 ] \\n , r[1] if len(r[1]) > 0 and r[1][0] > 0 else () \\n )\\n return filterZeroTokens(res)\",\n \"def buffer_before_token(self):\\n r = \\\"\\\".join(i for i in map(lambda x: x.decode(\\\"utf-8\\\"), self.buffer))\\n self.buffer = []\\n return r\",\n \"def pad_sequence(self, arr, max_length_tweet):\\n # padding a list of indices with 0 until a maximum length (max_length_tweet)\\n if max_length_tweet>len(arr):\\n trailing_zeros = [0]*(max_length_tweet-len(arr))\\n arr.extend(trailing_zeros)\\n return arr[:max_length_tweet]\",\n \"def ids_to_toks(self,ids,remove_pads=True):\\n ids = list(ids)\\n index = len(ids)\\n if remove_pads:\\n if self.bom() == ids[0]:\\n ids = ids[1:]\\n if self.eom() in ids:\\n index = ids.index(self.eom())\\n if self.pad() in ids and ids.index(self.pad()) < index:\\n index = ids.index(self.pad())\\n \\n return [self._id_to_tok[i] for i in ids[:index]]\",\n \"def get_dec_inp_targ_seqs(self, sequence, max_len, start_id, stop_id):\\n\\t\\tinp = [start_id] + sequence[:]\\n\\t\\ttarget = sequence[:]\\n\\t\\tif len(inp) > max_len: # truncate\\n\\t\\t\\tinp = inp[:max_len]\\n\\t\\t\\ttarget = target[:max_len] # no end_token\\n\\t\\telse: # no truncation\\n\\t\\t\\ttarget.append(stop_id) # end token\\n\\t\\tassert len(inp) == len(target)\\n\\t\\treturn inp, target\",\n \"def __UnPad(self, padded):\\n pad = ord(padded[-1])\\n return padded[:-pad]\",\n \"def truncate_seq_pair(tokens_a, tokens_b, max_length=509):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _padleft(width, s):\\n fmt = \\\"{0:>%ds}\\\" % width\\n return fmt.format(s)\",\n \"def create_position_ids_from_input_ids(self, x):\\r\\n mask = x.ne(self.padding_idx).long()\\r\\n incremental_indicies = torch.cumsum(mask, dim=1) * mask\\r\\n return incremental_indicies + self.padding_idx\",\n \"def adjustl(self):\\n s = self._val.lstrip()\\n pad_str = self.padding(len(s))\\n return s + pad_str\",\n \"def right_pad(message, pad_to=20, pad_with=' '):\\n message = str(message)\\n while len(message) < pad_to:\\n message = message + pad_with\\n return message\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop(0) #For dialogue context\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def convert_single_example(tokenizer, example, max_seq_length=256):\\n\\n if isinstance(example, PaddingInputExample):\\n input_ids = [0] * max_seq_length\\n input_mask = [0] * max_seq_length\\n segment_ids = [0] * max_seq_length\\n label = 0\\n return input_ids, input_mask, segment_ids, label\\n\\n tokens_a = tokenizer.tokenize(example.text_a)\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[0: (max_seq_length - 2)]\\n\\n tokens = []\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n for token in tokens_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n # print('Tokens', tokens[:3])\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n return input_ids, input_mask, segment_ids, example.label\",\n \"def pad_question(words,m_word, pad_char):\\n return [i+''.join([pad_char]*(m_word-len(i))) for i in words]\",\n \"def rotate(s, index):\\n # we'll have to split the list from index so that we can only rotate the charaters starting after index\\n left = s[:index]\\n right = s[index:]\\n\\n # shift each character to the left\\n # \\\"abcd\\\" => \\\"bcda\\\"\\n rotated = right[1:]\\n #rotated.append(right[0])\\n rotated += right[0]\\n # merged the rotated and left to form a complete word\\n s = left + rotated\\n return s\",\n \"def pad_sequence(sequence, max_length, pad):\\n padN = max(max_length - len(sequence), 0)\\n result = sequence[:max_length - padN] + [pad] * padN\\n return result\",\n \"def trim_batch(\\n input_ids,\\n pad_token_id,\\n attention_mask=None,\\n):\\n keep_column_mask = input_ids.ne(pad_token_id).any(dim=0)\\n if attention_mask is None:\\n return input_ids[:, keep_column_mask]\\n else:\\n return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])\",\n \"def _pad_tensors_to_same_length(x, y):\\n with tf.compat.v1.name_scope(\\\"pad_to_same_length\\\"):\\n x_length = tf.shape(input=x)[1]\\n y_length = tf.shape(input=y)[1]\\n\\n max_length = tf.maximum(x_length, y_length)\\n\\n x = tf.pad(tensor=x, paddings=[[0, 0], [0, max_length - x_length], [0, 0]])\\n y = tf.pad(tensor=y, paddings=[[0, 0], [0, max_length - y_length]])\\n return x, y\",\n \"def paddingSequence(X_train, X_test, maxLen=30):\\r\\n #######equalize list of seq\\r\\n X_train = pad_sequences(X_train, maxLen, padding='post', truncating='post')\\r\\n X_test = pad_sequences(X_test, maxLen, padding='post', truncating='post')\\r\\n return X_train, X_test\",\n \"def _whitespace_tokenize_with_offsets(self, input_tensor):\\n (values, row_splits, start_offsets, end_offsets) = (\\n gen_whitespace_tokenizer_v2.tf_text_whitespace_tokenize_with_offsets_v2(\\n input_values=input_tensor, input_config=self._config))\\n values = RaggedTensor.from_nested_row_splits(\\n flat_values=values,\\n nested_row_splits=[row_splits])\\n start_offsets = RaggedTensor.from_nested_row_splits(\\n flat_values=start_offsets,\\n nested_row_splits=[row_splits])\\n end_offsets = RaggedTensor.from_nested_row_splits(\\n flat_values=end_offsets,\\n nested_row_splits=[row_splits])\\n return (values, start_offsets, end_offsets)\",\n \"def lws_pad_lr(x, fsize, fshift):\\n M = lws_num_frames(len(x), fsize, fshift)\\n pad = (fsize - fshift)\\n T = len(x) + 2 * pad\\n r = (M - 1) * fshift + fsize - T\\n return pad, pad + r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8174382","0.7355779","0.730172","0.62766033","0.5987434","0.59027076","0.5735923","0.5567176","0.5503809","0.54715633","0.54715633","0.54715633","0.5460714","0.54170334","0.5338661","0.53169227","0.52875674","0.52819985","0.5207631","0.51908386","0.5179993","0.5175452","0.5173635","0.51706654","0.5155161","0.5131358","0.51284117","0.50838935","0.5081181","0.50639814","0.50419235","0.5041287","0.5011617","0.50095433","0.5006825","0.5002506","0.4987728","0.49789506","0.49507475","0.49503708","0.494609","0.4937291","0.49281597","0.49141747","0.49141544","0.48966452","0.48956236","0.48812407","0.4859949","0.48572347","0.48559362","0.48418215","0.48407698","0.48299038","0.48278546","0.48232383","0.4810538","0.48065215","0.47957","0.47758672","0.47630677","0.47626835","0.47467834","0.4746765","0.47462365","0.47415942","0.4740357","0.47400436","0.4738388","0.4738388","0.47198522","0.4717472","0.47171545","0.47138038","0.47074524","0.47031662","0.46884125","0.46829575","0.46790132","0.46790126","0.4678459","0.4673649","0.46728945","0.46651998","0.46588972","0.46522677","0.46507627","0.46408543","0.46395737","0.46344265","0.4629787","0.46283156","0.46150216","0.46139523","0.46134818","0.4604116","0.46028292","0.4599487","0.45984864","0.4589603"],"string":"[\n \"0.8174382\",\n \"0.7355779\",\n \"0.730172\",\n \"0.62766033\",\n \"0.5987434\",\n \"0.59027076\",\n \"0.5735923\",\n \"0.5567176\",\n \"0.5503809\",\n \"0.54715633\",\n \"0.54715633\",\n \"0.54715633\",\n \"0.5460714\",\n \"0.54170334\",\n \"0.5338661\",\n \"0.53169227\",\n \"0.52875674\",\n \"0.52819985\",\n \"0.5207631\",\n \"0.51908386\",\n \"0.5179993\",\n \"0.5175452\",\n \"0.5173635\",\n \"0.51706654\",\n \"0.5155161\",\n \"0.5131358\",\n \"0.51284117\",\n \"0.50838935\",\n \"0.5081181\",\n \"0.50639814\",\n \"0.50419235\",\n \"0.5041287\",\n \"0.5011617\",\n \"0.50095433\",\n \"0.5006825\",\n \"0.5002506\",\n \"0.4987728\",\n \"0.49789506\",\n \"0.49507475\",\n \"0.49503708\",\n \"0.494609\",\n \"0.4937291\",\n \"0.49281597\",\n \"0.49141747\",\n \"0.49141544\",\n \"0.48966452\",\n \"0.48956236\",\n \"0.48812407\",\n \"0.4859949\",\n \"0.48572347\",\n \"0.48559362\",\n \"0.48418215\",\n \"0.48407698\",\n \"0.48299038\",\n \"0.48278546\",\n \"0.48232383\",\n \"0.4810538\",\n \"0.48065215\",\n \"0.47957\",\n \"0.47758672\",\n \"0.47630677\",\n \"0.47626835\",\n \"0.47467834\",\n \"0.4746765\",\n \"0.47462365\",\n \"0.47415942\",\n \"0.4740357\",\n \"0.47400436\",\n \"0.4738388\",\n \"0.4738388\",\n \"0.47198522\",\n \"0.4717472\",\n \"0.47171545\",\n \"0.47138038\",\n \"0.47074524\",\n \"0.47031662\",\n \"0.46884125\",\n \"0.46829575\",\n \"0.46790132\",\n \"0.46790126\",\n \"0.4678459\",\n \"0.4673649\",\n \"0.46728945\",\n \"0.46651998\",\n \"0.46588972\",\n \"0.46522677\",\n \"0.46507627\",\n \"0.46408543\",\n \"0.46395737\",\n \"0.46344265\",\n \"0.4629787\",\n \"0.46283156\",\n \"0.46150216\",\n \"0.46139523\",\n \"0.46134818\",\n \"0.4604116\",\n \"0.46028292\",\n \"0.4599487\",\n \"0.45984864\",\n \"0.4589603\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81405616"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":10795,"cells":{"query":{"kind":"string","value":"Visualizes in a pyplot window an image and a label pair from provided paths. For reading files, Pillow is used so all paths and formats must be Pillowcompatible. The task definition is used to define colors for label ids (see panoptic_parts/utils/defs/template_v1.0.yaml)."},"document":{"kind":"string","value":"def visualize_from_paths(image_path, label_path, task_def_path):\n # sid2color is a mapping from all possible sids to colors\n with open(task_def_path) as fp:\n task_def = yaml.load(fp, Loader=yaml.Loader)\n sid2color = task_def['sid2color']\n # add colors for all sids that may exist in labels, but don't have a color from task_def\n sid2color.update({sid: sid2color[-1] # we use the void color here\n for sid in range(task_def['max_sid'])\n if not (sid in task_def['valid_sids'] or sid in sid2color)})\n\n # reduce resolution for faster execution\n image = Image.open(image_path)\n label = Image.open(label_path)\n uids = np.array(label, dtype=np.int32)\n\n # optionally transform parts ids\n # here we trasform the pids from the original dataset to another set of pids according\n # to sid2pids_groups, where parts for some scene-level semantic classes are grouped\n # TODO(panos): consider moving this functionality to colorize_label\n if 'sid2pids_groups' in task_def.keys():\n uids = _transform_uids(uids, task_def['max_sid'], task_def['sid2pids_groups'])\n\n # create the colorized label images\n uids_sem_inst_parts_colored, uids_sem_colored, uids_sem_inst_colored = \\\n experimental_colorize_label(uids,\n sid2color=sid2color,\n return_sem=True,\n return_sem_inst=True,\n emphasize_instance_boundaries=True)\n\n # plot\n # initialize figure for plotting\n _, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)\n # for ax in axes:\n # ax.set_axis_off()\n ax1.imshow(image)\n ax1.set_title('image')\n ax2.imshow(uids_sem_colored)\n ax2.set_title('labels colored on semantic level')\n ax3.imshow(uids_sem_inst_colored)\n ax3.set_title('labels colored on semantic and instance levels')\n ax4.imshow(uids_sem_inst_parts_colored)\n ax4.set_title('labels colored on semantic, instance, and parts levels')\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_oneshot_task(pairs):\n fig,(ax1,ax2) = plt.subplots(2)\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\n img = concat_images(pairs[1])\n ax1.get_yaxis().set_visible(False)\n ax1.get_xaxis().set_visible(False)\n ax2.matshow(img,cmap='gray')\n plt.xticks([])\n plt.yticks([])\n plt.show()","def run_path_visualisation(paths, config, modulesConfig):\n all_targets = [os.path.basename(config[s][\"target\"]) for s in config.sections]\n all_target_tasks = {os.path.basename(config[s][\"target\"]):s for s in config.sections}\n \n added_tasks = []\n prepared_paths = []\n for path in paths:\n prepared_tasks = []\n for idx, task in enumerate(list(reversed(path))):\n s_module, s_name, *identifier = task.split(\" \")\n\n # Special Rule For Join Module To Have A Connection To Another Module\n special_connection = False\n if s_module == \"processing_join\":\n args = config[task]\n con_module, con_name, *identifier = all_target_tasks.get(os.path.basename(args[\"joinwith\"]), s_module+\"_SPECIAL \"+s_name+\"_SPECIAL\").split(\" \")\n special_connection = {\n \"connection_to_module\" : con_module,\n \"connection_to_name\" : con_name,\n \"will_be_created\" : (os.path.basename(args[\"joinwith\"]) in all_targets)\n }\n\n prepared_tasks.append({\n 'module':s_module,\n 'name':s_name,\n 'display': (task not in added_tasks),\n 'specialConnection': special_connection,\n 'last': (idx == len(path) - 1),\n 'attributes': config[task]\n })\n added_tasks.append(task)\n prepared_paths.append(prepared_tasks)\n logger.debug(\"Path prepared for visualization!\")\n render_path_visualisation(config['projectRoot'], config['projectName'], prepared_paths)","def plot12(self, dataset, ts_string_indices, source_jpg_folder='jpg_images', extension='jpg', rows=3, cols=4,\n outfname='Sample Frames.png', cmap=None, gui_color='green'):\n # Settings ############################################################\n font_label_box = {\n 'color': 'green',\n 'size': 16,\n }\n font_steering = {'family': 'monospace',\n # 'color': 'darkred',\n 'weight': 'normal',\n 'size': 20,\n }\n ROWS = rows\n COLS = cols\n NUM_IMAGES = ROWS * COLS\n\n # Figure ##############################################################\n # figsize = [width, height]\n fig = plt.figure(figsize=PAPER_A3_LAND, facecolor='white')\n fig.suptitle(\"Sample frames, Dataset: {}\".format(dataset.data_folder), fontsize=20)\n\n for i, ts_string_index in enumerate(ts_string_indices):\n rec = dataset.df.loc[ts_string_index]\n\n timestamp_string = rec['datetime'].strftime(\"%D %H:%M:%S.\") + \"{:.2}\".format(\n str(rec['datetime'].microsecond))\n\n if 'steering_pred_signal' in dataset.df.columns:\n this_label = \"{}\\n{:0.2f}/{:0.2f} steering \\n{:0.2f} throttle\".format(timestamp_string,\n rec['steering_signal'],\n rec['steering_pred_signal'],\n rec['throttle_signal'])\n else:\n this_label = \"{}\\n{:0.2f}/ steering \\n{:0.2f} throttle\".format(timestamp_string, rec['steering_signal'],\n rec['throttle_signal'])\n\n ax = fig.add_subplot(ROWS, COLS, i + 1)\n\n # Main Image ##########################################################\n jpg_path = os.path.join(dataset.path_dataset, source_jpg_folder, ts_string_index + '.' + extension)\n assert os.path.exists(jpg_path), \"{} does not exist\".format(jpg_path)\n img = mpl.image.imread(jpg_path)\n ax.imshow(img, cmap=cmap)\n # plt.title(str_label)\n\n # Data box ########################################################\n\n # ax.axes.get_xaxis().set_visible(False)\n # ax.axes.get_yaxis().set_visible(False)\n t = ax.text(5, 25, this_label, color=gui_color, alpha=1)\n # t = plt.text(0.5, 0.5, 'text', transform=ax.transAxes, fontsize=30)\n t.set_bbox(dict(facecolor='white', alpha=0.7, edgecolor='none'))\n\n # Steering widget HUD #################################################\n # Steering HUD: Actual steering signal\n steer_actual = ''.join(['|' if v else '-' for v in dataset.linear_bin(rec['steering_signal'])])\n text_steer = ax.text(80, 105, steer_actual, fontdict=font_steering, horizontalalignment='center',\n verticalalignment='center', color=gui_color)\n # Steering HUD: Predicted steering angle\n if 'steering_pred_signal' in dataset.df.columns:\n steer_pred = ''.join(['◈' if v else ' ' for v in dataset.linear_bin(rec['steering_pred_signal'])])\n text_steer_pred = ax.text(80, 95, steer_pred, fontdict=font_steering, horizontalalignment='center',\n verticalalignment='center', color='red')\n\n outpath = os.path.join(dataset.path_dataset, outfname)\n fig.savefig(outpath)\n logging.debug(\"Wrote Sample Frames figure to {}\".format(outpath))","def _convert_path_list_to_images_and_labels(self, path_list, is_one_shot_task):\n number_of_pairs = int(len(path_list) / 2)\n pairs_of_images = [np.zeros(\n (number_of_pairs, self.image_height, self.image_height, 1)) for i in range(2)]\n labels = np.zeros((number_of_pairs, 1))\n\n for pair in range(number_of_pairs):\n image = Image.open(path_list[pair * 2])\n image = np.asarray(image).astype(np.float64)\n image = image / image.std() - image.mean()\n\n pairs_of_images[0][pair, :, :, 0] = image\n image = Image.open(path_list[pair * 2 + 1])\n image = np.asarray(image).astype(np.float64)\n image = image / image.std() - image.mean()\n\n pairs_of_images[1][pair, :, :, 0] = image\n if not is_one_shot_task:\n if (pair + 1) % 2 == 0:\n labels[pair] = 0\n else:\n labels[pair] = 1\n\n else:\n if pair == 0:\n labels[pair] = 1\n else:\n labels[pair] = 0\n\n if not is_one_shot_task:\n random_permutation = np.random.permutation(number_of_pairs)\n labels = labels[random_permutation]\n pairs_of_images[0][:, :, :,\n :] = pairs_of_images[0][random_permutation, :, :, :]\n pairs_of_images[1][:, :, :,\n :] = pairs_of_images[1][random_permutation, :, :, :]\n\n return pairs_of_images, labels","def makeGanttChart(mode, fileName):\n\n figType = OUTPUT_FILE_EXTENSION # \"png\", \"eps\"\n\n # extract the figure name and target directory (to store the figures)\n figureFileName = fileName[0:-6]\n k = figureFileName.rfind(\"/\") + 1\n figureFileName = figureFileName[k:]\n k = fileName.rfind(\"/\") + 1\n targetDirectory = \"\"\n if k == 0:\n targetDirectory = \"./\"\n else:\n targetDirectory = fileName[0:k]\n targetFname = targetDirectory + figureFileName + \".\" + figType\n\n # import the tasks\n tasks = parseTasks(mode, fileName)\n machines = sorted(getMachines(tasks))\n orders = sorted(getOrders(tasks))\n processingUnits = sorted(getProccessingUnits(tasks))\n operations = sorted(getOperations(tasks))\n\n if mode == \"MTS\":\n tasks = consolidateSiblingTasks(tasks, machines)\n tasks = removeDuplicateTasks(tasks)\n if checkForOverlappingTasks(tasks, machines):\n print(\"ERROR! Found overlapping tasks, check your input file!\")\n exit(5)\n\n # Print all of the read tasks in DEBUG mode\n if MYDEBUG:\n for t in tasks:\n t.print()\n\n # build the figure\n fig = plt.figure(figsize=(10, 5), dpi=DPI) # <------ USER OPTION HERE -----------------\n ax = fig.add_subplot(111)\n ax.set_title(figureFileName)\n\n # set up the axes\n y_pos = np.arange(len(machines))\n ax.set_yticks(y_pos)\n ax.set_ylim(min(y_pos) - 0.7, max(y_pos) + 0.7)\n ax.set_yticklabels(machines)\n ax.set_xlabel(\"Time (Hours)\")\n x_pos = np.arange(math.ceil(getMakeSpan(tasks))+1)\n ax.set_xticks(x_pos)\n ax.set_axisbelow(True)\n ax.grid(b=True, which=\"major\", axis=\"x\", alpha=0.5)\n\n # assign a unique color to each order and each operation\n # http://matplotlib.org/examples/color/colormaps_reference.html\n cmapOrders = plt.cm.Pastel2(np.linspace(0, 1, len(orders)))\n cmapOperations = plt.cm.Pastel2(np.linspace(0, 1, len(operations)))\n\n # plot the task rectangles\n # https://stackoverflow.com/questions/21397549/stack-bar-plot-in-matplotlib-and-add-label-to-each-section-and-suggestions\n for i, m in enumerate(machines):\n compatibleTasks = []\n for t in tasks:\n if m == t.machine:\n compatibleTasks.append(t)\n slots = [] # time slots for machine m\n for ct in compatibleTasks:\n for ct in compatibleTasks:\n thisSlot = (ct.tBegin, ct.tEnd)\n if thisSlot not in slots:\n slots.append(thisSlot)\n slots = sorted(slots)\n if mode == \"SCH\":\n for s, slt in enumerate(slots):\n thisBatchSize = \"\"\n thisOperation = \"\"\n for ct in compatibleTasks:\n if (ct.tBegin, ct.tEnd) == slt:\n thisBatchSize = ct.batchSize\n thisOperation = ct.operation\n thisColor = cmapOperations[operations.index(thisOperation)]\n h = ax.barh(i, width=slots[s][1]-slots[s][0], left=slots[s][0], align='center', color=thisColor)\n bl = h[0].get_xy()\n x = 0.5*h[0].get_width() + bl[0]\n y = 0.5*h[0].get_height() + bl[1]\n ax.text(x, y, str(thisBatchSize), ha='center',va='center')\n elif mode == \"MTS\":\n for s, slt in enumerate(slots):\n # Get the MAIN task corresponding to the current time slot\n currentTask = 0\n for ct in compatibleTasks:\n if (ct.tBegin, ct.tEnd) == slt:\n currentTask = ct\n # Plot the unique task\n if len(currentTask.subtasks) == 0:\n duration = slots[s][1]-slots[s][0]\n thisColor = cmapOrders[orders.index(currentTask.order)]\n\n h = []\n h.append(ax.barh(i, width=duration, left=slots[s][0], align='center', color=\"grey\", alpha=0.7))\n h.append(ax.barh(i, width=duration - 2*MARGIN, left=slots[s][0] + MARGIN, align='center',\n color=thisColor, height=0.65, linewidth=0))\n bl = h[0][0].get_xy()\n x = 0.5*h[0][0].get_width() + bl[0]\n y = 0.5*h[0][0].get_height() + bl[1]\n thisBatchSize = currentTask.batchSize\n ax.text(x, y, str(thisBatchSize), ha='center',va='center', size=LABEL_SIZE)\n else:\n # Plot first the MAIN task\n duration = slots[s][1]-slots[s][0]\n barHandles = []\n barHandles.append(ax.barh(i, width=duration, left=slots[s][0],\n align='center', color=\"grey\", alpha=0.7))\n bl = barHandles[0][0].get_xy()\n l = slots[s][0] + MARGIN\n # Plot the SUB tasks\n for counter, thisSub in enumerate(currentTask.subtasks):\n thisColor = cmapOrders[orders.index(thisSub.order)]\n partialDuration = (thisSub.batchSize/currentTask.batchSize) * duration - \\\n 2*MARGIN/len(currentTask.subtasks)\n barHandles.append(ax.barh(i, width=partialDuration, left=l, align='center', height=0.65, linewidth=0,\n color=thisColor))\n bl = barHandles[-1][0].get_xy()\n x = 0.5*barHandles[-1][0].get_width() + bl[0]\n y = 0.5*barHandles[-1][0].get_height() + bl[1]\n thisBatchSize = thisSub.batchSize\n ax.text(x, y, str(thisBatchSize), ha='center',va='center', size=LABEL_SIZE)\n l = l + partialDuration\n else:\n print(\"INVALID MODE\")\n exit(5)\n\n # Show / print the figure\n fig.savefig(targetFname, dpi=DPI)\n # if MYDEBUG:\n # plt.show()\n plt.clf()\n plt.close()\n\n\n # plot a legend (print in different file)\n if PLOT_LEGENDS:\n if mode == \"SCH\":\n pat = []\n leg = plt.figure(figsize=(5, 5), dpi=DPI)\n frame = plt.gca()\n frame.axes.get_xaxis().set_visible(False)\n frame.axes.get_yaxis().set_visible(False)\n leg.patch.set_visible(False)\n for op in operations:\n thisColor = cmapOperations[operations.index(op)]\n pat.append(mpatches.Patch(color=thisColor, label=op))\n plt.legend(handles=pat)\n leg.savefig(targetDirectory + figureFileName + \"_legend.\" + figType, dpi=DPI)\n elif mode == \"MTS\":\n pat = []\n leg = plt.figure(figsize=(5, 5), dpi= DPI)\n frame = plt.gca()\n frame.axes.get_xaxis().set_visible(False)\n frame.axes.get_yaxis().set_visible(False)\n leg.patch.set_visible(False)\n for ord in orders:\n thisColor = cmapOrders[orders.index(ord)]\n pat.append(mpatches.Patch(color=thisColor, label=ord))\n plt.legend(handles=pat)\n leg.savefig(targetDirectory + figureFileName + \"_legend.\" + figType, dpi=DPI)\n else:\n print(\"INVALID MODE\")\n exit(5)","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def _load_img_label(self):\n name = self._launch_file_b()\n self._img_label.configure(text=name)","def plots_from_files(imspaths, figsize=(10,5), rows=1, titles=None, maintitle=None):\n f = plt.figure(figsize=figsize)\n if maintitle is not None:\n plt.suptitle(maintitle, fontsize=16) \n for i in range(len(imspaths)):\n sp = f.add_subplot(rows, len(imspaths)//rows, i+1)\n sp.axis('Off')\n if titles is not None: sp.set_title(titles[i], fontsize=16)\n img = plt.imread(imspaths[i])\n plt.imshow(img)","def draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list):\n img_path=os.path.join(root_folder_path,root_folder_name,img_type,img_name+\".png\")\n img=cv2.imread(img_path)\n for each_bb in bb_list:\n cv2.rectangle(img,(each_bb[0],each_bb[2]),(each_bb[1],each_bb[3]),bb_color,3)\n cv2.putText(img,class_name,(each_bb[0],each_bb[3]),cv2.FONT_HERSHEY_SIMPLEX,1,(255,0,0),2,cv2.LINE_AA)\n cv2.imwrite(img_path,img)","def plot_images(imgs, lbls=None, cols=4, rows=5, save_path=None):\n # numpy array to list\n if not type(imgs) is list:\n imgs = list(imgs)\n # 1. check if the parameters are correct\n assert(len(imgs) == cols*rows)\n if not lbls is None:\n assert(len(lbls) == len(imgs))\n\n # 2. create the figure\n fig = plt.figure()\n\n # 3. iterate over the rows and cols\n for i in range(1, cols*rows + 1):\n # add the next subplot\n fig.add_subplot(rows, cols, i)\n # plot the image\n plt.imshow(imgs[i-1])\n # check if a lbls list is specified\n if not lbls is None:\n # show the lbl of the image\n plt.title(lbls[i-1])\n plt.tight_layout(pad=0.6)\n\n if not save_path is None:\n plt.savefig(save_path)\n else: \n plt.show()","def read_files_and_visualize(data):\n\n image = cv2.imread(data[0])\n label = cv2.imread(data[1], 0)\n name = data[1].split('/')[-1].split('.')[0]\n obj_label = None\n\n if generator_options.save_label_preview:\n obj_label = []\n if os.path.isfile(data[2]):\n with open(data[2], 'r') as f:\n obj = csv.reader(f, delimiter=',')\n for row in obj:\n row = [int(r.split('.')[0]) if index != 0 else r\n for index, r in enumerate(row)]\n obj_label.append(row)\n\n else:\n label_vals = np.unique(label)\n for val in label_vals:\n obj_label.append([_LABEL_DEF_FULL[val], 0, 0, 0, 0])\n\n save_visuals(image, label, obj_label, name)","def load_imgsLabels(self, image_paths):\n \n# label = image_paths[-1]\n \n images = self.load_images(image_paths)\n \n images = self.resize_images(images)\n \n images_list = self.greyscale_images(images)\n\n return images_list","def get_path_image(path_data, label, filename):\n\n return path_data.joinpath(f'label_{label}', filename)","def work(q, example_paths, label_paths, total_files, export_path_example, export_path_label, size, layover, input_size):\n\n while not q.empty():\n try:\n i = q.get(False)\n except Empty:\n break\n\n # Show progress\n utils.print_process(total_files - q.qsize(), total_files)\n\n # We assume that related examples and labels have the same index in the path lists\n example_path = example_paths[i]\n label_path = label_paths[i]\n\n # Creates masks for the image pairs\n mask_image(example_path, export_path_example, size, layover, input_size)\n mask_image(label_path, export_path_label, size, layover, input_size)\n\n q.task_done()","def plot_labels(lbl: scipy.ndarray, lbl_count: int) -> None:\n color_map = scipy.rand(lbl_count, 3)\n color_map = matplotlib.colors.ListedColormap(color_map)\n plt.imshow(lbl, cmap=color_map)\n plt.show()","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def plot_image(img, label=\"\"): \n if img.shape[0] == 3:\n img = img.transpose(1,2,0)\n fig,ax = plt.subplots(1)\n sns.set_style('white')\n ax.imshow(np.asarray(img))\n if label!=\"\":\n plt.title(number_label[label])\n return fig,ax","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def plotImages(image_list, name_list, path, as_grey, toSave=False):\n\n\tfig = plt.figure()\n\timageCoordinate = 100 + 10*len(image_list) + 1\n\ti = 0\n\n\tfor image in image_list:\n\t\tfig.add_subplot(imageCoordinate)\n\t\tplt.title(name_list[i])\n\t\tplt.axis('off')\n\t\tplt.imshow(image)\n\t\tif as_grey:\n\t\t\tplt.set_cmap('gray')\n\n\t\timageCoordinate += 1\n\t\ti += 1\n\n\tif toSave:\n\t\tplt.savefig(path + \".jpg\",bbox_inches='tight')\n\tplt.show()","def plot_list_image_path(list_image_path, log_image_path=False):\n i = 1\n nb_img = len(list_image_path)\n plt.figure(figsize=(10, 2 * nb_img))\n for image_path in list_image_path:\n if not os.path.isfile(image_path):\n continue\n img = load_img(image_path)\n plt.subplot(math.ceil(nb_img/3) + 1, 3, i)\n i += 1\n if log_image_path:\n plt.title(image_path)\n plt.imshow(img)\n plt.axis('off')\n plt.show()","def _plot_imgs_and_ctrs_np(self, config) -> None:\n imgs = config['imgs']\n ctrs = config['ctrs']\n orig_slices = config['slices']\n plane = config['plane']\n title = config['title']\n draw_only_ctrs = config['draw_only_ctrs']\n file_name_prefix = config['file_name_prefix']\n labels = config['labels']\n\n create_folder(self._output_folder)\n if plane != PlaneTypes.ALL: # Draw single plane\n # This should plot a single image with all the contours overlayed\n first_img_shape = imgs[0].shape\n # Validate the size of the images\n for c_img in imgs:\n if c_img.shape != first_img_shape:\n raise Exception('The shape of the images must be the same')\n\n slices = get_slices(orig_slices, imgs[0], plane)\n for c_slice in slices:\n draw_slice = should_display_slice(ctrs, c_slice, plane, draw_only_ctrs)\n if draw_slice:\n fig, ax = plt.subplots(1, len(imgs), squeeze=True, figsize=(8, 8))\n for img_idx, c_img in enumerate(imgs):\n img_slice = get_proper_plane(c_img, plane, c_slice)\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\n if len(imgs) > 1:\n plot_slice(img_slice, ctrs_slice, ax[img_idx], labels)\n else:\n plot_slice(img_slice, ctrs_slice, ax, labels)\n c_title = F'{title} {plane.value} {c_slice:04d}'\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\n plt.title(c_title, fontsize=20)\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\n else:\n if len(imgs) != 1:\n raise Exception('The number of image allowed for Plane type ALL must be 1')\n # In this case it should plot 3 images, one for each plane. Here we force it to plot\n # only the middle slice\n c_img = imgs[0]\n plt.subplots(1, 3, squeeze=True, figsize=(8 * 3, 8))\n for id_plane, plane in enumerate([PlaneTypes.AXIAL, PlaneTypes.SAGITTAL, PlaneTypes.CORONAL]):\n ax = plt.subplot(1, 3, id_plane + 1)\n c_slice = get_slices(SliceMode.MIDDLE, c_img, plane)[0]\n img_slice = get_proper_plane(c_img, plane, c_slice)\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\n plot_slice(img_slice, ctrs_slice, ax, labels)\n c_title = F'{title} ALL {c_slice:04d}'\n plt.title(c_title, fontsize=20)\n\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\n\n self._close_figure()","def save_images(self, samples, label=None, dir=\"\"):\n if label is None:\n label = self.global_step_\n fig = plt.figure()\n self.net_.eval()\n self.dist.visualize(fig, samples, self.energy)\n plot_fn = os.path.join(dir, f\"samples_{label}.png\")\n fig.savefig(plot_fn)\n plt.close(fig)","def plot_segmentation_prediction(\n prediction: ndarray,\n label: ndarray,\n raw_img: Image,\n raw_label: Image,\n img_shape: tuple,\n img_name: str,\n save_path: str,\n) -> None:\n raw_img = raw_img.resize(img_shape)\n\n final_mask = mark_boundaries(raw_img, prediction == 1, [255, 0, 0])\n final_mask = mark_boundaries(final_mask, prediction == 2, [0, 255, 0])\n final_mask = mark_boundaries(final_mask, prediction == 3, [0, 0, 255])\n\n final_seg_mask = zeros(img_shape + (3,), uint8)\n final_seg_mask[prediction == 1] = [255, 0, 0]\n final_seg_mask[prediction == 2] = [0, 255, 0]\n final_seg_mask[prediction == 3] = [0, 0, 255]\n\n final_label = mark_boundaries(raw_img, label[1], [255, 0, 0])\n final_label = mark_boundaries(final_label, label[2], [0, 255, 0])\n\n if label.shape[0] == 4:\n final_label = mark_boundaries(final_label, label[3], [0, 0, 255])\n\n fig = plt.figure(figsize=(14, 14))\n\n fig.add_subplot(2, 2, 1)\n plt.imshow(final_mask)\n\n plt.title(\"Prediction\")\n\n fig.add_subplot(2, 2, 2)\n plt.imshow(final_seg_mask)\n plt.title(\"Prediction - mask\")\n\n fig.add_subplot(2, 2, 3)\n plt.imshow(final_label)\n plt.title(\"Reference\")\n\n raw_label = array(raw_label)\n raw_label[(raw_label == [255, 255, 0]).sum(axis=2) == 3] = [255, 0, 0]\n raw_label = Image.fromarray(raw_label)\n raw_label = raw_label.resize(img_shape)\n \n fig.add_subplot(2, 2, 4)\n plt.imshow(raw_label)\n plt.title(\"Reference - mask\")\n\n plt.savefig(join(save_path, img_name))\n plt.close()","def plot_images_grid(images, labels, title):\n images = images.cpu()\n labels = labels.cpu()\n \n assert type(images[0]) is torch.Tensor, 'Image to plot is not torch.Tensor'\n image_size = int(np.sqrt(images[0].shape[0]))\n \n fig = plt.figure(figsize=(10,4))\n for idx in range(10):\n ax = fig.add_subplot(2,10/2,idx+1, xticks=[], yticks=[])\n ax.imshow(images[idx].view(image_size, image_size), cmap = 'gray')\n label = labels[idx].item()\n ax.set_title(label)\n #end\n fig.suptitle(title, fontsize = 14)\n plt.show()\n plt.close('all')","def label_visualize(img_dir):\n img = scipy.misc.imread(img_dir).astype(np.uint8)\n yo = np.nonzero(img == 1)\n visual = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\n\n for i in range(0, 34):\n index = np.nonzero(img == i)\n visual[index + (0,)] = labels[i][0]\n visual[index + (1,)] = labels[i][1]\n visual[index + (2,)] = labels[i][2]\n\n scipy.misc.imsave('./' + img_dir.split('/')[-1], visual)","def plot_labelled_images(x, y, filename, y_predict=None):\n\n plt.clf()\n\n nplot = 10\n nrows = 2\n ncols = 5\n\n # randomly choose which images from the dataset to plot \n random_indices = np.random.choice(x.shape[0], size=nplot, replace=False)\n\n figure = plt.gcf()\n\n for i, index in enumerate(random_indices):\n ax = figure.add_subplot(nrows, ncols, i + 1, xticks=[], yticks=[])\n\n # plot image\n ax.imshow(np.squeeze(x[index]))\n\n # add label as title of image\n label_index = np.argmax(y[index])\n label = label_names[label_index]\n\n # if predicted labels have been supplied in addition to true labels, show both\n if y_predict is not None:\n predicted_label_index = np.argmax(y_predict[index])\n predicted_label = label_names[predicted_label_index]\n title = \"true={}\\n(predicted={})\".format(label, predicted_label)\n\n # else only show true labels\n else:\n title = \"true={}\".format(label)\n\n ax.set_title(title)\n\n size = figure.get_size_inches()\n figure.set_size_inches(size[0]*2, size[1]*2)\n\n plt.savefig(filename, bbox_inches='tight')","def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\n batchSize = min(size, images.shape[0])\n \n if size == 0:\n batchSize = images.shape[0]\n\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\n no_of_columns = round(math.sqrt(batchSize))\n no_of_rows = math.ceil(batchSize / no_of_columns)\n print(\"batch size {}, no_of_rows {}, no_of_columns {}\".format(batchSize, no_of_rows, no_of_columns))\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\n # (width, height)\n for idx in np.arange(batchSize):\n ax = fig.add_subplot(no_of_rows, no_of_columns,\n idx+1, xticks=[], yticks=[])\n if greyscale:\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\n else:\n ax.imshow(np.squeeze(images[idx]))\n # print out the correct label for each image\n # .item() gets the value contained in a Tensor\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\n if not prediction is None:\n ax.set_title(\"{} ({})\".format(str(prediction[idx]), str(labels[idx])),\n color=(\"green\" if prediction[idx] == labels[idx] else \"red\"))\n else:\n ax.set_title(str(labels[idx]))","def plot_image_comparison(name, img_arr):\n\n plt.clf()\n fig = plt.figure()\n\n # divide the images into rows and columns\n num_imgs = len(img_arr)\n columns = num_imgs // 2\n rows = math.ceil(num_imgs / columns)\n\n for i, vals in enumerate(img_arr):\n fig.add_subplot(rows, columns, i+1)\n plt.imshow(vals[\"img\"], vmin=0, vmax=255)\n plt.axis(\"off\")\n plt.title(vals[\"title\"], fontsize=8)\n\n plt.savefig(f\"{name}/comparison.jpeg\")","def plot_images(images, labels=None, proba=None, ncols=5, models_names=None,\n classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n 'dog', 'frog', 'horse', 'ship', 'truck'], **kwargs):\n if isinstance(models_names, str):\n models_names = (models_names, )\n if not isinstance(proba, (list, tuple)):\n proba = (proba, )\n if models_names is None:\n models_names = ['']\n else:\n if models_names is None:\n models_names = ['Model ' + str(i+1) for i in range(len(proba))]\n\n # if the classes names are not specified they can be implicitely infered from the `proba` shape,\n if classes is None:\n if proba[0] is not None:\n classes = [str(i) for i in range(proba[0].shape[1])]\n elif labels is None:\n pass\n elif proba[0] is None:\n raise ValueError('Specify classes')\n\n n_items = len(images)\n nrows = (n_items // ncols) + 1\n fig, ax = plt.subplots(nrows, ncols, **kwargs)\n ax = ax.flatten()\n for i in range(n_items):\n ax[i].imshow(images[i])\n if labels is not None: # plot images with labels\n true_class_name = classes[labels[i]]\n title = 'Label: {}'.format(true_class_name)\n if proba[0] is not None: # plot images with labels and predictions\n for j, model_proba in enumerate(proba): # the case of preidctions of several models\n class_pred = np.argmax(model_proba, axis=1)[i]\n class_proba = model_proba[i][class_pred]\n pred_class_name = classes[class_pred]\n title += '\\n {0} pred: {1}, p = {2:.2f}'.format(models_names[j], pred_class_name, class_proba)\n ax[i].title.set_text(title)\n ax[i].grid(b=None)\n\n for i in range(n_items, nrows * ncols):\n fig.delaxes(ax[i])","def show_result(inputs, labels, outputs):\n num_classes = outputs.size(1)\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\n if num_classes == 2:\n outputs *= 255\n mask = outputs[0].reshape((360, 640))\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\n ax[0].set_title('Image')\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\n ax[1].set_title('gt')\n plt.show()\n plt.figure()\n plt.imshow(mask, cmap='gray')\n plt.title('Pred')\n plt.show()","def visualization_one(target_var = None, input_vars= None, output_image_name=None):\n ###\n # Main chunk of code here\n ###\n\n # Starter code for labeling the image\n plt.xlabel(None, figure = fig)\n plt.ylabel(None, figure = fig)\n plt.title(None, figure= fig)\n plt.legend()\n\n # exporting the image to the img folder\n plt.savefig(f'img/{output_image_name}.png', transparent = True, figure = fig)\n return fig","def path_plot(robot_path, regions, obs):\n\n for robot, path in robot_path.items():\n # prefix path\n if len(path) == 1:\n continue\n x_pre = np.asarray([point[0] + 0.5 for point in path])\n y_pre = np.asarray([point[1] + 0.5 for point in path])\n plt.quiver(x_pre[:-1], y_pre[:-1], x_pre[1:] - x_pre[:-1], y_pre[1:] - y_pre[:-1],\n color=\"#\" + ''.join([random.choice('0123456789ABCDEF') for j in range(6)]),\n scale_units='xy', angles='xy', scale=1, label='prefix path')\n\n plt.savefig('img/path.png', bbox_inches='tight', dpi=600)","def show_images_from_path(img_path,msk_path,fig_size=(10,4)):\r\n try:\r\n img = mpimg.imread(img_path)\r\n except:\r\n print(\"File not found!\")\r\n return None\r\n msk = mpimg.imread(msk_path,0)\r\n fig, ax = plt.subplots(1,2, figsize=fig_size)\r\n ax[0].set_title(\"Image\")\r\n ax[1].set_title(\"Mask\")\r\n ax[0].imshow(img)\r\n ax[1].imshow(msk)","def plot_reconstruction_images(inputs, pred, name):\n\n plt.clf()\n nb_plots = min(inputs.shape[0], 4)\n #inputs\n for i in range(nb_plots):\n ax = plt.subplot2grid((2, nb_plots), (0, i), rowspan=1, colspan=1)\n ax.imshow(inputs[i])\n ax.axis('off')\n #pred\n for i in range(nb_plots):\n ax = plt.subplot2grid((2, nb_plots), (1, i), rowspan=1, colspan=1)\n ax.imshow(pred[i])\n ax.axis('off')\n\n if name != None:\n plt.savefig(name, format='svg', bbox_inches='tight')\n else:\n plt.show()","def vis_segmentation(image, seg_map, FULL_COLOR_MAP, LABEL_NAMES):\n plt.figure(figsize=(15, 5))\n grid_spec = gridspec.GridSpec(1, 4, width_ratios=[6, 6, 6, 1])\n\n plt.subplot(grid_spec[0])\n plt.imshow(image)\n plt.axis('off')\n plt.title('input image')\n\n plt.subplot(grid_spec[1])\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\n plt.imshow(seg_image)\n plt.axis('off')\n plt.title('segmentation map')\n\n plt.subplot(grid_spec[2])\n plt.imshow(image)\n plt.imshow(seg_image, alpha=0.7)\n plt.axis('off')\n plt.title('segmentation overlay')\n\n unique_labels = np.unique(seg_map)\n ax = plt.subplot(grid_spec[3])\n plt.imshow(\n FULL_COLOR_MAP[unique_labels].astype(np.uint8), interpolation='nearest')\n ax.yaxis.tick_right()\n plt.yticks(range(len(unique_labels)), LABEL_NAMES[unique_labels])\n plt.xticks([], [])\n ax.tick_params(width=0.0)\n plt.grid('off')\n plt.show()","def map_fn(self, path, label):\n image = tf.image.decode_png(tf.io.read_file(path))\n image = tf.image.convert_image_dtype(image, tf.float32)\n if self.img_size is not None:\n image = tf.image.resize(image, self.img_size)\n return image, label","def visualize(**images):\r\n n_images = len(images)\r\n plt.figure(figsize=(20, 8))\r\n for idx, (name, image) in enumerate(images.items()):\r\n plt.subplot(1, n_images, idx + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n # get title from the parameter names\r\n plt.title(name.replace('_', ' ').title(), fontsize=20)\r\n plt.imshow(image)\r\n plt.show()","def render_blocks(image, paths):\n if 1:\n CMAP_OBJ = colorbrewer.qualitative.Set3_12\n CMAP_COLORS = list(map(tuple, CMAP_OBJ.colors))\n colormap = itertools.cycle(CMAP_COLORS)\n renderClass = RenderFile\n draw = ImageDraw.Draw(image)\n rend = renderClass(draw=draw, x=0, y=0)\n # X: size in points, not pixels\n # fnt = ImageFont.truetype(\"Umpush-Light.ttf\", size=14)\n fnt = None\n text_color = (0, 0, 0, 128)\n for path in paths:\n text_args = dict(\n xy=(rend.x, rend.y), text=os.path.basename(path), font=fnt, fill=text_color\n )\n rend.colors = [next(colormap)]\n render_file(path, rend)\n draw.text(**text_args)\n return image","def buildImages(files, targets, type):\n images = []\n for file in files:\n targets.append(file)\n with open(file, \"rb\") as f:\n if type == \"Byte\":\n images.append(bytePlot(list(f.read())))\n elif type == \"Markov\":\n images.append(markovPlot(list(f.read())))\n elif type == \"Hilbert\":\n images.append(hilbertPlot(list(f.read())))\n smp.imsave(\"{}.png\".format(file), images[-1])\n return images, targets","def display_some_traffic_sign_examples(path):\n\n images_paths = glob.glob(path + \"\\\\*.png\") # image paths\n plt.figure(figsize = (10, 10))\n\n for i in range(25):\n # select a random index in the dataset\n idx = np.random.randint(0, len(images_paths) - 1)\n img = imread(images_paths[idx])\n\n # subplot the dataset examples\n plt.subplot(5, 5, i + 1)\n plt.tight_layout(rect = [0, 0, 1, 0.95])\n plt.imshow(img)\n\n plt.suptitle(\"Dataset Examples\")\n plt.show()","def draw_binary_label(base_img, tf_img, label_colors, resize=True):\n for label in label_colors:\n #print(\"label:{0}\".format(label))\n if label == 7: # Roads\n #print(\"label:7, roads. . .\")\n road_mask = tf_img == label\n elif label == 10: # Vehicles\n #print(\"label:10, vehicles. . .\")\n vehicle_mask = tf_img == label\n #print(vehicle_mask)\n\n cmap = plt.cm.jet\n norm = plt.Normalize(vmin=tf_img.min(), vmax=tf_img.max())\n\n # map the normalized data to colors\n # image is now RGBA (512x512x4) \n rgba_label = scipy.misc.toimage(norm(tf_img))\n plt.imshow(rgba_label)\n plt.show()\n print(\"base_img:{0} tf_img:{1}\".format(np.shape(base_img), np.shape(rgba_label)))\n #colored = cv2.addWeighted(base_img.astype('uint8'), 1, rgba_label, 0.8, 0)\n colored = 2\n\n return road_mask, vehicle_mask, colored","def get_file_paths(\r\n paths: Union[PathT, List[PathT]] = \"data/hubmap-256x256/\",\r\n use_ids: Union[Tuple[int, ...], List[Tuple[int, ...]]] = (0, 1, 2, 3, 4, 5, 6, 7),\r\n) -> Tuple[List[Path], List[Path], List[List[str]]]:\r\n if not isinstance(paths, list):\r\n paths = [paths]\r\n use_ids = [use_ids]\r\n else:\r\n assert isinstance(use_ids, list)\r\n assert len(use_ids) == len(paths)\r\n\r\n paths = [Path(p) for p in paths]\r\n unique_ids = [\r\n sorted(set(p.name.split(\"_\")[0] for p in (path / \"train\").iterdir()))\r\n for path in paths\r\n ]\r\n # print(unique_ids)\r\n\r\n images = sorted(\r\n [\r\n p\r\n for j, (use_id_p, path) in enumerate(zip(use_ids, paths))\r\n for i in use_id_p\r\n for p in (path / \"train\").glob(f\"{unique_ids[j][i]}_*.png\")\r\n ]\r\n )\r\n\r\n masks = sorted(\r\n [\r\n p\r\n for j, (use_id_p, path) in enumerate(zip(use_ids, paths))\r\n for i in use_id_p\r\n for p in (path / \"masks\").glob(f\"{unique_ids[j][i]}_*.png\")\r\n ]\r\n )\r\n\r\n assert len(images) == len(masks), f\"images {len(images)}, masks {len(masks)}\"\r\n\r\n return images, masks, unique_ids","def icons(users, distance):\n\n # It would be pretty cool to put user thumbails where points are.\n # but i'm still not sure how to do this yet.\n images = []\n\n try:\n print 'getting images..'\n for p in users:\n print p\n f = p.image\n img = imread('image.tmp')\n images.append(img)\n except Exception as e:\n print 'got an error...'\n import traceback\n etype, evalue, tb = sys.exc_info()\n print yellow % '\\n'.join(traceback.format_exception(etype, evalue, tb))\n ip()\n\n (W, H, _) = shape(img) # thumbnails should all be the same size\n count = len(images)\n\n pl.figure()\n\n P2, _ = mds(distance, 2)\n X,Y = P2[:,0], P2[:,1]\n\n ## XXX: not a great transformation b/c we might stretch more in one dimension\n def N(x):\n \"force x to fit in interval [0,1]\"\n x = (x - x.min())\n x = x / x.max()\n assert all(x >= 0) and all(x <= 1)\n return x\n X = N(X)*475\n Y = N(Y)*425\n\n figimages = [pl.figimage(img, xo=x, yo=y) for img, x, y in zip(images, X, Y)]","def showImage(self, filePath): \n size = 244, 244 \n try:\n guiobjects.generateImageSize(filePath, [244, 244], IMG_UPLOAD)\n except:\n return \n imgPath = IMG_UPLOAD\n img = ocempgui.draw.Image.load_image(imgPath)\n self.imgOptionsTab.picture = img\n self.generateMask(\"imgUpload.png\")","def plot_images(images, labels, nrows, ncols, cls_true=None, cls_pred=None, grey=False):\n fig, axes = plt.subplots(nrows, ncols, figsize=(16, 2*nrows))\n\n for i, ax in enumerate(axes.flat): \n if grey:\n ax.imshow(images[i,:,:,0], cmap='binary')\n else:\n ax.imshow(images[i])\n\n ax.set_xticks([]); ax.set_yticks([])\n if labels:\n ax.set_title(labels[i])","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()","def plot_shapes(shapes, colors, title=\"Shape Model\", save=False):\n cv2.namedWindow(title)\n shapes = [scale_by_param(scale_to_unit(dshape), 1000) for dshape in shapes]\n #shapes = [shape.scale_to_unit().scale(1000) for shape in shapes]\n\n max_x = int(max([dshape[:, 0].max() for dshape in shapes]))\n max_y = int(max([dshape[:, 1].max() for dshape in shapes]))\n min_x = int(min([dshape[:, 0].min() for dshape in shapes]))\n min_y = int(min([dshape[:, 1].min() for dshape in shapes]))\n\n img = np.ones((max_y-min_y+20, max_x-min_x+20, 3), np.uint8)*255\n for shape_num, shape in enumerate(shapes):\n points = shape\n for i in range(len(points)):\n cv2.line(img, (int(points[i, 0]-min_x+10), int(points[i, 1]-min_y+10)),\n (int(points[(i + 1) % 40, 0]-min_x+10), int(points[(i + 1) % 40, 1]-min_y+10)),\n colors[shape_num], thickness=1, lineType=8)\n\n cv2.imshow(title, img)\n cv2.waitKey()\n if save:\n cv2.imwrite('Plot/'+title+'.png', img)\n cv2.destroyAllWindows()","def plot_example_images(\n output_dir, epoch, generator, label_imgs, test_imgs, imgs_count,\n examples=4):\n random_ints = np.random.randint(0, imgs_count, examples)\n image_batch_hr = denormalize(label_imgs[random_ints])\n image_batch_lr = test_imgs[random_ints]\n gen_img = generator.predict(image_batch_lr)\n generated_image = denormalize(gen_img)\n image_batch_lr = denormalize(image_batch_lr)\n\n plt.clf()\n\n for idx in range(examples):\n plt.subplot(examples, 3, 1 + idx * 3)\n plt.imshow(image_batch_lr[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplot(examples, 3, 2 + idx * 3)\n plt.imshow(generated_image[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplot(examples, 3, 3 + idx * 3)\n plt.imshow(image_batch_hr[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplots_adjust(wspace=0.01)\n plt.savefig(\n path.join(output_dir, f'generated_image_{epoch}.svg'),\n bbox_inches='tight', pad_inches=0, )","def save_pic(pic_tensor, title, filename):\n plt.close()\n plt.title(title, size=24)\n xyrgb = pic_tensor.data[0].numpy().transpose((1, 2, 0)) # convert from RGB x X x Y to X x Y x RGB\n if (xyrgb.shape)[-1] != 3: # no rgb image => Plot with color map\n xyrgb = xyrgb[:, :, 0]\n plt.imshow(xyrgb, cmap='gray', interpolation='nearest')\n if (xyrgb.shape)[-1] != 3: # no rgb image => show color bar legend\n cbar = plt.colorbar()\n cbar.ax.tick_params(labelsize=20)\n print(title, xyrgb.shape)\n plt.xticks(fontsize=20)\n plt.yticks(fontsize=20)\n plt.savefig(\"./\" + filename + \".pdf\", dpi=300, bbox_inches='tight')","def plot_labels_bundle_pth(device, model, dataset, dataloader):\n ## Get labels and preds\n labels, preds = get_labels_and_preds(device, model, dataloader)\n \n ## Plot the figure\n plot_labels(labels, preds, dataset.id_to_class_dict)","def graphical(cls, images):\n images = [(plt.imread(i), i.split(os.path.sep)[-1]) for i in images]\n views = [View(ViewPosition.click(img, path), img, img) for img, path in images]\n return cls(views)","def visualize_MTL(**images):\r\n n = len(images)\r\n plt.figure(figsize=(16, 5))\r\n for i, (name, image) in enumerate(images.items()):\r\n if image==None:\r\n continue\r\n else:\r\n plt.subplot(1, n, i + 1)\r\n plt.xticks([])\r\n plt.yticks([])\r\n plt.title(' '.join(name.split('_')).title())\r\n plt.imshow(image)\r\n plt.show()","def saveImage(self, data, fpath, list_label=\"[Word List]\", dpi=100):\n # Generate puzzle image\n colors = np.where(self.cover<1, \"#000000\", \"#FFFFFF\")\n df = pd.DataFrame(data)\n\n fig=plt.figure(figsize=(16, 8), dpi=dpi)\n ax1=fig.add_subplot(121) # puzzle\n ax2=fig.add_subplot(122) # word list\n ax1.axis(\"off\")\n ax2.axis(\"off\")\n fig.set_facecolor('#EEEEEE')\n \n # Draw puzzle\n ax1_table = ax1.table(cellText=df.values, cellColours=colors, cellLoc=\"center\", bbox=[0, 0, 1, 1], fontsize=20)\n ax1.set_title(label=f\"*** {self.title} ***\", size=20)\n \n # delete unmasked cells\n mask = np.where(puzzle.mask == False)\n for i, j in list(zip(mask[0], mask[1])):\n del ax1_table._cells[i, j]\n\n # Draw word list\n words = [word for word in self.usedWords if word != \"\"]\n if words == []:\n words = [\"\"]\n words.sort()\n words = sorted(words, key=len)\n\n rows = self.height\n cols = math.ceil(len(words)/rows)\n padnum = cols*rows - len(words)\n words += ['']*padnum\n words = np.array(words).reshape(cols, rows).T\n\n ax2_table = ax2.table(cellText=words, cellColours=None, cellLoc=\"left\", edges=\"open\", bbox=[0, 0, 1, 1])\n ax2.set_title(label=list_label, size=20)\n for _, cell in ax2_table.get_celld().items():\n cell.set_text_props(size=18)\n plt.tight_layout()\n plt.savefig(fpath, dpi=dpi)\n plt.close()","def plotSate(s,i,seed):\r\n fig, ax = plt.subplots()\r\n\r\n im = ax.imshow(s)\r\n\r\n plt.xticks([i for i in range(dim)], \"\")\r\n plt.yticks([i for i in range(dim)], \"\")\r\n\r\n fig.tight_layout()\r\n plt.savefig(\"Systems/\" + str(dim) + \"_\" + str(seed) + \"/Images/\" + str(i) +\r\n \".jpeg\",quality=80,optimize=True,\r\n dpi=80,progressive=True,transparent=True)\r\n fig.clear()\r\n plt.close(fig)","def makeFigure(imgList):\n for i, img in enumerate(imgList):\n i += 1\n ax = plt.subplot(len(imgList), 1, i)\n ax.imshow(img[0], cmap=COLOR_MAP)\n ax.get_yaxis().set_ticks([])\n if i == len(imgList):\n ax.set_xlabel('Time of day')\n ax.set_ylabel('Day of week')\n # add name of the repo as title\n plt.title(img[1])\n\n plt.tight_layout(pad=0)\n plt.show()","def decode_labels(mask, num_images=1, num_classes=21, task='seg'):\n n, h, w, c = mask.shape\n assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)\n outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)\n for i in range(num_images):\n if task == 'normal':\n outputs[i] = mask[i]\n elif task == 'seg':\n img = Image.new('RGB', (w, h), (255, 255, 255)) # unlabeled part is white (255, 255, 255)\n pixels = img.load()\n for j_, j in enumerate(mask[i, :, :, 0]):\n for k_, k in enumerate(j):\n if k < num_classes:\n pixels[k_, j_] = label_colours[k]\n outputs[i] = np.array(img)\n else:\n raise Exception('task name is not recognized!')\n\n return outputs","def show_prediction_labels_on_image(img_path, predictions):\r\n pil_image = Image.open(img_path).convert(\"RGB\")\r\n draw = ImageDraw.Draw(pil_image)\r\n\r\n for name, (top, right, bottom, left) in predictions:\r\n draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255))\r\n name = name.encode(\"UTF-8\")\r\n text_width, text_height = draw.textsize(name)\r\n draw.rectangle(((left, bottom - text_height - 10), (right, bottom)), fill=(0, 0, 255), outline=(0, 0, 255))\r\n draw.text((left + 6, bottom - text_height - 5), name, fill=(255, 255, 255, 255))\r\n del draw\r\n pil_image.show()","def plot_class_representations(\n images, labels,\n ignore_list=['-1', 'unknown'],\n img_width=150,\n force_b64=False):\n assert(len(images) == len(labels))\n assert(type(ignore_list) is list or ignore_list is None)\n assert(type(img_width) is int)\n\n uniques = np.unique(labels, return_index=True)\n labels = uniques[0]\n not_labeled_mask = np.isin(labels, ignore_list)\n labels = labels[~not_labeled_mask]\n idices = uniques[1][~not_labeled_mask]\n\n group = []\n for img_path in images[idices]:\n group.append(img_path)\n\n plot_images(\n group,\n labels=labels,\n max_images=len(group),\n img_width=img_width,\n force_b64=force_b64)","def load_from_path(self, paths, label_key='labels'):\n data = []\n labels = []\n for path in paths:\n with tf.io.gfile.GFile(path, 'rb') as f:\n d = {\n k.decode('utf8'): v\n for k, v in cPickle.load(f, encoding='bytes').items()\n }\n data.append(d['data'])\n labels.append(d[label_key])\n data = np.concatenate(data, axis=0)\n data = data.reshape((data.shape[0], 3, 32, 32))\n labels = np.concatenate(labels, axis=0)\n labels = np.reshape(labels, (len(labels), 1))\n\n if tf.keras.backend.image_data_format() == 'channels_last':\n data = data.transpose(0, 2, 3, 1)\n\n return data, labels","def define_tasks(self, imgcollections,\r\n description, dimensions, folder):\r\n n = imgcollections.size().getInfo()\r\n collections = imgcollections.toList(n) # this is server-object; not iterable\r\n tasks = []\r\n itr = np.arange(n).tolist()\r\n random.shuffle(itr)\r\n pbar = tqdm.tqdm(itr)\r\n for i in pbar:\r\n image = collections.get(i)\r\n task = self.define_task(ee.Image(image).float(),\r\n \"{0:05d}\".format(i),\r\n description,\r\n dimensions,\r\n folder)\r\n tasks.append(task)\r\n pbar.set_description(\"defining tasks {0:05d}/{1:05d}\".format(i, n)) \r\n return tasks","def show_pair(data, labeled=True, ordering='channel_last'):\n xb, yb = data\n batch_size = len(xb)\n \n fig = plt.figure(figsize=(5 * 2, 5 * batch_size))\n for i in range(batch_size):\n fig.add_subplot(batch_size, 2, (2 * i) + 1) \n show_image(xb[i], ordering=ordering)\n \n fig.add_subplot(batch_size, 2, (2 * i) + 2) \n if yb[i] is None:\n y = np.zeros_like(xb[i])\n else:\n y = yb[i] \n\n if labeled:\n show_label(y, ordering=ordering)\n else:\n show_image(y, ordering=ordering)\n \n return fig","def plot_images(imgs, layout, img_sz = 0.7, suptitle = ''):\n\tnrows, ncols = layout \n\tfig, axes = plt.subplots(nrows, ncols, \n\t\tfigsize = (img_sz * ncols, img_sz * nrows))\n\taxes = axes.ravel()\n\tfig.subplots_adjust(hspace = 0, wspace = 0)\n\tfig.suptitle(suptitle)\n\tfor i, img in enumerate(imgs):\n\t\taxes[i].get_xaxis().set_visible(False)\n\t\taxes[i].get_yaxis().set_visible(False)\n\t\taxes[i].imshow(img)","def make_training_curve_plots(algos,\n tasks,\n n_runs_per_expt,\n csv_filepath_template,\n figure_outdir,\n window_size=None,\n subplot_height=5,\n subplot_width=8):\n n_algo = len(algos)\n n_task = len(tasks)\n\n plt.figure('raw', figsize=(subplot_width * n_algo, subplot_height * n_task))\n plt.figure(\n 'medians_percentiles',\n figsize=(subplot_width * n_algo, subplot_height * n_task))\n n_subplots_x, n_subplots_y = subplots_square(n_task)\n plt.figure(\n 'medians_percentiles_pertask',\n figsize=(subplot_width * n_subplots_x, subplot_height * n_subplots_y))\n plt.figure(\n 'means_CIs_pertask',\n figsize=(subplot_width * n_subplots_x, subplot_height * n_subplots_y))\n fig_names = [\n 'raw', 'medians_percentiles', 'medians_percentiles_pertask',\n 'means_CIs_pertask'\n ]\n\n subplot_pos = 0\n # Iterate through each task.\n for i_task, task in enumerate(tasks):\n print('%s...' % task, end='')\n\n # Initialize x- and y-lims.\n xlims_extremes = [np.inf, -np.inf]\n task_baselines = [\n baseline for key, baseline in BASELINES.items() if task in key\n ]\n if task_baselines:\n ylims_extremes = [np.inf, max(task_baselines)]\n else:\n ylims_extremes = [np.inf, -np.inf]\n\n # Iterate through each algorithm.\n for i_algo, algo in enumerate(algos):\n subplot_pos += 1\n algo_color = ALGO_COLORS[i_algo]\n\n plt.figure('raw')\n plt.subplot(n_task, n_algo, subplot_pos)\n\n # Load and plot the raw curves.\n curves = []\n for run in range(n_runs_per_expt):\n csv_filepath = csv_filepath_template % (task, algo, run)\n with open(csv_filepath, 'r') as csv_file:\n csv_reader = csv.reader(csv_file)\n curve = []\n for _ in range(2):\n curve.append(np.array(csv_reader.next(), dtype=float))\n curves.append(curve)\n plt.plot(curve[0], curve[1])\n plot_baseline(algo, task)\n\n # update the xlim/ylim extremes\n xlims_extremes, ylims_extremes = update_xylims_extremes(\n xlims_extremes, ylims_extremes)\n\n # Compute summaries\n curves = np.array(curves)\n timesteps, window_means = compute_window_means(curves, window_size)\n means = compute_means(window_means)\n medians = compute_medians(window_means)\n cis = compute_boot_ci(window_means)\n percentiles = compute_percentiles(window_means)\n\n # plot the medians + percentiles\n plt.figure('medians_percentiles')\n plt.subplot(n_task, n_algo, subplot_pos)\n fill_plot(timesteps, medians, percentiles[0], percentiles[1], algo, task,\n algo_color)\n\n # Plot the medians + percentiles on a single plot per task.\n plt.figure('medians_percentiles_pertask')\n plt.subplot(n_subplots_y, n_subplots_x, i_task + 1)\n fill_plot(timesteps, medians, percentiles[0], percentiles[1], algo, task,\n algo_color)\n\n # Plot the mean + CI on a single plot per task.\n plt.figure('means_CIs_pertask')\n plt.subplot(n_subplots_y, n_subplots_x, i_task + 1)\n fill_plot(timesteps, means, cis[0], cis[1], algo, task, algo_color)\n\n # Figure titles.\n for fig_name in ['raw', 'medians_percentiles']:\n plt.figure(fig_name)\n plt.title('%s - %s' % (algo, task))\n for fig_name in ['medians_percentiles_pertask', 'means_CIs_pertask']:\n plt.figure(fig_name)\n plt.title(task)\n\n # equalize axes for the task\n for fig_name in ['raw', 'medians_percentiles']:\n equalize_axes_for_task(fig_name, xlims_extremes, ylims_extremes,\n subplot_pos, n_task, n_algo)\n\n # Add legends\n for fig_name in ['medians_percentiles_pertask', 'means_CIs_pertask']:\n plt.figure(fig_name)\n plt.legend(algos)\n\n # Save the figures.\n io_utils.makedirs(figure_outdir)\n for fig_name in fig_names:\n plt.figure(fig_name)\n plt.tight_layout()\n output_path = '%s/%s.png' % (figure_outdir, fig_name)\n with open(output_path, 'wb') as outfile:\n plt.savefig(outfile, dpi=100)","def run_visualization(filepath, MODEL, outputFilePath):\n try:\n # print(\"Trying to open : \" + sys.argv[1])\n \t# f = open(sys.argv[1])\n \tjpeg_str = open(filepath, \"rb\").read()\n \torignal_im = Image.open(BytesIO(jpeg_str))\n except IOError:\n print('Cannot retrieve image. Please check file: ' + filepath)\n return\n\n print('running deeplab on image %s...' % filepath)\n resized_im, seg_map = MODEL.run(orignal_im)\n\n # vis_segmentation(resized_im, seg_map)\n drawSegment(resized_im, seg_map, outputFilePath)","def generate_image_grid(sess, df, filenames,op, op2):\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\n\n nx, ny = 12, 1\n #plt.subplot()\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n #\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\n # plt.show()\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\n # img = np.array(x.tolist()).reshape(28, 28)\n #\n # plt.imshow(img, cmap='gray')\n # plt.show()\n\n \"\"\" grid \"\"\"\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n for i, g in enumerate(gs):\n\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\n ax = plt.subplot(g)\n img = np.array(x.tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()\n\n for i, g in enumerate(gs):\n\n ax = plt.subplot(g)\n img = np.array(df[i].tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()","def run_visualization(filepath):\n try:\n \t#print(\"Trying to open : \" + sys.argv[1])\n \t# f = open(sys.argv[1])\n \tjpeg_str = open(filepath, \"rb\").read()\n \torignal_im = Image.open(BytesIO(jpeg_str))\n except IOError:\n print('Cannot retrieve image. Please check file: ' + filepath)\n return\n\n #print('running deeplab on image %s...' % filepath)\n resized_im, seg_map = MODEL.run(orignal_im)\n\n # vis_segmentation(resized_im, seg_map)\n drawSegment(resized_im, seg_map)","def draw_all_labels(df,root_folder_path,root_folder_name,logger):\n # df=df[df.type==\"Color\"]\n len_images=df['file_id'].nunique()\n perc_list=[i*0.05 for i in range(0,20,1)]\n grouped_df=df.groupby(['file_id','class'])\n coordinate_names=['x_max','x_min','y_max','y_min']\n group_len=len(grouped_df)\n\n class_label_dict={}\n label_info_list=[]\n for ind,(name, group) in enumerate(grouped_df):\n img_name,class_name=name\n img_type=group['type'].values[0]\n bb_list=group[coordinate_names].values.astype(int)\n if class_name not in class_label_dict.keys():\n class_label_dict[class_name]=get_random_color()\n bb_color=class_label_dict[class_name]\n label_info_list.append([img_name,img_type,class_name,bb_color,bb_list])\n draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list)\n perc=float(\"{:.2f}\".format((ind+1)/group_len))\n if perc in perc_list:\n perc_list.remove(perc)\n logger.write(\"Classes annotated: \"+str(ind+1)+\"/\"+str(group_len))\n # print(\"Label list generated.\")\n # pool = Pool(1)\n # pool.starmap(draw_label_on_one_image, zip(\n # label_info_list, itertools.repeat(root_folder_path), itertools.repeat(root_folder_name)))\n # pool.close()\n # pool.join()\n # print(\"Drawing labels is finished.\")","def generate_images(self, model, test_input, step, dst_dir):\n prediction = model(test_input)\n\n plt.figure(figsize=(12, 12))\n display_list = [test_input[0], prediction[0]]\n title = ['Input Image', 'Predicted Image']\n\n for i in range(2):\n plt.subplot(1, 2, i+1)\n plt.title(title[i])\n # getting the pixel values between [0, 1] to plot it.\n plt.imshow(display_list[i] * 0.5 + 0.5)\n plt.axis('off')\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\n plt.savefig(filename)","def tasks_frame(self, task_id, frame_ids, outdir='', **kwargs):\n for frame_id in frame_ids:\n url = self.api.tasks_id_frame_id(task_id, frame_id)\n response = self.session.get(url)\n response.raise_for_status()\n im = Image.open(BytesIO(response.content))\n outfile = 'task_{}_frame_{:06d}.jpg'.format(task_id, frame_id)\n im.save(os.path.join(outdir, outfile))","def generate_2D_plot(x, y, labels_dict, file_title, plot_title):\n fig = plt.figure()\n plt.plot(x, y)\n\n if labels_dict:\n plt.xlabel(labels_dict[\"x\"])\n plt.ylabel(labels_dict[\"y\"])\n if plot_title:\n plt.title(plot_title)\n\n plt.savefig(file_title)","def _plot_images(self):\n # Plot sagittal (0), coronal (1) or axial (2) view\n self._images = dict(base=list(), cursor_v=list(), cursor_h=list(),\n bounds=list())\n img_min = np.nanmin(self._base_data)\n img_max = np.nanmax(self._base_data)\n text_kwargs = dict(fontsize='medium', weight='bold', color='#66CCEE',\n family='monospace', ha='center', va='center',\n path_effects=[patheffects.withStroke(\n linewidth=4, foreground=\"k\", alpha=0.75)])\n xyz = apply_trans(self._ras_vox_t, self._ras)\n for axis in range(3):\n plot_x_idx, plot_y_idx = self._xy_idx[axis]\n fig = self._figs[axis]\n ax = fig.axes[0]\n img_data = np.take(self._base_data, self._current_slice[axis],\n axis=axis).T\n self._images['base'].append(ax.imshow(\n img_data, cmap='gray', aspect='auto', zorder=1,\n vmin=img_min, vmax=img_max))\n img_extent = self._img_extents[axis] # x0, x1, y0, y1\n w, h = np.diff(np.array(img_extent).reshape(2, 2), axis=1)[:, 0]\n self._images['bounds'].append(Rectangle(\n img_extent[::2], w, h, edgecolor='w', facecolor='none',\n alpha=0.25, lw=0.5, zorder=1.5))\n ax.add_patch(self._images['bounds'][-1])\n v_x = (xyz[plot_x_idx],) * 2\n v_y = img_extent[2:4]\n self._images['cursor_v'].append(ax.plot(\n v_x, v_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\n h_y = (xyz[plot_y_idx],) * 2\n h_x = img_extent[0:2]\n self._images['cursor_h'].append(ax.plot(\n h_x, h_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\n # label axes\n self._figs[axis].text(0.5, 0.05, _IMG_LABELS[axis][0],\n **text_kwargs)\n self._figs[axis].text(0.05, 0.5, _IMG_LABELS[axis][1],\n **text_kwargs)\n self._figs[axis].axes[0].axis(img_extent)\n self._figs[axis].canvas.mpl_connect(\n 'scroll_event', self._on_scroll)\n self._figs[axis].canvas.mpl_connect(\n 'button_release_event', partial(self._on_click, axis=axis))\n # add head and brain in mm (convert from m)\n if self._head is None:\n logger.info('Using marching cubes on CT for the '\n '3D visualization panel')\n rr, tris = _marching_cubes(np.where(\n self._base_data < np.quantile(self._base_data, 0.95), 0, 1),\n [1])[0]\n rr = apply_trans(self._vox_ras_t, rr)\n self._renderer.mesh(\n *rr.T, triangles=tris, color='gray', opacity=0.2,\n reset_camera=False, render=False)\n else:\n self._renderer.mesh(\n *self._head['rr'].T * 1000, triangles=self._head['tris'],\n color='gray', opacity=0.2, reset_camera=False, render=False)\n if self._lh is not None and self._rh is not None:\n self._renderer.mesh(\n *self._lh['rr'].T * 1000, triangles=self._lh['tris'],\n color='white', opacity=0.2, reset_camera=False, render=False)\n self._renderer.mesh(\n *self._rh['rr'].T * 1000, triangles=self._rh['tris'],\n color='white', opacity=0.2, reset_camera=False, render=False)\n self._renderer.set_camera(azimuth=90, elevation=90, distance=300,\n focalpoint=tuple(self._ras))\n # update plots\n self._draw()\n self._renderer._update()","def plt_to_ipy_img(dummy: any = None, **kwargs) -> IPython.display.Image:\n return IPython.display.Image(filename=plot_to_file(**kwargs))","def plot_images(data_obj, fs):\n\n fig = new_pdf_page(data_obj.pdf_obj) # Create a new page\n plt.suptitle('Cropped and Rotated Images')\n\n for i, file in enumerate(data_obj.files):\n\n # Specify the plot parameters\n ax2 = fig.add_subplot(3, 2, i + 1)\n plt.tick_params(axis='both', which='both', bottom='off', left='off',\n top='off', right='off', labelbottom='off', labelleft='off')\n\n # Plot the image and the image title\n plt.imshow(data_obj.img_data[i].img, cmap=plt.get_cmap('gray'))\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation), fontsize=fs)\n\n # Add the ROI rectangles to the plot\n data_obj.img_data[i].step_wedge_ROI.add_rect_to_plot(edgecolor='orange')\n data_obj.img_data[i].lead_foil_ROI.add_rect_to_plot(edgecolor='blue')\n data_obj.img_data[i].POM_piece_ROI.add_rect_to_plot(edgecolor='red')","def make_label_map(path, label_list):\r\n \r\n img = []\r\n for name in path:\r\n now = np.zeros((224,224))\r\n im = cv2.resize(cv2.imread(name), (224,224)).tolist()\r\n for y, i in enumerate(im):\r\n for x, j in enumerate(i):\r\n try:\r\n now[y, x] = label_list.index(j)\r\n\r\n except ValueError:\r\n now[y, x] = 0\r\n\r\n img.append(now)\r\n return img","def plot_image_path(image_path, log_image_path=False):\n img = load_img(image_path)\n if log_image_path:\n plt.title(image_path)\n plt.imshow(img)\n plt.axis('off')\n plt.show()","def visualize_heat_maps(self, image_paths, last_layer='fc', savefig_path=\"\"):\n\n layer_idx = [idx for idx, layer in enumerate(self.model.layers) if layer.name == last_layer][0]\n\n heatmaps = []\n for path in image_paths:\n seed_img = utils.load_img(path, target_size=(self.config.crop_height, self.config.crop_width))\n x = np.expand_dims(img_to_array(seed_img), axis=0)\n x = preprocess_input(x)\n pred_class = np.argmax(self.model.predict(x))\n\n # Here we are asking it to show attention such that prob of `pred_class` is maximized.\n heatmap = visualize_saliency(self.model, layer_idx, [pred_class], seed_img)\n heatmaps.append(heatmap)\n\n plt.axis('off')\n plt.imshow(utils.stitch_images(heatmaps))\n plt.title('Saliency map')\n plt.savefig(savefig_path)\n\n print('debug')","def vis_segmentation(image, seg_map):\n plt.figure(figsize=(20, 20))\n \n seg_image = label_to_color_image(seg_map).astype(np.uint8)\n plt.imshow(seg_image)\n plt.axis('off')\n plt.savefig(str(image_id)+'_seg.jpg',bbox_inches='tight')\n plt.close()","def show_next_image(self):\r\n self.index += 1\r\n progress_string = \"%d/%d\" % (self.index+1, self.n_paths)\r\n self.progress_label.configure(text=progress_string)\r\n \r\n display_name = \"Name = %s\" % (self.file_names[self.index])\r\n self.name_label.configure(text = display_name)\r\n \r\n #### added in version 2\r\n #sorting_string = df.sorted_in_folder[self.index].split(os.sep)[-2] #shows the last folder in the filepath before the file\r\n sorting_string = self.df.sorted_in_folder[self.index].split(\"/\")[-2]\r\n self.sorting_label.configure(text=(\"In folder: %s\" % (sorting_string)))\r\n \r\n #Add Current Label\r\n print(sorting_string)\r\n for label in labels:\r\n if label not in sorting_string:\r\n cat_string = 'Unlabelled'\r\n else:\r\n cat_string = sorting_string\r\n \r\n self.cat_label.configure(text = ('Current Category : %s' %(cat_string)))\r\n \r\n ####\r\n\r\n if self.index < self.n_paths:\r\n self.set_image(self.df.sorted_in_folder[self.index])\r\n else:\r\n self.master.quit()","def plot_points(source = [], images = [], plt_show = False, \\\n color = 'darkgreen', marker = 'x', label = ''): #FIXME - this function should me moved to a more generic module (plot_utils.py for instance)\n #print source, images\n if len(source) == 0 and len(images) == 0:\n return 0\n\n plt.figure(1, figsize=(16, 8))\n\n if len(source) > 0:\n x_src = [row[0] for row in source]\n y_src = [row[1] for row in source]\n plt.subplot(1, 2, 1).set_aspect(1)\n plt.plot(x_src, y_src, markersize = 7, color = color, marker = marker, \\\n label = label, linewidth=0)\n plt.legend()\n\n if len(images) > 0:\n x_img = [row[0] for row in images]\n y_img = [row[1] for row in images]\n plt.subplot (1, 2, 2).set_aspect(1)\n plt.plot(x_img, y_img, markersize = 7, color = color, marker = marker, \\\n label = label, linewidth=0)\n plt.legend()\n\n if plt_show:\n plt.show()\n plt.close()","def visualize(self):\n NUM_AFFINITY = 4\n NUM_WILL = 7\n\n # Colors for the tasks and categories\n COLORS = d3['Category20c'][20] + d3['Category20b'][20]\n COLORS_CAT = d3['Category20'][20]\n COLORS_AFFINITY = brewer['Greens'][NUM_AFFINITY]\n COLORS_WILL = brewer['RdBu'][NUM_WILL]\n\n # Date range for the figure title\n start_str = c.START.strftime(\"%A %m/%d/%y\")\n end_str = c.END.strftime(\"%A %m/%d/%y\")\n\n # Day of week range for the x axis\n start_weekday_str = c.START.strftime(\"%a\")\n end_weekday_str = c.END.strftime(\"%a\")\n\n times, tasks = self.array.nonzero()\n day_start = tutil.DAY_START\n hours = (times % tutil.SLOTS_PER_DAY) / tutil.SLOTS_PER_HOUR\n bottom = day_start + hours\n top = bottom + (0.95 / tutil.SLOTS_PER_HOUR)\n left = np.floor(times / tutil.SLOTS_PER_DAY)\n right = left + 0.75\n chunk_min = [self.task_chunk_min[j] for j in tasks]\n chunk_max = [self.task_chunk_max[j] for j in tasks]\n affinity_cog_task = [self.task_cognitive_load[j] for j in tasks]\n affinity_cog_slot = [c.AFFINITY_COGNITIVE[i] for i in times]\n affinity_cognitive = (np.array(affinity_cog_task) * np.array(\n affinity_cog_slot)).tolist()\n willpower_task = [self.task_willpower_load[j] for j in tasks]\n willpower_cumulative = np.cumsum(willpower_task)\n duration = [self.task_duration[j] for j in tasks]\n duration_realized = [self.task_duration_realized[j] for j in tasks]\n task_names = [self.task_names[j] for j in tasks]\n category_ids = [[l for l, j in enumerate(array) if j != 0] for array in\n [self.task_category[j, :] for j in tasks]]\n category = [\", \".join(\n [self.cat_names[l] for l, j in enumerate(array) if j != 0]) for\n array in [self.task_category[j, :] for j in tasks]]\n data_tooltips = dict(\n chunk_min=chunk_min,\n chunk_max=chunk_max,\n affinity_cognitive=affinity_cognitive,\n affinity_cog_slot=affinity_cog_slot,\n affinity_cog_task=affinity_cog_task,\n willpower_task=willpower_task,\n willpower_cumulative=willpower_cumulative,\n duration=duration,\n duration_realized=duration_realized,\n task_id=tasks,\n task=task_names,\n category=category,\n )\n\n offset = self.num_tasks - self.num_categories\n # Use #deebf7 as placeholder/default event color\n colors = [COLORS[i % len(COLORS)] if i < offset else '#ffffcc' for i in\n tasks]\n data1 = data_tooltips.copy()\n data1.update(dict(\n top=top,\n bottom=bottom,\n left=left,\n right=right,\n colors=colors,\n ))\n source1 = ColumnDataSource(data=data1)\n\n TOOLTIPS = [(\"task\", \"@task\"),\n (\"category\", \"@category\"),\n (\"duration\", \"@duration_realized / @duration\"),\n (\"willpower\", \"@willpower_task\"),\n (\"willpower (cum)\", \"@willpower_cumulative\"),\n (\"chunk_range\", \"(@chunk_min, @chunk_max)\"),\n (\"affinity [slot x task]\", \"@affinity_cognitive = \"\n \"@affinity_cog_slot x \"\n \"@affinity_cog_task\"),\n (\"task_id\", \"@task_id\"),\n (\"index\", \"$index\"),\n (\"(t,l)\", \"(@bottom, @left)\"),\n ]\n\n # [Bokeh] inverted axis range example:\n # https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/CJAvppgQmKo\n yr = Range1d(start=22, end=6)\n # yr = Range1d(start=24.5, end=-0.5)\n xr = Range1d(start=-0.3, end=7.3)\n p = figure(plot_width=1000, plot_height=600, y_range=yr, x_range=xr,\n tooltips=TOOLTIPS,\n title=\"Calendar: {} to {}\".format(start_str, end_str))\n self.p = p\n output_file(\"calendar.html\")\n\n p.xaxis[0].axis_label = 'Weekday ({}-{})'.format(start_weekday_str,\n end_weekday_str)\n p.yaxis[0].axis_label = 'Hour (7AM-9:30PM)'\n\n # Replace default yaxis so that each hour is displayed\n p.yaxis[0].ticker.desired_num_ticks = int(tutil.HOURS_PER_DAY)\n p.yaxis[0].ticker.num_minor_ticks = 4\n p.xaxis[0].ticker.num_minor_ticks = 0\n\n # Display task allocation as colored rectangles\n p.quad(top='top', bottom='bottom', left='left', right='right',\n color='colors', fill_alpha=0.7, line_alpha=0.5, source=source1)\n\n # Pre-process task names for display (no repeats, abbreviated names)\n # FIXME(cathywu) currently assumes that y is in time order, which may\n # not be the case when more task types are incorporated\n task_display = []\n curr_task = \"\"\n for name in task_names:\n if name == curr_task:\n task_display.append(\"\")\n else:\n curr_task = name\n task_display.append(name)\n data2 = data_tooltips.copy()\n data2.update(dict(\n x=left,\n y=top,\n # abbreviated version of task\n task=[k[:19] for k in task_display],\n ))\n source2 = ColumnDataSource(data=data2)\n\n # Annotate rectangles with task name\n # [Bokeh] Text properties:\n # https://bokeh.pydata.org/en/latest/docs/user_guide/styling.html#text-properties\n labels = LabelSet(x='x', y='y', text='task', level='glyph', x_offset=3,\n y_offset=-1, source=source2, text_font_size='7pt',\n render_mode='canvas')\n p.add_layout(labels)\n\n # Display cognitive affinity as rectangle to the right of the task\n colors_affinity = np.array(\n np.array(affinity_cognitive) * (NUM_AFFINITY - 1), dtype=int)\n colors_affinity = [COLORS_AFFINITY[NUM_AFFINITY - 1 - i] for i in\n colors_affinity.tolist()]\n data5 = data_tooltips.copy()\n data5.update(dict(\n top=(np.array(top) - 0.05).tolist(),\n bottom=(np.array(bottom) + 0.05).tolist(),\n left=(np.array(right) + 0.12).tolist(),\n right=(np.array(right) + 0.2).tolist(),\n colors=colors_affinity,\n ))\n source5 = ColumnDataSource(data=data5)\n p.quad(top='top', bottom='bottom', left='left', right='right',\n color='colors', source=source5)\n\n # Display willpower balance as rectangle to the right of the task\n colors_will = np.minimum(willpower_cumulative, 2)\n colors_will = np.maximum(colors_will, -2)\n colors_will += 2\n colors_will = np.array(colors_will / 4 * (NUM_WILL - 1), dtype=int)\n colors_will = [COLORS_WILL[i] for i in colors_will.tolist()]\n data6 = data_tooltips.copy()\n data6.update(dict(\n top=top,\n bottom=bottom,\n left=np.array(right) + 0.02,\n right=(np.array(right) + 0.1).tolist(),\n colors=colors_will,\n ))\n source6 = ColumnDataSource(data=data6)\n p.quad(top='top', bottom='bottom', left='left', right='right',\n color='colors', source=source6)\n\n # Display categories as a colored line on the left\n # TODO(cathywu) currently displays only the \"first\" category,\n # add support for more categories\n xs = []\n ys = []\n for y0, y1, x in zip(top, bottom, left):\n xs.append([x, x])\n ys.append([y0, y1])\n colors_cat = [COLORS_CAT[cat_ids[0] % len(COLORS_CAT)] for cat_ids in\n category_ids]\n data3 = data_tooltips.copy()\n data3.update(dict(\n xs=xs,\n ys=ys,\n colors=colors_cat,\n ))\n source3 = ColumnDataSource(data=data3)\n p.multi_line(xs='xs', ys='ys', color='colors', line_width=4,\n source=source3)\n\n # Annotate columns with day of the week\n data4 = data_tooltips.copy()\n data4.update(dict(\n x=[k + 0.1 for k in range(tutil.LOOKAHEAD)],\n y=[6.75 for _ in range(tutil.LOOKAHEAD)],\n weekday=[(c.START + timedelta(k)).strftime(\"%A\") for k in\n range(tutil.LOOKAHEAD)],\n ))\n source4 = ColumnDataSource(data=data4)\n labels2 = LabelSet(x='x', y='y', text='weekday', level='glyph',\n x_offset=3, y_offset=-1, source=source4,\n text_font_size='10pt', render_mode='canvas')\n p.add_layout(labels2)\n\n show(p)","def visualization(image_path, points, label, vis_color=(255, 255, 255)):\r\n points = np.asarray(points, dtype=np.int32)\r\n points = np.reshape(points, [-1, 2])\r\n image = cv2.imread(image_path)\r\n cv2.polylines(image, [points], 1, (0, 255, 0), 2)\r\n image = Image.fromarray(image)\r\n FONT = ImageFont.truetype(font_path, 20, encoding='utf-8')\r\n DRAW = ImageDraw.Draw(image)\r\n\r\n DRAW.text(points[0], label, vis_color, font=FONT)\r\n return np.array(image)","def show_flow(filename):\n flow = read_flow(filename)\n img = flow_to_image(flow)\n plt.imshow(img)\n plt.show()","def images_show(images: Sequence, labels: Sequence[str] = None, title: str = '') -> None:\n\n nb_img = len(images)\n\n if nb_img == 0:\n raise ValueError('No image to print')\n\n # Only on image, no need of subplot\n if nb_img == 1:\n plt.imshow(images[0], interpolation='none')\n plt.axis('off')\n title_str = ''\n if title:\n title_str = title\n if labels and len(labels) > 0 and labels[0]:\n if len(title_str) > 0:\n title_str += '\\n' + labels[0]\n else:\n title_str = labels[0]\n if len(title_str) > 0:\n plt.title(title_str)\n\n # More than 1 image\n else:\n if nb_img < 4:\n # For 3 or below just plot them in one line\n nb_rows = 1\n nb_cols = nb_img\n else:\n nb_rows = nb_cols = ceil(sqrt(nb_img))\n nb_rows = ceil(nb_img / nb_rows) # Remove empty rows if necessary\n\n # Create subplots\n fig, axs = plt.subplots(nrows=nb_rows, ncols=nb_cols, figsize=(nb_cols * 2, nb_rows * 2 + 1))\n\n for row in range(nb_rows):\n for col in range(nb_cols):\n i = row * nb_cols + col\n if nb_rows == 1:\n ax = axs[col]\n else:\n ax = axs[row, col]\n # Disable axis even if no image\n ax.axis('off')\n # Add image and image caption\n if i < len(images):\n ax.imshow(images[i], interpolation='none')\n if labels and len(labels) > i and labels[i]:\n ax.set_title(labels[i])\n\n if title:\n fig.suptitle(title)\n\n # Adjust the padding between and around subplots\n plt.tight_layout()\n # Show it\n plt.show()","def img_render(kve, lopt_str, sopt_str, gopt_str, popt_str, glopt_str, img_path):\n i_before = ''\n i_layer = ''\n i_after = ''\n i_label_str_html = ''\n if 'img' in kve:\n img_paths = [x.strip() for x in kve['img'].split(':')]\n for opt_str in glopt_str, popt_str, gopt_str, sopt_str, lopt_str:\n if 'autoilabel' in opt_str:\n i_label_str = os.path.splitext(os.path.basename(img_paths[0]))[0]\n i_label_str_html = ' <div class=\"label bottom\">' \\\n + i_label_str + '</div>'\n if 'ilabel' in kve:\n i_label_str = kve['ilabel']\n i_label_str_html = ' <div class=\"label bottom\">' \\\n + i_label_str + '</div>'\n img_tag_str = ''\n for idx, path in enumerate(img_paths):\n img_tag_str = img_tag_str + '<img src=\"' + img_path + img_paths[idx] + '\"/>'\n for opt_str in [glopt_str, popt_str, gopt_str, sopt_str, lopt_str]:\n if 'ibefore' in opt_str:\n i_before = ' <div class=\"layout ' + lopt_str \\\n + '\"><div class=\"img\">' + img_tag_str + '</div>' \\\n + i_label_str_html + '</div>'\n if 'iafter' in opt_str:\n i_after = ' <div class=\"layout ' + lopt_str \\\n + '\"><div class=\"img\">' + img_tag_str + '</div>' \\\n + i_label_str_html + '</div>'\n if not (i_before or i_after):\n i_layer = ' <div class=\"img\">' + img_tag_str + '</div>'\n return i_before, i_layer, i_after\n return '', '', ''","def on_pushButton_2_clicked(self):\n # TODO: not implemented yet\n try:\n str='str.png'\n process_pic.graphics ().process (str)\n self.click=\"process\"\n pixMap = QPixmap(\"temp.png\").scaled(self.label.width(),self.label.height())\n self.label.setPixmap(pixMap)\n except:\n button=QMessageBox.about(self, '注意', '应先向空白处导入图片后再进行处理')\n else:\n pass\n\n\n\n #os.popen('python process_pic.py')","def get_image_path_label(all_paths):\r\n n_folders_int = random.sample(range(0, len(all_paths)), n_way)\r\n image_labels = [[(glob.glob(all_paths[n] + '\\*')[k], n) # (path, label)\r\n for n in n_folders_int\r\n for k in random.sample(range(0, len(glob.glob(all_paths[n] + '\\*'))), k_shot+1)\r\n ] for b in range(batch_size)] \r\n return image_labels","def DrawImageLabel(*args, **kwargs):\n return _gdi_.PseudoDC_DrawImageLabel(*args, **kwargs)","def draw_image(res, train, label, output_dir, fig, write_file=False):\n size = len(label)\n infer_res, infer_conf, gt_conf = compare_result(res, label)\n if not os.path.exists(output_dir+\"/correct\"):\n os.makedirs(output_dir+\"/correct\")\n if not os.path.exists(output_dir + \"/incorrect\"):\n os.makedirs(output_dir + \"/incorrect\")\n\n if write_file:\n cor = open(output_dir+\"/res_correct.txt\", 'a')\n err = open(output_dir+\"/res_incorrect.txt\", 'a')\n # right inferences\n r = 0\n # error inferences\n e = 0\n # error details\n count = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n for i in range(size):\n img = Image.fromarray(train[i].reshape(fig, fig).astype(np.uint8))\n if infer_res[i] == label[i]:\n r += 1\n img.save(output_dir+\"/correct/\"+str(i)+\"_\"+str(infer_res[i])+\"_\"+str(infer_conf[i])+\".png\")\n if write_file:\n cor.write(str(i)+\"_\"+str(infer_res[i])+\"_\"+str(infer_conf[i])+str(res[i][0][0][0])+'\\n')\n\n else:\n\n e += 1\n img.save(output_dir + \"/incorrect/\" + str(i) + \"_gt:\" + str(label[i]) + \"_\" + str(\n gt_conf[i]) + \"_inf:\" + str(infer_res[i]) + \"_\" + str(infer_conf[i]) + \".png\")\n count[label[i]] += 1\n if write_file:\n err.write(str(i) + \"_gt:\"+str(label[i]) + \"_\"+str(gt_conf[i]) + \"_inf:\"+str(infer_res[i])+\"_\" +\n str(infer_conf[i]) + str(res[i][0][0][0]) + '\\n')\n if write_file:\n cor.close()\n err.close()\n print(\"correct inference results:\"+str(r))\n print(\"incorrect inference results:\" + str(e))\n print(\"incorrect inference results details:\" + str(count))","def show_shot(path_to_images, name_image):\n crrt_image = misc.imread(\"./{}/{}\".format(path_to_images, name_image))\n\n plt.imshow(crrt_image)\n\n plt.draw()\n plt.pause(0.5)","def display_sample(display_list):\n plt.figure(figsize=(18, 18))\n\n title = ['Input Image', 'True Mask', 'Predicted Mask']\n\n for i in range(len(display_list)):\n plt.subplot(1, len(display_list), i+1)\n plt.title(title[i])\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\n plt.axis('off')\n plt.show()","def plot_fig2(tables_task_ids):\n from snep.tables.experiment import ExperimentTables\n\n tables, task_ids = tables_task_ids['test0']\n assert isinstance(tables, ExperimentTables) # This allows PyCharm to autocomplete method names for tables\n params = tables.get_general_params(True)\n param_ranges = tables.read_param_ranges()\n\n # filter tasks to only the ones that reach the targets\n targets = [{('c',): 0, ('bfb',): 0}]\n target_ids = filter_tasks(task_ids, targets)\n\n # -------------------------------------\n # Get experiment results and params\n # -------------------------------------\n # Simulation times\n ntrls = len(target_ids)\n sub = params['sen']['populations']['sub']\n settletime = params['simulation']['settletime'] / second\n runtime = params['simulation']['runtime'] / second - settletime\n stimon = params['simulation']['stimon'] / second - settletime\n stimoff = params['simulation']['stimoff'] / second - settletime\n pops, timepoints = tables.get_raw_data(task_ids[0])['poprates_dec'].shape\n dt = runtime / timepoints\n nSE, downsampltimepoints = tables.get_computed(task_ids[0])['spikes'].shape\n time = np.linspace(0, runtime, timepoints)\n downsampltime = np.linspace(0, runtime, downsampltimepoints)\n downsampldt = runtime / downsampltimepoints\n\n # allocate variables\n rateDE = np.empty((ntrls, pops, timepoints), dtype='float32')\n rateSE = np.empty((ntrls, pops, timepoints), dtype='float32')\n spksSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\n # evntSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\n # brstSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\n # snglSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\n pref_msk = np.empty((ntrls, 1), dtype='int')\n\n # loop through trials and retrieve results\n for trl, tid in tqdm(enumerate(target_ids)):\n # get neurometric info of all neurons\n computed = tables.get_computed(tid)\n spksSE[trl] = computed['spikes']\n # evntSE[trl] = computed['events']\n # brstSE[trl] = computed['bursts']\n # snglSE[trl] = computed['singles']\n\n # population rates\n raw_data = tables.get_raw_data(tid)\n rateDE[trl] = raw_data['poprates_dec'] # 0: pref, 1: npref\n rateSE[trl] = raw_data['poprates_sen'] # 0: pref, 1: npref\n pref_msk[trl] = raw_data['pref_msk']\n\n # -------------------------------------\n # Choice probability and correlations\n # -------------------------------------\n # accuracy\n acc = pref_msk.sum() / ntrls\n\n # get active neurons, 100 per subpopulation\n actn = get_actn(spksSE, sub)\n\n # a calculation every 1, 5 or 10 ms?\n stepCP = 10\n auc1 = get_CPs(spksSE, np.logical_not(pref_msk), actn[0], downsampldt, step=stepCP)\n auc2 = get_CPs(spksSE, pref_msk.astype(bool), actn[1], downsampldt, step=stepCP)\n auc12 = np.concatenate((auc1, auc2), axis=0)\n\n stepCorr = 50\n corrsall, corrsii, corrsij = get_corr(spksSE, actn, downsampldt, step=stepCorr)\n\n # -------------------------------------\n # Plot figure 2\n # -------------------------------------\n fig, axs = plt.subplots(4, 1, figsize=(8, 12), sharex=True)\n\n fig.add_axes(axs[0])\n plt.plot(time, rateDE[:, 0, :].mean(axis=0), c='C3', lw=2, label='preferred')\n plt.plot(time, rateDE[:, 1, :].mean(axis=0), c='C0', lw=2, label='non-preferred')\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=1.5)\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=1.5)\n plt.title('Integration circuit')\n plt.ylabel('Population rate (sp/s)') # , {'horizontalalignment': 'right'}\n plt.ylim(0, 50)\n # plt.legend(loc='center right', bbox_to_anchor=(1.22, 0.82))\n\n # sensory circuit\n fig.add_axes(axs[1])\n plt.plot(time, rateSE[:, 0, :].mean(axis=0), c='C3', lw=2, label='preferred')\n plt.plot(time, rateSE[:, 1, :].mean(axis=0), c='C0', lw=2, label='pon-preferred')\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\n plt.title('Sensory circuit')\n plt.ylabel('Population rate (sp/s)')\n plt.ylim(0, 20) # 0, 15\n plt.legend(loc='center', bbox_to_anchor=(0.76, 0.91), ncol=2, fontsize='x-small')\n\n # CPs\n # clean to plot\n aucm = auc12.mean(axis=0)\n ymin = 0.45\n cleanaucm = np.ones(aucm.shape) * np.nan\n cleanaucm[aucm > ymin] = aucm[aucm > ymin]\n\n fig.add_axes(axs[2])\n plt.plot(downsampltime[::stepCP][1:], cleanaucm, 'k', lw=2)\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\n plt.ylabel('Choice prob.')\n plt.ylim(ymin, ymin + 0.2) # ymin+0.2\n\n # correlations\n fig.add_axes(axs[3])\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsall, axis=0), c='k', lw=2, label='EE')\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsii, axis=0), c='C4', lw=2, label='EiEi')\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsij, axis=0), c='C2', lw=2, label='EjEj')\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\n plt.xlim(stimon - 0.5, stimoff + 0.5)\n plt.ylim(-0.2, 0.2) # -0.25, 0.25\n plt.xlabel('Time (s)')\n plt.ylabel('Noise correlations')\n plt.legend(loc='center', bbox_to_anchor=(0.77, 0.95), ncol=3, fontsize='x-small')\n\n # save figure\n #savepath = '/Users/PSR/Documents/WS19/MasterThesis/Experiments/run_hierarchical/'\n fig.savefig(load_path + '/' + thisexperiment + '/figure2.png')\n plt.close(fig)\n\n # -------------------------------------\n # Save analysis\n # -------------------------------------\n thisanalysisname = '/CPs-' + str(ntrls) + 'trls-' + str(targets) + '.pkl'\n\n # save variables\n with open(savepath + thisexperiment + thisanalysisname, 'wb') as f:\n pickle.dump([pref_msk,\n actn,\n auc12,\n [corrsall, corrsii, corrsij]], f)\n\n # TODO: plot burst probability and coherence levels\n # TODO: plot accuracy!","def labelling():\n title = input('Please enter the title of output figure: ')\n plt.title(title)\n plt.xlabel(\"Time (s)\")\n plt.ylabel(\"Voltage (V)\")\n plt.legend()\n plt.savefig(\"Scope_%s\"%str(round(time.time()))) # Time stamp on file names\n plt.show()","def show(image,label,pred):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n s=\"True Label : \"+str(label)+\" Predicted label : \"+str(pred)\n pyplot.xlabel(s,fontname=\"Arial\", fontsize=20 )\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.show()","def save_images(PATH, show_img, datasets, from_dataset):\n dataset = datasets[from_dataset]\n imgModels = dataset['models']\n for modelname, model in imgModels.items():\n print('save', modelname)\n plt.imshow(model[70])\n plt.set_cmap(\"gray\")\n plt.axis('off')\n plt.savefig(PATH + '/' + from_dataset + '_' + modelname + '.png', dpi=400)\n\n if show_img == True:\n plt.show()","def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n for i in range(n_row * n_col):\n plt.subplot(n_row, n_col, i + 1)\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\n plt.title(titles[i], size=12)\n plt.xticks(())\n plt.yticks(())\n plt.show()\n plt.savefig(\"feature_{}.png\".format(50))","def visualize_image(images, save_name):\n dim = images.shape[0]\n n_image_rows = int(np.ceil(np.sqrt(dim)))\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\n right=1., left=0., hspace=0., wspace=0.)\n\n for g, count in zip(gs, range(int(dim))):\n ax = plt.subplot(g)\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\n ax.set_xticks([])\n ax.set_yticks([])\n plt.savefig(save_name + '_vis.png')","def plot_imgs_and_ctrs_itk(self, itk_imgs: list, itk_ctrs: list, slices=SliceMode.ALL, title='',\n plane=PlaneTypes.AXIAL, draw_only_ctrs=True, file_name_prefix='', labels=[]):\n args = {\n 'imgs': [sitk.GetArrayFromImage(itk_img) for itk_img in itk_imgs],\n 'ctrs': [sitk.GetArrayFromImage(itk_ctr) for itk_ctr in itk_ctrs],\n 'slices': slices,\n 'plane': plane,\n 'draw_only_ctrs': draw_only_ctrs,\n 'file_name_prefix': file_name_prefix,\n 'labels': labels,\n 'title': title\n }\n self._plot_imgs_and_ctrs_np(args)","def create_png(image, label):\n sv = \"/home/avojtekova/Desktop/final_results/star_det/generated_images/\" \n \n for i in range(len(image)):\n data = fits.getdata(image[i][0], ext = 0)\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\n \n print(image[i][0])\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \n plt.title(label[i])\n plt.axis('off')\n plt.tight_layout()\n plt.legend\n if i<2:\n if not os.path.isdir(sv + image[i][0][-33:-25] + \"/\") :\n os.makedirs(sv + image[i][0][-33:-25] + \"/\")\n plt.savefig(sv + image[i][0][-33:-25] + \"/\" + label[i]+ \"_\" + image[i][0][-33:-25] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \n else:\n if not os.path.isdir(sv + image[i][0][-40:-32] + \"/\") :\n os.makedirs(sv + image[i][0][-40:-32] + \"/\")\n plt.savefig(sv + image[i][0][-40:-32] + \"/\" + label[i]+image[i][0][-40:-32] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\n plt.close()"],"string":"[\n \"def plot_oneshot_task(pairs):\\n fig,(ax1,ax2) = plt.subplots(2)\\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\\n img = concat_images(pairs[1])\\n ax1.get_yaxis().set_visible(False)\\n ax1.get_xaxis().set_visible(False)\\n ax2.matshow(img,cmap='gray')\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def run_path_visualisation(paths, config, modulesConfig):\\n all_targets = [os.path.basename(config[s][\\\"target\\\"]) for s in config.sections]\\n all_target_tasks = {os.path.basename(config[s][\\\"target\\\"]):s for s in config.sections}\\n \\n added_tasks = []\\n prepared_paths = []\\n for path in paths:\\n prepared_tasks = []\\n for idx, task in enumerate(list(reversed(path))):\\n s_module, s_name, *identifier = task.split(\\\" \\\")\\n\\n # Special Rule For Join Module To Have A Connection To Another Module\\n special_connection = False\\n if s_module == \\\"processing_join\\\":\\n args = config[task]\\n con_module, con_name, *identifier = all_target_tasks.get(os.path.basename(args[\\\"joinwith\\\"]), s_module+\\\"_SPECIAL \\\"+s_name+\\\"_SPECIAL\\\").split(\\\" \\\")\\n special_connection = {\\n \\\"connection_to_module\\\" : con_module,\\n \\\"connection_to_name\\\" : con_name,\\n \\\"will_be_created\\\" : (os.path.basename(args[\\\"joinwith\\\"]) in all_targets)\\n }\\n\\n prepared_tasks.append({\\n 'module':s_module,\\n 'name':s_name,\\n 'display': (task not in added_tasks),\\n 'specialConnection': special_connection,\\n 'last': (idx == len(path) - 1),\\n 'attributes': config[task]\\n })\\n added_tasks.append(task)\\n prepared_paths.append(prepared_tasks)\\n logger.debug(\\\"Path prepared for visualization!\\\")\\n render_path_visualisation(config['projectRoot'], config['projectName'], prepared_paths)\",\n \"def plot12(self, dataset, ts_string_indices, source_jpg_folder='jpg_images', extension='jpg', rows=3, cols=4,\\n outfname='Sample Frames.png', cmap=None, gui_color='green'):\\n # Settings ############################################################\\n font_label_box = {\\n 'color': 'green',\\n 'size': 16,\\n }\\n font_steering = {'family': 'monospace',\\n # 'color': 'darkred',\\n 'weight': 'normal',\\n 'size': 20,\\n }\\n ROWS = rows\\n COLS = cols\\n NUM_IMAGES = ROWS * COLS\\n\\n # Figure ##############################################################\\n # figsize = [width, height]\\n fig = plt.figure(figsize=PAPER_A3_LAND, facecolor='white')\\n fig.suptitle(\\\"Sample frames, Dataset: {}\\\".format(dataset.data_folder), fontsize=20)\\n\\n for i, ts_string_index in enumerate(ts_string_indices):\\n rec = dataset.df.loc[ts_string_index]\\n\\n timestamp_string = rec['datetime'].strftime(\\\"%D %H:%M:%S.\\\") + \\\"{:.2}\\\".format(\\n str(rec['datetime'].microsecond))\\n\\n if 'steering_pred_signal' in dataset.df.columns:\\n this_label = \\\"{}\\\\n{:0.2f}/{:0.2f} steering \\\\n{:0.2f} throttle\\\".format(timestamp_string,\\n rec['steering_signal'],\\n rec['steering_pred_signal'],\\n rec['throttle_signal'])\\n else:\\n this_label = \\\"{}\\\\n{:0.2f}/ steering \\\\n{:0.2f} throttle\\\".format(timestamp_string, rec['steering_signal'],\\n rec['throttle_signal'])\\n\\n ax = fig.add_subplot(ROWS, COLS, i + 1)\\n\\n # Main Image ##########################################################\\n jpg_path = os.path.join(dataset.path_dataset, source_jpg_folder, ts_string_index + '.' + extension)\\n assert os.path.exists(jpg_path), \\\"{} does not exist\\\".format(jpg_path)\\n img = mpl.image.imread(jpg_path)\\n ax.imshow(img, cmap=cmap)\\n # plt.title(str_label)\\n\\n # Data box ########################################################\\n\\n # ax.axes.get_xaxis().set_visible(False)\\n # ax.axes.get_yaxis().set_visible(False)\\n t = ax.text(5, 25, this_label, color=gui_color, alpha=1)\\n # t = plt.text(0.5, 0.5, 'text', transform=ax.transAxes, fontsize=30)\\n t.set_bbox(dict(facecolor='white', alpha=0.7, edgecolor='none'))\\n\\n # Steering widget HUD #################################################\\n # Steering HUD: Actual steering signal\\n steer_actual = ''.join(['|' if v else '-' for v in dataset.linear_bin(rec['steering_signal'])])\\n text_steer = ax.text(80, 105, steer_actual, fontdict=font_steering, horizontalalignment='center',\\n verticalalignment='center', color=gui_color)\\n # Steering HUD: Predicted steering angle\\n if 'steering_pred_signal' in dataset.df.columns:\\n steer_pred = ''.join(['◈' if v else ' ' for v in dataset.linear_bin(rec['steering_pred_signal'])])\\n text_steer_pred = ax.text(80, 95, steer_pred, fontdict=font_steering, horizontalalignment='center',\\n verticalalignment='center', color='red')\\n\\n outpath = os.path.join(dataset.path_dataset, outfname)\\n fig.savefig(outpath)\\n logging.debug(\\\"Wrote Sample Frames figure to {}\\\".format(outpath))\",\n \"def _convert_path_list_to_images_and_labels(self, path_list, is_one_shot_task):\\n number_of_pairs = int(len(path_list) / 2)\\n pairs_of_images = [np.zeros(\\n (number_of_pairs, self.image_height, self.image_height, 1)) for i in range(2)]\\n labels = np.zeros((number_of_pairs, 1))\\n\\n for pair in range(number_of_pairs):\\n image = Image.open(path_list[pair * 2])\\n image = np.asarray(image).astype(np.float64)\\n image = image / image.std() - image.mean()\\n\\n pairs_of_images[0][pair, :, :, 0] = image\\n image = Image.open(path_list[pair * 2 + 1])\\n image = np.asarray(image).astype(np.float64)\\n image = image / image.std() - image.mean()\\n\\n pairs_of_images[1][pair, :, :, 0] = image\\n if not is_one_shot_task:\\n if (pair + 1) % 2 == 0:\\n labels[pair] = 0\\n else:\\n labels[pair] = 1\\n\\n else:\\n if pair == 0:\\n labels[pair] = 1\\n else:\\n labels[pair] = 0\\n\\n if not is_one_shot_task:\\n random_permutation = np.random.permutation(number_of_pairs)\\n labels = labels[random_permutation]\\n pairs_of_images[0][:, :, :,\\n :] = pairs_of_images[0][random_permutation, :, :, :]\\n pairs_of_images[1][:, :, :,\\n :] = pairs_of_images[1][random_permutation, :, :, :]\\n\\n return pairs_of_images, labels\",\n \"def makeGanttChart(mode, fileName):\\n\\n figType = OUTPUT_FILE_EXTENSION # \\\"png\\\", \\\"eps\\\"\\n\\n # extract the figure name and target directory (to store the figures)\\n figureFileName = fileName[0:-6]\\n k = figureFileName.rfind(\\\"/\\\") + 1\\n figureFileName = figureFileName[k:]\\n k = fileName.rfind(\\\"/\\\") + 1\\n targetDirectory = \\\"\\\"\\n if k == 0:\\n targetDirectory = \\\"./\\\"\\n else:\\n targetDirectory = fileName[0:k]\\n targetFname = targetDirectory + figureFileName + \\\".\\\" + figType\\n\\n # import the tasks\\n tasks = parseTasks(mode, fileName)\\n machines = sorted(getMachines(tasks))\\n orders = sorted(getOrders(tasks))\\n processingUnits = sorted(getProccessingUnits(tasks))\\n operations = sorted(getOperations(tasks))\\n\\n if mode == \\\"MTS\\\":\\n tasks = consolidateSiblingTasks(tasks, machines)\\n tasks = removeDuplicateTasks(tasks)\\n if checkForOverlappingTasks(tasks, machines):\\n print(\\\"ERROR! Found overlapping tasks, check your input file!\\\")\\n exit(5)\\n\\n # Print all of the read tasks in DEBUG mode\\n if MYDEBUG:\\n for t in tasks:\\n t.print()\\n\\n # build the figure\\n fig = plt.figure(figsize=(10, 5), dpi=DPI) # <------ USER OPTION HERE -----------------\\n ax = fig.add_subplot(111)\\n ax.set_title(figureFileName)\\n\\n # set up the axes\\n y_pos = np.arange(len(machines))\\n ax.set_yticks(y_pos)\\n ax.set_ylim(min(y_pos) - 0.7, max(y_pos) + 0.7)\\n ax.set_yticklabels(machines)\\n ax.set_xlabel(\\\"Time (Hours)\\\")\\n x_pos = np.arange(math.ceil(getMakeSpan(tasks))+1)\\n ax.set_xticks(x_pos)\\n ax.set_axisbelow(True)\\n ax.grid(b=True, which=\\\"major\\\", axis=\\\"x\\\", alpha=0.5)\\n\\n # assign a unique color to each order and each operation\\n # http://matplotlib.org/examples/color/colormaps_reference.html\\n cmapOrders = plt.cm.Pastel2(np.linspace(0, 1, len(orders)))\\n cmapOperations = plt.cm.Pastel2(np.linspace(0, 1, len(operations)))\\n\\n # plot the task rectangles\\n # https://stackoverflow.com/questions/21397549/stack-bar-plot-in-matplotlib-and-add-label-to-each-section-and-suggestions\\n for i, m in enumerate(machines):\\n compatibleTasks = []\\n for t in tasks:\\n if m == t.machine:\\n compatibleTasks.append(t)\\n slots = [] # time slots for machine m\\n for ct in compatibleTasks:\\n for ct in compatibleTasks:\\n thisSlot = (ct.tBegin, ct.tEnd)\\n if thisSlot not in slots:\\n slots.append(thisSlot)\\n slots = sorted(slots)\\n if mode == \\\"SCH\\\":\\n for s, slt in enumerate(slots):\\n thisBatchSize = \\\"\\\"\\n thisOperation = \\\"\\\"\\n for ct in compatibleTasks:\\n if (ct.tBegin, ct.tEnd) == slt:\\n thisBatchSize = ct.batchSize\\n thisOperation = ct.operation\\n thisColor = cmapOperations[operations.index(thisOperation)]\\n h = ax.barh(i, width=slots[s][1]-slots[s][0], left=slots[s][0], align='center', color=thisColor)\\n bl = h[0].get_xy()\\n x = 0.5*h[0].get_width() + bl[0]\\n y = 0.5*h[0].get_height() + bl[1]\\n ax.text(x, y, str(thisBatchSize), ha='center',va='center')\\n elif mode == \\\"MTS\\\":\\n for s, slt in enumerate(slots):\\n # Get the MAIN task corresponding to the current time slot\\n currentTask = 0\\n for ct in compatibleTasks:\\n if (ct.tBegin, ct.tEnd) == slt:\\n currentTask = ct\\n # Plot the unique task\\n if len(currentTask.subtasks) == 0:\\n duration = slots[s][1]-slots[s][0]\\n thisColor = cmapOrders[orders.index(currentTask.order)]\\n\\n h = []\\n h.append(ax.barh(i, width=duration, left=slots[s][0], align='center', color=\\\"grey\\\", alpha=0.7))\\n h.append(ax.barh(i, width=duration - 2*MARGIN, left=slots[s][0] + MARGIN, align='center',\\n color=thisColor, height=0.65, linewidth=0))\\n bl = h[0][0].get_xy()\\n x = 0.5*h[0][0].get_width() + bl[0]\\n y = 0.5*h[0][0].get_height() + bl[1]\\n thisBatchSize = currentTask.batchSize\\n ax.text(x, y, str(thisBatchSize), ha='center',va='center', size=LABEL_SIZE)\\n else:\\n # Plot first the MAIN task\\n duration = slots[s][1]-slots[s][0]\\n barHandles = []\\n barHandles.append(ax.barh(i, width=duration, left=slots[s][0],\\n align='center', color=\\\"grey\\\", alpha=0.7))\\n bl = barHandles[0][0].get_xy()\\n l = slots[s][0] + MARGIN\\n # Plot the SUB tasks\\n for counter, thisSub in enumerate(currentTask.subtasks):\\n thisColor = cmapOrders[orders.index(thisSub.order)]\\n partialDuration = (thisSub.batchSize/currentTask.batchSize) * duration - \\\\\\n 2*MARGIN/len(currentTask.subtasks)\\n barHandles.append(ax.barh(i, width=partialDuration, left=l, align='center', height=0.65, linewidth=0,\\n color=thisColor))\\n bl = barHandles[-1][0].get_xy()\\n x = 0.5*barHandles[-1][0].get_width() + bl[0]\\n y = 0.5*barHandles[-1][0].get_height() + bl[1]\\n thisBatchSize = thisSub.batchSize\\n ax.text(x, y, str(thisBatchSize), ha='center',va='center', size=LABEL_SIZE)\\n l = l + partialDuration\\n else:\\n print(\\\"INVALID MODE\\\")\\n exit(5)\\n\\n # Show / print the figure\\n fig.savefig(targetFname, dpi=DPI)\\n # if MYDEBUG:\\n # plt.show()\\n plt.clf()\\n plt.close()\\n\\n\\n # plot a legend (print in different file)\\n if PLOT_LEGENDS:\\n if mode == \\\"SCH\\\":\\n pat = []\\n leg = plt.figure(figsize=(5, 5), dpi=DPI)\\n frame = plt.gca()\\n frame.axes.get_xaxis().set_visible(False)\\n frame.axes.get_yaxis().set_visible(False)\\n leg.patch.set_visible(False)\\n for op in operations:\\n thisColor = cmapOperations[operations.index(op)]\\n pat.append(mpatches.Patch(color=thisColor, label=op))\\n plt.legend(handles=pat)\\n leg.savefig(targetDirectory + figureFileName + \\\"_legend.\\\" + figType, dpi=DPI)\\n elif mode == \\\"MTS\\\":\\n pat = []\\n leg = plt.figure(figsize=(5, 5), dpi= DPI)\\n frame = plt.gca()\\n frame.axes.get_xaxis().set_visible(False)\\n frame.axes.get_yaxis().set_visible(False)\\n leg.patch.set_visible(False)\\n for ord in orders:\\n thisColor = cmapOrders[orders.index(ord)]\\n pat.append(mpatches.Patch(color=thisColor, label=ord))\\n plt.legend(handles=pat)\\n leg.savefig(targetDirectory + figureFileName + \\\"_legend.\\\" + figType, dpi=DPI)\\n else:\\n print(\\\"INVALID MODE\\\")\\n exit(5)\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def _load_img_label(self):\\n name = self._launch_file_b()\\n self._img_label.configure(text=name)\",\n \"def plots_from_files(imspaths, figsize=(10,5), rows=1, titles=None, maintitle=None):\\n f = plt.figure(figsize=figsize)\\n if maintitle is not None:\\n plt.suptitle(maintitle, fontsize=16) \\n for i in range(len(imspaths)):\\n sp = f.add_subplot(rows, len(imspaths)//rows, i+1)\\n sp.axis('Off')\\n if titles is not None: sp.set_title(titles[i], fontsize=16)\\n img = plt.imread(imspaths[i])\\n plt.imshow(img)\",\n \"def draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list):\\n img_path=os.path.join(root_folder_path,root_folder_name,img_type,img_name+\\\".png\\\")\\n img=cv2.imread(img_path)\\n for each_bb in bb_list:\\n cv2.rectangle(img,(each_bb[0],each_bb[2]),(each_bb[1],each_bb[3]),bb_color,3)\\n cv2.putText(img,class_name,(each_bb[0],each_bb[3]),cv2.FONT_HERSHEY_SIMPLEX,1,(255,0,0),2,cv2.LINE_AA)\\n cv2.imwrite(img_path,img)\",\n \"def plot_images(imgs, lbls=None, cols=4, rows=5, save_path=None):\\n # numpy array to list\\n if not type(imgs) is list:\\n imgs = list(imgs)\\n # 1. check if the parameters are correct\\n assert(len(imgs) == cols*rows)\\n if not lbls is None:\\n assert(len(lbls) == len(imgs))\\n\\n # 2. create the figure\\n fig = plt.figure()\\n\\n # 3. iterate over the rows and cols\\n for i in range(1, cols*rows + 1):\\n # add the next subplot\\n fig.add_subplot(rows, cols, i)\\n # plot the image\\n plt.imshow(imgs[i-1])\\n # check if a lbls list is specified\\n if not lbls is None:\\n # show the lbl of the image\\n plt.title(lbls[i-1])\\n plt.tight_layout(pad=0.6)\\n\\n if not save_path is None:\\n plt.savefig(save_path)\\n else: \\n plt.show()\",\n \"def read_files_and_visualize(data):\\n\\n image = cv2.imread(data[0])\\n label = cv2.imread(data[1], 0)\\n name = data[1].split('/')[-1].split('.')[0]\\n obj_label = None\\n\\n if generator_options.save_label_preview:\\n obj_label = []\\n if os.path.isfile(data[2]):\\n with open(data[2], 'r') as f:\\n obj = csv.reader(f, delimiter=',')\\n for row in obj:\\n row = [int(r.split('.')[0]) if index != 0 else r\\n for index, r in enumerate(row)]\\n obj_label.append(row)\\n\\n else:\\n label_vals = np.unique(label)\\n for val in label_vals:\\n obj_label.append([_LABEL_DEF_FULL[val], 0, 0, 0, 0])\\n\\n save_visuals(image, label, obj_label, name)\",\n \"def load_imgsLabels(self, image_paths):\\n \\n# label = image_paths[-1]\\n \\n images = self.load_images(image_paths)\\n \\n images = self.resize_images(images)\\n \\n images_list = self.greyscale_images(images)\\n\\n return images_list\",\n \"def get_path_image(path_data, label, filename):\\n\\n return path_data.joinpath(f'label_{label}', filename)\",\n \"def work(q, example_paths, label_paths, total_files, export_path_example, export_path_label, size, layover, input_size):\\n\\n while not q.empty():\\n try:\\n i = q.get(False)\\n except Empty:\\n break\\n\\n # Show progress\\n utils.print_process(total_files - q.qsize(), total_files)\\n\\n # We assume that related examples and labels have the same index in the path lists\\n example_path = example_paths[i]\\n label_path = label_paths[i]\\n\\n # Creates masks for the image pairs\\n mask_image(example_path, export_path_example, size, layover, input_size)\\n mask_image(label_path, export_path_label, size, layover, input_size)\\n\\n q.task_done()\",\n \"def plot_labels(lbl: scipy.ndarray, lbl_count: int) -> None:\\n color_map = scipy.rand(lbl_count, 3)\\n color_map = matplotlib.colors.ListedColormap(color_map)\\n plt.imshow(lbl, cmap=color_map)\\n plt.show()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def plot_image(img, label=\\\"\\\"): \\n if img.shape[0] == 3:\\n img = img.transpose(1,2,0)\\n fig,ax = plt.subplots(1)\\n sns.set_style('white')\\n ax.imshow(np.asarray(img))\\n if label!=\\\"\\\":\\n plt.title(number_label[label])\\n return fig,ax\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def plotImages(image_list, name_list, path, as_grey, toSave=False):\\n\\n\\tfig = plt.figure()\\n\\timageCoordinate = 100 + 10*len(image_list) + 1\\n\\ti = 0\\n\\n\\tfor image in image_list:\\n\\t\\tfig.add_subplot(imageCoordinate)\\n\\t\\tplt.title(name_list[i])\\n\\t\\tplt.axis('off')\\n\\t\\tplt.imshow(image)\\n\\t\\tif as_grey:\\n\\t\\t\\tplt.set_cmap('gray')\\n\\n\\t\\timageCoordinate += 1\\n\\t\\ti += 1\\n\\n\\tif toSave:\\n\\t\\tplt.savefig(path + \\\".jpg\\\",bbox_inches='tight')\\n\\tplt.show()\",\n \"def plot_list_image_path(list_image_path, log_image_path=False):\\n i = 1\\n nb_img = len(list_image_path)\\n plt.figure(figsize=(10, 2 * nb_img))\\n for image_path in list_image_path:\\n if not os.path.isfile(image_path):\\n continue\\n img = load_img(image_path)\\n plt.subplot(math.ceil(nb_img/3) + 1, 3, i)\\n i += 1\\n if log_image_path:\\n plt.title(image_path)\\n plt.imshow(img)\\n plt.axis('off')\\n plt.show()\",\n \"def _plot_imgs_and_ctrs_np(self, config) -> None:\\n imgs = config['imgs']\\n ctrs = config['ctrs']\\n orig_slices = config['slices']\\n plane = config['plane']\\n title = config['title']\\n draw_only_ctrs = config['draw_only_ctrs']\\n file_name_prefix = config['file_name_prefix']\\n labels = config['labels']\\n\\n create_folder(self._output_folder)\\n if plane != PlaneTypes.ALL: # Draw single plane\\n # This should plot a single image with all the contours overlayed\\n first_img_shape = imgs[0].shape\\n # Validate the size of the images\\n for c_img in imgs:\\n if c_img.shape != first_img_shape:\\n raise Exception('The shape of the images must be the same')\\n\\n slices = get_slices(orig_slices, imgs[0], plane)\\n for c_slice in slices:\\n draw_slice = should_display_slice(ctrs, c_slice, plane, draw_only_ctrs)\\n if draw_slice:\\n fig, ax = plt.subplots(1, len(imgs), squeeze=True, figsize=(8, 8))\\n for img_idx, c_img in enumerate(imgs):\\n img_slice = get_proper_plane(c_img, plane, c_slice)\\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\\n if len(imgs) > 1:\\n plot_slice(img_slice, ctrs_slice, ax[img_idx], labels)\\n else:\\n plot_slice(img_slice, ctrs_slice, ax, labels)\\n c_title = F'{title} {plane.value} {c_slice:04d}'\\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\\n plt.title(c_title, fontsize=20)\\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\\n else:\\n if len(imgs) != 1:\\n raise Exception('The number of image allowed for Plane type ALL must be 1')\\n # In this case it should plot 3 images, one for each plane. Here we force it to plot\\n # only the middle slice\\n c_img = imgs[0]\\n plt.subplots(1, 3, squeeze=True, figsize=(8 * 3, 8))\\n for id_plane, plane in enumerate([PlaneTypes.AXIAL, PlaneTypes.SAGITTAL, PlaneTypes.CORONAL]):\\n ax = plt.subplot(1, 3, id_plane + 1)\\n c_slice = get_slices(SliceMode.MIDDLE, c_img, plane)[0]\\n img_slice = get_proper_plane(c_img, plane, c_slice)\\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\\n plot_slice(img_slice, ctrs_slice, ax, labels)\\n c_title = F'{title} ALL {c_slice:04d}'\\n plt.title(c_title, fontsize=20)\\n\\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\\n\\n self._close_figure()\",\n \"def save_images(self, samples, label=None, dir=\\\"\\\"):\\n if label is None:\\n label = self.global_step_\\n fig = plt.figure()\\n self.net_.eval()\\n self.dist.visualize(fig, samples, self.energy)\\n plot_fn = os.path.join(dir, f\\\"samples_{label}.png\\\")\\n fig.savefig(plot_fn)\\n plt.close(fig)\",\n \"def plot_segmentation_prediction(\\n prediction: ndarray,\\n label: ndarray,\\n raw_img: Image,\\n raw_label: Image,\\n img_shape: tuple,\\n img_name: str,\\n save_path: str,\\n) -> None:\\n raw_img = raw_img.resize(img_shape)\\n\\n final_mask = mark_boundaries(raw_img, prediction == 1, [255, 0, 0])\\n final_mask = mark_boundaries(final_mask, prediction == 2, [0, 255, 0])\\n final_mask = mark_boundaries(final_mask, prediction == 3, [0, 0, 255])\\n\\n final_seg_mask = zeros(img_shape + (3,), uint8)\\n final_seg_mask[prediction == 1] = [255, 0, 0]\\n final_seg_mask[prediction == 2] = [0, 255, 0]\\n final_seg_mask[prediction == 3] = [0, 0, 255]\\n\\n final_label = mark_boundaries(raw_img, label[1], [255, 0, 0])\\n final_label = mark_boundaries(final_label, label[2], [0, 255, 0])\\n\\n if label.shape[0] == 4:\\n final_label = mark_boundaries(final_label, label[3], [0, 0, 255])\\n\\n fig = plt.figure(figsize=(14, 14))\\n\\n fig.add_subplot(2, 2, 1)\\n plt.imshow(final_mask)\\n\\n plt.title(\\\"Prediction\\\")\\n\\n fig.add_subplot(2, 2, 2)\\n plt.imshow(final_seg_mask)\\n plt.title(\\\"Prediction - mask\\\")\\n\\n fig.add_subplot(2, 2, 3)\\n plt.imshow(final_label)\\n plt.title(\\\"Reference\\\")\\n\\n raw_label = array(raw_label)\\n raw_label[(raw_label == [255, 255, 0]).sum(axis=2) == 3] = [255, 0, 0]\\n raw_label = Image.fromarray(raw_label)\\n raw_label = raw_label.resize(img_shape)\\n \\n fig.add_subplot(2, 2, 4)\\n plt.imshow(raw_label)\\n plt.title(\\\"Reference - mask\\\")\\n\\n plt.savefig(join(save_path, img_name))\\n plt.close()\",\n \"def plot_images_grid(images, labels, title):\\n images = images.cpu()\\n labels = labels.cpu()\\n \\n assert type(images[0]) is torch.Tensor, 'Image to plot is not torch.Tensor'\\n image_size = int(np.sqrt(images[0].shape[0]))\\n \\n fig = plt.figure(figsize=(10,4))\\n for idx in range(10):\\n ax = fig.add_subplot(2,10/2,idx+1, xticks=[], yticks=[])\\n ax.imshow(images[idx].view(image_size, image_size), cmap = 'gray')\\n label = labels[idx].item()\\n ax.set_title(label)\\n #end\\n fig.suptitle(title, fontsize = 14)\\n plt.show()\\n plt.close('all')\",\n \"def label_visualize(img_dir):\\n img = scipy.misc.imread(img_dir).astype(np.uint8)\\n yo = np.nonzero(img == 1)\\n visual = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)\\n\\n for i in range(0, 34):\\n index = np.nonzero(img == i)\\n visual[index + (0,)] = labels[i][0]\\n visual[index + (1,)] = labels[i][1]\\n visual[index + (2,)] = labels[i][2]\\n\\n scipy.misc.imsave('./' + img_dir.split('/')[-1], visual)\",\n \"def plot_labelled_images(x, y, filename, y_predict=None):\\n\\n plt.clf()\\n\\n nplot = 10\\n nrows = 2\\n ncols = 5\\n\\n # randomly choose which images from the dataset to plot \\n random_indices = np.random.choice(x.shape[0], size=nplot, replace=False)\\n\\n figure = plt.gcf()\\n\\n for i, index in enumerate(random_indices):\\n ax = figure.add_subplot(nrows, ncols, i + 1, xticks=[], yticks=[])\\n\\n # plot image\\n ax.imshow(np.squeeze(x[index]))\\n\\n # add label as title of image\\n label_index = np.argmax(y[index])\\n label = label_names[label_index]\\n\\n # if predicted labels have been supplied in addition to true labels, show both\\n if y_predict is not None:\\n predicted_label_index = np.argmax(y_predict[index])\\n predicted_label = label_names[predicted_label_index]\\n title = \\\"true={}\\\\n(predicted={})\\\".format(label, predicted_label)\\n\\n # else only show true labels\\n else:\\n title = \\\"true={}\\\".format(label)\\n\\n ax.set_title(title)\\n\\n size = figure.get_size_inches()\\n figure.set_size_inches(size[0]*2, size[1]*2)\\n\\n plt.savefig(filename, bbox_inches='tight')\",\n \"def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\\n batchSize = min(size, images.shape[0])\\n \\n if size == 0:\\n batchSize = images.shape[0]\\n\\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\\n no_of_columns = round(math.sqrt(batchSize))\\n no_of_rows = math.ceil(batchSize / no_of_columns)\\n print(\\\"batch size {}, no_of_rows {}, no_of_columns {}\\\".format(batchSize, no_of_rows, no_of_columns))\\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\\n # (width, height)\\n for idx in np.arange(batchSize):\\n ax = fig.add_subplot(no_of_rows, no_of_columns,\\n idx+1, xticks=[], yticks=[])\\n if greyscale:\\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\\n else:\\n ax.imshow(np.squeeze(images[idx]))\\n # print out the correct label for each image\\n # .item() gets the value contained in a Tensor\\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\\n if not prediction is None:\\n ax.set_title(\\\"{} ({})\\\".format(str(prediction[idx]), str(labels[idx])),\\n color=(\\\"green\\\" if prediction[idx] == labels[idx] else \\\"red\\\"))\\n else:\\n ax.set_title(str(labels[idx]))\",\n \"def plot_image_comparison(name, img_arr):\\n\\n plt.clf()\\n fig = plt.figure()\\n\\n # divide the images into rows and columns\\n num_imgs = len(img_arr)\\n columns = num_imgs // 2\\n rows = math.ceil(num_imgs / columns)\\n\\n for i, vals in enumerate(img_arr):\\n fig.add_subplot(rows, columns, i+1)\\n plt.imshow(vals[\\\"img\\\"], vmin=0, vmax=255)\\n plt.axis(\\\"off\\\")\\n plt.title(vals[\\\"title\\\"], fontsize=8)\\n\\n plt.savefig(f\\\"{name}/comparison.jpeg\\\")\",\n \"def plot_images(images, labels=None, proba=None, ncols=5, models_names=None,\\n classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',\\n 'dog', 'frog', 'horse', 'ship', 'truck'], **kwargs):\\n if isinstance(models_names, str):\\n models_names = (models_names, )\\n if not isinstance(proba, (list, tuple)):\\n proba = (proba, )\\n if models_names is None:\\n models_names = ['']\\n else:\\n if models_names is None:\\n models_names = ['Model ' + str(i+1) for i in range(len(proba))]\\n\\n # if the classes names are not specified they can be implicitely infered from the `proba` shape,\\n if classes is None:\\n if proba[0] is not None:\\n classes = [str(i) for i in range(proba[0].shape[1])]\\n elif labels is None:\\n pass\\n elif proba[0] is None:\\n raise ValueError('Specify classes')\\n\\n n_items = len(images)\\n nrows = (n_items // ncols) + 1\\n fig, ax = plt.subplots(nrows, ncols, **kwargs)\\n ax = ax.flatten()\\n for i in range(n_items):\\n ax[i].imshow(images[i])\\n if labels is not None: # plot images with labels\\n true_class_name = classes[labels[i]]\\n title = 'Label: {}'.format(true_class_name)\\n if proba[0] is not None: # plot images with labels and predictions\\n for j, model_proba in enumerate(proba): # the case of preidctions of several models\\n class_pred = np.argmax(model_proba, axis=1)[i]\\n class_proba = model_proba[i][class_pred]\\n pred_class_name = classes[class_pred]\\n title += '\\\\n {0} pred: {1}, p = {2:.2f}'.format(models_names[j], pred_class_name, class_proba)\\n ax[i].title.set_text(title)\\n ax[i].grid(b=None)\\n\\n for i in range(n_items, nrows * ncols):\\n fig.delaxes(ax[i])\",\n \"def show_result(inputs, labels, outputs):\\n num_classes = outputs.size(1)\\n outputs = outputs.argmax(dim=1).detach().cpu().numpy()\\n if num_classes == 2:\\n outputs *= 255\\n mask = outputs[0].reshape((360, 640))\\n fig, ax = plt.subplots(1, 2, figsize=(20, 1 * 5))\\n ax[0].imshow(inputs[0, :3, :, ].detach().cpu().numpy().transpose((1, 2, 0)))\\n ax[0].set_title('Image')\\n ax[1].imshow(labels[0].detach().cpu().numpy().reshape((360, 640)), cmap='gray')\\n ax[1].set_title('gt')\\n plt.show()\\n plt.figure()\\n plt.imshow(mask, cmap='gray')\\n plt.title('Pred')\\n plt.show()\",\n \"def visualization_one(target_var = None, input_vars= None, output_image_name=None):\\n ###\\n # Main chunk of code here\\n ###\\n\\n # Starter code for labeling the image\\n plt.xlabel(None, figure = fig)\\n plt.ylabel(None, figure = fig)\\n plt.title(None, figure= fig)\\n plt.legend()\\n\\n # exporting the image to the img folder\\n plt.savefig(f'img/{output_image_name}.png', transparent = True, figure = fig)\\n return fig\",\n \"def path_plot(robot_path, regions, obs):\\n\\n for robot, path in robot_path.items():\\n # prefix path\\n if len(path) == 1:\\n continue\\n x_pre = np.asarray([point[0] + 0.5 for point in path])\\n y_pre = np.asarray([point[1] + 0.5 for point in path])\\n plt.quiver(x_pre[:-1], y_pre[:-1], x_pre[1:] - x_pre[:-1], y_pre[1:] - y_pre[:-1],\\n color=\\\"#\\\" + ''.join([random.choice('0123456789ABCDEF') for j in range(6)]),\\n scale_units='xy', angles='xy', scale=1, label='prefix path')\\n\\n plt.savefig('img/path.png', bbox_inches='tight', dpi=600)\",\n \"def show_images_from_path(img_path,msk_path,fig_size=(10,4)):\\r\\n try:\\r\\n img = mpimg.imread(img_path)\\r\\n except:\\r\\n print(\\\"File not found!\\\")\\r\\n return None\\r\\n msk = mpimg.imread(msk_path,0)\\r\\n fig, ax = plt.subplots(1,2, figsize=fig_size)\\r\\n ax[0].set_title(\\\"Image\\\")\\r\\n ax[1].set_title(\\\"Mask\\\")\\r\\n ax[0].imshow(img)\\r\\n ax[1].imshow(msk)\",\n \"def plot_reconstruction_images(inputs, pred, name):\\n\\n plt.clf()\\n nb_plots = min(inputs.shape[0], 4)\\n #inputs\\n for i in range(nb_plots):\\n ax = plt.subplot2grid((2, nb_plots), (0, i), rowspan=1, colspan=1)\\n ax.imshow(inputs[i])\\n ax.axis('off')\\n #pred\\n for i in range(nb_plots):\\n ax = plt.subplot2grid((2, nb_plots), (1, i), rowspan=1, colspan=1)\\n ax.imshow(pred[i])\\n ax.axis('off')\\n\\n if name != None:\\n plt.savefig(name, format='svg', bbox_inches='tight')\\n else:\\n plt.show()\",\n \"def vis_segmentation(image, seg_map, FULL_COLOR_MAP, LABEL_NAMES):\\n plt.figure(figsize=(15, 5))\\n grid_spec = gridspec.GridSpec(1, 4, width_ratios=[6, 6, 6, 1])\\n\\n plt.subplot(grid_spec[0])\\n plt.imshow(image)\\n plt.axis('off')\\n plt.title('input image')\\n\\n plt.subplot(grid_spec[1])\\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\\n plt.imshow(seg_image)\\n plt.axis('off')\\n plt.title('segmentation map')\\n\\n plt.subplot(grid_spec[2])\\n plt.imshow(image)\\n plt.imshow(seg_image, alpha=0.7)\\n plt.axis('off')\\n plt.title('segmentation overlay')\\n\\n unique_labels = np.unique(seg_map)\\n ax = plt.subplot(grid_spec[3])\\n plt.imshow(\\n FULL_COLOR_MAP[unique_labels].astype(np.uint8), interpolation='nearest')\\n ax.yaxis.tick_right()\\n plt.yticks(range(len(unique_labels)), LABEL_NAMES[unique_labels])\\n plt.xticks([], [])\\n ax.tick_params(width=0.0)\\n plt.grid('off')\\n plt.show()\",\n \"def map_fn(self, path, label):\\n image = tf.image.decode_png(tf.io.read_file(path))\\n image = tf.image.convert_image_dtype(image, tf.float32)\\n if self.img_size is not None:\\n image = tf.image.resize(image, self.img_size)\\n return image, label\",\n \"def visualize(**images):\\r\\n n_images = len(images)\\r\\n plt.figure(figsize=(20, 8))\\r\\n for idx, (name, image) in enumerate(images.items()):\\r\\n plt.subplot(1, n_images, idx + 1)\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n # get title from the parameter names\\r\\n plt.title(name.replace('_', ' ').title(), fontsize=20)\\r\\n plt.imshow(image)\\r\\n plt.show()\",\n \"def render_blocks(image, paths):\\n if 1:\\n CMAP_OBJ = colorbrewer.qualitative.Set3_12\\n CMAP_COLORS = list(map(tuple, CMAP_OBJ.colors))\\n colormap = itertools.cycle(CMAP_COLORS)\\n renderClass = RenderFile\\n draw = ImageDraw.Draw(image)\\n rend = renderClass(draw=draw, x=0, y=0)\\n # X: size in points, not pixels\\n # fnt = ImageFont.truetype(\\\"Umpush-Light.ttf\\\", size=14)\\n fnt = None\\n text_color = (0, 0, 0, 128)\\n for path in paths:\\n text_args = dict(\\n xy=(rend.x, rend.y), text=os.path.basename(path), font=fnt, fill=text_color\\n )\\n rend.colors = [next(colormap)]\\n render_file(path, rend)\\n draw.text(**text_args)\\n return image\",\n \"def buildImages(files, targets, type):\\n images = []\\n for file in files:\\n targets.append(file)\\n with open(file, \\\"rb\\\") as f:\\n if type == \\\"Byte\\\":\\n images.append(bytePlot(list(f.read())))\\n elif type == \\\"Markov\\\":\\n images.append(markovPlot(list(f.read())))\\n elif type == \\\"Hilbert\\\":\\n images.append(hilbertPlot(list(f.read())))\\n smp.imsave(\\\"{}.png\\\".format(file), images[-1])\\n return images, targets\",\n \"def display_some_traffic_sign_examples(path):\\n\\n images_paths = glob.glob(path + \\\"\\\\\\\\*.png\\\") # image paths\\n plt.figure(figsize = (10, 10))\\n\\n for i in range(25):\\n # select a random index in the dataset\\n idx = np.random.randint(0, len(images_paths) - 1)\\n img = imread(images_paths[idx])\\n\\n # subplot the dataset examples\\n plt.subplot(5, 5, i + 1)\\n plt.tight_layout(rect = [0, 0, 1, 0.95])\\n plt.imshow(img)\\n\\n plt.suptitle(\\\"Dataset Examples\\\")\\n plt.show()\",\n \"def draw_binary_label(base_img, tf_img, label_colors, resize=True):\\n for label in label_colors:\\n #print(\\\"label:{0}\\\".format(label))\\n if label == 7: # Roads\\n #print(\\\"label:7, roads. . .\\\")\\n road_mask = tf_img == label\\n elif label == 10: # Vehicles\\n #print(\\\"label:10, vehicles. . .\\\")\\n vehicle_mask = tf_img == label\\n #print(vehicle_mask)\\n\\n cmap = plt.cm.jet\\n norm = plt.Normalize(vmin=tf_img.min(), vmax=tf_img.max())\\n\\n # map the normalized data to colors\\n # image is now RGBA (512x512x4) \\n rgba_label = scipy.misc.toimage(norm(tf_img))\\n plt.imshow(rgba_label)\\n plt.show()\\n print(\\\"base_img:{0} tf_img:{1}\\\".format(np.shape(base_img), np.shape(rgba_label)))\\n #colored = cv2.addWeighted(base_img.astype('uint8'), 1, rgba_label, 0.8, 0)\\n colored = 2\\n\\n return road_mask, vehicle_mask, colored\",\n \"def get_file_paths(\\r\\n paths: Union[PathT, List[PathT]] = \\\"data/hubmap-256x256/\\\",\\r\\n use_ids: Union[Tuple[int, ...], List[Tuple[int, ...]]] = (0, 1, 2, 3, 4, 5, 6, 7),\\r\\n) -> Tuple[List[Path], List[Path], List[List[str]]]:\\r\\n if not isinstance(paths, list):\\r\\n paths = [paths]\\r\\n use_ids = [use_ids]\\r\\n else:\\r\\n assert isinstance(use_ids, list)\\r\\n assert len(use_ids) == len(paths)\\r\\n\\r\\n paths = [Path(p) for p in paths]\\r\\n unique_ids = [\\r\\n sorted(set(p.name.split(\\\"_\\\")[0] for p in (path / \\\"train\\\").iterdir()))\\r\\n for path in paths\\r\\n ]\\r\\n # print(unique_ids)\\r\\n\\r\\n images = sorted(\\r\\n [\\r\\n p\\r\\n for j, (use_id_p, path) in enumerate(zip(use_ids, paths))\\r\\n for i in use_id_p\\r\\n for p in (path / \\\"train\\\").glob(f\\\"{unique_ids[j][i]}_*.png\\\")\\r\\n ]\\r\\n )\\r\\n\\r\\n masks = sorted(\\r\\n [\\r\\n p\\r\\n for j, (use_id_p, path) in enumerate(zip(use_ids, paths))\\r\\n for i in use_id_p\\r\\n for p in (path / \\\"masks\\\").glob(f\\\"{unique_ids[j][i]}_*.png\\\")\\r\\n ]\\r\\n )\\r\\n\\r\\n assert len(images) == len(masks), f\\\"images {len(images)}, masks {len(masks)}\\\"\\r\\n\\r\\n return images, masks, unique_ids\",\n \"def icons(users, distance):\\n\\n # It would be pretty cool to put user thumbails where points are.\\n # but i'm still not sure how to do this yet.\\n images = []\\n\\n try:\\n print 'getting images..'\\n for p in users:\\n print p\\n f = p.image\\n img = imread('image.tmp')\\n images.append(img)\\n except Exception as e:\\n print 'got an error...'\\n import traceback\\n etype, evalue, tb = sys.exc_info()\\n print yellow % '\\\\n'.join(traceback.format_exception(etype, evalue, tb))\\n ip()\\n\\n (W, H, _) = shape(img) # thumbnails should all be the same size\\n count = len(images)\\n\\n pl.figure()\\n\\n P2, _ = mds(distance, 2)\\n X,Y = P2[:,0], P2[:,1]\\n\\n ## XXX: not a great transformation b/c we might stretch more in one dimension\\n def N(x):\\n \\\"force x to fit in interval [0,1]\\\"\\n x = (x - x.min())\\n x = x / x.max()\\n assert all(x >= 0) and all(x <= 1)\\n return x\\n X = N(X)*475\\n Y = N(Y)*425\\n\\n figimages = [pl.figimage(img, xo=x, yo=y) for img, x, y in zip(images, X, Y)]\",\n \"def showImage(self, filePath): \\n size = 244, 244 \\n try:\\n guiobjects.generateImageSize(filePath, [244, 244], IMG_UPLOAD)\\n except:\\n return \\n imgPath = IMG_UPLOAD\\n img = ocempgui.draw.Image.load_image(imgPath)\\n self.imgOptionsTab.picture = img\\n self.generateMask(\\\"imgUpload.png\\\")\",\n \"def plot_images(images, labels, nrows, ncols, cls_true=None, cls_pred=None, grey=False):\\n fig, axes = plt.subplots(nrows, ncols, figsize=(16, 2*nrows))\\n\\n for i, ax in enumerate(axes.flat): \\n if grey:\\n ax.imshow(images[i,:,:,0], cmap='binary')\\n else:\\n ax.imshow(images[i])\\n\\n ax.set_xticks([]); ax.set_yticks([])\\n if labels:\\n ax.set_title(labels[i])\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\",\n \"def plot_shapes(shapes, colors, title=\\\"Shape Model\\\", save=False):\\n cv2.namedWindow(title)\\n shapes = [scale_by_param(scale_to_unit(dshape), 1000) for dshape in shapes]\\n #shapes = [shape.scale_to_unit().scale(1000) for shape in shapes]\\n\\n max_x = int(max([dshape[:, 0].max() for dshape in shapes]))\\n max_y = int(max([dshape[:, 1].max() for dshape in shapes]))\\n min_x = int(min([dshape[:, 0].min() for dshape in shapes]))\\n min_y = int(min([dshape[:, 1].min() for dshape in shapes]))\\n\\n img = np.ones((max_y-min_y+20, max_x-min_x+20, 3), np.uint8)*255\\n for shape_num, shape in enumerate(shapes):\\n points = shape\\n for i in range(len(points)):\\n cv2.line(img, (int(points[i, 0]-min_x+10), int(points[i, 1]-min_y+10)),\\n (int(points[(i + 1) % 40, 0]-min_x+10), int(points[(i + 1) % 40, 1]-min_y+10)),\\n colors[shape_num], thickness=1, lineType=8)\\n\\n cv2.imshow(title, img)\\n cv2.waitKey()\\n if save:\\n cv2.imwrite('Plot/'+title+'.png', img)\\n cv2.destroyAllWindows()\",\n \"def plot_example_images(\\n output_dir, epoch, generator, label_imgs, test_imgs, imgs_count,\\n examples=4):\\n random_ints = np.random.randint(0, imgs_count, examples)\\n image_batch_hr = denormalize(label_imgs[random_ints])\\n image_batch_lr = test_imgs[random_ints]\\n gen_img = generator.predict(image_batch_lr)\\n generated_image = denormalize(gen_img)\\n image_batch_lr = denormalize(image_batch_lr)\\n\\n plt.clf()\\n\\n for idx in range(examples):\\n plt.subplot(examples, 3, 1 + idx * 3)\\n plt.imshow(image_batch_lr[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplot(examples, 3, 2 + idx * 3)\\n plt.imshow(generated_image[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplot(examples, 3, 3 + idx * 3)\\n plt.imshow(image_batch_hr[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplots_adjust(wspace=0.01)\\n plt.savefig(\\n path.join(output_dir, f'generated_image_{epoch}.svg'),\\n bbox_inches='tight', pad_inches=0, )\",\n \"def save_pic(pic_tensor, title, filename):\\n plt.close()\\n plt.title(title, size=24)\\n xyrgb = pic_tensor.data[0].numpy().transpose((1, 2, 0)) # convert from RGB x X x Y to X x Y x RGB\\n if (xyrgb.shape)[-1] != 3: # no rgb image => Plot with color map\\n xyrgb = xyrgb[:, :, 0]\\n plt.imshow(xyrgb, cmap='gray', interpolation='nearest')\\n if (xyrgb.shape)[-1] != 3: # no rgb image => show color bar legend\\n cbar = plt.colorbar()\\n cbar.ax.tick_params(labelsize=20)\\n print(title, xyrgb.shape)\\n plt.xticks(fontsize=20)\\n plt.yticks(fontsize=20)\\n plt.savefig(\\\"./\\\" + filename + \\\".pdf\\\", dpi=300, bbox_inches='tight')\",\n \"def plot_labels_bundle_pth(device, model, dataset, dataloader):\\n ## Get labels and preds\\n labels, preds = get_labels_and_preds(device, model, dataloader)\\n \\n ## Plot the figure\\n plot_labels(labels, preds, dataset.id_to_class_dict)\",\n \"def graphical(cls, images):\\n images = [(plt.imread(i), i.split(os.path.sep)[-1]) for i in images]\\n views = [View(ViewPosition.click(img, path), img, img) for img, path in images]\\n return cls(views)\",\n \"def visualize_MTL(**images):\\r\\n n = len(images)\\r\\n plt.figure(figsize=(16, 5))\\r\\n for i, (name, image) in enumerate(images.items()):\\r\\n if image==None:\\r\\n continue\\r\\n else:\\r\\n plt.subplot(1, n, i + 1)\\r\\n plt.xticks([])\\r\\n plt.yticks([])\\r\\n plt.title(' '.join(name.split('_')).title())\\r\\n plt.imshow(image)\\r\\n plt.show()\",\n \"def saveImage(self, data, fpath, list_label=\\\"[Word List]\\\", dpi=100):\\n # Generate puzzle image\\n colors = np.where(self.cover<1, \\\"#000000\\\", \\\"#FFFFFF\\\")\\n df = pd.DataFrame(data)\\n\\n fig=plt.figure(figsize=(16, 8), dpi=dpi)\\n ax1=fig.add_subplot(121) # puzzle\\n ax2=fig.add_subplot(122) # word list\\n ax1.axis(\\\"off\\\")\\n ax2.axis(\\\"off\\\")\\n fig.set_facecolor('#EEEEEE')\\n \\n # Draw puzzle\\n ax1_table = ax1.table(cellText=df.values, cellColours=colors, cellLoc=\\\"center\\\", bbox=[0, 0, 1, 1], fontsize=20)\\n ax1.set_title(label=f\\\"*** {self.title} ***\\\", size=20)\\n \\n # delete unmasked cells\\n mask = np.where(puzzle.mask == False)\\n for i, j in list(zip(mask[0], mask[1])):\\n del ax1_table._cells[i, j]\\n\\n # Draw word list\\n words = [word for word in self.usedWords if word != \\\"\\\"]\\n if words == []:\\n words = [\\\"\\\"]\\n words.sort()\\n words = sorted(words, key=len)\\n\\n rows = self.height\\n cols = math.ceil(len(words)/rows)\\n padnum = cols*rows - len(words)\\n words += ['']*padnum\\n words = np.array(words).reshape(cols, rows).T\\n\\n ax2_table = ax2.table(cellText=words, cellColours=None, cellLoc=\\\"left\\\", edges=\\\"open\\\", bbox=[0, 0, 1, 1])\\n ax2.set_title(label=list_label, size=20)\\n for _, cell in ax2_table.get_celld().items():\\n cell.set_text_props(size=18)\\n plt.tight_layout()\\n plt.savefig(fpath, dpi=dpi)\\n plt.close()\",\n \"def plotSate(s,i,seed):\\r\\n fig, ax = plt.subplots()\\r\\n\\r\\n im = ax.imshow(s)\\r\\n\\r\\n plt.xticks([i for i in range(dim)], \\\"\\\")\\r\\n plt.yticks([i for i in range(dim)], \\\"\\\")\\r\\n\\r\\n fig.tight_layout()\\r\\n plt.savefig(\\\"Systems/\\\" + str(dim) + \\\"_\\\" + str(seed) + \\\"/Images/\\\" + str(i) +\\r\\n \\\".jpeg\\\",quality=80,optimize=True,\\r\\n dpi=80,progressive=True,transparent=True)\\r\\n fig.clear()\\r\\n plt.close(fig)\",\n \"def makeFigure(imgList):\\n for i, img in enumerate(imgList):\\n i += 1\\n ax = plt.subplot(len(imgList), 1, i)\\n ax.imshow(img[0], cmap=COLOR_MAP)\\n ax.get_yaxis().set_ticks([])\\n if i == len(imgList):\\n ax.set_xlabel('Time of day')\\n ax.set_ylabel('Day of week')\\n # add name of the repo as title\\n plt.title(img[1])\\n\\n plt.tight_layout(pad=0)\\n plt.show()\",\n \"def decode_labels(mask, num_images=1, num_classes=21, task='seg'):\\n n, h, w, c = mask.shape\\n assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)\\n outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)\\n for i in range(num_images):\\n if task == 'normal':\\n outputs[i] = mask[i]\\n elif task == 'seg':\\n img = Image.new('RGB', (w, h), (255, 255, 255)) # unlabeled part is white (255, 255, 255)\\n pixels = img.load()\\n for j_, j in enumerate(mask[i, :, :, 0]):\\n for k_, k in enumerate(j):\\n if k < num_classes:\\n pixels[k_, j_] = label_colours[k]\\n outputs[i] = np.array(img)\\n else:\\n raise Exception('task name is not recognized!')\\n\\n return outputs\",\n \"def show_prediction_labels_on_image(img_path, predictions):\\r\\n pil_image = Image.open(img_path).convert(\\\"RGB\\\")\\r\\n draw = ImageDraw.Draw(pil_image)\\r\\n\\r\\n for name, (top, right, bottom, left) in predictions:\\r\\n draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255))\\r\\n name = name.encode(\\\"UTF-8\\\")\\r\\n text_width, text_height = draw.textsize(name)\\r\\n draw.rectangle(((left, bottom - text_height - 10), (right, bottom)), fill=(0, 0, 255), outline=(0, 0, 255))\\r\\n draw.text((left + 6, bottom - text_height - 5), name, fill=(255, 255, 255, 255))\\r\\n del draw\\r\\n pil_image.show()\",\n \"def plot_class_representations(\\n images, labels,\\n ignore_list=['-1', 'unknown'],\\n img_width=150,\\n force_b64=False):\\n assert(len(images) == len(labels))\\n assert(type(ignore_list) is list or ignore_list is None)\\n assert(type(img_width) is int)\\n\\n uniques = np.unique(labels, return_index=True)\\n labels = uniques[0]\\n not_labeled_mask = np.isin(labels, ignore_list)\\n labels = labels[~not_labeled_mask]\\n idices = uniques[1][~not_labeled_mask]\\n\\n group = []\\n for img_path in images[idices]:\\n group.append(img_path)\\n\\n plot_images(\\n group,\\n labels=labels,\\n max_images=len(group),\\n img_width=img_width,\\n force_b64=force_b64)\",\n \"def load_from_path(self, paths, label_key='labels'):\\n data = []\\n labels = []\\n for path in paths:\\n with tf.io.gfile.GFile(path, 'rb') as f:\\n d = {\\n k.decode('utf8'): v\\n for k, v in cPickle.load(f, encoding='bytes').items()\\n }\\n data.append(d['data'])\\n labels.append(d[label_key])\\n data = np.concatenate(data, axis=0)\\n data = data.reshape((data.shape[0], 3, 32, 32))\\n labels = np.concatenate(labels, axis=0)\\n labels = np.reshape(labels, (len(labels), 1))\\n\\n if tf.keras.backend.image_data_format() == 'channels_last':\\n data = data.transpose(0, 2, 3, 1)\\n\\n return data, labels\",\n \"def define_tasks(self, imgcollections,\\r\\n description, dimensions, folder):\\r\\n n = imgcollections.size().getInfo()\\r\\n collections = imgcollections.toList(n) # this is server-object; not iterable\\r\\n tasks = []\\r\\n itr = np.arange(n).tolist()\\r\\n random.shuffle(itr)\\r\\n pbar = tqdm.tqdm(itr)\\r\\n for i in pbar:\\r\\n image = collections.get(i)\\r\\n task = self.define_task(ee.Image(image).float(),\\r\\n \\\"{0:05d}\\\".format(i),\\r\\n description,\\r\\n dimensions,\\r\\n folder)\\r\\n tasks.append(task)\\r\\n pbar.set_description(\\\"defining tasks {0:05d}/{1:05d}\\\".format(i, n)) \\r\\n return tasks\",\n \"def show_pair(data, labeled=True, ordering='channel_last'):\\n xb, yb = data\\n batch_size = len(xb)\\n \\n fig = plt.figure(figsize=(5 * 2, 5 * batch_size))\\n for i in range(batch_size):\\n fig.add_subplot(batch_size, 2, (2 * i) + 1) \\n show_image(xb[i], ordering=ordering)\\n \\n fig.add_subplot(batch_size, 2, (2 * i) + 2) \\n if yb[i] is None:\\n y = np.zeros_like(xb[i])\\n else:\\n y = yb[i] \\n\\n if labeled:\\n show_label(y, ordering=ordering)\\n else:\\n show_image(y, ordering=ordering)\\n \\n return fig\",\n \"def plot_images(imgs, layout, img_sz = 0.7, suptitle = ''):\\n\\tnrows, ncols = layout \\n\\tfig, axes = plt.subplots(nrows, ncols, \\n\\t\\tfigsize = (img_sz * ncols, img_sz * nrows))\\n\\taxes = axes.ravel()\\n\\tfig.subplots_adjust(hspace = 0, wspace = 0)\\n\\tfig.suptitle(suptitle)\\n\\tfor i, img in enumerate(imgs):\\n\\t\\taxes[i].get_xaxis().set_visible(False)\\n\\t\\taxes[i].get_yaxis().set_visible(False)\\n\\t\\taxes[i].imshow(img)\",\n \"def make_training_curve_plots(algos,\\n tasks,\\n n_runs_per_expt,\\n csv_filepath_template,\\n figure_outdir,\\n window_size=None,\\n subplot_height=5,\\n subplot_width=8):\\n n_algo = len(algos)\\n n_task = len(tasks)\\n\\n plt.figure('raw', figsize=(subplot_width * n_algo, subplot_height * n_task))\\n plt.figure(\\n 'medians_percentiles',\\n figsize=(subplot_width * n_algo, subplot_height * n_task))\\n n_subplots_x, n_subplots_y = subplots_square(n_task)\\n plt.figure(\\n 'medians_percentiles_pertask',\\n figsize=(subplot_width * n_subplots_x, subplot_height * n_subplots_y))\\n plt.figure(\\n 'means_CIs_pertask',\\n figsize=(subplot_width * n_subplots_x, subplot_height * n_subplots_y))\\n fig_names = [\\n 'raw', 'medians_percentiles', 'medians_percentiles_pertask',\\n 'means_CIs_pertask'\\n ]\\n\\n subplot_pos = 0\\n # Iterate through each task.\\n for i_task, task in enumerate(tasks):\\n print('%s...' % task, end='')\\n\\n # Initialize x- and y-lims.\\n xlims_extremes = [np.inf, -np.inf]\\n task_baselines = [\\n baseline for key, baseline in BASELINES.items() if task in key\\n ]\\n if task_baselines:\\n ylims_extremes = [np.inf, max(task_baselines)]\\n else:\\n ylims_extremes = [np.inf, -np.inf]\\n\\n # Iterate through each algorithm.\\n for i_algo, algo in enumerate(algos):\\n subplot_pos += 1\\n algo_color = ALGO_COLORS[i_algo]\\n\\n plt.figure('raw')\\n plt.subplot(n_task, n_algo, subplot_pos)\\n\\n # Load and plot the raw curves.\\n curves = []\\n for run in range(n_runs_per_expt):\\n csv_filepath = csv_filepath_template % (task, algo, run)\\n with open(csv_filepath, 'r') as csv_file:\\n csv_reader = csv.reader(csv_file)\\n curve = []\\n for _ in range(2):\\n curve.append(np.array(csv_reader.next(), dtype=float))\\n curves.append(curve)\\n plt.plot(curve[0], curve[1])\\n plot_baseline(algo, task)\\n\\n # update the xlim/ylim extremes\\n xlims_extremes, ylims_extremes = update_xylims_extremes(\\n xlims_extremes, ylims_extremes)\\n\\n # Compute summaries\\n curves = np.array(curves)\\n timesteps, window_means = compute_window_means(curves, window_size)\\n means = compute_means(window_means)\\n medians = compute_medians(window_means)\\n cis = compute_boot_ci(window_means)\\n percentiles = compute_percentiles(window_means)\\n\\n # plot the medians + percentiles\\n plt.figure('medians_percentiles')\\n plt.subplot(n_task, n_algo, subplot_pos)\\n fill_plot(timesteps, medians, percentiles[0], percentiles[1], algo, task,\\n algo_color)\\n\\n # Plot the medians + percentiles on a single plot per task.\\n plt.figure('medians_percentiles_pertask')\\n plt.subplot(n_subplots_y, n_subplots_x, i_task + 1)\\n fill_plot(timesteps, medians, percentiles[0], percentiles[1], algo, task,\\n algo_color)\\n\\n # Plot the mean + CI on a single plot per task.\\n plt.figure('means_CIs_pertask')\\n plt.subplot(n_subplots_y, n_subplots_x, i_task + 1)\\n fill_plot(timesteps, means, cis[0], cis[1], algo, task, algo_color)\\n\\n # Figure titles.\\n for fig_name in ['raw', 'medians_percentiles']:\\n plt.figure(fig_name)\\n plt.title('%s - %s' % (algo, task))\\n for fig_name in ['medians_percentiles_pertask', 'means_CIs_pertask']:\\n plt.figure(fig_name)\\n plt.title(task)\\n\\n # equalize axes for the task\\n for fig_name in ['raw', 'medians_percentiles']:\\n equalize_axes_for_task(fig_name, xlims_extremes, ylims_extremes,\\n subplot_pos, n_task, n_algo)\\n\\n # Add legends\\n for fig_name in ['medians_percentiles_pertask', 'means_CIs_pertask']:\\n plt.figure(fig_name)\\n plt.legend(algos)\\n\\n # Save the figures.\\n io_utils.makedirs(figure_outdir)\\n for fig_name in fig_names:\\n plt.figure(fig_name)\\n plt.tight_layout()\\n output_path = '%s/%s.png' % (figure_outdir, fig_name)\\n with open(output_path, 'wb') as outfile:\\n plt.savefig(outfile, dpi=100)\",\n \"def run_visualization(filepath, MODEL, outputFilePath):\\n try:\\n # print(\\\"Trying to open : \\\" + sys.argv[1])\\n \\t# f = open(sys.argv[1])\\n \\tjpeg_str = open(filepath, \\\"rb\\\").read()\\n \\torignal_im = Image.open(BytesIO(jpeg_str))\\n except IOError:\\n print('Cannot retrieve image. Please check file: ' + filepath)\\n return\\n\\n print('running deeplab on image %s...' % filepath)\\n resized_im, seg_map = MODEL.run(orignal_im)\\n\\n # vis_segmentation(resized_im, seg_map)\\n drawSegment(resized_im, seg_map, outputFilePath)\",\n \"def generate_image_grid(sess, df, filenames,op, op2):\\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\\n\\n nx, ny = 12, 1\\n #plt.subplot()\\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n #\\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\\n # plt.show()\\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\\n # img = np.array(x.tolist()).reshape(28, 28)\\n #\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n\\n \\\"\\\"\\\" grid \\\"\\\"\\\"\\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n for i, g in enumerate(gs):\\n\\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\\n ax = plt.subplot(g)\\n img = np.array(x.tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\\n\\n for i, g in enumerate(gs):\\n\\n ax = plt.subplot(g)\\n img = np.array(df[i].tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\",\n \"def run_visualization(filepath):\\n try:\\n \\t#print(\\\"Trying to open : \\\" + sys.argv[1])\\n \\t# f = open(sys.argv[1])\\n \\tjpeg_str = open(filepath, \\\"rb\\\").read()\\n \\torignal_im = Image.open(BytesIO(jpeg_str))\\n except IOError:\\n print('Cannot retrieve image. Please check file: ' + filepath)\\n return\\n\\n #print('running deeplab on image %s...' % filepath)\\n resized_im, seg_map = MODEL.run(orignal_im)\\n\\n # vis_segmentation(resized_im, seg_map)\\n drawSegment(resized_im, seg_map)\",\n \"def draw_all_labels(df,root_folder_path,root_folder_name,logger):\\n # df=df[df.type==\\\"Color\\\"]\\n len_images=df['file_id'].nunique()\\n perc_list=[i*0.05 for i in range(0,20,1)]\\n grouped_df=df.groupby(['file_id','class'])\\n coordinate_names=['x_max','x_min','y_max','y_min']\\n group_len=len(grouped_df)\\n\\n class_label_dict={}\\n label_info_list=[]\\n for ind,(name, group) in enumerate(grouped_df):\\n img_name,class_name=name\\n img_type=group['type'].values[0]\\n bb_list=group[coordinate_names].values.astype(int)\\n if class_name not in class_label_dict.keys():\\n class_label_dict[class_name]=get_random_color()\\n bb_color=class_label_dict[class_name]\\n label_info_list.append([img_name,img_type,class_name,bb_color,bb_list])\\n draw_label_on_image(root_folder_path,root_folder_name,img_name,img_type,class_name,bb_color,bb_list)\\n perc=float(\\\"{:.2f}\\\".format((ind+1)/group_len))\\n if perc in perc_list:\\n perc_list.remove(perc)\\n logger.write(\\\"Classes annotated: \\\"+str(ind+1)+\\\"/\\\"+str(group_len))\\n # print(\\\"Label list generated.\\\")\\n # pool = Pool(1)\\n # pool.starmap(draw_label_on_one_image, zip(\\n # label_info_list, itertools.repeat(root_folder_path), itertools.repeat(root_folder_name)))\\n # pool.close()\\n # pool.join()\\n # print(\\\"Drawing labels is finished.\\\")\",\n \"def generate_images(self, model, test_input, step, dst_dir):\\n prediction = model(test_input)\\n\\n plt.figure(figsize=(12, 12))\\n display_list = [test_input[0], prediction[0]]\\n title = ['Input Image', 'Predicted Image']\\n\\n for i in range(2):\\n plt.subplot(1, 2, i+1)\\n plt.title(title[i])\\n # getting the pixel values between [0, 1] to plot it.\\n plt.imshow(display_list[i] * 0.5 + 0.5)\\n plt.axis('off')\\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\\n plt.savefig(filename)\",\n \"def tasks_frame(self, task_id, frame_ids, outdir='', **kwargs):\\n for frame_id in frame_ids:\\n url = self.api.tasks_id_frame_id(task_id, frame_id)\\n response = self.session.get(url)\\n response.raise_for_status()\\n im = Image.open(BytesIO(response.content))\\n outfile = 'task_{}_frame_{:06d}.jpg'.format(task_id, frame_id)\\n im.save(os.path.join(outdir, outfile))\",\n \"def generate_2D_plot(x, y, labels_dict, file_title, plot_title):\\n fig = plt.figure()\\n plt.plot(x, y)\\n\\n if labels_dict:\\n plt.xlabel(labels_dict[\\\"x\\\"])\\n plt.ylabel(labels_dict[\\\"y\\\"])\\n if plot_title:\\n plt.title(plot_title)\\n\\n plt.savefig(file_title)\",\n \"def _plot_images(self):\\n # Plot sagittal (0), coronal (1) or axial (2) view\\n self._images = dict(base=list(), cursor_v=list(), cursor_h=list(),\\n bounds=list())\\n img_min = np.nanmin(self._base_data)\\n img_max = np.nanmax(self._base_data)\\n text_kwargs = dict(fontsize='medium', weight='bold', color='#66CCEE',\\n family='monospace', ha='center', va='center',\\n path_effects=[patheffects.withStroke(\\n linewidth=4, foreground=\\\"k\\\", alpha=0.75)])\\n xyz = apply_trans(self._ras_vox_t, self._ras)\\n for axis in range(3):\\n plot_x_idx, plot_y_idx = self._xy_idx[axis]\\n fig = self._figs[axis]\\n ax = fig.axes[0]\\n img_data = np.take(self._base_data, self._current_slice[axis],\\n axis=axis).T\\n self._images['base'].append(ax.imshow(\\n img_data, cmap='gray', aspect='auto', zorder=1,\\n vmin=img_min, vmax=img_max))\\n img_extent = self._img_extents[axis] # x0, x1, y0, y1\\n w, h = np.diff(np.array(img_extent).reshape(2, 2), axis=1)[:, 0]\\n self._images['bounds'].append(Rectangle(\\n img_extent[::2], w, h, edgecolor='w', facecolor='none',\\n alpha=0.25, lw=0.5, zorder=1.5))\\n ax.add_patch(self._images['bounds'][-1])\\n v_x = (xyz[plot_x_idx],) * 2\\n v_y = img_extent[2:4]\\n self._images['cursor_v'].append(ax.plot(\\n v_x, v_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\\n h_y = (xyz[plot_y_idx],) * 2\\n h_x = img_extent[0:2]\\n self._images['cursor_h'].append(ax.plot(\\n h_x, h_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\\n # label axes\\n self._figs[axis].text(0.5, 0.05, _IMG_LABELS[axis][0],\\n **text_kwargs)\\n self._figs[axis].text(0.05, 0.5, _IMG_LABELS[axis][1],\\n **text_kwargs)\\n self._figs[axis].axes[0].axis(img_extent)\\n self._figs[axis].canvas.mpl_connect(\\n 'scroll_event', self._on_scroll)\\n self._figs[axis].canvas.mpl_connect(\\n 'button_release_event', partial(self._on_click, axis=axis))\\n # add head and brain in mm (convert from m)\\n if self._head is None:\\n logger.info('Using marching cubes on CT for the '\\n '3D visualization panel')\\n rr, tris = _marching_cubes(np.where(\\n self._base_data < np.quantile(self._base_data, 0.95), 0, 1),\\n [1])[0]\\n rr = apply_trans(self._vox_ras_t, rr)\\n self._renderer.mesh(\\n *rr.T, triangles=tris, color='gray', opacity=0.2,\\n reset_camera=False, render=False)\\n else:\\n self._renderer.mesh(\\n *self._head['rr'].T * 1000, triangles=self._head['tris'],\\n color='gray', opacity=0.2, reset_camera=False, render=False)\\n if self._lh is not None and self._rh is not None:\\n self._renderer.mesh(\\n *self._lh['rr'].T * 1000, triangles=self._lh['tris'],\\n color='white', opacity=0.2, reset_camera=False, render=False)\\n self._renderer.mesh(\\n *self._rh['rr'].T * 1000, triangles=self._rh['tris'],\\n color='white', opacity=0.2, reset_camera=False, render=False)\\n self._renderer.set_camera(azimuth=90, elevation=90, distance=300,\\n focalpoint=tuple(self._ras))\\n # update plots\\n self._draw()\\n self._renderer._update()\",\n \"def plt_to_ipy_img(dummy: any = None, **kwargs) -> IPython.display.Image:\\n return IPython.display.Image(filename=plot_to_file(**kwargs))\",\n \"def plot_images(data_obj, fs):\\n\\n fig = new_pdf_page(data_obj.pdf_obj) # Create a new page\\n plt.suptitle('Cropped and Rotated Images')\\n\\n for i, file in enumerate(data_obj.files):\\n\\n # Specify the plot parameters\\n ax2 = fig.add_subplot(3, 2, i + 1)\\n plt.tick_params(axis='both', which='both', bottom='off', left='off',\\n top='off', right='off', labelbottom='off', labelleft='off')\\n\\n # Plot the image and the image title\\n plt.imshow(data_obj.img_data[i].img, cmap=plt.get_cmap('gray'))\\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation), fontsize=fs)\\n\\n # Add the ROI rectangles to the plot\\n data_obj.img_data[i].step_wedge_ROI.add_rect_to_plot(edgecolor='orange')\\n data_obj.img_data[i].lead_foil_ROI.add_rect_to_plot(edgecolor='blue')\\n data_obj.img_data[i].POM_piece_ROI.add_rect_to_plot(edgecolor='red')\",\n \"def make_label_map(path, label_list):\\r\\n \\r\\n img = []\\r\\n for name in path:\\r\\n now = np.zeros((224,224))\\r\\n im = cv2.resize(cv2.imread(name), (224,224)).tolist()\\r\\n for y, i in enumerate(im):\\r\\n for x, j in enumerate(i):\\r\\n try:\\r\\n now[y, x] = label_list.index(j)\\r\\n\\r\\n except ValueError:\\r\\n now[y, x] = 0\\r\\n\\r\\n img.append(now)\\r\\n return img\",\n \"def plot_image_path(image_path, log_image_path=False):\\n img = load_img(image_path)\\n if log_image_path:\\n plt.title(image_path)\\n plt.imshow(img)\\n plt.axis('off')\\n plt.show()\",\n \"def visualize_heat_maps(self, image_paths, last_layer='fc', savefig_path=\\\"\\\"):\\n\\n layer_idx = [idx for idx, layer in enumerate(self.model.layers) if layer.name == last_layer][0]\\n\\n heatmaps = []\\n for path in image_paths:\\n seed_img = utils.load_img(path, target_size=(self.config.crop_height, self.config.crop_width))\\n x = np.expand_dims(img_to_array(seed_img), axis=0)\\n x = preprocess_input(x)\\n pred_class = np.argmax(self.model.predict(x))\\n\\n # Here we are asking it to show attention such that prob of `pred_class` is maximized.\\n heatmap = visualize_saliency(self.model, layer_idx, [pred_class], seed_img)\\n heatmaps.append(heatmap)\\n\\n plt.axis('off')\\n plt.imshow(utils.stitch_images(heatmaps))\\n plt.title('Saliency map')\\n plt.savefig(savefig_path)\\n\\n print('debug')\",\n \"def vis_segmentation(image, seg_map):\\n plt.figure(figsize=(20, 20))\\n \\n seg_image = label_to_color_image(seg_map).astype(np.uint8)\\n plt.imshow(seg_image)\\n plt.axis('off')\\n plt.savefig(str(image_id)+'_seg.jpg',bbox_inches='tight')\\n plt.close()\",\n \"def show_next_image(self):\\r\\n self.index += 1\\r\\n progress_string = \\\"%d/%d\\\" % (self.index+1, self.n_paths)\\r\\n self.progress_label.configure(text=progress_string)\\r\\n \\r\\n display_name = \\\"Name = %s\\\" % (self.file_names[self.index])\\r\\n self.name_label.configure(text = display_name)\\r\\n \\r\\n #### added in version 2\\r\\n #sorting_string = df.sorted_in_folder[self.index].split(os.sep)[-2] #shows the last folder in the filepath before the file\\r\\n sorting_string = self.df.sorted_in_folder[self.index].split(\\\"/\\\")[-2]\\r\\n self.sorting_label.configure(text=(\\\"In folder: %s\\\" % (sorting_string)))\\r\\n \\r\\n #Add Current Label\\r\\n print(sorting_string)\\r\\n for label in labels:\\r\\n if label not in sorting_string:\\r\\n cat_string = 'Unlabelled'\\r\\n else:\\r\\n cat_string = sorting_string\\r\\n \\r\\n self.cat_label.configure(text = ('Current Category : %s' %(cat_string)))\\r\\n \\r\\n ####\\r\\n\\r\\n if self.index < self.n_paths:\\r\\n self.set_image(self.df.sorted_in_folder[self.index])\\r\\n else:\\r\\n self.master.quit()\",\n \"def plot_points(source = [], images = [], plt_show = False, \\\\\\n color = 'darkgreen', marker = 'x', label = ''): #FIXME - this function should me moved to a more generic module (plot_utils.py for instance)\\n #print source, images\\n if len(source) == 0 and len(images) == 0:\\n return 0\\n\\n plt.figure(1, figsize=(16, 8))\\n\\n if len(source) > 0:\\n x_src = [row[0] for row in source]\\n y_src = [row[1] for row in source]\\n plt.subplot(1, 2, 1).set_aspect(1)\\n plt.plot(x_src, y_src, markersize = 7, color = color, marker = marker, \\\\\\n label = label, linewidth=0)\\n plt.legend()\\n\\n if len(images) > 0:\\n x_img = [row[0] for row in images]\\n y_img = [row[1] for row in images]\\n plt.subplot (1, 2, 2).set_aspect(1)\\n plt.plot(x_img, y_img, markersize = 7, color = color, marker = marker, \\\\\\n label = label, linewidth=0)\\n plt.legend()\\n\\n if plt_show:\\n plt.show()\\n plt.close()\",\n \"def visualize(self):\\n NUM_AFFINITY = 4\\n NUM_WILL = 7\\n\\n # Colors for the tasks and categories\\n COLORS = d3['Category20c'][20] + d3['Category20b'][20]\\n COLORS_CAT = d3['Category20'][20]\\n COLORS_AFFINITY = brewer['Greens'][NUM_AFFINITY]\\n COLORS_WILL = brewer['RdBu'][NUM_WILL]\\n\\n # Date range for the figure title\\n start_str = c.START.strftime(\\\"%A %m/%d/%y\\\")\\n end_str = c.END.strftime(\\\"%A %m/%d/%y\\\")\\n\\n # Day of week range for the x axis\\n start_weekday_str = c.START.strftime(\\\"%a\\\")\\n end_weekday_str = c.END.strftime(\\\"%a\\\")\\n\\n times, tasks = self.array.nonzero()\\n day_start = tutil.DAY_START\\n hours = (times % tutil.SLOTS_PER_DAY) / tutil.SLOTS_PER_HOUR\\n bottom = day_start + hours\\n top = bottom + (0.95 / tutil.SLOTS_PER_HOUR)\\n left = np.floor(times / tutil.SLOTS_PER_DAY)\\n right = left + 0.75\\n chunk_min = [self.task_chunk_min[j] for j in tasks]\\n chunk_max = [self.task_chunk_max[j] for j in tasks]\\n affinity_cog_task = [self.task_cognitive_load[j] for j in tasks]\\n affinity_cog_slot = [c.AFFINITY_COGNITIVE[i] for i in times]\\n affinity_cognitive = (np.array(affinity_cog_task) * np.array(\\n affinity_cog_slot)).tolist()\\n willpower_task = [self.task_willpower_load[j] for j in tasks]\\n willpower_cumulative = np.cumsum(willpower_task)\\n duration = [self.task_duration[j] for j in tasks]\\n duration_realized = [self.task_duration_realized[j] for j in tasks]\\n task_names = [self.task_names[j] for j in tasks]\\n category_ids = [[l for l, j in enumerate(array) if j != 0] for array in\\n [self.task_category[j, :] for j in tasks]]\\n category = [\\\", \\\".join(\\n [self.cat_names[l] for l, j in enumerate(array) if j != 0]) for\\n array in [self.task_category[j, :] for j in tasks]]\\n data_tooltips = dict(\\n chunk_min=chunk_min,\\n chunk_max=chunk_max,\\n affinity_cognitive=affinity_cognitive,\\n affinity_cog_slot=affinity_cog_slot,\\n affinity_cog_task=affinity_cog_task,\\n willpower_task=willpower_task,\\n willpower_cumulative=willpower_cumulative,\\n duration=duration,\\n duration_realized=duration_realized,\\n task_id=tasks,\\n task=task_names,\\n category=category,\\n )\\n\\n offset = self.num_tasks - self.num_categories\\n # Use #deebf7 as placeholder/default event color\\n colors = [COLORS[i % len(COLORS)] if i < offset else '#ffffcc' for i in\\n tasks]\\n data1 = data_tooltips.copy()\\n data1.update(dict(\\n top=top,\\n bottom=bottom,\\n left=left,\\n right=right,\\n colors=colors,\\n ))\\n source1 = ColumnDataSource(data=data1)\\n\\n TOOLTIPS = [(\\\"task\\\", \\\"@task\\\"),\\n (\\\"category\\\", \\\"@category\\\"),\\n (\\\"duration\\\", \\\"@duration_realized / @duration\\\"),\\n (\\\"willpower\\\", \\\"@willpower_task\\\"),\\n (\\\"willpower (cum)\\\", \\\"@willpower_cumulative\\\"),\\n (\\\"chunk_range\\\", \\\"(@chunk_min, @chunk_max)\\\"),\\n (\\\"affinity [slot x task]\\\", \\\"@affinity_cognitive = \\\"\\n \\\"@affinity_cog_slot x \\\"\\n \\\"@affinity_cog_task\\\"),\\n (\\\"task_id\\\", \\\"@task_id\\\"),\\n (\\\"index\\\", \\\"$index\\\"),\\n (\\\"(t,l)\\\", \\\"(@bottom, @left)\\\"),\\n ]\\n\\n # [Bokeh] inverted axis range example:\\n # https://groups.google.com/a/continuum.io/forum/#!topic/bokeh/CJAvppgQmKo\\n yr = Range1d(start=22, end=6)\\n # yr = Range1d(start=24.5, end=-0.5)\\n xr = Range1d(start=-0.3, end=7.3)\\n p = figure(plot_width=1000, plot_height=600, y_range=yr, x_range=xr,\\n tooltips=TOOLTIPS,\\n title=\\\"Calendar: {} to {}\\\".format(start_str, end_str))\\n self.p = p\\n output_file(\\\"calendar.html\\\")\\n\\n p.xaxis[0].axis_label = 'Weekday ({}-{})'.format(start_weekday_str,\\n end_weekday_str)\\n p.yaxis[0].axis_label = 'Hour (7AM-9:30PM)'\\n\\n # Replace default yaxis so that each hour is displayed\\n p.yaxis[0].ticker.desired_num_ticks = int(tutil.HOURS_PER_DAY)\\n p.yaxis[0].ticker.num_minor_ticks = 4\\n p.xaxis[0].ticker.num_minor_ticks = 0\\n\\n # Display task allocation as colored rectangles\\n p.quad(top='top', bottom='bottom', left='left', right='right',\\n color='colors', fill_alpha=0.7, line_alpha=0.5, source=source1)\\n\\n # Pre-process task names for display (no repeats, abbreviated names)\\n # FIXME(cathywu) currently assumes that y is in time order, which may\\n # not be the case when more task types are incorporated\\n task_display = []\\n curr_task = \\\"\\\"\\n for name in task_names:\\n if name == curr_task:\\n task_display.append(\\\"\\\")\\n else:\\n curr_task = name\\n task_display.append(name)\\n data2 = data_tooltips.copy()\\n data2.update(dict(\\n x=left,\\n y=top,\\n # abbreviated version of task\\n task=[k[:19] for k in task_display],\\n ))\\n source2 = ColumnDataSource(data=data2)\\n\\n # Annotate rectangles with task name\\n # [Bokeh] Text properties:\\n # https://bokeh.pydata.org/en/latest/docs/user_guide/styling.html#text-properties\\n labels = LabelSet(x='x', y='y', text='task', level='glyph', x_offset=3,\\n y_offset=-1, source=source2, text_font_size='7pt',\\n render_mode='canvas')\\n p.add_layout(labels)\\n\\n # Display cognitive affinity as rectangle to the right of the task\\n colors_affinity = np.array(\\n np.array(affinity_cognitive) * (NUM_AFFINITY - 1), dtype=int)\\n colors_affinity = [COLORS_AFFINITY[NUM_AFFINITY - 1 - i] for i in\\n colors_affinity.tolist()]\\n data5 = data_tooltips.copy()\\n data5.update(dict(\\n top=(np.array(top) - 0.05).tolist(),\\n bottom=(np.array(bottom) + 0.05).tolist(),\\n left=(np.array(right) + 0.12).tolist(),\\n right=(np.array(right) + 0.2).tolist(),\\n colors=colors_affinity,\\n ))\\n source5 = ColumnDataSource(data=data5)\\n p.quad(top='top', bottom='bottom', left='left', right='right',\\n color='colors', source=source5)\\n\\n # Display willpower balance as rectangle to the right of the task\\n colors_will = np.minimum(willpower_cumulative, 2)\\n colors_will = np.maximum(colors_will, -2)\\n colors_will += 2\\n colors_will = np.array(colors_will / 4 * (NUM_WILL - 1), dtype=int)\\n colors_will = [COLORS_WILL[i] for i in colors_will.tolist()]\\n data6 = data_tooltips.copy()\\n data6.update(dict(\\n top=top,\\n bottom=bottom,\\n left=np.array(right) + 0.02,\\n right=(np.array(right) + 0.1).tolist(),\\n colors=colors_will,\\n ))\\n source6 = ColumnDataSource(data=data6)\\n p.quad(top='top', bottom='bottom', left='left', right='right',\\n color='colors', source=source6)\\n\\n # Display categories as a colored line on the left\\n # TODO(cathywu) currently displays only the \\\"first\\\" category,\\n # add support for more categories\\n xs = []\\n ys = []\\n for y0, y1, x in zip(top, bottom, left):\\n xs.append([x, x])\\n ys.append([y0, y1])\\n colors_cat = [COLORS_CAT[cat_ids[0] % len(COLORS_CAT)] for cat_ids in\\n category_ids]\\n data3 = data_tooltips.copy()\\n data3.update(dict(\\n xs=xs,\\n ys=ys,\\n colors=colors_cat,\\n ))\\n source3 = ColumnDataSource(data=data3)\\n p.multi_line(xs='xs', ys='ys', color='colors', line_width=4,\\n source=source3)\\n\\n # Annotate columns with day of the week\\n data4 = data_tooltips.copy()\\n data4.update(dict(\\n x=[k + 0.1 for k in range(tutil.LOOKAHEAD)],\\n y=[6.75 for _ in range(tutil.LOOKAHEAD)],\\n weekday=[(c.START + timedelta(k)).strftime(\\\"%A\\\") for k in\\n range(tutil.LOOKAHEAD)],\\n ))\\n source4 = ColumnDataSource(data=data4)\\n labels2 = LabelSet(x='x', y='y', text='weekday', level='glyph',\\n x_offset=3, y_offset=-1, source=source4,\\n text_font_size='10pt', render_mode='canvas')\\n p.add_layout(labels2)\\n\\n show(p)\",\n \"def visualization(image_path, points, label, vis_color=(255, 255, 255)):\\r\\n points = np.asarray(points, dtype=np.int32)\\r\\n points = np.reshape(points, [-1, 2])\\r\\n image = cv2.imread(image_path)\\r\\n cv2.polylines(image, [points], 1, (0, 255, 0), 2)\\r\\n image = Image.fromarray(image)\\r\\n FONT = ImageFont.truetype(font_path, 20, encoding='utf-8')\\r\\n DRAW = ImageDraw.Draw(image)\\r\\n\\r\\n DRAW.text(points[0], label, vis_color, font=FONT)\\r\\n return np.array(image)\",\n \"def show_flow(filename):\\n flow = read_flow(filename)\\n img = flow_to_image(flow)\\n plt.imshow(img)\\n plt.show()\",\n \"def images_show(images: Sequence, labels: Sequence[str] = None, title: str = '') -> None:\\n\\n nb_img = len(images)\\n\\n if nb_img == 0:\\n raise ValueError('No image to print')\\n\\n # Only on image, no need of subplot\\n if nb_img == 1:\\n plt.imshow(images[0], interpolation='none')\\n plt.axis('off')\\n title_str = ''\\n if title:\\n title_str = title\\n if labels and len(labels) > 0 and labels[0]:\\n if len(title_str) > 0:\\n title_str += '\\\\n' + labels[0]\\n else:\\n title_str = labels[0]\\n if len(title_str) > 0:\\n plt.title(title_str)\\n\\n # More than 1 image\\n else:\\n if nb_img < 4:\\n # For 3 or below just plot them in one line\\n nb_rows = 1\\n nb_cols = nb_img\\n else:\\n nb_rows = nb_cols = ceil(sqrt(nb_img))\\n nb_rows = ceil(nb_img / nb_rows) # Remove empty rows if necessary\\n\\n # Create subplots\\n fig, axs = plt.subplots(nrows=nb_rows, ncols=nb_cols, figsize=(nb_cols * 2, nb_rows * 2 + 1))\\n\\n for row in range(nb_rows):\\n for col in range(nb_cols):\\n i = row * nb_cols + col\\n if nb_rows == 1:\\n ax = axs[col]\\n else:\\n ax = axs[row, col]\\n # Disable axis even if no image\\n ax.axis('off')\\n # Add image and image caption\\n if i < len(images):\\n ax.imshow(images[i], interpolation='none')\\n if labels and len(labels) > i and labels[i]:\\n ax.set_title(labels[i])\\n\\n if title:\\n fig.suptitle(title)\\n\\n # Adjust the padding between and around subplots\\n plt.tight_layout()\\n # Show it\\n plt.show()\",\n \"def img_render(kve, lopt_str, sopt_str, gopt_str, popt_str, glopt_str, img_path):\\n i_before = ''\\n i_layer = ''\\n i_after = ''\\n i_label_str_html = ''\\n if 'img' in kve:\\n img_paths = [x.strip() for x in kve['img'].split(':')]\\n for opt_str in glopt_str, popt_str, gopt_str, sopt_str, lopt_str:\\n if 'autoilabel' in opt_str:\\n i_label_str = os.path.splitext(os.path.basename(img_paths[0]))[0]\\n i_label_str_html = ' <div class=\\\"label bottom\\\">' \\\\\\n + i_label_str + '</div>'\\n if 'ilabel' in kve:\\n i_label_str = kve['ilabel']\\n i_label_str_html = ' <div class=\\\"label bottom\\\">' \\\\\\n + i_label_str + '</div>'\\n img_tag_str = ''\\n for idx, path in enumerate(img_paths):\\n img_tag_str = img_tag_str + '<img src=\\\"' + img_path + img_paths[idx] + '\\\"/>'\\n for opt_str in [glopt_str, popt_str, gopt_str, sopt_str, lopt_str]:\\n if 'ibefore' in opt_str:\\n i_before = ' <div class=\\\"layout ' + lopt_str \\\\\\n + '\\\"><div class=\\\"img\\\">' + img_tag_str + '</div>' \\\\\\n + i_label_str_html + '</div>'\\n if 'iafter' in opt_str:\\n i_after = ' <div class=\\\"layout ' + lopt_str \\\\\\n + '\\\"><div class=\\\"img\\\">' + img_tag_str + '</div>' \\\\\\n + i_label_str_html + '</div>'\\n if not (i_before or i_after):\\n i_layer = ' <div class=\\\"img\\\">' + img_tag_str + '</div>'\\n return i_before, i_layer, i_after\\n return '', '', ''\",\n \"def on_pushButton_2_clicked(self):\\n # TODO: not implemented yet\\n try:\\n str='str.png'\\n process_pic.graphics ().process (str)\\n self.click=\\\"process\\\"\\n pixMap = QPixmap(\\\"temp.png\\\").scaled(self.label.width(),self.label.height())\\n self.label.setPixmap(pixMap)\\n except:\\n button=QMessageBox.about(self, '注意', '应先向空白处导入图片后再进行处理')\\n else:\\n pass\\n\\n\\n\\n #os.popen('python process_pic.py')\",\n \"def get_image_path_label(all_paths):\\r\\n n_folders_int = random.sample(range(0, len(all_paths)), n_way)\\r\\n image_labels = [[(glob.glob(all_paths[n] + '\\\\*')[k], n) # (path, label)\\r\\n for n in n_folders_int\\r\\n for k in random.sample(range(0, len(glob.glob(all_paths[n] + '\\\\*'))), k_shot+1)\\r\\n ] for b in range(batch_size)] \\r\\n return image_labels\",\n \"def DrawImageLabel(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawImageLabel(*args, **kwargs)\",\n \"def draw_image(res, train, label, output_dir, fig, write_file=False):\\n size = len(label)\\n infer_res, infer_conf, gt_conf = compare_result(res, label)\\n if not os.path.exists(output_dir+\\\"/correct\\\"):\\n os.makedirs(output_dir+\\\"/correct\\\")\\n if not os.path.exists(output_dir + \\\"/incorrect\\\"):\\n os.makedirs(output_dir + \\\"/incorrect\\\")\\n\\n if write_file:\\n cor = open(output_dir+\\\"/res_correct.txt\\\", 'a')\\n err = open(output_dir+\\\"/res_incorrect.txt\\\", 'a')\\n # right inferences\\n r = 0\\n # error inferences\\n e = 0\\n # error details\\n count = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\\n for i in range(size):\\n img = Image.fromarray(train[i].reshape(fig, fig).astype(np.uint8))\\n if infer_res[i] == label[i]:\\n r += 1\\n img.save(output_dir+\\\"/correct/\\\"+str(i)+\\\"_\\\"+str(infer_res[i])+\\\"_\\\"+str(infer_conf[i])+\\\".png\\\")\\n if write_file:\\n cor.write(str(i)+\\\"_\\\"+str(infer_res[i])+\\\"_\\\"+str(infer_conf[i])+str(res[i][0][0][0])+'\\\\n')\\n\\n else:\\n\\n e += 1\\n img.save(output_dir + \\\"/incorrect/\\\" + str(i) + \\\"_gt:\\\" + str(label[i]) + \\\"_\\\" + str(\\n gt_conf[i]) + \\\"_inf:\\\" + str(infer_res[i]) + \\\"_\\\" + str(infer_conf[i]) + \\\".png\\\")\\n count[label[i]] += 1\\n if write_file:\\n err.write(str(i) + \\\"_gt:\\\"+str(label[i]) + \\\"_\\\"+str(gt_conf[i]) + \\\"_inf:\\\"+str(infer_res[i])+\\\"_\\\" +\\n str(infer_conf[i]) + str(res[i][0][0][0]) + '\\\\n')\\n if write_file:\\n cor.close()\\n err.close()\\n print(\\\"correct inference results:\\\"+str(r))\\n print(\\\"incorrect inference results:\\\" + str(e))\\n print(\\\"incorrect inference results details:\\\" + str(count))\",\n \"def show_shot(path_to_images, name_image):\\n crrt_image = misc.imread(\\\"./{}/{}\\\".format(path_to_images, name_image))\\n\\n plt.imshow(crrt_image)\\n\\n plt.draw()\\n plt.pause(0.5)\",\n \"def display_sample(display_list):\\n plt.figure(figsize=(18, 18))\\n\\n title = ['Input Image', 'True Mask', 'Predicted Mask']\\n\\n for i in range(len(display_list)):\\n plt.subplot(1, len(display_list), i+1)\\n plt.title(title[i])\\n plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))\\n plt.axis('off')\\n plt.show()\",\n \"def plot_fig2(tables_task_ids):\\n from snep.tables.experiment import ExperimentTables\\n\\n tables, task_ids = tables_task_ids['test0']\\n assert isinstance(tables, ExperimentTables) # This allows PyCharm to autocomplete method names for tables\\n params = tables.get_general_params(True)\\n param_ranges = tables.read_param_ranges()\\n\\n # filter tasks to only the ones that reach the targets\\n targets = [{('c',): 0, ('bfb',): 0}]\\n target_ids = filter_tasks(task_ids, targets)\\n\\n # -------------------------------------\\n # Get experiment results and params\\n # -------------------------------------\\n # Simulation times\\n ntrls = len(target_ids)\\n sub = params['sen']['populations']['sub']\\n settletime = params['simulation']['settletime'] / second\\n runtime = params['simulation']['runtime'] / second - settletime\\n stimon = params['simulation']['stimon'] / second - settletime\\n stimoff = params['simulation']['stimoff'] / second - settletime\\n pops, timepoints = tables.get_raw_data(task_ids[0])['poprates_dec'].shape\\n dt = runtime / timepoints\\n nSE, downsampltimepoints = tables.get_computed(task_ids[0])['spikes'].shape\\n time = np.linspace(0, runtime, timepoints)\\n downsampltime = np.linspace(0, runtime, downsampltimepoints)\\n downsampldt = runtime / downsampltimepoints\\n\\n # allocate variables\\n rateDE = np.empty((ntrls, pops, timepoints), dtype='float32')\\n rateSE = np.empty((ntrls, pops, timepoints), dtype='float32')\\n spksSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\\n # evntSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\\n # brstSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\\n # snglSE = np.empty((ntrls, nSE, downsampltimepoints), dtype='float32')\\n pref_msk = np.empty((ntrls, 1), dtype='int')\\n\\n # loop through trials and retrieve results\\n for trl, tid in tqdm(enumerate(target_ids)):\\n # get neurometric info of all neurons\\n computed = tables.get_computed(tid)\\n spksSE[trl] = computed['spikes']\\n # evntSE[trl] = computed['events']\\n # brstSE[trl] = computed['bursts']\\n # snglSE[trl] = computed['singles']\\n\\n # population rates\\n raw_data = tables.get_raw_data(tid)\\n rateDE[trl] = raw_data['poprates_dec'] # 0: pref, 1: npref\\n rateSE[trl] = raw_data['poprates_sen'] # 0: pref, 1: npref\\n pref_msk[trl] = raw_data['pref_msk']\\n\\n # -------------------------------------\\n # Choice probability and correlations\\n # -------------------------------------\\n # accuracy\\n acc = pref_msk.sum() / ntrls\\n\\n # get active neurons, 100 per subpopulation\\n actn = get_actn(spksSE, sub)\\n\\n # a calculation every 1, 5 or 10 ms?\\n stepCP = 10\\n auc1 = get_CPs(spksSE, np.logical_not(pref_msk), actn[0], downsampldt, step=stepCP)\\n auc2 = get_CPs(spksSE, pref_msk.astype(bool), actn[1], downsampldt, step=stepCP)\\n auc12 = np.concatenate((auc1, auc2), axis=0)\\n\\n stepCorr = 50\\n corrsall, corrsii, corrsij = get_corr(spksSE, actn, downsampldt, step=stepCorr)\\n\\n # -------------------------------------\\n # Plot figure 2\\n # -------------------------------------\\n fig, axs = plt.subplots(4, 1, figsize=(8, 12), sharex=True)\\n\\n fig.add_axes(axs[0])\\n plt.plot(time, rateDE[:, 0, :].mean(axis=0), c='C3', lw=2, label='preferred')\\n plt.plot(time, rateDE[:, 1, :].mean(axis=0), c='C0', lw=2, label='non-preferred')\\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=1.5)\\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=1.5)\\n plt.title('Integration circuit')\\n plt.ylabel('Population rate (sp/s)') # , {'horizontalalignment': 'right'}\\n plt.ylim(0, 50)\\n # plt.legend(loc='center right', bbox_to_anchor=(1.22, 0.82))\\n\\n # sensory circuit\\n fig.add_axes(axs[1])\\n plt.plot(time, rateSE[:, 0, :].mean(axis=0), c='C3', lw=2, label='preferred')\\n plt.plot(time, rateSE[:, 1, :].mean(axis=0), c='C0', lw=2, label='pon-preferred')\\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\\n plt.title('Sensory circuit')\\n plt.ylabel('Population rate (sp/s)')\\n plt.ylim(0, 20) # 0, 15\\n plt.legend(loc='center', bbox_to_anchor=(0.76, 0.91), ncol=2, fontsize='x-small')\\n\\n # CPs\\n # clean to plot\\n aucm = auc12.mean(axis=0)\\n ymin = 0.45\\n cleanaucm = np.ones(aucm.shape) * np.nan\\n cleanaucm[aucm > ymin] = aucm[aucm > ymin]\\n\\n fig.add_axes(axs[2])\\n plt.plot(downsampltime[::stepCP][1:], cleanaucm, 'k', lw=2)\\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\\n plt.ylabel('Choice prob.')\\n plt.ylim(ymin, ymin + 0.2) # ymin+0.2\\n\\n # correlations\\n fig.add_axes(axs[3])\\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsall, axis=0), c='k', lw=2, label='EE')\\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsii, axis=0), c='C4', lw=2, label='EiEi')\\n plt.plot(downsampltime[::stepCorr][1:], np.nanmean(corrsij, axis=0), c='C2', lw=2, label='EjEj')\\n plt.axvline(x=stimon, color='gray', ls='dashed', lw=2)\\n plt.axvline(x=stimoff, color='gray', ls='dashed', lw=2)\\n plt.xlim(stimon - 0.5, stimoff + 0.5)\\n plt.ylim(-0.2, 0.2) # -0.25, 0.25\\n plt.xlabel('Time (s)')\\n plt.ylabel('Noise correlations')\\n plt.legend(loc='center', bbox_to_anchor=(0.77, 0.95), ncol=3, fontsize='x-small')\\n\\n # save figure\\n #savepath = '/Users/PSR/Documents/WS19/MasterThesis/Experiments/run_hierarchical/'\\n fig.savefig(load_path + '/' + thisexperiment + '/figure2.png')\\n plt.close(fig)\\n\\n # -------------------------------------\\n # Save analysis\\n # -------------------------------------\\n thisanalysisname = '/CPs-' + str(ntrls) + 'trls-' + str(targets) + '.pkl'\\n\\n # save variables\\n with open(savepath + thisexperiment + thisanalysisname, 'wb') as f:\\n pickle.dump([pref_msk,\\n actn,\\n auc12,\\n [corrsall, corrsii, corrsij]], f)\\n\\n # TODO: plot burst probability and coherence levels\\n # TODO: plot accuracy!\",\n \"def labelling():\\n title = input('Please enter the title of output figure: ')\\n plt.title(title)\\n plt.xlabel(\\\"Time (s)\\\")\\n plt.ylabel(\\\"Voltage (V)\\\")\\n plt.legend()\\n plt.savefig(\\\"Scope_%s\\\"%str(round(time.time()))) # Time stamp on file names\\n plt.show()\",\n \"def show(image,label,pred):\\n from matplotlib import pyplot\\n import matplotlib as mpl\\n fig = pyplot.figure()\\n ax = fig.add_subplot(1,1,1)\\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\\n imgplot.set_interpolation('nearest')\\n s=\\\"True Label : \\\"+str(label)+\\\" Predicted label : \\\"+str(pred)\\n pyplot.xlabel(s,fontname=\\\"Arial\\\", fontsize=20 )\\n ax.xaxis.set_ticks_position('top')\\n ax.yaxis.set_ticks_position('left')\\n pyplot.show()\",\n \"def save_images(PATH, show_img, datasets, from_dataset):\\n dataset = datasets[from_dataset]\\n imgModels = dataset['models']\\n for modelname, model in imgModels.items():\\n print('save', modelname)\\n plt.imshow(model[70])\\n plt.set_cmap(\\\"gray\\\")\\n plt.axis('off')\\n plt.savefig(PATH + '/' + from_dataset + '_' + modelname + '.png', dpi=400)\\n\\n if show_img == True:\\n plt.show()\",\n \"def plot_gallery(images, titles, h, w, n_row=3, n_col=4):\\n plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))\\n plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\\n for i in range(n_row * n_col):\\n plt.subplot(n_row, n_col, i + 1)\\n plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)\\n plt.title(titles[i], size=12)\\n plt.xticks(())\\n plt.yticks(())\\n plt.show()\\n plt.savefig(\\\"feature_{}.png\\\".format(50))\",\n \"def visualize_image(images, save_name):\\n dim = images.shape[0]\\n n_image_rows = int(np.ceil(np.sqrt(dim)))\\n n_image_cols = int(np.ceil(dim * 1.0 / n_image_rows))\\n gs = gridspec.GridSpec(n_image_rows, n_image_cols, top=1., bottom=0.,\\n right=1., left=0., hspace=0., wspace=0.)\\n\\n for g, count in zip(gs, range(int(dim))):\\n ax = plt.subplot(g)\\n ax.imshow(images[count, :].astype(np.float32).reshape((28, 28)))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n plt.savefig(save_name + '_vis.png')\",\n \"def plot_imgs_and_ctrs_itk(self, itk_imgs: list, itk_ctrs: list, slices=SliceMode.ALL, title='',\\n plane=PlaneTypes.AXIAL, draw_only_ctrs=True, file_name_prefix='', labels=[]):\\n args = {\\n 'imgs': [sitk.GetArrayFromImage(itk_img) for itk_img in itk_imgs],\\n 'ctrs': [sitk.GetArrayFromImage(itk_ctr) for itk_ctr in itk_ctrs],\\n 'slices': slices,\\n 'plane': plane,\\n 'draw_only_ctrs': draw_only_ctrs,\\n 'file_name_prefix': file_name_prefix,\\n 'labels': labels,\\n 'title': title\\n }\\n self._plot_imgs_and_ctrs_np(args)\",\n \"def create_png(image, label):\\n sv = \\\"/home/avojtekova/Desktop/final_results/star_det/generated_images/\\\" \\n \\n for i in range(len(image)):\\n data = fits.getdata(image[i][0], ext = 0)\\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\\n \\n print(image[i][0])\\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \\n plt.title(label[i])\\n plt.axis('off')\\n plt.tight_layout()\\n plt.legend\\n if i<2:\\n if not os.path.isdir(sv + image[i][0][-33:-25] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-33:-25] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-33:-25] + \\\"/\\\" + label[i]+ \\\"_\\\" + image[i][0][-33:-25] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \\n else:\\n if not os.path.isdir(sv + image[i][0][-40:-32] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-40:-32] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-40:-32] + \\\"/\\\" + label[i]+image[i][0][-40:-32] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\\n plt.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62449753","0.5956047","0.5905638","0.5834986","0.5807051","0.57767344","0.5769278","0.5720147","0.5714393","0.5708018","0.55924964","0.55918765","0.55361027","0.55186796","0.5489448","0.5472695","0.54674464","0.54264355","0.5421594","0.54154986","0.5411966","0.54003215","0.53931046","0.539129","0.5387641","0.5376994","0.5375564","0.53652376","0.5361416","0.53431624","0.5333098","0.531914","0.5310269","0.53023076","0.52925986","0.5289381","0.52724946","0.52576625","0.5251245","0.52412915","0.5238899","0.5234611","0.52279174","0.52206963","0.5218306","0.52144814","0.52144814","0.52144814","0.52075404","0.52033025","0.51798683","0.5173278","0.51603675","0.51226205","0.5117339","0.51143515","0.5113879","0.5111192","0.5109851","0.5104857","0.50992906","0.50950855","0.5092445","0.50900835","0.5087552","0.50849444","0.50694644","0.5069408","0.5066314","0.50659156","0.50622135","0.5044865","0.5040086","0.5039105","0.50374085","0.5036336","0.5032989","0.5027913","0.50261366","0.5024661","0.5021999","0.50180805","0.50163376","0.5014156","0.50133526","0.5003455","0.5001073","0.49953723","0.49923632","0.49919704","0.49909258","0.4989883","0.49889165","0.4985849","0.49837622","0.49822855","0.49768722","0.4972097","0.49716833","0.49714845"],"string":"[\n \"0.62449753\",\n \"0.5956047\",\n \"0.5905638\",\n \"0.5834986\",\n \"0.5807051\",\n \"0.57767344\",\n \"0.5769278\",\n \"0.5720147\",\n \"0.5714393\",\n \"0.5708018\",\n \"0.55924964\",\n \"0.55918765\",\n \"0.55361027\",\n \"0.55186796\",\n \"0.5489448\",\n \"0.5472695\",\n \"0.54674464\",\n \"0.54264355\",\n \"0.5421594\",\n \"0.54154986\",\n \"0.5411966\",\n \"0.54003215\",\n \"0.53931046\",\n \"0.539129\",\n \"0.5387641\",\n \"0.5376994\",\n \"0.5375564\",\n \"0.53652376\",\n \"0.5361416\",\n \"0.53431624\",\n \"0.5333098\",\n \"0.531914\",\n \"0.5310269\",\n \"0.53023076\",\n \"0.52925986\",\n \"0.5289381\",\n \"0.52724946\",\n \"0.52576625\",\n \"0.5251245\",\n \"0.52412915\",\n \"0.5238899\",\n \"0.5234611\",\n \"0.52279174\",\n \"0.52206963\",\n \"0.5218306\",\n \"0.52144814\",\n \"0.52144814\",\n \"0.52144814\",\n \"0.52075404\",\n \"0.52033025\",\n \"0.51798683\",\n \"0.5173278\",\n \"0.51603675\",\n \"0.51226205\",\n \"0.5117339\",\n \"0.51143515\",\n \"0.5113879\",\n \"0.5111192\",\n \"0.5109851\",\n \"0.5104857\",\n \"0.50992906\",\n \"0.50950855\",\n \"0.5092445\",\n \"0.50900835\",\n \"0.5087552\",\n \"0.50849444\",\n \"0.50694644\",\n \"0.5069408\",\n \"0.5066314\",\n \"0.50659156\",\n \"0.50622135\",\n \"0.5044865\",\n \"0.5040086\",\n \"0.5039105\",\n \"0.50374085\",\n \"0.5036336\",\n \"0.5032989\",\n \"0.5027913\",\n \"0.50261366\",\n \"0.5024661\",\n \"0.5021999\",\n \"0.50180805\",\n \"0.50163376\",\n \"0.5014156\",\n \"0.50133526\",\n \"0.5003455\",\n \"0.5001073\",\n \"0.49953723\",\n \"0.49923632\",\n \"0.49919704\",\n \"0.49909258\",\n \"0.4989883\",\n \"0.49889165\",\n \"0.4985849\",\n \"0.49837622\",\n \"0.49822855\",\n \"0.49768722\",\n \"0.4972097\",\n \"0.49716833\",\n \"0.49714845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80462617"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10796,"cells":{"query":{"kind":"string","value":"Computes top principal component."},"document":{"kind":"string","value":"def pc1(d):\n\timport numpy as np\n\tfrom sklearn.decomposition import TruncatedSVD\n\t# Normalize data\n\tt1 = d.T\n\tt1 = t1 - t1.mean(axis=0)\n\tt1 = t1 / (np.sqrt((t1**2).mean(axis=0)) + 1E-200)\n\tt0 = TruncatedSVD(n_components=1)\n\tt1 = t0.fit_transform(t1).T.astype(d.dtype, copy=False).ravel()\n\tassert t1.shape == (d.shape[1], )\n\treturn t1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def first_principal_component(X):\n guess = [1 for _ in X[0]]\n unscaled_maximizer = maximize_batch(\n partial(directional_variance, X),\n partial(directional_variance_gradient, X),\n guess)\n return direction(unscaled_maximizer)","def max_principal_components(self):\n return self._max_principal_components","def principal(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"principal\")","def principal(self):\n return Principal(self)","def total_principal(self) -> Decimal:\n return self._quantize(self.principal)","def top_layer(self):\n return self._top","def cohighest_root(self):\n return self.highest_root().associated_coroot()","def top(self):","def principal(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"principal\")","def get_principal(self, principal_id, info=True):","def principal(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"principal\")","def principal(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"principal\")","def principal(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"principal\")","def principal(self):\n s = [self.voigt[i] for i in range(6)]\n\n # calculate centers\n cxy = (s[0] + s[1]) / 2\n cyz = (s[1] + s[2]) / 2\n czx = (s[2] + s[0]) / 2\n\n # calculate radii\n rxy = ((s[0] - s[1])**2 + (2*s[3])**2)**(1/2) / 2\n ryz = ((s[1] - s[2])**2 + (2*s[4])**2)**(1/2) / 2\n rzx = ((s[2] - s[0])**2 + (2*s[5])**2)**(1/2) / 2\n\n return array([[cxy + rxy, cxy - rxy, rxy],\n [cyz + ryz, cyz - ryz, ryz],\n [czx + rzx, czx - rzx, rzx]])","def top(self):\n return self[0]","def top(self):\n # type: () -> float\n return self._top","def top(self):\n return self.a[-1]","def top(self) -> Face:\n return self.bodies[0].faces[self._top_index]","def principal(sigma):\n vals, vecs = np.linalg.eigh(sigma)\n vals = np.abs(vals)\n order = vals.argsort()[::-1]\n vecs = vecs[:, order]\n vals = vals[order]\n\n func = mplstereonet.vector2plunge_bearing\n vec_orientations = [func(*item) for item in vecs.T]\n\n \"\"\"\n val1, val2, val3 = vals\n print (val2-val3) / (val1 - val3)\n print 'sigma1', val1 \n print 'sigma2', val2\n print 'sigma3', val3\n \"\"\"\n return vals, vec_orientations","def null_coroot(self):\n assert(self.cartan_type().is_affine())\n coef = self.cartan_type().acheck()\n return sum(coef[k]*self.simple_coroots()[k] for k in coef.keys())","def top(self):\n # if not empty\n if not self.empty():\n return self._data[0].get_value()[1].course\n # if empty\n return None","def top(self):\n return self.get_cards()[-1]","def get_raw_principal(self, principal_id):","def top(heap):\n return heap[_root()]","def get_pca_principal_component_images(self):\n return self.get_pca_images()[2]","def PrincipalComponents(mat,reverseOrder=1):\n covMat = FormCorrelationMatrix(mat)\n\n eigenVals,eigenVects = numpy.linalg.eig(covMat)\n try:\n eigenVals = eigenVals.real\n except:\n pass\n try:\n eigenVects = eigenVects.real\n except:\n pass\n\n # and now sort:\n ptOrder = numpy.argsort(eigenVals).tolist()\n if reverseOrder:\n ptOrder.reverse()\n eigenVals = numpy.array([eigenVals[x] for x in ptOrder])\n eigenVects = numpy.array([eigenVects[x] for x in ptOrder])\n return eigenVals,eigenVects","def finalize_top(self, top):\n if not self.use_pr:\n return top\n\n # Expose AXI interface to the top level, and then wrap the entire\n # user design.\n top.add_port('axil_clk', 'axil_clk', parent_sig=False, dir='in')\n top.add_port('axil_rst_n', 'axil_clk', parent_sig=False, dir='in')\n top.add_port('M_AXI_araddr', 'M_AXI_araddr', width=32, parent_sig=False, dir='in')\n top.add_port('M_AXI_arready', 'M_AXI_arready', parent_sig=False, dir='out')\n top.add_port('M_AXI_arvalid', 'M_AXI_arvalid', parent_sig=False, dir='in')\n top.add_port('M_AXI_awaddr', 'M_AXI_awaddr', width=32, parent_sig=False, dir='in')\n top.add_port('M_AXI_awready', 'M_AXI_awready', parent_sig=False, dir='out')\n top.add_port('M_AXI_awvalid', 'M_AXI_awvalid', parent_sig=False, dir='in')\n top.add_port('M_AXI_bready', 'M_AXI_bready', parent_sig=False, dir='in')\n top.add_port('M_AXI_bresp', 'M_AXI_bresp', width=2, parent_sig=False, dir='out')\n top.add_port('M_AXI_bvalid', 'M_AXI_bvalid', parent_sig=False, dir='out')\n top.add_port('M_AXI_rdata', 'M_AXI_rdata', width=32, parent_sig=False, dir='out')\n top.add_port('M_AXI_rready', 'M_AXI_rready', parent_sig=False, dir='in')\n top.add_port('M_AXI_rresp', 'M_AXI_rresp', width=2, parent_sig=False, dir='out')\n top.add_port('M_AXI_rvalid', 'M_AXI_rvalid', parent_sig=False, dir='out')\n top.add_port('M_AXI_wdata', 'M_AXI_wdata', width=32, parent_sig=False, dir='in')\n top.add_port('M_AXI_wready', 'M_AXI_wready', parent_sig=False, dir='out')\n top.add_port('M_AXI_wstrb', 'M_AXI_wstrb', width=4, parent_sig=False, dir='in')\n top.add_port('M_AXI_wvalid', 'M_AXI_wvalid', parent_sig=False, dir='in')\n if self.enable_wishbone:\n top.add_port('wbm_cyc_o', 'wbm_cyc_o', parent_sig=False, dir='in')\n top.add_port('wbm_stb_o', 'wbm_stb_o', parent_sig=False, dir='in')\n top.add_port('wbm_we_o ', 'wbm_we_o ', parent_sig=False, dir='in')\n top.add_port('wbm_sel_o', 'wbm_sel_o', parent_sig=False, dir='in', width=4)\n top.add_port('wbm_adr_o', 'wbm_adr_o', parent_sig=False, dir='in', width=32)\n top.add_port('wbm_dat_o', 'wbm_dat_o', parent_sig=False, dir='in', width=32)\n top.add_port('wbm_dat_i', 'wbm_dat_i', parent_sig=False, dir='out', width=32)\n top.add_port('wbm_ack_i', 'wbm_ack_i', parent_sig=False, dir='out')\n top.add_port('wb_clk_i', 'wb_clk_i', parent_sig=False, dir='in')\n top.add_port('wb_rst_i', 'wb_rst_i', parent_sig=False, dir='in')\n top.instantiate_child_ports()\n # With PR, we're not going to be using this module as top. Instead, let's\n # rename is `user_top` which will be instantiated within a high-level static top-level.\n # The assumpion is that the static top-level is already routed and included in a project and need\n # not be generated here.\n top.name = 'user_top'\n return top","def _TopCLIElement(self):\n if self.IsRoot():\n return self\n # pylint: disable=protected-access\n return self._parent_group._TopCLIElement()","def form_top_clipping_plane(fx: float, img_height: int) -> np.ndarray:\n top_plane = np.array([0.0, fx, img_height / 2.0, 0.0])\n top_plane /= np.linalg.norm(top_plane)\n return top_plane","def top(self):\n return self.points['topRight'].y","def top(self):\n return self.points['topRight'].y","def principal_component_analysis(X, num_components):\n components = []\n for _ in range(num_components):\n component = first_principal_component(X)\n components.append(component)\n X = remove_projection(X, component)\n \n return components","def first_top_bottom():\n identity = NB_CARDS * np.identity(NB_CARDS)\n # First outcome, the deck isn't changed\n shuffled_deck_1 = deepcopy(identity)\n # Second outcome, the first card is at the bottom and every other cards goes\n # up\n shuffled_deck_2 = deepcopy(identity)\n for i in range(NB_CARDS-1):\n shuffled_deck_2[i] = deepcopy(identity[i+1])\n shuffled_deck_2[NB_CARDS-1] = deepcopy(identity[0])\n # Now we have to combine the two outcome with probability half\n return (shuffled_deck_1 + shuffled_deck_2)/2","def top(self):\n return self._top","def top(self):\n return self._top","def get_principal_data( user_email ):\n \n try:\n sp = models.SyndicatePrincipal.objects.get( principal_id=user_email )\n return sp\n except ObjectDoesNotExist:\n logger.error(\"No SyndicatePrincipal record for %s\" % user_email)\n return None","def getContainerTop(self):\n return self.containerTop","def calculate_principal_components(embedding, num_components=3):\n embedding -= tf.reduce_mean(embedding, axis=0, keep_dims=True)\n sigma = tf.matmul(embedding, embedding, transpose_a=True)\n _, u, _ = tf.svd(sigma)\n return u[:, :num_components]","def get_topmost_card(self):\n if len(self.cards) > 0:\n return self.cards[-1]\n else:\n return None","def top(self) -> Optional[FloatObject]:\n return self.get(\"/Top\", None)","def principal(self):\n\n\n sw = self.telofase()\n if sw is False:\n exc, var = self.excentricidad()\n if 0.35 < exc < 0.5:\n self.guardar_imagen('anafase')\n return 3\n elif 0.5 <= exc < 0.65:\n self.guardar_imagen('metafase')\n return 2\n elif exc >= 0.65:\n self.guardar_imagen('profase')\n return 1\n else:\n self.guardar_imagen('sin_clasificar')\n return 0\n else:\n return 4","def top(self):\r\n return self.topele","def top(self) -> int:\n return self.topEle","def top( self , i , j ):\n return self._get_top( i , j )","def top(self) -> int:\n return self.topvalue","def PrincipalComponents(mat, reverseOrder=1):\n covMat = FormCorrelationMatrix(mat)\n\n eigenVals, eigenVects = numpy.linalg.eig(covMat)\n # The 'real' component, if it exists as its own attribute\n eigenVals = getattr(eigenVals, \"real\", eigenVals)\n eigenVects = getattr(eigenVects, \"real\", eigenVects)\n\n # and now sort:\n ptOrder = numpy.argsort(eigenVals).tolist()\n if reverseOrder:\n ptOrder.reverse()\n eigenVals = numpy.array([eigenVals[x] for x in ptOrder])\n eigenVects = numpy.array([eigenVects[x] for x in ptOrder])\n return eigenVals, eigenVects","def evalTopContactDisp(length: float,\n topcurve_radius: float,\n topJointAngle: float, \n topOrientationDF: float):\n halfJointAngle = topJointAngle/2\n return np.array((\n topcurve_radius*sin(halfJointAngle)*sin(topOrientationDF),\n -topcurve_radius*sin(halfJointAngle)*cos(topOrientationDF),\n topcurve_radius*cos(halfJointAngle) + length/2 - topcurve_radius\n ))","def principal_axis(alpha_carbons):\n # alpha carbons coordinates as a numpy array\n coord = numpy.array(alpha_carbons, float)\n\n # get geometrical center\n center = numpy.mean(coord, 0)\n coord = coord - center\n\n # create inertia matrix and extract eigenvectors and values\n inertia = numpy.dot(coord.transpose(), coord)\n e_values, e_vectors = numpy.linalg.eig(inertia)\n\n # sort eigenvalues\n order = numpy.argsort(e_values)\n\n # axis1 is the principal axis with the greatest eigenvalue\n _, _, axis1 = e_vectors[:, order].transpose()\n\n axis_direction = axis1 / numpy.linalg.norm(axis1)\n\n return center, axis_direction","def principal_po_box(self, principal_po_box):\n\n self._principal_po_box = principal_po_box","def top(self) -> float:\n points = self.get_adjusted_points()\n y_points = [point[1] for point in points]\n return max(y_points)","def top_draw(self):\n top_card = self.cards.pop(0)\n return top_card","def top_right(self, obj):\n return self.phy2abs.top_right(obj)","def top_authors(cursor):\n top_auth = 'No authors found.'\n try:\n cursor.execute(\"\"\"\n select name, hits\n from authors, views_by_id as views_by_id\n where id = author\n group by name, hits\n order by hits desc\"\"\")\n\n authors = cursor.fetchall()\n # If no authors were found, return\n if len(authors) <= 0:\n return top_auth\n\n except psycopg2.Error as e:\n print('Fetching authors by popularity: \\r\\n{}'.format(e.pgerror))\n\n # If the query returns any authors, return the results.\n else:\n top_auth = 'Top authors by article views: \\r\\n'\n for auth in authors:\n top_auth += ' {} - {} views\\r\\n'.format(auth[0], auth[1])\n return top_auth","def do_top(cs, args):\n\n if args.pid:\n # List container single ps id top result\n output = cs.containers.top(args.container, ' '.join(args.pid))\n else:\n # List container all processes top result\n output = cs.containers.top(args.container)\n for titles in output['Titles']:\n print(\"%-20s\") % titles,\n if output['Processes']:\n for process in output['Processes']:\n print(\"\")\n for info in process:\n print(\"%-20s\") % info,\n else:\n print(\"\")","def __top_Algs_ ( self ) :\n _algs = self.TopAlg\n\n def _alg_name_ ( _n ):\n\n _p = _n.rfind('/')\n if 0 > _p : return _n\n return _n[_p:]\n\n def _pyAlg ( _n ) :\n for _a in self.pyalgorithms :\n if _n == _a.name() : return _a\n return None \n \n algs = [] \n for _a in _algs :\n # get the proper name \n _n = _alg_name_ ( _a )\n # check if it is pyalgorithm:\n _pa = _pyAlg ( _n )\n if _pa :\n algs += [ _pa ]\n else :\n _alg = self.algorithm ( _a , True )\n algs += [ _alg ]\n \n return algs","def __top_Algs_ ( self ) :\n _algs = self.TopAlg\n\n def _alg_name_ ( _n ):\n\n _p = _n.rfind('/')\n if 0 > _p : return _n\n return _n[_p:]\n\n def _pyAlg ( _n ) :\n for _a in self.pyalgorithms :\n if _n == _a.name() : return _a\n return None \n \n algs = [] \n for _a in _algs :\n # get the proper name \n _n = _alg_name_ ( _a )\n # check if it is pyalgorithm:\n _pa = _pyAlg ( _n )\n if _pa :\n algs += [ _pa ]\n else :\n _alg = self.algorithm ( _a , True )\n algs += [ _alg ]\n \n return algs","def set_principal_components(principal_components):\n View.__principal_components = principal_components","def get_top_solution_score(self):\n top_solution_score = self.top_k_solution_scores[0] if len(self.top_k_solution_scores) else None\n return top_solution_score","def PCA(X, k):\n cov = np.matmul(np.matrix.transpose(X), X)\n w, v = np.linalg.eig(cov)\n k_largest = np.argsort(w)[::-1][:k]\n v = np.matrix.transpose(v)\n U = v[k_largest]\n S = w[k_largest]\n return U, S","def cf_profile_ac(self):\n return self.gen_profile() / self.system_capacity_ac()","def top(self):\n\n return self._top","def associated_coroot(self):","def interest_to_principle(self) -> float:\n return float(round(self.total_interest / self.total_principal * 100, 1))","def principal_order_ideal(self, x):\n return self.order_ideal([x])","def midtop(self):\n return (self.centerx, self.top)","def circle_of_least_confusion(self):\n ff=beam_field() \n ff.rectangular_grid(1,2000,self.entrance_pupil)\n ff.propagate(self.surfaces)\n def f(x):\n pl=ff.project_onto_plane(x)\n return max(pl[:,1])\n \n # m=self.marginal_ray\n if hasattr(self, 'start'):\n start=self.start\n else:\n# start=(m.Q_p[-1,0,2]-m.Q_p[-2,0,2])/2\n start=(self.surfaces[-1].pos()-self.surfaces[-2].pos())/2\n #print(start)\n res=minimize(f,(start), method='Nelder-Mead')\n self.start=res.final_simplex[0][0,0]\n \n return res.final_simplex[0][0,0],res.final_simplex[1][0]","def top(self, value):\n\n pass","def get_principal_title_task():\n interaction = zope.security.management.getInteraction()\n return interaction.participations[0].principal.title","def ft_syndicate_principal():\n print \"generating key pair\"\n pubkey_pem, privkey_pem = api.generate_key_pair( 4096 )\n \n user_email = \"fakeuser@opencloud.us\"\n \n print \"saving principal\"\n put_principal_data( user_email, \"asdf\", pubkey_pem, privkey_pem )\n \n print \"fetching principal private key\"\n saved_privkey_pem = get_principal_pkey( user_email, \"asdf\" )\n \n assert saved_privkey_pem is not None, \"Could not fetch saved private key\"\n assert saved_privkey_pem == privkey_pem, \"Saved private key does not match actual private key\"\n \n print \"delete principal\"\n \n delete_principal_data( user_email )\n \n print \"make sure its deleted...\"\n \n saved_privkey_pem = get_principal_pkey( user_email, \"asdf\" )\n \n assert saved_privkey_pem is None, \"Principal key not deleted\"","def top(self):\n return self.q1.return_top()","def printTopAuthors():\n query = \"\"\"\n SELECT author_article_popularity_view.author,\n SUM(author_article_popularity_view.views) AS total_views\n FROM author_article_popularity_view\n GROUP BY author_article_popularity_view.author\n ORDER BY total_views DESC;\n \"\"\"\n cursor = connection.cursor()\n cursor.execute(query)\n results = cursor.fetchall()\n print(\"\\nTop authors of all time: \")\n for i, result in enumerate(results):\n print(\"{}. {} - {:,} views\".format(i + 1, result[0], result[1]))","def top(self):\n print(self.arr[-1])","def top(self):\n return self.arr[-1]","def getPrincipal(id=None):\n if id is None:\n interaction = queryInteraction()\n\n if interaction is not None:\n for participation in interaction.participations:\n if participation.principal is not None:\n return participation.principal\n else:\n try:\n return getUtility(IAuthentication).getPrincipal(id)\n except PrincipalLookupError:\n return None","def computeTopSurfaceIndices(top):\n itop = np.array([(top[i,j], j, i) \\\n for i in range(top.shape[0]) \\\n for j in range(top.shape[1]) \\\n if top[i,j] >= 0])\n return itop","def h_P(self, z0):\n # Get the governing variables\n (B, N, u_slip, u_inf) = self.get_variables(z0, 0.)\n \n # Compute U_N\n U_N = u_slip / (B * N)**(1./4.)\n \n # Compute the correlation equation\n return 5.2 * np.exp(-(U_N - 1.8)**2 / 10.24) * (B / N**3)**(1./4.)","def top_of_climb_index(self):\n return self.altitudes.argmax()","def top(self):\n \n assert not self.empty()\n return self._s[-1]","def null_root(self):\n if self.cartan_type().is_affine():\n coef = self.cartan_type().a()\n return sum(coef[k]*self.simple_roots()[k] for k in coef.keys())","def test_top_clipping_plane() -> None:\n fx_px = 10.0\n height_px = 45\n pinhole_camera = _create_pinhole_camera(\n fx_px=fx_px,\n fy_px=0,\n cx_px=0,\n cy_px=0,\n height_px=height_px,\n width_px=1000,\n cam_name=\"ring_front_center\",\n )\n\n top_plane = pinhole_camera.top_clipping_plane\n\n width_px = 1000.0\n points_xyz: NDArrayFloat = np.array(\n [\n [0, 0, 0],\n [-width_px / 2, -height_px / 2, fx_px],\n [width_px / 2, -height_px / 2, fx_px],\n ]\n )\n a, b, c, d = _fit_plane_to_point_cloud(points_xyz)\n top_plane_expected: NDArrayFloat = np.array([a, b, c, d])\n\n # enforce that plane normal points into the frustum\n if top_plane_expected[1] < 0:\n # y-coord of normal should point in pos y-axis dir(down) on top-clipping plane\n top_plane_expected *= -1\n\n assert top_plane_expected[1] > 0 and top_plane_expected[2] > 0\n assert np.allclose(top_plane, top_plane_expected)","def user_principal_name(self):\n if \"userPrincipalName\" in self._prop_dict:\n return self._prop_dict[\"userPrincipalName\"]\n else:\n return None","def user_principal_name(self):\n if \"userPrincipalName\" in self._prop_dict:\n return self._prop_dict[\"userPrincipalName\"]\n else:\n return None","def principal_id(self) -> Optional[str]:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def principal_id(self) -> str:\n return pulumi.get(self, \"principal_id\")","def get_top_role(self, default = None):\n top_role = default\n \n role_ids = self.role_ids\n if (role_ids is not None):\n role_found = False\n \n for role_id in role_ids:\n try:\n role = ROLES[role_id]\n except KeyError:\n continue\n \n if role_found:\n if role > top_role:\n top_role = role\n else:\n top_role = role\n role_found = True\n \n # If non of the roles is cached, create a partial role from the highest id.\n if not role_found:\n top_role = create_partial_role_from_id(role_ids[-1])\n \n return top_role","def topolar(img, order=1):\n '''From Stackreg'''\n # max_radius is the length of the diagonal\n # from a corner to the mid-point of img.\n max_radius = 0.5*np.linalg.norm( img.shape )\n\n def transform(coords):\n # Put coord[1] in the interval, [-pi, pi]\n theta = 2*np.pi*coords[1] / (img.shape[1] - 1.)\n\n # Then map it to the interval [0, max_radius].\n radius = max_radius * coords[0] / img.shape[0]\n\n i = 0.5*img.shape[0] - radius*np.sin(theta)\n j = radius*np.cos(theta) + 0.5*img.shape[1]\n return i,j\n\n polar = ndimage.interpolation.geometric_transform(img, transform, order=order)\n\n rads = max_radius * np.linspace(0,1,img.shape[0])\n angs = np.linspace(0, 2*np.pi, img.shape[1])\n\n return polar, (rads, angs)","def top_right(self, obj):\n if (obj.__class__.__name__ == 'PhysicalObject') or (issubclass(obj.__class__, laygo2.object.PhysicalObject)):\n return self.top_right(obj.bbox)\n else:\n _i = self.bbox(obj)\n return _i[1]","def top(self):\n if self.is_empty():\n return None\n return self._head.value","def top(self) -> object:\n return self._data[-1]","def top(self) -> object:\n return self._data[-1]","def child_U(self):\n return math.sqrt(self.number_visits) * self.child_priors / (\n 1 + self.child_number_visits)","def __cacula_agio(table):\n from m2py.misc.vectorize import column\n\n PV = table[0][-1]\n total = sum(column(table, 1))\n premium = total/PV - 1\n return round(premium, 2)","def uppermost(self):\r\n last = None\r\n replicable = self\r\n\r\n # Walk the parent tree until no parent\r\n try:\r\n while replicable:\r\n last, replicable = replicable, replicable.owner\r\n\r\n except AttributeError:\r\n pass\r\n\r\n return last"],"string":"[\n \"def first_principal_component(X):\\n guess = [1 for _ in X[0]]\\n unscaled_maximizer = maximize_batch(\\n partial(directional_variance, X),\\n partial(directional_variance_gradient, X),\\n guess)\\n return direction(unscaled_maximizer)\",\n \"def max_principal_components(self):\\n return self._max_principal_components\",\n \"def principal(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"principal\\\")\",\n \"def principal(self):\\n return Principal(self)\",\n \"def total_principal(self) -> Decimal:\\n return self._quantize(self.principal)\",\n \"def top_layer(self):\\n return self._top\",\n \"def cohighest_root(self):\\n return self.highest_root().associated_coroot()\",\n \"def top(self):\",\n \"def principal(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"principal\\\")\",\n \"def get_principal(self, principal_id, info=True):\",\n \"def principal(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"principal\\\")\",\n \"def principal(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"principal\\\")\",\n \"def principal(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"principal\\\")\",\n \"def principal(self):\\n s = [self.voigt[i] for i in range(6)]\\n\\n # calculate centers\\n cxy = (s[0] + s[1]) / 2\\n cyz = (s[1] + s[2]) / 2\\n czx = (s[2] + s[0]) / 2\\n\\n # calculate radii\\n rxy = ((s[0] - s[1])**2 + (2*s[3])**2)**(1/2) / 2\\n ryz = ((s[1] - s[2])**2 + (2*s[4])**2)**(1/2) / 2\\n rzx = ((s[2] - s[0])**2 + (2*s[5])**2)**(1/2) / 2\\n\\n return array([[cxy + rxy, cxy - rxy, rxy],\\n [cyz + ryz, cyz - ryz, ryz],\\n [czx + rzx, czx - rzx, rzx]])\",\n \"def top(self):\\n return self[0]\",\n \"def top(self):\\n # type: () -> float\\n return self._top\",\n \"def top(self):\\n return self.a[-1]\",\n \"def top(self) -> Face:\\n return self.bodies[0].faces[self._top_index]\",\n \"def principal(sigma):\\n vals, vecs = np.linalg.eigh(sigma)\\n vals = np.abs(vals)\\n order = vals.argsort()[::-1]\\n vecs = vecs[:, order]\\n vals = vals[order]\\n\\n func = mplstereonet.vector2plunge_bearing\\n vec_orientations = [func(*item) for item in vecs.T]\\n\\n \\\"\\\"\\\"\\n val1, val2, val3 = vals\\n print (val2-val3) / (val1 - val3)\\n print 'sigma1', val1 \\n print 'sigma2', val2\\n print 'sigma3', val3\\n \\\"\\\"\\\"\\n return vals, vec_orientations\",\n \"def null_coroot(self):\\n assert(self.cartan_type().is_affine())\\n coef = self.cartan_type().acheck()\\n return sum(coef[k]*self.simple_coroots()[k] for k in coef.keys())\",\n \"def top(self):\\n # if not empty\\n if not self.empty():\\n return self._data[0].get_value()[1].course\\n # if empty\\n return None\",\n \"def top(self):\\n return self.get_cards()[-1]\",\n \"def get_raw_principal(self, principal_id):\",\n \"def top(heap):\\n return heap[_root()]\",\n \"def get_pca_principal_component_images(self):\\n return self.get_pca_images()[2]\",\n \"def PrincipalComponents(mat,reverseOrder=1):\\n covMat = FormCorrelationMatrix(mat)\\n\\n eigenVals,eigenVects = numpy.linalg.eig(covMat)\\n try:\\n eigenVals = eigenVals.real\\n except:\\n pass\\n try:\\n eigenVects = eigenVects.real\\n except:\\n pass\\n\\n # and now sort:\\n ptOrder = numpy.argsort(eigenVals).tolist()\\n if reverseOrder:\\n ptOrder.reverse()\\n eigenVals = numpy.array([eigenVals[x] for x in ptOrder])\\n eigenVects = numpy.array([eigenVects[x] for x in ptOrder])\\n return eigenVals,eigenVects\",\n \"def finalize_top(self, top):\\n if not self.use_pr:\\n return top\\n\\n # Expose AXI interface to the top level, and then wrap the entire\\n # user design.\\n top.add_port('axil_clk', 'axil_clk', parent_sig=False, dir='in')\\n top.add_port('axil_rst_n', 'axil_clk', parent_sig=False, dir='in')\\n top.add_port('M_AXI_araddr', 'M_AXI_araddr', width=32, parent_sig=False, dir='in')\\n top.add_port('M_AXI_arready', 'M_AXI_arready', parent_sig=False, dir='out')\\n top.add_port('M_AXI_arvalid', 'M_AXI_arvalid', parent_sig=False, dir='in')\\n top.add_port('M_AXI_awaddr', 'M_AXI_awaddr', width=32, parent_sig=False, dir='in')\\n top.add_port('M_AXI_awready', 'M_AXI_awready', parent_sig=False, dir='out')\\n top.add_port('M_AXI_awvalid', 'M_AXI_awvalid', parent_sig=False, dir='in')\\n top.add_port('M_AXI_bready', 'M_AXI_bready', parent_sig=False, dir='in')\\n top.add_port('M_AXI_bresp', 'M_AXI_bresp', width=2, parent_sig=False, dir='out')\\n top.add_port('M_AXI_bvalid', 'M_AXI_bvalid', parent_sig=False, dir='out')\\n top.add_port('M_AXI_rdata', 'M_AXI_rdata', width=32, parent_sig=False, dir='out')\\n top.add_port('M_AXI_rready', 'M_AXI_rready', parent_sig=False, dir='in')\\n top.add_port('M_AXI_rresp', 'M_AXI_rresp', width=2, parent_sig=False, dir='out')\\n top.add_port('M_AXI_rvalid', 'M_AXI_rvalid', parent_sig=False, dir='out')\\n top.add_port('M_AXI_wdata', 'M_AXI_wdata', width=32, parent_sig=False, dir='in')\\n top.add_port('M_AXI_wready', 'M_AXI_wready', parent_sig=False, dir='out')\\n top.add_port('M_AXI_wstrb', 'M_AXI_wstrb', width=4, parent_sig=False, dir='in')\\n top.add_port('M_AXI_wvalid', 'M_AXI_wvalid', parent_sig=False, dir='in')\\n if self.enable_wishbone:\\n top.add_port('wbm_cyc_o', 'wbm_cyc_o', parent_sig=False, dir='in')\\n top.add_port('wbm_stb_o', 'wbm_stb_o', parent_sig=False, dir='in')\\n top.add_port('wbm_we_o ', 'wbm_we_o ', parent_sig=False, dir='in')\\n top.add_port('wbm_sel_o', 'wbm_sel_o', parent_sig=False, dir='in', width=4)\\n top.add_port('wbm_adr_o', 'wbm_adr_o', parent_sig=False, dir='in', width=32)\\n top.add_port('wbm_dat_o', 'wbm_dat_o', parent_sig=False, dir='in', width=32)\\n top.add_port('wbm_dat_i', 'wbm_dat_i', parent_sig=False, dir='out', width=32)\\n top.add_port('wbm_ack_i', 'wbm_ack_i', parent_sig=False, dir='out')\\n top.add_port('wb_clk_i', 'wb_clk_i', parent_sig=False, dir='in')\\n top.add_port('wb_rst_i', 'wb_rst_i', parent_sig=False, dir='in')\\n top.instantiate_child_ports()\\n # With PR, we're not going to be using this module as top. Instead, let's\\n # rename is `user_top` which will be instantiated within a high-level static top-level.\\n # The assumpion is that the static top-level is already routed and included in a project and need\\n # not be generated here.\\n top.name = 'user_top'\\n return top\",\n \"def _TopCLIElement(self):\\n if self.IsRoot():\\n return self\\n # pylint: disable=protected-access\\n return self._parent_group._TopCLIElement()\",\n \"def form_top_clipping_plane(fx: float, img_height: int) -> np.ndarray:\\n top_plane = np.array([0.0, fx, img_height / 2.0, 0.0])\\n top_plane /= np.linalg.norm(top_plane)\\n return top_plane\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def principal_component_analysis(X, num_components):\\n components = []\\n for _ in range(num_components):\\n component = first_principal_component(X)\\n components.append(component)\\n X = remove_projection(X, component)\\n \\n return components\",\n \"def first_top_bottom():\\n identity = NB_CARDS * np.identity(NB_CARDS)\\n # First outcome, the deck isn't changed\\n shuffled_deck_1 = deepcopy(identity)\\n # Second outcome, the first card is at the bottom and every other cards goes\\n # up\\n shuffled_deck_2 = deepcopy(identity)\\n for i in range(NB_CARDS-1):\\n shuffled_deck_2[i] = deepcopy(identity[i+1])\\n shuffled_deck_2[NB_CARDS-1] = deepcopy(identity[0])\\n # Now we have to combine the two outcome with probability half\\n return (shuffled_deck_1 + shuffled_deck_2)/2\",\n \"def top(self):\\n return self._top\",\n \"def top(self):\\n return self._top\",\n \"def get_principal_data( user_email ):\\n \\n try:\\n sp = models.SyndicatePrincipal.objects.get( principal_id=user_email )\\n return sp\\n except ObjectDoesNotExist:\\n logger.error(\\\"No SyndicatePrincipal record for %s\\\" % user_email)\\n return None\",\n \"def getContainerTop(self):\\n return self.containerTop\",\n \"def calculate_principal_components(embedding, num_components=3):\\n embedding -= tf.reduce_mean(embedding, axis=0, keep_dims=True)\\n sigma = tf.matmul(embedding, embedding, transpose_a=True)\\n _, u, _ = tf.svd(sigma)\\n return u[:, :num_components]\",\n \"def get_topmost_card(self):\\n if len(self.cards) > 0:\\n return self.cards[-1]\\n else:\\n return None\",\n \"def top(self) -> Optional[FloatObject]:\\n return self.get(\\\"/Top\\\", None)\",\n \"def principal(self):\\n\\n\\n sw = self.telofase()\\n if sw is False:\\n exc, var = self.excentricidad()\\n if 0.35 < exc < 0.5:\\n self.guardar_imagen('anafase')\\n return 3\\n elif 0.5 <= exc < 0.65:\\n self.guardar_imagen('metafase')\\n return 2\\n elif exc >= 0.65:\\n self.guardar_imagen('profase')\\n return 1\\n else:\\n self.guardar_imagen('sin_clasificar')\\n return 0\\n else:\\n return 4\",\n \"def top(self):\\r\\n return self.topele\",\n \"def top(self) -> int:\\n return self.topEle\",\n \"def top( self , i , j ):\\n return self._get_top( i , j )\",\n \"def top(self) -> int:\\n return self.topvalue\",\n \"def PrincipalComponents(mat, reverseOrder=1):\\n covMat = FormCorrelationMatrix(mat)\\n\\n eigenVals, eigenVects = numpy.linalg.eig(covMat)\\n # The 'real' component, if it exists as its own attribute\\n eigenVals = getattr(eigenVals, \\\"real\\\", eigenVals)\\n eigenVects = getattr(eigenVects, \\\"real\\\", eigenVects)\\n\\n # and now sort:\\n ptOrder = numpy.argsort(eigenVals).tolist()\\n if reverseOrder:\\n ptOrder.reverse()\\n eigenVals = numpy.array([eigenVals[x] for x in ptOrder])\\n eigenVects = numpy.array([eigenVects[x] for x in ptOrder])\\n return eigenVals, eigenVects\",\n \"def evalTopContactDisp(length: float,\\n topcurve_radius: float,\\n topJointAngle: float, \\n topOrientationDF: float):\\n halfJointAngle = topJointAngle/2\\n return np.array((\\n topcurve_radius*sin(halfJointAngle)*sin(topOrientationDF),\\n -topcurve_radius*sin(halfJointAngle)*cos(topOrientationDF),\\n topcurve_radius*cos(halfJointAngle) + length/2 - topcurve_radius\\n ))\",\n \"def principal_axis(alpha_carbons):\\n # alpha carbons coordinates as a numpy array\\n coord = numpy.array(alpha_carbons, float)\\n\\n # get geometrical center\\n center = numpy.mean(coord, 0)\\n coord = coord - center\\n\\n # create inertia matrix and extract eigenvectors and values\\n inertia = numpy.dot(coord.transpose(), coord)\\n e_values, e_vectors = numpy.linalg.eig(inertia)\\n\\n # sort eigenvalues\\n order = numpy.argsort(e_values)\\n\\n # axis1 is the principal axis with the greatest eigenvalue\\n _, _, axis1 = e_vectors[:, order].transpose()\\n\\n axis_direction = axis1 / numpy.linalg.norm(axis1)\\n\\n return center, axis_direction\",\n \"def principal_po_box(self, principal_po_box):\\n\\n self._principal_po_box = principal_po_box\",\n \"def top(self) -> float:\\n points = self.get_adjusted_points()\\n y_points = [point[1] for point in points]\\n return max(y_points)\",\n \"def top_draw(self):\\n top_card = self.cards.pop(0)\\n return top_card\",\n \"def top_right(self, obj):\\n return self.phy2abs.top_right(obj)\",\n \"def top_authors(cursor):\\n top_auth = 'No authors found.'\\n try:\\n cursor.execute(\\\"\\\"\\\"\\n select name, hits\\n from authors, views_by_id as views_by_id\\n where id = author\\n group by name, hits\\n order by hits desc\\\"\\\"\\\")\\n\\n authors = cursor.fetchall()\\n # If no authors were found, return\\n if len(authors) <= 0:\\n return top_auth\\n\\n except psycopg2.Error as e:\\n print('Fetching authors by popularity: \\\\r\\\\n{}'.format(e.pgerror))\\n\\n # If the query returns any authors, return the results.\\n else:\\n top_auth = 'Top authors by article views: \\\\r\\\\n'\\n for auth in authors:\\n top_auth += ' {} - {} views\\\\r\\\\n'.format(auth[0], auth[1])\\n return top_auth\",\n \"def do_top(cs, args):\\n\\n if args.pid:\\n # List container single ps id top result\\n output = cs.containers.top(args.container, ' '.join(args.pid))\\n else:\\n # List container all processes top result\\n output = cs.containers.top(args.container)\\n for titles in output['Titles']:\\n print(\\\"%-20s\\\") % titles,\\n if output['Processes']:\\n for process in output['Processes']:\\n print(\\\"\\\")\\n for info in process:\\n print(\\\"%-20s\\\") % info,\\n else:\\n print(\\\"\\\")\",\n \"def __top_Algs_ ( self ) :\\n _algs = self.TopAlg\\n\\n def _alg_name_ ( _n ):\\n\\n _p = _n.rfind('/')\\n if 0 > _p : return _n\\n return _n[_p:]\\n\\n def _pyAlg ( _n ) :\\n for _a in self.pyalgorithms :\\n if _n == _a.name() : return _a\\n return None \\n \\n algs = [] \\n for _a in _algs :\\n # get the proper name \\n _n = _alg_name_ ( _a )\\n # check if it is pyalgorithm:\\n _pa = _pyAlg ( _n )\\n if _pa :\\n algs += [ _pa ]\\n else :\\n _alg = self.algorithm ( _a , True )\\n algs += [ _alg ]\\n \\n return algs\",\n \"def __top_Algs_ ( self ) :\\n _algs = self.TopAlg\\n\\n def _alg_name_ ( _n ):\\n\\n _p = _n.rfind('/')\\n if 0 > _p : return _n\\n return _n[_p:]\\n\\n def _pyAlg ( _n ) :\\n for _a in self.pyalgorithms :\\n if _n == _a.name() : return _a\\n return None \\n \\n algs = [] \\n for _a in _algs :\\n # get the proper name \\n _n = _alg_name_ ( _a )\\n # check if it is pyalgorithm:\\n _pa = _pyAlg ( _n )\\n if _pa :\\n algs += [ _pa ]\\n else :\\n _alg = self.algorithm ( _a , True )\\n algs += [ _alg ]\\n \\n return algs\",\n \"def set_principal_components(principal_components):\\n View.__principal_components = principal_components\",\n \"def get_top_solution_score(self):\\n top_solution_score = self.top_k_solution_scores[0] if len(self.top_k_solution_scores) else None\\n return top_solution_score\",\n \"def PCA(X, k):\\n cov = np.matmul(np.matrix.transpose(X), X)\\n w, v = np.linalg.eig(cov)\\n k_largest = np.argsort(w)[::-1][:k]\\n v = np.matrix.transpose(v)\\n U = v[k_largest]\\n S = w[k_largest]\\n return U, S\",\n \"def cf_profile_ac(self):\\n return self.gen_profile() / self.system_capacity_ac()\",\n \"def top(self):\\n\\n return self._top\",\n \"def associated_coroot(self):\",\n \"def interest_to_principle(self) -> float:\\n return float(round(self.total_interest / self.total_principal * 100, 1))\",\n \"def principal_order_ideal(self, x):\\n return self.order_ideal([x])\",\n \"def midtop(self):\\n return (self.centerx, self.top)\",\n \"def circle_of_least_confusion(self):\\n ff=beam_field() \\n ff.rectangular_grid(1,2000,self.entrance_pupil)\\n ff.propagate(self.surfaces)\\n def f(x):\\n pl=ff.project_onto_plane(x)\\n return max(pl[:,1])\\n \\n # m=self.marginal_ray\\n if hasattr(self, 'start'):\\n start=self.start\\n else:\\n# start=(m.Q_p[-1,0,2]-m.Q_p[-2,0,2])/2\\n start=(self.surfaces[-1].pos()-self.surfaces[-2].pos())/2\\n #print(start)\\n res=minimize(f,(start), method='Nelder-Mead')\\n self.start=res.final_simplex[0][0,0]\\n \\n return res.final_simplex[0][0,0],res.final_simplex[1][0]\",\n \"def top(self, value):\\n\\n pass\",\n \"def get_principal_title_task():\\n interaction = zope.security.management.getInteraction()\\n return interaction.participations[0].principal.title\",\n \"def ft_syndicate_principal():\\n print \\\"generating key pair\\\"\\n pubkey_pem, privkey_pem = api.generate_key_pair( 4096 )\\n \\n user_email = \\\"fakeuser@opencloud.us\\\"\\n \\n print \\\"saving principal\\\"\\n put_principal_data( user_email, \\\"asdf\\\", pubkey_pem, privkey_pem )\\n \\n print \\\"fetching principal private key\\\"\\n saved_privkey_pem = get_principal_pkey( user_email, \\\"asdf\\\" )\\n \\n assert saved_privkey_pem is not None, \\\"Could not fetch saved private key\\\"\\n assert saved_privkey_pem == privkey_pem, \\\"Saved private key does not match actual private key\\\"\\n \\n print \\\"delete principal\\\"\\n \\n delete_principal_data( user_email )\\n \\n print \\\"make sure its deleted...\\\"\\n \\n saved_privkey_pem = get_principal_pkey( user_email, \\\"asdf\\\" )\\n \\n assert saved_privkey_pem is None, \\\"Principal key not deleted\\\"\",\n \"def top(self):\\n return self.q1.return_top()\",\n \"def printTopAuthors():\\n query = \\\"\\\"\\\"\\n SELECT author_article_popularity_view.author,\\n SUM(author_article_popularity_view.views) AS total_views\\n FROM author_article_popularity_view\\n GROUP BY author_article_popularity_view.author\\n ORDER BY total_views DESC;\\n \\\"\\\"\\\"\\n cursor = connection.cursor()\\n cursor.execute(query)\\n results = cursor.fetchall()\\n print(\\\"\\\\nTop authors of all time: \\\")\\n for i, result in enumerate(results):\\n print(\\\"{}. {} - {:,} views\\\".format(i + 1, result[0], result[1]))\",\n \"def top(self):\\n print(self.arr[-1])\",\n \"def top(self):\\n return self.arr[-1]\",\n \"def getPrincipal(id=None):\\n if id is None:\\n interaction = queryInteraction()\\n\\n if interaction is not None:\\n for participation in interaction.participations:\\n if participation.principal is not None:\\n return participation.principal\\n else:\\n try:\\n return getUtility(IAuthentication).getPrincipal(id)\\n except PrincipalLookupError:\\n return None\",\n \"def computeTopSurfaceIndices(top):\\n itop = np.array([(top[i,j], j, i) \\\\\\n for i in range(top.shape[0]) \\\\\\n for j in range(top.shape[1]) \\\\\\n if top[i,j] >= 0])\\n return itop\",\n \"def h_P(self, z0):\\n # Get the governing variables\\n (B, N, u_slip, u_inf) = self.get_variables(z0, 0.)\\n \\n # Compute U_N\\n U_N = u_slip / (B * N)**(1./4.)\\n \\n # Compute the correlation equation\\n return 5.2 * np.exp(-(U_N - 1.8)**2 / 10.24) * (B / N**3)**(1./4.)\",\n \"def top_of_climb_index(self):\\n return self.altitudes.argmax()\",\n \"def top(self):\\n \\n assert not self.empty()\\n return self._s[-1]\",\n \"def null_root(self):\\n if self.cartan_type().is_affine():\\n coef = self.cartan_type().a()\\n return sum(coef[k]*self.simple_roots()[k] for k in coef.keys())\",\n \"def test_top_clipping_plane() -> None:\\n fx_px = 10.0\\n height_px = 45\\n pinhole_camera = _create_pinhole_camera(\\n fx_px=fx_px,\\n fy_px=0,\\n cx_px=0,\\n cy_px=0,\\n height_px=height_px,\\n width_px=1000,\\n cam_name=\\\"ring_front_center\\\",\\n )\\n\\n top_plane = pinhole_camera.top_clipping_plane\\n\\n width_px = 1000.0\\n points_xyz: NDArrayFloat = np.array(\\n [\\n [0, 0, 0],\\n [-width_px / 2, -height_px / 2, fx_px],\\n [width_px / 2, -height_px / 2, fx_px],\\n ]\\n )\\n a, b, c, d = _fit_plane_to_point_cloud(points_xyz)\\n top_plane_expected: NDArrayFloat = np.array([a, b, c, d])\\n\\n # enforce that plane normal points into the frustum\\n if top_plane_expected[1] < 0:\\n # y-coord of normal should point in pos y-axis dir(down) on top-clipping plane\\n top_plane_expected *= -1\\n\\n assert top_plane_expected[1] > 0 and top_plane_expected[2] > 0\\n assert np.allclose(top_plane, top_plane_expected)\",\n \"def user_principal_name(self):\\n if \\\"userPrincipalName\\\" in self._prop_dict:\\n return self._prop_dict[\\\"userPrincipalName\\\"]\\n else:\\n return None\",\n \"def user_principal_name(self):\\n if \\\"userPrincipalName\\\" in self._prop_dict:\\n return self._prop_dict[\\\"userPrincipalName\\\"]\\n else:\\n return None\",\n \"def principal_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def principal_id(self) -> str:\\n return pulumi.get(self, \\\"principal_id\\\")\",\n \"def get_top_role(self, default = None):\\n top_role = default\\n \\n role_ids = self.role_ids\\n if (role_ids is not None):\\n role_found = False\\n \\n for role_id in role_ids:\\n try:\\n role = ROLES[role_id]\\n except KeyError:\\n continue\\n \\n if role_found:\\n if role > top_role:\\n top_role = role\\n else:\\n top_role = role\\n role_found = True\\n \\n # If non of the roles is cached, create a partial role from the highest id.\\n if not role_found:\\n top_role = create_partial_role_from_id(role_ids[-1])\\n \\n return top_role\",\n \"def topolar(img, order=1):\\n '''From Stackreg'''\\n # max_radius is the length of the diagonal\\n # from a corner to the mid-point of img.\\n max_radius = 0.5*np.linalg.norm( img.shape )\\n\\n def transform(coords):\\n # Put coord[1] in the interval, [-pi, pi]\\n theta = 2*np.pi*coords[1] / (img.shape[1] - 1.)\\n\\n # Then map it to the interval [0, max_radius].\\n radius = max_radius * coords[0] / img.shape[0]\\n\\n i = 0.5*img.shape[0] - radius*np.sin(theta)\\n j = radius*np.cos(theta) + 0.5*img.shape[1]\\n return i,j\\n\\n polar = ndimage.interpolation.geometric_transform(img, transform, order=order)\\n\\n rads = max_radius * np.linspace(0,1,img.shape[0])\\n angs = np.linspace(0, 2*np.pi, img.shape[1])\\n\\n return polar, (rads, angs)\",\n \"def top_right(self, obj):\\n if (obj.__class__.__name__ == 'PhysicalObject') or (issubclass(obj.__class__, laygo2.object.PhysicalObject)):\\n return self.top_right(obj.bbox)\\n else:\\n _i = self.bbox(obj)\\n return _i[1]\",\n \"def top(self):\\n if self.is_empty():\\n return None\\n return self._head.value\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def child_U(self):\\n return math.sqrt(self.number_visits) * self.child_priors / (\\n 1 + self.child_number_visits)\",\n \"def __cacula_agio(table):\\n from m2py.misc.vectorize import column\\n\\n PV = table[0][-1]\\n total = sum(column(table, 1))\\n premium = total/PV - 1\\n return round(premium, 2)\",\n \"def uppermost(self):\\r\\n last = None\\r\\n replicable = self\\r\\n\\r\\n # Walk the parent tree until no parent\\r\\n try:\\r\\n while replicable:\\r\\n last, replicable = replicable, replicable.owner\\r\\n\\r\\n except AttributeError:\\r\\n pass\\r\\n\\r\\n return last\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6089231","0.5806278","0.5718602","0.5631194","0.555383","0.5522287","0.55130035","0.5443612","0.54245883","0.53624135","0.53293145","0.53293145","0.53293145","0.5287979","0.5231421","0.5225504","0.5204582","0.51921564","0.5179744","0.5143214","0.511822","0.5083305","0.5067763","0.506667","0.50566113","0.5052028","0.50361216","0.50114167","0.49950203","0.4994112","0.4994112","0.49883506","0.4984348","0.49585915","0.49585915","0.49504474","0.49327832","0.49322528","0.4928815","0.49024197","0.4896768","0.48959225","0.48776266","0.48753077","0.48639128","0.48574886","0.48414424","0.48399323","0.48377013","0.48213878","0.4818058","0.48026195","0.4799693","0.47963443","0.4794447","0.4794447","0.4788333","0.47882965","0.47859904","0.47707963","0.47684604","0.4767543","0.47643876","0.4758921","0.4756294","0.47392955","0.47368562","0.4734901","0.47323737","0.47295356","0.47248477","0.47172362","0.47164786","0.4715423","0.47110933","0.46991235","0.4691565","0.46898422","0.46775195","0.46753922","0.46730298","0.46730298","0.4669066","0.46624336","0.46624336","0.46624336","0.46624336","0.46624336","0.46624336","0.46624336","0.46624336","0.46624336","0.46596187","0.4657368","0.4654394","0.465425","0.46536714","0.46536714","0.46487322","0.4645238","0.46367055"],"string":"[\n \"0.6089231\",\n \"0.5806278\",\n \"0.5718602\",\n \"0.5631194\",\n \"0.555383\",\n \"0.5522287\",\n \"0.55130035\",\n \"0.5443612\",\n \"0.54245883\",\n \"0.53624135\",\n \"0.53293145\",\n \"0.53293145\",\n \"0.53293145\",\n \"0.5287979\",\n \"0.5231421\",\n \"0.5225504\",\n \"0.5204582\",\n \"0.51921564\",\n \"0.5179744\",\n \"0.5143214\",\n \"0.511822\",\n \"0.5083305\",\n \"0.5067763\",\n \"0.506667\",\n \"0.50566113\",\n \"0.5052028\",\n \"0.50361216\",\n \"0.50114167\",\n \"0.49950203\",\n \"0.4994112\",\n \"0.4994112\",\n \"0.49883506\",\n \"0.4984348\",\n \"0.49585915\",\n \"0.49585915\",\n \"0.49504474\",\n \"0.49327832\",\n \"0.49322528\",\n \"0.4928815\",\n \"0.49024197\",\n \"0.4896768\",\n \"0.48959225\",\n \"0.48776266\",\n \"0.48753077\",\n \"0.48639128\",\n \"0.48574886\",\n \"0.48414424\",\n \"0.48399323\",\n \"0.48377013\",\n \"0.48213878\",\n \"0.4818058\",\n \"0.48026195\",\n \"0.4799693\",\n \"0.47963443\",\n \"0.4794447\",\n \"0.4794447\",\n \"0.4788333\",\n \"0.47882965\",\n \"0.47859904\",\n \"0.47707963\",\n \"0.47684604\",\n \"0.4767543\",\n \"0.47643876\",\n \"0.4758921\",\n \"0.4756294\",\n \"0.47392955\",\n \"0.47368562\",\n \"0.4734901\",\n \"0.47323737\",\n \"0.47295356\",\n \"0.47248477\",\n \"0.47172362\",\n \"0.47164786\",\n \"0.4715423\",\n \"0.47110933\",\n \"0.46991235\",\n \"0.4691565\",\n \"0.46898422\",\n \"0.46775195\",\n \"0.46753922\",\n \"0.46730298\",\n \"0.46730298\",\n \"0.4669066\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46624336\",\n \"0.46596187\",\n \"0.4657368\",\n \"0.4654394\",\n \"0.465425\",\n \"0.46536714\",\n \"0.46536714\",\n \"0.46487322\",\n \"0.4645238\",\n \"0.46367055\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10797,"cells":{"query":{"kind":"string","value":"Converts a pandas series of string to numeric ratios."},"document":{"kind":"string","value":"def toratio(s):\n\tfrom operator import truediv\n\treturn s.apply(lambda x: truediv(*[int(y) for y in x.split('/')]))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def convert_to_float(series):\n series = series.str[:-4].str.replace('.', '').str.replace(',', '.').astype(float)\n return series","def convert(srat):\n try:\n return float(srat)\n except ValueError:\n num, denom = srat.split('/')\n return float(num) / float(denom)","def convertRate(row):\n if pd.isnull(row):\n return 1.0\n elif ':' in str(row):\n rows = row.split(':')\n return 1.0 - float(rows[1]) / float(rows[0])\n else:\n return float(row)","def get_freq(string:str) -> float:\n import numpy\n try:\n freq = float(string.replace(\"%\", \"\")) / 100\n except AttributeError as e:\n # if string is np.nan\n freq = numpy.nan\n return freq","def to_numeric(self, *args, **kwargs): # noqa: PR02\n return SeriesDefault.register(pandas.to_numeric)(self, *args, **kwargs)","def _downcast_numeric(series, allow_categorical=allow_categorical):\r\n if pd.api.types.is_sparse(series.dtype) is True:\r\n return series\r\n elif pd.api.types.is_numeric_dtype(series.dtype) is False:\r\n if pd.api.types.is_datetime64_any_dtype(series.dtype):\r\n return series\r\n else:\r\n if allow_categorical:\r\n return series\r\n else:\r\n codes, uniques = series.factorize()\r\n series = pd.Series(data=codes, index=series.index)\r\n series = _downcast_numeric(series)\r\n return series\r\n else:\r\n series = pd.to_numeric(series, downcast=\"integer\")\r\n if pd.api.types.is_float_dtype(series.dtype):\r\n series = series.astype(float_dtype)\r\n return series","def normalize_series(series):\n return (series - series.mean()) / (series.max() - series.min())","def convert_series(self, column: str, dtype: str) -> TYPE_ROW:\n\n series = self.df[column]\n\n if dtype != \"float\":\n series = series.fillna(NULL)\n\n values = self.force_dtype(series, dtype)\n\n return values","def _to_float(self, s: str) -> float:\n return int(s[:-1]) / 1e9 if s.endswith('n') else float(s[:-1])","def guess_series(input_string):\n float_finder = re.compile(\n r\"(nan|[-+]?inf|[-+]?[0-9]*\\.?[0-9]+(?:e[-+]?[0-9]+)?)\", re.I\n )\n return [\n i\n for i in [\n _convert_to_float(j)\n for j in float_finder.findall(input_string)\n # Remove entires we couldn't convert to a sensible value.\n ]\n if i is not None\n ]","def convertRate(row):\n if row == 'null':\n return 1.0\n elif ':' in row:\n rows = row.split(':')\n return 1.0 - float(rows[1])/float(rows[0])\n else:\n return float(row)","def find_non_numeric(pd_series):\n\n numeric = []\n for elem in pd_series:\n if not elem.isdigit():\n numeric.append(np.nan)\n else:\n numeric.append(int(elem))\n\n return numeric","def _parseNumbers(s):\n ss = utils.unclump(s)\n\n m3 = re.match('^\\d+$', ss)\n if m3 is not None:\n return decimal.Decimal(round(float(ss), 2))\n\n m1 = re.match(r'(\\d+)\\s+(\\d)/(\\d)', ss)\n if m1 is not None:\n num = int(m1.group(1)) + (float(m1.group(2)) / float(m1.group(3)))\n return decimal.Decimal(str(round(num, 2)))\n\n m2 = re.match(r'^(\\d)/(\\d)$', ss)\n if m2 is not None:\n num = float(m2.group(1)) / float(m2.group(2))\n return decimal.Decimal(str(round(num, 2)))\n\n return None","def to_numeric(s):\n\n try:\n s = float(s)\n except Exception as e:\n log.debug('Caught `{e!s}` trying to cast {s!r} to numeric'.format(**locals()))\n pass\n return s","def _convert_val_to_numeric(val, cast_type=float, regex_exp='[^0-9.-()]'):\n multiplier = 1\n\n try:\n stripped = regex.sub(regex_exp, '', val)\n if len(stripped) >= 2 and stripped[0] == '(' and stripped[-1] == ')':\n multiplier = multiplier*-1\n ans = cast_type(stripped[1:-1])\n else:\n ans = cast_type(regex.sub(regex_exp, '', val))\n ans = ans * multiplier\n except ValueError:\n ans = pd.NA\n print(f\"ERROR READING VALUE:\\\"{val}\\\"\\t Filling with <NA>\")\n except TypeError:\n if type(val) in [float, int, cast_type]:\n ans = cast_type(val)\n else:\n print(f\"ERROR READING VALUE:\\\"{val}\\\"\\t Filling with <NA>\")\n ans = pd.NA\n return ans","def str_to_num(s):\n\n method = {\n \"float\": string.atof,\n \"int\": string.atoi\n }\n\n if not type(s) is StringType:\n return 0\n\n if \".\" in s:\n return method[\"float\"](s)\n else:\n return method[\"int\"](s, 10)","def ratio(self, string='') -> float:\n try:\n return(self.find(string)/self.total)\n except Exception as error:\n print(f\"Error: self.ratio({string}) -> {error}\")","def _tokens_to_ratios(self, tokens):\n return [token * 0.01 for token in tokens]","def str2num(s):\n if s.is_constant() and (s.is_float() or s.is_integer()):\n return True, s.compute_value()\n elif s.functor == \".\":\n values = term2list(s)\n numvalues = []\n for value in values:\n if isinstance(value, int) or isinstance(value, float):\n numvalues.append(value)\n else:\n return None, None\n return True, tuple(numvalues)\n else:\n return None, None","def clarity_conversion(string):\n if (string == 'I1'):\n return 0.125\n if (string == 'SI2'):\n return 0.25\n if (string == 'SI1'):\n return 0.375\n if (string == 'VS2'):\n return 0.5\n if (string == 'VS1'):\n return 0.625\n if (string == 'VVS2'):\n return 0.75\n if (string == 'VVS1'):\n return 0.875\n if (string == 'IF'):\n return 1","def to_real_series(self, data: pd.Series) -> pd.Series:\n ...","def get_metric(self, data_row: pd.Series) -> float:","def toNumeric(self):\n for column in list(self.data.columns):\n if not is_numeric_dtype(self.data[column]):\n values = list(sorted(self.data[column].unique()))\n indices = [index for index, value in enumerate(values)]\n self.data[column] = self.data[column].replace(\n to_replace=values, value=indices)","def _convert_int(self) -> pd.Series:\n\n if self.requires_nan:\n dtype = \"float\"\n else:\n dtype = \"int\"\n\n return self._convert(dtype=dtype)","def string_to_number(s):\n\n if type(s).__name__==\"str\":\n s = s.strip()\n if s ==\"-\":\n s = 0\n else:\n s = s.replace(\",\",\"\").replace(\"$\",\"\")\n if s.find(\"(\")>=0 and s.find(\")\")>=0:\n s = s.replace(\"(\",\"-\").replace(\")\",\"\")\n return float(s)","def float_series() -> pd.Series:\n series = pd.Series([(n/1000) for n in range(1001)])\n return series","def normalise_series(to_normalise: pd.Series) -> pd.Series:\n \n # return (to_normalise - to_normalise.mean()) / to_normalise.std() # 0 mean and unit standard deviation\n return to_normalise / to_normalise.std() # positive and unit standard deviation","def missing_values_ratio(series: TimeSeries) -> float:\n\n return series.pd_dataframe().isnull().sum().mean() / len(series)","def evaluate(self, string):\n return round(eval(string), 3)","def to_float(s):\n try:\n return float(s)\n except ValueError:\n return np.nan","def find_numerical(self, df):\n # categorical = [key for key in df.keys() if df.dtypes[key] == np.dtype('O')]\n numeric = [key for key in df.keys() if df.dtypes[key] != np.dtype('O')]\n # correct naive expectations\n actual_categoric = ['MSSubClass']\n numeric = list(set(numeric) - set(actual_categoric))\n return numeric","def find_numerical(self, df):\n # categorical = [key for key in df.keys() if df.dtypes[key] == np.dtype('O')]\n numeric = [key for key in df.keys() if df.dtypes[key] != np.dtype('O')]\n # correct naive expectations\n actual_categoric = ['MSSubClass']\n numeric = list(set(numeric) - set(actual_categoric))\n return numeric","def coerce_strings(df, col):\r\n for i,j in enumerate(df[col]):\r\n if type(j) == str:\r\n j = float(j.replace(',', ''))\r\n df[col].iloc[i] = j\r\n\r\n return df","def to_digit(s: str) -> Union[float, str, int]:\n out = s.strip()\n f_twin = r'\\d+[,.]\\d{2,} {0,}- {0,}\\d+[.,]\\d{2,}'\n f_rank = r'\\d/10'\n f_score = r'[ ]{0,}\\d+[ ]{0,}'\n f_date = r'\\d\\d\\.\\d\\d\\.\\d\\d\\d\\d'\n f_main = r'(-?\\d*\\,?\\d+\\.?\\d*)[%BM]?'\n\n if isinstance(s, str) and re.findall(f_date, s) == [] and len(s) < 50 and s != '-':\n try: # begin from big one, because bigs consist small re\n\n if re.search(f_main, s) is not None:\n res = re.search(f_main, s.strip()).groups()[0]\n if res == '-':\n return '-'\n k = 1\n mul = 1\n after_point = res.split('.')\n if len(after_point) == 2:\n k = 10 ** len(after_point[1].replace(',', ''))\n\n mul = 1000000000 if s.find('B') > 0 else mul # found Billions\n mul = 1000000 if s.find('M') > 0 else mul # found Millions\n mul = 0.01 if s.find('%') > 0 else mul # found Percent format\n mul = mul * -1 if s.find(')') > 0 else mul # financial format to show minus : -192.34 = (192.34)\n\n return round(float(res.replace('.', '').replace(',', '')), 2) * mul / k if k > 1 else \\\n int(res.replace('.', '').replace(',', '')) * mul\n\n if len(re.findall(f_twin, s)) > 0: # format range xxx.xx - xxx.xx\n return float(re.findall(f_twin, s)[0]\n .replace(' ', '')\n .split('-')[0]\n .replace(',', '')\n .replace('.', '')) / 100\n\n if len(re.findall(f_rank, s)) > 0: # format score like 9/10 -> 9\n return int(re.findall(f_rank, s)[0].split('/')[0])\n\n if len(re.findall(f_score, s)) > 0: # format one digit score like ' 5 ' -> 5\n return int(re.findall(f_score, s)[0].replace(' ', ''))\n\n except Exception as e:\n\n logging.error(f\"Error in to_digit(). Input {s}, Out \")\n return out","def to_numerical(table, column_name):\n def replace(entry):\n return float(entry)\n assert (isinstance(table, Table)), \"Input not a supported type.\"\n column = table.apply(replace, column_name)\n return table.append_column(column_name, column)","def parse(string):\n posslash = string.find('/')\n if posslash < 0:\n return Rational(int(string), 1)\n else:\n strs = string.split('/')\n return Rational(int(strs[0].strip()), int(strs[1].strip()))","def percent_rank(\n series: Iterable[Any], na_last: str = \"keep\"\n) -> Iterable[float]:\n # Without this:\n # pandas 1.2.0: ValueError: Transform function failed\n if len(series) == 0:\n dtype = getattr(series, \"dtype\", None)\n return Array(series, dtype=dtype) # make a copy\n\n ranking = _rank(series, na_last, \"min\", True)\n minrank = ranking.min()\n maxrank = ranking.max()\n ret = ranking.transform(lambda r: (r - minrank) / (maxrank - minrank))\n ret[ranking.isna()] = NA\n return ret","def inspect_dtype_object(self, column: str) -> str:\n\n series = self.df[column].dropna()\n\n # check for bool\n try:\n conv = pd.to_numeric(series)\n return self.inspect_dtype(conv)\n except ValueError:\n pass\n\n # check for mixed dtypes\n dtypes = {type(x) for x in series}\n if len(dtypes) > 1:\n raise TypeError(\"Column `{}` has mixed dtypes: {}. Currently, \"\n \"this is not supported.\"\n .format(column, dtypes))\n\n # check for string\n if isinstance(series[0], str):\n return \"str\"\n\n # raise if unsupported dtype is encountered\n raise TypeError(\"Column `{}` has dtype `{}` which is currently \"\n \"not supported.\"\n .format(column, type(series[0])))","def compare_strings(string1: str, string2: str) -> float:\n return SequenceMatcher(None, string1, string2).ratio()","def generate(data: pd.DataFrame) -> np.ndarray:\n # TODO tests\n return data.apply(pd.to_numeric, errors='coerce')","def from_str(klass, s):\n # Special cases\n if s == \"nan\" :\n return RatTerm(RatNum(1, 0), 1)\n elif s == \"0\" :\n return RatTerm(RatNum(0, 1), 1)\n elif s == \"x\" :\n return RatTerm(RatNum(1, 1), 1)\n elif s == \"-x\" :\n return RatTerm(RatNum(-1, 1), 1)\n \n # Exponent\n if \"^\" in s :\n expo = int(s.split(\"^\")[1])\n else :\n expo = 0\n \n # Rational coefficient \n co = s.split(\"*\")[0]\n if \"/\" in co :\n nom, sep, denom = s.partition(\"/\")\n nom = int(nom)\n denom = int(denom.split(\"*\")[0])\n # coefficient = 1\n elif s.startswith(\"x\") :\n nom = 1\n denom = 1\n # coefficient = -1\n elif s.startswith(\"-x\") :\n nom = -1\n denom = 1\n else :\n nom = int(s.split(\"*\")[0])\n denom = 1\n \n return RatTerm(RatNum(nom, denom), expo)","def loss_ratio(df, column, missing_indicator=0):\r\n \r\n # if np.nan is passed\r\n if np.isnan(missing_indicator):\r\n ratio = float(len(df[df[column].isnull()]))/len(df)\r\n else:\r\n ratio = float(len(df[df[column]==missing_indicator]))/len(df)\r\n \r\n return ratio","def to_number(s):\n ret = s\n try:\n ret = float(s)\n except ValueError:\n ret = ret.strip('\\'').strip()\n return ret\n\n try:\n ret = int(s)\n except ValueError:\n pass\n return ret","def to_numeric_and_downcast_data(df: pd.DataFrame):\n fcols = df.select_dtypes('float').columns\n \n icols = df.select_dtypes('integer').columns\n\n df[fcols] = df[fcols].apply(pd.to_numeric, downcast='float')\n \n df[icols] = df[icols].apply(pd.to_numeric, downcast='integer')\n\n return df","def convert_dollars(df,col_name):\n df[col_name] = df[col_name].replace('[^.0-9]','',regex=True).astype(float)\n return df","def extractSI(s):\n\n # If this is representing a range, just return it as is.\n if \"[\" in s:\n return (s, None)\n\n types = {\"T\": \"Time\", \"O\": \"Rate\", \"A\": \"Rate\", \"s\": \"Seconds\", \"%\": \"Percentage\"}\n du = s.split()\n # Preserve integers as such, so that columns like \"Threads\" generate an X axis \"1 2 3\",\n # rather than \"1.0 2.0 3.0\"\n num = float(du[0]) if \".\" in du[0] else int(du[0])\n units = du[1] if len(du) == 2 else \" \"\n if s[-1] == \" \":\n units = units + \" \"\n\n # http://physics.nist.gov/cuu/Units/prefixes.html\n factor = {\n \"Y\": 1e24,\n \"Z\": 1e21,\n \"E\": 1e18,\n \"P\": 1e15,\n \"T\": 1e12,\n \"G\": 1e9,\n \"M\": 1e6,\n \"k\": 1e3,\n \" \": 1,\n \"m\": -1e3, # Yes, I do mean that, see below for the explanation.\n \"u\": -1e6,\n \"n\": -1e9,\n \"p\": -1e12,\n \"f\": -1e15,\n \"a\": -1e18,\n \"z\": -1e21,\n \"y\": -1e24,\n }[units[0] if len(units) == 2 else \" \"]\n # print (\"units = '\" + units + \"'\" + \" factor=\" + str(factor))\n\n # Minor trickery here is an attempt to preserve accuracy by using a single divide,\n # rather than multiplying by 1/x, which introduces two roundings since 1/10 is not representable\n # perfectly in IEEE floating point.\n # (Not that this really matters, other than for cleanliness, since we're likely reading numbers with\n # at most five decimal digits of precision).\n return (\n num * factor if factor > 0 else num / -factor,\n types.get(units[-1], \"Count\"),\n )","def sentence(self, string='') -> float:\n try:\n out = 0\n for word in string.split(' '):\n out += self.ratio(word)\n return(out)\n except Exception as error:\n print(f\"Error: self.sentence({string}) -> {error}\")","def _convert_df_to_series(df):\n if isinstance(df, pd.DataFrame) and df.shape[1] == 1:\n return df.iloc[:, 0]\n elif isinstance(df, pd.DataFrame) and df.shape[1] > 1:\n raise TypeError('DataFrame cannot be converted to a Series as it contains more than 1 column.')\n return df","def convert(rates, value, from_string, to_string):\n tuple_list = (\n [x for x in rates if x[0] == from_string and x[1] == to_string])\n if tuple_list:\n return round(tuple_list[0][2] * value, 2)\n else:\n tuple_list2 = (\n [x for x in rates if x[1] == from_string and x[0] == to_string])\n return round((1/tuple_list2[0][2]) * value, 2)","def str2num(s):\r\n try:\r\n return int(s)\r\n except ValueError:\r\n return float(s)","def __call__(self) -> pd.Series:\n\n converter = {\"datetime\": self._convert_datetime,\n \"int\": self._convert_int,\n \"bool\": self._convert_bool}\n\n func = converter.get(self.parent.dtype, self._convert)\n\n return func()","def _parseNumber(self, str):\r\n\t\tif (str.count(\".\") == 0):\r\n\t\t\treturn int(str)\r\n\t\tif (str.count(\".\") == 1):\r\n\t\t\treturn float(str)\r\n\t\treturn str","def _cast_number(self, result, source_name):\n\n logger.debug(\"Converting string in records into integer/float\")\n\n columns = self.appresponse.reports.sources[source_name]['columns']\n functions = [lambda x: x] * len(result['columns'])\n\n for i, col in enumerate(result['columns']):\n if columns[col]['type'] in ['integer', 'timestamp']:\n functions[i] = (lambda x: None if x == 'NULL'\n else int(x) if x.isdigit() else x)\n elif columns[col]['type'] in ('number', 'duration'):\n functions[i] = (lambda x: None if x == 'NULL'\n else float(x) if\n x.replace('.', '', 1).isdigit() else x)\n\n # operate on each column, then zip back into list of tuples\n datacols = []\n for i, c in enumerate(zip(*result['data'])):\n datacols.append(map(functions[i], c))\n\n records = zip(*datacols)\n\n return records","def convert_to_r_matrix(df, strings_as_factors=False):\n if isinstance(df, pandas.Series):\n # If it's a Series, cast it to a DataFrame\n df = pandas.DataFrame(df)\n r_dataframe = pandas_data_frame_to_rpy2_data_frame(df)\n as_matrix = robj.baseenv.get(\"as.matrix\")\n r_matrix = as_matrix(r_dataframe)\n return r_matrix","def variation_statistic(gene_data: pd.DataFrame) -> pd.Series:\n statistic = gene_data.std(axis=1) / gene_data.mean(axis=1)\n # statistic = gene_data.std(axis=1)\n # TODO How to deal with 0 expressed genes? Are they informative?????\n return statistic.replace(np.nan, 0)","def num(s: str):\n try: return int(s)\n except ValueError: return float(s)","def _convertType(self, s):\n for func in (int, float):\n try:\n n = func(s)\n return n\n except:\n pass\n return s","def percent_parse(pstring):\n if pstring.strip().endswith('%'):\n return int(pstring.strip()[:-1]) / 100\n else:\n return np.nan","def lexical_density(string):\r\n # YOUR CODE HERE\r\n\r\n from collections import Counter\r\n tokenizedStr = string.strip('.').split(' ')\r\n\r\n c = Counter(tokenize(string.strip('.'), True));\r\n\r\n data = list(c);\r\n data.remove(' ');\r\n\r\n result = len(data)/len(tokenizedStr)\r\n return result","def coerce_numeric_values(df, annot_types):\n if \"numeric\" in annot_types:\n numeric_columns = df.xs(\n \"numeric\", axis=1, level=1, drop_level=False\n ).columns.tolist()\n try:\n # Round numeric columns to 3 decimal places\n df[numeric_columns] = df[numeric_columns].round(3).astype(float)\n except ValueError as e:\n log_exception(Annotations.dev_logger, Annotations.user_logger, e)\n raise ValueError(e)\n return df","def _get_number_from_string(x):\n try:\n return float(x)\n except ValueError:\n raise ValueError('Unknown element')","def _convert_labelled_numeric_items(table, exploded_df, row_header_cols, col_header_cols, decimal_pt='.',\n cast_type=float):\n\n def convert_val(val):\n return _convert_val_to_numeric(val, cast_type, f'[^0-9{decimal_pt}()-]')\n\n numeric_cells = _generate_is_numeric_table(exploded_df, row_header_cols, col_header_cols)\n\n for i in range(table.shape[0]):\n table.iloc[i, :][numeric_cells.iloc[i, :]] = table.iloc[i, :][numeric_cells.iloc[i, :]].apply(convert_val)\n return table","def _convert(self, dtype=None) -> pd.Series:\n\n dtype = dtype or self.parent.dtype\n return pd.Series(self.sanitized, dtype=dtype, name=self.parent.name)","def convert_percent_str(x):\n if x:\n return float(str(x).strip(\"% \"))\n return 0","def _make_numeric(self, data):\n # First remove commas from attendance values. Skip if column is all NA\n # -- not sure if everyone kept records in the early days.\n if data['Attendance'].count() > 0:\n data['Attendance'] = data['Attendance'].str.replace(',', '')\n else:\n data['Attendance'] = np.nan\n\n # Replace unknown with NaN so that column can be numeric\n data['Attendance'].replace(r'^Unknown$', np.nan, regex=True,\n inplace=True)\n\n # now make everything numeric\n num_cols = [\"R\", \"RA\", \"Inn\", \"Rank\", \"Attendance\"]\n data[num_cols] = data[num_cols].astype(float) # not int b/c of NaNs\n return data","def _parse_numbers(self, numberstr: str):\n numbers = []\n currentnumber = \"\"\n\n for c in numberstr:\n if c.isdigit() or c == '-' or c == '.':\n currentnumber += c\n elif len(currentnumber) > 0:\n numbers.append(float(currentnumber))\n currentnumber = \"\"\n if len(currentnumber) > 0:\n numbers.append(float(currentnumber))\n\n return np.array(numbers)","def __parse_traffic(str):\n return float(str.strip().split(\",\")[0].replace('.',''))","def normalize(s, lo_pctl=0.01, hi_pctl=.99):\n\n data_types = {pd.core.series.Series: (lambda x: x.values),\n np.ndarray: (lambda x: x), \n list: (lambda x: np.array(x))}\n\n this_type = type(s)\n assert this_type in data_types.keys(), 'invalid data type. Enter numpy array, pandas series , or list of float.'\n \n for b in [lo_pctl, hi_pctl]:\n assert (b >= 0) & (b <= 1), 'invalid winsor bound. Value must be fraction: > 0 and < 1.'\n assert lo_pctl < hi_pctl, 'invalid winsor bound. First item '\n\n y = data_types[type(s)](s)\n z = np.empty(y.shape)\n z[:] = np.nan\n\n # Compute mean and stdev excluding outliers defined by lo and hi_pctl\n if len(y) > 1:\n upper_bound = np.nanquantile(y, hi_pctl)\n lower_bound = np.nanquantile(y, lo_pctl)\n with np.errstate(invalid='ignore'): # ignore stupid warning about 'invalid value encountered in less than'\n mu = np.nanmean(y[(y >= lower_bound) & (y <= upper_bound)])\n sigma = np.nanstd(y[(y >= lower_bound) & (y <= upper_bound)])\n\n if sigma == 0:\n sigma = np.nan\n\n # Compute normalized variable\n with np.errstate(invalid='ignore'):\n y[y < lower_bound] = lower_bound\n y[y > upper_bound] = upper_bound\n z = (y - mu) / sigma\n\n return z","def parse_reading(data):\n pat =re.compile('([1-9][0-9]*)')\n datum = data.split('\\n')\n #print datum\n for d in datum:\n m = pat.search(d)\n if m is not None:\n return float(m.group(1))\n return float(-1)","def _convert_metastr(metastr, dtype=None):\n if dtype is None:\n dtype = str\n\n if issubclass(dtype, tuple):\n return tuple(float(f.strip()) for f in metastr.split(\",\"))\n else:\n return dtype(metastr)","def test_cast_non_numeric_true():\n assert _currency_column_to_numeric(\"foo\", {\"foo\": 42}) == 42","def coerce(s1):\n if s1==\"true\":\n return True\n elif s1==\"false\":\n return False\n elif s1.isnumeric():\n return int(s1)\n elif '.' in s1 and s1.replace('.','').isnumeric():\n return float(s1)\n else:\n return s1","def parse_string(str_value):\n comps = str_value.split(\"/\")\n assert len(comps) <= 2, \"Cannot parse {0} as Rational\".format(str_value) \n \n num_string = comps[0].strip()\n if (len(comps) == 1):\n return Rational(int(num_string))\n else:\n den_string = comps[1].strip()\n return Rational(int(num_string), int(den_string))","def _convert_to_float(s):\n try:\n return float(s)\n except:\n return s","def check_series(s: pd.Series, input_output=\"\") -> bool:\n\n error_string = (\n \"There are non-representation cells (every cell should be a list of floats) in the given Series.\"\n \" See help(hero.HeroSeries) for more information.\"\n )\n\n def is_numeric(x):\n try:\n float(x)\n except ValueError:\n return False\n else:\n return True\n\n def is_list_of_numbers(cell):\n return all(is_numeric(x) for x in cell) and isinstance(cell, (list, tuple))\n\n if not is_list_of_numbers(s.iloc[0]) or s.index.nlevels != 1:\n raise TypeError(error_string)","def extract_nums(string):\r\n num_list = []\r\n mods1 = string.replace('$', '')\r\n mods2 = mods1.replace('K', '')\r\n for s in mods2.split(' '):\r\n try:\r\n num_list.append(int(s))\r\n except Exception:\r\n pass\r\n return np.mean(num_list)","def check_series(s: pd.Series) -> bool:\n\n error_string = (\n \"The input Series should consist only of strings in every cell.\"\n \" See help(hero.HeroSeries) for more information.\"\n )\n\n if not isinstance(s.iloc[0], str) or s.index.nlevels != 1:\n raise TypeError(error_string)","def get_rmsse(self, valid_preds) -> pd.Series:\n\n score = ((self.valid_series - valid_preds) ** 2).mean(axis = 1)\n rmsse = (score / self.scale).map(np.sqrt)\n\n return rmsse","def file_name_to_radar_num(saliency_file_name):\n\n error_checking.assert_is_string(saliency_file_name)\n\n pathless_file_name = os.path.split(saliency_file_name)[-1]\n extensionless_file_name = os.path.splitext(pathless_file_name)[0]\n radar_word = extensionless_file_name.split('_')[-1]\n\n assert radar_word.startswith('radar')\n\n radar_number = int(radar_word.replace('radar', ''))\n error_checking.assert_is_geq(radar_number, 0)\n\n return radar_number","def test_cast_non_numeric_false():\n assert _currency_column_to_numeric(\"10 dollars\", {\"foo\": 42}) == \"10\"","def perc_str_to_int(string: str) -> int:\n match = re.search(r\"\\((\\d+)%\\)$\", string)\n if match:\n return int(match.group(1))\n raise ValueError(\"Cannot find percentage in table\")","def numDecodings(self, s):\n if not s or s[0] == '0':return 0\n s1,s2 = 1,1\n for m in xrange(1,len(s)):\n if s[m] == '0':s2 = 0\n if s[m-1] == '1' or (s[m-1] == '2' and s[m] <= '6'):\n s2 += s1\n s1 = s2 - s1\n else:\n s1 = s2\n if s2 == 0:return 0\n return s2","def make_numeric(\n df,\n vars_=[\n 'emp',\n 'empszfi',\n 'firmpdemp',\n 'payann',\n 'rcppdemp',\n 'eth_group',\n 'geotype',\n 'rcpszfi',\n 'sex',\n 'vet_group']):\n df[vars_] = df[vars_].apply(pd.to_numeric)\n return df","def custom_cast(s):\n for cast_func in (int, float, str):\n try:\n return cast_func(s)\n except ValueError:\n pass\n raise BaseException('Could not cast as number/string!')","def string_to_number(col_name):\n \n return ( pl.col(col_name).str.replace_all('[\\$MBK]', '').cast(pl.Float64)\n * pl.when(pl.col(col_name).str.ends_with('K'))\n .then(pl.lit(1000))\n .when(pl.col(col_name).str.ends_with('M'))\n .then(pl.lit(1_000_000))\n .when(pl.col(col_name).str.ends_with('B'))\n .then(pl.lit(1_000_000_000))\n .otherwise(pl.lit(1))\n )","def parse_result_series(result):\n if isinstance(result, np.ndarray):\n return result\n\n if result is None or not len(result):\n return None\n\n dates, values = result\n return pd.DataFrame({0:dates.astype(int)/1000,1:values})","def parse_speed(as_str: str) -> float:\n return float(as_str.rstrip(\"x\"))","def get_sample_rate(rate_string):\n if rate_string.endswith(\"%\"):\n rate = float(rate_string[:-1])/100\n elif '/' in rate_string:\n x, y = rate_string.split('/')\n rate = Decimal(x) / (Decimal(y) * Decimal('1.0'))\n else:\n rate = float(rate_string)\n if rate < 0 or rate > 1:\n raise ValueError('rate %r (=%.3f) must be 1%% <= rate <= 100%% ' % (rate_string, rate))\n return int(rate * 1000)","def mean(a_series):\n return float(sum(a_series) / max(len(a_series) * 1.0, 1.0))","def normalize_data(df):\r\n return df/df.ix[0,:]","def note_to_frequency(note: str) -> float:\n n = note_to_semitone_diff(note)\n return semitone_diff_to_frequency(n)","def _eval(string):\n # Remove black spaces\n string = string.strip()\n # Check if the string is None\n if string == \"\":\n return None\n # Check if the string is an integer\n elif string.isdigit():\n return int(string)\n # Try to convert to float\n try:\n string = re.sub(\"[Dd]\", \"e\", string)\n return float(string)\n except:\n pass\n # Else, return the stripped string\n return str(string)","def convert_to_numeric(score):\n return float(score)","def na_ratio(ts: TimeSeries) -> float:\n\n return ts.pd_dataframe().isnull().sum().mean() / len(ts)","def convert(df,celsius):\r\n converted_temp=(df[celsius]*(9/5))+32\r\n return converted_temp","def values_are_pandas_numbers(values: List[str]):\n for v in values:\n try:\n float(v)\n except ValueError:\n return False\n return True","def normalize_column(data: DataFrame, column: str):\n m = mean(data[column])\n s = sd(data[column])\n return data[column].map(lambda x: (x - m) / s)","def _convert_normlogprice(self, series):\n try:\n return np.log(series.div(series[0]))\n except:\n raise TypeError('ERROR: Could not transform prices to log function. Check price history data.')","def str2floatTrap(self, someStr):\n\n tempStr = someStr\n\n if tempStr.startswith('('):\n tempStr = tempStr[1:]\n\n if tempStr.endswith(')'):\n tempStr = tempStr[:len(tempStr) - 1]\n\n return float(tempStr)","def convert(row):\n\n for k,v in row.iteritems():\n if isinstance(v, str):\n if v.isdigit():\n row[k] = int(v)\n elif re.match(r'^\\d+[,\\.]\\d+$', v):\n row[k] = float(v)\n return row"],"string":"[\n \"def convert_to_float(series):\\n series = series.str[:-4].str.replace('.', '').str.replace(',', '.').astype(float)\\n return series\",\n \"def convert(srat):\\n try:\\n return float(srat)\\n except ValueError:\\n num, denom = srat.split('/')\\n return float(num) / float(denom)\",\n \"def convertRate(row):\\n if pd.isnull(row):\\n return 1.0\\n elif ':' in str(row):\\n rows = row.split(':')\\n return 1.0 - float(rows[1]) / float(rows[0])\\n else:\\n return float(row)\",\n \"def get_freq(string:str) -> float:\\n import numpy\\n try:\\n freq = float(string.replace(\\\"%\\\", \\\"\\\")) / 100\\n except AttributeError as e:\\n # if string is np.nan\\n freq = numpy.nan\\n return freq\",\n \"def to_numeric(self, *args, **kwargs): # noqa: PR02\\n return SeriesDefault.register(pandas.to_numeric)(self, *args, **kwargs)\",\n \"def _downcast_numeric(series, allow_categorical=allow_categorical):\\r\\n if pd.api.types.is_sparse(series.dtype) is True:\\r\\n return series\\r\\n elif pd.api.types.is_numeric_dtype(series.dtype) is False:\\r\\n if pd.api.types.is_datetime64_any_dtype(series.dtype):\\r\\n return series\\r\\n else:\\r\\n if allow_categorical:\\r\\n return series\\r\\n else:\\r\\n codes, uniques = series.factorize()\\r\\n series = pd.Series(data=codes, index=series.index)\\r\\n series = _downcast_numeric(series)\\r\\n return series\\r\\n else:\\r\\n series = pd.to_numeric(series, downcast=\\\"integer\\\")\\r\\n if pd.api.types.is_float_dtype(series.dtype):\\r\\n series = series.astype(float_dtype)\\r\\n return series\",\n \"def normalize_series(series):\\n return (series - series.mean()) / (series.max() - series.min())\",\n \"def convert_series(self, column: str, dtype: str) -> TYPE_ROW:\\n\\n series = self.df[column]\\n\\n if dtype != \\\"float\\\":\\n series = series.fillna(NULL)\\n\\n values = self.force_dtype(series, dtype)\\n\\n return values\",\n \"def _to_float(self, s: str) -> float:\\n return int(s[:-1]) / 1e9 if s.endswith('n') else float(s[:-1])\",\n \"def guess_series(input_string):\\n float_finder = re.compile(\\n r\\\"(nan|[-+]?inf|[-+]?[0-9]*\\\\.?[0-9]+(?:e[-+]?[0-9]+)?)\\\", re.I\\n )\\n return [\\n i\\n for i in [\\n _convert_to_float(j)\\n for j in float_finder.findall(input_string)\\n # Remove entires we couldn't convert to a sensible value.\\n ]\\n if i is not None\\n ]\",\n \"def convertRate(row):\\n if row == 'null':\\n return 1.0\\n elif ':' in row:\\n rows = row.split(':')\\n return 1.0 - float(rows[1])/float(rows[0])\\n else:\\n return float(row)\",\n \"def find_non_numeric(pd_series):\\n\\n numeric = []\\n for elem in pd_series:\\n if not elem.isdigit():\\n numeric.append(np.nan)\\n else:\\n numeric.append(int(elem))\\n\\n return numeric\",\n \"def _parseNumbers(s):\\n ss = utils.unclump(s)\\n\\n m3 = re.match('^\\\\d+$', ss)\\n if m3 is not None:\\n return decimal.Decimal(round(float(ss), 2))\\n\\n m1 = re.match(r'(\\\\d+)\\\\s+(\\\\d)/(\\\\d)', ss)\\n if m1 is not None:\\n num = int(m1.group(1)) + (float(m1.group(2)) / float(m1.group(3)))\\n return decimal.Decimal(str(round(num, 2)))\\n\\n m2 = re.match(r'^(\\\\d)/(\\\\d)$', ss)\\n if m2 is not None:\\n num = float(m2.group(1)) / float(m2.group(2))\\n return decimal.Decimal(str(round(num, 2)))\\n\\n return None\",\n \"def to_numeric(s):\\n\\n try:\\n s = float(s)\\n except Exception as e:\\n log.debug('Caught `{e!s}` trying to cast {s!r} to numeric'.format(**locals()))\\n pass\\n return s\",\n \"def _convert_val_to_numeric(val, cast_type=float, regex_exp='[^0-9.-()]'):\\n multiplier = 1\\n\\n try:\\n stripped = regex.sub(regex_exp, '', val)\\n if len(stripped) >= 2 and stripped[0] == '(' and stripped[-1] == ')':\\n multiplier = multiplier*-1\\n ans = cast_type(stripped[1:-1])\\n else:\\n ans = cast_type(regex.sub(regex_exp, '', val))\\n ans = ans * multiplier\\n except ValueError:\\n ans = pd.NA\\n print(f\\\"ERROR READING VALUE:\\\\\\\"{val}\\\\\\\"\\\\t Filling with <NA>\\\")\\n except TypeError:\\n if type(val) in [float, int, cast_type]:\\n ans = cast_type(val)\\n else:\\n print(f\\\"ERROR READING VALUE:\\\\\\\"{val}\\\\\\\"\\\\t Filling with <NA>\\\")\\n ans = pd.NA\\n return ans\",\n \"def str_to_num(s):\\n\\n method = {\\n \\\"float\\\": string.atof,\\n \\\"int\\\": string.atoi\\n }\\n\\n if not type(s) is StringType:\\n return 0\\n\\n if \\\".\\\" in s:\\n return method[\\\"float\\\"](s)\\n else:\\n return method[\\\"int\\\"](s, 10)\",\n \"def ratio(self, string='') -> float:\\n try:\\n return(self.find(string)/self.total)\\n except Exception as error:\\n print(f\\\"Error: self.ratio({string}) -> {error}\\\")\",\n \"def _tokens_to_ratios(self, tokens):\\n return [token * 0.01 for token in tokens]\",\n \"def str2num(s):\\n if s.is_constant() and (s.is_float() or s.is_integer()):\\n return True, s.compute_value()\\n elif s.functor == \\\".\\\":\\n values = term2list(s)\\n numvalues = []\\n for value in values:\\n if isinstance(value, int) or isinstance(value, float):\\n numvalues.append(value)\\n else:\\n return None, None\\n return True, tuple(numvalues)\\n else:\\n return None, None\",\n \"def clarity_conversion(string):\\n if (string == 'I1'):\\n return 0.125\\n if (string == 'SI2'):\\n return 0.25\\n if (string == 'SI1'):\\n return 0.375\\n if (string == 'VS2'):\\n return 0.5\\n if (string == 'VS1'):\\n return 0.625\\n if (string == 'VVS2'):\\n return 0.75\\n if (string == 'VVS1'):\\n return 0.875\\n if (string == 'IF'):\\n return 1\",\n \"def to_real_series(self, data: pd.Series) -> pd.Series:\\n ...\",\n \"def get_metric(self, data_row: pd.Series) -> float:\",\n \"def toNumeric(self):\\n for column in list(self.data.columns):\\n if not is_numeric_dtype(self.data[column]):\\n values = list(sorted(self.data[column].unique()))\\n indices = [index for index, value in enumerate(values)]\\n self.data[column] = self.data[column].replace(\\n to_replace=values, value=indices)\",\n \"def _convert_int(self) -> pd.Series:\\n\\n if self.requires_nan:\\n dtype = \\\"float\\\"\\n else:\\n dtype = \\\"int\\\"\\n\\n return self._convert(dtype=dtype)\",\n \"def string_to_number(s):\\n\\n if type(s).__name__==\\\"str\\\":\\n s = s.strip()\\n if s ==\\\"-\\\":\\n s = 0\\n else:\\n s = s.replace(\\\",\\\",\\\"\\\").replace(\\\"$\\\",\\\"\\\")\\n if s.find(\\\"(\\\")>=0 and s.find(\\\")\\\")>=0:\\n s = s.replace(\\\"(\\\",\\\"-\\\").replace(\\\")\\\",\\\"\\\")\\n return float(s)\",\n \"def float_series() -> pd.Series:\\n series = pd.Series([(n/1000) for n in range(1001)])\\n return series\",\n \"def normalise_series(to_normalise: pd.Series) -> pd.Series:\\n \\n # return (to_normalise - to_normalise.mean()) / to_normalise.std() # 0 mean and unit standard deviation\\n return to_normalise / to_normalise.std() # positive and unit standard deviation\",\n \"def missing_values_ratio(series: TimeSeries) -> float:\\n\\n return series.pd_dataframe().isnull().sum().mean() / len(series)\",\n \"def evaluate(self, string):\\n return round(eval(string), 3)\",\n \"def to_float(s):\\n try:\\n return float(s)\\n except ValueError:\\n return np.nan\",\n \"def find_numerical(self, df):\\n # categorical = [key for key in df.keys() if df.dtypes[key] == np.dtype('O')]\\n numeric = [key for key in df.keys() if df.dtypes[key] != np.dtype('O')]\\n # correct naive expectations\\n actual_categoric = ['MSSubClass']\\n numeric = list(set(numeric) - set(actual_categoric))\\n return numeric\",\n \"def find_numerical(self, df):\\n # categorical = [key for key in df.keys() if df.dtypes[key] == np.dtype('O')]\\n numeric = [key for key in df.keys() if df.dtypes[key] != np.dtype('O')]\\n # correct naive expectations\\n actual_categoric = ['MSSubClass']\\n numeric = list(set(numeric) - set(actual_categoric))\\n return numeric\",\n \"def coerce_strings(df, col):\\r\\n for i,j in enumerate(df[col]):\\r\\n if type(j) == str:\\r\\n j = float(j.replace(',', ''))\\r\\n df[col].iloc[i] = j\\r\\n\\r\\n return df\",\n \"def to_digit(s: str) -> Union[float, str, int]:\\n out = s.strip()\\n f_twin = r'\\\\d+[,.]\\\\d{2,} {0,}- {0,}\\\\d+[.,]\\\\d{2,}'\\n f_rank = r'\\\\d/10'\\n f_score = r'[ ]{0,}\\\\d+[ ]{0,}'\\n f_date = r'\\\\d\\\\d\\\\.\\\\d\\\\d\\\\.\\\\d\\\\d\\\\d\\\\d'\\n f_main = r'(-?\\\\d*\\\\,?\\\\d+\\\\.?\\\\d*)[%BM]?'\\n\\n if isinstance(s, str) and re.findall(f_date, s) == [] and len(s) < 50 and s != '-':\\n try: # begin from big one, because bigs consist small re\\n\\n if re.search(f_main, s) is not None:\\n res = re.search(f_main, s.strip()).groups()[0]\\n if res == '-':\\n return '-'\\n k = 1\\n mul = 1\\n after_point = res.split('.')\\n if len(after_point) == 2:\\n k = 10 ** len(after_point[1].replace(',', ''))\\n\\n mul = 1000000000 if s.find('B') > 0 else mul # found Billions\\n mul = 1000000 if s.find('M') > 0 else mul # found Millions\\n mul = 0.01 if s.find('%') > 0 else mul # found Percent format\\n mul = mul * -1 if s.find(')') > 0 else mul # financial format to show minus : -192.34 = (192.34)\\n\\n return round(float(res.replace('.', '').replace(',', '')), 2) * mul / k if k > 1 else \\\\\\n int(res.replace('.', '').replace(',', '')) * mul\\n\\n if len(re.findall(f_twin, s)) > 0: # format range xxx.xx - xxx.xx\\n return float(re.findall(f_twin, s)[0]\\n .replace(' ', '')\\n .split('-')[0]\\n .replace(',', '')\\n .replace('.', '')) / 100\\n\\n if len(re.findall(f_rank, s)) > 0: # format score like 9/10 -> 9\\n return int(re.findall(f_rank, s)[0].split('/')[0])\\n\\n if len(re.findall(f_score, s)) > 0: # format one digit score like ' 5 ' -> 5\\n return int(re.findall(f_score, s)[0].replace(' ', ''))\\n\\n except Exception as e:\\n\\n logging.error(f\\\"Error in to_digit(). Input {s}, Out \\\")\\n return out\",\n \"def to_numerical(table, column_name):\\n def replace(entry):\\n return float(entry)\\n assert (isinstance(table, Table)), \\\"Input not a supported type.\\\"\\n column = table.apply(replace, column_name)\\n return table.append_column(column_name, column)\",\n \"def parse(string):\\n posslash = string.find('/')\\n if posslash < 0:\\n return Rational(int(string), 1)\\n else:\\n strs = string.split('/')\\n return Rational(int(strs[0].strip()), int(strs[1].strip()))\",\n \"def percent_rank(\\n series: Iterable[Any], na_last: str = \\\"keep\\\"\\n) -> Iterable[float]:\\n # Without this:\\n # pandas 1.2.0: ValueError: Transform function failed\\n if len(series) == 0:\\n dtype = getattr(series, \\\"dtype\\\", None)\\n return Array(series, dtype=dtype) # make a copy\\n\\n ranking = _rank(series, na_last, \\\"min\\\", True)\\n minrank = ranking.min()\\n maxrank = ranking.max()\\n ret = ranking.transform(lambda r: (r - minrank) / (maxrank - minrank))\\n ret[ranking.isna()] = NA\\n return ret\",\n \"def inspect_dtype_object(self, column: str) -> str:\\n\\n series = self.df[column].dropna()\\n\\n # check for bool\\n try:\\n conv = pd.to_numeric(series)\\n return self.inspect_dtype(conv)\\n except ValueError:\\n pass\\n\\n # check for mixed dtypes\\n dtypes = {type(x) for x in series}\\n if len(dtypes) > 1:\\n raise TypeError(\\\"Column `{}` has mixed dtypes: {}. Currently, \\\"\\n \\\"this is not supported.\\\"\\n .format(column, dtypes))\\n\\n # check for string\\n if isinstance(series[0], str):\\n return \\\"str\\\"\\n\\n # raise if unsupported dtype is encountered\\n raise TypeError(\\\"Column `{}` has dtype `{}` which is currently \\\"\\n \\\"not supported.\\\"\\n .format(column, type(series[0])))\",\n \"def compare_strings(string1: str, string2: str) -> float:\\n return SequenceMatcher(None, string1, string2).ratio()\",\n \"def generate(data: pd.DataFrame) -> np.ndarray:\\n # TODO tests\\n return data.apply(pd.to_numeric, errors='coerce')\",\n \"def from_str(klass, s):\\n # Special cases\\n if s == \\\"nan\\\" :\\n return RatTerm(RatNum(1, 0), 1)\\n elif s == \\\"0\\\" :\\n return RatTerm(RatNum(0, 1), 1)\\n elif s == \\\"x\\\" :\\n return RatTerm(RatNum(1, 1), 1)\\n elif s == \\\"-x\\\" :\\n return RatTerm(RatNum(-1, 1), 1)\\n \\n # Exponent\\n if \\\"^\\\" in s :\\n expo = int(s.split(\\\"^\\\")[1])\\n else :\\n expo = 0\\n \\n # Rational coefficient \\n co = s.split(\\\"*\\\")[0]\\n if \\\"/\\\" in co :\\n nom, sep, denom = s.partition(\\\"/\\\")\\n nom = int(nom)\\n denom = int(denom.split(\\\"*\\\")[0])\\n # coefficient = 1\\n elif s.startswith(\\\"x\\\") :\\n nom = 1\\n denom = 1\\n # coefficient = -1\\n elif s.startswith(\\\"-x\\\") :\\n nom = -1\\n denom = 1\\n else :\\n nom = int(s.split(\\\"*\\\")[0])\\n denom = 1\\n \\n return RatTerm(RatNum(nom, denom), expo)\",\n \"def loss_ratio(df, column, missing_indicator=0):\\r\\n \\r\\n # if np.nan is passed\\r\\n if np.isnan(missing_indicator):\\r\\n ratio = float(len(df[df[column].isnull()]))/len(df)\\r\\n else:\\r\\n ratio = float(len(df[df[column]==missing_indicator]))/len(df)\\r\\n \\r\\n return ratio\",\n \"def to_number(s):\\n ret = s\\n try:\\n ret = float(s)\\n except ValueError:\\n ret = ret.strip('\\\\'').strip()\\n return ret\\n\\n try:\\n ret = int(s)\\n except ValueError:\\n pass\\n return ret\",\n \"def to_numeric_and_downcast_data(df: pd.DataFrame):\\n fcols = df.select_dtypes('float').columns\\n \\n icols = df.select_dtypes('integer').columns\\n\\n df[fcols] = df[fcols].apply(pd.to_numeric, downcast='float')\\n \\n df[icols] = df[icols].apply(pd.to_numeric, downcast='integer')\\n\\n return df\",\n \"def convert_dollars(df,col_name):\\n df[col_name] = df[col_name].replace('[^.0-9]','',regex=True).astype(float)\\n return df\",\n \"def extractSI(s):\\n\\n # If this is representing a range, just return it as is.\\n if \\\"[\\\" in s:\\n return (s, None)\\n\\n types = {\\\"T\\\": \\\"Time\\\", \\\"O\\\": \\\"Rate\\\", \\\"A\\\": \\\"Rate\\\", \\\"s\\\": \\\"Seconds\\\", \\\"%\\\": \\\"Percentage\\\"}\\n du = s.split()\\n # Preserve integers as such, so that columns like \\\"Threads\\\" generate an X axis \\\"1 2 3\\\",\\n # rather than \\\"1.0 2.0 3.0\\\"\\n num = float(du[0]) if \\\".\\\" in du[0] else int(du[0])\\n units = du[1] if len(du) == 2 else \\\" \\\"\\n if s[-1] == \\\" \\\":\\n units = units + \\\" \\\"\\n\\n # http://physics.nist.gov/cuu/Units/prefixes.html\\n factor = {\\n \\\"Y\\\": 1e24,\\n \\\"Z\\\": 1e21,\\n \\\"E\\\": 1e18,\\n \\\"P\\\": 1e15,\\n \\\"T\\\": 1e12,\\n \\\"G\\\": 1e9,\\n \\\"M\\\": 1e6,\\n \\\"k\\\": 1e3,\\n \\\" \\\": 1,\\n \\\"m\\\": -1e3, # Yes, I do mean that, see below for the explanation.\\n \\\"u\\\": -1e6,\\n \\\"n\\\": -1e9,\\n \\\"p\\\": -1e12,\\n \\\"f\\\": -1e15,\\n \\\"a\\\": -1e18,\\n \\\"z\\\": -1e21,\\n \\\"y\\\": -1e24,\\n }[units[0] if len(units) == 2 else \\\" \\\"]\\n # print (\\\"units = '\\\" + units + \\\"'\\\" + \\\" factor=\\\" + str(factor))\\n\\n # Minor trickery here is an attempt to preserve accuracy by using a single divide,\\n # rather than multiplying by 1/x, which introduces two roundings since 1/10 is not representable\\n # perfectly in IEEE floating point.\\n # (Not that this really matters, other than for cleanliness, since we're likely reading numbers with\\n # at most five decimal digits of precision).\\n return (\\n num * factor if factor > 0 else num / -factor,\\n types.get(units[-1], \\\"Count\\\"),\\n )\",\n \"def sentence(self, string='') -> float:\\n try:\\n out = 0\\n for word in string.split(' '):\\n out += self.ratio(word)\\n return(out)\\n except Exception as error:\\n print(f\\\"Error: self.sentence({string}) -> {error}\\\")\",\n \"def _convert_df_to_series(df):\\n if isinstance(df, pd.DataFrame) and df.shape[1] == 1:\\n return df.iloc[:, 0]\\n elif isinstance(df, pd.DataFrame) and df.shape[1] > 1:\\n raise TypeError('DataFrame cannot be converted to a Series as it contains more than 1 column.')\\n return df\",\n \"def convert(rates, value, from_string, to_string):\\n tuple_list = (\\n [x for x in rates if x[0] == from_string and x[1] == to_string])\\n if tuple_list:\\n return round(tuple_list[0][2] * value, 2)\\n else:\\n tuple_list2 = (\\n [x for x in rates if x[1] == from_string and x[0] == to_string])\\n return round((1/tuple_list2[0][2]) * value, 2)\",\n \"def str2num(s):\\r\\n try:\\r\\n return int(s)\\r\\n except ValueError:\\r\\n return float(s)\",\n \"def __call__(self) -> pd.Series:\\n\\n converter = {\\\"datetime\\\": self._convert_datetime,\\n \\\"int\\\": self._convert_int,\\n \\\"bool\\\": self._convert_bool}\\n\\n func = converter.get(self.parent.dtype, self._convert)\\n\\n return func()\",\n \"def _parseNumber(self, str):\\r\\n\\t\\tif (str.count(\\\".\\\") == 0):\\r\\n\\t\\t\\treturn int(str)\\r\\n\\t\\tif (str.count(\\\".\\\") == 1):\\r\\n\\t\\t\\treturn float(str)\\r\\n\\t\\treturn str\",\n \"def _cast_number(self, result, source_name):\\n\\n logger.debug(\\\"Converting string in records into integer/float\\\")\\n\\n columns = self.appresponse.reports.sources[source_name]['columns']\\n functions = [lambda x: x] * len(result['columns'])\\n\\n for i, col in enumerate(result['columns']):\\n if columns[col]['type'] in ['integer', 'timestamp']:\\n functions[i] = (lambda x: None if x == 'NULL'\\n else int(x) if x.isdigit() else x)\\n elif columns[col]['type'] in ('number', 'duration'):\\n functions[i] = (lambda x: None if x == 'NULL'\\n else float(x) if\\n x.replace('.', '', 1).isdigit() else x)\\n\\n # operate on each column, then zip back into list of tuples\\n datacols = []\\n for i, c in enumerate(zip(*result['data'])):\\n datacols.append(map(functions[i], c))\\n\\n records = zip(*datacols)\\n\\n return records\",\n \"def convert_to_r_matrix(df, strings_as_factors=False):\\n if isinstance(df, pandas.Series):\\n # If it's a Series, cast it to a DataFrame\\n df = pandas.DataFrame(df)\\n r_dataframe = pandas_data_frame_to_rpy2_data_frame(df)\\n as_matrix = robj.baseenv.get(\\\"as.matrix\\\")\\n r_matrix = as_matrix(r_dataframe)\\n return r_matrix\",\n \"def variation_statistic(gene_data: pd.DataFrame) -> pd.Series:\\n statistic = gene_data.std(axis=1) / gene_data.mean(axis=1)\\n # statistic = gene_data.std(axis=1)\\n # TODO How to deal with 0 expressed genes? Are they informative?????\\n return statistic.replace(np.nan, 0)\",\n \"def num(s: str):\\n try: return int(s)\\n except ValueError: return float(s)\",\n \"def _convertType(self, s):\\n for func in (int, float):\\n try:\\n n = func(s)\\n return n\\n except:\\n pass\\n return s\",\n \"def percent_parse(pstring):\\n if pstring.strip().endswith('%'):\\n return int(pstring.strip()[:-1]) / 100\\n else:\\n return np.nan\",\n \"def lexical_density(string):\\r\\n # YOUR CODE HERE\\r\\n\\r\\n from collections import Counter\\r\\n tokenizedStr = string.strip('.').split(' ')\\r\\n\\r\\n c = Counter(tokenize(string.strip('.'), True));\\r\\n\\r\\n data = list(c);\\r\\n data.remove(' ');\\r\\n\\r\\n result = len(data)/len(tokenizedStr)\\r\\n return result\",\n \"def coerce_numeric_values(df, annot_types):\\n if \\\"numeric\\\" in annot_types:\\n numeric_columns = df.xs(\\n \\\"numeric\\\", axis=1, level=1, drop_level=False\\n ).columns.tolist()\\n try:\\n # Round numeric columns to 3 decimal places\\n df[numeric_columns] = df[numeric_columns].round(3).astype(float)\\n except ValueError as e:\\n log_exception(Annotations.dev_logger, Annotations.user_logger, e)\\n raise ValueError(e)\\n return df\",\n \"def _get_number_from_string(x):\\n try:\\n return float(x)\\n except ValueError:\\n raise ValueError('Unknown element')\",\n \"def _convert_labelled_numeric_items(table, exploded_df, row_header_cols, col_header_cols, decimal_pt='.',\\n cast_type=float):\\n\\n def convert_val(val):\\n return _convert_val_to_numeric(val, cast_type, f'[^0-9{decimal_pt}()-]')\\n\\n numeric_cells = _generate_is_numeric_table(exploded_df, row_header_cols, col_header_cols)\\n\\n for i in range(table.shape[0]):\\n table.iloc[i, :][numeric_cells.iloc[i, :]] = table.iloc[i, :][numeric_cells.iloc[i, :]].apply(convert_val)\\n return table\",\n \"def _convert(self, dtype=None) -> pd.Series:\\n\\n dtype = dtype or self.parent.dtype\\n return pd.Series(self.sanitized, dtype=dtype, name=self.parent.name)\",\n \"def convert_percent_str(x):\\n if x:\\n return float(str(x).strip(\\\"% \\\"))\\n return 0\",\n \"def _make_numeric(self, data):\\n # First remove commas from attendance values. Skip if column is all NA\\n # -- not sure if everyone kept records in the early days.\\n if data['Attendance'].count() > 0:\\n data['Attendance'] = data['Attendance'].str.replace(',', '')\\n else:\\n data['Attendance'] = np.nan\\n\\n # Replace unknown with NaN so that column can be numeric\\n data['Attendance'].replace(r'^Unknown$', np.nan, regex=True,\\n inplace=True)\\n\\n # now make everything numeric\\n num_cols = [\\\"R\\\", \\\"RA\\\", \\\"Inn\\\", \\\"Rank\\\", \\\"Attendance\\\"]\\n data[num_cols] = data[num_cols].astype(float) # not int b/c of NaNs\\n return data\",\n \"def _parse_numbers(self, numberstr: str):\\n numbers = []\\n currentnumber = \\\"\\\"\\n\\n for c in numberstr:\\n if c.isdigit() or c == '-' or c == '.':\\n currentnumber += c\\n elif len(currentnumber) > 0:\\n numbers.append(float(currentnumber))\\n currentnumber = \\\"\\\"\\n if len(currentnumber) > 0:\\n numbers.append(float(currentnumber))\\n\\n return np.array(numbers)\",\n \"def __parse_traffic(str):\\n return float(str.strip().split(\\\",\\\")[0].replace('.',''))\",\n \"def normalize(s, lo_pctl=0.01, hi_pctl=.99):\\n\\n data_types = {pd.core.series.Series: (lambda x: x.values),\\n np.ndarray: (lambda x: x), \\n list: (lambda x: np.array(x))}\\n\\n this_type = type(s)\\n assert this_type in data_types.keys(), 'invalid data type. Enter numpy array, pandas series , or list of float.'\\n \\n for b in [lo_pctl, hi_pctl]:\\n assert (b >= 0) & (b <= 1), 'invalid winsor bound. Value must be fraction: > 0 and < 1.'\\n assert lo_pctl < hi_pctl, 'invalid winsor bound. First item '\\n\\n y = data_types[type(s)](s)\\n z = np.empty(y.shape)\\n z[:] = np.nan\\n\\n # Compute mean and stdev excluding outliers defined by lo and hi_pctl\\n if len(y) > 1:\\n upper_bound = np.nanquantile(y, hi_pctl)\\n lower_bound = np.nanquantile(y, lo_pctl)\\n with np.errstate(invalid='ignore'): # ignore stupid warning about 'invalid value encountered in less than'\\n mu = np.nanmean(y[(y >= lower_bound) & (y <= upper_bound)])\\n sigma = np.nanstd(y[(y >= lower_bound) & (y <= upper_bound)])\\n\\n if sigma == 0:\\n sigma = np.nan\\n\\n # Compute normalized variable\\n with np.errstate(invalid='ignore'):\\n y[y < lower_bound] = lower_bound\\n y[y > upper_bound] = upper_bound\\n z = (y - mu) / sigma\\n\\n return z\",\n \"def parse_reading(data):\\n pat =re.compile('([1-9][0-9]*)')\\n datum = data.split('\\\\n')\\n #print datum\\n for d in datum:\\n m = pat.search(d)\\n if m is not None:\\n return float(m.group(1))\\n return float(-1)\",\n \"def _convert_metastr(metastr, dtype=None):\\n if dtype is None:\\n dtype = str\\n\\n if issubclass(dtype, tuple):\\n return tuple(float(f.strip()) for f in metastr.split(\\\",\\\"))\\n else:\\n return dtype(metastr)\",\n \"def test_cast_non_numeric_true():\\n assert _currency_column_to_numeric(\\\"foo\\\", {\\\"foo\\\": 42}) == 42\",\n \"def coerce(s1):\\n if s1==\\\"true\\\":\\n return True\\n elif s1==\\\"false\\\":\\n return False\\n elif s1.isnumeric():\\n return int(s1)\\n elif '.' in s1 and s1.replace('.','').isnumeric():\\n return float(s1)\\n else:\\n return s1\",\n \"def parse_string(str_value):\\n comps = str_value.split(\\\"/\\\")\\n assert len(comps) <= 2, \\\"Cannot parse {0} as Rational\\\".format(str_value) \\n \\n num_string = comps[0].strip()\\n if (len(comps) == 1):\\n return Rational(int(num_string))\\n else:\\n den_string = comps[1].strip()\\n return Rational(int(num_string), int(den_string))\",\n \"def _convert_to_float(s):\\n try:\\n return float(s)\\n except:\\n return s\",\n \"def check_series(s: pd.Series, input_output=\\\"\\\") -> bool:\\n\\n error_string = (\\n \\\"There are non-representation cells (every cell should be a list of floats) in the given Series.\\\"\\n \\\" See help(hero.HeroSeries) for more information.\\\"\\n )\\n\\n def is_numeric(x):\\n try:\\n float(x)\\n except ValueError:\\n return False\\n else:\\n return True\\n\\n def is_list_of_numbers(cell):\\n return all(is_numeric(x) for x in cell) and isinstance(cell, (list, tuple))\\n\\n if not is_list_of_numbers(s.iloc[0]) or s.index.nlevels != 1:\\n raise TypeError(error_string)\",\n \"def extract_nums(string):\\r\\n num_list = []\\r\\n mods1 = string.replace('$', '')\\r\\n mods2 = mods1.replace('K', '')\\r\\n for s in mods2.split(' '):\\r\\n try:\\r\\n num_list.append(int(s))\\r\\n except Exception:\\r\\n pass\\r\\n return np.mean(num_list)\",\n \"def check_series(s: pd.Series) -> bool:\\n\\n error_string = (\\n \\\"The input Series should consist only of strings in every cell.\\\"\\n \\\" See help(hero.HeroSeries) for more information.\\\"\\n )\\n\\n if not isinstance(s.iloc[0], str) or s.index.nlevels != 1:\\n raise TypeError(error_string)\",\n \"def get_rmsse(self, valid_preds) -> pd.Series:\\n\\n score = ((self.valid_series - valid_preds) ** 2).mean(axis = 1)\\n rmsse = (score / self.scale).map(np.sqrt)\\n\\n return rmsse\",\n \"def file_name_to_radar_num(saliency_file_name):\\n\\n error_checking.assert_is_string(saliency_file_name)\\n\\n pathless_file_name = os.path.split(saliency_file_name)[-1]\\n extensionless_file_name = os.path.splitext(pathless_file_name)[0]\\n radar_word = extensionless_file_name.split('_')[-1]\\n\\n assert radar_word.startswith('radar')\\n\\n radar_number = int(radar_word.replace('radar', ''))\\n error_checking.assert_is_geq(radar_number, 0)\\n\\n return radar_number\",\n \"def test_cast_non_numeric_false():\\n assert _currency_column_to_numeric(\\\"10 dollars\\\", {\\\"foo\\\": 42}) == \\\"10\\\"\",\n \"def perc_str_to_int(string: str) -> int:\\n match = re.search(r\\\"\\\\((\\\\d+)%\\\\)$\\\", string)\\n if match:\\n return int(match.group(1))\\n raise ValueError(\\\"Cannot find percentage in table\\\")\",\n \"def numDecodings(self, s):\\n if not s or s[0] == '0':return 0\\n s1,s2 = 1,1\\n for m in xrange(1,len(s)):\\n if s[m] == '0':s2 = 0\\n if s[m-1] == '1' or (s[m-1] == '2' and s[m] <= '6'):\\n s2 += s1\\n s1 = s2 - s1\\n else:\\n s1 = s2\\n if s2 == 0:return 0\\n return s2\",\n \"def make_numeric(\\n df,\\n vars_=[\\n 'emp',\\n 'empszfi',\\n 'firmpdemp',\\n 'payann',\\n 'rcppdemp',\\n 'eth_group',\\n 'geotype',\\n 'rcpszfi',\\n 'sex',\\n 'vet_group']):\\n df[vars_] = df[vars_].apply(pd.to_numeric)\\n return df\",\n \"def custom_cast(s):\\n for cast_func in (int, float, str):\\n try:\\n return cast_func(s)\\n except ValueError:\\n pass\\n raise BaseException('Could not cast as number/string!')\",\n \"def string_to_number(col_name):\\n \\n return ( pl.col(col_name).str.replace_all('[\\\\$MBK]', '').cast(pl.Float64)\\n * pl.when(pl.col(col_name).str.ends_with('K'))\\n .then(pl.lit(1000))\\n .when(pl.col(col_name).str.ends_with('M'))\\n .then(pl.lit(1_000_000))\\n .when(pl.col(col_name).str.ends_with('B'))\\n .then(pl.lit(1_000_000_000))\\n .otherwise(pl.lit(1))\\n )\",\n \"def parse_result_series(result):\\n if isinstance(result, np.ndarray):\\n return result\\n\\n if result is None or not len(result):\\n return None\\n\\n dates, values = result\\n return pd.DataFrame({0:dates.astype(int)/1000,1:values})\",\n \"def parse_speed(as_str: str) -> float:\\n return float(as_str.rstrip(\\\"x\\\"))\",\n \"def get_sample_rate(rate_string):\\n if rate_string.endswith(\\\"%\\\"):\\n rate = float(rate_string[:-1])/100\\n elif '/' in rate_string:\\n x, y = rate_string.split('/')\\n rate = Decimal(x) / (Decimal(y) * Decimal('1.0'))\\n else:\\n rate = float(rate_string)\\n if rate < 0 or rate > 1:\\n raise ValueError('rate %r (=%.3f) must be 1%% <= rate <= 100%% ' % (rate_string, rate))\\n return int(rate * 1000)\",\n \"def mean(a_series):\\n return float(sum(a_series) / max(len(a_series) * 1.0, 1.0))\",\n \"def normalize_data(df):\\r\\n return df/df.ix[0,:]\",\n \"def note_to_frequency(note: str) -> float:\\n n = note_to_semitone_diff(note)\\n return semitone_diff_to_frequency(n)\",\n \"def _eval(string):\\n # Remove black spaces\\n string = string.strip()\\n # Check if the string is None\\n if string == \\\"\\\":\\n return None\\n # Check if the string is an integer\\n elif string.isdigit():\\n return int(string)\\n # Try to convert to float\\n try:\\n string = re.sub(\\\"[Dd]\\\", \\\"e\\\", string)\\n return float(string)\\n except:\\n pass\\n # Else, return the stripped string\\n return str(string)\",\n \"def convert_to_numeric(score):\\n return float(score)\",\n \"def na_ratio(ts: TimeSeries) -> float:\\n\\n return ts.pd_dataframe().isnull().sum().mean() / len(ts)\",\n \"def convert(df,celsius):\\r\\n converted_temp=(df[celsius]*(9/5))+32\\r\\n return converted_temp\",\n \"def values_are_pandas_numbers(values: List[str]):\\n for v in values:\\n try:\\n float(v)\\n except ValueError:\\n return False\\n return True\",\n \"def normalize_column(data: DataFrame, column: str):\\n m = mean(data[column])\\n s = sd(data[column])\\n return data[column].map(lambda x: (x - m) / s)\",\n \"def _convert_normlogprice(self, series):\\n try:\\n return np.log(series.div(series[0]))\\n except:\\n raise TypeError('ERROR: Could not transform prices to log function. Check price history data.')\",\n \"def str2floatTrap(self, someStr):\\n\\n tempStr = someStr\\n\\n if tempStr.startswith('('):\\n tempStr = tempStr[1:]\\n\\n if tempStr.endswith(')'):\\n tempStr = tempStr[:len(tempStr) - 1]\\n\\n return float(tempStr)\",\n \"def convert(row):\\n\\n for k,v in row.iteritems():\\n if isinstance(v, str):\\n if v.isdigit():\\n row[k] = int(v)\\n elif re.match(r'^\\\\d+[,\\\\.]\\\\d+$', v):\\n row[k] = float(v)\\n return row\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6325216","0.6113206","0.58220035","0.5687025","0.567426","0.56450087","0.5632027","0.5590445","0.5578296","0.5572146","0.5564546","0.5494868","0.54813343","0.5451129","0.54271585","0.5381694","0.5367929","0.5367361","0.5344174","0.5337416","0.5271317","0.5268334","0.52636","0.52311754","0.5229584","0.5210046","0.518892","0.5171191","0.5158843","0.5149584","0.512946","0.512946","0.51256335","0.51032794","0.5100585","0.5090202","0.5088895","0.50880337","0.5075071","0.5068161","0.5044191","0.50313723","0.50080615","0.49825844","0.49759483","0.49658957","0.49539194","0.49373665","0.49332374","0.49114555","0.490526","0.48983508","0.4894084","0.48933804","0.4890739","0.488","0.4869735","0.4865245","0.4844066","0.4843404","0.48406258","0.48323032","0.48308882","0.48233998","0.4821307","0.48146304","0.48040408","0.47959852","0.47894213","0.4781922","0.47786897","0.47733748","0.4772965","0.47695065","0.47621614","0.4753716","0.47504088","0.47479293","0.47463349","0.47446465","0.47443706","0.47379646","0.47357598","0.47284323","0.47136736","0.47128284","0.4709981","0.46969086","0.46961927","0.46954075","0.4695329","0.46831185","0.46798962","0.46693","0.46688023","0.46681675","0.46671835","0.46659428","0.46649945","0.46466386"],"string":"[\n \"0.6325216\",\n \"0.6113206\",\n \"0.58220035\",\n \"0.5687025\",\n \"0.567426\",\n \"0.56450087\",\n \"0.5632027\",\n \"0.5590445\",\n \"0.5578296\",\n \"0.5572146\",\n \"0.5564546\",\n \"0.5494868\",\n \"0.54813343\",\n \"0.5451129\",\n \"0.54271585\",\n \"0.5381694\",\n \"0.5367929\",\n \"0.5367361\",\n \"0.5344174\",\n \"0.5337416\",\n \"0.5271317\",\n \"0.5268334\",\n \"0.52636\",\n \"0.52311754\",\n \"0.5229584\",\n \"0.5210046\",\n \"0.518892\",\n \"0.5171191\",\n \"0.5158843\",\n \"0.5149584\",\n \"0.512946\",\n \"0.512946\",\n \"0.51256335\",\n \"0.51032794\",\n \"0.5100585\",\n \"0.5090202\",\n \"0.5088895\",\n \"0.50880337\",\n \"0.5075071\",\n \"0.5068161\",\n \"0.5044191\",\n \"0.50313723\",\n \"0.50080615\",\n \"0.49825844\",\n \"0.49759483\",\n \"0.49658957\",\n \"0.49539194\",\n \"0.49373665\",\n \"0.49332374\",\n \"0.49114555\",\n \"0.490526\",\n \"0.48983508\",\n \"0.4894084\",\n \"0.48933804\",\n \"0.4890739\",\n \"0.488\",\n \"0.4869735\",\n \"0.4865245\",\n \"0.4844066\",\n \"0.4843404\",\n \"0.48406258\",\n \"0.48323032\",\n \"0.48308882\",\n \"0.48233998\",\n \"0.4821307\",\n \"0.48146304\",\n \"0.48040408\",\n \"0.47959852\",\n \"0.47894213\",\n \"0.4781922\",\n \"0.47786897\",\n \"0.47733748\",\n \"0.4772965\",\n \"0.47695065\",\n \"0.47621614\",\n \"0.4753716\",\n \"0.47504088\",\n \"0.47479293\",\n \"0.47463349\",\n \"0.47446465\",\n \"0.47443706\",\n \"0.47379646\",\n \"0.47357598\",\n \"0.47284323\",\n \"0.47136736\",\n \"0.47128284\",\n \"0.4709981\",\n \"0.46969086\",\n \"0.46961927\",\n \"0.46954075\",\n \"0.4695329\",\n \"0.46831185\",\n \"0.46798962\",\n \"0.46693\",\n \"0.46688023\",\n \"0.46681675\",\n \"0.46671835\",\n \"0.46659428\",\n \"0.46649945\",\n \"0.46466386\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.48489207"},"document_rank":{"kind":"string","value":"58"}}},{"rowIdx":10798,"cells":{"query":{"kind":"string","value":"Finds GO enrichment with goatools (0.7.11 tested)."},"document":{"kind":"string","value":"def goe(\n\tgenelist,\n\tgo_file,\n\tgoa_file,\n\tbg=None,\n\tnmin=5,\n\tconversion=None,\n\tevidence_set={\n\t\t'EXP', 'IDA', 'IPI', 'IMP', 'IGI', 'HTP', 'HDA', 'HMP', 'HGI', 'IBA',\n\t\t'IBD', 'IKR', 'IRD', 'ISS', 'ISO', 'ISA', 'ISM'}):\n\tfrom tempfile import NamedTemporaryFile\n\tfrom os import linesep\n\tfrom goatools.go_enrichment import GOEnrichmentStudy\n\tfrom goatools.obo_parser import GODag\n\tfrom goatools.associations import read_gaf\n\tfrom collections import defaultdict\n\timport itertools\n\tfrom biothings_client import get_client\n\timport pandas as pd\n\timport logging\n\tassert type(genelist) is list and len(genelist) > 0\n\tif nmin < 1:\n\t\tnmin = 1\n\n\tbg0 = bg\n\t# Convert gene names\n\tif conversion is not None:\n\t\tassert len(conversion) == 3\n\t\tname_from, name_to, species = conversion\n\t\tmg = get_client('gene')\n\t\tans = set(genelist)\n\t\tif bg is not None:\n\t\t\tt1 = set(bg)\n\t\t\tassert len(ans - t1) == 0\n\t\t\tans |= t1\n\t\tans = list(ans)\n\t\tans = mg.querymany(ans, scopes=name_from, fields=name_to, species=species)\n\t\tt1 = set(['query', '_score', name_to.split('.')[0]])\n\t\tans = list(filter(lambda x: len(t1 - set(x)) == 0, ans))\n\t\tans = sorted(ans, key=lambda x: x['_score'])\n\t\tconvert = {x['query']: x for x in ans}\n\t\tfor xi in name_to.split('.'):\n\t\t\tconvert = filter(lambda x: xi in x[1], convert.items())\n\t\t\tconvert = {x[0]: x[1][xi] for x in convert}\n\t\tconvert = {\n\t\t\tx[0]: x[1] if type(x[1]) is str else x[1][0]\n\t\t\tfor x in convert.items()}\n\t\tgenelist2 = list(\n\t\t\tset([convert[x] for x in filter(lambda x: x in convert, genelist)]))\n\t\tif bg is not None:\n\t\t\tbg = list(set([convert[x] for x in filter(lambda x: x in convert, bg)]))\n\t\tt1 = set(genelist)\n\t\tconverti = list(filter(lambda x: x[0] in t1, convert.items()))\n\t\tt1 = defaultdict(list)\n\t\tfor xi in converti:\n\t\t\tt1[xi[1]].append(xi[0])\n\t\tconverti = dict(t1)\n\t\tt1 = defaultdict(list)\n\t\tfor xi in convert.items():\n\t\t\tt1[xi[1]].append(xi[0])\n\t\tconvertia = dict(t1)\n\telse:\n\t\tgenelist2 = genelist\n\n\t# Load GO DAG and association files\n\tlogging.debug('Reading GO DAG file ' + go_file)\n\tgodag = GODag(go_file)\n\tlogging.debug('Reading GO association file ' + goa_file)\n\tgoa = read_gaf(goa_file, evidence_set=evidence_set)\n\tif bg is None:\n\t\tbg = list(goa.keys())\n\n\t# Compute enrichment\n\tgoe = GOEnrichmentStudy(bg, goa, godag)\n\tans = goe.run_study(genelist2)\n\t# Format output\n\twith NamedTemporaryFile() as f:\n\t\tgoe.wr_tsv(f.name, ans)\n\t\tans = f.read()\n\tans = ans.decode()\n\tans = [x.split('\\t') for x in ans.split(linesep)]\n\tif len(ans[-1]) < 2:\n\t\tans = ans[:-1]\n\tif len(ans) == 0 or len(ans[0]) == 0:\n\t\traise ValueError('No enrichment found. Check your input ID type.')\n\tans[0][0] = ans[0][0].strip('# ')\n\tans = pd.DataFrame(ans[1:], columns=ans[0])\n\tans.drop(['NS', 'enrichment', 'study_count', 'p_sidak', 'p_holm'],\n\t\t\t axis=1,\n\t\t\t inplace=True)\n\tfor xj in ['p_uncorrected', 'p_bonferroni']:\n\t\tans[xj] = pd.to_numeric(ans[xj], errors='raise')\n\tans['depth'] = pd.to_numeric(ans['depth'],\n\t\t\t\t\t\t\t\t errors='raise',\n\t\t\t\t\t\t\t\t downcast='unsigned')\n\t# Odds ratio column and sort column\n\tans['odds_ratio'] = toratio(ans['ratio_in_study']) / toratio(\n\t\tans['ratio_in_pop'])\n\tans = ans[[\n\t\t'name', 'depth', 'p_uncorrected', 'p_bonferroni', 'odds_ratio',\n\t\t'ratio_in_study', 'ratio_in_pop', 'GO', 'study_items']]\n\tans['study_items'] = ans['study_items'].apply(lambda x: x.replace(' ', ''))\n\t# Convert back study_items\n\tif conversion is not None:\n\t\tans['study_items'] = ans['study_items'].apply(lambda x: ','.join(\n\t\t\tlist(itertools.chain.from_iterable([converti[y] for y in x.split(',')])))\n\t\t\t\t\t\t\t\t\t\t\t\t\t if len(x) > 0 else x)\n\tans.sort_values('p_uncorrected', inplace=True)\n\n\t# Get top enriched GO by P-value\n\tgotop = ans[\n\t\t(ans['odds_ratio'] > 1)\n\t\t& ans['ratio_in_study'].apply(lambda x: int(x.split('/')[0]) >= nmin)]\n\tif len(gotop) == 0:\n\t\traise ValueError('No GO enrichment found for given criteria.')\n\tgotop = str(gotop.iloc[0]['GO'])\n\tif bg0 is not None:\n\t\t# Children GOs\n\t\tgos = set([gotop] + list(godag.query_term(gotop).get_all_children()))\n\t\t# Look for genes\n\t\tgenes = list(\n\t\t\tfilter(lambda x: len(list(filter(lambda y: y in gos, goa[x]))) > 0, goa))\n\t\tif conversion is not None:\n\t\t\tgenes = [convertia[x] for x in filter(lambda x: x in convertia, genes)]\n\t\t\tgenes = list(set(list(itertools.chain.from_iterable(genes))))\n\t\tgenes = set(genes)\n\t\tgenes = list(filter(lambda x: x in genes, bg0))\n\telse:\n\t\tgenes = None\n\treturn (ans, gotop, genes)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_functional_enrichment(enrichment_file, go, remove_parents=False, only_biological_processes=False, only_slim=False, logodds_cutoff=0):\n\n #from toolbox import OboParser\n #g=OboParser.getOboGraph(\"/home/emre/arastirma/celldiff/data/GO/gene_ontology.1_2.obo\")\n g=go\n\n go_terms = None\n name = None\n name_to_go_terms ={}\n\n altid_to_goid = {}\n for goid, data in g.nodes(data=True):\n for altid in data[\"x\"]:\n altid_to_goid[altid] = goid\n\n f = open(enrichment_file)\n for line in f:\n line = line.strip()\n if line.startswith(\"# of\"):\n go_terms = set()\n elif line.startswith(\"#\"):\n if go_terms is not None: \n if name is None:\n name = \"generic\"\n if remove_parents:\n go_terms = remove_parent_terms(go_terms, g)\n name_to_go_terms[name] = go_terms\n #print name, go_terms\n name = line \n else:\n words = line.split(\"\\t\")\n try:\n n = int(words[0])\n #pval = float(words[4]) # contains text like <0.0067\n except:\n print(words)\n continue\n go_term = words[5]\n lodds = float(words[2])\n if lodds < logodds_cutoff:\n continue\n if go_term in altid_to_goid:\n go_term = altid_to_goid[go_term]\n if only_biological_processes:\n if g.node[go_term]['t'] == \"biological_process\": # and 'a' in g.node[go_term]: #is bp and slim # (\"molecular_function\", \"biological_process\"):\n if only_slim:\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\n go_terms.add(go_term)\n else:\n go_terms.add(go_term)\n else:\n if only_slim:\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\n go_terms.add(go_term)\n else:\n go_terms.add(go_term)\n\n f.close()\n\n if name is None:\n name = \"generic\"\n if remove_parents:\n go_terms = remove_parent_terms(go_terms, g)\n name_to_go_terms[name] = go_terms\n #print name, go_terms\n\n if \"generic\" in name_to_go_terms:\n return name_to_go_terms[\"generic\"]\n\n return name_to_go_terms","def find(self, egg):","def _applyGooglePatches(self):\n # Edit the base template to point users to the Google fork\n # of the Melange codebase instead of the vanilla release.\n tmpl_file = self.wc.path(\n self._branchPath('app/soc/templates/soc/base.html'))\n tmpl = io.fileToLines(tmpl_file)\n for i, line in enumerate(tmpl):\n if 'http://code.google.com/p/soc/source/browse/tags/' in line:\n tmpl[i] = line.replace('/p/soc/', '/p/soc-google/')\n break\n else:\n raise error.ExpectationFailed(\n 'No source code link found in base.html')\n io.linesToFile(tmpl_file, tmpl)\n\n self.wc.commit(\n 'Customize the Melange release link in the sidebar menu')","def mergenotes():","def go_enrichment(genelist, background_go=None, go_info=None, return_odds=False, gofile=dbpaths['goterms']):\n # if background list of GO terms is not supplied, make one:\n if background_go:\n go_obj = background_go\n else:\n go_obj = GO_maker(gofile)\n\n f_squares = [] # where the Fisher's Exact Tables will be held (and returned)\n\n god = {}\n goodds = {}\n gopval = {}\n\n for godict in go_obj.fetch_gos(genelist):\n for goterm in godict:\n try:\n god[goterm] += 1\n except KeyError:\n god[goterm] = 1\n\n for goterm in god:\n if goterm == \"GO:######\":\n continue\n dip = god[goterm]\n\n go_w_deg = dip\n go_wo_deg = len(go_obj.fetch_genes(goterm)) - dip\n nogo_w_deg = len(genelist) - dip\n nogo_wo_deg = go_obj.count_genes() - len(go_obj.fetch_genes(goterm)) - len(genelist) + dip\n\n if isinstance(go_info,dict):\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm, go_info[goterm]))\n else:\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm))\n\n verbalise(\"B\", \"Performing Fisher's Exact Test on %d squares\" % (len(f_squares)))\n for square in f_squares:\n square.fisher_test()\n\n return f_squares","def test_wr_methods(log=sys.stdout):\n # 1. Gene Ontology Enrichment Analysis\n # 1a. Initialize: Load ontologies, associations, and population gene IDs\n taxid = 10090 # Mouse study\n geneids_pop = GeneID2nt_mus.keys() # Mouse protein-coding genes\n goeaobj = get_goeaobj(\"fdr_bh\", geneids_pop, taxid)\n # 1b. Run GOEA\n geneids_study = get_geneid2symbol(\"nbt.3102-S4_GeneIDs.xlsx\")\n keep_if = lambda nt: getattr(nt, \"p_fdr_bh\") < 0.05 # keep if results are significant\n goea_results = goeaobj.run_study(geneids_study, keep_if=keep_if)\n # 2. Write results\n # Write parameters:\n # The format_string names below are the same names as in the namedtuple field_names.\n prtfmt = \"{GO} {NS} {level:>2} {depth:>2} {p_fdr_bh:5.2e} {study_count:>5} {name}\\n\"\n wr_params = {\n # Format for printing in text format\n 'prtfmt' : prtfmt, \n # Format for p-values in tsv and xlsx format\n 'fld2fmt' : {'p_fdr_bh' : '{:8.2e}'}, \n # Print a subset namedtuple fields, don't print all fields in namedtuple.\n 'prt_flds' : get_fmtflds(prtfmt) \n }\n # 2a. Use the write functions inside the GOEnrichmentStudy class.\n _wr_3fmt_goeaobj(goea_results, goeaobj, wr_params, log)\n # 2b. Use the write functions straight from the wr_tbl package to print a list of namedtuples.\n _wr_3fmt_wrtbl(goea_results, wr_params, log)\n assert filecmp.cmp('nbt3102_subset_obj.tsv', 'nbt3102_subset_nt.tsv')","def main():\n ## real SWAT tags","def enrichment_kegg(**kwargs):\n logger.setLevel(kwargs[\"logger\"])\n\n keggname = kwargs[\"kegg_name\"]\n params = {\n \"padj\": kwargs[\"padj_cutoff\"],\n \"log2_fc\": kwargs[\"log2_foldchange_cutoff\"],\n \"mapper\": kwargs[\"biomart\"],\n \"nmax\": kwargs[\"max_pathways\"],\n \"kegg_background\": kwargs[\"kegg_background\"],\n \"preload_directory\": kwargs[\"kegg_pathways_directory\"],\n \"plot_logx\": not kwargs[\"plot_linearx\"],\n \"color_node_with_annotation\": kwargs['annotation_attribute']\n }\n filename = kwargs[\"biomart\"]\n if filename and os.path.exists(filename) is False:\n logger.error(\"{} does not exists\".format(filename))\n sys.exit(1)\n filename = kwargs[\"kegg_pathways_directory\"]\n if filename and os.path.exists(filename) is False:\n logger.error(\"{} does not exists\".format(filename))\n sys.exit(1)\n\n logger.info(f\"Reading RNAdiff results from {kwargs['name']}\")\n dirpath = os.path.dirname(os.path.abspath(kwargs[\"name\"]))\n rnadiff = RNADiffResults(dirpath, index_col=0, header=[0, 1])\n\n # now that we have loaded all results from a rnadiff analysis, let us\n # perform the enrichment for each comparison found in the file\n annot_col = kwargs[\"annotation_attribute\"]\n\n padj = params[\"padj\"]\n log2fc = params[\"log2_fc\"]\n\n # setting these attributes set the gene list with log2fc and padj filter\n rnadiff._log2_fc = log2fc\n rnadiff._alpha = padj\n gene_lists = rnadiff.get_gene_lists(\n annot_col=annot_col, Nmax=kwargs.get(\"max_genes\", 1000000), dropna=True\n ) # no filter on number of genes\n\n output_directory = kwargs[\"output_directory\"]\n for compa, gene_dict in gene_lists.items():\n\n if keggname.startswith('vc'):\n logger.warning(\"Vibrio Cholera annotation old_locus_tag processed to be compatible with KEGG/Sequana\")\n if kwargs['annotation_attribute'] == 'old_locus_tag':\n def get_kegg_id(x):\n try:\n a, b = x.split(',')\n if a[0:3] == 'VC_':\n return a\n else:\n return b\n except:\n return x\n for cat in ['up', 'down', 'all']:\n gene_dict[cat] = [get_kegg_id(x) for x in gene_dict[cat]]\n old_locus_tag = rnadiff.annotation['old_locus_tag'].values\n rnadiff.annotation['old_locus_tag'] = [get_kegg_id(x) for x in old_locus_tag]\n\n config.output_dir = f\"{output_directory}/{compa}\"\n os.makedirs(f\"{output_directory}\", exist_ok=True)\n\n # we define the data and its annotation that will be used by the KEGG\n # enrichment. No need to apply any filter, we pass the entire data set\n # so that even small fold change can be shown\n df = rnadiff.comparisons[compa].df.copy()\n df = pd.concat([df, rnadiff.annotation.loc[df.index].copy()], axis=1)\n df.reset_index(inplace=True)\n\n ModuleKEGGEnrichment(\n gene_dict,\n keggname,\n df,\n enrichment_params=params,\n command=\" \".join([\"sequana\"] + sys.argv[1:]),\n )","def findInteractions( targetGenes, geneTable ):\n pass","def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\n\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\n\n print \"%-4d kegg pathways from %d DEGs\" % (len(deg_keggs), len(degs) )\n print \"%-4d kegg pathways from %d nonDEGs\" % (len(neg_keggs), len(negs) )\n\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\n pathwaytype_dict = {}\n pathway_dict = {}\n pathway_lookup = {}\n\n print \"extracting pathways...\"\n ko1_h = open(dbpaths['kegg'], 'rb')\n for line in ko1_h:\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\n pathtype_f = re.search('B.*<b>(.*)<', line)\n if pathtype_f is not None:\n pathtype = pathtype_f.group(1)\n else:\n pathtype = 'unknown'\n pathwaytype_dict[pathtype] = {}\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\n pathway_f = re.search(\"C +([0-9]*) *(.*)\\[PATH\", line)\n if pathway_f is not None:\n pathway_id = pathway_f.group(1)\n pathway_name = pathway_f.group(2)\n else:\n pathway_id = 'unknown'\n pathway_name = 'unknown'\n pathway_dict[pathway_id] = {}\n pathway_lookup[pathway_id] = pathway_name\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\n koterm_f = re.search(\"(K[0-9]*)\", line)\n if koterm_f is not None:\n koterm = koterm_f.group(1)\n else:\n koterm = 'unknown'\n pathwaytype_dict[pathtype][koterm] = 1\n pathway_dict[pathway_id][koterm] = 1\n\n\n print \"calculating enrichment...\"\n pathwaytype_ps = {}\n pathway_ps = {}\n # count number of degs and negs in each pathway:\n for pathwaytype in pathwaytype_dict:\n pwtsize = len(pathwaytype_dict)\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathwaytype_ps[pathwaytype] = pval\n\n if pval < pthresh:\n print \"%s\\n \\\n In Path Not in Path\\n\\\n DEG : %-7d %d\\n\\\n non-DEG: %-7d %d\\n\\\n Odds Ratio:%.3f\\n\\\n P-value:%.4f\\n\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\n oddrat, pval)\n\n\n for pathway in pathway_dict:\n pwtsize = len(pathway_dict)\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\n\n ## Fisher's Exact Test:\n # In Pathway: Not in Pathway:\n # DEG : degs_in_path degs_not_in\n # non-DEG : negs_in_path negs_not_in\n #\n\n return pathwaytype_ps, pathway_ps","def voorbeeld():\n os.system(\"rm Twogs.txt cogs.txt\")\n os.system(\"touch Twogs.txt cogs.txt\")\n orgslijst = [y[:-1] for y in openfile(\"orglijst.txt\") if \"\\n\" in y]\n for x in range(len(orgslijst)):\n org1 = orgslijst[x]\n for y in range(len(orgslijst)):\n org2 = orgslijst[y]\n if x > y:\n schrijfnaartwog(org1, org2)\n print(org1)\n prots, twogs, cogs = openneededfiles(org1)\n if x >= 2:\n searchforcog(cogs, twogs, prots)","def main():\n # AVAILABLE for implementation:\n # 'go_terms', 'member_databases', 'integrated', 'entry_annotations', ''\n #\n # USED:\n # basics: 'accession', 'type', 'description', 'counters', 'entry_id', 'source_database', 'name'\n # hierarchy\n # wikipedia\n # literature\n # cross_references\n # overlaps_with\n\n parser = argparse.ArgumentParser(description=\"Retrieve InterPro documents and convert them into json\")\n parser.add_argument(\"--basics\", \"-b\", action=\"store_true\", help=\"Include basic information such as accession, \"\n \"type, name, description, counters, entry_id and \"\n \"source_database\")\n parser.add_argument(\"--hierarchy\", \"-hi\", action=\"store_true\", help=\"\")\n parser.add_argument(\"--wikipedia\", \"-w\", action=\"store_true\", help=\"\")\n parser.add_argument(\"--literature\", \"-l\", action=\"store_true\", help=\"\")\n parser.add_argument(\"--cross_references\", \"-cr\", action=\"store_true\", help=\"\")\n parser.add_argument(\"--overlaps\", \"-o\", action=\"store_true\", help=\"\")\n parser.add_argument(\"dbxrefs\", nargs=argparse.REMAINDER)\n args = parser.parse_args()\n\n # if nothing specified, output all available information for the entry\n if None not in (args.basics, args.hierarchy, args.wikipedia, args.literature, args.cross_references, args.overlaps):\n args.basics = True\n args.hierarchy = True\n args.wikipedia = True\n args.literature = True\n args.cross_references = True\n args.overlaps = True\n\n dbxrefs = dbxref.resolver.convert_to_dbxrefs(args.dbxrefs)\n\n documents = retrieve(dbxrefs, basics=args.basics, hierarchy=args.hierarchy, wikipedia=args.wikipedia,\n literature=args.literature, cross_references=args.cross_references, overlaps=args.overlaps)\n print(json.dumps(documents, sort_keys=True, indent=4))","def main():\n\n # Accept up to three command-line arguments\n input_terms = \"<input_GO_terms_file>\"\n input_annotations = \"<input_gene_associations_file>\"\n output_filename = \"<output_filename>\"\n\n\n # The first two arguments are required GO terms file ending with .obo\n # and gene association GAF file ending with .gaf\n if len(sys.argv) < 3:\n sys.exit(\"Please provide required GO terms .obo file and gene \" +\n \"assocatiion .gaf file.\")\n elif not sys.argv[1].endswith(\".obo\"):\n sys.exit(\"Please provide a GO terms .obo file.\")\n elif not sys.argv[2].endswith(\".gaf\"):\n sys.exit(\"Please provide a gene association .gaf file.\")\n else:\n input_terms = sys.argv[1]\n input_annotations = sys.argv[2]\n\n\n # Check if the provided import .obo or .gaf files exist\n if not input_terms:\n sys.exit(input_terms + \" not found. Check the file path and try again.\")\n elif not input_annotations:\n sys.exit(input_annotations + \" not found. Check the file path and try again.\")\n elif len(sys.argv) == 3:\n output_filename = \"results.tsv\"\n sys.stdout = open(\"results.tsv\", \"w\")\n elif len(sys.argv) == 4:\n output_filename = sys.argv[3] + \".tsv\"\n sys.stdout = open(output_filename, \"w\")\n\n\n # parse id and is_valeus and make a go_dict\n split_input_terms = split_terms(input_terms)\n go_dict = {}\n for record in split_input_terms:\n (go_id, is_a) = parse_go_term(record)\n key_go_dict = \"\".join(go_id)\n go_dict[key_go_dict] = is_a\n\n\n # Export an annotation gene information to tsv format into the output file\n gene_association_map = map_protein_to_go(input_annotations)\n for protein, go_ids in sorted(gene_association_map.items()):\n print(protein, end=\"\")\n\n for go_id in sorted(go_ids):\n parent_go_ids = find_parent_terms(go_id, go_dict)\n\n count = 0\n for parent_go_id in sorted(parent_go_ids):\n\n if count == 0:\n print(\"\\t\", go_id, \"\\t\", parent_go_id)\n count += 1\n else:\n print(\"\\t\", parent_go_id, sep=\"\\t\")\n\n sys.stdout.close()","def get_my_mutations(quality_cutoff, coverage_cutoff):\n\n # my_mutations = {}\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\n # for line in f:\n # my_mutations[line.strip()] = True\n # return my_mutations\n\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \n 'NimbleGen Tiled Regions')\n # NimbleGen Tiled Regions\n # Target Regions\n\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\n all_somatic = {}\n all_inherited = {}\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\n for exome in global_settings.exome_types:\n data_file = use_data_dir + exome\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\n cancer_qualities, quality_cutoff,\n False, coverage_cutoff)\n # only use the bed_tools NimbleGen\n # restriction for hg18 data\n for s in somatic['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_somatic[s] = True\n for i in inherited['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_inherited[i] = True\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))","def newcogfind(ncf_cogs, ncf_twogs, ncf_prots):\n coglijst_hoogste_waarde = list(set([y.split()[0] for y in ncf_cogs]))\n werkgetal = vindhoogstecognummer(coglijst_hoogste_waarde)\n ncf_list = []\n for prot in ncf_prots:\n prot_in_twogs = zoekinlijst(prot, ncf_twogs, 1)\n posible_found_twogs = verbrogentwogs(prot, ncf_twogs, prot_in_twogs)\n if posible_found_twogs != list():\n newcog = list(set(\" \".join(posible_found_twogs).split()))\n werkgetal += 1\n for incog in newcog:\n cogzin = \"%s\\t%s\\n\" % ((\"0000000000%s\" % werkgetal)[-8:], incog)\n ncf_list.append(cogzin)\n twogremove(zoekinlijst(incog, ncf_twogs, 0), ncf_twogs)\n voegtoeaancog(ncf_list)","def test_intersection(self):\n a = pybedtools.BedTool","def main(ctx, verbose):\n return","def do_poortego_find(self, arg):\n poortego_find(self.my_interface, arg)","def generate_gem():\n resource_path = os.path.join(os.path.dirname(__file__), \"data/\")\n genome_fa = resource_path + \"tb.Human.GCA_000001405.22.fasta\"\n genome_gem_fa = resource_path + \"tb.Human.GCA_000001405.22_gem.fasta\"\n\n with gzip.open(genome_fa + '.gz', 'rb') as fgz_in:\n with open(genome_fa, 'wb') as f_out:\n f_out.write(fgz_in.read())\n\n genome_gem_idx = resource_path + \"tb.Human.GCA_000001405.22_gem.fasta.gem.gz\"\n\n input_files = {\n \"genome\": genome_fa\n }\n\n output_files = {\n \"index\": genome_gem_idx,\n \"genome_gem\": genome_gem_fa\n }\n\n metadata = {\n \"genome\": Metadata(\n \"Assembly\", \"fasta\", genome_fa, None,\n {'assembly': 'test'}),\n }\n\n print(input_files, output_files)\n\n gem_it = gemIndexerTool({\"execution\": resource_path})\n gem_it.run(input_files, metadata, output_files)","def import_various(context):\n # Only run step if a flag file is present\n if context.readDataFile('collective.opensearch-default.txt') is None:\n return\n logger = context.getLogger('collective.opensearch')\n site = context.getSite()\n pass","def main():\n ref_seq = {}\n ent_spe_sero = {}\n tag_dict = {\"Contigs_with_VP1\":\"contigs\", \"P1_sequences\":\"p1\",\n \"VP1_sequences\":\"vp1\", \"5UTR_sequences\":\"5utr\", \"3D_sequences\":\"3d\"}\n args = get_arguments()\n # Load query elements\n print(\"Load resume file\")\n (query_dict, classify_list,\n classify_specie_list, serotype_list) = get_query(args.resume_file,\n args.tag,\n args.incomplete)\n print(\"{} descriptions loaded\".format(len(query_dict)))\n # Load specie association\n if args.ent_serotype_file and args.template_seq_file:\n # Load enterovirus serotype\n print(\"Load enterovirus serotype association\")\n ent_spe_sero = load_spe_sero(args.ent_serotype_file)\n # Load template sequence\n print(\"Load template sequence\")\n ref_seq = get_template_sequence(args.template_seq_file, ent_spe_sero)\n # Grab query sequence in the database\n print(\"Load database sequence\")\n sequence_data = get_sequence(query_dict, args.fasta_file)\n print(\"{} sequences loaded\".format(len(sequence_data)))\n # Write the new fasta file\n print(\"Write the new fasta\")\n write_sequence(args.results, sequence_data, query_dict, classify_list,\n tag_dict[args.tag], ref_seq, ent_spe_sero)\n #print(save_association)\n print(\"Write the itol label\")\n write_itol_label(args.itol_dir, sequence_data, query_dict, classify_list,\n tag_dict[args.tag])\n print(\"Write the itol tree color\")\n write_itol_tree_color(args.itol_dir, sequence_data, query_dict, classify_specie_list, serotype_list,\n tag_dict[args.tag])\n print(\"Done\")","def searchforcog(sfc_cogs, sfc_twogs, sfc_prots):\n cogupdate(sfc_cogs, sfc_twogs, sfc_prots)\n newcogfind(sfc_cogs, sfc_twogs, sfc_prots)\n newtwogfile(sfc_twogs)","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('-i', '--input-ontology',\n default=config_test.config[\"msh_test_onto\"])\n parser.add_argument('-s', '--signature')\n parser.add_argument('-f', '--format-name', default=None)\n parser.add_argument('-o', '--output-file', default=\"ontology/output.owl\")\n parser.add_argument('-d', '--max-depth', default=10)\n parser.add_argument('-l', '--locality', default='top')\n\n args = parser.parse_args()\n\n g = Graph().parse(args.input_ontology, format=args.format_name)\n resource = entity_mapper.match_entity(args.signature, g)\n ontomodule = extract_module.extract_module(\n [resource], g, locality=args.locality, max_depth=args.max_depth)\n\n with open(args.output_file, \"w\") as f:\n ontomodule.serialize(f)","def do_it(args):\n\n #force = args.force\n #testing = args.testing\n #verbose = args.verbose\n #regions = args.regions\n\n # XXX WORKING HERE","def mainGA(NAME, target_output, target_image): \n global toolbox\n\n print(\"Target image: {0} Target output: {1}\".format(target_image, target_output)) \n sys.stdout.flush()\n\n model = load_model(NAME) \n fit = Fitness(NAME, model, target_image, target_output)\n\n #Genetic operators \n toolbox.register(\"evaluate\", fit.evaluate)\n toolbox.register(\"mate\", cxTwoPointCopy) \n #toolbox.register(\"mate\", cxUniform)\n toolbox.register(\"mutate\", tools.mutGaussian, mu=0.0, sigma=0.1, indpb=0.05)\n toolbox.register(\"select\", tools.selTournament, tournsize=3)\n \n\n pop = toolbox.population(n=50)\n hof = tools.HallOfFame(1, similar=np.array_equal)\n \n #stats = tools.Statistics(lambda ind: ind.fitness.values)\n #stats.register(\"avg\", np.mean)\n #stats.register(\"std\", np.std)\n #stats.register(\"min\", np.min)\n #stats.register(\"max\", np.max)\n \n pop, log = algorithms.eaSimple(pop, toolbox, cxpb=CXPB, mutpb=MUTPB, \n ngen=NGEN, halloffame=hof, \n verbose=False)\n\n return hof[0]","def import_gene_information(inputargs):\n\n global chainnams, chain\n chain = inputargs['chain']\n\n if inputargs['tags'] == \"extended\" and inputargs['species'] == \"mouse\":\n print(\"Please note that there is currently no extended tag set for mouse TCR genes.\\n\" \\\n \"Decombinator will now switch the tag set in use from \\'extended\\' to \\'original\\'.\\n\" \\\n \"In future, consider editing the script to change the default, \" \\\n \"or use the appropriate flags (-sp mouse -tg original).\")\n inputargs['tags'] = \"original\"\n\n if inputargs['tags'] == \"extended\" and (chain == 'g' or chain == 'd'):\n print(\"Please note that there is currently no extended tag set for gamma/delta TCR genes.\\n\" \\\n \"Decombinator will now switch the tag set in use from \\'extended\\' to \\'original\\'.\\n\" \\\n \"In future, consider editing the script to change the default, or use the appropriate flags.\")\n inputargs['tags'] = \"original\"\n\n # Check species information\n if inputargs['species'] not in [\"human\", \"mouse\"]:\n print(\"Species not recognised. Please select either \\'human\\' (default) or \\'mouse\\'.\\n\" \\\n \"If mouse is required by default, consider changing the default value in the script.\")\n sys.exit()\n\n # Look for tag and V/J fasta and cysteine position files: if these cannot be found in the working directory,\n # source them from GitHub repositories\n # Note that fasta/tag files fit the pattern \"species_tagset_gene.[fasta/tags]\"\n # I.e. \"[human/mouse]_[extended/original]_TR[A/B/G/D][V/J].[fasta/tags]\"\n\n for gene in ['v', 'j']:\n # Get FASTA data\n fasta_file = read_tcr_file(inputargs['species'], inputargs['tags'], gene, \"fasta\", inputargs['tagfastadir'])\n globals()[gene + \"_genes\"] = list(SeqIO.parse(fasta_file, \"fasta\"))\n\n globals()[gene + \"_regions\"] = [str( item.seq.upper()) for item in globals()[gene + \"_genes\"]]\n globals()[gene + \"_names\"] = [str(item.id.upper().split(\"|\")[1]) for item in globals()[gene + \"_genes\"]]\n\n # Get conserved translation residue sites and functionality data\n translation_file = open(read_tcr_file(inputargs['species'], inputargs['tags'], gene, \"translate\",\n inputargs['tagfastadir']),\"rt\")\n translate_data = [x.rstrip() for x in list(translation_file)]\n\n globals()[gene + \"_translate_position\"] = [int(x.split(\",\")[1]) for x in translate_data]\n globals()[gene + \"_translate_residue\"] = [x.split(\",\")[2] for x in translate_data]\n globals()[gene + \"_functionality\"] = [x.split(\",\")[3] for x in translate_data]\n\n if gene == 'v':\n \n if inputargs['species'] == \"human\":\n # Get germline CDR data\n cdr_file = open(read_tcr_file(inputargs['species'], inputargs['tags'], gene, \"cdrs\", inputargs['tagfastadir']), \"rt\")\n cdr_data = [x.rstrip() for x in list(cdr_file)]\n cdr_file.close()\n v_cdr1 = [x.split(\" \")[1] for x in cdr_data]\n v_cdr2 = [x.split(\" \")[2] for x in cdr_data]\n else:\n # cdr_file only exists for human - CDR1 and CDR2 only written to output tsv\n # for human. Otherwise create empty lists fo v_cdr1 and v_cdr2, to write empty\n # fields to output tsv\n v_cdr1 = [\"\"]*len(globals()[gene + \"_genes\"])\n v_cdr2 = [\"\"]*len(globals()[gene + \"_genes\"])\n\n return v_regions, j_regions, v_names, j_names, v_translate_position, v_translate_residue, \\\n j_translate_position, j_translate_residue, v_functionality, j_functionality, v_cdr1, v_cdr2","def g_n():\n for gname in os.listdir(sroot):\n if gname != 's1-league1-game1':\n continue\n if gname.startswith('s1'):\n p0 = os.path.join(sroot, gname)\n p1 = os.path.join(p0, 'commitment', 'jperret')\n p2 = os.path.join(p0, 'commitment', 'sa')\n if os.path.isdir(p1) and os.path.isdir(p2):\n for fname in os.listdir(p1):\n if fname.endswith('.aa'):\n bname = fname[:-3]\n #~ if bname == 's1-league1-game2_07':\n #~ continue\n a = ad.Annotations(os.path.join(p1, fname))\n a.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\n a.gen_full_struct()\n a.commitments = list(u for u in a.units if u.type == 'Commitment')\n a2 = ad.Annotations(os.path.join(p2, fname))\n a2.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\n a2.gen_full_struct()\n a2.commitments = list(u for u in a2.units if u.type == 'Commitment')\n yield bname, (a, a2)","def run_fenrichment(args):\n filter_enrichment(args)","def main():\n logging.getLogger(\"dance\").setLevel(logging.DEBUG)\n logging.getLogger(\"dance\").addHandler(logging.StreamHandler(sys.stderr))\n\n def relevant_if_has_t142(mol: oechem.OEMol):\n params = smirnoff_param_utils.read_params_from_mol(mol)\n return \"t142\" in params\n\n def size_and_wbo_fingerprint(mol: oechem.OEMol):\n \"\"\"Fingerprint with number of atoms in the mol and WBO between central atoms in the t142 param.\n\n (WBO is Wiberg Bond Order.)\n\n Note: The indices are the same in OpenEye and OFF molecules, so the\n parameter indices are correct, even though they were calculated for the\n OFF mol.\n \"\"\"\n oechem.OEAddExplicitHydrogens(mol)\n params = smirnoff_param_utils.read_params_from_mol(mol)\n return (\n mol.NumAtoms(),\n smirnoff_param_utils.calculate_t142_central_wbo(mol, params),\n )\n\n config = {\n \"database_type\": \"OEB\",\n \"database_info\": \"combined_molecules_with_parameters.oeb\",\n \"relevance_function\": relevant_if_has_t142,\n \"filter_output_oeb\": \"results/filter_output.oeb\",\n \"fingerprint_function\": size_and_wbo_fingerprint,\n \"fingerprint_output_oeb\": \"results/fingerprint_output.oeb\",\n \"selection_frequency\": 375, # To select ~20 molecules.\n \"dataset_type\": \"OEB\",\n \"dataset_info\": \"results/dataset.oeb\",\n \"sorted_by_fingerprint_oeb\": \"results/sorted_by_fingerprint.oeb\",\n \"in_memory_sorting_threshold\": 25000,\n \"tmpdir\": \"results/tmp\",\n }\n\n run_dance(config)","def main():\n LESSONS_PATH = os.path.join(LESSON_LOCATOR_DATA, LESSON_SETS[0])\n ORIGINAL_LESSONS_PATH = os.path.join(LESSONS_PATH, \"original\")\n ANNOTATED_LESSONS_PATH = os.path.join(LESSONS_PATH, \"annotated\")\n\n if not os.path.exists(ANNOTATED_LESSONS_PATH):\n os.mkdir(ANNOTATED_LESSONS_PATH)\n\n print(\"Scanning original lessons in %s...\" % ORIGINAL_LESSONS_PATH)\n\n for item in os.listdir(ORIGINAL_LESSONS_PATH):\n if item == \".DS_Store\": continue\n\n print(\" found: %s\" % item)\n\n item_path = os.path.join(ORIGINAL_LESSONS_PATH, item)\n\n lesson_number = None\n lesson_description = None\n mobj = re.search(r'^AY\\s+(\\d+)\\s*-\\s*(.+)\\.txt$', item)\n if mobj:\n lesson_number = mobj.group(1)\n lesson_description = mobj.group(2)\n\n print(\" number: %s\" % lesson_number)\n print(\" description: %s\" % lesson_description)\n\n lesson = dict()\n lesson['number'] = lesson_number\n lesson['description'] = lesson_description\n\n fh = open(item_path)\n lesson_raw_text = fh.read()\n fh.close()\n lesson_text = re.split(r'\\n', lesson_raw_text)\n# lesson_raw_text_reencoded = lesson_raw_text.decode('mac-roman').encode('utf-8')\n# lesson_text = re.split(r'\\n', lesson_raw_text_reencoded)\n\n lesson['text'] = lesson_text\n lesson['parsed'] = parseLesson(lesson_text)\n\n if lesson['parsed']['end_of_lesson'] is None:\n print(\" lesson has no 'end of lesson' marker\")\n\n lesson_json = json.dumps(lesson, indent=4)\n annotated_lesson_path = os.path.join(ANNOTATED_LESSONS_PATH, \"ay_%04d.json\" % int(lesson_number))\n fh = open(annotated_lesson_path, \"w\")\n fh.write(lesson_json)\n fh.close()\n\n else:\n print(\"ERROR: File name not understood: %s\" % item)\n\n return 0","def main():\n get_obofoundry(force_download=True)","def get_clarifications_winogrande(ex, nlp, comet_model):\n personx, persony = ex['option1'], ex['option2']\n\n # Only extract relations for people\n if personx[0] != personx[0].upper() or persony[0] != persony[0].upper():\n return []\n\n input_event = ex[\"sentence\"]\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\n\n curr_events = []\n for category, prefix in CATEGORY_TO_PREFIX.items():\n for out_event in outputs[category]:\n if out_event != \"none\" and out_event != \"\":\n if not out_event.lower().startswith(\"person\") and not out_event.lower().startswith(\"other\"):\n out_event = \" \".join((prefix, out_event))\n\n out_event = re.sub(\"personx\", personx, out_event, flags=re.I)\n out_event = re.sub(\"person x\", personx, out_event, flags=re.I)\n out_event = re.sub(\"persony\", persony, out_event, flags=re.I)\n out_event = re.sub(\"person y\", persony, out_event, flags=re.I)\n\n question = CATEGORY_TO_QUESTION[category].replace(\"PersonX\", personx)\n curr_events.append((question, out_event))\n\n return curr_events","def load_ocsge(ctx, item):\n connecter = ScalingoInterface(ctx.obj)\n connecter.manage_py(\"load_ocsge --no-verbose\", **{\"item\": item})","def help():\n description = \"\"\"\n Get the observed and expected enrichment trend plot based on contact matrix.\n Example:\n getSigEnrich.py -d GM12878_Trac -o GM12878_Trac -cut 0 -p 10 \n \"\"\"\n parser = argparse.ArgumentParser(description=description,\n formatter_class=RawTextHelpFormatter)\n parser.add_argument(\"-d\",\n dest=\"dir\",\n required=True,\n type=str,\n help=\"Directory for cLoops2 pre generated.\")\n parser.add_argument(\"-o\",\n dest=\"output\",\n required=True,\n type=str,\n help=\"Output prefix.\")\n parser.add_argument(\n \"-c\",\n dest=\"chroms\",\n required=False,\n default=\"\",\n type=str,\n help=\n \"Whether to process limited chroms, specify it as chr1,chr2,chr3, default is not. Use this to save time for quite big data.\"\n )\n parser.add_argument(\n \"-bs\",\n dest=\"binSize\",\n required=False,\n default=5000,\n type=int,\n help=\n \"Bin size (bp) to generate the contact matrix for estimation, default is 5000 bp.\"\n )\n parser.add_argument(\n \"-cut\",\n dest=\"cut\",\n type=int,\n default=0,\n help=\"Distance cutoff for PETs to filter, default is 0.\")\n parser.add_argument('-p',\n dest=\"cpu\",\n required=False,\n default=1,\n type=int,\n help=\"Number of CPUs to run the job, default is 1.\")\n parser.add_argument(\n '-r',\n dest=\"repeats\",\n required=False,\n default=10,\n type=int,\n help=\n \"The reapet times to shuffle PETs to get the mean expected background,default is 10.\"\n )\n parser.add_argument('-plot',\n dest=\"plot\",\n required=False,\n action=\"store_true\",\n help=\"Set to plot the result.\")\n op = parser.parse_args()\n return op","def main():\n mock_uri = ''\n inventory = fetch_inventory(SphinxApp, mock_uri,\n OBJECT_INVENTORY_RELPATH)\n sphinx_mods = set(inventory['py:module'].keys())\n\n library_dir = os.path.join(BASE_DIR, 'gcloud')\n public_mods = get_public_modules(library_dir,\n base_package='gcloud')\n public_mods = set(public_mods)\n\n if not sphinx_mods <= public_mods:\n unexpected_mods = sphinx_mods - public_mods\n message = ['Unexpected error. There were modules referenced by '\n 'Sphinx that are not among the public modules.']\n message.extend(['- %s' % (mod,) for mod in unexpected_mods])\n print('\\n'.join(message), file=sys.stderr)\n sys.exit(1)\n\n undocumented_mods = public_mods - sphinx_mods\n # Remove ignored modules.\n undocumented_mods -= IGNORED_MODULES\n if undocumented_mods:\n message_parts = ['Found undocumented public modules:']\n message_parts.extend(['- ' + mod_name\n for mod_name in sorted(undocumented_mods)])\n print('\\n'.join(message_parts), file=sys.stderr)\n sys.exit(1)","def main():\n print(get_advice())","def composeWorkplaceOntology():\n\n import ossPyFuncs \n import pandas as pd\n \n #mysql query to extract full table from government organizations\n #certian table columns feature capital letters which cases uproblems\n postgreSql_selectQuery=\"SELECT * FROM us_gov_manual.us_govman_2019 ;\"\n #pass querry and obtain table\n govTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n\n #mysql query to obtain academic instutions\n postgreSql_selectQuery=\"SELECT institution FROM hipolabs.universities ;\"\n #pass querry and obtain table\n univTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2018_us1000;\"\n businesses1=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2019_us1000;\"\n businesses2=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2020_global2000;\"\n businesses3=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n\n #combine theinsitutions into a vector\n combinedSeries=[govTable['AgencyName'],univTable['institution'],businesses1['company'],businesses2['company'],businesses3['company']]\n #turn the multi item vector into a single series\n fullWordbank=pd.concat(combinedSeries)\n #turn that series into a pd dataframe\n wordbankTable=pd.DataFrame(fullWordbank.unique())\n\n return wordbankTable","def explore(self, *args):","def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\n tmpl_out_path, null_charges=False, growing_mode=\"SoftcoreLike\"):\n lambda_to_reduce = float(step/(total_steps+1))\n templ_ini = TemplateImpact(template_initial_path)\n \n for bond in templ_ini.list_of_bonds:\n key, bond_cont = bond\n templ_grw = TemplateImpact(template_grown_path)\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \n template_grown=templ_grw,\n hydrogen_to_replace=hydrogen_to_replace)\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\n set_linker_bond(templ_grw)\n if growing_mode == \"SoftcoreLike\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\n null_charges=null_charges)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \n null_charges=null_charges)\n \n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"AllLinear\":\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\n null_charges=False)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n elif growing_mode == \"SpreadHcharge\":\n if step > 1:\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\n else:\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \n hydrogen=hydrogen_to_replace, n_GS=total_steps)\n else:\n raise ValueError(\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\")\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\n [atom.pdb_atom_name for atom in core_atoms_grown]","def get_doc_prov(j, gcis_url, refList, orgList):\n doc = ProvEsDocument()\n \n org = requests.get(j['href']).json()\n \n doc_attrs = [\n (\"prov:type\", 'gcis:organization'),\n (\"prov:label\", j['name']),\n (\"prov:location\", \"%s%s\"%(gcis_url, j['uri'])),\n (\"gcis:organization_type_identifier\", j['organization_type_identifier']),\n (\"gcis:country_code\", j['country_code']),\n ]\n orgID = 'bibo:%s' % j['identifier']\n doc.agent(orgID, doc_attrs)\n\n for child in org['children']:\n cOrgURI = child['organization']\n rel = child['relationship']\n\n cOrg = next(o for o in orgList if o['uri'] == cOrgURI)\n cOrgID = 'bibo:%s'%cOrg['identifier']\n\n #cOrgAttrs = [\n # (\"prov:type\", 'gcis:organization'),\n # (\"prov:label\", cOrg['name']),\n # (\"prov:location\", cOrg['uri']),\n # (\"gcis:organization_type_identifier\", cOrg['organization_type_identifier']),\n # (\"gcis:country_code\", cOrg['country_code']),\n # ]\n #doc.entity(cOrgID, cOrgAttrs)\n #doc.hadMember(orgID, cOrgID)\n #for parent in org['parents']:\n # pOrgURI = parent['organization']\n # rel = parent['relationship']\n # pOrg = next(o for o in orgList if o['uri'] == pOrgURI)\n # pOrgID = 'bibo:%s'%pOrg['identifier']\n # doc.hadMember(pOrgID, orgID)\n\n prov_json = json.loads(doc.serialize())\n\n return prov_json","def script(self):","def OLDfindMatchingStyleReport(self,TargetOG=1.037,TargetFG=1.011, TargetIBU=48.2, TargetSRM=7):\n\t\n\t\thideNegative=1\n\t\textendedText=0\n\n\t\tself.cleanupXML(\"styleguide2008.xml\")\t\n\t\tTog=TargetOG\n\t\tTfg=TargetFG\n\t\tTibu=TargetIBU\n\t\tTsrm=TargetSRM\n\t\tbeerstyles={}\n\t\txmldoc = minidom.parse(\".styleguide2008.xml.tmp\")\n\t\tsg = xmldoc.childNodes[2]\n\n\t\td=None\n\n\n\n\t\tfor c in sg.childNodes[1].childNodes:\n\t\t#\tprint c\n\t\t\tD=d\n\t\t\tfor d in c.childNodes:\n\t\t#\t\tprint d\t\n\t\t\t\ttry:\n\t\t\t\t\tbeerstyle= d.getElementsByTagName('name')[0].firstChild.data\t\n\t\t\t\t\tbeerstyles[beerstyle]={ \t'xml': d,\t'substyles' : {} }\n\t\t\t\t\n\n\t\t\t\texcept:\n\t\t\t\t\tpass\n\t\t\t\n\t\t#\n\n\t\tprint \"There are %s beer styles in the database.\" %(len(beerstyles))\n\t\tprint \" searching for;\"\n\t\tprint \" original gravity %s\" %(Tog)\n\t\tprint \" final gravity %s\" %(Tfg)\n\t\tprint \" target IBU %s\" %(Tibu)\n\t\tprint \" target SRM %s\" %(Tsrm)\n\n\n\t\tresults={}\n\t\tscores=[]\n\t\tscoreResultMap={}\n\n\n\t\tfor style in beerstyles:\n\t\t\tsubstyle= beerstyles[style]['xml'].getElementsByTagName('name')[0].firstChild.data\n\n\t\t\tscore=0\n\n\t\t\tbeerstyles[style]['substyles'][substyle] = {}\n\t\t\tstats= beerstyles[style]['xml'].getElementsByTagName('stats')[0]\n\n\t\t\tog=stats.getElementsByTagName('og')\n\t\t\tfg=stats.getElementsByTagName('fg')\n\t\t\tibu=stats.getElementsByTagName('ibu')\n\t\t\tsrm=stats.getElementsByTagName('srm')\n\n\t\t\ttry:\n\t\t\t\toglow=og[0].getElementsByTagName('low')[0].firstChild.data\n\t\t\t\toghigh=og[0].getElementsByTagName('high')[0].firstChild.data\n\t\t\texcept:\n\t\t\t\toglow=-1\n\t\t\t\toghigh=-1\n\t\t\ttry:\n\t\t\t\tfglow=fg[0].getElementsByTagName('low')[0].firstChild.data\n\t\t\t\tfghigh=fg[0].getElementsByTagName('high')[0].firstChild.data\n\t\t\texcept:\n\t\t\t\tfglow=-1\n\t\t\t\tfghigh=-1\n\t\t\ttry:\n\t\t\t\tibulow=ibu[0].getElementsByTagName('low')[0].firstChild.data\n\t\t\t\tibuhigh=ibu[0].getElementsByTagName('high')[0].firstChild.data\n\t\t\texcept:\n\t\t\t\tibulow=-1\n\t\t\t\tibuhigh=-1\n\n\t\t\ttry:\n\t\t\t\tsrmlow=srm[0].getElementsByTagName('low')[0].firstChild.data\n\t\t\t\tsrmhigh=srm[0].getElementsByTagName('high')[0].firstChild.data\n\t\t\texcept:\n\t\t\t\tsrmlow=-1\n\t\t\t\tsrmhigh=-1\n\n\n\t\t\t#############################################################################################################\n\t\t\t# Checking Range of Gravity's and giving score\n\t\t\t\n\t\t\tscoreOg=0\n\t\t\tscoreFg=0\n\t\t\tscoreIbu=0\t\n\t\t\tscoreSrm=0\n\t\t\tif Tog < float(oglow) and Tog > float(oghigh):\n\t\t\t\tscoreOg=0\t\t\t\t\t\t# Original Gravity Out Of Range\n\t\t\telif Tog < float(oglow) and Tog <= float(oghigh):\t\t\n\t\t\t\tscoreOg=5\t\t\t\t\t\t# Original Gravity Not Higher\n\t\t\telif Tog >= float(oglow) and Tog > float(oghigh):\t\n\t\t\t\tscoreOg=5\t\t\t\t\t\t# Original Gravity Not Lower\n\t\t\telse:\n\t\t\t\tscoreOg=20\t\t\t\t\t\t# Original Gravity in range\n\n\t\t\t# FG\n\t\t\tif Tfg < float(fglow) and Tfg > float(fghigh):\n\t\t\t\tscoreFg=0\t\t\t\t\t\t# Original Gravity Out Of Range\n\t\t\telif Tfg < float(fglow) and Tfg <= float(fghigh):\t\t\n\t\t\t\tscoreFg=5\t\t\t\t\t\t# Original Gravity Not Higher\n\t\t\telif Tfg >= float(fglow) and Tfg > float(fghigh):\t\n\t\t\t\tscoreFg=5\t\t\t\t\t\t# Original Gravity Not Lower\n\t\t\telse:\n\t\t\t\tscoreFg=20\t\t\t\t\t\t# Original Gravity in range\n\t\t\t\n\n\t\t\t# IBU\n\t\t\tif Tibu < float(ibulow) and Tibu > float(ibuhigh):\n\t\t\t\tscoreIbu=0\t\t\t\t\t\t# Original Gravity Out Of Range\n\t\t\telif Tibu < float(ibulow) and Tibu <= float(ibuhigh):\t\t\n\t\t\t\tscoreIbu=9\t\t\t\t\t\t# Original Gravity Not Higher\n\t\t\telif Tibu >= float(ibulow) and Tibu > float(ibuhigh):\t\n\t\t\t\tscoreIbu=9\t\t\t\t\t\t# Original Gravity Not Lower\n\t\t\telse:\n\t\t\t\tscoreIbu=40\t\t\t\t\t\t# Original Gravity in range\n\t\t\t\n\n\t\t\t# SRM\n\t\t\tif Tsrm < float(srmlow) and Tsrm > float(srmhigh):\n\t\t\t\tscoreSrm=0\t\t\t\t\t\t# Original Gravity Out Of Range\n\t\t\telif Tsrm < float(srmlow) and Tsrm <= float(srmhigh):\t\t\n\t\t\t\tscoreSrm=6\t\t\t\t\t\t# Original Gravity Not Higher\n\t\t\telif Tsrm >= float(srmlow) and Tsrm > float(srmhigh):\t\n\t\t\t\tscoreSrm=6\t\t\t\t\t\t# Original Gravity Not Lower\n\t\t\telse:\n\t\t\t\tscoreSrm=30\t\t\t\t\t\t# Original Gravity in range\n\t\t\t\n\n\t\t\ttry:\n\t\t\t\tsys.stderr.write(\"%s/%s score=%s scoreOg=%s scoreFg=%s scoreIbu=%s scoreSrm=%s\\n\" %(style,substyle,scoreOg+scoreFg+scoreIbu+scoreSrm,scoreOg,scoreFg,scoreIbu,scoreSrm))\t\n\t\t\t\tresults[ (style,substyle) ] = {'og': (float(oglow),float(oghigh)), 'fg': (float(fglow),float(fghigh)), 'ibu' : (float(ibulow),float(ibuhigh)), 'srm':(float(srmlow),float(srmhigh)), 'xml':beerstyles[style]['xml']}\n\n\t\t\t\tscore=(scoreSrm+scoreIbu+scoreOg+scoreFg)*100\n\t\t\t\tif not scoreResultMap.has_key( score ):\n\t\t\t\t\tscoreResultMap[ score ] = []\n\t\t\t\t\tscores.append(score)\n\t\t\t\tscoreResultMap[ score ].append( (style,substyle) )\n\t\t\texcept:\n\t\t\t\tpass\n\t\t\t\n\t\tscores.sort()\n\t\tscores.reverse()\n\t\tsys.stderr.write(\"\\n\")\n\t\tsys.stderr.write(\"\\n\")\n\t\tsys.stderr.write(\"\\n\")\n\n\n\t\tprint \n\t\tprint\n\t\tfor score in scores:\n\t\t\tsubscores=[]\n\t\t\tsubscoreMap={}\n\t\t\t# a better scoring mechanism that applies within the group rather than outside the grouping\n\t\t\tfor (style,substyle) in scoreResultMap[ score ]:\n\t\t\t\t(oglow,oghigh) = results[ (style,substyle) ]['og']\n\t\t\t\togmid = ((oghigh-oglow)/2)+oglow\n\t\t\t\togdelta = pow( (100-(ogmid/Tog)*100), 6)\n\t\t\t\t(fglow,fghigh) = results[ (style,substyle) ]['fg']\n\t\t\t\tfgmid = ((fghigh-fglow)/2)+fglow\n\t\t\t\tfgdelta = pow( (100-(fgmid/Tfg)*100), 6)\n\t\t\t\t(ibulow,ibuhigh) = results[ (style,substyle) ]['ibu']\n\t\t\t\tibumid = ((ibuhigh-ibulow)/2)+ibulow\n\t\t\t\tibudelta = pow( (10-(ibumid/Tibu)*10), 6)\n\t\t\t\t(srmlow,srmhigh) = results[ (style,substyle) ]['srm']\n\t\t\t\tsrmmid = ((srmhigh-srmlow)/2)+srmlow\n\t\t\t\tsrmdelta = pow( (5-(srmmid/Tsrm)*5), 6)\n\n\t\t\t\tsubscore=score-ogdelta-fgdelta-ibudelta-srmdelta\n\t\t\t\tif not subscoreMap.has_key(subscore):\n\t\t\t\t\tsubscores.append(subscore)\t\n\t\t\t\t\tsubscoreMap[subscore] =[]\n\t\t\t\tsubscoreMap[subscore].append( (style,substyle,ogdelta,fgdelta,ibudelta,srmdelta))\n\n\t\t\tsubscores.sort()\n\t\t\tsubscores.reverse()\n\t\t\tfor Ssubscore in subscores:\n\t\t\t\tfor (Sstyle,Ssubstyle,Sogdelta,Sfgdelta,Sibudelta,Ssrmdelta) in subscoreMap[ Ssubscore ]:\n\t\t\t\n\t\t\t\t\tif (hideNegative\t and Ssubscore >= 0) or not hideNegative:\n\t\t\t\t\t\tprint \"Style: %s; SubStyle: %s;\" %(Sstyle,Ssubstyle)\n\t\t\t\t\t\tprint \"Score: %s (basescore:%s og:%f.4 fg:%f.4 ibu:%f.4 srm:%f.4)\" %(Ssubscore,score,Sogdelta,Sfgdelta,Sibudelta,Ssrmdelta)\n\t\t\t\t\t\ttry:\n\t\t\t\t\t\t\t(oglow,oghigh) = results[ (Sstyle,Ssubstyle) ]['og']\n\t\t\t\t\t\t\tprint \" Original Gravity: %s----%s (Target %s)\" %(oglow,oghigh,Tog)\n\t\t\t\t\t\t\t(fglow,fghigh) = results[ (Sstyle,Ssubstyle) ]['fg']\n\t\t\t\t\t\t\tprint \" Final Gravity: %s----%s (Target %s)\" %(fglow,fghigh,Tfg)\n\t\t\t\t\t\t\t(ibulow,ibuhigh) = results[ (Sstyle,Ssubstyle) ]['ibu']\n\t\t\t\t\t\t\tprint \" International Bittering Units: %s----%s (Target %s)\" %(ibulow,ibuhigh,Tibu)\n\t\t\t\t\t\t\t(srmlow,srmhigh) = results[ (Sstyle,Ssubstyle) ]['srm']\n\t\t\t\t\t\t\tprint \" SRM: %s----%s (Target %s)\" %(srmlow,srmhigh,Tsrm)\n\n\t\t\t\t\t\t\tif extendedText:\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Aroma\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('aroma')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Ingredients\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('ingredients')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Flavor\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('flavor')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"MouthFeel\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('mouthfeel')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Impression\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('impression')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Comments\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('comments')[0].firstChild.data)\n\t\t\t\t\t\t\t\tprint self._tidyText(\"Example\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('examples')[0].firstChild.data)\n\t\t\t\t\t\texcept:\n\t\t\t\t\t\t\tpass\n\n\t\t\t\t\t\tprint \n\t\t\t\t\t\tprint","def limk2_gene_context():\n return {\n \"id\": \"normalize.gene:LIMK2\",\n \"type\": \"GeneDescriptor\",\n \"label\": \"LIMK2\",\n \"gene_id\": \"hgnc:6614\",\n \"xrefs\": [\n \"ncbigene:3985\",\n \"ensembl:ENSG00000182541\"\n ],\n \"extensions\": [\n {\n \"type\": \"Extension\",\n \"name\": \"symbol_status\",\n \"value\": \"approved\"\n },\n {\n \"name\": \"approved_name\",\n \"value\": \"LIM domain kinase 2\",\n \"type\": \"Extension\"\n },\n {\n \"type\": \"Extension\",\n \"name\": \"associated_with\",\n \"value\": [\n \"refseq:NM_016733\",\n \"ccds:CCDS33637\",\n \"ccds:CCDS13892\",\n \"ena.embl:D45906\",\n \"uniprot:P53671\",\n \"pubmed:10591208\",\n \"vega:OTTHUMG00000151251\",\n \"omim:601988\",\n \"iuphar:2055\",\n \"pubmed:8537403\",\n \"ccds:CCDS13891\",\n \"ucsc:uc003akh.4\"\n ]\n },\n {\n \"type\": \"Extension\",\n \"name\": \"hgnc_locations\",\n \"value\": [\n {\n \"_id\": \"ga4gh:VCL.IoyhTh4PxvPx8yF9P3IecXDVs_XVbDe9\",\n \"type\": \"ChromosomeLocation\",\n \"species_id\": \"taxonomy:9606\",\n \"chr\": \"22\",\n \"interval\": {\n \"end\": \"q12.2\",\n \"start\": \"q12.2\",\n \"type\": \"CytobandInterval\"\n }\n }\n ]\n },\n {\n \"type\": \"Extension\",\n \"name\": \"ensembl_locations\",\n \"value\": [\n {\n \"_id\": \"ga4gh:VSL.Mat3OiuXCd7vNWAGB5lOKaSf_ESc_xK9\",\n \"type\": \"SequenceLocation\",\n \"sequence_id\": \"ga4gh:SQ.7B7SHsmchAR0dFcDCuSFjJAo7tX87krQ\",\n \"interval\": {\n \"start\": {\"type\": \"Number\", \"value\": 31212238},\n \"end\": {\"type\": \"Number\", \"value\": 31280080},\n \"type\": \"SequenceInterval\"\n }\n }\n ]\n },\n {\n \"type\": \"Extension\",\n \"name\": \"ncbi_locations\",\n \"value\": [\n {\n \"_id\": \"ga4gh:VCL.IoyhTh4PxvPx8yF9P3IecXDVs_XVbDe9\",\n \"type\": \"ChromosomeLocation\",\n \"species_id\": \"taxonomy:9606\",\n \"chr\": \"22\",\n \"interval\": {\n \"end\": \"q12.2\",\n \"start\": \"q12.2\",\n \"type\": \"CytobandInterval\"\n }\n },\n {\n \"_id\": \"ga4gh:VSL.N1dI0SlDciU-8OsmdjEfSKdVDp-Q5_lf\",\n \"type\": \"SequenceLocation\",\n \"sequence_id\": \"ga4gh:SQ.7B7SHsmchAR0dFcDCuSFjJAo7tX87krQ\",\n \"interval\": {\n \"start\": {\"type\": \"Number\", \"value\": 31212297},\n \"end\": {\"type\": \"Number\", \"value\": 31280080},\n \"type\": \"SequenceInterval\"\n }\n }\n ]\n },\n {\n \"type\": \"Extension\",\n \"name\": \"hgnc_locus_type\",\n \"value\": \"gene with protein product\"\n },\n {\n \"type\": \"Extension\",\n \"name\": \"ncbi_gene_type\",\n \"value\": \"protein-coding\"\n },\n {\n \"type\": \"Extension\",\n \"name\": \"ensembl_biotype\",\n \"value\": \"protein_coding\"\n }\n ]\n }","def GoAnnot(prots, gos, onlyProts=False):\r\n with resources.open_text(\"autoprot.data\",\"Homo_sapiens.gene_info\") as d:\r\n geneInfo = pd.read_csv(d, sep='\\t')\r\n with resources.open_text(\"autoprot.data\",\"gene2go_alt\") as d:\r\n gene2go = pd.read_csv(d, sep='\\t')\r\n prots = pd.DataFrame(pd.Series([str(i).upper().split(';')[0] for i in prots]), columns=[\"Gene names\"])\r\n prots = prots.merge(geneInfo[[\"Symbol\", \"GeneID\"]], left_on=\"Gene names\", right_on=\"Symbol\", how='inner')\r\n \r\n prots = prots.merge(gene2go[[\"GeneID\", \"GO_ID\", \"GO_term\"]], on=\"GeneID\", how='inner')\r\n if onlyProts == True:\r\n for idx, go in enumerate(gos):\r\n if idx == 0:\r\n redProts = prots[\"Symbol\"][prots[\"GO_term\"].str.contains(go)]\r\n else:\r\n redProts = redProts.append(prots[\"Symbol\"][prots[\"GO_term\"].str.contains(go)])\r\n return redProts.drop_duplicates()\r\n else: \r\n for idx, go in enumerate(gos):\r\n if idx == 0:\r\n redProts = prots[prots[\"GO_term\"]==go]\r\n else:\r\n redProts = redProts.append(prots[prots[\"GO_term\"]==go])\r\n return redProts.drop_duplicates()","def substantiate():","def goopy():\n # Start timer:\n start = time()\n\n parser = GooeyParser(prog=\"AutoCAT\", description=f\"\\n{PROG_DESC}\")\n\n # Accept argument for the vendor's email address:\n parser.add_argument(\n \"Vendor\", action=\"store\", type=str, help=\"Vendor's email address:\"\n )\n\n # Grab user's input:\n args = parser.parse_args()\n email_input = args.Vendor\n\n # [CHECK] Validation for Vendor Emails:\n if (not validators.email(email_input)):\n print(\"Vendor field may only contain email addresses!\")\n raise ValueError\n\n print(\"\\nLaunching Approval Process . . .\")\n\n # Initialize our WebDriver + Procedures classes:\n driver = MyWebDriver().initialize_driver()\n approve = ApproveVendorProcess(driver)\n\n # Run all procedures:\n approve.run_all(email_input)\n delta = round(time() - start, 3)\n print(f\"\\n ---- Completed in {delta} seconds total. ----\")","def find_enstools_packages():\n\n return [f'enstools.{p}' for p in (find_packages(f'{os.path.dirname(__file__)}/enstools'))]","def main():\n\n obj_lookup = interfaces_dir / \"FrameLib-obj-jlookup.json\"\n\n worker = jParseAndBuild()\n\n refpages = [x for x in refpages_dir.rglob(\"fl.*.xml\")]\n\n for ref in refpages:\n worker.extract_from_refpage(ref)\n\n write_json(obj_lookup, worker.j_master_dict)","def _getJetBuildTool2(merge_param,\n ptmin,\n ptminFilter,\n jet_calib,\n cluster_calib,\n concrete_type,\n do_minimalist_setup,\n do_substructure,\n iParticleRejectionTool,\n name='',\n secondary_label='',\n trkopt = '',\n outputLabel='',\n OutputLevel=INFO,\n fromJet=False\n ):\n\n # declare jtm as global as this function body may modify it\n # with the += operator\n global jtm\n\n msg = 'Naming convention breaks with merge param %d' % merge_param\n int_merge_param = int(10 * merge_param)\n assert 10 * merge_param == int_merge_param, msg\n\n assert merge_param > 0.\n\n # Ensure the calibration is valid\n _is_calibration_supported(int_merge_param, jet_calib, cluster_calib)\n\n # in situ calibration step is only for data, not MC\n # this string here allows the following code to be data/MC unaware\n inSitu = 'i' if _getIsData() else ''\n \n # tell the offline code which calibration is requested\n calib_str = {'jes': 'calib:j:triggerNoPileup:HLTKt4',\n 'subjes': 'calib:aj:trigger:HLTKt4',\n 'sub': 'calib:a:trigger:HLTKt4',\n 'subjesIS': 'calib:ajg%s:trigger2016:HLTKt4'%(inSitu)}.get(jet_calib, '')\n\n # with S Schramm very early 18/4/2016\n mymods = [jtm.jetens]\n if calib_str: mymods.append(calib_str)\n if not fromJet: mymods.append(jtm.caloqual_cluster)\n if outputLabel!='triggerTowerjets': #towers don't have cluster moments\n mymods.append(jtm.clsmoms)\n if secondary_label == 'GhostTrack': # ghost track association expected, will want track moments.\n if not hasattr(jtm, 'trkmoms_'+trkopt):\n print (\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no track moment tools configured. Continuing without trkmodifers.\")\n else: \n trkmoms_ghosttrack = getattr(jtm, 'trkmoms_'+trkopt)\n trkmoms_ghosttrack.unlock()\n trkmoms_ghosttrack.AssociatedTracks = secondary_label\n trkmoms_ghosttrack.lock()\n mymods.append(trkmoms_ghosttrack)\n if not hasattr(jtm, 'jvf_'+trkopt):\n print (\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no JVF tool configured. Continuing without jvf calculations.\")\n else: \n jvf_ghosttrack = getattr(jtm, 'jvf_'+trkopt)\n jvf_ghosttrack.unlock()\n jvf_ghosttrack.AssociatedTracks = secondary_label\n jvf_ghosttrack.lock()\n mymods.append(jvf_ghosttrack)\n if not hasattr(jtm, 'jvt_'+trkopt):\n print (\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no JVT tool configured. Continuing without jvt calculations.\")\n else: \n jvt_ghosttrack = getattr(jtm, 'jvt_'+trkopt)\n mymods.append(jvt_ghosttrack)\n\n if not do_minimalist_setup:\n # add in extra modofiers. This allows monitoring the ability\n # to run with the extra modifiers, which may be required in the\n # future.\n mymods.extend([\n jtm.nsubjettiness,\n jtm.jetens,\n jtm.caloqual_cluster,\n jtm.bchcorrclus,\n jtm.width\n ])\n\n if do_substructure:\n # this set of moments will be reduced once we've run once to\n # evaluate costs\n\n # don't want to include nsubjettiness and width twice\n if do_minimalist_setup:\n mymods.extend([\n jtm.nsubjettiness,\n jtm.width\n ])\n\n mymods.extend([\n # jtm.nsubjettiness,\n jtm.ktdr,\n jtm.ktsplitter,\n jtm.encorr,\n jtm.charge,\n jtm.angularity,\n jtm.comshapes,\n jtm.ktmassdrop,\n jtm.dipolarity,\n jtm.pull,\n jtm.planarflow,\n # jtm.width,\n jtm.qw,\n # jtm.trksummoms # this needs tracks and vertices which we\n # don't have by default\n ])\n\n\n # Add jet calo width always\n if do_minimalist_setup and not do_substructure:\n mymods.append(jtm.width)\n\n jtm.modifiersMap[\"mymods\"] = mymods\n \n if not name:\n name = 'TriggerJetBuilderTool_%d%s%sTopoJets' % (int_merge_param,\n cluster_calib,\n jet_calib)\n elif '_' in name:\n name = 'TriggerJetBuilderTool_%s' % name.split('_')[1]\n\n for jr in jtm.trigjetrecs:\n if jr.name() == name:\n print ('returning existing TriggerJetBuildTool with name', name)\n return jr\n \n\n print ('adding new jet builder ', name)\n assert cluster_calib in ('LC', 'EM')\n \n getter_label = cluster_calib + 'Topo'\n\n try:\n # jetBuildTool = jtm.addJetFinderTrigger(\n #OutputLevel=VERBOSE\n jetBuildTool = jtm.addTriggerJetBuildTool(\n name=name,\n alg=\"AntiKt\",\n radius=merge_param,\n getter_label=getter_label,\n concrete_type=concrete_type,\n modifiersin = \"mymods\", # key in jtmmodifiers map\n ghostArea=0.01, # != 0: calcjet area for pileup subtraction\n ptmin=ptmin,\n ptminFilter=ptminFilter,\n iParticleRejectionTool=iParticleRejectionTool,\n OutputLevel=OutputLevel,)\n \n except Exception as e:\n print ('error adding new jet builder %s' % name)\n print ('exception', e)\n import traceback\n traceback.print_exc()\n raise e\n\n nname = jetBuildTool.name()\n print ('name comparison', name, nname, hasattr(jtm, nname))\n\n # try:\n # if not hasattr(jtm,\"jbldTrigger\"):\n # jtm.addJetBuilderWithArea(\n # JetFromPseudojetMT(\"jbldTrigger\",\n # Attributes = [\"ActiveArea\",\n # \"ActiveArea4vec\"])\n # )\n # \n # if merge_param==0.4: \n # from AthenaCommon.AppMgr import ToolSvc\n # getattr(ToolSvc,name+\"Finder\").unlock()\n # getattr(ToolSvc,name+\"Finder\").JetBuilder = jtm.jbldTrigger\n # getattr(ToolSvc,name+\"Finder\").lock()\n\n #except Exception, e:\n # print 'error adding new JetFromPseudoJet %s' % name\n # print 'exception', e\n # print 'traceback', exc2string2()\n # raise e\n\n return jetBuildTool","def analysis(self, S_hit, S_score=None, S_go=None, SRC_GENE=None, min_overlap=3, min_enrichment=0, p_cutoff=0.01, n_CPU=0, l_rsa_keep_most=True, S_go_category=None, l_background_by_ontology=False):\n\n def go_filtered(S_go, S_go_category):\n return [x for x in S_go if self.get_category_id(x) in S_go_category]\n\n S_all_go_filtered=[]\n def all_go_filtered(S_go_category):\n if len(S_all_go_filtered)==0:\n S_go=self.GO_GENE_ENRICH\n S_all_go_filtered.append(go_filtered(S_go, S_go_category))\n return S_all_go_filtered[0]\n\n N_go=0\n if S_go_category is not None and len(S_go_category)>0:\n # hard code for now, to be fixed later\n if type(S_go_category) in (int, str):\n S_go_category=[S_go_category]\n S_go_category={int(x) for x in S_go_category if self.CATEGORY_COUNT.get(x,0)>0 }\n for x in S_go_category:\n N_go+=self.CATEGORY_COUNT[x]\n else:\n N_go=sum(self.CATEGORY_COUNT.values())\n\n l_multi_list=type(S_hit) is dict\n if S_go is None:\n if l_multi_list:\n S_go={}\n for k in S_hit.keys():\n S_go[k]=all_go_filtered(S_go_category)\n else:\n S_go=all_go_filtered(S_go_category)\n else:\n if l_multi_list:\n for k in S_hit.keys():\n if S_go.get(k, None) is None:\n S_go[k]=all_go_filtered(S_go_category)\n else:\n S_go[k]=go_filtered(S_go[k], S_go_category)\n else:\n S_go=go_filtered(S_go, S_go_category)\n\n if SRC_GENE is not None:\n if type(SRC_GENE) is list:\n SRC_GENE=set(SRC_GENE)\n SRC_GENE=self.ALL_GENE.intersection(SRC_GENE) # remove genes from background, if it is not in self.ALL_GENE\n N_total=len(SRC_GENE) #self.ALL_GENE.intersection(SRC_GENE))\n elif l_background_by_ontology:\n # GeneGo uses this\n if l_multi_list:\n X=set()\n for x in S_go.values():\n X.add(set(x))\n src_genes=self.gene_count(list(X))\n else:\n src_genes=self.gene_count(S_go)\n N_total=len(src_genes)\n SRC_GENE=set(src_genes.keys())\n else:\n if self.is_L1000():\n N_total=len(self.ALL_GENE)\n else:\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\n #N_total=len(self.ALL_GENE)\n # prefiltering uninteresting GO terms\n # already converted to multiple hit list situation\n sw=util.StopWatch()\n L=[] # list of (S_hit, s_go)\n\n def spread_input(S_hit, S_go, key):\n #S_hit, S_go, key=(X[0], X[1], X[2])\n # may not worth it\n #c_cnt=self.go_count(S_hit, S_go)\n #S_go=[s_go for s_go in S_go if c_cnt.get(s_go,0)>=min_overlap ]\n # minimum size\n MIN_BATCH=2000\n S_go2=util.split(S_go, chunk_size=MIN_BATCH)\n return [(key, S_hit, x) for x in S_go2]\n\n #sw.check('To spreadout')\n if l_multi_list:\n #mp=parallel.MP()\n #m=1 if len(S_hit)<=3 else n_CPU\n #mp.start(f=spread_input, n_CPU=m)\n #L=[(X, S_go[k], k) for k,X in S_hit.items() if len(X)>=min_overlap]\n #out=mp.map(L)\n #L=[y for X in out for y in X]\n L=[]\n for k,X in S_hit.items():\n if len(X)<min_overlap: continue\n L.extend(spread_input(X, S_go[k], k))\n random.shuffle(L)\n else:\n if len(S_hit)>=min_overlap:\n L=spread_input(S_hit, S_go, 'Default')\n\n if self.eg is None:\n self.eg=ez.EntrezGene(tax_id=self.tax_id, l_use_GPDB=self.GPDB)\n if n_CPU==0: n_CPU=1\n #print \">>>>>>>>>>>>>>\", len(L)\n S_chunk=util.split(L, n_chunk=n_CPU)\n #sw.check('Spreadout tasks: %d' % len(L))\n\n def analyze(L):\n \"\"\"L is a list of [[s_name, S_hit, s_go]], s_go can also be a list\"\"\"\n rslt=[]\n #p=util.Progress(len(L))\n i=0\n import multiprocessing\n s_pid=str(multiprocessing.current_process().pid)\n for s_name, S_hit, S_go in L:\n i+=1\n #if (i % 50000): p.check(i, s_pid)\n if type(S_go) is str: S_go=[S_go]\n for s_go in S_go:\n if s_go not in self.GO_GENE: continue\n if S_score is None:\n c=self.analysis_go(s_go, S_hit, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff)\n else:\n c=self.analysis_go_RSA(s_go, S_hit, S_score, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff, l_keep_most=l_rsa_keep_most)\n if c is None:\n continue\n c['Name']=s_name\n if min_enrichment>0 and c['Enrichment']<min_enrichment: continue\n if p_cutoff<1 and 10**c['LogP']>p_cutoff: continue\n c['Description']= self.go_description(s_go)\n S_gene=c['GeneID'].split('|')\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\n c['Hits']='|'.join(S_symbol)\n if 'GeneID_All' in c:\n S_gene=c['GeneID_All'].split('|')\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\n c['Hits_All']='|'.join(S_symbol)\n if self.GPDB:\n c['CategoryID'] = self.get_category_id(c['GO'])\n c['Category'] = self.CATEGORY.get(self.get_category_id(c['GO']))\n c['GO'] = self.get_source_id(c['GO'])\n rslt.append(c)\n return rslt\n out=parallel.parmap(analyze, S_chunk, n_CPU=n_CPU)\n #if n_CPU>1:\n # mp=parallel.MP()\n # mp.start(f=analyze, n_CPU=n_CPU)\n # out=mp.map(S_chunk)\n #else:\n # out=[analyze(x) for x in S_chunk]\n\n #mp.start(n_CPU=n_CPU)\n #sw.check('P-value Calculation')\n #sw.check('P-value Calculation Done')\n rslt=[]\n for x in out:\n if len(x): rslt.extend(x)\n\n if len(rslt):\n #sw.check('Length: %d' % len(rslt))\n t=pd.DataFrame(rslt)\n #sw.check('Table DONE')\n if S_score is None:\n t=t.sort_values(['LogP','Enrichment','#GeneInGOAndHitList'], ascending=[True,False,False])\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\n '#GeneInGO','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits']\n else:\n t=t.sort_values(['LogP','Enrichment','#HitInGORemain','#GeneInGOAndHitList'], ascending=[True,False,False,False])\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\n '#GeneInGO','#HitRemain','#HitInGORemain','Cutoff','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits','GeneID_All','Hits_All']\n if self.GPDB:\n #cols.insert(1,'field1')\n cols.insert(1,'CategoryID')\n cols.insert(1,'Category')\n #sw.check('sorted DONE')\n t=t.reindex(columns=cols)\n # FDR\n #print \">>> N_go: \", N_go\n #sw.check('reindex DONE')\n t['Log(q-value)']=np.log10(np.clip(stats.adjust_p(np.power(10, t.LogP.values), N=N_go), 1e-100, 1.0))\n #sw.check('q-value DONE')\n if not l_multi_list:\n t.drop('Name', axis=1, inplace=True)\n return t\n else:\n return None","def run_demo():\n while True:\n embeddings = beer_emb.embed_doc(input(\"Test if words are beer-related: \"),\n word_filter=False)\n for word_vec in embeddings:\n print(is_beer_related(word_vec))","def get_tools_using_technique():\n global tools_using_technique\n\n if not tools_using_technique:\n tools_using_technique = rsh.tools_using_technique(get_srcs())\n \n return tools_using_technique","def get_tools(cls):\n pass","def get_tools_used_by_groups():\n global tools_used_by_groups\n\n if not tools_used_by_groups:\n tools_used_by_groups = rsh.tools_used_by_groups(get_srcs())\n \n return tools_used_by_groups","def detect_objects(robot):\n env = robot.GetEnv()\n with env:\n robot_in_world = robot.GetTransform()\n\n table_in_world = numpy.dot(robot_in_world, TABLE_IN_ROBOT)\n table = add_object(env, 'table', 'furniture/table.kinbody.xml',\n table_in_world)\n\n glass = add_object(env, 'glass', 'objects/plastic_glass.kinbody.xml',\n numpy.dot(table_in_world, GLASS_IN_TABLE))\n return table, glass","def find_gpas(s):\n \"*** YOUR CODE HERE ***\"","def main():\n\n # Setup `pysc` to use BASIC auth, with a username, and password. Also sets the endpoint to use.\n setup_sensorcloud_basic(CONSTS['SC_USERNAME'], CONSTS['SC_PASSWORD'],\n CONSTS['SC_ENDPOINT'], CONSTS['PYSC_DEBUG'])\n\n org_id = CONSTS['ORG_ID']\n\n # Ensure the organisation exists on the SensorCloud endpoint.\n try:\n organisation = pysc.models.Organisation.single(org_id)\n except KeyError:\n raise RuntimeWarning(\"\"\"The organisation named {:s} was not found.\\n\"\"\"\n \"\"\"Although the `pysc` api has functionality to create an organisation, it cannot \"\"\"\n \"\"\"do so on the sensor-cloud.io instance on AWS.\"\"\".format(org_id))\n # Ensure sanity, check we got the organisation that we asked for.\n assert (org_id == organisation.id)\n\n # Here we use the Group.resolve_all helper with organisation_id param to filter groups based on id\n # The resolve_all command is similar to .index() however it also calls .follow() on found link automatically,\n # _and_ it converts the resulting HAL objects into real valid `pysc` Group() objects.\n org_groups = pysc.models.Group.resolve_all(params={'organisation_id': org_id})\n # We are not likely to have more than 1000 groups, so we don't need to do return doc pagination here.\n for g in org_groups:\n group_id = g.id\n print(\"Found group: {:s}\".format(group_id))\n\n print(\"Found a total of {:d} groups for {:s} on that SensorCloud endpoint.\".format(len(org_groups), org_id))","def test_gettesttools_html(self):\n pass","def kegg_module_enrichment(genelist, dbpaths=dbpaths):\n size, kegglist = cbir_to_kegg(genelist)\n\n #print \"Creating Kegg module library\"\n ## create Kegg module dictionary:\n kmod_h = open(dbpaths['kegg'], 'rb')\n\n kmodlist = []\n kmodd = {}\n kmodcount = 0\n kmcount = {}\n kmod = 'none'\n\n kgroupb = {}\n kgroupbcount = {}\n kgroupblist = []\n kbcount = {}\n b_group = 'none'\n\n kgroupc = {}\n kgroupccount = {}\n kccount = {}\n kgroupclist = []\n c_group = 'none'\n\n kod = {} # this is to count how many KOs there are in the list\n\n for line in kmod_h:\n \"\"\"if line[0] == 'B': # higher level functional description (eg 'Energy Metabolism')\n kbcount[b_group] = len(kgroupbcount)# add old b_group count to dictionary\n kgroupbcount = {} # reset counter\n try:\n b_group = re.search(\"<b>(.*)</b>\", line).group(1)\n kgroupblist.append(b_group)\n except:\n b_group = 'none'\n \"\"\"\n if line[0] == 'C': # descriptive function (eg Carbon fixation)\n kccount[c_group] = len(kgroupccount)# add old c_group count to dictionary\n kgroupccount = {} # reset counter\n try:\n c_group = re.search(\"C *(.*)\", line.trim()).group(1)\n kgroupclist.append(c_group)\n except:\n c_group = 'none'\n\n elif line[0] == 'D': # Kegg module (eg M00165 Reductive pentose phosphate cycle)\n kmcount[kmod] = kmodcount\n kmodcount = 0\n try:\n ksearch = re.search(\"(M[0-9]*) *(.*)\\[PATH\", line)\n kmod = ksearch.group(1)\n kmoddef = ksearch.group(2)\n kmodlist.append(kmod)\n except:\n kmod = 'none'\n kmoddef = 'none'\n\n elif line[0] == 'E': # Kegg term\n try:\n ko = re.search(\"(K[0-9]*)\", line).group(1)\n\n kmodcount += 1\n kgroupbcount[ko] = True\n kgroupccount[ko] = True\n try:\n kmodd[ko].append(kmod)\n kgroupb[ko].append(b_group)\n kgroupc[ko].append(c_group)\n except:\n kmodd[ko] = [kmod]\n kgroupb[ko] = [b_group]\n kgroupc[ko] = [c_group]\n except:\n pass\n kccount[c_group] = len(kgroupccount)# add final old c_group count to dictionary\n kmcount[kmod] = kmodcount # add final kmmod group count to dictionary\n\n\n kmodtestsize = len(kmodlist) # for multiple testing correction\n kgrpbtestsize = len(kgroupblist)\n kgrpctestsize = len(kgroupclist)\n\n #print \"calculating Fisher's exact test\"\n # count number of kegglist KOs are in each kegg module, perform Fisher's exact test\n dip = 0\n dipcount = {} # possibly unnecessary\n kmodenrich = {}\n kmododds = {}\n\n for mod in kmodlist:\n for ko in kegglist:\n if ko not in kmodd: # some KOs do not exist in a module.\n pass\n elif mod in kmodd[ko]:\n dip += 1\n dipcount[mod] = dip # possibly unnecessary\n oddrat, pval = fisher_exact([\n [dip, len(kegglist) - dip],\n [kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip]\n ])\n if pval < 0.05:\n print \"%s\\n In Path Not in Path\\nDEG : %-7d %d\\nnon-DEG: %-7d %d\\n%.4f\\n\" % (mod, dip, len(kegglist) - dip,kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip, pval )\n kmododds[mod] = oddrat\n kmodenrich[mod] = pval\n dip = 0 # reset for next module\n #sys.stdout.write(\"%s\\n In Path Not in Path\\nDEG : %-7d %d\\nnon-DEG: %-7d %d\\n%.4f\\n\" % (mod, dip, len(kegglist) - dip,kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip, pval ) )\n #print type(pval), pval\n #print type(kmodtestsize), kmodtestsize\n\n dip = 0\n kcenrich = {}\n kcodds = {}\n\n for fn in kgroupclist:\n for ko in kegglist:\n if fn in kgroupc[ko]:\n dip += 1\n #sys.stdout.write(\" In Path Not in Path\\nDEG :%-7d %d\\nnonDEG:%-7d %d\" % (dip, len(kegglist) - dip, kccount[fn]-dip, len(keggcount) - len(kegglist) - kccount[fn] + dip ))\n oddrat, pval = fisher_exact([\n [dip, len(kegglist) - dip],\n [kccount[fn]-dip, size - len(kegglist) - kccount[fn] + dip]\n ])\n #sys.stdout.write(pval)\n #sys.stdout.flush()\n kcodds[fn] = oddrat\n kcenrich[fn] = pval / kgrpctestsize\n dip = 0 # reset for next module\n\n #print kmodenrich\n return kmodenrich, kcenrich\n ## Fisher's Exact Test:\n # In Pathway: Not in Pathway: SUM:\n # DEG : dip len(kegglist) - dip len(kegglist)\n # non-DEG : kmcount[mod]-dip len(keggcount) - len(kegglist) - kmcount[mod] + dip len(keggcount) - len(kegglist)\n # SUM : kmcount[mod] len(keggcount) - kmcount[mod] len(keggcount)\n #\n\n pass","def testExample(self):\n popesCreek = self.createPopesCreek()\n mountVernon = self.createMountVernon()\n chestnutGrove = self.createChestnutGrove()\n\n george = self.createGeorge(popesCreek, mountVernon)\n martha = self.createMartha(chestnutGrove, mountVernon)\n\n marriage = self.createMarriage(george, martha)\n sources = self.citeGeorgeMarthaAndMarriage(george, martha, marriage)\n\n contributor = self.createContributor()\n\n gx = Gedcomx()\n gx.persons.set([george, martha])\n gx.relationships.set([marriage])\n gx.sourceDescriptions.set(sources)\n gx.agents.set([contributor])\n gx.attribution.contributor.resource = u\"#\" + contributor.id\n\n gx.places.set([popesCreek, mountVernon, chestnutGrove])\n gx_dict = gx.to_dict()\n\n # Read the json output from java program and initialize a gedcomx object.\n dirname = os.path.abspath(os.path.dirname(__file__))\n java_gx = Gedcomx()\n java_gx.load( open(os.path.join(dirname, 'data', 'GeorgeMarthaExample_java.json') ))\n java_dict = java_gx.to_dict()\n\n # Compare both objects.\n self.assertDictEqual(gx_dict, java_dict)\n self.assertDictEqual(java_dict, gx_dict)","def get_genes(variant):\n genes = {}\n transcripts = []\n mongo_genes = []\n \n # Conversion from ensembl to refseq\n # ensembl_to_refseq is a dictionary with ensembl transcript id as keys and\n # a list of refseq ids as values\n ensembl_to_refseq = {}\n for gene_info in variant['info_dict'].get(\n 'Ensembl_transcript_to_refseq_transcript', []):\n splitted_gene = gene_info.split(':')\n transcript_info = splitted_gene[1]\n for transcript in transcript_info.split('|'):\n splitted_transcript = transcript.split('>')\n if len(splitted_transcript) > 1:\n ensembl_id = splitted_transcript[0]\n refseq_ids = splitted_transcript[1].split('/')\n ensembl_to_refseq[ensembl_id] = refseq_ids\n \n # A dictionary with clinical gene descriptions\n gene_descriptions = {}\n for gene_info in variant['info_dict'].get('Gene_description', []):\n splitted_gene = gene_info.split(':')\n hgnc_symbol = splitted_gene[0]\n description = splitted_gene[1]\n gene_descriptions[hgnc_symbol] = description\n \n # First we get all vep entrys that we find and put them under their \n # corresponding gene symbol in 'genes'\n for vep_entry in variant['vep_info'].get(variant['ALT'], []):\n transcript = get_transcript(vep_entry, ensembl_to_refseq)\n hgnc_symbol = transcript.hgnc_symbol\n if hgnc_symbol:\n if hgnc_symbol in genes:\n genes[hgnc_symbol]['transcripts'][transcript.transcript_id] = transcript\n for functional_annotation in transcript.functional_annotations:\n new_rank = SO_TERMS[functional_annotation]['rank']\n if new_rank < genes[hgnc_symbol]['best_rank']:\n genes[hgnc_symbol]['best_rank'] = new_rank\n genes[hgnc_symbol]['most_severe_transcript'] = transcript\n genes[hgnc_symbol]['most_severe_function'] = functional_annotation\n \n else:\n genes[hgnc_symbol] = {}\n genes[hgnc_symbol]['transcripts'] = {}\n genes[hgnc_symbol]['transcripts'][transcript.transcript_id] = transcript\n genes[hgnc_symbol]['most_severe_transcript'] = transcript\n genes[hgnc_symbol]['omim_gene_id'] = None\n genes[hgnc_symbol]['phenotypic_terms'] = []\n genes[hgnc_symbol]['best_rank'] = 40\n genes[hgnc_symbol]['ensembl_id'] = transcript.ensembl_id\n \n for functional_annotation in transcript.functional_annotations:\n new_rank = SO_TERMS[functional_annotation]['rank']\n if new_rank < genes[hgnc_symbol]['best_rank']:\n genes[hgnc_symbol]['best_rank'] = new_rank\n genes[hgnc_symbol]['most_severe_function'] = functional_annotation\n \n \n ######################################################################\n ## There are two types of OMIM terms, one is the OMIM gene entry ##\n ## and one is for the phenotypic terms. ##\n ## Each key in the 'omim_terms' dictionary reprecents a gene id. ##\n ## Values are a dictionary with 'omim_gene_id' = omim_gene_id and ##\n ## 'phenotypic_terms' = [list of OmimPhenotypeObjects] ##\n ######################################################################\n\n # Fill the omim gene id:s:\n for annotation in variant['info_dict'].get('OMIM_morbid', []):\n if annotation:\n splitted_record = annotation.split(':')\n try:\n hgnc_symbol = splitted_record[0]\n omim_term = splitted_record[1]\n genes[hgnc_symbol]['omim_gene_id'] = omim_term\n except (ValueError, KeyError):\n pass\n\n # Fill the omim phenotype terms:\n for gene_annotation in variant['info_dict'].get('Phenotypic_disease_model', []):\n if gene_annotation:\n splitted_gene = gene_annotation.split(':')\n hgnc_symbol = splitted_gene[0]\n for omim_entry in splitted_gene[1].split('|'):\n splitted_record = omim_entry.split('>')\n \n phenotype_id = splitted_record[0]\n inheritance_patterns = []\n if len(splitted_record) > 1:\n inheritance_patterns = splitted_record[1].split('/')\n \n disease_model = PhenotypeTerm(\n phenotype_id=phenotype_id,\n disease_models=inheritance_patterns\n )\n \n genes[hgnc_symbol]['phenotypic_terms'].append(disease_model)\n \n for hgnc_symbol in genes:\n gene_info = genes[hgnc_symbol]\n most_severe = gene_info['most_severe_transcript']\n # Create a mongo engine gene object for each gene found in the variant\n mongo_gene = Gene(hgnc_symbol=hgnc_symbol)\n mongo_gene.description = gene_descriptions.get(hgnc_symbol)\n mongo_gene.ensembl_gene_id = gene_info.get('ensembl_id', None)\n mongo_gene.omim_gene_entry = gene_info.get(\n 'omim_gene_id', \n None\n )\n\n mongo_gene.omim_phenotypes = gene_info.get(\n 'phenotypic_terms', \n []\n )\n\n # Add a list with the transcripts:\n mongo_gene.transcripts = []\n for transcript_id in gene_info['transcripts']:\n mongo_gene.transcripts.append(gene_info['transcripts'][transcript_id])\n\n try:\n mongo_gene.functional_annotation = gene_info['most_severe_function']\n except AttributeError:\n pass\n try:\n mongo_gene.region_annotation = SO_TERMS[mongo_gene.functional_annotation]['region']\n except AttributeError:\n pass\n try:\n mongo_gene.sift_prediction = most_severe.sift_prediction\n except AttributeError:\n pass\n try:\n mongo_gene.polyphen_prediction = most_severe.polyphen_prediction\n except AttributeError:\n pass\n # Add the mongo engine gene to the dictionary\n mongo_genes.append(mongo_gene)\n\n return mongo_genes","def MergeLogic(self) -> str:","def find_common_interactor():\n # 1. filter the unique fusion gene pairs.\n # fusionGenePair = pd.read_csv(\"./fusionGenePair.csv\", header=0, sep=' ')\n # unique_fusionGenePair = fusionGenePair.drop_duplicates()\n # unique_fusionGenePair.to_csv(\"./uniqueFusion.csv\", sep=' ', index=False)\n unique_fusionGenePair = pd.read_csv(\"./uniqueFusion.csv\", sep=' ', header=0)\n\n # 2. for each gene pairs, get all the interactors each partner has.\n\n # Store the 5' partner gene and 3' partner gene in two lists.\n FivePartnerGenelist = []\n ThreePartnerGenelist = []\n for index, row in unique_fusionGenePair.iterrows():\n FivePartnerGenelist.append(row['5_PARTNER_GENE'])\n ThreePartnerGenelist.append(row['3_PARTNER_GENE'])\n # Get the unique gene in each pair\n uniqueFPGL = list(OrderedDict.fromkeys(FivePartnerGenelist))\n uniqueTPGL = list(OrderedDict.fromkeys(ThreePartnerGenelist))\n uniqueGene = list(OrderedDict.fromkeys(uniqueTPGL + uniqueFPGL))\n\n # Find each gene's interactor in the PPI datasets\n PPIS = pd.read_csv(\"./IID results/PPIs_final.tsv\", sep='\\t', header=0)\n\n # Put each gene interactor into a dictionary.\n geneIntDic = {}\n for item in uniqueGene:\n for index, row in PPIS.iterrows():\n if row['Query Symbol'] == item:\n if item in geneIntDic:\n geneIntDic[item].append(row['Partner Symbol'])\n else:\n key = item\n geneIntDic.setdefault(key, [])\n geneIntDic[item].append(row['Partner Symbol'])\n if row['Partner Symbol'] == item:\n if item in geneIntDic:\n geneIntDic[item].append(row['Query Symbol'])\n else:\n key = item\n geneIntDic.setdefault(key, [])\n geneIntDic[item].append(row['Query Symbol'])\n w = csv.writer(open(\"./geneIntDic.csv\", \"w\"))\n for key, val in geneIntDic.items():\n w.writerow([key, val])","def search_org(es, text_orig, context=None, just_search=False):\n # pylint: disable=redefined-variable-type\n # `org_id` may be `None`, `False` or string.\n\n org_id = None\n text_search = text_orig\n\n while True:\n if context and context.get(\"refresh\", None):\n # Necessarily imprecise way of allowing recently\n # inserted alias to appear in results\n time.sleep(1)\n context[\"refresh\"] = False\n\n candidates = get_candidates(es, text_search)\n if not candidates:\n break\n\n sys.stderr.write(\n (\"\\nFind: '\\033[92m%s\\033[0m'\\n\\n\" % (text_orig))\n )\n for i, org in enumerate(candidates, 1):\n sys.stderr.write(\n \" %4d: \\033[37m%-5d %s\\033[0m\\n\" % (\n i, org[\"org_id\"], org[\"score\"])\n )\n for name in org[\"alias_all\"]:\n sys.stderr.write(\n (\" \\033[94m%s\\033[0m\\n\" % name)\n )\n sys.stderr.write(\"\\n\")\n sys.stderr.write(\" Empty: None of the above\\n\")\n sys.stderr.write(\" Text: Alternative search\\n: \")\n sys.stderr.write(\" '-': Skip\\n\\n: \")\n if just_search:\n return\n\n choice = input()\n choice = choice.strip()\n if not len(choice):\n org_id = None\n break\n sys.stderr.write(\"\\n\")\n if choice == \"-\":\n org_id = False\n break\n sys.stderr.write(\"\\n\")\n try:\n choice = int(choice)\n except ValueError:\n text_search = choice\n continue\n if choice == 0:\n org_id = \" \"\n break\n if choice > len(candidates):\n continue\n org_id = candidates[choice - 1][\"org_id\"]\n break\n\n return org_id","def lookup(text):\n ret = basic(text)\n ret.update(basic(text, \"gwas\"))\n return ret","def main():\n example = {\n \"maybe\": True,\n \"gtags\": [\"one\", \"two\", \"three\"],\n \"current\": {\n \"type\": \"NUMERIC\",\n \"is_filter\": True,\n \"values\": {\n \"lower\": 33,\n \"upper\": 0,\n \"operation\": \"between\"\n }\n },\n \"loc\": {\n \"type\": \"GEO\",\n \"is_filter\": True,\n \"values\": {\n \"long\": 33,\n \"lat\": -10,\n \"distance\": 1.2,\n \"metric\": \"km\"\n }\n },\n \"exact_text\": {\n \"type\": \"TEXT\",\n \"is_filter\": True,\n \"values\": {\n \"term\": \"hello world\"\n }\n },\n }\n \n\n for _ in range(100):\n insertable = create_insertable(example)\n \n print(insertable)\n pass","def main():\n # files\n summary_file = sys.argv[1]\n pwms_to_tfs_file = sys.argv[2]\n expressed_tfs_file = sys.argv[3] # TODO\n\n # TODO pull in num regions to resize things? but complicated with overlaps etc\n # TODO edit edges with type of interaction\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\n \n # read in data\n summary = pd.read_csv(summary_file, sep=\"\\t\")\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\"\\t\")\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\"expressed\"].notna()]\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\n for line_idx in range(pwms_to_tfs.shape[0]):\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\n pwm_name = pwm_info[\"hclust_model_name\"]\n pwm_to_tf = dict(zip(pwm_info[\"expressed\"].split(\";\"), pwm_info[\"expressed_hgnc\"].split(\";\")))\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\n\n \n # filter expressed hgncs for dynamic ones only\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\"\\t\", index_col=0)\n for pwm_name in pwms_to_filt_tfs.keys():\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\n for ensembl_tf in tfs_tmp.keys():\n if ensembl_tf not in tfs_filt.index:\n del tfs_tmp[ensembl_tf]\n if len(tfs_tmp.keys()) == 0:\n del pwms_to_filt_tfs[pwm_name]\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\n\n # add in tfs column\n tf1 = []\n for pwm in summary[\"pwm1\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n # TODO try add in max point\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf1.append(tf_str)\n summary[\"tf1\"] = tf1\n\n tf2 = []\n for pwm in summary[\"pwm2\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf2.append(tf_str)\n summary[\"tf2\"] = tf2\n \n # remove failed rules\n summary = summary[~summary[\"interaction\"].str.contains(\"FAILED\")]\n \n # make graph\n graph = nx.from_pandas_edgelist(summary, \"tf1\", \"tf2\")\n\n # set up positions\n #pos = graphviz_layout(graph, prog=\"dot\")\n pos = graphviz_layout(graph, prog=\"neato\")\n scale_factor = 3\n for key in pos.keys():\n coords = pos[key]\n pos[key] = {\"x\": scale_factor*coords[0], \"y\": -scale_factor*coords[1]}\n nx.set_node_attributes(graph, pos, \"graphics\") # note this is diff from v1 to v2 in networkx\n \n # add graphics\n add_graphics_theme_to_nx_graph(graph)\n\n # write gml\n out_file = \"summary.gml\"\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\n\n # tfs: for each tf, get gene column\n \n \n return","def main():\n\n merch_bot = MerchBot()\n merch_bot.run_bot()","def DontuseThis():\n BCM_outputs = ['phi','rho','theta',\n 'r_probabilityMaps','l_probabilityMaps',\n 'models']\n BCM_Models = pe.Node(interface=nio.DataGrabber(input_names=['structures'],\n outfields=BCM_outputs),\n name='10_BCM_Models')\n BCM_Models.inputs.base_directory = atlas_fname_wpath\n BCM_Models.inputs.template_args['phi'] = [['spatialImages','phi','nii.gz']]\n BCM_Models.inputs.template_args['rho'] = [['spatialImages','rho','nii.gz']]\n BCM_Models.inputs.template_args['theta'] = [['spatialImages','theta','nii.gz']]\n BCM_Models.inputs.template_args['r_probabilityMaps'] = [['structures']]\n BCM_Models.inputs.template_args['l_probabilityMaps'] = [['structures']]\n BCM_Models.inputs.template_args['models'] = [['structures']]\n\n BRAINSCut_structures = ['caudate','thalamus','putamen','hippocampus']\n #BRAINSCut_structures = ['caudate','thalamus']\n BCM_Models.iterables = ( 'structures', BRAINSCut_structures )\n BCM_Models.inputs.template = '%s/%s.%s'\n BCM_Models.inputs.field_template = dict(\n r_probabilityMaps='probabilityMaps/r_%s_ProbabilityMap.nii.gz',\n l_probabilityMaps='probabilityMaps/l_%s_ProbabilityMap.nii.gz',\n models='modelFiles/%sModel*',\n )\n\n \"\"\"\n The xml creation and BRAINSCut need to be their own mini-pipeline that gets\n executed once for each of the structures in BRAINSCut_structures. This can be\n accomplished with a map node and a new pipeline.\n \"\"\"\n \"\"\"\n Create xml file for BRAINSCut\n \"\"\"\n\n\n BFitAtlasToSubject = pe.Node(interface=BRAINSFit(),name=\"BFitAtlasToSubject\")\n BFitAtlasToSubject.inputs.costMetric=\"MMI\"\n BFitAtlasToSubject.inputs.maskProcessingMode=\"ROI\"\n BFitAtlasToSubject.inputs.numberOfSamples=100000\n BFitAtlasToSubject.inputs.numberOfIterations=[1500,1500]\n BFitAtlasToSubject.inputs.numberOfHistogramBins=50\n BFitAtlasToSubject.inputs.maximumStepLength=0.2\n BFitAtlasToSubject.inputs.minimumStepLength=[0.005,0.005]\n BFitAtlasToSubject.inputs.transformType= [\"Affine\",\"BSpline\"]\n BFitAtlasToSubject.inputs.maxBSplineDisplacement= 7\n BFitAtlasToSubject.inputs.maskInferiorCutOffFromCenter=65\n BFitAtlasToSubject.inputs.splineGridSize=[28,20,24]\n BFitAtlasToSubject.inputs.outputVolume=\"Trial_Initializer_Output.nii.gz\"\n BFitAtlasToSubject.inputs.outputTransform=\"Trial_Initializer_Output.mat\"\n cutWF.connect(SplitAvgBABC,'avgBABCT1',BFitAtlasToSubject,'fixedVolume')\n cutWF.connect(BABC,'outputLabels',BFitAtlasToSubject,'fixedBinaryVolume')\n cutWF.connect(BAtlas,'template_t1',BFitAtlasToSubject,'movingVolume')\n cutWF.connect(BAtlas,'template_brain',BFitAtlasToSubject,'movingBinaryVolume')\n cutWF.connect(BLI,'outputTransformFilename',BFitAtlasToSubject,'initialTransform')\n\n CreateBRAINSCutXML = pe.Node(Function(input_names=['rho','phi','theta',\n 'model',\n 'r_probabilityMap',\n 'l_probabilityMap',\n 'atlasT1','atlasBrain',\n 'subjT1','subjT2',\n 'subjT1GAD','subjT2GAD',\n 'subjSGGAD','subjBrain',\n 'atlasToSubj','output_dir'],\n output_names=['xml_filename','rl_structure_filename_list'],\n function = create_BRAINSCut_XML),\n overwrite = True,\n name=\"CreateBRAINSCutXML\")\n\n ## HACK Makde better directory\n CreateBRAINSCutXML.inputs.output_dir = \".\" #os.path.join(cutWF.base_dir, \"BRAINSCut_output\")\n cutWF.connect(BCM_Models,'models',CreateBRAINSCutXML,'model')\n cutWF.connect(BCM_Models,'rho',CreateBRAINSCutXML,'rho')\n cutWF.connect(BCM_Models,'phi',CreateBRAINSCutXML,'phi')\n cutWF.connect(BCM_Models,'theta',CreateBRAINSCutXML,'theta')\n cutWF.connect(BCM_Models,'r_probabilityMaps',CreateBRAINSCutXML,'r_probabilityMap')\n cutWF.connect(BCM_Models,'l_probabilityMaps',CreateBRAINSCutXML,'l_probabilityMap')\n cutWF.connect(BAtlas,'template_t1',CreateBRAINSCutXML,'atlasT1')\n cutWF.connect(BAtlas,'template_brain',CreateBRAINSCutXML,'atlasBrain')\n cutWF.connect(SplitAvgBABC,'avgBABCT1',CreateBRAINSCutXML,'subjT1')\n cutWF.connect(SplitAvgBABC,'avgBABCT2',CreateBRAINSCutXML,'subjT2')\n cutWF.connect(GADT1,'outputVolume',CreateBRAINSCutXML,'subjT1GAD')\n cutWF.connect(GADT2,'outputVolume',CreateBRAINSCutXML,'subjT2GAD')\n cutWF.connect(SGI,'outputFileName',CreateBRAINSCutXML,'subjSGGAD')\n cutWF.connect(BABC,'outputLabels',CreateBRAINSCutXML,'subjBrain')\n cutWF.connect(BFitAtlasToSubject,'outputTransform',CreateBRAINSCutXML,'atlasToSubj')\n #CreateBRAINSCutXML.inputs.atlasToSubj = \"INTERNAL_REGISTER.mat\"\n #cutWF.connect(BABC,'atlasToSubjectTransform',CreateBRAINSCutXML,'atlasToSubj')\n\n \"\"\"\n ResampleNACLabels\n \"\"\"\n ResampleAtlasNACLabels=pe.Node(interface=BRAINSResample(),name=\"ResampleAtlasNACLabels\")\n ResampleAtlasNACLabels.inputs.interpolationMode = \"NearestNeighbor\"\n ResampleAtlasNACLabels.inputs.outputVolume = \"atlasToSubjectNACLabels.nii.gz\"\n\n cutWF.connect(cutWF,'OutputSpec.atlasToSubjectTransform',ResampleAtlasNACLabels,'warpTransform')\n cutWF.connect(cutWF,'OutputSpec.t1_corrected',ResampleAtlasNACLabels,'referenceVolume')\n cutWF.connect(BAtlas,'template_nac_lables',ResampleAtlasNACLabels,'inputVolume')\n\n \"\"\"\n BRAINSMush\n \"\"\"\n BMUSH=pe.Node(interface=BRAINSMush(),name=\"BMUSH\")\n BMUSH.inputs.outputVolume = \"MushImage.nii.gz\"\n BMUSH.inputs.outputMask = \"MushMask.nii.gz\"\n BMUSH.inputs.lowerThresholdFactor = 1.2\n BMUSH.inputs.upperThresholdFactor = 0.55\n\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BMUSH,'inputFirstVolume')\n cutWF.connect(myLocalTCWF,'OutputSpec.t2_corrected',BMUSH,'inputSecondVolume')\n cutWF.connect(myLocalTCWF,'OutputSpec.outputLabels',BMUSH,'inputMaskVolume')\n\n \"\"\"\n BRAINSROIAuto\n \"\"\"\n BROI = pe.Node(interface=BRAINSROIAuto(), name=\"BRAINSROIAuto\")\n BROI.inputs.closingSize=12\n BROI.inputs.otsuPercentileThreshold=0.01\n BROI.inputs.thresholdCorrectionFactor=1.0\n BROI.inputs.outputROIMaskVolume = \"temproiAuto_t1_ACPC_corrected_BRAINSABC.nii.gz\"\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BROI,'inputVolume')\n\n \"\"\"\n Split the implicit outputs of BABCext\n \"\"\"\n SplitAvgBABC = pe.Node(Function(input_names=['in_files','T1_count'], output_names=['avgBABCT1','avgBABCT2'],\n function = get_first_T1_and_T2), run_without_submitting=True, name=\"99_SplitAvgBABC\")\n SplitAvgBABC.inputs.T1_count = 1 ## There is only 1 average T1 image.\n\n cutWF.connect(myLocalTCWF,'OutputSpec.outputAverageImages',SplitAvgBABC,'in_files')\n\n\n\n def printFullPath(outFileFullPath):\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"=\"*80)\n print(\"{0}\".format(outFileFullPath))\n return outFileFullPath\n printOutImage = pe.Node( Function(function=printFullPath, input_names = ['outFileFullPath'], output_names = ['genoutFileFullPath']), run_without_submitting=True, name=\"99_printOutImage\")\n cutWF.connect( GADT2, 'outputVolume', printOutImage, 'outFileFullPath' )","def ensembl_genes(species,log=0):\n \n t1=time.time()\n #open ace genes by- ensembl region\n path=os.environ['PYDATA']+'/'+species+'/aceview/'+species+'_genes_by_ensembl_region.bkdb'\n aceGeneDB=bsddb.btopen(path,'r') \n \n path=os.environ['PYDATA']+\"/\"+species+\"/ensembl/\"+species+'_genes_by_region.bkdb'\n otherGenesDB=bsddb.btopen(path,'r')\n '''create ensembl genes by ace gene'''\n path=os.environ['PYDATA']+'/'+species+'/aceview/'+species+'_ensembl_genes_by_gene.bkdb'\n otherGenesByGeneDB=bsddb.btopen(path,'w')\n geneNb=0\n\n for region in aceGeneDB.keys():\n if region not in otherGenesDB.keys():\n print 'region %s not in ensembl/%s_genes_by_region.bkdb'%(region,species)\n else: \n print 'processing region ',region\n aceGenes=cPickle.loads(aceGeneDB[region])\n otherGenes=cPickle.loads(otherGenesDB[region])\n #construct dictionnary of ace genes containing ensembl genes\n ace={}\n '''process each ensembl gene in the current region'''\n for ensemblGeneIndex in range(len(otherGenes.IDs)): \n '''find the index of the ace genes that contains either the start or the end of the current ensembl gene'''\n aceGeneIndexes=[]\n indexes=bintools.owningStructure(otherGenes.starts[ensemblGeneIndex],otherGenes.strands[ensemblGeneIndex],aceGenes.starts,aceGenes.ends,aceGenes.strands,1)\n aceGeneIndexes.extend(indexes) \n indexes=bintools.owningStructure(otherGenes.ends[ensemblGeneIndex],otherGenes.strands[ensemblGeneIndex],aceGenes.starts,aceGenes.ends,aceGenes.strands,1)\n aceGeneIndexes.extend(indexes) \n '''register the current ensembl gene index in the ace dictionnary'''\n for aceGeneIndex in aceGeneIndexes: \n try:\n ace[aceGenes.IDs[aceGeneIndex]].append(ensemblGeneIndex)\n except: \n ace[aceGenes.IDs[aceGeneIndex]]=[ensemblGeneIndex] \n \n '''process each ace gene in the current region''' \n for aceGeneIndex in range(len(aceGenes.IDs)): \n '''find the index of the ensembl genes that contains either the start or the end of the current ace gene'''\n ensemblGeneIndexes=[]\n indexes=bintools.owningStructure(aceGenes.starts[aceGeneIndex],aceGenes.strands[aceGeneIndex],otherGenes.starts,otherGenes.ends,otherGenes.strands,1) \n ensemblGeneIndexes.extend(indexes)\n indexes=bintools.owningStructure(aceGenes.ends[aceGeneIndex],aceGenes.strands[aceGeneIndex],otherGenes.starts,otherGenes.ends,otherGenes.strands,1) \n ensemblGeneIndexes.extend(indexes)\n '''add the ensembl gene indexes found in the previous for loop processing ensembl genes'''\n try:\n ensemblGeneIndexes.extend(ace[aceGenes.IDs[aceGeneIndex]])\n except:\n pass \n ensemblGeneIndexes=set(ensemblGeneIndexes)\n '''recover the corresponding ensembl gene IDs'''\n ensemblGeneIDs=[] \n for i in range(len(ensemblGeneIndexes)):\n ensemblGeneIDs.append(otherGenes.IDs[ensemblGeneIndexes.pop()]) \n '''register the current ace gene'''\n ensemblGeneIDs.sort()\n otherGenesByGeneDB[aceGenes.IDs[aceGeneIndex]]=cPickle.dumps(ensemblGeneIDs,protocol=-1)\n geneNb=geneNb+1\n \n otherGenesByGeneDB.close() \n otherGenesDB.close()\n aceGeneDB.close()\n t2=time.time()\n if log!=0:\n log.write('%s\\t%s\\t\\t17\\t%s_ensembl_genes_by_gene.bkdb\\taceview\\t%u\\t%.2f\\n'%(date.today(),species,species,geneNb,t2-t1))","def change2postion_saveas_wig(wigfile,chrname, cluster, tag_thr=2):\n package = {}\n \n cutoff = 1000 / 10\n oceanbegin = 0 # ocean: tag num <= 2\n oceanflag = 1\n \n num = []\n for k in xrange(len(cluster)):\n num.append(cluster[k])\n \n #put a header for each chromosome\n print >>wigfile,\"track type=wiggle_0\\nvariableStep chrom=%s span=%d\" %(chrname,10)\n \n for k in xrange(len(num) - 1):\n if num[k] > tag_thr:\n if oceanflag == 1:\n oceanflag = 0\n if (k - oceanbegin) >= cutoff:\n oceanflag = 0\n for m in xrange(oceanbegin, k):\n num[m] = -1\n \n elif num[k] <= tag_thr and oceanflag == 0:\n oceanbegin = k\n oceanflag = 1\n if oceanflag == 1:\n for m in xrange(oceanbegin, len(num)):\n num[m] = -1\n\n linenum = 0\n islandflag = 0\n islandbegin = 0\n islandline = 0\n for k in xrange(len(num) - 1):\n if islandflag == 0 and num[k] > -1:\n islandflag = 1\n linenum += 1\n islandbegin = k + 1\n islandline = linenum\n print >>wigfile, \"%d\\t%d\" %(islandbegin*10-9,num[k])\n \n elif islandflag == 1 and num[k] > -1:\n linenum += 1\n print >>wigfile, \"%d\\t%d\" %(k*10+1,num[k])\n elif islandflag == 1 and num[k] == -1:\n islandflag = 0\n\n if islandflag == 1:\n linenum += 1\n print >>wigfile, \"%d\\t%d\" %(len(num)*10-9,num[len(num)-1])\n \n num = []","def exercise():\n pi_good = get_pdb_inputs(pdb_str=pdb_str_answer, restraints=False)\n map_data = get_map(xrs=pi_good.xrs)\n xrs_good = pi_good.xrs.deep_copy_scatterers()\n pi_good.ph.write_pdb_file(file_name=\"answer.pdb\",\n crystal_symmetry=xrs_good.crystal_symmetry())\n #\n pi_poor = get_pdb_inputs(pdb_str=pdb_str_poor, restraints=True)\n pi_poor.ph.write_pdb_file(file_name=\"poor.pdb\")\n xrs_poor = pi_poor.xrs.deep_copy_scatterers()\n #\n d = xrs_good.distances(other=xrs_poor)\n print(d.min_max_mean().as_tuple())\n assert flex.max(d)>2\n assert flex.mean(d)>0.7\n #\n xrs_refined = xrs_poor\n for i in range(3):\n ero = individual_sites.easy(\n map_data = map_data,\n xray_structure = xrs_refined,\n pdb_hierarchy = pi_poor.ph,\n geometry_restraints_manager = pi_poor.grm)\n xrs_refined = ero.xray_structure\n # comapre\n d = xrs_good.distances(other=xrs_refined)\n print(d.min_max_mean().as_tuple())\n assert flex.max(d)<0.15\n assert flex.mean(d)<0.03\n ero.pdb_hierarchy.write_pdb_file(file_name=\"refined.pdb\",\n crystal_symmetry=xrs_good.crystal_symmetry())","def region2feature(region , ext):\n server = \"https://rest.ensembl.org/overlap/region/human/\"+region +\"?\"\n for i in range(len(ext)):\n server = server + \"feature=\" + ext[i] + \";\"\n\n server = server[:-1]\n #print(server)\n r = requests.get(server,headers={\"Content-Type\" : \"application/json\"})\n\n if not r.ok:\n r.raise_for_status()\n sys.exit()\n decoded = r.content.decode()\n dict_decoded = json.loads(decoded)\n if len(dict_decoded):\n len_dict = len(dict_decoded)\n for i in range(len_dict):\n if dict_decoded[i]['feature_type'] == \"gene\":\n ID = dict_decoded[i]['gene_id']\n start = dict_decoded[i]['start']\n end = dict_decoded[i]['end']\n name = dict_decoded[i]['external_name']\n biotype = dict_decoded[i]['biotype']\n chr = dict_decoded[i]['seq_region_name']\n des = dict_decoded[i]['description']\n print(\"{0}\\t{1}\\t{2}\\t{3}\\t{4}\\t{5}\\t{6}\".\\\n format(ID,name,chr,start,end,biotype,des),file = Output)\n return(name)\n\n if dict_decoded[i]['feature_type'] == \"regulatory\":\n ID = dict_decoded[i]['id']\n chr = dict_decoded[i]['seq_region_name']\n start = dict_decoded[i]['start']\n end = dict_decoded[i]['end']\n des = dict_decoded[i]['description']\n feature_type = dict_decoded[i]['feature_type']\n print(\"{0}\\t{1}\\t{2}\\t{3}\\t{4}\\t{5}\".\\\n format(ID,chr,start,end,feature_type,des),file = Output)\n return(None)\n else:\n print(\"No match\")","def add_gazebo_tags():\n global robot\n # TODO instantiate plugins according to sensors present in input urdf\n return","def test_incept():\n\n # help.ogler.resetLevel(level=logging.DEBUG)\n\n for name in [\"wan\", \"wil\", \"wes\", \"multisig1\", \"multisig2\", \"multisig3\"]:\n if os.path.exists('/usr/local/var/keri/db/{}'.format(name)):\n shutil.rmtree('/usr/local/var/keri/db/{}'.format(name))\n if os.path.exists('/usr/local/var/keri/ks/{}'.format(name)):\n shutil.rmtree('/usr/local/var/keri/ks/{}'.format(name))\n\n\n with habbing.openHab(name=\"wan\", salt=b'wann-the-witness', transferable=False, temp=False) as wanHab, \\\n habbing.openHab(name=\"wil\", salt=b'will-the-witness', transferable=False, temp=False) as wilHab, \\\n habbing.openHab(name=\"wes\", salt=b'wess-the-witness', transferable=False, temp=False) as wesHab:\n\n wanDoers = indirecting.setupWitness(name=\"wan\", hab=wanHab, temp=False, tcpPort=5632, httpPort=5642)\n wilDoers = indirecting.setupWitness(name=\"wil\", hab=wilHab, temp=False, tcpPort=5633, httpPort=5643)\n wesDoers = indirecting.setupWitness(name=\"wes\", hab=wesHab, temp=False, tcpPort=5634, httpPort=5644)\n\n inceptor = InceptingDoer()\n doers = wanDoers + wilDoers + wesDoers + [inceptor]\n\n limit = 2.0\n tock = 0.03125\n doist = doing.Doist(tock=tock, limit=limit, doers=doers)\n doist.enter()\n\n tymer = tyming.Tymer(tymth=doist.tymen(), duration=doist.limit)\n\n while not tymer.expired:\n doist.recur()\n time.sleep(doist.tock)\n # doist.do(doers=doers)\n\n assert doist.limit == limit\n\n doist.exit()\n\n preb = b'Ep4WexrfQvQjblYg9ti12cr7NpKWaXLNP5CXmq_4Zhng' # multisig aid\n digb = b'E5_qNBzfkBc2kWAzGn5UUWhWUVrX4Yk1QBpVXHucygfk' # multisig inception digest\n dgkey = dbing.dgKey(preb, digb)\n\n wigs = wanHab.db.getWigs(dgkey)\n # assert len(wigs) == 3\n wigs = wilHab.db.getWigs(dgkey)\n # assert len(wigs) == 3\n wigs = wesHab.db.getWigs(dgkey)\n # assert len(wigs) == 3","def main(unused_argv):\n\n # Read the scene file.\n with open(FLAGS.scene_path, 'r') as file_id:\n scenes = json.load(file_id)\n\n # Read the synonyms file.\n with open(FLAGS.synonym_path, 'r') as file_id:\n synonyms = json.load(file_id)\n sorter = lambda x: len(x[0].split(' '))\n\n # Read the metainformation file.\n with open(FLAGS.metainfo_path, 'r') as file_id:\n gvars.METAINFO = json.load(file_id)\n tag_inv_map = {attr: tag for tag, attr in gvars.METAINFO['tag_map'].items()\n if tag != '<P>'}\n gvars.METAINFO['tag_inv_map'] = tag_inv_map\n gvars.METAINFO['synonym_keys'] = sorted(synonyms.items(),\n key=sorter, reverse=True)\n\n # Add ids to objects.\n scenes = utils.add_object_ids(scenes)\n scenes = utils.clean_object_attributes(scenes)\n\n # Read the caption templates.\n template_paths = os.listdir(FLAGS.caption_template_root)\n cap_templates = []\n for ii in template_paths:\n with open(os.path.join(FLAGS.caption_template_root, ii), 'r') as file_id:\n cur_templates = json.load(file_id)\n cap_templates.extend(cur_templates)\n #utils.pretty_print_templates(cap_templates, 1)\n\n # Read the question templates.\n template_paths = os.listdir(FLAGS.question_template_root)\n ques_templates = []\n for ii in template_paths:\n with open(os.path.join(FLAGS.question_template_root, ii), 'r') as file_id:\n cur_templates = json.load(file_id)\n ques_templates.extend(cur_templates)\n #utils.pretty_print_templates(ques_templates, 1)\n\n # 1. Check if there a scene_id_file specified.\n # 2. Check if num_images is -1\n if FLAGS.scene_id_file != '':\n with open(FLAGS.scene_id_file, 'r') as file_id:\n missing_ids = [int(ii.strip('\\n')) for ii in file_id.readlines()]\n print('Dialogs missing for scenes: %d' % len(missing_ids))\n\n # Create a image_index -> scenes list index dictionary\n image_list_id_dict = {ii['image_index']: index\n for index, ii in enumerate(scenes['scenes'])}\n scenes_subset = [scenes['scenes'][image_list_id_dict[scene_id]]\n for scene_id in missing_ids]\n\n elif FLAGS.num_images == -1:\n scenes_subset = scenes['scenes']\n\n else:\n scenes_subset = scenes['scenes'][0: FLAGS.num_images]\n\n # BFS for each scene.\n if FLAGS.num_workers == 1:\n # Single thread version.\n dialogs = []\n for index, scene in enumerate(scenes_subset):\n cur_time = time.strftime('%a-%d%b%y-%X', time.gmtime())\n print('Generating [ %s ] [ Worker: %d, Progress: %d/%d Scene: %d ]' %\\\n (cur_time, 0, index, len(scenes_subset), scene['image_index']))\n gen_dialog = generate_dialog_bfs(scene, cap_templates, ques_templates)\n dialogs.append(gen_dialog)\n\n else:\n # Multithread version.\n output_q = multiprocessing.Queue()\n jobs = []\n for worker_id in range(FLAGS.num_workers):\n allotment = scenes_subset[worker_id::FLAGS.num_workers]\n inputs = (allotment, cap_templates, ques_templates)\n inputs += (worker_id, output_q)\n\n process = multiprocessing.Process(target=worker, args=inputs)\n jobs.append(process)\n process.start()\n\n # Wait for all the jobs to finish and collect the output.\n final_results = {}\n for _ in jobs:\n final_results.update(output_q.get())\n for job in jobs:\n job.join()\n\n # Flatten and sort.\n final_results = [jj for _, ii in final_results.items() for jj in ii]\n dialogs = sorted(final_results, key=lambda x: x['image_index'])\n # utils.pretty_print_dialogs(dialogs)\n\n # Save the dialogs.\n print('Saving dialog at: %s' % FLAGS.save_path)\n with open(FLAGS.save_path, 'w') as file_id:\n json.dump(dialogs, file_id)","def test_evolve_load_generation(logger):\n\n generations = 2\n layers.packet.Packet.reset_restrictions()\n\n options = {}\n options[\"population_size\"] = 2\n options[\"in-trees\"] = 0\n options[\"out-trees\"] = 1\n options[\"in-actions\"] = 0\n options[\"out-actions\"] = 3\n options[\"library\"] = False\n options[\"seed\"] = None\n\n for generation_index in range(generations):\n population = []\n population_str = ''\n\n # Generate random strategies to initialize the population\n for i in range(options[\"population_size\"]):\n p = evolve.generate_strategy(logger, options[\"in-trees\"], options[\"out-trees\"], options[\"in-actions\"],\n options[\"out-actions\"],\n options[\"seed\"], environment_id=None)\n print(str(p))\n actions.utils.parse(str(p), logger)\n population.append(p)\n if i == options[\"population_size\"] - 1:\n population_str += str(p)\n else:\n population_str += str(p) + \"\\n\"\n\n # Write the generation file\n filename = os.path.join(test_files_directory, \"generation\" + str(generation_index))\n evolve.write_generation(filename, population)\n\n cmd = [\n \"--population\", \"3\",\n \"--generations\", \"1\",\n \"--test-type\", \"http\",\n \"--load-from\", filename,\n \"--port\", \"80\",\n \"--protos\", \"ip,udp,tcp,dns,dnsqr\",\n \"--censor\", \"censor2\",\n \"--log\", \"debug\",\n \"--no-skip-empty\",\n ]\n print(evolve.driver(cmd))","def main(args):\n corpus = read_corpus(args, verbose=True)\n for k in sorted(corpus, key=educe.stac.id_to_path):\n doc = corpus[k]\n print(\"========== %s ============\" % k)\n print()\n if args.edges:\n dialogues = sorted_first_widest(filter(is_dialogue, doc.units))\n if dialogues:\n d_first = dialogues[0]\n print(annotate_doc(doc, span=d_first.text_span()))\n if len(dialogues) > 1:\n d_last = dialogues[-1]\n txt = annotate_doc(doc, span=d_last.text_span())\n print(\"...\\n\")\n print(txt.encode('utf-8'))\n else:\n print(annotate_doc(doc).encode('utf-8'))\n print()","def main():\n client = SlackClient(ACCESS_TOKEN)\n\n if not client.rtm_connect(with_team_state=False):\n print(\"could not connect to slack\")\n sys.exit(1)\n\n print(\"connected to network!\")\n\n bot_id = client.api_call(\"auth.test\")[\"user_id\"]\n\n for data in tagged_messages(client, bot_id):\n if any(x in data.get(\"text\") for x in [\"lunch\", \"eat\", \"hungry\"]):\n whats_for_lunch(client, data)\n continue","def main():\n\n cwd = os.path.realpath(__file__)\n plugin_dir = os.path.join(os.path.dirname(cwd), 'plugins')\n plugins = {\n name.replace('greet_', ''): importlib.import_module('plugins.' + name)\n for _, name, _ in pkgutil.iter_modules(path=[plugin_dir])\n if name.startswith('greet_')\n }\n\n args = get_args(plugins)\n\n print(plugins[args.language].greet(args.name))","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-w\", \"--workflow_path\", help='Path to workflow file')\n parser.add_argument(\"-g\", \"--galaxy\",\n dest=\"galaxy_url\",\n help=\"Target Galaxy instance URL/IP address (required \"\n \"if not defined in the tools list file)\",)\n parser.add_argument(\"-a\", \"--apikey\",\n dest=\"api_key\",\n help=\"Galaxy admin user API key (required if not \"\n \"defined in the tools list file)\",)\n args = parser.parse_args()\n\n gi = galaxy.GalaxyInstance(url=args.galaxy_url, key=args.api_key)\n\n with open(args.workflow_path, 'r') as wf_file:\n import_uuid = json.load(wf_file).get('uuid')\n existing_uuids = [d.get('latest_workflow_uuid') for d in gi.workflows.get_workflows()]\n if import_uuid not in existing_uuids:\n gi.workflows.import_workflow_from_local_path(args.workflow_path)","def main():\n tot = []\n with open(intersect) as fil:\n for line in fil:\n data = []\n if len(line) > 1:\n rec = int_parse(line)\n win = find_winID(rec.wst, w)\n if int(rec.gst) != -1:\n imp = rec.info.rstrip().split(';')\n ID = imp[0].split('=')[1]\n Name = imp[1].split('=')[1]\n if imp[2].startswith('fullname'):\n fullname = imp[2].split('=')[1]\n if imp[3].startswith('Alias'):\n Alias = imp[3].split('=')[1]\n Ontology_term = imp[4].split('=')[1]\n Dbxref = imp[5].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n Alias = 'NA'\n Ontology_term = imp[3].split('=')[1]\n Dbxref = imp[4].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n fullname = 'NA'\n if imp[2].startswith('Alias'):\n Alias = imp[2].split('=')[1]\n Ontology_term = imp[3].split('=')[1]\n Dbxref = imp[4].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n Alias = 'NA'\n Ontology_term = imp[2].split('=')[1]\n Dbxref = imp[3].split('=')[1]\n GO, _ = split_ont(Ontology_term)\n _, SO = split_ont(Ontology_term)\n gst = rec.gst\n gen = rec.gen\n else:\n ID = 'NA'\n Name = 'NA'\n fullname = 'NA'\n gst = 'NA'\n gen = 'NA'\n Alias = 'NA'\n GO = 'NA'\n SO = 'NA'\n Dbxref = 'NA'\n data.append(ID)\n data.append(Name)\n data.append(fullname)\n data.append(gst)\n data.append(gen)\n data.append(Alias)\n data.append(GO)\n data.append(SO)\n data.append(Dbxref)\n data.append(rec.chrom)\n data.append(win)\n tot.append(tuple(data))\n writeTable(tot)","def main():\n\tnews = Googlenews()\n\tnews.gnews()","def get_doc_prov(j, gcis_url, refList):\n gcis_ns = \"https://gcis-search-stage.jpl.net:3000/gcis.owl#\"\n doc = ProvEsDocument()\n bndl = None\n \n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\n# for ref in refList:\n# if ref['child_publication'] == j['uri']:\n \n\n\n doc_attrs = [\n (\"prov:type\", 'gcis:Article'),\n (\"prov:label\", j['title']),\n (\"prov:location\", j['uri']),\n #(\"prov:wasAttributedTo\", j['']),\n ]\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\n\n prov_json = json.loads(doc.serialize())\n\n return prov_json","def find_mgrs_intersection_large(footprint):\n\n polygon_geom = ogr.CreateGeometryFromWkt(footprint)\n\n mgrs_grid_file_dir = Path(DATA_DIR, 'MGRS_100kmSQ_ID')\n\n mgrs_master_shp_file = Path(mgrs_grid_file_dir, 'mgrs_gzd_final.shp')\n\n shapefile_driver = ogr.GetDriverByName(\"ESRI Shapefile\")\n\n print(mgrs_master_shp_file)\n\n grid_ds = shapefile_driver.Open(str(mgrs_master_shp_file), 0)\n\n layer = grid_ds.GetLayer()\n\n # sourceSR = layer.GetSpatialRef()\n # targetSR = osr.SpatialReference()\n # targetSR.ImportFromEPSG(4326) # WGS84\n # coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)\n\n feature_count = layer.GetFeatureCount()\n print(f\"Number of features in {os.path.basename(mgrs_master_shp_file)}: {feature_count}\")\n layerDefinition = layer.GetLayerDefn()\n\n for i in range(layerDefinition.GetFieldCount()):\n print(layerDefinition.GetFieldDefn(i).GetName())\n\n intersect_list = []\n\n for f in layer:\n # print feature.GetField(\"STATE_NAME\")\n # geom = feature.GetGeometryRef()\n # print(geom.Centroid().ExportToWkt())\n # geom_list.append(geom)\n # print(geom)\n\n geom = f.GetGeometryRef()\n # print(geom)\n # print(polygon_geom)\n intersect_result = geom.Intersection(polygon_geom)\n # print(intersect_result)\n if not intersect_result.IsEmpty():\n print(\"FOUND INTERSECT\")\n print(f.GetField('gzd'))\n intersect_list.append(f.GetField('gzd'))\n\n # # iterate over the geometries and dissolve all into one\n # layer = dataSource.GetLayer()\n # layerDefinition = layer.GetLayerDefn()\n\n # for i in range(layerDefinition.GetFieldCount()):\n # print(layerDefinition.GetFieldDefn(i).GetName())\n\n # Collect all Geometry\n # geomcol = ogr.Geometry(ogr.wkbGeometryCollection)\n # Create the feature and set values\n # featureDefn = outLayer.GetLayerDefn()\n # feature = ogr.Feature(featureDefn)\n\n # multipoly = ogr.Geometry(ogr.wkbMultiPolygon)\n # for feature in inLayer:\n # geomcol.AddGeometry(feature.GetGeometryRef())\n\n # geom_list = []\n\n\n # geomcol.AddGeometry(geom)\n\n # if problem_child:\n # # print(file_stem_split)\n # # print(geom)\n # print(geom.IsValid())\n # # print(idx)\n # pass\n # if file_stem_split in ['59Q']:\n # print(geom)\n # print(geom.GetGeometryName())\n\n\n\n\n # spatial_ref = osr.SpatialReference()\n # spatial_ref.ImportFromEPSG(4326)\n\n # outLayer = outDataSource.CreateLayer(\"gzd_8x6_degree\", spatial_ref, geom_type=ogr.wkbMultiPolygon)\n\n # # Add an ID field\n # idField = ogr.FieldDefn(\"id\", ogr.OFTInteger)\n # outLayer.CreateField(idField)\n # gzdField = ogr.FieldDefn(\"gzd\", ogr.OFTString)\n # outLayer.CreateField(gzdField)\n\n # for idx, file_name in enumerate(Path(target_dir).iterdir()):\n # problem_child = False\n # print(idx)\n # if file_name.suffix == '.zip':\n # # print(file_name)\n # print('Found a zip file')\n # file_name_only = file_name.name\n # file_name_stem = file_name.stem\n # # print(file_name_only)\n # # print(file_name_stem)\n\n # file_stem_split = file_name_stem.split('_')[-1]\n\n # print(file_stem_split)\n\n # # if file_stem_split not in ['59Q']:\n # # continue\n\n # if file_stem_split in ['Antarctica', 'Arctic']:\n # continue\n\n # with zipfile.ZipFile(file_name, 'r') as zf:\n # # zf.extractall('temp_unzip')\n # actual_file_stem = \"\"\n # for zip_info in zf.infolist():\n # print(zip_info.filename)\n\n # if zip_info.filename[-1] == '/':\n # continue\n\n # zip_info.filename = zip_info.filename.split('/')[-1]\n # if actual_file_stem == \"\":\n # actual_file_stem = zip_info.filename.split('.')[0]\n # zf.extract(zip_info, temp_zip_dir)\n\n # if actual_file_stem != file_name_stem:\n # file_name_stem = actual_file_stem\n\n # file_path = Path(temp_zip_dir, file_name_stem + '.shp')\n\n # print(file_path)\n\n # dataSource = outDriver.Open(str(file_path), 0) # 0 means read-only. 1 means writeable.\n\n # if dataSource is None:\n # print(f'Could not open {file_path}')\n # else:\n # print(f'Opened {file_path}')\n # layer = dataSource.GetLayer()\n\n # sourceSR = layer.GetSpatialRef()\n # targetSR = osr.SpatialReference()\n # targetSR.ImportFromEPSG(4326) # WGS84\n\n # coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)\n\n # if file_stem_split in ['01R', '01S', '01K', '01J', '01H']:\n # # print('WE GOT A PROBLEM CHILD HERE')\n # # print('\\n\\n\\n\\n')\n # problem_child = True\n\n\n # featureCount = layer.GetFeatureCount()\n # print(f\"Number of features in {os.path.basename(file_path)}: {featureCount}\")\n\n # # # iterate over the geometries and dissolve all into one\n # # layer = dataSource.GetLayer()\n # # layerDefinition = layer.GetLayerDefn()\n\n # # for i in range(layerDefinition.GetFieldCount()):\n # # print(layerDefinition.GetFieldDefn(i).GetName())\n\n # # Collect all Geometry\n # geomcol = ogr.Geometry(ogr.wkbGeometryCollection)\n # # Create the feature and set values\n # featureDefn = outLayer.GetLayerDefn()\n # feature = ogr.Feature(featureDefn)\n\n # multipoly = ogr.Geometry(ogr.wkbMultiPolygon)\n # # for feature in inLayer:\n # # geomcol.AddGeometry(feature.GetGeometryRef())\n\n # # geom_list = []\n # for f in layer:\n # # print feature.GetField(\"STATE_NAME\")\n # # geom = feature.GetGeometryRef()\n # # print(geom.Centroid().ExportToWkt())\n # # geom_list.append(geom)\n # # print(geom)\n\n # geom = f.GetGeometryRef()\n # geom.Transform(coordTrans)\n\n # # geomcol.AddGeometry(geom)\n\n # if problem_child:\n # # print(file_stem_split)\n # # print(geom)\n # print(geom.IsValid())\n # # print(idx)\n # pass\n # if file_stem_split in ['59Q']:\n # print(geom)\n # print(geom.GetGeometryName())\n\n # if idx > 18 and idx < 1176:\n # if file_stem_split in ['59Q']:\n # print(geom)\n # print(geom.GetGeometryName())\n # if geom.GetGeometryName() == 'MULTIPOLYGON':\n # for i in range(0, geom.GetGeometryCount()):\n # g = geom.GetGeometryRef(i)\n # # print(g.GetGeometryName())\n # multipoly.AddGeometry(g)\n\n\n # else:\n # multipoly.AddGeometry(geom)\n # elif idx > 1176:\n # sub_geom = geom.GetGeometryRef(0)\n # # print(sub_geom)\n # # print(sub_geom.GetPointCount())\n\n # outRing = ogr.Geometry(ogr.wkbLinearRing)\n # # outRing.AddPoint(1154115.274565847, 686419.4442701361)\n\n # # Create inner ring\n # # innerRing = ogr.Geometry(ogr.wkbLinearRing)\n # # innerRing.AddPoint(1149490.1097279799, 691044.6091080031)\n\n # # Create polygon\n # poly = ogr.Geometry(ogr.wkbPolygon)\n # # poly.AddGeometry(outRing)\n # # poly.AddGeometry(innerRing)\n\n # for i in range(0, sub_geom.GetPointCount()):\n # # GetPoint returns a tuple not a Geometry\n # pt = sub_geom.GetPoint(i)\n\n # if pt[0] < 0:\n # point_x = pt[0] * -1\n # point_y = pt[1]\n # else:\n # point_x = pt[0]\n # point_y = pt[1]\n\n # outRing.AddPoint(point_x, point_y)\n # # print(\"%i). POINT (%f %f)\" %(i, point_x, point_y))\n\n # poly.AddGeometry(outRing)\n\n\n\n # multipoly.AddGeometry(poly)\n # else:\n # sub_geom = geom.GetGeometryRef(0)\n # # print(sub_geom)\n # # print(sub_geom.GetPointCount())\n\n # outRing = ogr.Geometry(ogr.wkbLinearRing)\n # # outRing.AddPoint(1154115.274565847, 686419.4442701361)\n\n # # Create inner ring\n # # innerRing = ogr.Geometry(ogr.wkbLinearRing)\n # # innerRing.AddPoint(1149490.1097279799, 691044.6091080031)\n\n # # Create polygon\n # poly = ogr.Geometry(ogr.wkbPolygon)\n # # poly.AddGeometry(outRing)\n # # poly.AddGeometry(innerRing)\n\n # for i in range(0, sub_geom.GetPointCount()):\n # # GetPoint returns a tuple not a Geometry\n # pt = sub_geom.GetPoint(i)\n\n # if pt[0] > 0:\n # point_x = pt[0] * -1\n # point_y = pt[1]\n # else:\n # point_x = pt[0]\n # point_y = pt[1]\n\n # outRing.AddPoint(point_x, point_y)\n # # print(\"%i). POINT (%f %f)\" %(i, point_x, point_y))\n\n # poly.AddGeometry(outRing)\n\n\n\n # multipoly.AddGeometry(poly)\n\n # # layer.ResetReading()\n\n # # print(feature)\n\n # cascade_union = multipoly.UnionCascaded()\n # feature.SetGeometry(cascade_union)\n\n # # convexhull = geomcol.ConvexHull()\n # # feature.SetGeometry(convexhull)\n\n # file_name_split = file_name_stem.split('_')\n # gzd_from_file_name = file_name_split[-1]\n # # print(idx + 1)\n\n # feature.SetField(\"id\", idx + 1)\n # feature.SetField(\"gzd\", gzd_from_file_name)\n\n # outLayer.CreateFeature(feature)\n\n # feature = None\n\n # # Save and close DataSource\n # dataSource = None\n\n # for file_name in Path(temp_zip_dir).iterdir():\n # os.remove(file_name)\n\n # # if idx > 20:\n # # break\n\n # # all done!\n grid_ds = None\n\n return intersect_list","def run():\n\n api = api_start()\n stonks = {}\n check_function = load_symbol_list()\n for obj in (\"comments\", \"submissions\"):\n for post in get_text(api, obj):\n if obj == \"comments\":\n full_text = post.body\n else: # obj == \"submissions\"\n full_text = post.title + post.selftext\n try:\n stonks = check_texts(\n full_text, post.author.name, stonks, check_function\n )\n except AttributeError:\n pass\n\n return stonks","def intronDiscovery(poolArguement):\n\n\tbamFiles, gene, chrom, start, stop, cwd = poolArguement\n\n\tprint ('processing ' + gene)\n\n\tpos = ''.join([chrom, ':', start, '-', stop])\n\n\tfor bam in bamFiles:\n\n\t\tspliceDict = {}\n\t\tgeneFilePath = (cwd + \"/\" + bam[:-4] + \"/\" + gene + \".txt\")\n\n\t\ttry:\n\t\t\texitcode, stdout, stderr = run(' '.join(['samtools view', bam, pos]))\n\t\texcept Exception as e:\n\t\t\tprint ('Exception message: ' + str(e))\n\t\t\tprint (\"Exception occured while running \\\"samtools view\\\" on \" + bam + \" for position \" + pos + \" Skipping.\")\n\t\t\tcontinue\n\n\t\tif not stdout:\n\t\t\t#print ('No introns found for ' + gene + ' at ' + pos + ' in ' + bam)\n\t\t\tcontinue\n\n\t\tfor line in stdout.splitlines():\n\n\t\t\telems = line.decode().split()\n\n\t\t\talignmentStart = int(elems[3])\n\t\t\tcigar = str(elems[5])\n\t\t\talignmentScore = int(elems[1])\n \n\t\t\tif 'N' not in cigar: \t#only get introns\n\t\t\t\tcontinue\n\n\t\t\tif (alignmentScore >= 256): \t#only primary alignments\n\t\t\t\tcontinue\n\n\t\t\tif not ((alignmentStart > int(start)) and (alignmentStart < int(stop))): \t#check if alignment start is after known junction start but before known junction end \n\t\t\t\tcontinue\n\n\t\t\ttry:\n\t\t\t\toffset, matchedExon, intronLength = parseCIGARForIntrons(cigar)\n\t\t\texcept Exception as e:\n\t\t\t\tprint ('Error message: ' + str(e))\n\t\t\t\tprint ('Error trying to parse CIGAR string: ' + cigar + ' with the bam file ' + bam + ' and the position: ' + pos + ' Skipping.')\n\t\t\t\tcontinue\n\n\t\t\tjunctionStart = alignmentStart + matchedExon + offset\n\t\t\tjunctionEnd = junctionStart + intronLength\n\n\t\t\t# Beryl Cummings' Code, taken from makeUniqSpliceDict()\n\t\t\t# uniqueSplice = ':'.join([chrom, str(junctionStart), str(junctionEnd)])\n\t\t\tuniqueSplice = (chrom, str(junctionStart), str(junctionEnd))\n\t\t\t\n\t\t\tif uniqueSplice not in spliceDict:\n\t\t\t\tspliceDict[uniqueSplice] = 1\n\t\t\telse:\n\t\t\t\tspliceDict[uniqueSplice] += 1\n\n\t\tdel stdout # saves ram in between samtool calls\n\n\t\tif spliceDict:\n\t\t\tprintSplices(geneFilePath, spliceDict)\n\t\t\tdel spliceDict\n\n\tprint ('finished ' + gene)","def main():\n parser = argparse.ArgumentParser(description='MergeGVCFs and genotype them using the GATK')\n parser.add_argument('-g', '--gatk', dest='gatk', help=\"Location of the GATK\", required=True)\n parser.add_argument('-x', '--xmx', dest='xmx', help=\"Memory to use with JAVA\", required=True)\n parser.add_argument('-c', '--cores', dest='cores', help=\"Number of cores to use\")\n parser.add_argument('-o', '--output', dest='output', \n help='Final output from the haplotype caller')\n parser.add_argument('-r', '--reference', dest='reference', \n help='Reference FASTA file')\n parser.add_argument('-b','--bed', dest='bed_file',\n help=\"Bed file for limiting the GATK\")\n parser.add_argument('-p', '--ploidy', dest='ploidy', \n help=\"Sample ploidy\", default=2)\n parser.add_argument('-d', '--out_directory', dest='directory', help='Output director')\n parser.add_argument('bams', nargs=\"*\", help='gVCF variant call files output from the GATK')\n args = parser.parse_args()\n args.cores = int(args.cores)\n args.xmx = args.xmx.strip('\"')\n print args.bams\n genovcfs = haplotype_caller(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\n bams=args.bams, reference=args.reference,\n out_directory=args.directory, ploidy=args.ploidy, bed_file=args.bed_file)\n outputs = merge_gvcfs(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\n gvcfs=genovcfs, reference=args.reference)\n genotype_gvcfs(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\n inputs=outputs, output=args.output, reference=args.reference,bed_file=args.bed_file)\n #haplotype_single(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\n # inputs=args.gvcfs, reference=args.reference)","def recon_sg2(json_file_dir, if_add_bases=True):\n id2color = {\n \"gray\": [87, 87, 87],\n \"red\": [173, 35, 35],\n \"blue\": [42, 75, 215],\n \"green\": [29, 105, 20],\n \"brown\": [129, 74, 25],\n \"purple\": [129, 38, 192],\n \"cyan\": [41, 208, 208],\n \"yellow\": [255, 238, 51],\n \"c1\": [42, 87, 9],\n \"c2\": [255, 102, 255],\n \"orange\": [255, 140, 0]\n }\n\n color2id = {tuple(v): u for u, v in id2color.items()}\n with open(json_file_dir, 'r') as json_file:\n du = json.load(json_file)\n location_dict = {}\n objects = []\n bboxes = []\n for obj in du[\"objects\"]:\n color = tuple([int(du33*255) for du33 in obj[\"color\"]][:-1])\n object_id = color2id[color]\n a_key = \"%.3f\" % obj[\"location\"][0]\n if a_key not in location_dict:\n location_dict[a_key] = [(object_id, obj[\"location\"][2])]\n else:\n location_dict[a_key].append((object_id, obj[\"location\"][2]))\n objects.append(object_id)\n bboxes.append([\n obj[\"bbox\"][0]/128.0,\n obj[\"bbox\"][1]/128.0,\n obj[\"bbox\"][2]/128.0,\n obj[\"bbox\"][3]/128.0,\n ])\n obj2id = {objects[du4]: objects[du4] for du4 in range(len(objects))}\n if if_add_bases:\n relationships = [\n [obj2id[\"brown\"], \"left\", obj2id[\"purple\"]],\n [obj2id[\"purple\"], \"left\", obj2id[\"cyan\"]],\n ]\n else:\n relationships = []\n for du3 in location_dict:\n location = sorted(location_dict[du3], key=lambda x: x[1])\n while len(location) > 1:\n o1 = location.pop()[0]\n o2 = location[-1][0]\n relationships.append([obj2id[o1], \"up\", obj2id[o2]])\n assert o1 not in [\"cyan\", \"purple\", \"brown\"]\n\n return relationships","def main():\n\n # this will analyze all files in the input_files directory\n for folder in [x for x in os.listdir(os.path.join(os.getcwd(), 'test_directory')) if os.path.isdir(os.path.join(os.getcwd(), 'test_directory', x))]:\n try:\n print(f'Creating GED_Repo for files in {folder}')\n g = GED_Repo([os.path.join(os.getcwd(), 'test_directory', folder, f) for f in os.listdir(os.path.join(os.getcwd(), 'test_directory', folder)) if f.endswith('.ged')])\n g.check_data()\n g.print_data()\n g.print_individuals()\n g.print_families()\n except ValueError as v:\n print(v)\n except FileNotFoundError as f:\n print(f)","def cli(ctx):","def cli(ctx):","def test_pnictogen():\n for template in templates:\n template_prefix, extension = os.path.splitext(template)\n for xyz_file in example_xyz_files:\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\n\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\n )\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\n\n assert_equals(type(written_files), list)\n for written_file in written_files:\n assert_equals(type(written_file), str)\n\n written_files2 = pnictogen(mol, input_prefix, template)\n assert_equals(written_files, written_files2)\n\n # Allow use of template in the parent directory\n with cd(\"pnictogen/repo\"):\n mol = Atoms(\n cclib.bridge.cclib2openbabel.readfile(\"../../data/water-dimer.xyz\", \"xyz\")\n )\n written_files = pnictogen(mol, \"../../data/water-dimer\", \"ADF.in\", \"in\")\n\n assert_equals(written_files, [\"../../data/water-dimer.in\"])\n\n main([\"-g\", \"/tmp/hello.world.ORCA.inp\"])\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\"data/co.xyz\", \"xyz\"))\n written_files = pnictogen(mol, \"data/co\", \"/tmp/hello.world.ORCA.inp\", foo=\"bar\")\n\n assert_equals(written_files, [\"data/co.inp\"])","def main(argv):\n\tendpoint = \"C\"\n\tif len(argv) > 0:\n\t\tendpoint = argv[0]\t\t\n\t\n\tsite_map = {}\n\tsite_map[\"5 Major Pooled\"] = [\"Agogo\", \"Kintampo\", \"Kombewa\", \"Nanoro\", \"Siaya\"]\n\tsite_map[\"11 Pooled\"] = [\"Agogo\", \"Kintampo\", \"Kombewa\", \"Nanoro\", \"Siaya\", \"Bagamoyo\", \"Kilifi\", \"Korogwe\", \"Lambarene\", \"Lilongwe\", \"Manhica\"]\n\tstart_map = {}\n\tstart_map[\"TEP\"] = 294\n\tstart_map[\"SERA2\"] = 36\n\tend_map = {}\n\tend_map[\"TEP\"] = 387\n\tend_map[\"SERA2\"] = 119\n\t\n\tthreshold_map = {}\n\tthreshold_map[\"TEP_5 Major Pooled_6-12 Weeks_C\"] = 4\n\tthreshold_map[\"TEP_11 Pooled_6-12 Weeks_C\"] = 4\n\tthreshold_map[\"TEP_5 Major Pooled_5-17 Months_C\"] = 4\n\tthreshold_map[\"TEP_11 Pooled_5-17 Months_C\"] = 4\t\n\tthreshold_map[\"TEP_5 Major Pooled_6-12 Weeks_X\"] = 3\n\tthreshold_map[\"TEP_11 Pooled_6-12 Weeks_X\"] = 3\n\tthreshold_map[\"TEP_5 Major Pooled_5-17 Months_X\"] = 4\n\tthreshold_map[\"TEP_11 Pooled_5-17 Months_X\"] = 4\t\n\t\n\tthreshold_map[\"SERA2_5 Major Pooled_6-12 Weeks_C\"] = 4\n\tthreshold_map[\"SERA2_11 Pooled_6-12 Weeks_C\"] = 4\n\tthreshold_map[\"SERA2_5 Major Pooled_5-17 Months_C\"] = 4\n\tthreshold_map[\"SERA2_11 Pooled_5-17 Months_C\"] = 4\t\n\tthreshold_map[\"SERA2_5 Major Pooled_6-12 Weeks_X\"] = 4\n\tthreshold_map[\"SERA2_11 Pooled_6-12 Weeks_X\"] = 3\n\tthreshold_map[\"SERA2_5 Major Pooled_5-17 Months_X\"] = 4\n\tthreshold_map[\"SERA2_11 Pooled_5-17 Months_X\"] = 4\t\t\t\n\t\t\n\tdata = get_data(endpoint)\n\t\n\tprint \"locus\\tsite\\tcohort\\taa\"\n\n\tfor locus in [\"SERA2\"]:\n\t\tfor site_group in [\"5 Major Pooled\", \"11 Pooled\"]:\n\t\t\tfor cohort in [\"6-12 Weeks\", \"5-17 Months\"]:\t\t\n\t\t\t\tsubset = subset_data(data, locus, site_map[site_group], cohort)\n\t\t\t\tthreshold = threshold_map[\"_\".join([locus, site_group, cohort, endpoint])]\n\t\t\t\taa_sites = get_filtered_sites(subset, start_map[locus], end_map[locus], threshold)\n\t\t\t\tprint_filtered_sites(locus, site_group, cohort, aa_sites)","def get_go():\n # decompress obo file if it wasn't yet\n if not os.path.exists(OBO_FILE):\n _decompress_obofile()\n # create global variable\n if __GO__[0] is None:\n __GO__[0] = onto.Ontology(OBO_FILE, with_rels=True, include_alt_ids=False)\n return __GO__[0]","def build_gallery(\n include_core: bool = True,\n include_contrib: bool = True,\n ignore_suppress: bool = False,\n ignore_only_for: bool = False,\n only_these_expectations: List[str] = [],\n only_consider_these_backends: List[str] = [],\n context: Optional[DataContext] = None,\n) -> Dict:\n gallery_info = dict()\n requirements_dict = {}\n logger.info(\"Loading great_expectations library.\")\n installed_packages = pkg_resources.working_set\n installed_packages_txt = sorted(f\"{i.key}=={i.version}\" for i in installed_packages)\n logger.debug(f\"Found the following packages: {installed_packages_txt}\")\n\n expectation_file_info = get_expectation_file_info_dict(\n include_core=include_core,\n include_contrib=include_contrib,\n only_these_expectations=only_these_expectations,\n )\n import great_expectations\n\n core_expectations = (\n great_expectations.expectations.registry.list_registered_expectation_implementations()\n )\n if include_core:\n print(\"\\n\\n\\n=== (Core) ===\")\n logger.info(\"Getting base registered expectations list\")\n logger.debug(f\"Found the following expectations: {sorted(core_expectations)}\")\n for expectation in core_expectations:\n if only_these_expectations and expectation not in only_these_expectations:\n # logger.debug(f\"Skipping {expectation} since it's not requested\")\n continue\n requirements_dict[expectation] = {\"group\": \"core\"}\n\n just_installed = set()\n failed_to_import_set = set()\n\n if include_contrib:\n print(\"\\n\\n\\n=== (Contrib) ===\")\n logger.info(\"Finding contrib modules\")\n skip_dirs = (\"cli\", \"tests\")\n contrib_dir = os.path.join(\n os.path.dirname(__file__),\n \"..\",\n \"..\",\n \"contrib\",\n )\n\n for root, dirs, files in os.walk(contrib_dir):\n for dirname in skip_dirs:\n if dirname in dirs:\n dirs.remove(dirname)\n if \"expectations\" in dirs:\n if root.endswith(\"great_expectations_experimental\"):\n sys.path.append(root)\n else:\n # A package in contrib that may contain more Expectations\n sys.path.append(os.path.dirname(root))\n for filename in files:\n if filename.endswith(\".py\") and filename.startswith(\"expect_\"):\n if (\n only_these_expectations\n and filename.replace(\".py\", \"\") not in only_these_expectations\n ):\n # logger.debug(f\"Skipping {filename} since it's not requested\")\n continue\n logger.debug(f\"Getting requirements for module {filename}\")\n contrib_subdir_name = os.path.basename(os.path.dirname(root))\n requirements_dict[filename[:-3]] = get_contrib_requirements(\n os.path.join(root, filename)\n )\n requirements_dict[filename[:-3]][\"group\"] = contrib_subdir_name\n logger.info(\"Done finding contrib modules\")\n\n for expectation in sorted(requirements_dict):\n # Temp\n if expectation in [\n \"expect_column_kl_divergence_to_be_less_than\", # Infinity values break JSON\n \"expect_column_values_to_be_valid_arn\", # Contrib Expectation where pretty much no test passes on any backend\n ]:\n continue\n group = requirements_dict[expectation][\"group\"]\n print(f\"\\n\\n\\n=== {expectation} ({group}) ===\")\n requirements = requirements_dict[expectation].get(\"requirements\", [])\n parsed_requirements = pkg_resources.parse_requirements(requirements)\n for req in parsed_requirements:\n is_satisfied = any(\n [installed_pkg in req for installed_pkg in installed_packages]\n )\n if is_satisfied or req in just_installed:\n continue\n logger.debug(f\"Executing command: 'pip install \\\"{req}\\\"'\")\n status_code = execute_shell_command(f'pip install \"{req}\"')\n if status_code == 0:\n just_installed.add(req)\n else:\n expectation_tracebacks.write(\n f\"\\n\\n----------------\\n{expectation} ({group})\\n\"\n )\n expectation_tracebacks.write(f\"Failed to pip install {req}\\n\\n\")\n\n if group != \"core\":\n logger.debug(f\"Importing {expectation}\")\n try:\n if group == \"great_expectations_experimental\":\n importlib.import_module(f\"expectations.{expectation}\", group)\n else:\n importlib.import_module(f\"{group}.expectations\")\n except (ModuleNotFoundError, ImportError, Exception) as e:\n logger.error(f\"Failed to load expectation: {expectation}\")\n print(traceback.format_exc())\n expectation_tracebacks.write(\n f\"\\n\\n----------------\\n{expectation} ({group})\\n\"\n )\n expectation_tracebacks.write(traceback.format_exc())\n failed_to_import_set.add(expectation)\n continue\n\n logger.debug(f\"Running diagnostics for expectation: {expectation}\")\n try:\n impl = great_expectations.expectations.registry.get_expectation_impl(\n expectation\n )\n diagnostics = impl().run_diagnostics(\n ignore_suppress=ignore_suppress,\n ignore_only_for=ignore_only_for,\n debug_logger=logger,\n only_consider_these_backends=only_consider_these_backends,\n context=context,\n )\n checklist_string = diagnostics.generate_checklist()\n expectation_checklists.write(\n f\"\\n\\n----------------\\n{expectation} ({group})\\n\"\n )\n expectation_checklists.write(f\"{checklist_string}\\n\")\n if diagnostics[\"description\"][\"docstring\"]:\n diagnostics[\"description\"][\"docstring\"] = format_docstring_to_markdown(\n diagnostics[\"description\"][\"docstring\"]\n )\n except Exception:\n logger.error(f\"Failed to run diagnostics for: {expectation}\")\n print(traceback.format_exc())\n expectation_tracebacks.write(\n f\"\\n\\n----------------\\n{expectation} ({group})\\n\"\n )\n expectation_tracebacks.write(traceback.format_exc())\n else:\n try:\n gallery_info[expectation] = diagnostics.to_json_dict()\n gallery_info[expectation][\"created_at\"] = expectation_file_info[\n expectation\n ][\"created_at\"]\n gallery_info[expectation][\"updated_at\"] = expectation_file_info[\n expectation\n ][\"updated_at\"]\n gallery_info[expectation][\"package\"] = expectation_file_info[\n expectation\n ][\"package\"]\n gallery_info[expectation][\"exp_type\"] = expectation_file_info[\n expectation\n ].get(\"exp_type\")\n except TypeError as e:\n logger.error(f\"Failed to create JSON for: {expectation}\")\n print(traceback.format_exc())\n expectation_tracebacks.write(\n f\"\\n\\n----------------\\n[JSON write fail] {expectation} ({group})\\n\"\n )\n expectation_tracebacks.write(traceback.format_exc())\n\n if just_installed:\n print(\"\\n\\n\\n=== (Uninstalling) ===\")\n logger.info(\n f\"Uninstalling packages that were installed while running this script...\"\n )\n for req in just_installed:\n logger.debug(f\"Executing command: 'pip uninstall -y \\\"{req}\\\"'\")\n execute_shell_command(f'pip uninstall -y \"{req}\"')\n\n expectation_filenames_set = set(requirements_dict.keys())\n full_registered_expectations_set = set(\n great_expectations.expectations.registry.list_registered_expectation_implementations()\n )\n if only_these_expectations:\n registered_expectations_set = (\n set(only_these_expectations) & full_registered_expectations_set\n )\n expectation_filenames_set = (\n set(only_these_expectations) & expectation_filenames_set\n )\n elif not include_core:\n registered_expectations_set = full_registered_expectations_set - set(\n core_expectations\n )\n else:\n registered_expectations_set = full_registered_expectations_set\n non_matched_filenames = (\n expectation_filenames_set - registered_expectations_set - failed_to_import_set\n )\n if failed_to_import_set:\n expectation_tracebacks.write(f\"\\n\\n----------------\\n(Not a traceback)\\n\")\n expectation_tracebacks.write(\"Expectations that failed to import:\\n\")\n for expectation in sorted(failed_to_import_set):\n expectation_tracebacks.write(f\"- {expectation}\\n\")\n if non_matched_filenames:\n expectation_tracebacks.write(f\"\\n\\n----------------\\n(Not a traceback)\\n\")\n expectation_tracebacks.write(\n \"Expectation filenames that don't match their defined Expectation name:\\n\"\n )\n for fname in sorted(non_matched_filenames):\n expectation_tracebacks.write(f\"- {fname}\\n\")\n\n bad_names = sorted(\n list(registered_expectations_set - expectation_filenames_set)\n )\n expectation_tracebacks.write(\n f\"\\nRegistered Expectation names that don't match:\\n\"\n )\n for exp_name in bad_names:\n expectation_tracebacks.write(f\"- {exp_name}\\n\")\n\n if include_core and not only_these_expectations:\n core_dir = os.path.join(\n os.path.dirname(__file__),\n \"..\",\n \"..\",\n \"great_expectations\",\n \"expectations\",\n \"core\",\n )\n core_expectations_filename_set = {\n fname.rsplit(\".\", 1)[0]\n for fname in os.listdir(core_dir)\n if fname.startswith(\"expect_\")\n }\n core_expectations_not_in_gallery = core_expectations_filename_set - set(\n core_expectations\n )\n if core_expectations_not_in_gallery:\n expectation_tracebacks.write(f\"\\n\\n----------------\\n(Not a traceback)\\n\")\n expectation_tracebacks.write(\n f\"Core Expectation files not included in core_expectations:\\n\"\n )\n for exp_name in sorted(core_expectations_not_in_gallery):\n expectation_tracebacks.write(f\"- {exp_name}\\n\")\n\n return gallery_info","def support(self):","def test_charged_ligand():\n imatinib_path = examples_paths()['imatinib']\n with mmtools.utils.temporary_directory() as tmp_dir:\n # receptors = {'Asp': -1, 'Abl': -8} # receptor name -> net charge\n # Only run `Asp` on CI as Abl can be very slow\n receptors = {'Asp': -1} # receptor name -> net charge\n solvent_names = ['PME', 'PMEionic']\n updates = yank_load(\"\"\"\n molecules:\n Asp:\n name: \"(3S)-3-amino-4-hydroxy-4-oxo-butanoate\"\n openeye: {{quacpac: am1-bcc}}\n antechamber: {{charge_method: null}}\n imatinib:\n filepath: {}\n openeye: {{quacpac: am1-bcc}}\n antechamber: {{charge_method: null}}\n explicit-system:\n receptor: !Combinatorial {}\n ligand: imatinib\n pack: yes\n solvent: !Combinatorial {}\n \"\"\".format(imatinib_path, list(receptors.keys()), solvent_names))\n yaml_content = get_template_script(tmp_dir, keep_openeye=True)\n yaml_content['options']['resume_setup'] = True\n yaml_content['molecules'].update(updates['molecules'])\n yaml_content['solvents']['PMEionic'] = copy.deepcopy(yaml_content['solvents']['PME'])\n yaml_content['solvents']['PMEionic']['ionic_strength'] = '10*millimolar'\n yaml_content['systems']['explicit-system'].update(updates['explicit-system'])\n exp_builder = ExperimentBuilder(yaml_content)\n\n for receptor in receptors:\n\n for solvent_name in solvent_names:\n system_id = 'explicit-system_{}_{}'.format(receptor, solvent_name)\n system_files_paths = exp_builder._db.get_system(system_id)\n for i, phase_name in enumerate(['complex', 'solvent']):\n inpcrd_file_path = system_files_paths[i].position_path\n prmtop_file_path = system_files_paths[i].parameters_path\n\n system, topology, _ = pipeline.read_system_files(\n inpcrd_file_path, prmtop_file_path, {'nonbondedMethod': openmm.app.PME})\n\n # Identify components.\n if phase_name == 'complex':\n alchemical_region = 'ligand_atoms'\n topography = Topography(topology, ligand_atoms='resname MOL')\n\n # Safety check: receptor must be negatively charged as expected\n receptor_net_charge = pipeline.compute_net_charge(system,\n topography.receptor_atoms)\n assert receptor_net_charge == receptors[receptor]\n else:\n alchemical_region = 'solute_atoms'\n topography = Topography(topology)\n\n # There is a single ligand/solute counterion.\n ligand_counterions = pipeline.find_alchemical_counterions(system, topography,\n alchemical_region)\n assert len(ligand_counterions) == 1\n ion_idx = ligand_counterions[0]\n ion_atom = next(itertools.islice(topology.atoms(), ion_idx, None))\n assert '-' in ion_atom.residue.name\n\n # In complex, there should be both ions even if the system is globally\n # neutral (e.g. asp lys system), because of the alchemical ion.\n n_pos_ions, n_neg_ions, n_ionic_strength_ions = get_number_of_ions(\n exp_builder, phase=phase_name, system_id=system_id)\n print(system_id, phase_name, n_ionic_strength_ions, n_pos_ions, n_neg_ions)\n\n # Check correct number of ions.\n if phase_name == 'complex':\n n_neutralization_ions = abs(receptors[receptor])\n if n_ionic_strength_ions > 0:\n n_neutralization_ions -= 1 # we don't add an extra anion to alchemically modify\n assert n_pos_ions == n_neutralization_ions + n_ionic_strength_ions\n assert n_neg_ions == max(1, n_ionic_strength_ions)\n else:\n assert n_pos_ions == n_ionic_strength_ions\n assert n_neg_ions == 1 + n_ionic_strength_ions","def main():\n\n allowed_splitlevels = (1, 99)\n parser = argparse.ArgumentParser(description=main.__doc__, epilog='Homepage: https://github.com/kbat/mc-tools')\n parser.add_argument('-splitlevel', dest='splitlevel', type=int, help='split level (see TTree::Branch documentation)', required=False, default=1, choices=allowed_splitlevels)\n parser.add_argument('wssa', type=str, help='ssw output file name')\n arguments = parser.parse_args()\n\n fin_name = arguments.wssa\n fout_name = fin_name + \".root\"\n\n hits = ROOT.hit_t()\n\n ssw = SSW(fin_name)\n\n fout = ROOT.TFile(fout_name, \"recreate\", ssw.getTitle())\n T = ROOT.TTree(\"T\", ssw.probs)\n# T.SetMaxTreeSize((Long64_t)1e+18)\n\n if arguments.splitlevel==99:\n T.Branch(\"hits\", hits, \"history:id:weight:energy:time:x:y:z:wx:wy:k\")\n elif arguments.splitlevel == 1:\n T.Branch(\"history\", ROOT.AddressOf(hits, 'history'), \"history\")\n T.Branch(\"id\", ROOT.AddressOf(hits, 'id'), \"id\")\n T.Branch(\"weight\", ROOT.AddressOf(hits, 'weight'), \"weight\")\n T.Branch(\"energy\", ROOT.AddressOf(hits, 'energy'), \"energy\")\n T.Branch(\"time\", ROOT.AddressOf(hits, 'time'), \"time\")\n T.Branch(\"x\", ROOT.AddressOf(hits, 'x'), \"x\")\n T.Branch(\"y\", ROOT.AddressOf(hits, 'y'), \"y\")\n T.Branch(\"z\", ROOT.AddressOf(hits, 'z'), \"z\")\n T.Branch(\"wx\", ROOT.AddressOf(hits, 'wx'), \"wx\")\n T.Branch(\"wy\", ROOT.AddressOf(hits, 'wy'), \"wy\")\n T.Branch(\"k\", ROOT.AddressOf(hits, 'k'), \"k\")\n\n for i in range(ssw.nevt):\n ssb = ssw.readHit()\n hits.history = ssb[0] # >0 = with collision, <0 = without collision\n hits.id = ssb[1] # surface + particle type + multigroup problem info\n hits.weight = ssb[2]\n hits.energy = ssb[3] # [MeV]\n hits.time = ssb[4] # [shakes]\n hits.x = ssb[5] # [cm]\n hits.y = ssb[6] # [cm]\n hits.z = ssb[7] # [cm]\n hits.wx = ssb[8]\n hits.wy = ssb[9]\n hits.k = ssb[10] # cosine of angle between track and normal to surface jsu (in MCNPX it is called cs)\n T.Fill()\n \n sinfo = ROOT.TObjString(\"%d\" % ssw.N); # number of incident particles for correct normalisation\n T.GetUserInfo().Add(sinfo);\n\n# T.Print()\n T.SetAlias(\"theta\", \"TMath::RadToDeg()*(TMath::ATan2(x,y) > 0 ? TMath::ATan2(x,y) : 2*TMath::Pi()+TMath::ATan2(x,y))\");\n T.SetAlias(\"i\",\"TMath::Nint(TMath::Abs(id/1E+6))\");# tmp variable\n T.SetAlias(\"JGP\",\"-TMath::Nint(i/200.0)\"); # energy group\n T.SetAlias(\"JC\",\"TMath::Nint(i/100.0) + 2*JGP\"); #\n T.SetAlias(\"IPT\",\"i-100*JC+200*JGP\"); # particle type: 1=neutron, 2=photon, 3=electron\n T.SetAlias(\"wz\", \"TMath::Sqrt(TMath::Max(0, 1-wx*wx-wy*wy)) * id/TMath::Abs(id)\") # z-direction cosine\n T.SetAlias(\"surface\", \"TMath::Abs(id) % 1000000\") # surface crossed\n T.Write()\n fout.Purge()\n fout.Close()","def main():\n create_sets()\n optimal_weights = genetic_algorithm()\n obtain_best_model(optimal_weights)"],"string":"[\n \"def get_functional_enrichment(enrichment_file, go, remove_parents=False, only_biological_processes=False, only_slim=False, logodds_cutoff=0):\\n\\n #from toolbox import OboParser\\n #g=OboParser.getOboGraph(\\\"/home/emre/arastirma/celldiff/data/GO/gene_ontology.1_2.obo\\\")\\n g=go\\n\\n go_terms = None\\n name = None\\n name_to_go_terms ={}\\n\\n altid_to_goid = {}\\n for goid, data in g.nodes(data=True):\\n for altid in data[\\\"x\\\"]:\\n altid_to_goid[altid] = goid\\n\\n f = open(enrichment_file)\\n for line in f:\\n line = line.strip()\\n if line.startswith(\\\"# of\\\"):\\n go_terms = set()\\n elif line.startswith(\\\"#\\\"):\\n if go_terms is not None: \\n if name is None:\\n name = \\\"generic\\\"\\n if remove_parents:\\n go_terms = remove_parent_terms(go_terms, g)\\n name_to_go_terms[name] = go_terms\\n #print name, go_terms\\n name = line \\n else:\\n words = line.split(\\\"\\\\t\\\")\\n try:\\n n = int(words[0])\\n #pval = float(words[4]) # contains text like <0.0067\\n except:\\n print(words)\\n continue\\n go_term = words[5]\\n lodds = float(words[2])\\n if lodds < logodds_cutoff:\\n continue\\n if go_term in altid_to_goid:\\n go_term = altid_to_goid[go_term]\\n if only_biological_processes:\\n if g.node[go_term]['t'] == \\\"biological_process\\\": # and 'a' in g.node[go_term]: #is bp and slim # (\\\"molecular_function\\\", \\\"biological_process\\\"):\\n if only_slim:\\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\\n go_terms.add(go_term)\\n else:\\n go_terms.add(go_term)\\n else:\\n if only_slim:\\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\\n go_terms.add(go_term)\\n else:\\n go_terms.add(go_term)\\n\\n f.close()\\n\\n if name is None:\\n name = \\\"generic\\\"\\n if remove_parents:\\n go_terms = remove_parent_terms(go_terms, g)\\n name_to_go_terms[name] = go_terms\\n #print name, go_terms\\n\\n if \\\"generic\\\" in name_to_go_terms:\\n return name_to_go_terms[\\\"generic\\\"]\\n\\n return name_to_go_terms\",\n \"def find(self, egg):\",\n \"def _applyGooglePatches(self):\\n # Edit the base template to point users to the Google fork\\n # of the Melange codebase instead of the vanilla release.\\n tmpl_file = self.wc.path(\\n self._branchPath('app/soc/templates/soc/base.html'))\\n tmpl = io.fileToLines(tmpl_file)\\n for i, line in enumerate(tmpl):\\n if 'http://code.google.com/p/soc/source/browse/tags/' in line:\\n tmpl[i] = line.replace('/p/soc/', '/p/soc-google/')\\n break\\n else:\\n raise error.ExpectationFailed(\\n 'No source code link found in base.html')\\n io.linesToFile(tmpl_file, tmpl)\\n\\n self.wc.commit(\\n 'Customize the Melange release link in the sidebar menu')\",\n \"def mergenotes():\",\n \"def go_enrichment(genelist, background_go=None, go_info=None, return_odds=False, gofile=dbpaths['goterms']):\\n # if background list of GO terms is not supplied, make one:\\n if background_go:\\n go_obj = background_go\\n else:\\n go_obj = GO_maker(gofile)\\n\\n f_squares = [] # where the Fisher's Exact Tables will be held (and returned)\\n\\n god = {}\\n goodds = {}\\n gopval = {}\\n\\n for godict in go_obj.fetch_gos(genelist):\\n for goterm in godict:\\n try:\\n god[goterm] += 1\\n except KeyError:\\n god[goterm] = 1\\n\\n for goterm in god:\\n if goterm == \\\"GO:######\\\":\\n continue\\n dip = god[goterm]\\n\\n go_w_deg = dip\\n go_wo_deg = len(go_obj.fetch_genes(goterm)) - dip\\n nogo_w_deg = len(genelist) - dip\\n nogo_wo_deg = go_obj.count_genes() - len(go_obj.fetch_genes(goterm)) - len(genelist) + dip\\n\\n if isinstance(go_info,dict):\\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm, go_info[goterm]))\\n else:\\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm))\\n\\n verbalise(\\\"B\\\", \\\"Performing Fisher's Exact Test on %d squares\\\" % (len(f_squares)))\\n for square in f_squares:\\n square.fisher_test()\\n\\n return f_squares\",\n \"def test_wr_methods(log=sys.stdout):\\n # 1. Gene Ontology Enrichment Analysis\\n # 1a. Initialize: Load ontologies, associations, and population gene IDs\\n taxid = 10090 # Mouse study\\n geneids_pop = GeneID2nt_mus.keys() # Mouse protein-coding genes\\n goeaobj = get_goeaobj(\\\"fdr_bh\\\", geneids_pop, taxid)\\n # 1b. Run GOEA\\n geneids_study = get_geneid2symbol(\\\"nbt.3102-S4_GeneIDs.xlsx\\\")\\n keep_if = lambda nt: getattr(nt, \\\"p_fdr_bh\\\") < 0.05 # keep if results are significant\\n goea_results = goeaobj.run_study(geneids_study, keep_if=keep_if)\\n # 2. Write results\\n # Write parameters:\\n # The format_string names below are the same names as in the namedtuple field_names.\\n prtfmt = \\\"{GO} {NS} {level:>2} {depth:>2} {p_fdr_bh:5.2e} {study_count:>5} {name}\\\\n\\\"\\n wr_params = {\\n # Format for printing in text format\\n 'prtfmt' : prtfmt, \\n # Format for p-values in tsv and xlsx format\\n 'fld2fmt' : {'p_fdr_bh' : '{:8.2e}'}, \\n # Print a subset namedtuple fields, don't print all fields in namedtuple.\\n 'prt_flds' : get_fmtflds(prtfmt) \\n }\\n # 2a. Use the write functions inside the GOEnrichmentStudy class.\\n _wr_3fmt_goeaobj(goea_results, goeaobj, wr_params, log)\\n # 2b. Use the write functions straight from the wr_tbl package to print a list of namedtuples.\\n _wr_3fmt_wrtbl(goea_results, wr_params, log)\\n assert filecmp.cmp('nbt3102_subset_obj.tsv', 'nbt3102_subset_nt.tsv')\",\n \"def main():\\n ## real SWAT tags\",\n \"def enrichment_kegg(**kwargs):\\n logger.setLevel(kwargs[\\\"logger\\\"])\\n\\n keggname = kwargs[\\\"kegg_name\\\"]\\n params = {\\n \\\"padj\\\": kwargs[\\\"padj_cutoff\\\"],\\n \\\"log2_fc\\\": kwargs[\\\"log2_foldchange_cutoff\\\"],\\n \\\"mapper\\\": kwargs[\\\"biomart\\\"],\\n \\\"nmax\\\": kwargs[\\\"max_pathways\\\"],\\n \\\"kegg_background\\\": kwargs[\\\"kegg_background\\\"],\\n \\\"preload_directory\\\": kwargs[\\\"kegg_pathways_directory\\\"],\\n \\\"plot_logx\\\": not kwargs[\\\"plot_linearx\\\"],\\n \\\"color_node_with_annotation\\\": kwargs['annotation_attribute']\\n }\\n filename = kwargs[\\\"biomart\\\"]\\n if filename and os.path.exists(filename) is False:\\n logger.error(\\\"{} does not exists\\\".format(filename))\\n sys.exit(1)\\n filename = kwargs[\\\"kegg_pathways_directory\\\"]\\n if filename and os.path.exists(filename) is False:\\n logger.error(\\\"{} does not exists\\\".format(filename))\\n sys.exit(1)\\n\\n logger.info(f\\\"Reading RNAdiff results from {kwargs['name']}\\\")\\n dirpath = os.path.dirname(os.path.abspath(kwargs[\\\"name\\\"]))\\n rnadiff = RNADiffResults(dirpath, index_col=0, header=[0, 1])\\n\\n # now that we have loaded all results from a rnadiff analysis, let us\\n # perform the enrichment for each comparison found in the file\\n annot_col = kwargs[\\\"annotation_attribute\\\"]\\n\\n padj = params[\\\"padj\\\"]\\n log2fc = params[\\\"log2_fc\\\"]\\n\\n # setting these attributes set the gene list with log2fc and padj filter\\n rnadiff._log2_fc = log2fc\\n rnadiff._alpha = padj\\n gene_lists = rnadiff.get_gene_lists(\\n annot_col=annot_col, Nmax=kwargs.get(\\\"max_genes\\\", 1000000), dropna=True\\n ) # no filter on number of genes\\n\\n output_directory = kwargs[\\\"output_directory\\\"]\\n for compa, gene_dict in gene_lists.items():\\n\\n if keggname.startswith('vc'):\\n logger.warning(\\\"Vibrio Cholera annotation old_locus_tag processed to be compatible with KEGG/Sequana\\\")\\n if kwargs['annotation_attribute'] == 'old_locus_tag':\\n def get_kegg_id(x):\\n try:\\n a, b = x.split(',')\\n if a[0:3] == 'VC_':\\n return a\\n else:\\n return b\\n except:\\n return x\\n for cat in ['up', 'down', 'all']:\\n gene_dict[cat] = [get_kegg_id(x) for x in gene_dict[cat]]\\n old_locus_tag = rnadiff.annotation['old_locus_tag'].values\\n rnadiff.annotation['old_locus_tag'] = [get_kegg_id(x) for x in old_locus_tag]\\n\\n config.output_dir = f\\\"{output_directory}/{compa}\\\"\\n os.makedirs(f\\\"{output_directory}\\\", exist_ok=True)\\n\\n # we define the data and its annotation that will be used by the KEGG\\n # enrichment. No need to apply any filter, we pass the entire data set\\n # so that even small fold change can be shown\\n df = rnadiff.comparisons[compa].df.copy()\\n df = pd.concat([df, rnadiff.annotation.loc[df.index].copy()], axis=1)\\n df.reset_index(inplace=True)\\n\\n ModuleKEGGEnrichment(\\n gene_dict,\\n keggname,\\n df,\\n enrichment_params=params,\\n command=\\\" \\\".join([\\\"sequana\\\"] + sys.argv[1:]),\\n )\",\n \"def findInteractions( targetGenes, geneTable ):\\n pass\",\n \"def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\\n\\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\\n\\n print \\\"%-4d kegg pathways from %d DEGs\\\" % (len(deg_keggs), len(degs) )\\n print \\\"%-4d kegg pathways from %d nonDEGs\\\" % (len(neg_keggs), len(negs) )\\n\\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\\n pathwaytype_dict = {}\\n pathway_dict = {}\\n pathway_lookup = {}\\n\\n print \\\"extracting pathways...\\\"\\n ko1_h = open(dbpaths['kegg'], 'rb')\\n for line in ko1_h:\\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\\n pathtype_f = re.search('B.*<b>(.*)<', line)\\n if pathtype_f is not None:\\n pathtype = pathtype_f.group(1)\\n else:\\n pathtype = 'unknown'\\n pathwaytype_dict[pathtype] = {}\\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\\n pathway_f = re.search(\\\"C +([0-9]*) *(.*)\\\\[PATH\\\", line)\\n if pathway_f is not None:\\n pathway_id = pathway_f.group(1)\\n pathway_name = pathway_f.group(2)\\n else:\\n pathway_id = 'unknown'\\n pathway_name = 'unknown'\\n pathway_dict[pathway_id] = {}\\n pathway_lookup[pathway_id] = pathway_name\\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\\n koterm_f = re.search(\\\"(K[0-9]*)\\\", line)\\n if koterm_f is not None:\\n koterm = koterm_f.group(1)\\n else:\\n koterm = 'unknown'\\n pathwaytype_dict[pathtype][koterm] = 1\\n pathway_dict[pathway_id][koterm] = 1\\n\\n\\n print \\\"calculating enrichment...\\\"\\n pathwaytype_ps = {}\\n pathway_ps = {}\\n # count number of degs and negs in each pathway:\\n for pathwaytype in pathwaytype_dict:\\n pwtsize = len(pathwaytype_dict)\\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathwaytype_ps[pathwaytype] = pval\\n\\n if pval < pthresh:\\n print \\\"%s\\\\n \\\\\\n In Path Not in Path\\\\n\\\\\\n DEG : %-7d %d\\\\n\\\\\\n non-DEG: %-7d %d\\\\n\\\\\\n Odds Ratio:%.3f\\\\n\\\\\\n P-value:%.4f\\\\n\\\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\\n oddrat, pval)\\n\\n\\n for pathway in pathway_dict:\\n pwtsize = len(pathway_dict)\\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\\n\\n ## Fisher's Exact Test:\\n # In Pathway: Not in Pathway:\\n # DEG : degs_in_path degs_not_in\\n # non-DEG : negs_in_path negs_not_in\\n #\\n\\n return pathwaytype_ps, pathway_ps\",\n \"def voorbeeld():\\n os.system(\\\"rm Twogs.txt cogs.txt\\\")\\n os.system(\\\"touch Twogs.txt cogs.txt\\\")\\n orgslijst = [y[:-1] for y in openfile(\\\"orglijst.txt\\\") if \\\"\\\\n\\\" in y]\\n for x in range(len(orgslijst)):\\n org1 = orgslijst[x]\\n for y in range(len(orgslijst)):\\n org2 = orgslijst[y]\\n if x > y:\\n schrijfnaartwog(org1, org2)\\n print(org1)\\n prots, twogs, cogs = openneededfiles(org1)\\n if x >= 2:\\n searchforcog(cogs, twogs, prots)\",\n \"def main():\\n # AVAILABLE for implementation:\\n # 'go_terms', 'member_databases', 'integrated', 'entry_annotations', ''\\n #\\n # USED:\\n # basics: 'accession', 'type', 'description', 'counters', 'entry_id', 'source_database', 'name'\\n # hierarchy\\n # wikipedia\\n # literature\\n # cross_references\\n # overlaps_with\\n\\n parser = argparse.ArgumentParser(description=\\\"Retrieve InterPro documents and convert them into json\\\")\\n parser.add_argument(\\\"--basics\\\", \\\"-b\\\", action=\\\"store_true\\\", help=\\\"Include basic information such as accession, \\\"\\n \\\"type, name, description, counters, entry_id and \\\"\\n \\\"source_database\\\")\\n parser.add_argument(\\\"--hierarchy\\\", \\\"-hi\\\", action=\\\"store_true\\\", help=\\\"\\\")\\n parser.add_argument(\\\"--wikipedia\\\", \\\"-w\\\", action=\\\"store_true\\\", help=\\\"\\\")\\n parser.add_argument(\\\"--literature\\\", \\\"-l\\\", action=\\\"store_true\\\", help=\\\"\\\")\\n parser.add_argument(\\\"--cross_references\\\", \\\"-cr\\\", action=\\\"store_true\\\", help=\\\"\\\")\\n parser.add_argument(\\\"--overlaps\\\", \\\"-o\\\", action=\\\"store_true\\\", help=\\\"\\\")\\n parser.add_argument(\\\"dbxrefs\\\", nargs=argparse.REMAINDER)\\n args = parser.parse_args()\\n\\n # if nothing specified, output all available information for the entry\\n if None not in (args.basics, args.hierarchy, args.wikipedia, args.literature, args.cross_references, args.overlaps):\\n args.basics = True\\n args.hierarchy = True\\n args.wikipedia = True\\n args.literature = True\\n args.cross_references = True\\n args.overlaps = True\\n\\n dbxrefs = dbxref.resolver.convert_to_dbxrefs(args.dbxrefs)\\n\\n documents = retrieve(dbxrefs, basics=args.basics, hierarchy=args.hierarchy, wikipedia=args.wikipedia,\\n literature=args.literature, cross_references=args.cross_references, overlaps=args.overlaps)\\n print(json.dumps(documents, sort_keys=True, indent=4))\",\n \"def main():\\n\\n # Accept up to three command-line arguments\\n input_terms = \\\"<input_GO_terms_file>\\\"\\n input_annotations = \\\"<input_gene_associations_file>\\\"\\n output_filename = \\\"<output_filename>\\\"\\n\\n\\n # The first two arguments are required GO terms file ending with .obo\\n # and gene association GAF file ending with .gaf\\n if len(sys.argv) < 3:\\n sys.exit(\\\"Please provide required GO terms .obo file and gene \\\" +\\n \\\"assocatiion .gaf file.\\\")\\n elif not sys.argv[1].endswith(\\\".obo\\\"):\\n sys.exit(\\\"Please provide a GO terms .obo file.\\\")\\n elif not sys.argv[2].endswith(\\\".gaf\\\"):\\n sys.exit(\\\"Please provide a gene association .gaf file.\\\")\\n else:\\n input_terms = sys.argv[1]\\n input_annotations = sys.argv[2]\\n\\n\\n # Check if the provided import .obo or .gaf files exist\\n if not input_terms:\\n sys.exit(input_terms + \\\" not found. Check the file path and try again.\\\")\\n elif not input_annotations:\\n sys.exit(input_annotations + \\\" not found. Check the file path and try again.\\\")\\n elif len(sys.argv) == 3:\\n output_filename = \\\"results.tsv\\\"\\n sys.stdout = open(\\\"results.tsv\\\", \\\"w\\\")\\n elif len(sys.argv) == 4:\\n output_filename = sys.argv[3] + \\\".tsv\\\"\\n sys.stdout = open(output_filename, \\\"w\\\")\\n\\n\\n # parse id and is_valeus and make a go_dict\\n split_input_terms = split_terms(input_terms)\\n go_dict = {}\\n for record in split_input_terms:\\n (go_id, is_a) = parse_go_term(record)\\n key_go_dict = \\\"\\\".join(go_id)\\n go_dict[key_go_dict] = is_a\\n\\n\\n # Export an annotation gene information to tsv format into the output file\\n gene_association_map = map_protein_to_go(input_annotations)\\n for protein, go_ids in sorted(gene_association_map.items()):\\n print(protein, end=\\\"\\\")\\n\\n for go_id in sorted(go_ids):\\n parent_go_ids = find_parent_terms(go_id, go_dict)\\n\\n count = 0\\n for parent_go_id in sorted(parent_go_ids):\\n\\n if count == 0:\\n print(\\\"\\\\t\\\", go_id, \\\"\\\\t\\\", parent_go_id)\\n count += 1\\n else:\\n print(\\\"\\\\t\\\", parent_go_id, sep=\\\"\\\\t\\\")\\n\\n sys.stdout.close()\",\n \"def get_my_mutations(quality_cutoff, coverage_cutoff):\\n\\n # my_mutations = {}\\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\\n # for line in f:\\n # my_mutations[line.strip()] = True\\n # return my_mutations\\n\\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \\n 'NimbleGen Tiled Regions')\\n # NimbleGen Tiled Regions\\n # Target Regions\\n\\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\\n all_somatic = {}\\n all_inherited = {}\\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\\n for exome in global_settings.exome_types:\\n data_file = use_data_dir + exome\\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\\n cancer_qualities, quality_cutoff,\\n False, coverage_cutoff)\\n # only use the bed_tools NimbleGen\\n # restriction for hg18 data\\n for s in somatic['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_somatic[s] = True\\n for i in inherited['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_inherited[i] = True\\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))\",\n \"def newcogfind(ncf_cogs, ncf_twogs, ncf_prots):\\n coglijst_hoogste_waarde = list(set([y.split()[0] for y in ncf_cogs]))\\n werkgetal = vindhoogstecognummer(coglijst_hoogste_waarde)\\n ncf_list = []\\n for prot in ncf_prots:\\n prot_in_twogs = zoekinlijst(prot, ncf_twogs, 1)\\n posible_found_twogs = verbrogentwogs(prot, ncf_twogs, prot_in_twogs)\\n if posible_found_twogs != list():\\n newcog = list(set(\\\" \\\".join(posible_found_twogs).split()))\\n werkgetal += 1\\n for incog in newcog:\\n cogzin = \\\"%s\\\\t%s\\\\n\\\" % ((\\\"0000000000%s\\\" % werkgetal)[-8:], incog)\\n ncf_list.append(cogzin)\\n twogremove(zoekinlijst(incog, ncf_twogs, 0), ncf_twogs)\\n voegtoeaancog(ncf_list)\",\n \"def test_intersection(self):\\n a = pybedtools.BedTool\",\n \"def main(ctx, verbose):\\n return\",\n \"def do_poortego_find(self, arg):\\n poortego_find(self.my_interface, arg)\",\n \"def generate_gem():\\n resource_path = os.path.join(os.path.dirname(__file__), \\\"data/\\\")\\n genome_fa = resource_path + \\\"tb.Human.GCA_000001405.22.fasta\\\"\\n genome_gem_fa = resource_path + \\\"tb.Human.GCA_000001405.22_gem.fasta\\\"\\n\\n with gzip.open(genome_fa + '.gz', 'rb') as fgz_in:\\n with open(genome_fa, 'wb') as f_out:\\n f_out.write(fgz_in.read())\\n\\n genome_gem_idx = resource_path + \\\"tb.Human.GCA_000001405.22_gem.fasta.gem.gz\\\"\\n\\n input_files = {\\n \\\"genome\\\": genome_fa\\n }\\n\\n output_files = {\\n \\\"index\\\": genome_gem_idx,\\n \\\"genome_gem\\\": genome_gem_fa\\n }\\n\\n metadata = {\\n \\\"genome\\\": Metadata(\\n \\\"Assembly\\\", \\\"fasta\\\", genome_fa, None,\\n {'assembly': 'test'}),\\n }\\n\\n print(input_files, output_files)\\n\\n gem_it = gemIndexerTool({\\\"execution\\\": resource_path})\\n gem_it.run(input_files, metadata, output_files)\",\n \"def import_various(context):\\n # Only run step if a flag file is present\\n if context.readDataFile('collective.opensearch-default.txt') is None:\\n return\\n logger = context.getLogger('collective.opensearch')\\n site = context.getSite()\\n pass\",\n \"def main():\\n ref_seq = {}\\n ent_spe_sero = {}\\n tag_dict = {\\\"Contigs_with_VP1\\\":\\\"contigs\\\", \\\"P1_sequences\\\":\\\"p1\\\",\\n \\\"VP1_sequences\\\":\\\"vp1\\\", \\\"5UTR_sequences\\\":\\\"5utr\\\", \\\"3D_sequences\\\":\\\"3d\\\"}\\n args = get_arguments()\\n # Load query elements\\n print(\\\"Load resume file\\\")\\n (query_dict, classify_list,\\n classify_specie_list, serotype_list) = get_query(args.resume_file,\\n args.tag,\\n args.incomplete)\\n print(\\\"{} descriptions loaded\\\".format(len(query_dict)))\\n # Load specie association\\n if args.ent_serotype_file and args.template_seq_file:\\n # Load enterovirus serotype\\n print(\\\"Load enterovirus serotype association\\\")\\n ent_spe_sero = load_spe_sero(args.ent_serotype_file)\\n # Load template sequence\\n print(\\\"Load template sequence\\\")\\n ref_seq = get_template_sequence(args.template_seq_file, ent_spe_sero)\\n # Grab query sequence in the database\\n print(\\\"Load database sequence\\\")\\n sequence_data = get_sequence(query_dict, args.fasta_file)\\n print(\\\"{} sequences loaded\\\".format(len(sequence_data)))\\n # Write the new fasta file\\n print(\\\"Write the new fasta\\\")\\n write_sequence(args.results, sequence_data, query_dict, classify_list,\\n tag_dict[args.tag], ref_seq, ent_spe_sero)\\n #print(save_association)\\n print(\\\"Write the itol label\\\")\\n write_itol_label(args.itol_dir, sequence_data, query_dict, classify_list,\\n tag_dict[args.tag])\\n print(\\\"Write the itol tree color\\\")\\n write_itol_tree_color(args.itol_dir, sequence_data, query_dict, classify_specie_list, serotype_list,\\n tag_dict[args.tag])\\n print(\\\"Done\\\")\",\n \"def searchforcog(sfc_cogs, sfc_twogs, sfc_prots):\\n cogupdate(sfc_cogs, sfc_twogs, sfc_prots)\\n newcogfind(sfc_cogs, sfc_twogs, sfc_prots)\\n newtwogfile(sfc_twogs)\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-i', '--input-ontology',\\n default=config_test.config[\\\"msh_test_onto\\\"])\\n parser.add_argument('-s', '--signature')\\n parser.add_argument('-f', '--format-name', default=None)\\n parser.add_argument('-o', '--output-file', default=\\\"ontology/output.owl\\\")\\n parser.add_argument('-d', '--max-depth', default=10)\\n parser.add_argument('-l', '--locality', default='top')\\n\\n args = parser.parse_args()\\n\\n g = Graph().parse(args.input_ontology, format=args.format_name)\\n resource = entity_mapper.match_entity(args.signature, g)\\n ontomodule = extract_module.extract_module(\\n [resource], g, locality=args.locality, max_depth=args.max_depth)\\n\\n with open(args.output_file, \\\"w\\\") as f:\\n ontomodule.serialize(f)\",\n \"def do_it(args):\\n\\n #force = args.force\\n #testing = args.testing\\n #verbose = args.verbose\\n #regions = args.regions\\n\\n # XXX WORKING HERE\",\n \"def mainGA(NAME, target_output, target_image): \\n global toolbox\\n\\n print(\\\"Target image: {0} Target output: {1}\\\".format(target_image, target_output)) \\n sys.stdout.flush()\\n\\n model = load_model(NAME) \\n fit = Fitness(NAME, model, target_image, target_output)\\n\\n #Genetic operators \\n toolbox.register(\\\"evaluate\\\", fit.evaluate)\\n toolbox.register(\\\"mate\\\", cxTwoPointCopy) \\n #toolbox.register(\\\"mate\\\", cxUniform)\\n toolbox.register(\\\"mutate\\\", tools.mutGaussian, mu=0.0, sigma=0.1, indpb=0.05)\\n toolbox.register(\\\"select\\\", tools.selTournament, tournsize=3)\\n \\n\\n pop = toolbox.population(n=50)\\n hof = tools.HallOfFame(1, similar=np.array_equal)\\n \\n #stats = tools.Statistics(lambda ind: ind.fitness.values)\\n #stats.register(\\\"avg\\\", np.mean)\\n #stats.register(\\\"std\\\", np.std)\\n #stats.register(\\\"min\\\", np.min)\\n #stats.register(\\\"max\\\", np.max)\\n \\n pop, log = algorithms.eaSimple(pop, toolbox, cxpb=CXPB, mutpb=MUTPB, \\n ngen=NGEN, halloffame=hof, \\n verbose=False)\\n\\n return hof[0]\",\n \"def import_gene_information(inputargs):\\n\\n global chainnams, chain\\n chain = inputargs['chain']\\n\\n if inputargs['tags'] == \\\"extended\\\" and inputargs['species'] == \\\"mouse\\\":\\n print(\\\"Please note that there is currently no extended tag set for mouse TCR genes.\\\\n\\\" \\\\\\n \\\"Decombinator will now switch the tag set in use from \\\\'extended\\\\' to \\\\'original\\\\'.\\\\n\\\" \\\\\\n \\\"In future, consider editing the script to change the default, \\\" \\\\\\n \\\"or use the appropriate flags (-sp mouse -tg original).\\\")\\n inputargs['tags'] = \\\"original\\\"\\n\\n if inputargs['tags'] == \\\"extended\\\" and (chain == 'g' or chain == 'd'):\\n print(\\\"Please note that there is currently no extended tag set for gamma/delta TCR genes.\\\\n\\\" \\\\\\n \\\"Decombinator will now switch the tag set in use from \\\\'extended\\\\' to \\\\'original\\\\'.\\\\n\\\" \\\\\\n \\\"In future, consider editing the script to change the default, or use the appropriate flags.\\\")\\n inputargs['tags'] = \\\"original\\\"\\n\\n # Check species information\\n if inputargs['species'] not in [\\\"human\\\", \\\"mouse\\\"]:\\n print(\\\"Species not recognised. Please select either \\\\'human\\\\' (default) or \\\\'mouse\\\\'.\\\\n\\\" \\\\\\n \\\"If mouse is required by default, consider changing the default value in the script.\\\")\\n sys.exit()\\n\\n # Look for tag and V/J fasta and cysteine position files: if these cannot be found in the working directory,\\n # source them from GitHub repositories\\n # Note that fasta/tag files fit the pattern \\\"species_tagset_gene.[fasta/tags]\\\"\\n # I.e. \\\"[human/mouse]_[extended/original]_TR[A/B/G/D][V/J].[fasta/tags]\\\"\\n\\n for gene in ['v', 'j']:\\n # Get FASTA data\\n fasta_file = read_tcr_file(inputargs['species'], inputargs['tags'], gene, \\\"fasta\\\", inputargs['tagfastadir'])\\n globals()[gene + \\\"_genes\\\"] = list(SeqIO.parse(fasta_file, \\\"fasta\\\"))\\n\\n globals()[gene + \\\"_regions\\\"] = [str( item.seq.upper()) for item in globals()[gene + \\\"_genes\\\"]]\\n globals()[gene + \\\"_names\\\"] = [str(item.id.upper().split(\\\"|\\\")[1]) for item in globals()[gene + \\\"_genes\\\"]]\\n\\n # Get conserved translation residue sites and functionality data\\n translation_file = open(read_tcr_file(inputargs['species'], inputargs['tags'], gene, \\\"translate\\\",\\n inputargs['tagfastadir']),\\\"rt\\\")\\n translate_data = [x.rstrip() for x in list(translation_file)]\\n\\n globals()[gene + \\\"_translate_position\\\"] = [int(x.split(\\\",\\\")[1]) for x in translate_data]\\n globals()[gene + \\\"_translate_residue\\\"] = [x.split(\\\",\\\")[2] for x in translate_data]\\n globals()[gene + \\\"_functionality\\\"] = [x.split(\\\",\\\")[3] for x in translate_data]\\n\\n if gene == 'v':\\n \\n if inputargs['species'] == \\\"human\\\":\\n # Get germline CDR data\\n cdr_file = open(read_tcr_file(inputargs['species'], inputargs['tags'], gene, \\\"cdrs\\\", inputargs['tagfastadir']), \\\"rt\\\")\\n cdr_data = [x.rstrip() for x in list(cdr_file)]\\n cdr_file.close()\\n v_cdr1 = [x.split(\\\" \\\")[1] for x in cdr_data]\\n v_cdr2 = [x.split(\\\" \\\")[2] for x in cdr_data]\\n else:\\n # cdr_file only exists for human - CDR1 and CDR2 only written to output tsv\\n # for human. Otherwise create empty lists fo v_cdr1 and v_cdr2, to write empty\\n # fields to output tsv\\n v_cdr1 = [\\\"\\\"]*len(globals()[gene + \\\"_genes\\\"])\\n v_cdr2 = [\\\"\\\"]*len(globals()[gene + \\\"_genes\\\"])\\n\\n return v_regions, j_regions, v_names, j_names, v_translate_position, v_translate_residue, \\\\\\n j_translate_position, j_translate_residue, v_functionality, j_functionality, v_cdr1, v_cdr2\",\n \"def g_n():\\n for gname in os.listdir(sroot):\\n if gname != 's1-league1-game1':\\n continue\\n if gname.startswith('s1'):\\n p0 = os.path.join(sroot, gname)\\n p1 = os.path.join(p0, 'commitment', 'jperret')\\n p2 = os.path.join(p0, 'commitment', 'sa')\\n if os.path.isdir(p1) and os.path.isdir(p2):\\n for fname in os.listdir(p1):\\n if fname.endswith('.aa'):\\n bname = fname[:-3]\\n #~ if bname == 's1-league1-game2_07':\\n #~ continue\\n a = ad.Annotations(os.path.join(p1, fname))\\n a.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\\n a.gen_full_struct()\\n a.commitments = list(u for u in a.units if u.type == 'Commitment')\\n a2 = ad.Annotations(os.path.join(p2, fname))\\n a2.load_text(os.path.join(p0, 'unannotated', bname+'.ac'))\\n a2.gen_full_struct()\\n a2.commitments = list(u for u in a2.units if u.type == 'Commitment')\\n yield bname, (a, a2)\",\n \"def run_fenrichment(args):\\n filter_enrichment(args)\",\n \"def main():\\n logging.getLogger(\\\"dance\\\").setLevel(logging.DEBUG)\\n logging.getLogger(\\\"dance\\\").addHandler(logging.StreamHandler(sys.stderr))\\n\\n def relevant_if_has_t142(mol: oechem.OEMol):\\n params = smirnoff_param_utils.read_params_from_mol(mol)\\n return \\\"t142\\\" in params\\n\\n def size_and_wbo_fingerprint(mol: oechem.OEMol):\\n \\\"\\\"\\\"Fingerprint with number of atoms in the mol and WBO between central atoms in the t142 param.\\n\\n (WBO is Wiberg Bond Order.)\\n\\n Note: The indices are the same in OpenEye and OFF molecules, so the\\n parameter indices are correct, even though they were calculated for the\\n OFF mol.\\n \\\"\\\"\\\"\\n oechem.OEAddExplicitHydrogens(mol)\\n params = smirnoff_param_utils.read_params_from_mol(mol)\\n return (\\n mol.NumAtoms(),\\n smirnoff_param_utils.calculate_t142_central_wbo(mol, params),\\n )\\n\\n config = {\\n \\\"database_type\\\": \\\"OEB\\\",\\n \\\"database_info\\\": \\\"combined_molecules_with_parameters.oeb\\\",\\n \\\"relevance_function\\\": relevant_if_has_t142,\\n \\\"filter_output_oeb\\\": \\\"results/filter_output.oeb\\\",\\n \\\"fingerprint_function\\\": size_and_wbo_fingerprint,\\n \\\"fingerprint_output_oeb\\\": \\\"results/fingerprint_output.oeb\\\",\\n \\\"selection_frequency\\\": 375, # To select ~20 molecules.\\n \\\"dataset_type\\\": \\\"OEB\\\",\\n \\\"dataset_info\\\": \\\"results/dataset.oeb\\\",\\n \\\"sorted_by_fingerprint_oeb\\\": \\\"results/sorted_by_fingerprint.oeb\\\",\\n \\\"in_memory_sorting_threshold\\\": 25000,\\n \\\"tmpdir\\\": \\\"results/tmp\\\",\\n }\\n\\n run_dance(config)\",\n \"def main():\\n LESSONS_PATH = os.path.join(LESSON_LOCATOR_DATA, LESSON_SETS[0])\\n ORIGINAL_LESSONS_PATH = os.path.join(LESSONS_PATH, \\\"original\\\")\\n ANNOTATED_LESSONS_PATH = os.path.join(LESSONS_PATH, \\\"annotated\\\")\\n\\n if not os.path.exists(ANNOTATED_LESSONS_PATH):\\n os.mkdir(ANNOTATED_LESSONS_PATH)\\n\\n print(\\\"Scanning original lessons in %s...\\\" % ORIGINAL_LESSONS_PATH)\\n\\n for item in os.listdir(ORIGINAL_LESSONS_PATH):\\n if item == \\\".DS_Store\\\": continue\\n\\n print(\\\" found: %s\\\" % item)\\n\\n item_path = os.path.join(ORIGINAL_LESSONS_PATH, item)\\n\\n lesson_number = None\\n lesson_description = None\\n mobj = re.search(r'^AY\\\\s+(\\\\d+)\\\\s*-\\\\s*(.+)\\\\.txt$', item)\\n if mobj:\\n lesson_number = mobj.group(1)\\n lesson_description = mobj.group(2)\\n\\n print(\\\" number: %s\\\" % lesson_number)\\n print(\\\" description: %s\\\" % lesson_description)\\n\\n lesson = dict()\\n lesson['number'] = lesson_number\\n lesson['description'] = lesson_description\\n\\n fh = open(item_path)\\n lesson_raw_text = fh.read()\\n fh.close()\\n lesson_text = re.split(r'\\\\n', lesson_raw_text)\\n# lesson_raw_text_reencoded = lesson_raw_text.decode('mac-roman').encode('utf-8')\\n# lesson_text = re.split(r'\\\\n', lesson_raw_text_reencoded)\\n\\n lesson['text'] = lesson_text\\n lesson['parsed'] = parseLesson(lesson_text)\\n\\n if lesson['parsed']['end_of_lesson'] is None:\\n print(\\\" lesson has no 'end of lesson' marker\\\")\\n\\n lesson_json = json.dumps(lesson, indent=4)\\n annotated_lesson_path = os.path.join(ANNOTATED_LESSONS_PATH, \\\"ay_%04d.json\\\" % int(lesson_number))\\n fh = open(annotated_lesson_path, \\\"w\\\")\\n fh.write(lesson_json)\\n fh.close()\\n\\n else:\\n print(\\\"ERROR: File name not understood: %s\\\" % item)\\n\\n return 0\",\n \"def main():\\n get_obofoundry(force_download=True)\",\n \"def get_clarifications_winogrande(ex, nlp, comet_model):\\n personx, persony = ex['option1'], ex['option2']\\n\\n # Only extract relations for people\\n if personx[0] != personx[0].upper() or persony[0] != persony[0].upper():\\n return []\\n\\n input_event = ex[\\\"sentence\\\"]\\n outputs = {category: comet_model.predict(input_event, category, num_beams=5) for category in comet_model.categories}\\n\\n curr_events = []\\n for category, prefix in CATEGORY_TO_PREFIX.items():\\n for out_event in outputs[category]:\\n if out_event != \\\"none\\\" and out_event != \\\"\\\":\\n if not out_event.lower().startswith(\\\"person\\\") and not out_event.lower().startswith(\\\"other\\\"):\\n out_event = \\\" \\\".join((prefix, out_event))\\n\\n out_event = re.sub(\\\"personx\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"person x\\\", personx, out_event, flags=re.I)\\n out_event = re.sub(\\\"persony\\\", persony, out_event, flags=re.I)\\n out_event = re.sub(\\\"person y\\\", persony, out_event, flags=re.I)\\n\\n question = CATEGORY_TO_QUESTION[category].replace(\\\"PersonX\\\", personx)\\n curr_events.append((question, out_event))\\n\\n return curr_events\",\n \"def load_ocsge(ctx, item):\\n connecter = ScalingoInterface(ctx.obj)\\n connecter.manage_py(\\\"load_ocsge --no-verbose\\\", **{\\\"item\\\": item})\",\n \"def help():\\n description = \\\"\\\"\\\"\\n Get the observed and expected enrichment trend plot based on contact matrix.\\n Example:\\n getSigEnrich.py -d GM12878_Trac -o GM12878_Trac -cut 0 -p 10 \\n \\\"\\\"\\\"\\n parser = argparse.ArgumentParser(description=description,\\n formatter_class=RawTextHelpFormatter)\\n parser.add_argument(\\\"-d\\\",\\n dest=\\\"dir\\\",\\n required=True,\\n type=str,\\n help=\\\"Directory for cLoops2 pre generated.\\\")\\n parser.add_argument(\\\"-o\\\",\\n dest=\\\"output\\\",\\n required=True,\\n type=str,\\n help=\\\"Output prefix.\\\")\\n parser.add_argument(\\n \\\"-c\\\",\\n dest=\\\"chroms\\\",\\n required=False,\\n default=\\\"\\\",\\n type=str,\\n help=\\n \\\"Whether to process limited chroms, specify it as chr1,chr2,chr3, default is not. Use this to save time for quite big data.\\\"\\n )\\n parser.add_argument(\\n \\\"-bs\\\",\\n dest=\\\"binSize\\\",\\n required=False,\\n default=5000,\\n type=int,\\n help=\\n \\\"Bin size (bp) to generate the contact matrix for estimation, default is 5000 bp.\\\"\\n )\\n parser.add_argument(\\n \\\"-cut\\\",\\n dest=\\\"cut\\\",\\n type=int,\\n default=0,\\n help=\\\"Distance cutoff for PETs to filter, default is 0.\\\")\\n parser.add_argument('-p',\\n dest=\\\"cpu\\\",\\n required=False,\\n default=1,\\n type=int,\\n help=\\\"Number of CPUs to run the job, default is 1.\\\")\\n parser.add_argument(\\n '-r',\\n dest=\\\"repeats\\\",\\n required=False,\\n default=10,\\n type=int,\\n help=\\n \\\"The reapet times to shuffle PETs to get the mean expected background,default is 10.\\\"\\n )\\n parser.add_argument('-plot',\\n dest=\\\"plot\\\",\\n required=False,\\n action=\\\"store_true\\\",\\n help=\\\"Set to plot the result.\\\")\\n op = parser.parse_args()\\n return op\",\n \"def main():\\n mock_uri = ''\\n inventory = fetch_inventory(SphinxApp, mock_uri,\\n OBJECT_INVENTORY_RELPATH)\\n sphinx_mods = set(inventory['py:module'].keys())\\n\\n library_dir = os.path.join(BASE_DIR, 'gcloud')\\n public_mods = get_public_modules(library_dir,\\n base_package='gcloud')\\n public_mods = set(public_mods)\\n\\n if not sphinx_mods <= public_mods:\\n unexpected_mods = sphinx_mods - public_mods\\n message = ['Unexpected error. There were modules referenced by '\\n 'Sphinx that are not among the public modules.']\\n message.extend(['- %s' % (mod,) for mod in unexpected_mods])\\n print('\\\\n'.join(message), file=sys.stderr)\\n sys.exit(1)\\n\\n undocumented_mods = public_mods - sphinx_mods\\n # Remove ignored modules.\\n undocumented_mods -= IGNORED_MODULES\\n if undocumented_mods:\\n message_parts = ['Found undocumented public modules:']\\n message_parts.extend(['- ' + mod_name\\n for mod_name in sorted(undocumented_mods)])\\n print('\\\\n'.join(message_parts), file=sys.stderr)\\n sys.exit(1)\",\n \"def main():\\n print(get_advice())\",\n \"def composeWorkplaceOntology():\\n\\n import ossPyFuncs \\n import pandas as pd\\n \\n #mysql query to extract full table from government organizations\\n #certian table columns feature capital letters which cases uproblems\\n postgreSql_selectQuery=\\\"SELECT * FROM us_gov_manual.us_govman_2019 ;\\\"\\n #pass querry and obtain table\\n govTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n\\n #mysql query to obtain academic instutions\\n postgreSql_selectQuery=\\\"SELECT institution FROM hipolabs.universities ;\\\"\\n #pass querry and obtain table\\n univTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2018_us1000;\\\"\\n businesses1=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2019_us1000;\\\"\\n businesses2=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2020_global2000;\\\"\\n businesses3=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n\\n #combine theinsitutions into a vector\\n combinedSeries=[govTable['AgencyName'],univTable['institution'],businesses1['company'],businesses2['company'],businesses3['company']]\\n #turn the multi item vector into a single series\\n fullWordbank=pd.concat(combinedSeries)\\n #turn that series into a pd dataframe\\n wordbankTable=pd.DataFrame(fullWordbank.unique())\\n\\n return wordbankTable\",\n \"def explore(self, *args):\",\n \"def main(template_initial_path, template_grown_path, step, total_steps, hydrogen_to_replace, core_atom_linker,\\n tmpl_out_path, null_charges=False, growing_mode=\\\"SoftcoreLike\\\"):\\n lambda_to_reduce = float(step/(total_steps+1))\\n templ_ini = TemplateImpact(template_initial_path)\\n \\n for bond in templ_ini.list_of_bonds:\\n key, bond_cont = bond\\n templ_grw = TemplateImpact(template_grown_path)\\n fragment_atoms, core_atoms_in, core_atoms_grown = detect_atoms(template_initial=templ_ini, \\n template_grown=templ_grw,\\n hydrogen_to_replace=hydrogen_to_replace)\\n set_fragment_atoms(list_of_fragment_atoms=fragment_atoms)\\n set_connecting_atom(template_grown=templ_grw, pdb_atom_name=core_atom_linker)\\n fragment_bonds = detect_fragment_bonds(list_of_fragment_atoms=fragment_atoms, template_grown=templ_grw)\\n set_fragment_bonds(list_of_fragment_bonds=fragment_bonds)\\n set_linker_bond(templ_grw)\\n if growing_mode == \\\"SoftcoreLike\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=True,\\n null_charges=null_charges)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=True, \\n null_charges=null_charges)\\n \\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"AllLinear\\\":\\n modify_core_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, exp_charges=False)\\n reduce_fragment_parameters_linearly(templ_grw, lambda_to_reduce, exp_charges=False,\\n null_charges=False)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n elif growing_mode == \\\"SpreadHcharge\\\":\\n if step > 1:\\n reduce_fragment_parameters_originaly(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n modify_linkers_parameters_linearly(templ_grw, lambda_to_reduce, templ_ini, hydrogen_to_replace)\\n else:\\n reduce_fragment_parameters_spreading_H(templ_grw, templ_ini, lambda_to_reduce, \\n hydrogen=hydrogen_to_replace, n_GS=total_steps)\\n else:\\n raise ValueError(\\\"Growing mode Not valid. Choose between: 'SoftcoreLike', 'SpreadHcharge', 'AllLinear'.\\\")\\n templ_grw.write_template_to_file(template_new_name=tmpl_out_path)\\n return [atom.pdb_atom_name for atom in fragment_atoms], \\\\\\n [atom.pdb_atom_name for atom in core_atoms_grown]\",\n \"def get_doc_prov(j, gcis_url, refList, orgList):\\n doc = ProvEsDocument()\\n \\n org = requests.get(j['href']).json()\\n \\n doc_attrs = [\\n (\\\"prov:type\\\", 'gcis:organization'),\\n (\\\"prov:label\\\", j['name']),\\n (\\\"prov:location\\\", \\\"%s%s\\\"%(gcis_url, j['uri'])),\\n (\\\"gcis:organization_type_identifier\\\", j['organization_type_identifier']),\\n (\\\"gcis:country_code\\\", j['country_code']),\\n ]\\n orgID = 'bibo:%s' % j['identifier']\\n doc.agent(orgID, doc_attrs)\\n\\n for child in org['children']:\\n cOrgURI = child['organization']\\n rel = child['relationship']\\n\\n cOrg = next(o for o in orgList if o['uri'] == cOrgURI)\\n cOrgID = 'bibo:%s'%cOrg['identifier']\\n\\n #cOrgAttrs = [\\n # (\\\"prov:type\\\", 'gcis:organization'),\\n # (\\\"prov:label\\\", cOrg['name']),\\n # (\\\"prov:location\\\", cOrg['uri']),\\n # (\\\"gcis:organization_type_identifier\\\", cOrg['organization_type_identifier']),\\n # (\\\"gcis:country_code\\\", cOrg['country_code']),\\n # ]\\n #doc.entity(cOrgID, cOrgAttrs)\\n #doc.hadMember(orgID, cOrgID)\\n #for parent in org['parents']:\\n # pOrgURI = parent['organization']\\n # rel = parent['relationship']\\n # pOrg = next(o for o in orgList if o['uri'] == pOrgURI)\\n # pOrgID = 'bibo:%s'%pOrg['identifier']\\n # doc.hadMember(pOrgID, orgID)\\n\\n prov_json = json.loads(doc.serialize())\\n\\n return prov_json\",\n \"def script(self):\",\n \"def OLDfindMatchingStyleReport(self,TargetOG=1.037,TargetFG=1.011, TargetIBU=48.2, TargetSRM=7):\\n\\t\\n\\t\\thideNegative=1\\n\\t\\textendedText=0\\n\\n\\t\\tself.cleanupXML(\\\"styleguide2008.xml\\\")\\t\\n\\t\\tTog=TargetOG\\n\\t\\tTfg=TargetFG\\n\\t\\tTibu=TargetIBU\\n\\t\\tTsrm=TargetSRM\\n\\t\\tbeerstyles={}\\n\\t\\txmldoc = minidom.parse(\\\".styleguide2008.xml.tmp\\\")\\n\\t\\tsg = xmldoc.childNodes[2]\\n\\n\\t\\td=None\\n\\n\\n\\n\\t\\tfor c in sg.childNodes[1].childNodes:\\n\\t\\t#\\tprint c\\n\\t\\t\\tD=d\\n\\t\\t\\tfor d in c.childNodes:\\n\\t\\t#\\t\\tprint d\\t\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tbeerstyle= d.getElementsByTagName('name')[0].firstChild.data\\t\\n\\t\\t\\t\\t\\tbeerstyles[beerstyle]={ \\t'xml': d,\\t'substyles' : {} }\\n\\t\\t\\t\\t\\n\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\n\\t\\t#\\n\\n\\t\\tprint \\\"There are %s beer styles in the database.\\\" %(len(beerstyles))\\n\\t\\tprint \\\" searching for;\\\"\\n\\t\\tprint \\\" original gravity %s\\\" %(Tog)\\n\\t\\tprint \\\" final gravity %s\\\" %(Tfg)\\n\\t\\tprint \\\" target IBU %s\\\" %(Tibu)\\n\\t\\tprint \\\" target SRM %s\\\" %(Tsrm)\\n\\n\\n\\t\\tresults={}\\n\\t\\tscores=[]\\n\\t\\tscoreResultMap={}\\n\\n\\n\\t\\tfor style in beerstyles:\\n\\t\\t\\tsubstyle= beerstyles[style]['xml'].getElementsByTagName('name')[0].firstChild.data\\n\\n\\t\\t\\tscore=0\\n\\n\\t\\t\\tbeerstyles[style]['substyles'][substyle] = {}\\n\\t\\t\\tstats= beerstyles[style]['xml'].getElementsByTagName('stats')[0]\\n\\n\\t\\t\\tog=stats.getElementsByTagName('og')\\n\\t\\t\\tfg=stats.getElementsByTagName('fg')\\n\\t\\t\\tibu=stats.getElementsByTagName('ibu')\\n\\t\\t\\tsrm=stats.getElementsByTagName('srm')\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\toglow=og[0].getElementsByTagName('low')[0].firstChild.data\\n\\t\\t\\t\\toghigh=og[0].getElementsByTagName('high')[0].firstChild.data\\n\\t\\t\\texcept:\\n\\t\\t\\t\\toglow=-1\\n\\t\\t\\t\\toghigh=-1\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tfglow=fg[0].getElementsByTagName('low')[0].firstChild.data\\n\\t\\t\\t\\tfghigh=fg[0].getElementsByTagName('high')[0].firstChild.data\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tfglow=-1\\n\\t\\t\\t\\tfghigh=-1\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tibulow=ibu[0].getElementsByTagName('low')[0].firstChild.data\\n\\t\\t\\t\\tibuhigh=ibu[0].getElementsByTagName('high')[0].firstChild.data\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tibulow=-1\\n\\t\\t\\t\\tibuhigh=-1\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tsrmlow=srm[0].getElementsByTagName('low')[0].firstChild.data\\n\\t\\t\\t\\tsrmhigh=srm[0].getElementsByTagName('high')[0].firstChild.data\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tsrmlow=-1\\n\\t\\t\\t\\tsrmhigh=-1\\n\\n\\n\\t\\t\\t#############################################################################################################\\n\\t\\t\\t# Checking Range of Gravity's and giving score\\n\\t\\t\\t\\n\\t\\t\\tscoreOg=0\\n\\t\\t\\tscoreFg=0\\n\\t\\t\\tscoreIbu=0\\t\\n\\t\\t\\tscoreSrm=0\\n\\t\\t\\tif Tog < float(oglow) and Tog > float(oghigh):\\n\\t\\t\\t\\tscoreOg=0\\t\\t\\t\\t\\t\\t# Original Gravity Out Of Range\\n\\t\\t\\telif Tog < float(oglow) and Tog <= float(oghigh):\\t\\t\\n\\t\\t\\t\\tscoreOg=5\\t\\t\\t\\t\\t\\t# Original Gravity Not Higher\\n\\t\\t\\telif Tog >= float(oglow) and Tog > float(oghigh):\\t\\n\\t\\t\\t\\tscoreOg=5\\t\\t\\t\\t\\t\\t# Original Gravity Not Lower\\n\\t\\t\\telse:\\n\\t\\t\\t\\tscoreOg=20\\t\\t\\t\\t\\t\\t# Original Gravity in range\\n\\n\\t\\t\\t# FG\\n\\t\\t\\tif Tfg < float(fglow) and Tfg > float(fghigh):\\n\\t\\t\\t\\tscoreFg=0\\t\\t\\t\\t\\t\\t# Original Gravity Out Of Range\\n\\t\\t\\telif Tfg < float(fglow) and Tfg <= float(fghigh):\\t\\t\\n\\t\\t\\t\\tscoreFg=5\\t\\t\\t\\t\\t\\t# Original Gravity Not Higher\\n\\t\\t\\telif Tfg >= float(fglow) and Tfg > float(fghigh):\\t\\n\\t\\t\\t\\tscoreFg=5\\t\\t\\t\\t\\t\\t# Original Gravity Not Lower\\n\\t\\t\\telse:\\n\\t\\t\\t\\tscoreFg=20\\t\\t\\t\\t\\t\\t# Original Gravity in range\\n\\t\\t\\t\\n\\n\\t\\t\\t# IBU\\n\\t\\t\\tif Tibu < float(ibulow) and Tibu > float(ibuhigh):\\n\\t\\t\\t\\tscoreIbu=0\\t\\t\\t\\t\\t\\t# Original Gravity Out Of Range\\n\\t\\t\\telif Tibu < float(ibulow) and Tibu <= float(ibuhigh):\\t\\t\\n\\t\\t\\t\\tscoreIbu=9\\t\\t\\t\\t\\t\\t# Original Gravity Not Higher\\n\\t\\t\\telif Tibu >= float(ibulow) and Tibu > float(ibuhigh):\\t\\n\\t\\t\\t\\tscoreIbu=9\\t\\t\\t\\t\\t\\t# Original Gravity Not Lower\\n\\t\\t\\telse:\\n\\t\\t\\t\\tscoreIbu=40\\t\\t\\t\\t\\t\\t# Original Gravity in range\\n\\t\\t\\t\\n\\n\\t\\t\\t# SRM\\n\\t\\t\\tif Tsrm < float(srmlow) and Tsrm > float(srmhigh):\\n\\t\\t\\t\\tscoreSrm=0\\t\\t\\t\\t\\t\\t# Original Gravity Out Of Range\\n\\t\\t\\telif Tsrm < float(srmlow) and Tsrm <= float(srmhigh):\\t\\t\\n\\t\\t\\t\\tscoreSrm=6\\t\\t\\t\\t\\t\\t# Original Gravity Not Higher\\n\\t\\t\\telif Tsrm >= float(srmlow) and Tsrm > float(srmhigh):\\t\\n\\t\\t\\t\\tscoreSrm=6\\t\\t\\t\\t\\t\\t# Original Gravity Not Lower\\n\\t\\t\\telse:\\n\\t\\t\\t\\tscoreSrm=30\\t\\t\\t\\t\\t\\t# Original Gravity in range\\n\\t\\t\\t\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tsys.stderr.write(\\\"%s/%s score=%s scoreOg=%s scoreFg=%s scoreIbu=%s scoreSrm=%s\\\\n\\\" %(style,substyle,scoreOg+scoreFg+scoreIbu+scoreSrm,scoreOg,scoreFg,scoreIbu,scoreSrm))\\t\\n\\t\\t\\t\\tresults[ (style,substyle) ] = {'og': (float(oglow),float(oghigh)), 'fg': (float(fglow),float(fghigh)), 'ibu' : (float(ibulow),float(ibuhigh)), 'srm':(float(srmlow),float(srmhigh)), 'xml':beerstyles[style]['xml']}\\n\\n\\t\\t\\t\\tscore=(scoreSrm+scoreIbu+scoreOg+scoreFg)*100\\n\\t\\t\\t\\tif not scoreResultMap.has_key( score ):\\n\\t\\t\\t\\t\\tscoreResultMap[ score ] = []\\n\\t\\t\\t\\t\\tscores.append(score)\\n\\t\\t\\t\\tscoreResultMap[ score ].append( (style,substyle) )\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tpass\\n\\t\\t\\t\\n\\t\\tscores.sort()\\n\\t\\tscores.reverse()\\n\\t\\tsys.stderr.write(\\\"\\\\n\\\")\\n\\t\\tsys.stderr.write(\\\"\\\\n\\\")\\n\\t\\tsys.stderr.write(\\\"\\\\n\\\")\\n\\n\\n\\t\\tprint \\n\\t\\tprint\\n\\t\\tfor score in scores:\\n\\t\\t\\tsubscores=[]\\n\\t\\t\\tsubscoreMap={}\\n\\t\\t\\t# a better scoring mechanism that applies within the group rather than outside the grouping\\n\\t\\t\\tfor (style,substyle) in scoreResultMap[ score ]:\\n\\t\\t\\t\\t(oglow,oghigh) = results[ (style,substyle) ]['og']\\n\\t\\t\\t\\togmid = ((oghigh-oglow)/2)+oglow\\n\\t\\t\\t\\togdelta = pow( (100-(ogmid/Tog)*100), 6)\\n\\t\\t\\t\\t(fglow,fghigh) = results[ (style,substyle) ]['fg']\\n\\t\\t\\t\\tfgmid = ((fghigh-fglow)/2)+fglow\\n\\t\\t\\t\\tfgdelta = pow( (100-(fgmid/Tfg)*100), 6)\\n\\t\\t\\t\\t(ibulow,ibuhigh) = results[ (style,substyle) ]['ibu']\\n\\t\\t\\t\\tibumid = ((ibuhigh-ibulow)/2)+ibulow\\n\\t\\t\\t\\tibudelta = pow( (10-(ibumid/Tibu)*10), 6)\\n\\t\\t\\t\\t(srmlow,srmhigh) = results[ (style,substyle) ]['srm']\\n\\t\\t\\t\\tsrmmid = ((srmhigh-srmlow)/2)+srmlow\\n\\t\\t\\t\\tsrmdelta = pow( (5-(srmmid/Tsrm)*5), 6)\\n\\n\\t\\t\\t\\tsubscore=score-ogdelta-fgdelta-ibudelta-srmdelta\\n\\t\\t\\t\\tif not subscoreMap.has_key(subscore):\\n\\t\\t\\t\\t\\tsubscores.append(subscore)\\t\\n\\t\\t\\t\\t\\tsubscoreMap[subscore] =[]\\n\\t\\t\\t\\tsubscoreMap[subscore].append( (style,substyle,ogdelta,fgdelta,ibudelta,srmdelta))\\n\\n\\t\\t\\tsubscores.sort()\\n\\t\\t\\tsubscores.reverse()\\n\\t\\t\\tfor Ssubscore in subscores:\\n\\t\\t\\t\\tfor (Sstyle,Ssubstyle,Sogdelta,Sfgdelta,Sibudelta,Ssrmdelta) in subscoreMap[ Ssubscore ]:\\n\\t\\t\\t\\n\\t\\t\\t\\t\\tif (hideNegative\\t and Ssubscore >= 0) or not hideNegative:\\n\\t\\t\\t\\t\\t\\tprint \\\"Style: %s; SubStyle: %s;\\\" %(Sstyle,Ssubstyle)\\n\\t\\t\\t\\t\\t\\tprint \\\"Score: %s (basescore:%s og:%f.4 fg:%f.4 ibu:%f.4 srm:%f.4)\\\" %(Ssubscore,score,Sogdelta,Sfgdelta,Sibudelta,Ssrmdelta)\\n\\t\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\t(oglow,oghigh) = results[ (Sstyle,Ssubstyle) ]['og']\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" Original Gravity: %s----%s (Target %s)\\\" %(oglow,oghigh,Tog)\\n\\t\\t\\t\\t\\t\\t\\t(fglow,fghigh) = results[ (Sstyle,Ssubstyle) ]['fg']\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" Final Gravity: %s----%s (Target %s)\\\" %(fglow,fghigh,Tfg)\\n\\t\\t\\t\\t\\t\\t\\t(ibulow,ibuhigh) = results[ (Sstyle,Ssubstyle) ]['ibu']\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" International Bittering Units: %s----%s (Target %s)\\\" %(ibulow,ibuhigh,Tibu)\\n\\t\\t\\t\\t\\t\\t\\t(srmlow,srmhigh) = results[ (Sstyle,Ssubstyle) ]['srm']\\n\\t\\t\\t\\t\\t\\t\\tprint \\\" SRM: %s----%s (Target %s)\\\" %(srmlow,srmhigh,Tsrm)\\n\\n\\t\\t\\t\\t\\t\\t\\tif extendedText:\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Aroma\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('aroma')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Ingredients\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('ingredients')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Flavor\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('flavor')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"MouthFeel\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('mouthfeel')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Impression\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('impression')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Comments\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('comments')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\t\\t\\tprint self._tidyText(\\\"Example\\\", results[(Sstyle,Ssubstyle)]['xml'].getElementsByTagName('examples')[0].firstChild.data)\\n\\t\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\t\\tpass\\n\\n\\t\\t\\t\\t\\t\\tprint \\n\\t\\t\\t\\t\\t\\tprint\",\n \"def limk2_gene_context():\\n return {\\n \\\"id\\\": \\\"normalize.gene:LIMK2\\\",\\n \\\"type\\\": \\\"GeneDescriptor\\\",\\n \\\"label\\\": \\\"LIMK2\\\",\\n \\\"gene_id\\\": \\\"hgnc:6614\\\",\\n \\\"xrefs\\\": [\\n \\\"ncbigene:3985\\\",\\n \\\"ensembl:ENSG00000182541\\\"\\n ],\\n \\\"extensions\\\": [\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"symbol_status\\\",\\n \\\"value\\\": \\\"approved\\\"\\n },\\n {\\n \\\"name\\\": \\\"approved_name\\\",\\n \\\"value\\\": \\\"LIM domain kinase 2\\\",\\n \\\"type\\\": \\\"Extension\\\"\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"associated_with\\\",\\n \\\"value\\\": [\\n \\\"refseq:NM_016733\\\",\\n \\\"ccds:CCDS33637\\\",\\n \\\"ccds:CCDS13892\\\",\\n \\\"ena.embl:D45906\\\",\\n \\\"uniprot:P53671\\\",\\n \\\"pubmed:10591208\\\",\\n \\\"vega:OTTHUMG00000151251\\\",\\n \\\"omim:601988\\\",\\n \\\"iuphar:2055\\\",\\n \\\"pubmed:8537403\\\",\\n \\\"ccds:CCDS13891\\\",\\n \\\"ucsc:uc003akh.4\\\"\\n ]\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"hgnc_locations\\\",\\n \\\"value\\\": [\\n {\\n \\\"_id\\\": \\\"ga4gh:VCL.IoyhTh4PxvPx8yF9P3IecXDVs_XVbDe9\\\",\\n \\\"type\\\": \\\"ChromosomeLocation\\\",\\n \\\"species_id\\\": \\\"taxonomy:9606\\\",\\n \\\"chr\\\": \\\"22\\\",\\n \\\"interval\\\": {\\n \\\"end\\\": \\\"q12.2\\\",\\n \\\"start\\\": \\\"q12.2\\\",\\n \\\"type\\\": \\\"CytobandInterval\\\"\\n }\\n }\\n ]\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"ensembl_locations\\\",\\n \\\"value\\\": [\\n {\\n \\\"_id\\\": \\\"ga4gh:VSL.Mat3OiuXCd7vNWAGB5lOKaSf_ESc_xK9\\\",\\n \\\"type\\\": \\\"SequenceLocation\\\",\\n \\\"sequence_id\\\": \\\"ga4gh:SQ.7B7SHsmchAR0dFcDCuSFjJAo7tX87krQ\\\",\\n \\\"interval\\\": {\\n \\\"start\\\": {\\\"type\\\": \\\"Number\\\", \\\"value\\\": 31212238},\\n \\\"end\\\": {\\\"type\\\": \\\"Number\\\", \\\"value\\\": 31280080},\\n \\\"type\\\": \\\"SequenceInterval\\\"\\n }\\n }\\n ]\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"ncbi_locations\\\",\\n \\\"value\\\": [\\n {\\n \\\"_id\\\": \\\"ga4gh:VCL.IoyhTh4PxvPx8yF9P3IecXDVs_XVbDe9\\\",\\n \\\"type\\\": \\\"ChromosomeLocation\\\",\\n \\\"species_id\\\": \\\"taxonomy:9606\\\",\\n \\\"chr\\\": \\\"22\\\",\\n \\\"interval\\\": {\\n \\\"end\\\": \\\"q12.2\\\",\\n \\\"start\\\": \\\"q12.2\\\",\\n \\\"type\\\": \\\"CytobandInterval\\\"\\n }\\n },\\n {\\n \\\"_id\\\": \\\"ga4gh:VSL.N1dI0SlDciU-8OsmdjEfSKdVDp-Q5_lf\\\",\\n \\\"type\\\": \\\"SequenceLocation\\\",\\n \\\"sequence_id\\\": \\\"ga4gh:SQ.7B7SHsmchAR0dFcDCuSFjJAo7tX87krQ\\\",\\n \\\"interval\\\": {\\n \\\"start\\\": {\\\"type\\\": \\\"Number\\\", \\\"value\\\": 31212297},\\n \\\"end\\\": {\\\"type\\\": \\\"Number\\\", \\\"value\\\": 31280080},\\n \\\"type\\\": \\\"SequenceInterval\\\"\\n }\\n }\\n ]\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"hgnc_locus_type\\\",\\n \\\"value\\\": \\\"gene with protein product\\\"\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"ncbi_gene_type\\\",\\n \\\"value\\\": \\\"protein-coding\\\"\\n },\\n {\\n \\\"type\\\": \\\"Extension\\\",\\n \\\"name\\\": \\\"ensembl_biotype\\\",\\n \\\"value\\\": \\\"protein_coding\\\"\\n }\\n ]\\n }\",\n \"def GoAnnot(prots, gos, onlyProts=False):\\r\\n with resources.open_text(\\\"autoprot.data\\\",\\\"Homo_sapiens.gene_info\\\") as d:\\r\\n geneInfo = pd.read_csv(d, sep='\\\\t')\\r\\n with resources.open_text(\\\"autoprot.data\\\",\\\"gene2go_alt\\\") as d:\\r\\n gene2go = pd.read_csv(d, sep='\\\\t')\\r\\n prots = pd.DataFrame(pd.Series([str(i).upper().split(';')[0] for i in prots]), columns=[\\\"Gene names\\\"])\\r\\n prots = prots.merge(geneInfo[[\\\"Symbol\\\", \\\"GeneID\\\"]], left_on=\\\"Gene names\\\", right_on=\\\"Symbol\\\", how='inner')\\r\\n \\r\\n prots = prots.merge(gene2go[[\\\"GeneID\\\", \\\"GO_ID\\\", \\\"GO_term\\\"]], on=\\\"GeneID\\\", how='inner')\\r\\n if onlyProts == True:\\r\\n for idx, go in enumerate(gos):\\r\\n if idx == 0:\\r\\n redProts = prots[\\\"Symbol\\\"][prots[\\\"GO_term\\\"].str.contains(go)]\\r\\n else:\\r\\n redProts = redProts.append(prots[\\\"Symbol\\\"][prots[\\\"GO_term\\\"].str.contains(go)])\\r\\n return redProts.drop_duplicates()\\r\\n else: \\r\\n for idx, go in enumerate(gos):\\r\\n if idx == 0:\\r\\n redProts = prots[prots[\\\"GO_term\\\"]==go]\\r\\n else:\\r\\n redProts = redProts.append(prots[prots[\\\"GO_term\\\"]==go])\\r\\n return redProts.drop_duplicates()\",\n \"def substantiate():\",\n \"def goopy():\\n # Start timer:\\n start = time()\\n\\n parser = GooeyParser(prog=\\\"AutoCAT\\\", description=f\\\"\\\\n{PROG_DESC}\\\")\\n\\n # Accept argument for the vendor's email address:\\n parser.add_argument(\\n \\\"Vendor\\\", action=\\\"store\\\", type=str, help=\\\"Vendor's email address:\\\"\\n )\\n\\n # Grab user's input:\\n args = parser.parse_args()\\n email_input = args.Vendor\\n\\n # [CHECK] Validation for Vendor Emails:\\n if (not validators.email(email_input)):\\n print(\\\"Vendor field may only contain email addresses!\\\")\\n raise ValueError\\n\\n print(\\\"\\\\nLaunching Approval Process . . .\\\")\\n\\n # Initialize our WebDriver + Procedures classes:\\n driver = MyWebDriver().initialize_driver()\\n approve = ApproveVendorProcess(driver)\\n\\n # Run all procedures:\\n approve.run_all(email_input)\\n delta = round(time() - start, 3)\\n print(f\\\"\\\\n ---- Completed in {delta} seconds total. ----\\\")\",\n \"def find_enstools_packages():\\n\\n return [f'enstools.{p}' for p in (find_packages(f'{os.path.dirname(__file__)}/enstools'))]\",\n \"def main():\\n\\n obj_lookup = interfaces_dir / \\\"FrameLib-obj-jlookup.json\\\"\\n\\n worker = jParseAndBuild()\\n\\n refpages = [x for x in refpages_dir.rglob(\\\"fl.*.xml\\\")]\\n\\n for ref in refpages:\\n worker.extract_from_refpage(ref)\\n\\n write_json(obj_lookup, worker.j_master_dict)\",\n \"def _getJetBuildTool2(merge_param,\\n ptmin,\\n ptminFilter,\\n jet_calib,\\n cluster_calib,\\n concrete_type,\\n do_minimalist_setup,\\n do_substructure,\\n iParticleRejectionTool,\\n name='',\\n secondary_label='',\\n trkopt = '',\\n outputLabel='',\\n OutputLevel=INFO,\\n fromJet=False\\n ):\\n\\n # declare jtm as global as this function body may modify it\\n # with the += operator\\n global jtm\\n\\n msg = 'Naming convention breaks with merge param %d' % merge_param\\n int_merge_param = int(10 * merge_param)\\n assert 10 * merge_param == int_merge_param, msg\\n\\n assert merge_param > 0.\\n\\n # Ensure the calibration is valid\\n _is_calibration_supported(int_merge_param, jet_calib, cluster_calib)\\n\\n # in situ calibration step is only for data, not MC\\n # this string here allows the following code to be data/MC unaware\\n inSitu = 'i' if _getIsData() else ''\\n \\n # tell the offline code which calibration is requested\\n calib_str = {'jes': 'calib:j:triggerNoPileup:HLTKt4',\\n 'subjes': 'calib:aj:trigger:HLTKt4',\\n 'sub': 'calib:a:trigger:HLTKt4',\\n 'subjesIS': 'calib:ajg%s:trigger2016:HLTKt4'%(inSitu)}.get(jet_calib, '')\\n\\n # with S Schramm very early 18/4/2016\\n mymods = [jtm.jetens]\\n if calib_str: mymods.append(calib_str)\\n if not fromJet: mymods.append(jtm.caloqual_cluster)\\n if outputLabel!='triggerTowerjets': #towers don't have cluster moments\\n mymods.append(jtm.clsmoms)\\n if secondary_label == 'GhostTrack': # ghost track association expected, will want track moments.\\n if not hasattr(jtm, 'trkmoms_'+trkopt):\\n print (\\\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no track moment tools configured. Continuing without trkmodifers.\\\")\\n else: \\n trkmoms_ghosttrack = getattr(jtm, 'trkmoms_'+trkopt)\\n trkmoms_ghosttrack.unlock()\\n trkmoms_ghosttrack.AssociatedTracks = secondary_label\\n trkmoms_ghosttrack.lock()\\n mymods.append(trkmoms_ghosttrack)\\n if not hasattr(jtm, 'jvf_'+trkopt):\\n print (\\\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no JVF tool configured. Continuing without jvf calculations.\\\")\\n else: \\n jvf_ghosttrack = getattr(jtm, 'jvf_'+trkopt)\\n jvf_ghosttrack.unlock()\\n jvf_ghosttrack.AssociatedTracks = secondary_label\\n jvf_ghosttrack.lock()\\n mymods.append(jvf_ghosttrack)\\n if not hasattr(jtm, 'jvt_'+trkopt):\\n print (\\\"In TrigHLTJetRecConfig._getJetBuildTool: Something went wrong. GhostTrack label set but no JVT tool configured. Continuing without jvt calculations.\\\")\\n else: \\n jvt_ghosttrack = getattr(jtm, 'jvt_'+trkopt)\\n mymods.append(jvt_ghosttrack)\\n\\n if not do_minimalist_setup:\\n # add in extra modofiers. This allows monitoring the ability\\n # to run with the extra modifiers, which may be required in the\\n # future.\\n mymods.extend([\\n jtm.nsubjettiness,\\n jtm.jetens,\\n jtm.caloqual_cluster,\\n jtm.bchcorrclus,\\n jtm.width\\n ])\\n\\n if do_substructure:\\n # this set of moments will be reduced once we've run once to\\n # evaluate costs\\n\\n # don't want to include nsubjettiness and width twice\\n if do_minimalist_setup:\\n mymods.extend([\\n jtm.nsubjettiness,\\n jtm.width\\n ])\\n\\n mymods.extend([\\n # jtm.nsubjettiness,\\n jtm.ktdr,\\n jtm.ktsplitter,\\n jtm.encorr,\\n jtm.charge,\\n jtm.angularity,\\n jtm.comshapes,\\n jtm.ktmassdrop,\\n jtm.dipolarity,\\n jtm.pull,\\n jtm.planarflow,\\n # jtm.width,\\n jtm.qw,\\n # jtm.trksummoms # this needs tracks and vertices which we\\n # don't have by default\\n ])\\n\\n\\n # Add jet calo width always\\n if do_minimalist_setup and not do_substructure:\\n mymods.append(jtm.width)\\n\\n jtm.modifiersMap[\\\"mymods\\\"] = mymods\\n \\n if not name:\\n name = 'TriggerJetBuilderTool_%d%s%sTopoJets' % (int_merge_param,\\n cluster_calib,\\n jet_calib)\\n elif '_' in name:\\n name = 'TriggerJetBuilderTool_%s' % name.split('_')[1]\\n\\n for jr in jtm.trigjetrecs:\\n if jr.name() == name:\\n print ('returning existing TriggerJetBuildTool with name', name)\\n return jr\\n \\n\\n print ('adding new jet builder ', name)\\n assert cluster_calib in ('LC', 'EM')\\n \\n getter_label = cluster_calib + 'Topo'\\n\\n try:\\n # jetBuildTool = jtm.addJetFinderTrigger(\\n #OutputLevel=VERBOSE\\n jetBuildTool = jtm.addTriggerJetBuildTool(\\n name=name,\\n alg=\\\"AntiKt\\\",\\n radius=merge_param,\\n getter_label=getter_label,\\n concrete_type=concrete_type,\\n modifiersin = \\\"mymods\\\", # key in jtmmodifiers map\\n ghostArea=0.01, # != 0: calcjet area for pileup subtraction\\n ptmin=ptmin,\\n ptminFilter=ptminFilter,\\n iParticleRejectionTool=iParticleRejectionTool,\\n OutputLevel=OutputLevel,)\\n \\n except Exception as e:\\n print ('error adding new jet builder %s' % name)\\n print ('exception', e)\\n import traceback\\n traceback.print_exc()\\n raise e\\n\\n nname = jetBuildTool.name()\\n print ('name comparison', name, nname, hasattr(jtm, nname))\\n\\n # try:\\n # if not hasattr(jtm,\\\"jbldTrigger\\\"):\\n # jtm.addJetBuilderWithArea(\\n # JetFromPseudojetMT(\\\"jbldTrigger\\\",\\n # Attributes = [\\\"ActiveArea\\\",\\n # \\\"ActiveArea4vec\\\"])\\n # )\\n # \\n # if merge_param==0.4: \\n # from AthenaCommon.AppMgr import ToolSvc\\n # getattr(ToolSvc,name+\\\"Finder\\\").unlock()\\n # getattr(ToolSvc,name+\\\"Finder\\\").JetBuilder = jtm.jbldTrigger\\n # getattr(ToolSvc,name+\\\"Finder\\\").lock()\\n\\n #except Exception, e:\\n # print 'error adding new JetFromPseudoJet %s' % name\\n # print 'exception', e\\n # print 'traceback', exc2string2()\\n # raise e\\n\\n return jetBuildTool\",\n \"def analysis(self, S_hit, S_score=None, S_go=None, SRC_GENE=None, min_overlap=3, min_enrichment=0, p_cutoff=0.01, n_CPU=0, l_rsa_keep_most=True, S_go_category=None, l_background_by_ontology=False):\\n\\n def go_filtered(S_go, S_go_category):\\n return [x for x in S_go if self.get_category_id(x) in S_go_category]\\n\\n S_all_go_filtered=[]\\n def all_go_filtered(S_go_category):\\n if len(S_all_go_filtered)==0:\\n S_go=self.GO_GENE_ENRICH\\n S_all_go_filtered.append(go_filtered(S_go, S_go_category))\\n return S_all_go_filtered[0]\\n\\n N_go=0\\n if S_go_category is not None and len(S_go_category)>0:\\n # hard code for now, to be fixed later\\n if type(S_go_category) in (int, str):\\n S_go_category=[S_go_category]\\n S_go_category={int(x) for x in S_go_category if self.CATEGORY_COUNT.get(x,0)>0 }\\n for x in S_go_category:\\n N_go+=self.CATEGORY_COUNT[x]\\n else:\\n N_go=sum(self.CATEGORY_COUNT.values())\\n\\n l_multi_list=type(S_hit) is dict\\n if S_go is None:\\n if l_multi_list:\\n S_go={}\\n for k in S_hit.keys():\\n S_go[k]=all_go_filtered(S_go_category)\\n else:\\n S_go=all_go_filtered(S_go_category)\\n else:\\n if l_multi_list:\\n for k in S_hit.keys():\\n if S_go.get(k, None) is None:\\n S_go[k]=all_go_filtered(S_go_category)\\n else:\\n S_go[k]=go_filtered(S_go[k], S_go_category)\\n else:\\n S_go=go_filtered(S_go, S_go_category)\\n\\n if SRC_GENE is not None:\\n if type(SRC_GENE) is list:\\n SRC_GENE=set(SRC_GENE)\\n SRC_GENE=self.ALL_GENE.intersection(SRC_GENE) # remove genes from background, if it is not in self.ALL_GENE\\n N_total=len(SRC_GENE) #self.ALL_GENE.intersection(SRC_GENE))\\n elif l_background_by_ontology:\\n # GeneGo uses this\\n if l_multi_list:\\n X=set()\\n for x in S_go.values():\\n X.add(set(x))\\n src_genes=self.gene_count(list(X))\\n else:\\n src_genes=self.gene_count(S_go)\\n N_total=len(src_genes)\\n SRC_GENE=set(src_genes.keys())\\n else:\\n if self.is_L1000():\\n N_total=len(self.ALL_GENE)\\n else:\\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\\n #N_total=len(self.ALL_GENE)\\n # prefiltering uninteresting GO terms\\n # already converted to multiple hit list situation\\n sw=util.StopWatch()\\n L=[] # list of (S_hit, s_go)\\n\\n def spread_input(S_hit, S_go, key):\\n #S_hit, S_go, key=(X[0], X[1], X[2])\\n # may not worth it\\n #c_cnt=self.go_count(S_hit, S_go)\\n #S_go=[s_go for s_go in S_go if c_cnt.get(s_go,0)>=min_overlap ]\\n # minimum size\\n MIN_BATCH=2000\\n S_go2=util.split(S_go, chunk_size=MIN_BATCH)\\n return [(key, S_hit, x) for x in S_go2]\\n\\n #sw.check('To spreadout')\\n if l_multi_list:\\n #mp=parallel.MP()\\n #m=1 if len(S_hit)<=3 else n_CPU\\n #mp.start(f=spread_input, n_CPU=m)\\n #L=[(X, S_go[k], k) for k,X in S_hit.items() if len(X)>=min_overlap]\\n #out=mp.map(L)\\n #L=[y for X in out for y in X]\\n L=[]\\n for k,X in S_hit.items():\\n if len(X)<min_overlap: continue\\n L.extend(spread_input(X, S_go[k], k))\\n random.shuffle(L)\\n else:\\n if len(S_hit)>=min_overlap:\\n L=spread_input(S_hit, S_go, 'Default')\\n\\n if self.eg is None:\\n self.eg=ez.EntrezGene(tax_id=self.tax_id, l_use_GPDB=self.GPDB)\\n if n_CPU==0: n_CPU=1\\n #print \\\">>>>>>>>>>>>>>\\\", len(L)\\n S_chunk=util.split(L, n_chunk=n_CPU)\\n #sw.check('Spreadout tasks: %d' % len(L))\\n\\n def analyze(L):\\n \\\"\\\"\\\"L is a list of [[s_name, S_hit, s_go]], s_go can also be a list\\\"\\\"\\\"\\n rslt=[]\\n #p=util.Progress(len(L))\\n i=0\\n import multiprocessing\\n s_pid=str(multiprocessing.current_process().pid)\\n for s_name, S_hit, S_go in L:\\n i+=1\\n #if (i % 50000): p.check(i, s_pid)\\n if type(S_go) is str: S_go=[S_go]\\n for s_go in S_go:\\n if s_go not in self.GO_GENE: continue\\n if S_score is None:\\n c=self.analysis_go(s_go, S_hit, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff)\\n else:\\n c=self.analysis_go_RSA(s_go, S_hit, S_score, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff, l_keep_most=l_rsa_keep_most)\\n if c is None:\\n continue\\n c['Name']=s_name\\n if min_enrichment>0 and c['Enrichment']<min_enrichment: continue\\n if p_cutoff<1 and 10**c['LogP']>p_cutoff: continue\\n c['Description']= self.go_description(s_go)\\n S_gene=c['GeneID'].split('|')\\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\\n c['Hits']='|'.join(S_symbol)\\n if 'GeneID_All' in c:\\n S_gene=c['GeneID_All'].split('|')\\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\\n c['Hits_All']='|'.join(S_symbol)\\n if self.GPDB:\\n c['CategoryID'] = self.get_category_id(c['GO'])\\n c['Category'] = self.CATEGORY.get(self.get_category_id(c['GO']))\\n c['GO'] = self.get_source_id(c['GO'])\\n rslt.append(c)\\n return rslt\\n out=parallel.parmap(analyze, S_chunk, n_CPU=n_CPU)\\n #if n_CPU>1:\\n # mp=parallel.MP()\\n # mp.start(f=analyze, n_CPU=n_CPU)\\n # out=mp.map(S_chunk)\\n #else:\\n # out=[analyze(x) for x in S_chunk]\\n\\n #mp.start(n_CPU=n_CPU)\\n #sw.check('P-value Calculation')\\n #sw.check('P-value Calculation Done')\\n rslt=[]\\n for x in out:\\n if len(x): rslt.extend(x)\\n\\n if len(rslt):\\n #sw.check('Length: %d' % len(rslt))\\n t=pd.DataFrame(rslt)\\n #sw.check('Table DONE')\\n if S_score is None:\\n t=t.sort_values(['LogP','Enrichment','#GeneInGOAndHitList'], ascending=[True,False,False])\\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\\n '#GeneInGO','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits']\\n else:\\n t=t.sort_values(['LogP','Enrichment','#HitInGORemain','#GeneInGOAndHitList'], ascending=[True,False,False,False])\\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\\n '#GeneInGO','#HitRemain','#HitInGORemain','Cutoff','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits','GeneID_All','Hits_All']\\n if self.GPDB:\\n #cols.insert(1,'field1')\\n cols.insert(1,'CategoryID')\\n cols.insert(1,'Category')\\n #sw.check('sorted DONE')\\n t=t.reindex(columns=cols)\\n # FDR\\n #print \\\">>> N_go: \\\", N_go\\n #sw.check('reindex DONE')\\n t['Log(q-value)']=np.log10(np.clip(stats.adjust_p(np.power(10, t.LogP.values), N=N_go), 1e-100, 1.0))\\n #sw.check('q-value DONE')\\n if not l_multi_list:\\n t.drop('Name', axis=1, inplace=True)\\n return t\\n else:\\n return None\",\n \"def run_demo():\\n while True:\\n embeddings = beer_emb.embed_doc(input(\\\"Test if words are beer-related: \\\"),\\n word_filter=False)\\n for word_vec in embeddings:\\n print(is_beer_related(word_vec))\",\n \"def get_tools_using_technique():\\n global tools_using_technique\\n\\n if not tools_using_technique:\\n tools_using_technique = rsh.tools_using_technique(get_srcs())\\n \\n return tools_using_technique\",\n \"def get_tools(cls):\\n pass\",\n \"def get_tools_used_by_groups():\\n global tools_used_by_groups\\n\\n if not tools_used_by_groups:\\n tools_used_by_groups = rsh.tools_used_by_groups(get_srcs())\\n \\n return tools_used_by_groups\",\n \"def detect_objects(robot):\\n env = robot.GetEnv()\\n with env:\\n robot_in_world = robot.GetTransform()\\n\\n table_in_world = numpy.dot(robot_in_world, TABLE_IN_ROBOT)\\n table = add_object(env, 'table', 'furniture/table.kinbody.xml',\\n table_in_world)\\n\\n glass = add_object(env, 'glass', 'objects/plastic_glass.kinbody.xml',\\n numpy.dot(table_in_world, GLASS_IN_TABLE))\\n return table, glass\",\n \"def find_gpas(s):\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def main():\\n\\n # Setup `pysc` to use BASIC auth, with a username, and password. Also sets the endpoint to use.\\n setup_sensorcloud_basic(CONSTS['SC_USERNAME'], CONSTS['SC_PASSWORD'],\\n CONSTS['SC_ENDPOINT'], CONSTS['PYSC_DEBUG'])\\n\\n org_id = CONSTS['ORG_ID']\\n\\n # Ensure the organisation exists on the SensorCloud endpoint.\\n try:\\n organisation = pysc.models.Organisation.single(org_id)\\n except KeyError:\\n raise RuntimeWarning(\\\"\\\"\\\"The organisation named {:s} was not found.\\\\n\\\"\\\"\\\"\\n \\\"\\\"\\\"Although the `pysc` api has functionality to create an organisation, it cannot \\\"\\\"\\\"\\n \\\"\\\"\\\"do so on the sensor-cloud.io instance on AWS.\\\"\\\"\\\".format(org_id))\\n # Ensure sanity, check we got the organisation that we asked for.\\n assert (org_id == organisation.id)\\n\\n # Here we use the Group.resolve_all helper with organisation_id param to filter groups based on id\\n # The resolve_all command is similar to .index() however it also calls .follow() on found link automatically,\\n # _and_ it converts the resulting HAL objects into real valid `pysc` Group() objects.\\n org_groups = pysc.models.Group.resolve_all(params={'organisation_id': org_id})\\n # We are not likely to have more than 1000 groups, so we don't need to do return doc pagination here.\\n for g in org_groups:\\n group_id = g.id\\n print(\\\"Found group: {:s}\\\".format(group_id))\\n\\n print(\\\"Found a total of {:d} groups for {:s} on that SensorCloud endpoint.\\\".format(len(org_groups), org_id))\",\n \"def test_gettesttools_html(self):\\n pass\",\n \"def kegg_module_enrichment(genelist, dbpaths=dbpaths):\\n size, kegglist = cbir_to_kegg(genelist)\\n\\n #print \\\"Creating Kegg module library\\\"\\n ## create Kegg module dictionary:\\n kmod_h = open(dbpaths['kegg'], 'rb')\\n\\n kmodlist = []\\n kmodd = {}\\n kmodcount = 0\\n kmcount = {}\\n kmod = 'none'\\n\\n kgroupb = {}\\n kgroupbcount = {}\\n kgroupblist = []\\n kbcount = {}\\n b_group = 'none'\\n\\n kgroupc = {}\\n kgroupccount = {}\\n kccount = {}\\n kgroupclist = []\\n c_group = 'none'\\n\\n kod = {} # this is to count how many KOs there are in the list\\n\\n for line in kmod_h:\\n \\\"\\\"\\\"if line[0] == 'B': # higher level functional description (eg 'Energy Metabolism')\\n kbcount[b_group] = len(kgroupbcount)# add old b_group count to dictionary\\n kgroupbcount = {} # reset counter\\n try:\\n b_group = re.search(\\\"<b>(.*)</b>\\\", line).group(1)\\n kgroupblist.append(b_group)\\n except:\\n b_group = 'none'\\n \\\"\\\"\\\"\\n if line[0] == 'C': # descriptive function (eg Carbon fixation)\\n kccount[c_group] = len(kgroupccount)# add old c_group count to dictionary\\n kgroupccount = {} # reset counter\\n try:\\n c_group = re.search(\\\"C *(.*)\\\", line.trim()).group(1)\\n kgroupclist.append(c_group)\\n except:\\n c_group = 'none'\\n\\n elif line[0] == 'D': # Kegg module (eg M00165 Reductive pentose phosphate cycle)\\n kmcount[kmod] = kmodcount\\n kmodcount = 0\\n try:\\n ksearch = re.search(\\\"(M[0-9]*) *(.*)\\\\[PATH\\\", line)\\n kmod = ksearch.group(1)\\n kmoddef = ksearch.group(2)\\n kmodlist.append(kmod)\\n except:\\n kmod = 'none'\\n kmoddef = 'none'\\n\\n elif line[0] == 'E': # Kegg term\\n try:\\n ko = re.search(\\\"(K[0-9]*)\\\", line).group(1)\\n\\n kmodcount += 1\\n kgroupbcount[ko] = True\\n kgroupccount[ko] = True\\n try:\\n kmodd[ko].append(kmod)\\n kgroupb[ko].append(b_group)\\n kgroupc[ko].append(c_group)\\n except:\\n kmodd[ko] = [kmod]\\n kgroupb[ko] = [b_group]\\n kgroupc[ko] = [c_group]\\n except:\\n pass\\n kccount[c_group] = len(kgroupccount)# add final old c_group count to dictionary\\n kmcount[kmod] = kmodcount # add final kmmod group count to dictionary\\n\\n\\n kmodtestsize = len(kmodlist) # for multiple testing correction\\n kgrpbtestsize = len(kgroupblist)\\n kgrpctestsize = len(kgroupclist)\\n\\n #print \\\"calculating Fisher's exact test\\\"\\n # count number of kegglist KOs are in each kegg module, perform Fisher's exact test\\n dip = 0\\n dipcount = {} # possibly unnecessary\\n kmodenrich = {}\\n kmododds = {}\\n\\n for mod in kmodlist:\\n for ko in kegglist:\\n if ko not in kmodd: # some KOs do not exist in a module.\\n pass\\n elif mod in kmodd[ko]:\\n dip += 1\\n dipcount[mod] = dip # possibly unnecessary\\n oddrat, pval = fisher_exact([\\n [dip, len(kegglist) - dip],\\n [kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip]\\n ])\\n if pval < 0.05:\\n print \\\"%s\\\\n In Path Not in Path\\\\nDEG : %-7d %d\\\\nnon-DEG: %-7d %d\\\\n%.4f\\\\n\\\" % (mod, dip, len(kegglist) - dip,kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip, pval )\\n kmododds[mod] = oddrat\\n kmodenrich[mod] = pval\\n dip = 0 # reset for next module\\n #sys.stdout.write(\\\"%s\\\\n In Path Not in Path\\\\nDEG : %-7d %d\\\\nnon-DEG: %-7d %d\\\\n%.4f\\\\n\\\" % (mod, dip, len(kegglist) - dip,kmcount[mod]-dip, len(keggcount) - len(kegglist) - kmcount[mod] + dip, pval ) )\\n #print type(pval), pval\\n #print type(kmodtestsize), kmodtestsize\\n\\n dip = 0\\n kcenrich = {}\\n kcodds = {}\\n\\n for fn in kgroupclist:\\n for ko in kegglist:\\n if fn in kgroupc[ko]:\\n dip += 1\\n #sys.stdout.write(\\\" In Path Not in Path\\\\nDEG :%-7d %d\\\\nnonDEG:%-7d %d\\\" % (dip, len(kegglist) - dip, kccount[fn]-dip, len(keggcount) - len(kegglist) - kccount[fn] + dip ))\\n oddrat, pval = fisher_exact([\\n [dip, len(kegglist) - dip],\\n [kccount[fn]-dip, size - len(kegglist) - kccount[fn] + dip]\\n ])\\n #sys.stdout.write(pval)\\n #sys.stdout.flush()\\n kcodds[fn] = oddrat\\n kcenrich[fn] = pval / kgrpctestsize\\n dip = 0 # reset for next module\\n\\n #print kmodenrich\\n return kmodenrich, kcenrich\\n ## Fisher's Exact Test:\\n # In Pathway: Not in Pathway: SUM:\\n # DEG : dip len(kegglist) - dip len(kegglist)\\n # non-DEG : kmcount[mod]-dip len(keggcount) - len(kegglist) - kmcount[mod] + dip len(keggcount) - len(kegglist)\\n # SUM : kmcount[mod] len(keggcount) - kmcount[mod] len(keggcount)\\n #\\n\\n pass\",\n \"def testExample(self):\\n popesCreek = self.createPopesCreek()\\n mountVernon = self.createMountVernon()\\n chestnutGrove = self.createChestnutGrove()\\n\\n george = self.createGeorge(popesCreek, mountVernon)\\n martha = self.createMartha(chestnutGrove, mountVernon)\\n\\n marriage = self.createMarriage(george, martha)\\n sources = self.citeGeorgeMarthaAndMarriage(george, martha, marriage)\\n\\n contributor = self.createContributor()\\n\\n gx = Gedcomx()\\n gx.persons.set([george, martha])\\n gx.relationships.set([marriage])\\n gx.sourceDescriptions.set(sources)\\n gx.agents.set([contributor])\\n gx.attribution.contributor.resource = u\\\"#\\\" + contributor.id\\n\\n gx.places.set([popesCreek, mountVernon, chestnutGrove])\\n gx_dict = gx.to_dict()\\n\\n # Read the json output from java program and initialize a gedcomx object.\\n dirname = os.path.abspath(os.path.dirname(__file__))\\n java_gx = Gedcomx()\\n java_gx.load( open(os.path.join(dirname, 'data', 'GeorgeMarthaExample_java.json') ))\\n java_dict = java_gx.to_dict()\\n\\n # Compare both objects.\\n self.assertDictEqual(gx_dict, java_dict)\\n self.assertDictEqual(java_dict, gx_dict)\",\n \"def get_genes(variant):\\n genes = {}\\n transcripts = []\\n mongo_genes = []\\n \\n # Conversion from ensembl to refseq\\n # ensembl_to_refseq is a dictionary with ensembl transcript id as keys and\\n # a list of refseq ids as values\\n ensembl_to_refseq = {}\\n for gene_info in variant['info_dict'].get(\\n 'Ensembl_transcript_to_refseq_transcript', []):\\n splitted_gene = gene_info.split(':')\\n transcript_info = splitted_gene[1]\\n for transcript in transcript_info.split('|'):\\n splitted_transcript = transcript.split('>')\\n if len(splitted_transcript) > 1:\\n ensembl_id = splitted_transcript[0]\\n refseq_ids = splitted_transcript[1].split('/')\\n ensembl_to_refseq[ensembl_id] = refseq_ids\\n \\n # A dictionary with clinical gene descriptions\\n gene_descriptions = {}\\n for gene_info in variant['info_dict'].get('Gene_description', []):\\n splitted_gene = gene_info.split(':')\\n hgnc_symbol = splitted_gene[0]\\n description = splitted_gene[1]\\n gene_descriptions[hgnc_symbol] = description\\n \\n # First we get all vep entrys that we find and put them under their \\n # corresponding gene symbol in 'genes'\\n for vep_entry in variant['vep_info'].get(variant['ALT'], []):\\n transcript = get_transcript(vep_entry, ensembl_to_refseq)\\n hgnc_symbol = transcript.hgnc_symbol\\n if hgnc_symbol:\\n if hgnc_symbol in genes:\\n genes[hgnc_symbol]['transcripts'][transcript.transcript_id] = transcript\\n for functional_annotation in transcript.functional_annotations:\\n new_rank = SO_TERMS[functional_annotation]['rank']\\n if new_rank < genes[hgnc_symbol]['best_rank']:\\n genes[hgnc_symbol]['best_rank'] = new_rank\\n genes[hgnc_symbol]['most_severe_transcript'] = transcript\\n genes[hgnc_symbol]['most_severe_function'] = functional_annotation\\n \\n else:\\n genes[hgnc_symbol] = {}\\n genes[hgnc_symbol]['transcripts'] = {}\\n genes[hgnc_symbol]['transcripts'][transcript.transcript_id] = transcript\\n genes[hgnc_symbol]['most_severe_transcript'] = transcript\\n genes[hgnc_symbol]['omim_gene_id'] = None\\n genes[hgnc_symbol]['phenotypic_terms'] = []\\n genes[hgnc_symbol]['best_rank'] = 40\\n genes[hgnc_symbol]['ensembl_id'] = transcript.ensembl_id\\n \\n for functional_annotation in transcript.functional_annotations:\\n new_rank = SO_TERMS[functional_annotation]['rank']\\n if new_rank < genes[hgnc_symbol]['best_rank']:\\n genes[hgnc_symbol]['best_rank'] = new_rank\\n genes[hgnc_symbol]['most_severe_function'] = functional_annotation\\n \\n \\n ######################################################################\\n ## There are two types of OMIM terms, one is the OMIM gene entry ##\\n ## and one is for the phenotypic terms. ##\\n ## Each key in the 'omim_terms' dictionary reprecents a gene id. ##\\n ## Values are a dictionary with 'omim_gene_id' = omim_gene_id and ##\\n ## 'phenotypic_terms' = [list of OmimPhenotypeObjects] ##\\n ######################################################################\\n\\n # Fill the omim gene id:s:\\n for annotation in variant['info_dict'].get('OMIM_morbid', []):\\n if annotation:\\n splitted_record = annotation.split(':')\\n try:\\n hgnc_symbol = splitted_record[0]\\n omim_term = splitted_record[1]\\n genes[hgnc_symbol]['omim_gene_id'] = omim_term\\n except (ValueError, KeyError):\\n pass\\n\\n # Fill the omim phenotype terms:\\n for gene_annotation in variant['info_dict'].get('Phenotypic_disease_model', []):\\n if gene_annotation:\\n splitted_gene = gene_annotation.split(':')\\n hgnc_symbol = splitted_gene[0]\\n for omim_entry in splitted_gene[1].split('|'):\\n splitted_record = omim_entry.split('>')\\n \\n phenotype_id = splitted_record[0]\\n inheritance_patterns = []\\n if len(splitted_record) > 1:\\n inheritance_patterns = splitted_record[1].split('/')\\n \\n disease_model = PhenotypeTerm(\\n phenotype_id=phenotype_id,\\n disease_models=inheritance_patterns\\n )\\n \\n genes[hgnc_symbol]['phenotypic_terms'].append(disease_model)\\n \\n for hgnc_symbol in genes:\\n gene_info = genes[hgnc_symbol]\\n most_severe = gene_info['most_severe_transcript']\\n # Create a mongo engine gene object for each gene found in the variant\\n mongo_gene = Gene(hgnc_symbol=hgnc_symbol)\\n mongo_gene.description = gene_descriptions.get(hgnc_symbol)\\n mongo_gene.ensembl_gene_id = gene_info.get('ensembl_id', None)\\n mongo_gene.omim_gene_entry = gene_info.get(\\n 'omim_gene_id', \\n None\\n )\\n\\n mongo_gene.omim_phenotypes = gene_info.get(\\n 'phenotypic_terms', \\n []\\n )\\n\\n # Add a list with the transcripts:\\n mongo_gene.transcripts = []\\n for transcript_id in gene_info['transcripts']:\\n mongo_gene.transcripts.append(gene_info['transcripts'][transcript_id])\\n\\n try:\\n mongo_gene.functional_annotation = gene_info['most_severe_function']\\n except AttributeError:\\n pass\\n try:\\n mongo_gene.region_annotation = SO_TERMS[mongo_gene.functional_annotation]['region']\\n except AttributeError:\\n pass\\n try:\\n mongo_gene.sift_prediction = most_severe.sift_prediction\\n except AttributeError:\\n pass\\n try:\\n mongo_gene.polyphen_prediction = most_severe.polyphen_prediction\\n except AttributeError:\\n pass\\n # Add the mongo engine gene to the dictionary\\n mongo_genes.append(mongo_gene)\\n\\n return mongo_genes\",\n \"def MergeLogic(self) -> str:\",\n \"def find_common_interactor():\\n # 1. filter the unique fusion gene pairs.\\n # fusionGenePair = pd.read_csv(\\\"./fusionGenePair.csv\\\", header=0, sep=' ')\\n # unique_fusionGenePair = fusionGenePair.drop_duplicates()\\n # unique_fusionGenePair.to_csv(\\\"./uniqueFusion.csv\\\", sep=' ', index=False)\\n unique_fusionGenePair = pd.read_csv(\\\"./uniqueFusion.csv\\\", sep=' ', header=0)\\n\\n # 2. for each gene pairs, get all the interactors each partner has.\\n\\n # Store the 5' partner gene and 3' partner gene in two lists.\\n FivePartnerGenelist = []\\n ThreePartnerGenelist = []\\n for index, row in unique_fusionGenePair.iterrows():\\n FivePartnerGenelist.append(row['5_PARTNER_GENE'])\\n ThreePartnerGenelist.append(row['3_PARTNER_GENE'])\\n # Get the unique gene in each pair\\n uniqueFPGL = list(OrderedDict.fromkeys(FivePartnerGenelist))\\n uniqueTPGL = list(OrderedDict.fromkeys(ThreePartnerGenelist))\\n uniqueGene = list(OrderedDict.fromkeys(uniqueTPGL + uniqueFPGL))\\n\\n # Find each gene's interactor in the PPI datasets\\n PPIS = pd.read_csv(\\\"./IID results/PPIs_final.tsv\\\", sep='\\\\t', header=0)\\n\\n # Put each gene interactor into a dictionary.\\n geneIntDic = {}\\n for item in uniqueGene:\\n for index, row in PPIS.iterrows():\\n if row['Query Symbol'] == item:\\n if item in geneIntDic:\\n geneIntDic[item].append(row['Partner Symbol'])\\n else:\\n key = item\\n geneIntDic.setdefault(key, [])\\n geneIntDic[item].append(row['Partner Symbol'])\\n if row['Partner Symbol'] == item:\\n if item in geneIntDic:\\n geneIntDic[item].append(row['Query Symbol'])\\n else:\\n key = item\\n geneIntDic.setdefault(key, [])\\n geneIntDic[item].append(row['Query Symbol'])\\n w = csv.writer(open(\\\"./geneIntDic.csv\\\", \\\"w\\\"))\\n for key, val in geneIntDic.items():\\n w.writerow([key, val])\",\n \"def search_org(es, text_orig, context=None, just_search=False):\\n # pylint: disable=redefined-variable-type\\n # `org_id` may be `None`, `False` or string.\\n\\n org_id = None\\n text_search = text_orig\\n\\n while True:\\n if context and context.get(\\\"refresh\\\", None):\\n # Necessarily imprecise way of allowing recently\\n # inserted alias to appear in results\\n time.sleep(1)\\n context[\\\"refresh\\\"] = False\\n\\n candidates = get_candidates(es, text_search)\\n if not candidates:\\n break\\n\\n sys.stderr.write(\\n (\\\"\\\\nFind: '\\\\033[92m%s\\\\033[0m'\\\\n\\\\n\\\" % (text_orig))\\n )\\n for i, org in enumerate(candidates, 1):\\n sys.stderr.write(\\n \\\" %4d: \\\\033[37m%-5d %s\\\\033[0m\\\\n\\\" % (\\n i, org[\\\"org_id\\\"], org[\\\"score\\\"])\\n )\\n for name in org[\\\"alias_all\\\"]:\\n sys.stderr.write(\\n (\\\" \\\\033[94m%s\\\\033[0m\\\\n\\\" % name)\\n )\\n sys.stderr.write(\\\"\\\\n\\\")\\n sys.stderr.write(\\\" Empty: None of the above\\\\n\\\")\\n sys.stderr.write(\\\" Text: Alternative search\\\\n: \\\")\\n sys.stderr.write(\\\" '-': Skip\\\\n\\\\n: \\\")\\n if just_search:\\n return\\n\\n choice = input()\\n choice = choice.strip()\\n if not len(choice):\\n org_id = None\\n break\\n sys.stderr.write(\\\"\\\\n\\\")\\n if choice == \\\"-\\\":\\n org_id = False\\n break\\n sys.stderr.write(\\\"\\\\n\\\")\\n try:\\n choice = int(choice)\\n except ValueError:\\n text_search = choice\\n continue\\n if choice == 0:\\n org_id = \\\" \\\"\\n break\\n if choice > len(candidates):\\n continue\\n org_id = candidates[choice - 1][\\\"org_id\\\"]\\n break\\n\\n return org_id\",\n \"def lookup(text):\\n ret = basic(text)\\n ret.update(basic(text, \\\"gwas\\\"))\\n return ret\",\n \"def main():\\n example = {\\n \\\"maybe\\\": True,\\n \\\"gtags\\\": [\\\"one\\\", \\\"two\\\", \\\"three\\\"],\\n \\\"current\\\": {\\n \\\"type\\\": \\\"NUMERIC\\\",\\n \\\"is_filter\\\": True,\\n \\\"values\\\": {\\n \\\"lower\\\": 33,\\n \\\"upper\\\": 0,\\n \\\"operation\\\": \\\"between\\\"\\n }\\n },\\n \\\"loc\\\": {\\n \\\"type\\\": \\\"GEO\\\",\\n \\\"is_filter\\\": True,\\n \\\"values\\\": {\\n \\\"long\\\": 33,\\n \\\"lat\\\": -10,\\n \\\"distance\\\": 1.2,\\n \\\"metric\\\": \\\"km\\\"\\n }\\n },\\n \\\"exact_text\\\": {\\n \\\"type\\\": \\\"TEXT\\\",\\n \\\"is_filter\\\": True,\\n \\\"values\\\": {\\n \\\"term\\\": \\\"hello world\\\"\\n }\\n },\\n }\\n \\n\\n for _ in range(100):\\n insertable = create_insertable(example)\\n \\n print(insertable)\\n pass\",\n \"def main():\\n # files\\n summary_file = sys.argv[1]\\n pwms_to_tfs_file = sys.argv[2]\\n expressed_tfs_file = sys.argv[3] # TODO\\n\\n # TODO pull in num regions to resize things? but complicated with overlaps etc\\n # TODO edit edges with type of interaction\\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\\n \\n # read in data\\n summary = pd.read_csv(summary_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\\\"expressed\\\"].notna()]\\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\\n for line_idx in range(pwms_to_tfs.shape[0]):\\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\\n pwm_name = pwm_info[\\\"hclust_model_name\\\"]\\n pwm_to_tf = dict(zip(pwm_info[\\\"expressed\\\"].split(\\\";\\\"), pwm_info[\\\"expressed_hgnc\\\"].split(\\\";\\\")))\\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\\n\\n \\n # filter expressed hgncs for dynamic ones only\\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\\\"\\\\t\\\", index_col=0)\\n for pwm_name in pwms_to_filt_tfs.keys():\\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\\n for ensembl_tf in tfs_tmp.keys():\\n if ensembl_tf not in tfs_filt.index:\\n del tfs_tmp[ensembl_tf]\\n if len(tfs_tmp.keys()) == 0:\\n del pwms_to_filt_tfs[pwm_name]\\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\\n\\n # add in tfs column\\n tf1 = []\\n for pwm in summary[\\\"pwm1\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n # TODO try add in max point\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf1.append(tf_str)\\n summary[\\\"tf1\\\"] = tf1\\n\\n tf2 = []\\n for pwm in summary[\\\"pwm2\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf2.append(tf_str)\\n summary[\\\"tf2\\\"] = tf2\\n \\n # remove failed rules\\n summary = summary[~summary[\\\"interaction\\\"].str.contains(\\\"FAILED\\\")]\\n \\n # make graph\\n graph = nx.from_pandas_edgelist(summary, \\\"tf1\\\", \\\"tf2\\\")\\n\\n # set up positions\\n #pos = graphviz_layout(graph, prog=\\\"dot\\\")\\n pos = graphviz_layout(graph, prog=\\\"neato\\\")\\n scale_factor = 3\\n for key in pos.keys():\\n coords = pos[key]\\n pos[key] = {\\\"x\\\": scale_factor*coords[0], \\\"y\\\": -scale_factor*coords[1]}\\n nx.set_node_attributes(graph, pos, \\\"graphics\\\") # note this is diff from v1 to v2 in networkx\\n \\n # add graphics\\n add_graphics_theme_to_nx_graph(graph)\\n\\n # write gml\\n out_file = \\\"summary.gml\\\"\\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\\n\\n # tfs: for each tf, get gene column\\n \\n \\n return\",\n \"def main():\\n\\n merch_bot = MerchBot()\\n merch_bot.run_bot()\",\n \"def DontuseThis():\\n BCM_outputs = ['phi','rho','theta',\\n 'r_probabilityMaps','l_probabilityMaps',\\n 'models']\\n BCM_Models = pe.Node(interface=nio.DataGrabber(input_names=['structures'],\\n outfields=BCM_outputs),\\n name='10_BCM_Models')\\n BCM_Models.inputs.base_directory = atlas_fname_wpath\\n BCM_Models.inputs.template_args['phi'] = [['spatialImages','phi','nii.gz']]\\n BCM_Models.inputs.template_args['rho'] = [['spatialImages','rho','nii.gz']]\\n BCM_Models.inputs.template_args['theta'] = [['spatialImages','theta','nii.gz']]\\n BCM_Models.inputs.template_args['r_probabilityMaps'] = [['structures']]\\n BCM_Models.inputs.template_args['l_probabilityMaps'] = [['structures']]\\n BCM_Models.inputs.template_args['models'] = [['structures']]\\n\\n BRAINSCut_structures = ['caudate','thalamus','putamen','hippocampus']\\n #BRAINSCut_structures = ['caudate','thalamus']\\n BCM_Models.iterables = ( 'structures', BRAINSCut_structures )\\n BCM_Models.inputs.template = '%s/%s.%s'\\n BCM_Models.inputs.field_template = dict(\\n r_probabilityMaps='probabilityMaps/r_%s_ProbabilityMap.nii.gz',\\n l_probabilityMaps='probabilityMaps/l_%s_ProbabilityMap.nii.gz',\\n models='modelFiles/%sModel*',\\n )\\n\\n \\\"\\\"\\\"\\n The xml creation and BRAINSCut need to be their own mini-pipeline that gets\\n executed once for each of the structures in BRAINSCut_structures. This can be\\n accomplished with a map node and a new pipeline.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n Create xml file for BRAINSCut\\n \\\"\\\"\\\"\\n\\n\\n BFitAtlasToSubject = pe.Node(interface=BRAINSFit(),name=\\\"BFitAtlasToSubject\\\")\\n BFitAtlasToSubject.inputs.costMetric=\\\"MMI\\\"\\n BFitAtlasToSubject.inputs.maskProcessingMode=\\\"ROI\\\"\\n BFitAtlasToSubject.inputs.numberOfSamples=100000\\n BFitAtlasToSubject.inputs.numberOfIterations=[1500,1500]\\n BFitAtlasToSubject.inputs.numberOfHistogramBins=50\\n BFitAtlasToSubject.inputs.maximumStepLength=0.2\\n BFitAtlasToSubject.inputs.minimumStepLength=[0.005,0.005]\\n BFitAtlasToSubject.inputs.transformType= [\\\"Affine\\\",\\\"BSpline\\\"]\\n BFitAtlasToSubject.inputs.maxBSplineDisplacement= 7\\n BFitAtlasToSubject.inputs.maskInferiorCutOffFromCenter=65\\n BFitAtlasToSubject.inputs.splineGridSize=[28,20,24]\\n BFitAtlasToSubject.inputs.outputVolume=\\\"Trial_Initializer_Output.nii.gz\\\"\\n BFitAtlasToSubject.inputs.outputTransform=\\\"Trial_Initializer_Output.mat\\\"\\n cutWF.connect(SplitAvgBABC,'avgBABCT1',BFitAtlasToSubject,'fixedVolume')\\n cutWF.connect(BABC,'outputLabels',BFitAtlasToSubject,'fixedBinaryVolume')\\n cutWF.connect(BAtlas,'template_t1',BFitAtlasToSubject,'movingVolume')\\n cutWF.connect(BAtlas,'template_brain',BFitAtlasToSubject,'movingBinaryVolume')\\n cutWF.connect(BLI,'outputTransformFilename',BFitAtlasToSubject,'initialTransform')\\n\\n CreateBRAINSCutXML = pe.Node(Function(input_names=['rho','phi','theta',\\n 'model',\\n 'r_probabilityMap',\\n 'l_probabilityMap',\\n 'atlasT1','atlasBrain',\\n 'subjT1','subjT2',\\n 'subjT1GAD','subjT2GAD',\\n 'subjSGGAD','subjBrain',\\n 'atlasToSubj','output_dir'],\\n output_names=['xml_filename','rl_structure_filename_list'],\\n function = create_BRAINSCut_XML),\\n overwrite = True,\\n name=\\\"CreateBRAINSCutXML\\\")\\n\\n ## HACK Makde better directory\\n CreateBRAINSCutXML.inputs.output_dir = \\\".\\\" #os.path.join(cutWF.base_dir, \\\"BRAINSCut_output\\\")\\n cutWF.connect(BCM_Models,'models',CreateBRAINSCutXML,'model')\\n cutWF.connect(BCM_Models,'rho',CreateBRAINSCutXML,'rho')\\n cutWF.connect(BCM_Models,'phi',CreateBRAINSCutXML,'phi')\\n cutWF.connect(BCM_Models,'theta',CreateBRAINSCutXML,'theta')\\n cutWF.connect(BCM_Models,'r_probabilityMaps',CreateBRAINSCutXML,'r_probabilityMap')\\n cutWF.connect(BCM_Models,'l_probabilityMaps',CreateBRAINSCutXML,'l_probabilityMap')\\n cutWF.connect(BAtlas,'template_t1',CreateBRAINSCutXML,'atlasT1')\\n cutWF.connect(BAtlas,'template_brain',CreateBRAINSCutXML,'atlasBrain')\\n cutWF.connect(SplitAvgBABC,'avgBABCT1',CreateBRAINSCutXML,'subjT1')\\n cutWF.connect(SplitAvgBABC,'avgBABCT2',CreateBRAINSCutXML,'subjT2')\\n cutWF.connect(GADT1,'outputVolume',CreateBRAINSCutXML,'subjT1GAD')\\n cutWF.connect(GADT2,'outputVolume',CreateBRAINSCutXML,'subjT2GAD')\\n cutWF.connect(SGI,'outputFileName',CreateBRAINSCutXML,'subjSGGAD')\\n cutWF.connect(BABC,'outputLabels',CreateBRAINSCutXML,'subjBrain')\\n cutWF.connect(BFitAtlasToSubject,'outputTransform',CreateBRAINSCutXML,'atlasToSubj')\\n #CreateBRAINSCutXML.inputs.atlasToSubj = \\\"INTERNAL_REGISTER.mat\\\"\\n #cutWF.connect(BABC,'atlasToSubjectTransform',CreateBRAINSCutXML,'atlasToSubj')\\n\\n \\\"\\\"\\\"\\n ResampleNACLabels\\n \\\"\\\"\\\"\\n ResampleAtlasNACLabels=pe.Node(interface=BRAINSResample(),name=\\\"ResampleAtlasNACLabels\\\")\\n ResampleAtlasNACLabels.inputs.interpolationMode = \\\"NearestNeighbor\\\"\\n ResampleAtlasNACLabels.inputs.outputVolume = \\\"atlasToSubjectNACLabels.nii.gz\\\"\\n\\n cutWF.connect(cutWF,'OutputSpec.atlasToSubjectTransform',ResampleAtlasNACLabels,'warpTransform')\\n cutWF.connect(cutWF,'OutputSpec.t1_corrected',ResampleAtlasNACLabels,'referenceVolume')\\n cutWF.connect(BAtlas,'template_nac_lables',ResampleAtlasNACLabels,'inputVolume')\\n\\n \\\"\\\"\\\"\\n BRAINSMush\\n \\\"\\\"\\\"\\n BMUSH=pe.Node(interface=BRAINSMush(),name=\\\"BMUSH\\\")\\n BMUSH.inputs.outputVolume = \\\"MushImage.nii.gz\\\"\\n BMUSH.inputs.outputMask = \\\"MushMask.nii.gz\\\"\\n BMUSH.inputs.lowerThresholdFactor = 1.2\\n BMUSH.inputs.upperThresholdFactor = 0.55\\n\\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BMUSH,'inputFirstVolume')\\n cutWF.connect(myLocalTCWF,'OutputSpec.t2_corrected',BMUSH,'inputSecondVolume')\\n cutWF.connect(myLocalTCWF,'OutputSpec.outputLabels',BMUSH,'inputMaskVolume')\\n\\n \\\"\\\"\\\"\\n BRAINSROIAuto\\n \\\"\\\"\\\"\\n BROI = pe.Node(interface=BRAINSROIAuto(), name=\\\"BRAINSROIAuto\\\")\\n BROI.inputs.closingSize=12\\n BROI.inputs.otsuPercentileThreshold=0.01\\n BROI.inputs.thresholdCorrectionFactor=1.0\\n BROI.inputs.outputROIMaskVolume = \\\"temproiAuto_t1_ACPC_corrected_BRAINSABC.nii.gz\\\"\\n cutWF.connect(myLocalTCWF,'OutputSpec.t1_corrected',BROI,'inputVolume')\\n\\n \\\"\\\"\\\"\\n Split the implicit outputs of BABCext\\n \\\"\\\"\\\"\\n SplitAvgBABC = pe.Node(Function(input_names=['in_files','T1_count'], output_names=['avgBABCT1','avgBABCT2'],\\n function = get_first_T1_and_T2), run_without_submitting=True, name=\\\"99_SplitAvgBABC\\\")\\n SplitAvgBABC.inputs.T1_count = 1 ## There is only 1 average T1 image.\\n\\n cutWF.connect(myLocalTCWF,'OutputSpec.outputAverageImages',SplitAvgBABC,'in_files')\\n\\n\\n\\n def printFullPath(outFileFullPath):\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"=\\\"*80)\\n print(\\\"{0}\\\".format(outFileFullPath))\\n return outFileFullPath\\n printOutImage = pe.Node( Function(function=printFullPath, input_names = ['outFileFullPath'], output_names = ['genoutFileFullPath']), run_without_submitting=True, name=\\\"99_printOutImage\\\")\\n cutWF.connect( GADT2, 'outputVolume', printOutImage, 'outFileFullPath' )\",\n \"def ensembl_genes(species,log=0):\\n \\n t1=time.time()\\n #open ace genes by- ensembl region\\n path=os.environ['PYDATA']+'/'+species+'/aceview/'+species+'_genes_by_ensembl_region.bkdb'\\n aceGeneDB=bsddb.btopen(path,'r') \\n \\n path=os.environ['PYDATA']+\\\"/\\\"+species+\\\"/ensembl/\\\"+species+'_genes_by_region.bkdb'\\n otherGenesDB=bsddb.btopen(path,'r')\\n '''create ensembl genes by ace gene'''\\n path=os.environ['PYDATA']+'/'+species+'/aceview/'+species+'_ensembl_genes_by_gene.bkdb'\\n otherGenesByGeneDB=bsddb.btopen(path,'w')\\n geneNb=0\\n\\n for region in aceGeneDB.keys():\\n if region not in otherGenesDB.keys():\\n print 'region %s not in ensembl/%s_genes_by_region.bkdb'%(region,species)\\n else: \\n print 'processing region ',region\\n aceGenes=cPickle.loads(aceGeneDB[region])\\n otherGenes=cPickle.loads(otherGenesDB[region])\\n #construct dictionnary of ace genes containing ensembl genes\\n ace={}\\n '''process each ensembl gene in the current region'''\\n for ensemblGeneIndex in range(len(otherGenes.IDs)): \\n '''find the index of the ace genes that contains either the start or the end of the current ensembl gene'''\\n aceGeneIndexes=[]\\n indexes=bintools.owningStructure(otherGenes.starts[ensemblGeneIndex],otherGenes.strands[ensemblGeneIndex],aceGenes.starts,aceGenes.ends,aceGenes.strands,1)\\n aceGeneIndexes.extend(indexes) \\n indexes=bintools.owningStructure(otherGenes.ends[ensemblGeneIndex],otherGenes.strands[ensemblGeneIndex],aceGenes.starts,aceGenes.ends,aceGenes.strands,1)\\n aceGeneIndexes.extend(indexes) \\n '''register the current ensembl gene index in the ace dictionnary'''\\n for aceGeneIndex in aceGeneIndexes: \\n try:\\n ace[aceGenes.IDs[aceGeneIndex]].append(ensemblGeneIndex)\\n except: \\n ace[aceGenes.IDs[aceGeneIndex]]=[ensemblGeneIndex] \\n \\n '''process each ace gene in the current region''' \\n for aceGeneIndex in range(len(aceGenes.IDs)): \\n '''find the index of the ensembl genes that contains either the start or the end of the current ace gene'''\\n ensemblGeneIndexes=[]\\n indexes=bintools.owningStructure(aceGenes.starts[aceGeneIndex],aceGenes.strands[aceGeneIndex],otherGenes.starts,otherGenes.ends,otherGenes.strands,1) \\n ensemblGeneIndexes.extend(indexes)\\n indexes=bintools.owningStructure(aceGenes.ends[aceGeneIndex],aceGenes.strands[aceGeneIndex],otherGenes.starts,otherGenes.ends,otherGenes.strands,1) \\n ensemblGeneIndexes.extend(indexes)\\n '''add the ensembl gene indexes found in the previous for loop processing ensembl genes'''\\n try:\\n ensemblGeneIndexes.extend(ace[aceGenes.IDs[aceGeneIndex]])\\n except:\\n pass \\n ensemblGeneIndexes=set(ensemblGeneIndexes)\\n '''recover the corresponding ensembl gene IDs'''\\n ensemblGeneIDs=[] \\n for i in range(len(ensemblGeneIndexes)):\\n ensemblGeneIDs.append(otherGenes.IDs[ensemblGeneIndexes.pop()]) \\n '''register the current ace gene'''\\n ensemblGeneIDs.sort()\\n otherGenesByGeneDB[aceGenes.IDs[aceGeneIndex]]=cPickle.dumps(ensemblGeneIDs,protocol=-1)\\n geneNb=geneNb+1\\n \\n otherGenesByGeneDB.close() \\n otherGenesDB.close()\\n aceGeneDB.close()\\n t2=time.time()\\n if log!=0:\\n log.write('%s\\\\t%s\\\\t\\\\t17\\\\t%s_ensembl_genes_by_gene.bkdb\\\\taceview\\\\t%u\\\\t%.2f\\\\n'%(date.today(),species,species,geneNb,t2-t1))\",\n \"def change2postion_saveas_wig(wigfile,chrname, cluster, tag_thr=2):\\n package = {}\\n \\n cutoff = 1000 / 10\\n oceanbegin = 0 # ocean: tag num <= 2\\n oceanflag = 1\\n \\n num = []\\n for k in xrange(len(cluster)):\\n num.append(cluster[k])\\n \\n #put a header for each chromosome\\n print >>wigfile,\\\"track type=wiggle_0\\\\nvariableStep chrom=%s span=%d\\\" %(chrname,10)\\n \\n for k in xrange(len(num) - 1):\\n if num[k] > tag_thr:\\n if oceanflag == 1:\\n oceanflag = 0\\n if (k - oceanbegin) >= cutoff:\\n oceanflag = 0\\n for m in xrange(oceanbegin, k):\\n num[m] = -1\\n \\n elif num[k] <= tag_thr and oceanflag == 0:\\n oceanbegin = k\\n oceanflag = 1\\n if oceanflag == 1:\\n for m in xrange(oceanbegin, len(num)):\\n num[m] = -1\\n\\n linenum = 0\\n islandflag = 0\\n islandbegin = 0\\n islandline = 0\\n for k in xrange(len(num) - 1):\\n if islandflag == 0 and num[k] > -1:\\n islandflag = 1\\n linenum += 1\\n islandbegin = k + 1\\n islandline = linenum\\n print >>wigfile, \\\"%d\\\\t%d\\\" %(islandbegin*10-9,num[k])\\n \\n elif islandflag == 1 and num[k] > -1:\\n linenum += 1\\n print >>wigfile, \\\"%d\\\\t%d\\\" %(k*10+1,num[k])\\n elif islandflag == 1 and num[k] == -1:\\n islandflag = 0\\n\\n if islandflag == 1:\\n linenum += 1\\n print >>wigfile, \\\"%d\\\\t%d\\\" %(len(num)*10-9,num[len(num)-1])\\n \\n num = []\",\n \"def exercise():\\n pi_good = get_pdb_inputs(pdb_str=pdb_str_answer, restraints=False)\\n map_data = get_map(xrs=pi_good.xrs)\\n xrs_good = pi_good.xrs.deep_copy_scatterers()\\n pi_good.ph.write_pdb_file(file_name=\\\"answer.pdb\\\",\\n crystal_symmetry=xrs_good.crystal_symmetry())\\n #\\n pi_poor = get_pdb_inputs(pdb_str=pdb_str_poor, restraints=True)\\n pi_poor.ph.write_pdb_file(file_name=\\\"poor.pdb\\\")\\n xrs_poor = pi_poor.xrs.deep_copy_scatterers()\\n #\\n d = xrs_good.distances(other=xrs_poor)\\n print(d.min_max_mean().as_tuple())\\n assert flex.max(d)>2\\n assert flex.mean(d)>0.7\\n #\\n xrs_refined = xrs_poor\\n for i in range(3):\\n ero = individual_sites.easy(\\n map_data = map_data,\\n xray_structure = xrs_refined,\\n pdb_hierarchy = pi_poor.ph,\\n geometry_restraints_manager = pi_poor.grm)\\n xrs_refined = ero.xray_structure\\n # comapre\\n d = xrs_good.distances(other=xrs_refined)\\n print(d.min_max_mean().as_tuple())\\n assert flex.max(d)<0.15\\n assert flex.mean(d)<0.03\\n ero.pdb_hierarchy.write_pdb_file(file_name=\\\"refined.pdb\\\",\\n crystal_symmetry=xrs_good.crystal_symmetry())\",\n \"def region2feature(region , ext):\\n server = \\\"https://rest.ensembl.org/overlap/region/human/\\\"+region +\\\"?\\\"\\n for i in range(len(ext)):\\n server = server + \\\"feature=\\\" + ext[i] + \\\";\\\"\\n\\n server = server[:-1]\\n #print(server)\\n r = requests.get(server,headers={\\\"Content-Type\\\" : \\\"application/json\\\"})\\n\\n if not r.ok:\\n r.raise_for_status()\\n sys.exit()\\n decoded = r.content.decode()\\n dict_decoded = json.loads(decoded)\\n if len(dict_decoded):\\n len_dict = len(dict_decoded)\\n for i in range(len_dict):\\n if dict_decoded[i]['feature_type'] == \\\"gene\\\":\\n ID = dict_decoded[i]['gene_id']\\n start = dict_decoded[i]['start']\\n end = dict_decoded[i]['end']\\n name = dict_decoded[i]['external_name']\\n biotype = dict_decoded[i]['biotype']\\n chr = dict_decoded[i]['seq_region_name']\\n des = dict_decoded[i]['description']\\n print(\\\"{0}\\\\t{1}\\\\t{2}\\\\t{3}\\\\t{4}\\\\t{5}\\\\t{6}\\\".\\\\\\n format(ID,name,chr,start,end,biotype,des),file = Output)\\n return(name)\\n\\n if dict_decoded[i]['feature_type'] == \\\"regulatory\\\":\\n ID = dict_decoded[i]['id']\\n chr = dict_decoded[i]['seq_region_name']\\n start = dict_decoded[i]['start']\\n end = dict_decoded[i]['end']\\n des = dict_decoded[i]['description']\\n feature_type = dict_decoded[i]['feature_type']\\n print(\\\"{0}\\\\t{1}\\\\t{2}\\\\t{3}\\\\t{4}\\\\t{5}\\\".\\\\\\n format(ID,chr,start,end,feature_type,des),file = Output)\\n return(None)\\n else:\\n print(\\\"No match\\\")\",\n \"def add_gazebo_tags():\\n global robot\\n # TODO instantiate plugins according to sensors present in input urdf\\n return\",\n \"def test_incept():\\n\\n # help.ogler.resetLevel(level=logging.DEBUG)\\n\\n for name in [\\\"wan\\\", \\\"wil\\\", \\\"wes\\\", \\\"multisig1\\\", \\\"multisig2\\\", \\\"multisig3\\\"]:\\n if os.path.exists('/usr/local/var/keri/db/{}'.format(name)):\\n shutil.rmtree('/usr/local/var/keri/db/{}'.format(name))\\n if os.path.exists('/usr/local/var/keri/ks/{}'.format(name)):\\n shutil.rmtree('/usr/local/var/keri/ks/{}'.format(name))\\n\\n\\n with habbing.openHab(name=\\\"wan\\\", salt=b'wann-the-witness', transferable=False, temp=False) as wanHab, \\\\\\n habbing.openHab(name=\\\"wil\\\", salt=b'will-the-witness', transferable=False, temp=False) as wilHab, \\\\\\n habbing.openHab(name=\\\"wes\\\", salt=b'wess-the-witness', transferable=False, temp=False) as wesHab:\\n\\n wanDoers = indirecting.setupWitness(name=\\\"wan\\\", hab=wanHab, temp=False, tcpPort=5632, httpPort=5642)\\n wilDoers = indirecting.setupWitness(name=\\\"wil\\\", hab=wilHab, temp=False, tcpPort=5633, httpPort=5643)\\n wesDoers = indirecting.setupWitness(name=\\\"wes\\\", hab=wesHab, temp=False, tcpPort=5634, httpPort=5644)\\n\\n inceptor = InceptingDoer()\\n doers = wanDoers + wilDoers + wesDoers + [inceptor]\\n\\n limit = 2.0\\n tock = 0.03125\\n doist = doing.Doist(tock=tock, limit=limit, doers=doers)\\n doist.enter()\\n\\n tymer = tyming.Tymer(tymth=doist.tymen(), duration=doist.limit)\\n\\n while not tymer.expired:\\n doist.recur()\\n time.sleep(doist.tock)\\n # doist.do(doers=doers)\\n\\n assert doist.limit == limit\\n\\n doist.exit()\\n\\n preb = b'Ep4WexrfQvQjblYg9ti12cr7NpKWaXLNP5CXmq_4Zhng' # multisig aid\\n digb = b'E5_qNBzfkBc2kWAzGn5UUWhWUVrX4Yk1QBpVXHucygfk' # multisig inception digest\\n dgkey = dbing.dgKey(preb, digb)\\n\\n wigs = wanHab.db.getWigs(dgkey)\\n # assert len(wigs) == 3\\n wigs = wilHab.db.getWigs(dgkey)\\n # assert len(wigs) == 3\\n wigs = wesHab.db.getWigs(dgkey)\\n # assert len(wigs) == 3\",\n \"def main(unused_argv):\\n\\n # Read the scene file.\\n with open(FLAGS.scene_path, 'r') as file_id:\\n scenes = json.load(file_id)\\n\\n # Read the synonyms file.\\n with open(FLAGS.synonym_path, 'r') as file_id:\\n synonyms = json.load(file_id)\\n sorter = lambda x: len(x[0].split(' '))\\n\\n # Read the metainformation file.\\n with open(FLAGS.metainfo_path, 'r') as file_id:\\n gvars.METAINFO = json.load(file_id)\\n tag_inv_map = {attr: tag for tag, attr in gvars.METAINFO['tag_map'].items()\\n if tag != '<P>'}\\n gvars.METAINFO['tag_inv_map'] = tag_inv_map\\n gvars.METAINFO['synonym_keys'] = sorted(synonyms.items(),\\n key=sorter, reverse=True)\\n\\n # Add ids to objects.\\n scenes = utils.add_object_ids(scenes)\\n scenes = utils.clean_object_attributes(scenes)\\n\\n # Read the caption templates.\\n template_paths = os.listdir(FLAGS.caption_template_root)\\n cap_templates = []\\n for ii in template_paths:\\n with open(os.path.join(FLAGS.caption_template_root, ii), 'r') as file_id:\\n cur_templates = json.load(file_id)\\n cap_templates.extend(cur_templates)\\n #utils.pretty_print_templates(cap_templates, 1)\\n\\n # Read the question templates.\\n template_paths = os.listdir(FLAGS.question_template_root)\\n ques_templates = []\\n for ii in template_paths:\\n with open(os.path.join(FLAGS.question_template_root, ii), 'r') as file_id:\\n cur_templates = json.load(file_id)\\n ques_templates.extend(cur_templates)\\n #utils.pretty_print_templates(ques_templates, 1)\\n\\n # 1. Check if there a scene_id_file specified.\\n # 2. Check if num_images is -1\\n if FLAGS.scene_id_file != '':\\n with open(FLAGS.scene_id_file, 'r') as file_id:\\n missing_ids = [int(ii.strip('\\\\n')) for ii in file_id.readlines()]\\n print('Dialogs missing for scenes: %d' % len(missing_ids))\\n\\n # Create a image_index -> scenes list index dictionary\\n image_list_id_dict = {ii['image_index']: index\\n for index, ii in enumerate(scenes['scenes'])}\\n scenes_subset = [scenes['scenes'][image_list_id_dict[scene_id]]\\n for scene_id in missing_ids]\\n\\n elif FLAGS.num_images == -1:\\n scenes_subset = scenes['scenes']\\n\\n else:\\n scenes_subset = scenes['scenes'][0: FLAGS.num_images]\\n\\n # BFS for each scene.\\n if FLAGS.num_workers == 1:\\n # Single thread version.\\n dialogs = []\\n for index, scene in enumerate(scenes_subset):\\n cur_time = time.strftime('%a-%d%b%y-%X', time.gmtime())\\n print('Generating [ %s ] [ Worker: %d, Progress: %d/%d Scene: %d ]' %\\\\\\n (cur_time, 0, index, len(scenes_subset), scene['image_index']))\\n gen_dialog = generate_dialog_bfs(scene, cap_templates, ques_templates)\\n dialogs.append(gen_dialog)\\n\\n else:\\n # Multithread version.\\n output_q = multiprocessing.Queue()\\n jobs = []\\n for worker_id in range(FLAGS.num_workers):\\n allotment = scenes_subset[worker_id::FLAGS.num_workers]\\n inputs = (allotment, cap_templates, ques_templates)\\n inputs += (worker_id, output_q)\\n\\n process = multiprocessing.Process(target=worker, args=inputs)\\n jobs.append(process)\\n process.start()\\n\\n # Wait for all the jobs to finish and collect the output.\\n final_results = {}\\n for _ in jobs:\\n final_results.update(output_q.get())\\n for job in jobs:\\n job.join()\\n\\n # Flatten and sort.\\n final_results = [jj for _, ii in final_results.items() for jj in ii]\\n dialogs = sorted(final_results, key=lambda x: x['image_index'])\\n # utils.pretty_print_dialogs(dialogs)\\n\\n # Save the dialogs.\\n print('Saving dialog at: %s' % FLAGS.save_path)\\n with open(FLAGS.save_path, 'w') as file_id:\\n json.dump(dialogs, file_id)\",\n \"def test_evolve_load_generation(logger):\\n\\n generations = 2\\n layers.packet.Packet.reset_restrictions()\\n\\n options = {}\\n options[\\\"population_size\\\"] = 2\\n options[\\\"in-trees\\\"] = 0\\n options[\\\"out-trees\\\"] = 1\\n options[\\\"in-actions\\\"] = 0\\n options[\\\"out-actions\\\"] = 3\\n options[\\\"library\\\"] = False\\n options[\\\"seed\\\"] = None\\n\\n for generation_index in range(generations):\\n population = []\\n population_str = ''\\n\\n # Generate random strategies to initialize the population\\n for i in range(options[\\\"population_size\\\"]):\\n p = evolve.generate_strategy(logger, options[\\\"in-trees\\\"], options[\\\"out-trees\\\"], options[\\\"in-actions\\\"],\\n options[\\\"out-actions\\\"],\\n options[\\\"seed\\\"], environment_id=None)\\n print(str(p))\\n actions.utils.parse(str(p), logger)\\n population.append(p)\\n if i == options[\\\"population_size\\\"] - 1:\\n population_str += str(p)\\n else:\\n population_str += str(p) + \\\"\\\\n\\\"\\n\\n # Write the generation file\\n filename = os.path.join(test_files_directory, \\\"generation\\\" + str(generation_index))\\n evolve.write_generation(filename, population)\\n\\n cmd = [\\n \\\"--population\\\", \\\"3\\\",\\n \\\"--generations\\\", \\\"1\\\",\\n \\\"--test-type\\\", \\\"http\\\",\\n \\\"--load-from\\\", filename,\\n \\\"--port\\\", \\\"80\\\",\\n \\\"--protos\\\", \\\"ip,udp,tcp,dns,dnsqr\\\",\\n \\\"--censor\\\", \\\"censor2\\\",\\n \\\"--log\\\", \\\"debug\\\",\\n \\\"--no-skip-empty\\\",\\n ]\\n print(evolve.driver(cmd))\",\n \"def main(args):\\n corpus = read_corpus(args, verbose=True)\\n for k in sorted(corpus, key=educe.stac.id_to_path):\\n doc = corpus[k]\\n print(\\\"========== %s ============\\\" % k)\\n print()\\n if args.edges:\\n dialogues = sorted_first_widest(filter(is_dialogue, doc.units))\\n if dialogues:\\n d_first = dialogues[0]\\n print(annotate_doc(doc, span=d_first.text_span()))\\n if len(dialogues) > 1:\\n d_last = dialogues[-1]\\n txt = annotate_doc(doc, span=d_last.text_span())\\n print(\\\"...\\\\n\\\")\\n print(txt.encode('utf-8'))\\n else:\\n print(annotate_doc(doc).encode('utf-8'))\\n print()\",\n \"def main():\\n client = SlackClient(ACCESS_TOKEN)\\n\\n if not client.rtm_connect(with_team_state=False):\\n print(\\\"could not connect to slack\\\")\\n sys.exit(1)\\n\\n print(\\\"connected to network!\\\")\\n\\n bot_id = client.api_call(\\\"auth.test\\\")[\\\"user_id\\\"]\\n\\n for data in tagged_messages(client, bot_id):\\n if any(x in data.get(\\\"text\\\") for x in [\\\"lunch\\\", \\\"eat\\\", \\\"hungry\\\"]):\\n whats_for_lunch(client, data)\\n continue\",\n \"def main():\\n\\n cwd = os.path.realpath(__file__)\\n plugin_dir = os.path.join(os.path.dirname(cwd), 'plugins')\\n plugins = {\\n name.replace('greet_', ''): importlib.import_module('plugins.' + name)\\n for _, name, _ in pkgutil.iter_modules(path=[plugin_dir])\\n if name.startswith('greet_')\\n }\\n\\n args = get_args(plugins)\\n\\n print(plugins[args.language].greet(args.name))\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-w\\\", \\\"--workflow_path\\\", help='Path to workflow file')\\n parser.add_argument(\\\"-g\\\", \\\"--galaxy\\\",\\n dest=\\\"galaxy_url\\\",\\n help=\\\"Target Galaxy instance URL/IP address (required \\\"\\n \\\"if not defined in the tools list file)\\\",)\\n parser.add_argument(\\\"-a\\\", \\\"--apikey\\\",\\n dest=\\\"api_key\\\",\\n help=\\\"Galaxy admin user API key (required if not \\\"\\n \\\"defined in the tools list file)\\\",)\\n args = parser.parse_args()\\n\\n gi = galaxy.GalaxyInstance(url=args.galaxy_url, key=args.api_key)\\n\\n with open(args.workflow_path, 'r') as wf_file:\\n import_uuid = json.load(wf_file).get('uuid')\\n existing_uuids = [d.get('latest_workflow_uuid') for d in gi.workflows.get_workflows()]\\n if import_uuid not in existing_uuids:\\n gi.workflows.import_workflow_from_local_path(args.workflow_path)\",\n \"def main():\\n tot = []\\n with open(intersect) as fil:\\n for line in fil:\\n data = []\\n if len(line) > 1:\\n rec = int_parse(line)\\n win = find_winID(rec.wst, w)\\n if int(rec.gst) != -1:\\n imp = rec.info.rstrip().split(';')\\n ID = imp[0].split('=')[1]\\n Name = imp[1].split('=')[1]\\n if imp[2].startswith('fullname'):\\n fullname = imp[2].split('=')[1]\\n if imp[3].startswith('Alias'):\\n Alias = imp[3].split('=')[1]\\n Ontology_term = imp[4].split('=')[1]\\n Dbxref = imp[5].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n Alias = 'NA'\\n Ontology_term = imp[3].split('=')[1]\\n Dbxref = imp[4].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n fullname = 'NA'\\n if imp[2].startswith('Alias'):\\n Alias = imp[2].split('=')[1]\\n Ontology_term = imp[3].split('=')[1]\\n Dbxref = imp[4].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n Alias = 'NA'\\n Ontology_term = imp[2].split('=')[1]\\n Dbxref = imp[3].split('=')[1]\\n GO, _ = split_ont(Ontology_term)\\n _, SO = split_ont(Ontology_term)\\n gst = rec.gst\\n gen = rec.gen\\n else:\\n ID = 'NA'\\n Name = 'NA'\\n fullname = 'NA'\\n gst = 'NA'\\n gen = 'NA'\\n Alias = 'NA'\\n GO = 'NA'\\n SO = 'NA'\\n Dbxref = 'NA'\\n data.append(ID)\\n data.append(Name)\\n data.append(fullname)\\n data.append(gst)\\n data.append(gen)\\n data.append(Alias)\\n data.append(GO)\\n data.append(SO)\\n data.append(Dbxref)\\n data.append(rec.chrom)\\n data.append(win)\\n tot.append(tuple(data))\\n writeTable(tot)\",\n \"def main():\\n\\tnews = Googlenews()\\n\\tnews.gnews()\",\n \"def get_doc_prov(j, gcis_url, refList):\\n gcis_ns = \\\"https://gcis-search-stage.jpl.net:3000/gcis.owl#\\\"\\n doc = ProvEsDocument()\\n bndl = None\\n \\n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\\n# for ref in refList:\\n# if ref['child_publication'] == j['uri']:\\n \\n\\n\\n doc_attrs = [\\n (\\\"prov:type\\\", 'gcis:Article'),\\n (\\\"prov:label\\\", j['title']),\\n (\\\"prov:location\\\", j['uri']),\\n #(\\\"prov:wasAttributedTo\\\", j['']),\\n ]\\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\\n\\n prov_json = json.loads(doc.serialize())\\n\\n return prov_json\",\n \"def find_mgrs_intersection_large(footprint):\\n\\n polygon_geom = ogr.CreateGeometryFromWkt(footprint)\\n\\n mgrs_grid_file_dir = Path(DATA_DIR, 'MGRS_100kmSQ_ID')\\n\\n mgrs_master_shp_file = Path(mgrs_grid_file_dir, 'mgrs_gzd_final.shp')\\n\\n shapefile_driver = ogr.GetDriverByName(\\\"ESRI Shapefile\\\")\\n\\n print(mgrs_master_shp_file)\\n\\n grid_ds = shapefile_driver.Open(str(mgrs_master_shp_file), 0)\\n\\n layer = grid_ds.GetLayer()\\n\\n # sourceSR = layer.GetSpatialRef()\\n # targetSR = osr.SpatialReference()\\n # targetSR.ImportFromEPSG(4326) # WGS84\\n # coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)\\n\\n feature_count = layer.GetFeatureCount()\\n print(f\\\"Number of features in {os.path.basename(mgrs_master_shp_file)}: {feature_count}\\\")\\n layerDefinition = layer.GetLayerDefn()\\n\\n for i in range(layerDefinition.GetFieldCount()):\\n print(layerDefinition.GetFieldDefn(i).GetName())\\n\\n intersect_list = []\\n\\n for f in layer:\\n # print feature.GetField(\\\"STATE_NAME\\\")\\n # geom = feature.GetGeometryRef()\\n # print(geom.Centroid().ExportToWkt())\\n # geom_list.append(geom)\\n # print(geom)\\n\\n geom = f.GetGeometryRef()\\n # print(geom)\\n # print(polygon_geom)\\n intersect_result = geom.Intersection(polygon_geom)\\n # print(intersect_result)\\n if not intersect_result.IsEmpty():\\n print(\\\"FOUND INTERSECT\\\")\\n print(f.GetField('gzd'))\\n intersect_list.append(f.GetField('gzd'))\\n\\n # # iterate over the geometries and dissolve all into one\\n # layer = dataSource.GetLayer()\\n # layerDefinition = layer.GetLayerDefn()\\n\\n # for i in range(layerDefinition.GetFieldCount()):\\n # print(layerDefinition.GetFieldDefn(i).GetName())\\n\\n # Collect all Geometry\\n # geomcol = ogr.Geometry(ogr.wkbGeometryCollection)\\n # Create the feature and set values\\n # featureDefn = outLayer.GetLayerDefn()\\n # feature = ogr.Feature(featureDefn)\\n\\n # multipoly = ogr.Geometry(ogr.wkbMultiPolygon)\\n # for feature in inLayer:\\n # geomcol.AddGeometry(feature.GetGeometryRef())\\n\\n # geom_list = []\\n\\n\\n # geomcol.AddGeometry(geom)\\n\\n # if problem_child:\\n # # print(file_stem_split)\\n # # print(geom)\\n # print(geom.IsValid())\\n # # print(idx)\\n # pass\\n # if file_stem_split in ['59Q']:\\n # print(geom)\\n # print(geom.GetGeometryName())\\n\\n\\n\\n\\n # spatial_ref = osr.SpatialReference()\\n # spatial_ref.ImportFromEPSG(4326)\\n\\n # outLayer = outDataSource.CreateLayer(\\\"gzd_8x6_degree\\\", spatial_ref, geom_type=ogr.wkbMultiPolygon)\\n\\n # # Add an ID field\\n # idField = ogr.FieldDefn(\\\"id\\\", ogr.OFTInteger)\\n # outLayer.CreateField(idField)\\n # gzdField = ogr.FieldDefn(\\\"gzd\\\", ogr.OFTString)\\n # outLayer.CreateField(gzdField)\\n\\n # for idx, file_name in enumerate(Path(target_dir).iterdir()):\\n # problem_child = False\\n # print(idx)\\n # if file_name.suffix == '.zip':\\n # # print(file_name)\\n # print('Found a zip file')\\n # file_name_only = file_name.name\\n # file_name_stem = file_name.stem\\n # # print(file_name_only)\\n # # print(file_name_stem)\\n\\n # file_stem_split = file_name_stem.split('_')[-1]\\n\\n # print(file_stem_split)\\n\\n # # if file_stem_split not in ['59Q']:\\n # # continue\\n\\n # if file_stem_split in ['Antarctica', 'Arctic']:\\n # continue\\n\\n # with zipfile.ZipFile(file_name, 'r') as zf:\\n # # zf.extractall('temp_unzip')\\n # actual_file_stem = \\\"\\\"\\n # for zip_info in zf.infolist():\\n # print(zip_info.filename)\\n\\n # if zip_info.filename[-1] == '/':\\n # continue\\n\\n # zip_info.filename = zip_info.filename.split('/')[-1]\\n # if actual_file_stem == \\\"\\\":\\n # actual_file_stem = zip_info.filename.split('.')[0]\\n # zf.extract(zip_info, temp_zip_dir)\\n\\n # if actual_file_stem != file_name_stem:\\n # file_name_stem = actual_file_stem\\n\\n # file_path = Path(temp_zip_dir, file_name_stem + '.shp')\\n\\n # print(file_path)\\n\\n # dataSource = outDriver.Open(str(file_path), 0) # 0 means read-only. 1 means writeable.\\n\\n # if dataSource is None:\\n # print(f'Could not open {file_path}')\\n # else:\\n # print(f'Opened {file_path}')\\n # layer = dataSource.GetLayer()\\n\\n # sourceSR = layer.GetSpatialRef()\\n # targetSR = osr.SpatialReference()\\n # targetSR.ImportFromEPSG(4326) # WGS84\\n\\n # coordTrans = osr.CoordinateTransformation(sourceSR, targetSR)\\n\\n # if file_stem_split in ['01R', '01S', '01K', '01J', '01H']:\\n # # print('WE GOT A PROBLEM CHILD HERE')\\n # # print('\\\\n\\\\n\\\\n\\\\n')\\n # problem_child = True\\n\\n\\n # featureCount = layer.GetFeatureCount()\\n # print(f\\\"Number of features in {os.path.basename(file_path)}: {featureCount}\\\")\\n\\n # # # iterate over the geometries and dissolve all into one\\n # # layer = dataSource.GetLayer()\\n # # layerDefinition = layer.GetLayerDefn()\\n\\n # # for i in range(layerDefinition.GetFieldCount()):\\n # # print(layerDefinition.GetFieldDefn(i).GetName())\\n\\n # # Collect all Geometry\\n # geomcol = ogr.Geometry(ogr.wkbGeometryCollection)\\n # # Create the feature and set values\\n # featureDefn = outLayer.GetLayerDefn()\\n # feature = ogr.Feature(featureDefn)\\n\\n # multipoly = ogr.Geometry(ogr.wkbMultiPolygon)\\n # # for feature in inLayer:\\n # # geomcol.AddGeometry(feature.GetGeometryRef())\\n\\n # # geom_list = []\\n # for f in layer:\\n # # print feature.GetField(\\\"STATE_NAME\\\")\\n # # geom = feature.GetGeometryRef()\\n # # print(geom.Centroid().ExportToWkt())\\n # # geom_list.append(geom)\\n # # print(geom)\\n\\n # geom = f.GetGeometryRef()\\n # geom.Transform(coordTrans)\\n\\n # # geomcol.AddGeometry(geom)\\n\\n # if problem_child:\\n # # print(file_stem_split)\\n # # print(geom)\\n # print(geom.IsValid())\\n # # print(idx)\\n # pass\\n # if file_stem_split in ['59Q']:\\n # print(geom)\\n # print(geom.GetGeometryName())\\n\\n # if idx > 18 and idx < 1176:\\n # if file_stem_split in ['59Q']:\\n # print(geom)\\n # print(geom.GetGeometryName())\\n # if geom.GetGeometryName() == 'MULTIPOLYGON':\\n # for i in range(0, geom.GetGeometryCount()):\\n # g = geom.GetGeometryRef(i)\\n # # print(g.GetGeometryName())\\n # multipoly.AddGeometry(g)\\n\\n\\n # else:\\n # multipoly.AddGeometry(geom)\\n # elif idx > 1176:\\n # sub_geom = geom.GetGeometryRef(0)\\n # # print(sub_geom)\\n # # print(sub_geom.GetPointCount())\\n\\n # outRing = ogr.Geometry(ogr.wkbLinearRing)\\n # # outRing.AddPoint(1154115.274565847, 686419.4442701361)\\n\\n # # Create inner ring\\n # # innerRing = ogr.Geometry(ogr.wkbLinearRing)\\n # # innerRing.AddPoint(1149490.1097279799, 691044.6091080031)\\n\\n # # Create polygon\\n # poly = ogr.Geometry(ogr.wkbPolygon)\\n # # poly.AddGeometry(outRing)\\n # # poly.AddGeometry(innerRing)\\n\\n # for i in range(0, sub_geom.GetPointCount()):\\n # # GetPoint returns a tuple not a Geometry\\n # pt = sub_geom.GetPoint(i)\\n\\n # if pt[0] < 0:\\n # point_x = pt[0] * -1\\n # point_y = pt[1]\\n # else:\\n # point_x = pt[0]\\n # point_y = pt[1]\\n\\n # outRing.AddPoint(point_x, point_y)\\n # # print(\\\"%i). POINT (%f %f)\\\" %(i, point_x, point_y))\\n\\n # poly.AddGeometry(outRing)\\n\\n\\n\\n # multipoly.AddGeometry(poly)\\n # else:\\n # sub_geom = geom.GetGeometryRef(0)\\n # # print(sub_geom)\\n # # print(sub_geom.GetPointCount())\\n\\n # outRing = ogr.Geometry(ogr.wkbLinearRing)\\n # # outRing.AddPoint(1154115.274565847, 686419.4442701361)\\n\\n # # Create inner ring\\n # # innerRing = ogr.Geometry(ogr.wkbLinearRing)\\n # # innerRing.AddPoint(1149490.1097279799, 691044.6091080031)\\n\\n # # Create polygon\\n # poly = ogr.Geometry(ogr.wkbPolygon)\\n # # poly.AddGeometry(outRing)\\n # # poly.AddGeometry(innerRing)\\n\\n # for i in range(0, sub_geom.GetPointCount()):\\n # # GetPoint returns a tuple not a Geometry\\n # pt = sub_geom.GetPoint(i)\\n\\n # if pt[0] > 0:\\n # point_x = pt[0] * -1\\n # point_y = pt[1]\\n # else:\\n # point_x = pt[0]\\n # point_y = pt[1]\\n\\n # outRing.AddPoint(point_x, point_y)\\n # # print(\\\"%i). POINT (%f %f)\\\" %(i, point_x, point_y))\\n\\n # poly.AddGeometry(outRing)\\n\\n\\n\\n # multipoly.AddGeometry(poly)\\n\\n # # layer.ResetReading()\\n\\n # # print(feature)\\n\\n # cascade_union = multipoly.UnionCascaded()\\n # feature.SetGeometry(cascade_union)\\n\\n # # convexhull = geomcol.ConvexHull()\\n # # feature.SetGeometry(convexhull)\\n\\n # file_name_split = file_name_stem.split('_')\\n # gzd_from_file_name = file_name_split[-1]\\n # # print(idx + 1)\\n\\n # feature.SetField(\\\"id\\\", idx + 1)\\n # feature.SetField(\\\"gzd\\\", gzd_from_file_name)\\n\\n # outLayer.CreateFeature(feature)\\n\\n # feature = None\\n\\n # # Save and close DataSource\\n # dataSource = None\\n\\n # for file_name in Path(temp_zip_dir).iterdir():\\n # os.remove(file_name)\\n\\n # # if idx > 20:\\n # # break\\n\\n # # all done!\\n grid_ds = None\\n\\n return intersect_list\",\n \"def run():\\n\\n api = api_start()\\n stonks = {}\\n check_function = load_symbol_list()\\n for obj in (\\\"comments\\\", \\\"submissions\\\"):\\n for post in get_text(api, obj):\\n if obj == \\\"comments\\\":\\n full_text = post.body\\n else: # obj == \\\"submissions\\\"\\n full_text = post.title + post.selftext\\n try:\\n stonks = check_texts(\\n full_text, post.author.name, stonks, check_function\\n )\\n except AttributeError:\\n pass\\n\\n return stonks\",\n \"def intronDiscovery(poolArguement):\\n\\n\\tbamFiles, gene, chrom, start, stop, cwd = poolArguement\\n\\n\\tprint ('processing ' + gene)\\n\\n\\tpos = ''.join([chrom, ':', start, '-', stop])\\n\\n\\tfor bam in bamFiles:\\n\\n\\t\\tspliceDict = {}\\n\\t\\tgeneFilePath = (cwd + \\\"/\\\" + bam[:-4] + \\\"/\\\" + gene + \\\".txt\\\")\\n\\n\\t\\ttry:\\n\\t\\t\\texitcode, stdout, stderr = run(' '.join(['samtools view', bam, pos]))\\n\\t\\texcept Exception as e:\\n\\t\\t\\tprint ('Exception message: ' + str(e))\\n\\t\\t\\tprint (\\\"Exception occured while running \\\\\\\"samtools view\\\\\\\" on \\\" + bam + \\\" for position \\\" + pos + \\\" Skipping.\\\")\\n\\t\\t\\tcontinue\\n\\n\\t\\tif not stdout:\\n\\t\\t\\t#print ('No introns found for ' + gene + ' at ' + pos + ' in ' + bam)\\n\\t\\t\\tcontinue\\n\\n\\t\\tfor line in stdout.splitlines():\\n\\n\\t\\t\\telems = line.decode().split()\\n\\n\\t\\t\\talignmentStart = int(elems[3])\\n\\t\\t\\tcigar = str(elems[5])\\n\\t\\t\\talignmentScore = int(elems[1])\\n \\n\\t\\t\\tif 'N' not in cigar: \\t#only get introns\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tif (alignmentScore >= 256): \\t#only primary alignments\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tif not ((alignmentStart > int(start)) and (alignmentStart < int(stop))): \\t#check if alignment start is after known junction start but before known junction end \\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\toffset, matchedExon, intronLength = parseCIGARForIntrons(cigar)\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint ('Error message: ' + str(e))\\n\\t\\t\\t\\tprint ('Error trying to parse CIGAR string: ' + cigar + ' with the bam file ' + bam + ' and the position: ' + pos + ' Skipping.')\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tjunctionStart = alignmentStart + matchedExon + offset\\n\\t\\t\\tjunctionEnd = junctionStart + intronLength\\n\\n\\t\\t\\t# Beryl Cummings' Code, taken from makeUniqSpliceDict()\\n\\t\\t\\t# uniqueSplice = ':'.join([chrom, str(junctionStart), str(junctionEnd)])\\n\\t\\t\\tuniqueSplice = (chrom, str(junctionStart), str(junctionEnd))\\n\\t\\t\\t\\n\\t\\t\\tif uniqueSplice not in spliceDict:\\n\\t\\t\\t\\tspliceDict[uniqueSplice] = 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tspliceDict[uniqueSplice] += 1\\n\\n\\t\\tdel stdout # saves ram in between samtool calls\\n\\n\\t\\tif spliceDict:\\n\\t\\t\\tprintSplices(geneFilePath, spliceDict)\\n\\t\\t\\tdel spliceDict\\n\\n\\tprint ('finished ' + gene)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='MergeGVCFs and genotype them using the GATK')\\n parser.add_argument('-g', '--gatk', dest='gatk', help=\\\"Location of the GATK\\\", required=True)\\n parser.add_argument('-x', '--xmx', dest='xmx', help=\\\"Memory to use with JAVA\\\", required=True)\\n parser.add_argument('-c', '--cores', dest='cores', help=\\\"Number of cores to use\\\")\\n parser.add_argument('-o', '--output', dest='output', \\n help='Final output from the haplotype caller')\\n parser.add_argument('-r', '--reference', dest='reference', \\n help='Reference FASTA file')\\n parser.add_argument('-b','--bed', dest='bed_file',\\n help=\\\"Bed file for limiting the GATK\\\")\\n parser.add_argument('-p', '--ploidy', dest='ploidy', \\n help=\\\"Sample ploidy\\\", default=2)\\n parser.add_argument('-d', '--out_directory', dest='directory', help='Output director')\\n parser.add_argument('bams', nargs=\\\"*\\\", help='gVCF variant call files output from the GATK')\\n args = parser.parse_args()\\n args.cores = int(args.cores)\\n args.xmx = args.xmx.strip('\\\"')\\n print args.bams\\n genovcfs = haplotype_caller(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\\n bams=args.bams, reference=args.reference,\\n out_directory=args.directory, ploidy=args.ploidy, bed_file=args.bed_file)\\n outputs = merge_gvcfs(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\\n gvcfs=genovcfs, reference=args.reference)\\n genotype_gvcfs(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\\n inputs=outputs, output=args.output, reference=args.reference,bed_file=args.bed_file)\\n #haplotype_single(gatk=args.gatk, xmx=args.xmx, cores=args.cores,\\n # inputs=args.gvcfs, reference=args.reference)\",\n \"def recon_sg2(json_file_dir, if_add_bases=True):\\n id2color = {\\n \\\"gray\\\": [87, 87, 87],\\n \\\"red\\\": [173, 35, 35],\\n \\\"blue\\\": [42, 75, 215],\\n \\\"green\\\": [29, 105, 20],\\n \\\"brown\\\": [129, 74, 25],\\n \\\"purple\\\": [129, 38, 192],\\n \\\"cyan\\\": [41, 208, 208],\\n \\\"yellow\\\": [255, 238, 51],\\n \\\"c1\\\": [42, 87, 9],\\n \\\"c2\\\": [255, 102, 255],\\n \\\"orange\\\": [255, 140, 0]\\n }\\n\\n color2id = {tuple(v): u for u, v in id2color.items()}\\n with open(json_file_dir, 'r') as json_file:\\n du = json.load(json_file)\\n location_dict = {}\\n objects = []\\n bboxes = []\\n for obj in du[\\\"objects\\\"]:\\n color = tuple([int(du33*255) for du33 in obj[\\\"color\\\"]][:-1])\\n object_id = color2id[color]\\n a_key = \\\"%.3f\\\" % obj[\\\"location\\\"][0]\\n if a_key not in location_dict:\\n location_dict[a_key] = [(object_id, obj[\\\"location\\\"][2])]\\n else:\\n location_dict[a_key].append((object_id, obj[\\\"location\\\"][2]))\\n objects.append(object_id)\\n bboxes.append([\\n obj[\\\"bbox\\\"][0]/128.0,\\n obj[\\\"bbox\\\"][1]/128.0,\\n obj[\\\"bbox\\\"][2]/128.0,\\n obj[\\\"bbox\\\"][3]/128.0,\\n ])\\n obj2id = {objects[du4]: objects[du4] for du4 in range(len(objects))}\\n if if_add_bases:\\n relationships = [\\n [obj2id[\\\"brown\\\"], \\\"left\\\", obj2id[\\\"purple\\\"]],\\n [obj2id[\\\"purple\\\"], \\\"left\\\", obj2id[\\\"cyan\\\"]],\\n ]\\n else:\\n relationships = []\\n for du3 in location_dict:\\n location = sorted(location_dict[du3], key=lambda x: x[1])\\n while len(location) > 1:\\n o1 = location.pop()[0]\\n o2 = location[-1][0]\\n relationships.append([obj2id[o1], \\\"up\\\", obj2id[o2]])\\n assert o1 not in [\\\"cyan\\\", \\\"purple\\\", \\\"brown\\\"]\\n\\n return relationships\",\n \"def main():\\n\\n # this will analyze all files in the input_files directory\\n for folder in [x for x in os.listdir(os.path.join(os.getcwd(), 'test_directory')) if os.path.isdir(os.path.join(os.getcwd(), 'test_directory', x))]:\\n try:\\n print(f'Creating GED_Repo for files in {folder}')\\n g = GED_Repo([os.path.join(os.getcwd(), 'test_directory', folder, f) for f in os.listdir(os.path.join(os.getcwd(), 'test_directory', folder)) if f.endswith('.ged')])\\n g.check_data()\\n g.print_data()\\n g.print_individuals()\\n g.print_families()\\n except ValueError as v:\\n print(v)\\n except FileNotFoundError as f:\\n print(f)\",\n \"def cli(ctx):\",\n \"def cli(ctx):\",\n \"def test_pnictogen():\\n for template in templates:\\n template_prefix, extension = os.path.splitext(template)\\n for xyz_file in example_xyz_files:\\n input_prefix, xyz_file_extension = os.path.splitext(xyz_file)\\n\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(xyz_file, xyz_file_extension[1:])\\n )\\n written_files = pnictogen(mol, input_prefix, template, extension[1:])\\n\\n assert_equals(type(written_files), list)\\n for written_file in written_files:\\n assert_equals(type(written_file), str)\\n\\n written_files2 = pnictogen(mol, input_prefix, template)\\n assert_equals(written_files, written_files2)\\n\\n # Allow use of template in the parent directory\\n with cd(\\\"pnictogen/repo\\\"):\\n mol = Atoms(\\n cclib.bridge.cclib2openbabel.readfile(\\\"../../data/water-dimer.xyz\\\", \\\"xyz\\\")\\n )\\n written_files = pnictogen(mol, \\\"../../data/water-dimer\\\", \\\"ADF.in\\\", \\\"in\\\")\\n\\n assert_equals(written_files, [\\\"../../data/water-dimer.in\\\"])\\n\\n main([\\\"-g\\\", \\\"/tmp/hello.world.ORCA.inp\\\"])\\n mol = Atoms(cclib.bridge.cclib2openbabel.readfile(\\\"data/co.xyz\\\", \\\"xyz\\\"))\\n written_files = pnictogen(mol, \\\"data/co\\\", \\\"/tmp/hello.world.ORCA.inp\\\", foo=\\\"bar\\\")\\n\\n assert_equals(written_files, [\\\"data/co.inp\\\"])\",\n \"def main(argv):\\n\\tendpoint = \\\"C\\\"\\n\\tif len(argv) > 0:\\n\\t\\tendpoint = argv[0]\\t\\t\\n\\t\\n\\tsite_map = {}\\n\\tsite_map[\\\"5 Major Pooled\\\"] = [\\\"Agogo\\\", \\\"Kintampo\\\", \\\"Kombewa\\\", \\\"Nanoro\\\", \\\"Siaya\\\"]\\n\\tsite_map[\\\"11 Pooled\\\"] = [\\\"Agogo\\\", \\\"Kintampo\\\", \\\"Kombewa\\\", \\\"Nanoro\\\", \\\"Siaya\\\", \\\"Bagamoyo\\\", \\\"Kilifi\\\", \\\"Korogwe\\\", \\\"Lambarene\\\", \\\"Lilongwe\\\", \\\"Manhica\\\"]\\n\\tstart_map = {}\\n\\tstart_map[\\\"TEP\\\"] = 294\\n\\tstart_map[\\\"SERA2\\\"] = 36\\n\\tend_map = {}\\n\\tend_map[\\\"TEP\\\"] = 387\\n\\tend_map[\\\"SERA2\\\"] = 119\\n\\t\\n\\tthreshold_map = {}\\n\\tthreshold_map[\\\"TEP_5 Major Pooled_6-12 Weeks_C\\\"] = 4\\n\\tthreshold_map[\\\"TEP_11 Pooled_6-12 Weeks_C\\\"] = 4\\n\\tthreshold_map[\\\"TEP_5 Major Pooled_5-17 Months_C\\\"] = 4\\n\\tthreshold_map[\\\"TEP_11 Pooled_5-17 Months_C\\\"] = 4\\t\\n\\tthreshold_map[\\\"TEP_5 Major Pooled_6-12 Weeks_X\\\"] = 3\\n\\tthreshold_map[\\\"TEP_11 Pooled_6-12 Weeks_X\\\"] = 3\\n\\tthreshold_map[\\\"TEP_5 Major Pooled_5-17 Months_X\\\"] = 4\\n\\tthreshold_map[\\\"TEP_11 Pooled_5-17 Months_X\\\"] = 4\\t\\n\\t\\n\\tthreshold_map[\\\"SERA2_5 Major Pooled_6-12 Weeks_C\\\"] = 4\\n\\tthreshold_map[\\\"SERA2_11 Pooled_6-12 Weeks_C\\\"] = 4\\n\\tthreshold_map[\\\"SERA2_5 Major Pooled_5-17 Months_C\\\"] = 4\\n\\tthreshold_map[\\\"SERA2_11 Pooled_5-17 Months_C\\\"] = 4\\t\\n\\tthreshold_map[\\\"SERA2_5 Major Pooled_6-12 Weeks_X\\\"] = 4\\n\\tthreshold_map[\\\"SERA2_11 Pooled_6-12 Weeks_X\\\"] = 3\\n\\tthreshold_map[\\\"SERA2_5 Major Pooled_5-17 Months_X\\\"] = 4\\n\\tthreshold_map[\\\"SERA2_11 Pooled_5-17 Months_X\\\"] = 4\\t\\t\\t\\n\\t\\t\\n\\tdata = get_data(endpoint)\\n\\t\\n\\tprint \\\"locus\\\\tsite\\\\tcohort\\\\taa\\\"\\n\\n\\tfor locus in [\\\"SERA2\\\"]:\\n\\t\\tfor site_group in [\\\"5 Major Pooled\\\", \\\"11 Pooled\\\"]:\\n\\t\\t\\tfor cohort in [\\\"6-12 Weeks\\\", \\\"5-17 Months\\\"]:\\t\\t\\n\\t\\t\\t\\tsubset = subset_data(data, locus, site_map[site_group], cohort)\\n\\t\\t\\t\\tthreshold = threshold_map[\\\"_\\\".join([locus, site_group, cohort, endpoint])]\\n\\t\\t\\t\\taa_sites = get_filtered_sites(subset, start_map[locus], end_map[locus], threshold)\\n\\t\\t\\t\\tprint_filtered_sites(locus, site_group, cohort, aa_sites)\",\n \"def get_go():\\n # decompress obo file if it wasn't yet\\n if not os.path.exists(OBO_FILE):\\n _decompress_obofile()\\n # create global variable\\n if __GO__[0] is None:\\n __GO__[0] = onto.Ontology(OBO_FILE, with_rels=True, include_alt_ids=False)\\n return __GO__[0]\",\n \"def build_gallery(\\n include_core: bool = True,\\n include_contrib: bool = True,\\n ignore_suppress: bool = False,\\n ignore_only_for: bool = False,\\n only_these_expectations: List[str] = [],\\n only_consider_these_backends: List[str] = [],\\n context: Optional[DataContext] = None,\\n) -> Dict:\\n gallery_info = dict()\\n requirements_dict = {}\\n logger.info(\\\"Loading great_expectations library.\\\")\\n installed_packages = pkg_resources.working_set\\n installed_packages_txt = sorted(f\\\"{i.key}=={i.version}\\\" for i in installed_packages)\\n logger.debug(f\\\"Found the following packages: {installed_packages_txt}\\\")\\n\\n expectation_file_info = get_expectation_file_info_dict(\\n include_core=include_core,\\n include_contrib=include_contrib,\\n only_these_expectations=only_these_expectations,\\n )\\n import great_expectations\\n\\n core_expectations = (\\n great_expectations.expectations.registry.list_registered_expectation_implementations()\\n )\\n if include_core:\\n print(\\\"\\\\n\\\\n\\\\n=== (Core) ===\\\")\\n logger.info(\\\"Getting base registered expectations list\\\")\\n logger.debug(f\\\"Found the following expectations: {sorted(core_expectations)}\\\")\\n for expectation in core_expectations:\\n if only_these_expectations and expectation not in only_these_expectations:\\n # logger.debug(f\\\"Skipping {expectation} since it's not requested\\\")\\n continue\\n requirements_dict[expectation] = {\\\"group\\\": \\\"core\\\"}\\n\\n just_installed = set()\\n failed_to_import_set = set()\\n\\n if include_contrib:\\n print(\\\"\\\\n\\\\n\\\\n=== (Contrib) ===\\\")\\n logger.info(\\\"Finding contrib modules\\\")\\n skip_dirs = (\\\"cli\\\", \\\"tests\\\")\\n contrib_dir = os.path.join(\\n os.path.dirname(__file__),\\n \\\"..\\\",\\n \\\"..\\\",\\n \\\"contrib\\\",\\n )\\n\\n for root, dirs, files in os.walk(contrib_dir):\\n for dirname in skip_dirs:\\n if dirname in dirs:\\n dirs.remove(dirname)\\n if \\\"expectations\\\" in dirs:\\n if root.endswith(\\\"great_expectations_experimental\\\"):\\n sys.path.append(root)\\n else:\\n # A package in contrib that may contain more Expectations\\n sys.path.append(os.path.dirname(root))\\n for filename in files:\\n if filename.endswith(\\\".py\\\") and filename.startswith(\\\"expect_\\\"):\\n if (\\n only_these_expectations\\n and filename.replace(\\\".py\\\", \\\"\\\") not in only_these_expectations\\n ):\\n # logger.debug(f\\\"Skipping {filename} since it's not requested\\\")\\n continue\\n logger.debug(f\\\"Getting requirements for module {filename}\\\")\\n contrib_subdir_name = os.path.basename(os.path.dirname(root))\\n requirements_dict[filename[:-3]] = get_contrib_requirements(\\n os.path.join(root, filename)\\n )\\n requirements_dict[filename[:-3]][\\\"group\\\"] = contrib_subdir_name\\n logger.info(\\\"Done finding contrib modules\\\")\\n\\n for expectation in sorted(requirements_dict):\\n # Temp\\n if expectation in [\\n \\\"expect_column_kl_divergence_to_be_less_than\\\", # Infinity values break JSON\\n \\\"expect_column_values_to_be_valid_arn\\\", # Contrib Expectation where pretty much no test passes on any backend\\n ]:\\n continue\\n group = requirements_dict[expectation][\\\"group\\\"]\\n print(f\\\"\\\\n\\\\n\\\\n=== {expectation} ({group}) ===\\\")\\n requirements = requirements_dict[expectation].get(\\\"requirements\\\", [])\\n parsed_requirements = pkg_resources.parse_requirements(requirements)\\n for req in parsed_requirements:\\n is_satisfied = any(\\n [installed_pkg in req for installed_pkg in installed_packages]\\n )\\n if is_satisfied or req in just_installed:\\n continue\\n logger.debug(f\\\"Executing command: 'pip install \\\\\\\"{req}\\\\\\\"'\\\")\\n status_code = execute_shell_command(f'pip install \\\"{req}\\\"')\\n if status_code == 0:\\n just_installed.add(req)\\n else:\\n expectation_tracebacks.write(\\n f\\\"\\\\n\\\\n----------------\\\\n{expectation} ({group})\\\\n\\\"\\n )\\n expectation_tracebacks.write(f\\\"Failed to pip install {req}\\\\n\\\\n\\\")\\n\\n if group != \\\"core\\\":\\n logger.debug(f\\\"Importing {expectation}\\\")\\n try:\\n if group == \\\"great_expectations_experimental\\\":\\n importlib.import_module(f\\\"expectations.{expectation}\\\", group)\\n else:\\n importlib.import_module(f\\\"{group}.expectations\\\")\\n except (ModuleNotFoundError, ImportError, Exception) as e:\\n logger.error(f\\\"Failed to load expectation: {expectation}\\\")\\n print(traceback.format_exc())\\n expectation_tracebacks.write(\\n f\\\"\\\\n\\\\n----------------\\\\n{expectation} ({group})\\\\n\\\"\\n )\\n expectation_tracebacks.write(traceback.format_exc())\\n failed_to_import_set.add(expectation)\\n continue\\n\\n logger.debug(f\\\"Running diagnostics for expectation: {expectation}\\\")\\n try:\\n impl = great_expectations.expectations.registry.get_expectation_impl(\\n expectation\\n )\\n diagnostics = impl().run_diagnostics(\\n ignore_suppress=ignore_suppress,\\n ignore_only_for=ignore_only_for,\\n debug_logger=logger,\\n only_consider_these_backends=only_consider_these_backends,\\n context=context,\\n )\\n checklist_string = diagnostics.generate_checklist()\\n expectation_checklists.write(\\n f\\\"\\\\n\\\\n----------------\\\\n{expectation} ({group})\\\\n\\\"\\n )\\n expectation_checklists.write(f\\\"{checklist_string}\\\\n\\\")\\n if diagnostics[\\\"description\\\"][\\\"docstring\\\"]:\\n diagnostics[\\\"description\\\"][\\\"docstring\\\"] = format_docstring_to_markdown(\\n diagnostics[\\\"description\\\"][\\\"docstring\\\"]\\n )\\n except Exception:\\n logger.error(f\\\"Failed to run diagnostics for: {expectation}\\\")\\n print(traceback.format_exc())\\n expectation_tracebacks.write(\\n f\\\"\\\\n\\\\n----------------\\\\n{expectation} ({group})\\\\n\\\"\\n )\\n expectation_tracebacks.write(traceback.format_exc())\\n else:\\n try:\\n gallery_info[expectation] = diagnostics.to_json_dict()\\n gallery_info[expectation][\\\"created_at\\\"] = expectation_file_info[\\n expectation\\n ][\\\"created_at\\\"]\\n gallery_info[expectation][\\\"updated_at\\\"] = expectation_file_info[\\n expectation\\n ][\\\"updated_at\\\"]\\n gallery_info[expectation][\\\"package\\\"] = expectation_file_info[\\n expectation\\n ][\\\"package\\\"]\\n gallery_info[expectation][\\\"exp_type\\\"] = expectation_file_info[\\n expectation\\n ].get(\\\"exp_type\\\")\\n except TypeError as e:\\n logger.error(f\\\"Failed to create JSON for: {expectation}\\\")\\n print(traceback.format_exc())\\n expectation_tracebacks.write(\\n f\\\"\\\\n\\\\n----------------\\\\n[JSON write fail] {expectation} ({group})\\\\n\\\"\\n )\\n expectation_tracebacks.write(traceback.format_exc())\\n\\n if just_installed:\\n print(\\\"\\\\n\\\\n\\\\n=== (Uninstalling) ===\\\")\\n logger.info(\\n f\\\"Uninstalling packages that were installed while running this script...\\\"\\n )\\n for req in just_installed:\\n logger.debug(f\\\"Executing command: 'pip uninstall -y \\\\\\\"{req}\\\\\\\"'\\\")\\n execute_shell_command(f'pip uninstall -y \\\"{req}\\\"')\\n\\n expectation_filenames_set = set(requirements_dict.keys())\\n full_registered_expectations_set = set(\\n great_expectations.expectations.registry.list_registered_expectation_implementations()\\n )\\n if only_these_expectations:\\n registered_expectations_set = (\\n set(only_these_expectations) & full_registered_expectations_set\\n )\\n expectation_filenames_set = (\\n set(only_these_expectations) & expectation_filenames_set\\n )\\n elif not include_core:\\n registered_expectations_set = full_registered_expectations_set - set(\\n core_expectations\\n )\\n else:\\n registered_expectations_set = full_registered_expectations_set\\n non_matched_filenames = (\\n expectation_filenames_set - registered_expectations_set - failed_to_import_set\\n )\\n if failed_to_import_set:\\n expectation_tracebacks.write(f\\\"\\\\n\\\\n----------------\\\\n(Not a traceback)\\\\n\\\")\\n expectation_tracebacks.write(\\\"Expectations that failed to import:\\\\n\\\")\\n for expectation in sorted(failed_to_import_set):\\n expectation_tracebacks.write(f\\\"- {expectation}\\\\n\\\")\\n if non_matched_filenames:\\n expectation_tracebacks.write(f\\\"\\\\n\\\\n----------------\\\\n(Not a traceback)\\\\n\\\")\\n expectation_tracebacks.write(\\n \\\"Expectation filenames that don't match their defined Expectation name:\\\\n\\\"\\n )\\n for fname in sorted(non_matched_filenames):\\n expectation_tracebacks.write(f\\\"- {fname}\\\\n\\\")\\n\\n bad_names = sorted(\\n list(registered_expectations_set - expectation_filenames_set)\\n )\\n expectation_tracebacks.write(\\n f\\\"\\\\nRegistered Expectation names that don't match:\\\\n\\\"\\n )\\n for exp_name in bad_names:\\n expectation_tracebacks.write(f\\\"- {exp_name}\\\\n\\\")\\n\\n if include_core and not only_these_expectations:\\n core_dir = os.path.join(\\n os.path.dirname(__file__),\\n \\\"..\\\",\\n \\\"..\\\",\\n \\\"great_expectations\\\",\\n \\\"expectations\\\",\\n \\\"core\\\",\\n )\\n core_expectations_filename_set = {\\n fname.rsplit(\\\".\\\", 1)[0]\\n for fname in os.listdir(core_dir)\\n if fname.startswith(\\\"expect_\\\")\\n }\\n core_expectations_not_in_gallery = core_expectations_filename_set - set(\\n core_expectations\\n )\\n if core_expectations_not_in_gallery:\\n expectation_tracebacks.write(f\\\"\\\\n\\\\n----------------\\\\n(Not a traceback)\\\\n\\\")\\n expectation_tracebacks.write(\\n f\\\"Core Expectation files not included in core_expectations:\\\\n\\\"\\n )\\n for exp_name in sorted(core_expectations_not_in_gallery):\\n expectation_tracebacks.write(f\\\"- {exp_name}\\\\n\\\")\\n\\n return gallery_info\",\n \"def support(self):\",\n \"def test_charged_ligand():\\n imatinib_path = examples_paths()['imatinib']\\n with mmtools.utils.temporary_directory() as tmp_dir:\\n # receptors = {'Asp': -1, 'Abl': -8} # receptor name -> net charge\\n # Only run `Asp` on CI as Abl can be very slow\\n receptors = {'Asp': -1} # receptor name -> net charge\\n solvent_names = ['PME', 'PMEionic']\\n updates = yank_load(\\\"\\\"\\\"\\n molecules:\\n Asp:\\n name: \\\"(3S)-3-amino-4-hydroxy-4-oxo-butanoate\\\"\\n openeye: {{quacpac: am1-bcc}}\\n antechamber: {{charge_method: null}}\\n imatinib:\\n filepath: {}\\n openeye: {{quacpac: am1-bcc}}\\n antechamber: {{charge_method: null}}\\n explicit-system:\\n receptor: !Combinatorial {}\\n ligand: imatinib\\n pack: yes\\n solvent: !Combinatorial {}\\n \\\"\\\"\\\".format(imatinib_path, list(receptors.keys()), solvent_names))\\n yaml_content = get_template_script(tmp_dir, keep_openeye=True)\\n yaml_content['options']['resume_setup'] = True\\n yaml_content['molecules'].update(updates['molecules'])\\n yaml_content['solvents']['PMEionic'] = copy.deepcopy(yaml_content['solvents']['PME'])\\n yaml_content['solvents']['PMEionic']['ionic_strength'] = '10*millimolar'\\n yaml_content['systems']['explicit-system'].update(updates['explicit-system'])\\n exp_builder = ExperimentBuilder(yaml_content)\\n\\n for receptor in receptors:\\n\\n for solvent_name in solvent_names:\\n system_id = 'explicit-system_{}_{}'.format(receptor, solvent_name)\\n system_files_paths = exp_builder._db.get_system(system_id)\\n for i, phase_name in enumerate(['complex', 'solvent']):\\n inpcrd_file_path = system_files_paths[i].position_path\\n prmtop_file_path = system_files_paths[i].parameters_path\\n\\n system, topology, _ = pipeline.read_system_files(\\n inpcrd_file_path, prmtop_file_path, {'nonbondedMethod': openmm.app.PME})\\n\\n # Identify components.\\n if phase_name == 'complex':\\n alchemical_region = 'ligand_atoms'\\n topography = Topography(topology, ligand_atoms='resname MOL')\\n\\n # Safety check: receptor must be negatively charged as expected\\n receptor_net_charge = pipeline.compute_net_charge(system,\\n topography.receptor_atoms)\\n assert receptor_net_charge == receptors[receptor]\\n else:\\n alchemical_region = 'solute_atoms'\\n topography = Topography(topology)\\n\\n # There is a single ligand/solute counterion.\\n ligand_counterions = pipeline.find_alchemical_counterions(system, topography,\\n alchemical_region)\\n assert len(ligand_counterions) == 1\\n ion_idx = ligand_counterions[0]\\n ion_atom = next(itertools.islice(topology.atoms(), ion_idx, None))\\n assert '-' in ion_atom.residue.name\\n\\n # In complex, there should be both ions even if the system is globally\\n # neutral (e.g. asp lys system), because of the alchemical ion.\\n n_pos_ions, n_neg_ions, n_ionic_strength_ions = get_number_of_ions(\\n exp_builder, phase=phase_name, system_id=system_id)\\n print(system_id, phase_name, n_ionic_strength_ions, n_pos_ions, n_neg_ions)\\n\\n # Check correct number of ions.\\n if phase_name == 'complex':\\n n_neutralization_ions = abs(receptors[receptor])\\n if n_ionic_strength_ions > 0:\\n n_neutralization_ions -= 1 # we don't add an extra anion to alchemically modify\\n assert n_pos_ions == n_neutralization_ions + n_ionic_strength_ions\\n assert n_neg_ions == max(1, n_ionic_strength_ions)\\n else:\\n assert n_pos_ions == n_ionic_strength_ions\\n assert n_neg_ions == 1 + n_ionic_strength_ions\",\n \"def main():\\n\\n allowed_splitlevels = (1, 99)\\n parser = argparse.ArgumentParser(description=main.__doc__, epilog='Homepage: https://github.com/kbat/mc-tools')\\n parser.add_argument('-splitlevel', dest='splitlevel', type=int, help='split level (see TTree::Branch documentation)', required=False, default=1, choices=allowed_splitlevels)\\n parser.add_argument('wssa', type=str, help='ssw output file name')\\n arguments = parser.parse_args()\\n\\n fin_name = arguments.wssa\\n fout_name = fin_name + \\\".root\\\"\\n\\n hits = ROOT.hit_t()\\n\\n ssw = SSW(fin_name)\\n\\n fout = ROOT.TFile(fout_name, \\\"recreate\\\", ssw.getTitle())\\n T = ROOT.TTree(\\\"T\\\", ssw.probs)\\n# T.SetMaxTreeSize((Long64_t)1e+18)\\n\\n if arguments.splitlevel==99:\\n T.Branch(\\\"hits\\\", hits, \\\"history:id:weight:energy:time:x:y:z:wx:wy:k\\\")\\n elif arguments.splitlevel == 1:\\n T.Branch(\\\"history\\\", ROOT.AddressOf(hits, 'history'), \\\"history\\\")\\n T.Branch(\\\"id\\\", ROOT.AddressOf(hits, 'id'), \\\"id\\\")\\n T.Branch(\\\"weight\\\", ROOT.AddressOf(hits, 'weight'), \\\"weight\\\")\\n T.Branch(\\\"energy\\\", ROOT.AddressOf(hits, 'energy'), \\\"energy\\\")\\n T.Branch(\\\"time\\\", ROOT.AddressOf(hits, 'time'), \\\"time\\\")\\n T.Branch(\\\"x\\\", ROOT.AddressOf(hits, 'x'), \\\"x\\\")\\n T.Branch(\\\"y\\\", ROOT.AddressOf(hits, 'y'), \\\"y\\\")\\n T.Branch(\\\"z\\\", ROOT.AddressOf(hits, 'z'), \\\"z\\\")\\n T.Branch(\\\"wx\\\", ROOT.AddressOf(hits, 'wx'), \\\"wx\\\")\\n T.Branch(\\\"wy\\\", ROOT.AddressOf(hits, 'wy'), \\\"wy\\\")\\n T.Branch(\\\"k\\\", ROOT.AddressOf(hits, 'k'), \\\"k\\\")\\n\\n for i in range(ssw.nevt):\\n ssb = ssw.readHit()\\n hits.history = ssb[0] # >0 = with collision, <0 = without collision\\n hits.id = ssb[1] # surface + particle type + multigroup problem info\\n hits.weight = ssb[2]\\n hits.energy = ssb[3] # [MeV]\\n hits.time = ssb[4] # [shakes]\\n hits.x = ssb[5] # [cm]\\n hits.y = ssb[6] # [cm]\\n hits.z = ssb[7] # [cm]\\n hits.wx = ssb[8]\\n hits.wy = ssb[9]\\n hits.k = ssb[10] # cosine of angle between track and normal to surface jsu (in MCNPX it is called cs)\\n T.Fill()\\n \\n sinfo = ROOT.TObjString(\\\"%d\\\" % ssw.N); # number of incident particles for correct normalisation\\n T.GetUserInfo().Add(sinfo);\\n\\n# T.Print()\\n T.SetAlias(\\\"theta\\\", \\\"TMath::RadToDeg()*(TMath::ATan2(x,y) > 0 ? TMath::ATan2(x,y) : 2*TMath::Pi()+TMath::ATan2(x,y))\\\");\\n T.SetAlias(\\\"i\\\",\\\"TMath::Nint(TMath::Abs(id/1E+6))\\\");# tmp variable\\n T.SetAlias(\\\"JGP\\\",\\\"-TMath::Nint(i/200.0)\\\"); # energy group\\n T.SetAlias(\\\"JC\\\",\\\"TMath::Nint(i/100.0) + 2*JGP\\\"); #\\n T.SetAlias(\\\"IPT\\\",\\\"i-100*JC+200*JGP\\\"); # particle type: 1=neutron, 2=photon, 3=electron\\n T.SetAlias(\\\"wz\\\", \\\"TMath::Sqrt(TMath::Max(0, 1-wx*wx-wy*wy)) * id/TMath::Abs(id)\\\") # z-direction cosine\\n T.SetAlias(\\\"surface\\\", \\\"TMath::Abs(id) % 1000000\\\") # surface crossed\\n T.Write()\\n fout.Purge()\\n fout.Close()\",\n \"def main():\\n create_sets()\\n optimal_weights = genetic_algorithm()\\n obtain_best_model(optimal_weights)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62130064","0.5718101","0.53815275","0.53254366","0.5073769","0.50681895","0.49845618","0.49842817","0.4910564","0.48540446","0.4827082","0.47912404","0.47549713","0.47513545","0.47407323","0.47222322","0.47175512","0.47109953","0.47066993","0.47058165","0.47013947","0.46902668","0.46694463","0.46639556","0.46578944","0.46440396","0.46432805","0.46389493","0.46367154","0.4635699","0.46300936","0.46223375","0.46198657","0.46162978","0.46058488","0.4589986","0.4573985","0.45629898","0.45517072","0.45323324","0.45303112","0.45278126","0.4521334","0.4510846","0.45097926","0.4501034","0.44931597","0.4481952","0.4476276","0.4471141","0.44678724","0.4466425","0.44659293","0.4460476","0.44577423","0.44571868","0.44530907","0.44487423","0.443507","0.44348046","0.4428008","0.44270268","0.44211477","0.44187212","0.44162682","0.44138485","0.44132954","0.4411836","0.44105026","0.4408013","0.44030768","0.4402716","0.44007748","0.43987513","0.43888038","0.4387965","0.43868175","0.43803003","0.43779993","0.43776342","0.43752247","0.43750995","0.4369148","0.4368258","0.43659818","0.43604976","0.43604138","0.43601197","0.4358382","0.43484068","0.43472853","0.43472853","0.43441987","0.43399897","0.43353721","0.4331755","0.43301263","0.43288624","0.43274555","0.43237442"],"string":"[\n \"0.62130064\",\n \"0.5718101\",\n \"0.53815275\",\n \"0.53254366\",\n \"0.5073769\",\n \"0.50681895\",\n \"0.49845618\",\n \"0.49842817\",\n \"0.4910564\",\n \"0.48540446\",\n \"0.4827082\",\n \"0.47912404\",\n \"0.47549713\",\n \"0.47513545\",\n \"0.47407323\",\n \"0.47222322\",\n \"0.47175512\",\n \"0.47109953\",\n \"0.47066993\",\n \"0.47058165\",\n \"0.47013947\",\n \"0.46902668\",\n \"0.46694463\",\n \"0.46639556\",\n \"0.46578944\",\n \"0.46440396\",\n \"0.46432805\",\n \"0.46389493\",\n \"0.46367154\",\n \"0.4635699\",\n \"0.46300936\",\n \"0.46223375\",\n \"0.46198657\",\n \"0.46162978\",\n \"0.46058488\",\n \"0.4589986\",\n \"0.4573985\",\n \"0.45629898\",\n \"0.45517072\",\n \"0.45323324\",\n \"0.45303112\",\n \"0.45278126\",\n \"0.4521334\",\n \"0.4510846\",\n \"0.45097926\",\n \"0.4501034\",\n \"0.44931597\",\n \"0.4481952\",\n \"0.4476276\",\n \"0.4471141\",\n \"0.44678724\",\n \"0.4466425\",\n \"0.44659293\",\n \"0.4460476\",\n \"0.44577423\",\n \"0.44571868\",\n \"0.44530907\",\n \"0.44487423\",\n \"0.443507\",\n \"0.44348046\",\n \"0.4428008\",\n \"0.44270268\",\n \"0.44211477\",\n \"0.44187212\",\n \"0.44162682\",\n \"0.44138485\",\n \"0.44132954\",\n \"0.4411836\",\n \"0.44105026\",\n \"0.4408013\",\n \"0.44030768\",\n \"0.4402716\",\n \"0.44007748\",\n \"0.43987513\",\n \"0.43888038\",\n \"0.4387965\",\n \"0.43868175\",\n \"0.43803003\",\n \"0.43779993\",\n \"0.43776342\",\n \"0.43752247\",\n \"0.43750995\",\n \"0.4369148\",\n \"0.4368258\",\n \"0.43659818\",\n \"0.43604976\",\n \"0.43604138\",\n \"0.43601197\",\n \"0.4358382\",\n \"0.43484068\",\n \"0.43472853\",\n \"0.43472853\",\n \"0.43441987\",\n \"0.43399897\",\n \"0.43353721\",\n \"0.4331755\",\n \"0.43301263\",\n \"0.43288624\",\n \"0.43274555\",\n \"0.43237442\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4953663"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":10799,"cells":{"query":{"kind":"string","value":"Finds the top variable GO enrichment of top principal genes in the binary coexpression network. Principal genes are those with most coexpressed genes. They reflect the most variable pathways in the dataset. When the variable pathways are housekeeping related, they may conceal celltypespecific coexpression patterns from being observed and understood. This function identifies the most variable pathway with gene ontology enrichment study of the top principal genes. Background genes are all genes provided."},"document":{"kind":"string","value":"def gotop(net, namet, go_file, goa_file, n=100, **ka):\n\timport numpy as np\n\tnt = len(namet)\n\tif net.shape != (nt, nt) or nt <= 1:\n\t\traise ValueError('Wrong shape for net or namet.')\n\tif n <= 1 or n >= nt:\n\t\traise ValueError(\n\t\t\t'Number of principal genes must be from 1 to the number of all genes (exclusive).'\n\t\t)\n\n\t# Find principal genes\n\tt1 = net.sum(axis=1)\n\tt2 = t1[t1.argsort()[::-1][n]]\n\n\tif t2 == 0:\n\t\traise RuntimeError('Not enough principal genes that have co-expression')\n\tt2 = np.nonzero(t1 >= t2)[0]\n\tassert len(t2) >= n\n\tassert len(t2) < nt\n\tt1 = [str(x) for x in namet[t2]]\n\tt2 = [str(x) for x in namet]\n\treturn tuple([t1] + list(goe(t1, go_file, goa_file, bg=t2, **ka)))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def GetTopConfidenceNodes(g, dia, topn=20):\r\n conf_hf = {}\r\n for i in g.nodes(data=True):\r\n n, distr = i\r\n if (distr['class_distribution']['No Diagnosis'] != 0):\r\n conf_hf[n] = distr['class_distribution']['Diagnosis'] / (\r\n distr['class_distribution']['Diagnosis'] + distr['class_distribution']['No Diagnosis'])\r\n nx.set_node_attributes(g, conf_hf, 'confidence')\r\n nodeconf = {i[0]: i[1]['confidence'] for i in g.nodes(data=True) if\r\n (i[1]['class_distribution']['No Diagnosis'] != 0)}\r\n nodeconf_sorted = sorted(nodeconf.items(), key=operator.itemgetter(1), reverse=True)\r\n PrintCodeDescr(g, dia, nodeconf_sorted[:topn], mode=\"node\")","def most_discriminating( features_df, labels_df, top=5):\n \n columns = features_df.shape[1]\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\n qualities = np.zeros(columns)\n \n _left = 0\n _right = 1\n\n _c = 0\n _h = 1\n\n # globals\n cases = float(labels_df['candy_id'].count()) # total cases\n\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\n p_h_A = 1.0 - p_c_A\n\n\n for feature in range(columns):\n\n branch_cases = np.zeros(2) # total on each branch\n pi = np.zeros(2) # proportion on each branch\n\n split = np.array([\n #c, h\n [0, 0], #left\n [0, 0] #right\n ])\n\n for index, value in features_df[feature].iteritems():\n split[value][labels_df.loc[index][0]] += 1\n\n branch_cases[_left] = split[_left].sum()\n branch_cases[_right] = split[_right].sum()\n \n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\n qualities[feature] = 0\n continue\n \n pi[_left] = branch_cases[_left] / cases\n pi[_right] = branch_cases[_right] / cases\n\n p_c_B = split[_left][_c] / branch_cases[_left]\n p_h_B = split[_left][_h] / branch_cases[_left]\n\n p_c_C = split[_right][_c] / branch_cases[_right]\n p_h_C = split[_right][_h] / branch_cases[_right]\n\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\n\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\n\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\n\n qualities[feature] = quality\n return list(reversed(qualities.argsort()))[:top]","def GetTopConfidenceEdges(g, dia, topn=20):\r\n edgez = {(e[0], e[1]): e[2]['z'] for e in g.edges(data=True)}\r\n edgeconf = {(e[0], e[1]): e[2]['frac_minority'] for e in g.edges(data=True)}\r\n edgenum = {(e[0], e[1]): e[2]['num_patients'] for e in g.edges(data=True)}\r\n edgez_sorted = sorted(edgez.items(), key=operator.itemgetter(1), reverse=True)[:topn]\r\n newedgez_sorted = []\r\n for e in edgez_sorted:\r\n e = list(e)\r\n edge = e[0]\r\n e.append(edgenum[e[0]])\r\n e.append(edgeconf[e[0]])\r\n newedgez_sorted.append(e)\r\n PrintCodeDescr(g, dia, newedgez_sorted, mode=\"edge\")","def get_functional_enrichment(enrichment_file, go, remove_parents=False, only_biological_processes=False, only_slim=False, logodds_cutoff=0):\n\n #from toolbox import OboParser\n #g=OboParser.getOboGraph(\"/home/emre/arastirma/celldiff/data/GO/gene_ontology.1_2.obo\")\n g=go\n\n go_terms = None\n name = None\n name_to_go_terms ={}\n\n altid_to_goid = {}\n for goid, data in g.nodes(data=True):\n for altid in data[\"x\"]:\n altid_to_goid[altid] = goid\n\n f = open(enrichment_file)\n for line in f:\n line = line.strip()\n if line.startswith(\"# of\"):\n go_terms = set()\n elif line.startswith(\"#\"):\n if go_terms is not None: \n if name is None:\n name = \"generic\"\n if remove_parents:\n go_terms = remove_parent_terms(go_terms, g)\n name_to_go_terms[name] = go_terms\n #print name, go_terms\n name = line \n else:\n words = line.split(\"\\t\")\n try:\n n = int(words[0])\n #pval = float(words[4]) # contains text like <0.0067\n except:\n print(words)\n continue\n go_term = words[5]\n lodds = float(words[2])\n if lodds < logodds_cutoff:\n continue\n if go_term in altid_to_goid:\n go_term = altid_to_goid[go_term]\n if only_biological_processes:\n if g.node[go_term]['t'] == \"biological_process\": # and 'a' in g.node[go_term]: #is bp and slim # (\"molecular_function\", \"biological_process\"):\n if only_slim:\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\n go_terms.add(go_term)\n else:\n go_terms.add(go_term)\n else:\n if only_slim:\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\n go_terms.add(go_term)\n else:\n go_terms.add(go_term)\n\n f.close()\n\n if name is None:\n name = \"generic\"\n if remove_parents:\n go_terms = remove_parent_terms(go_terms, g)\n name_to_go_terms[name] = go_terms\n #print name, go_terms\n\n if \"generic\" in name_to_go_terms:\n return name_to_go_terms[\"generic\"]\n\n return name_to_go_terms","def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\n\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\n\n print \"%-4d kegg pathways from %d DEGs\" % (len(deg_keggs), len(degs) )\n print \"%-4d kegg pathways from %d nonDEGs\" % (len(neg_keggs), len(negs) )\n\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\n pathwaytype_dict = {}\n pathway_dict = {}\n pathway_lookup = {}\n\n print \"extracting pathways...\"\n ko1_h = open(dbpaths['kegg'], 'rb')\n for line in ko1_h:\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\n pathtype_f = re.search('B.*<b>(.*)<', line)\n if pathtype_f is not None:\n pathtype = pathtype_f.group(1)\n else:\n pathtype = 'unknown'\n pathwaytype_dict[pathtype] = {}\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\n pathway_f = re.search(\"C +([0-9]*) *(.*)\\[PATH\", line)\n if pathway_f is not None:\n pathway_id = pathway_f.group(1)\n pathway_name = pathway_f.group(2)\n else:\n pathway_id = 'unknown'\n pathway_name = 'unknown'\n pathway_dict[pathway_id] = {}\n pathway_lookup[pathway_id] = pathway_name\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\n koterm_f = re.search(\"(K[0-9]*)\", line)\n if koterm_f is not None:\n koterm = koterm_f.group(1)\n else:\n koterm = 'unknown'\n pathwaytype_dict[pathtype][koterm] = 1\n pathway_dict[pathway_id][koterm] = 1\n\n\n print \"calculating enrichment...\"\n pathwaytype_ps = {}\n pathway_ps = {}\n # count number of degs and negs in each pathway:\n for pathwaytype in pathwaytype_dict:\n pwtsize = len(pathwaytype_dict)\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathwaytype_ps[pathwaytype] = pval\n\n if pval < pthresh:\n print \"%s\\n \\\n In Path Not in Path\\n\\\n DEG : %-7d %d\\n\\\n non-DEG: %-7d %d\\n\\\n Odds Ratio:%.3f\\n\\\n P-value:%.4f\\n\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\n oddrat, pval)\n\n\n for pathway in pathway_dict:\n pwtsize = len(pathway_dict)\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\n\n ## Fisher's Exact Test:\n # In Pathway: Not in Pathway:\n # DEG : degs_in_path degs_not_in\n # non-DEG : negs_in_path negs_not_in\n #\n\n return pathwaytype_ps, pathway_ps","def calc_genotype(self, arch_param):\n\n def _parse(weights, genos):\n gene = []\n n = 2\n start = 0\n for i in range(self.steps):\n end = start + n\n W = weights[start:end].copy()\n G = genos[start:end].copy()\n edges = sorted(range(i + 2),\n key=lambda x: -max(W[x][k] for k in range(len(W[x])) if G[x][k] != 'none'))[:2]\n for j in edges:\n k_best = None\n for k in range(len(W[j])):\n if G[j][k] != 'none':\n if k_best is None or W[j][k] > W[j][k_best]:\n k_best = k\n gene.append([G[j][k_best], i + 2, j])\n start = end\n n += 1\n return gene\n\n normal_param = np.array(self.darts_cfg.super_network.normal.genotype)\n reduce_param = np.array(self.darts_cfg.super_network.reduce.genotype)\n geno_normal = _parse(arch_param[0], normal_param[:, 0])\n geno_reduce = _parse(arch_param[1], reduce_param[:, 0])\n return [geno_normal, geno_reduce]","def get_GO_presence_labels(genes_of_interest, min_GO_size=200, max_GO_size=300):\n genes = pd.Series(genes_of_interest)\n go_group_presence = {}\n\n for GO in go2geneIDs:\n gene_ids = go2geneIDs[GO]\n\n # boolean vector (length is num of genes in embedding)\n in_go_group_vector = genes.isin(gene_ids)\n\n if (in_go_group_vector.sum() > min_GO_size) & (in_go_group_vector.sum() < max_GO_size):\n go_group_presence[GO] = in_go_group_vector\n\n result = pd.DataFrame(go_group_presence)\n result.index = genes\n result.index.name = 'entrezgene'\n return result","def brh_cogs2(DB, species, missing_factor=0.0, seed_sp=None, min_score=0):\n def _sort_cogs(cogs1, cogs2):\n seed1, mx1, avg1, ncogs1 = cogs1\n seed2, mx2, avg2, ncogs2 = cogs2\n for i, j in ((mx1, mx2), (avg1, avg2), (ncogs1, ncogs2)):\n v = -1 * cmp(i, j)\n if v != 0:\n break\n return v\n \n log.log(26, \"Searching BRH orthologs\")\n species = set(map(str, species))\n \n min_species = len(species) - round(missing_factor * len(species))\n \n if seed_sp == \"auto\":\n sp_to_test = list(species)\n elif seed_sp == \"largest\":\n cmd = \"\"\"SELECT taxid, size FROM species\"\"\"\n db.seqcursor.execute(cmd)\n sp2size = {}\n for tax, counter in db.seqcursor.fetchall():\n if tax in species: \n sp2size[tax] = counter\n \n sorted_sp = sorted(sp2size.items(), lambda x,y: cmp(x[1],y[1]))\n log.log(24, sorted_sp[:6])\n largest_sp = sorted_sp[-1][0]\n sp_to_test = [largest_sp]\n log.log(28, \"Using %s as search seed. Proteome size=%s genes\" %\\\n (largest_sp, sp2size[largest_sp]))\n else:\n sp_to_test = [str(seed_sp)]\n\n analysis_txt = StringIO()\n if sp_to_test:\n log.log(26, \"Finding best COG selection...\")\n seed2size = get_sorted_seeds(seed_sp, species, sp_to_test, min_species, DB)\n size_analysis = []\n for seedname, content in seed2size.iteritems():\n cog_sizes = [size for seq, size in content]\n mx, avg = _max(cog_sizes), round(_mean(cog_sizes))\n size_analysis.append([seedname, mx, avg, len(content)])\n size_analysis.sort(_sort_cogs) \n #print '\\n'.join(map(str, size_analysis))\n seed = size_analysis[0][0]\n print_as_table(size_analysis[:25], stdout=analysis_txt,\n header=[\"Seed\",\"largest COG\", \"avg COG size\", \"total COGs\"])\n if size_analysis[0][1] < len(species)-1:\n print size_analysis[0][1]\n raise ValueError(\"Current COG selection parameters do not permit to cover all species\")\n \n log.log(28, analysis_txt.getvalue())\n # The following loop tests each possible seed if none is\n # specified.\n log.log(28, \"Computing Clusters of Orthologs groups (COGs)\")\n log.log(28, \"Min number of species per COG: %d\" %min_species)\n cogs_selection = []\n log.log(26,\"Using seed species:%s\", seed)\n species_side1 = ','.join(map(quote, [s for s in species if str(s)>str(seed)]))\n species_side2 = ','.join(map(quote, [s for s in species if str(s)<str(seed)]))\n pairs1 = []\n pairs2 = []\n # Select all ids with matches in the target species, and\n # return the total number of species covered by each of\n # such ids.\n if species_side1 != \"\":\n cmd = \"\"\"SELECT seqid1, taxid1, seqid2, taxid2 from ortho_pair WHERE\n taxid1=\"%s\" AND taxid2 IN (%s) \"\"\" % (seed, species_side1)\n DB.orthocursor.execute(cmd)\n pairs1 = DB.orthocursor.fetchall()\n\n if species_side2 != \"\":\n cmd = \"\"\"SELECT seqid2, taxid2, seqid1, taxid1 from ortho_pair WHERE\n taxid1 IN (%s) AND taxid2 = \"%s\" \"\"\" % (species_side2, seed)\n DB.orthocursor.execute(cmd)\n pairs2 = DB.orthocursor.fetchall()\n \n cog_candidates = defaultdict(set)\n for seq1, sp1, seq2, sp2 in pairs1 + pairs2:\n s1 = (sp1, seq1)\n s2 = (sp2, seq2)\n cog_candidates[(sp1, seq1)].update([s1, s2])\n\n all_cogs = [cand for cand in cog_candidates.values() if\n len(cand) >= min_species]\n\n # CHECK CONSISTENCY\n seqs = set()\n for cand in all_cogs:\n seqs.update([b for a,b in cand if a == seed])\n pre_selected_seqs = set([v[0] for v in seed2size[seed]])\n if len(seqs & pre_selected_seqs) != len(set(seed2size[seed])) or\\\n len(seqs & pre_selected_seqs) != len(seqs): \n print \"old method seqs\", len(seqs), \"new seqs\", len(set(seed2size[seed])), \"Common\", len(seqs & pre_selected_seqs)\n raise ValueError(\"ooops\")\n \n cog_sizes = [len(cog) for cog in all_cogs]\n cog_spsizes = [len(set([e[0] for e in cog])) for cog in all_cogs]\n\n if [1 for i in xrange(len(cog_sizes)) if cog_sizes[i] != cog_spsizes[i]]:\n raise ValueError(\"Inconsistent COG found\")\n \n if cog_sizes: \n cogs_selection.append([seed, all_cogs])\n log.log(26, \"Found %d COGs\" % len(all_cogs))\n \n recoded_cogs = []\n for cog in all_cogs:\n named_cog = map(lambda x: \"%s%s%s\" %(x[0], GLOBALS[\"spname_delimiter\"],x[1]), cog)\n recoded_cogs.append(named_cog)\n\n return recoded_cogs, analysis_txt.getvalue()","def termination_heuristics(self, state):\n\n point_state = state[0][0]\n target_mask = get_target_mask(point_state)\n point_state = point_state[:3, target_mask].T\n depth_heuristics = self.graspnet_closure(point_state) \n if (depth_heuristics):\n print('object inside gripper? start retracting...')\n return depth_heuristics","def read_obs_neo_top_mid_bot(ring):\n fobs_neo = \"/srv/ccrc/data25/z5218916/data/Eucface_data/swc_at_depth/FACE_P0018_RA_NEUTRON_20120430-20190510_L1.csv\"\n neo = pd.read_csv(fobs_neo, usecols = ['Ring','Depth','Date','VWC'])\n neo['Date'] = pd.to_datetime(neo['Date'],format=\"%d/%m/%y\",infer_datetime_format=False)\n neo['Date'] = neo['Date'] - pd.datetime(2011,12,31)\n neo['Date'] = neo['Date'].dt.days\n neo = neo.sort_values(by=['Date','Depth'])\n\n if ring == 'amb':\n subset = neo[neo['Ring'].isin(['R2','R3','R6'])]\n elif ring == 'ele':\n subset = neo[neo['Ring'].isin(['R1','R4','R5'])]\n else:\n subset = neo[neo['Ring'].isin([ring])]\n\n subset = subset.groupby(by=[\"Depth\",\"Date\"]).mean()\n subset = subset.xs('VWC', axis=1, drop_level=True)\n x = subset.index.get_level_values(1).values\n y = subset.index.get_level_values(0).values\n value = subset.values\n\n X = subset[(25)].index.values[20:]\n Y = np.arange(0.5,460,1)\n\n grid_X, grid_Y = np.meshgrid(X,Y)\n\n grid_data = griddata((x, y) , value, (grid_X, grid_Y), method='nearest')\n\n neo_data = pd.DataFrame(subset[(25)].index.values[20:], columns=['dates'])\n neo_data[\"SM_15m\"] = np.mean(grid_data[0:150,:],axis=0)/100.\n neo_data[\"SM_all\"] = np.mean(grid_data[:,:],axis=0)/100.\n neo_data[\"SM_top\"] = np.mean(grid_data[0:30,:],axis=0)/100.\n neo_data[\"SM_mid\"] = np.mean(grid_data[30:150,:],axis=0)/100.\n neo_data[\"SM_bot\"] = np.mean(grid_data[150:460,:],axis=0)/100.\n neo_data[\"WA_all\"] = np.sum(grid_data[:,:]/100.*10.,axis=0)\n neo_data = neo_data.set_index('dates')\n return neo_data","def brh_cogs(DB, species, missing_factor=0.0, seed_sp=None, min_score=0):\n log.log(26, \"Searching BRH orthologs\")\n species = set(map(str, species))\n\n min_species = len(species) - round(missing_factor * len(species))\n \n if seed_sp == \"auto\":\n # seed2size = get_sorted_seeds(seed_sp, species, species, min_species, DB)\n # sort_seeds = sorted([(len(size), sp) for sp, size in seed2size.iteritems()])\n # sp_to_test = [sort_seeds[-1][1]]\n sp_to_test = list(species)\n elif seed_sp == \"largest\":\n cmd = \"\"\"SELECT taxid, size FROM species\"\"\"\n db.seqcursor.execute(cmd)\n sp2size = {}\n for tax, counter in db.seqcursor.fetchall():\n if tax in species: \n sp2size[tax] = counter\n \n sorted_sp = sorted(sp2size.items(), lambda x,y: cmp(x[1],y[1]))\n log.log(24, sorted_sp[:6])\n largest_sp = sorted_sp[-1][0]\n sp_to_test = [largest_sp]\n log.log(28, \"Using %s as search seed. Proteome size=%s genes\" %\\\n (largest_sp, sp2size[largest_sp]))\n else:\n sp_to_test = [str(seed_sp)]\n \n # The following loop tests each possible seed if none is\n # specified.\n log.log(28, \"Detecting Clusters of Orthologs groups (COGs)\")\n log.log(28, \"Min number of species per COG: %d\" %min_species)\n cogs_selection = []\n \n for j, seed in enumerate(sp_to_test):\n log.log(26,\"Testing new seed species:%s (%d/%d)\", seed, j+1, len(sp_to_test))\n species_side1 = ','.join(map(quote, [s for s in species if str(s)>str(seed)]))\n species_side2 = ','.join(map(quote, [s for s in species if str(s)<str(seed)]))\n pairs1 = []\n pairs2 = []\n # Select all ids with matches in the target species, and\n # return the total number of species covered by each of\n # such ids.\n if species_side1 != \"\":\n cmd = \"\"\"SELECT seqid1, taxid1, seqid2, taxid2 from ortho_pair WHERE\n taxid1=\"%s\" AND taxid2 IN (%s) \"\"\" %\\\n (seed, species_side1)\n DB.orthocursor.execute(cmd)\n pairs1 = DB.orthocursor.fetchall()\n\n if species_side2 != \"\":\n cmd = \"\"\"SELECT seqid2, taxid2, seqid1, taxid1 from ortho_pair WHERE\n taxid1 IN (%s) AND taxid2 = \"%s\" \"\"\" %\\\n (species_side2, seed)\n\n #taxid2=\"%s\" AND taxid1 IN (%s) AND score >= %s\"\"\" %\\\n #(seed, species_side2, min_score)\n DB.orthocursor.execute(cmd)\n pairs2 = DB.orthocursor.fetchall()\n\n cog_candidates = defaultdict(set)\n for seq1, sp1, seq2, sp2 in pairs1 + pairs2:\n s1 = (sp1, seq1)\n s2 = (sp2, seq2)\n cog_candidates[(sp1, seq1)].update([s1, s2])\n\n all_cogs = [cand for cand in cog_candidates.values() if\n len(cand) >= min_species]\n \n cog_sizes = [len(cog) for cog in all_cogs]\n cog_spsizes = [len(set([e[0] for e in cog])) for cog in all_cogs]\n\n if [1 for i in xrange(len(cog_sizes)) if cog_sizes[i] != cog_spsizes[i]]:\n # for i in xrange(len(cog_sizes)):\n # if cog_sizes[i] != cog_spsizes[i]:\n # print cog_sizes[i], cog_spsizes[i]\n # raw_input()\n raise ValueError(\"Inconsistent COG found\")\n \n if cog_sizes: \n cogs_selection.append([seed, all_cogs])\n log.log(26, \"Found %d COGs\" % len(all_cogs))\n\n def _sort_cogs(cogs1, cogs2):\n cogs1 = cogs1[1] # discard seed info\n cogs2 = cogs2[1] # discard seed info \n cog_sizes1 = [len(cog) for cog in cogs1]\n cog_sizes2 = [len(cog) for cog in cogs2]\n mx1, mn1, avg1 = _max(cog_sizes1), _min(cog_sizes1), round(_mean(cog_sizes1))\n mx2, mn2, avg2 = _max(cog_sizes2), _min(cog_sizes2), round(_mean(cog_sizes2))\n \n # we want to maximize all these values in the following order:\n for i, j in ((mx1, mx2), (avg1, avg2), (len(cogs1), len(cogs2))):\n v = -1 * cmp(i, j)\n if v != 0:\n break\n return v\n \n log.log(26, \"Finding best COG selection...\")\n cogs_selection.sort(_sort_cogs)\n lines = []\n for seed, all_cogs in cogs_selection:\n cog_sizes = [len(cog) for cog in all_cogs]\n mx, mn, avg = max(cog_sizes), min(cog_sizes), round(_mean(cog_sizes))\n lines.append([seed, mx, mn, avg, len(all_cogs)])\n analysis_txt = StringIO()\n print_as_table(lines[:25], stdout=analysis_txt,\n header=[\"Seed\",\"largest COG\", \"smallest COGs\", \"avg COG size\", \"total COGs\"])\n log.log(28, \"Analysis details:\\n\"+analysis_txt.getvalue())\n best_seed, best_cogs = cogs_selection[0]\n cog_sizes = [len(cog) for cog in best_cogs]\n\n # Not necessary since they will be sorted differently later on\n #best_cogs.sort(lambda x,y: cmp(len(x), len(y)), reverse=True)\n \n if max(cog_sizes) < len(species):\n raise ValueError(\"Current COG selection parameters do not permit to cover all species\")\n\n recoded_cogs = []\n for cog in best_cogs:\n named_cog = map(lambda x: \"%s%s%s\" %(x[0], GLOBALS[\"spname_delimiter\"],x[1]), cog)\n recoded_cogs.append(named_cog)\n\n return recoded_cogs, analysis_txt.getvalue()","def get_genes_graph(genes_path, save_path, method='pearson', thresh=0.95, p_value=False):\r\n if not os.path.exists(save_path):\r\n os.makedirs(save_path)\r\n genes_exp_df = pd.read_csv(os.path.join(genes_path, 'exp.csv'), index_col=0)\r\n\r\n # calculate correlation matrix\r\n genes_exp_corr = genes_exp_df.corr(method=method)\r\n genes_exp_corr = genes_exp_corr.apply(lambda x: abs(x))\r\n n = genes_exp_df.shape[0]\r\n\r\n # binarize\r\n if p_value == True:\r\n dist = scipy.stats.beta(n / 2 - 1, n / 2 - 1, loc=-1, scale=2)\r\n thresh = dist.isf(0.05)\r\n\r\n adj = np.where(genes_exp_corr > thresh, 1, 0)\r\n adj = adj - np.eye(genes_exp_corr.shape[0], dtype=np.int)\r\n edge_index = np.nonzero(adj)\r\n np.save(os.path.join(save_path, 'edge_index_{}_{}.npy').format(method, thresh), edge_index)\r\n\r\n return n, edge_index","def best_genome(self):\n return self.best_genomes(1)[0]","def newcogfind(ncf_cogs, ncf_twogs, ncf_prots):\n coglijst_hoogste_waarde = list(set([y.split()[0] for y in ncf_cogs]))\n werkgetal = vindhoogstecognummer(coglijst_hoogste_waarde)\n ncf_list = []\n for prot in ncf_prots:\n prot_in_twogs = zoekinlijst(prot, ncf_twogs, 1)\n posible_found_twogs = verbrogentwogs(prot, ncf_twogs, prot_in_twogs)\n if posible_found_twogs != list():\n newcog = list(set(\" \".join(posible_found_twogs).split()))\n werkgetal += 1\n for incog in newcog:\n cogzin = \"%s\\t%s\\n\" % ((\"0000000000%s\" % werkgetal)[-8:], incog)\n ncf_list.append(cogzin)\n twogremove(zoekinlijst(incog, ncf_twogs, 0), ncf_twogs)\n voegtoeaancog(ncf_list)","def get_final_main_cgovtype_ori_agency(file_path):\n final_main_df = pd.read_csv(file_path)\n final_main_fips_ori_agency = final_main_df[['ORI', 'AGENCY', 'CGOVTYPE', 'FIPS_STATE', 'FIPS_PLACE']]\n\n \"\"\"\n 1. Obtain only unique records from the final main file - key: fips place + fips state\n \"\"\"\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency.drop_duplicates(['FIPS_STATE', 'FIPS_PLACE']) # --> 11,602 rows\n\n \"\"\"\n 2. Rename CGOVTYPE, FIPS_STATE, FIPS_PLACE to Govt_level, 'STATEFP', 'place_fips' to match national census file\n \"\"\"\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency_unique.rename(\n {'CGOVTYPE': 'Govt_level', 'FIPS_STATE': 'STATEFP', 'FIPS_PLACE': 'place_fips'}, axis='columns')\n\n \"\"\"\n 3. Get only those records from 90 final main file whose cgovtype is 1,2 or 3\n \"\"\"\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency_unique.loc[final_main_fips_ori_agency_unique['Govt_level'].isin([1, 2, 3])]\n\n return final_main_fips_ori_agency_unique","def best(self):\n self.population.ascendent_sort()\n self.best_genome = self.population.collection[0]\n return self.best_genome","def GoAnnot(prots, gos, onlyProts=False):\r\n with resources.open_text(\"autoprot.data\",\"Homo_sapiens.gene_info\") as d:\r\n geneInfo = pd.read_csv(d, sep='\\t')\r\n with resources.open_text(\"autoprot.data\",\"gene2go_alt\") as d:\r\n gene2go = pd.read_csv(d, sep='\\t')\r\n prots = pd.DataFrame(pd.Series([str(i).upper().split(';')[0] for i in prots]), columns=[\"Gene names\"])\r\n prots = prots.merge(geneInfo[[\"Symbol\", \"GeneID\"]], left_on=\"Gene names\", right_on=\"Symbol\", how='inner')\r\n \r\n prots = prots.merge(gene2go[[\"GeneID\", \"GO_ID\", \"GO_term\"]], on=\"GeneID\", how='inner')\r\n if onlyProts == True:\r\n for idx, go in enumerate(gos):\r\n if idx == 0:\r\n redProts = prots[\"Symbol\"][prots[\"GO_term\"].str.contains(go)]\r\n else:\r\n redProts = redProts.append(prots[\"Symbol\"][prots[\"GO_term\"].str.contains(go)])\r\n return redProts.drop_duplicates()\r\n else: \r\n for idx, go in enumerate(gos):\r\n if idx == 0:\r\n redProts = prots[prots[\"GO_term\"]==go]\r\n else:\r\n redProts = redProts.append(prots[prots[\"GO_term\"]==go])\r\n return redProts.drop_duplicates()","def getNetCharge( top, gro, mdpfile, maxwarn = None):\n\n startdir = os.getcwd()\n #Copy to a temporary directory to avoid generating output files in the working directory\n tempdir = tempfile.mkdtemp()\n shutil.copy( top, os.path.join( tempdir, 'tmp.top') )\n shutil.copy( gro, os.path.join( tempdir, 'tmp.gro') )\n shutil.copy( mdpfile, os.path.join( tempdir, 'tmp.mdp') )\n os.chdir(tempdir)\n\n\n #Run grompp and extract output\n if maxwarn:\n rungmxcmd = 'grompp -f tmp.mdp -p tmp.top -c tmp.gro -maxwarn %(maxwarn)s' % vars()\n else:\n rungmxcmd = 'grompp -f tmp.mdp -p tmp.top -c tmp.gro'\n gromppout = commands.getoutput( rungmxcmd )\n \n #Find total charge in output\n totalcharge = None\n for line in gromppout.split('\\n'):\n if 'total charge' in line and not 'State B' in line:\n line = line.replace('System has non-zero total charge:','')\n charge = float( line.split()[0].strip() )\n totalcharge = int( round(charge) )\n break #Break at first occurrence, to avoid going on to, for example, state B charge if present.\n if not totalcharge:\n #If the net charge is already zero, it will not be printed. We can attempt to read it from the topology file, as this will often be tracked there. The following code will do so, but assumes the topology file contains only a single [ atoms ] block which is followed by a [ bonds ] block; it reads the last line of the section preceding the [ bonds ] block and atempts to find 'qtot' at the end of the line. \n file = open('tmp.top', 'r')\n text = file.readlines()\n file.close()\n bondsstart = text.index('[ bonds ]\\n')\n lastatomline = bondsstart-1\n while len(text[ lastatomline]) < 20 or text[lastatomline].find( ';' ) < 2: #While the line is too short or starts with a comment, keep reading back\n lastatomline -=1\n #Now extract qtot from line if present\n if 'qtot' in text[ lastatomline ]:\n lastsec = text[ lastatomline ].split('qtot')[1]\n qtot = lastsec.split()[0].strip()\n totalcharge = float(qtot)\n else: \n #Attempt to get it by summing the charges in the topology file's atoms section\n indices = extract_section( text, 'atoms' )\n totalcharge = None\n for index in indices:\n line, comments = stripcomments( text[index] )\n elements = line.split()\n if len( elements ) > 7:\n if totalcharge == None: totalcharge = 0.0\n totalcharge += float(elements[6])\n if totalcharge == None:\n #Otherwise give up and we'll raise an exception below\n print \"No total charge found in topology file.\"\n\n if totalcharge == None: #If we still can't find the total charge\n print \"ERROR while calculating total charge; Work done in %s...\" % os.getcwd()\n raise RuntimeError('Error: Could not read total charge from grompp output: %s' % gromppout )\n\n #Clean up\n os.chdir( startdir ) \n shutil.rmtree(tempdir)\n\n #Return\n return totalcharge","def challenge2(self):\n # Let's try an octree-type approach\n # For each grid cube we should be able to find whether a nanobot:\n # 1) is not in range (is outside grid cube and not in range of nearest face)\n # 2) is in range of whole cube (all 8 corners are in range)\n # 3) is in range of part of the cube (i.e. not 1 or 2)\n # Root node: figure out extent of whole space\n mins = []\n maxs = []\n for axis in range(3):\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n\n for count in range(len(self.nanobots), 0, -1):\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\n if results and results[0].count >= count:\n break\n\n print(f\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\")\n\n # Find result coord closest to origin\n closest_dist = np.iinfo(np.int32).max\n best_coord = None\n for result in results:\n for corner in itertools.product(*zip(result.mins, result.maxs)):\n d = manhattan_dist(corner, (0, 0, 0))\n if d < closest_dist:\n closest_dist = d\n best_coord = corner\n\n print(f\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\")","def parse_grism_associations(exposure_groups, \n best_direct=DIRECT_ORDER,\n get_max_overlap=True):\n N = len(exposure_groups)\n \n grism_groups = []\n for i in range(N):\n f_i = exposure_groups[i]['product'].split('-')[-1]\n root_i = exposure_groups[i]['product'].split('-'+f_i)[0]\n \n if f_i.startswith('g'):\n group = OrderedDict(grism=exposure_groups[i], \n direct=None)\n else:\n continue\n \n fp_i = exposure_groups[i]['footprint']\n olap_i = 0.\n d_i = f_i\n \n #print('\\nx\\n')\n d_idx = 10\n for j in range(N):\n f_j = exposure_groups[j]['product'].split('-')[-1]\n if f_j.startswith('g'):\n continue\n \n fp_j = exposure_groups[j]['footprint']\n olap = fp_i.intersection(fp_j)\n root_j = exposure_groups[j]['product'].split('-'+f_j)[0]\n\n #print(root_j, root_i, root_j == root_i)\n if (root_j == root_i):\n # if (group['direct'] is not None):\n # pass\n # if (group['direct']['product'].startswith(root_i)) & (d_i.upper() == best_direct[f_i.upper()]):\n # continue\n \n if best_direct[f_i.upper()].index(f_j.upper()) < d_idx:\n d_idx = best_direct[f_i.upper()].index(f_j.upper())\n group['direct'] = exposure_groups[j]\n olap_i = olap.area\n d_i = f_j\n #print(0,group['grism']['product'], group['direct']['product'])\n # continue\n \n #print(exposure_groups[i]['product'], exposure_groups[j]['product'], olap.area*3600.)\n \n # #print(exposure_groups[j]['product'], olap_i, olap.area)\n # if olap.area > 0:\n # if group['direct'] is None:\n # group['direct'] = exposure_groups[j]\n # olap_i = olap.area\n # d_i = f_j\n # #print(1,group['grism']['product'], group['direct']['product'])\n # else:\n # #if (f_j.upper() == best_direct[f_i.upper()]):\n # if get_max_overlap:\n # if olap.area < olap_i:\n # continue\n # \n # if d_i.upper() == best_direct[f_i.upper()]:\n # continue\n # \n # group['direct'] = exposure_groups[j]\n # #print(exposure_groups[j]['product'])\n # olap_i = olap.area\n # d_i = f_j\n # #print(2,group['grism']['product'], group['direct']['product'])\n \n grism_groups.append(group)\n \n return grism_groups","def eui_modesign():\n\n # setup design space\n # N ds ws wc lc g\n GAP = Struct()\n GAP.gd_min = np.array([1, 1e-3, 1e-3, 1e-3, 1e-3, 1e-5])\n GAP.gd_max = np.array([1e3, 1e-1, 1e-1, 1e-1, 1e-1, 1e-2])\n\n\n # setup genetic algorithm parameters--------------------------------------\n nobj=2 # number of objectives\n ngen=100 # number of generations\n npop = 100 # population size\n \n problem = MyProblem()\n problem.n_var = len(GAP.gd_min)\n problem.n_obj = nobj\n problem.n_constr = 2\n problem.xl = GAP.gd_min\n problem.xu = GAP.gd_max\n problem.elementwise_evaluation = True\n\n algorithm = NSGA2(\n pop_size=npop,\n eliminate_duplicates=True\n )\n \n # conduct the optimization-------------------------------------------------\n res = minimize(problem, algorithm, (\"n_gen\", ngen), verbose=True)\n\n # save results-------------------------------------------------------------\n return res","def process_component(COMP, G, max_k, min_length, max_CV, SEQS, bamfile, pool, use_scores=False, use_genes=False, num_procs=1):\n\n ###############MOVED FROM OUTER CODE ON WHOLE G\n if use_scores: remove_hi_confidence_chromosome(COMP) ##################################\n\n # initialize shortest path set considered\n path_count = 0\n seen_unoriented_paths = set([])\n paths_set = set([]) #the set of paths found\n\n\n # first look for paths starting from the nodes annotated with plasmid genes\n if use_genes:\n plasmid_gene_nodes = get_plasmid_gene_nodes(COMP)\n potential_plasmid_mass_tuples = [(get_spades_base_mass(COMP,nd),nd) for nd in plasmid_gene_nodes]\n potential_plasmid_mass_tuples.sort(key = lambda n: n[0])\n while potential_plasmid_mass_tuples: # could be removing other nodes from the list\n top_node = potential_plasmid_mass_tuples.pop() # highest mass node\n top_node_name = top_node[1]\n path = get_high_mass_shortest_path(top_node_name,COMP,use_scores,use_genes) #######\n if path is None: continue\n # check coverage variation\n path_CV = get_wgtd_path_coverage_CV(path,G,SEQS,max_k_val=max_k)\n logger.info(\"Plasmid gene path: %s, CV: %4f\" % (str(path),path_CV))\n if path_CV <= max_CV and is_good_cyc(path,G,bamfile):\n logger.info(\"Added plasmid gene path %s\" % (str(path)))\n\n # prevent checking nodes that have been removed\n i = 0\n while i < len(potential_plasmid_mass_tuples):\n if potential_plasmid_mass_tuples[i][1] in path or \\\n rc_node(potential_plasmid_mass_tuples[i][1]) in path:\n potential_plasmid_mass_tuples.pop(i)\n else: i += 1\n\n seen_unoriented_paths.add(get_unoriented_sorted_str(path))\n before_cov, _ = get_path_mean_std(path, G, SEQS, max_k)\n covs = update_path_coverage_vals(path, G, SEQS, max_k)\n update_path_with_covs(path, COMP, covs)\n path_count += 1\n paths_set.add((path,before_cov))\n\n else:\n logger.info(\"Did not add plasmid gene path: %s\" % (str(path)))\n\n # then look for circular paths that start from hi confidence plasmid nodes\n if use_scores:\n potential_plasmid_nodes = get_hi_conf_plasmids(COMP)\n potential_plasmid_mass_tuples = [(get_spades_base_mass(COMP,nd),nd) for nd in potential_plasmid_nodes]\n potential_plasmid_mass_tuples.sort(key = lambda n: n[0])\n while potential_plasmid_mass_tuples: # could be removing other nodes from the list\n top_node = potential_plasmid_mass_tuples.pop() # highest mass node\n top_node_name = top_node[1]\n path = get_high_mass_shortest_path(top_node_name,COMP,use_scores,use_genes)\n if path is None: continue\n # check coverage variation\n path_CV = get_wgtd_path_coverage_CV(path,G,SEQS,max_k_val=max_k)\n logger.info(\"Hi conf path: %s, CV: %4f\" % (str(path),path_CV))\n\n if path_CV <= max_CV and is_good_cyc(path,G,bamfile):\n logger.info(\"Added hi conf path %s\" % (str(path)))\n\n # prevent checking nodes that have been removed\n i = 0\n while i < len(potential_plasmid_mass_tuples):\n if potential_plasmid_mass_tuples[i][1] in path or \\\n rc_node(potential_plasmid_mass_tuples[i][1]) in path:\n potential_plasmid_mass_tuples.pop(i)\n else: i += 1\n\n seen_unoriented_paths.add(get_unoriented_sorted_str(path))\n before_cov, _ = get_path_mean_std(path, G, SEQS, max_k)\n #before_cov, _ = get_path_mean_std(path, COMP, SEQS, max_k)\n covs = update_path_coverage_vals(path, G, SEQS, max_k)##########################\n update_path_with_covs(path, COMP, covs) ####################################\n path_count += 1\n paths_set.add((path,before_cov))\n\n else:\n logger.info(\"Did not add hi-conf path: %s\" % (str(path)))\n\n # 3rd step. Run Recycler algorithm that looks for circular high mass shortest\n # paths and accept them as plasmid predictions if the coverages and mate pairs\n # match the required thresholds\n#######################################################################################\n#######################################################################################\n\n\n paths = enum_high_mass_shortest_paths(COMP, pool, use_scores,use_genes,seen_unoriented_paths)\n last_path_count = 0\n last_node_count = 0\n\n # continue as long as you either removed a low mass path\n # from the component or added a new path to final paths\n while(path_count!=last_path_count or\\\n len(COMP.nodes())!=last_node_count):\n\n last_node_count = len(COMP.nodes())\n last_path_count = path_count\n\n # make tuples of (CV, path)\n path_tuples = []\n for p in paths:\n if len(get_seq_from_path(p, SEQS, max_k_val=max_k)) < min_length:\n seen_unoriented_paths.add(get_unoriented_sorted_str(p))\n logger.info(\"Num seen paths: %d\" % (len(seen_unoriented_paths)))\n continue\n path_tuples.append((get_wgtd_path_coverage_CV(p,G,SEQS,max_k_val=max_k), p))\n\n logger.info(\"Num path tuples: %d\" % (len(path_tuples)))\n if(len(path_tuples)==0): break\n\n # sort in ascending CV order\n path_tuples.sort(key=lambda path: path[0])\n\n for pt in path_tuples:\n curr_path = pt[1]\n curr_path_CV = pt[0]\n logger.info(\"Path: %s\" % (\",\".join(curr_path)))\n if get_unoriented_sorted_str(curr_path) not in seen_unoriented_paths:\n\n ## only report if low CV and matches mate pair info\n if (curr_path_CV <= (max_CV) and \\\n is_good_cyc(curr_path,G,bamfile)):\n\n logger.info(\"Added path %s\" % \", \".join(curr_path))\n logger.info(\"\\tCV: %4f\" % curr_path_CV)\n seen_unoriented_paths.add(get_unoriented_sorted_str(curr_path))\n #before_cov, _ = get_path_mean_std(curr_path, COMP, SEQS, max_k)\n before_cov, _ = get_path_mean_std(curr_path, G, SEQS, max_k)\n covs = update_path_coverage_vals(curr_path, G, SEQS, max_k)\n update_path_with_covs(curr_path, COMP, covs)\n path_count += 1\n paths_set.add((curr_path,before_cov))\n break\n\n else:\n logger.info(\"Did not add path: %s\" % (\", \".join(curr_path)))\n logger.info(\"\\tCV: %4f\" % curr_path_CV)\n if curr_path_CV > max_CV:\n break # sorted by CV\n else: # not good mate pairs\n seen_unoriented_paths.add(get_unoriented_sorted_str(curr_path))\n\n # recalculate paths on the component\n print(str(len(COMP.nodes())) + \" nodes remain in component\")\n logger.info(\"Remaining nodes: %d\" % (len(COMP.nodes())))\n paths = enum_high_mass_shortest_paths(COMP, pool, use_scores,use_genes,seen_unoriented_paths)\n\n #end while\n return paths_set","def go_enrichment(genelist, background_go=None, go_info=None, return_odds=False, gofile=dbpaths['goterms']):\n # if background list of GO terms is not supplied, make one:\n if background_go:\n go_obj = background_go\n else:\n go_obj = GO_maker(gofile)\n\n f_squares = [] # where the Fisher's Exact Tables will be held (and returned)\n\n god = {}\n goodds = {}\n gopval = {}\n\n for godict in go_obj.fetch_gos(genelist):\n for goterm in godict:\n try:\n god[goterm] += 1\n except KeyError:\n god[goterm] = 1\n\n for goterm in god:\n if goterm == \"GO:######\":\n continue\n dip = god[goterm]\n\n go_w_deg = dip\n go_wo_deg = len(go_obj.fetch_genes(goterm)) - dip\n nogo_w_deg = len(genelist) - dip\n nogo_wo_deg = go_obj.count_genes() - len(go_obj.fetch_genes(goterm)) - len(genelist) + dip\n\n if isinstance(go_info,dict):\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm, go_info[goterm]))\n else:\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm))\n\n verbalise(\"B\", \"Performing Fisher's Exact Test on %d squares\" % (len(f_squares)))\n for square in f_squares:\n square.fisher_test()\n\n return f_squares","def HaarGOB(treeG):\n # number of level of the chain (or tree)\n Ntr = len(treeG)\n # reorder chain (optional) \n # reordering each level so that in each level the nodes are in the\n # descent order of degrees\n # compute u_l^c for level J_0 (top level)\n clusterJ0 = treeG[Ntr-1]['clusters']\n N0 = len(clusterJ0)\n # generate indicator function on G^c\n chic = np.identity(N0)\n uc = [None]*N0\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\n for l in np.arange(1, N0):\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\n# u = copy.deepcopy(uc)\n treeG[Ntr-1]['u'] = uc\n # compute the next level orthonormal basis ulk and stored into u\n for j_tr in np.arange(0, Ntr-1)[::-1]:\n N1 = len(treeG[j_tr]['clusters'])\n u = [None]*N1\n i = N0\n for l in range(N0):\n clusterl = treeG[j_tr+1]['clusters'][l]\n kl = len(clusterl)\n #for k==1\n ucl = uc[l]\n ul1 = np.zeros(N1)\n for j in range(N0):\n idxj = treeG[j_tr+1]['clusters'][j]\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\n u[l] = ul1\n if kl>1:\n chil = np.zeros((kl,N1))\n for k in range(kl):\n idxl = treeG[j_tr+1]['clusters'][l]\n chil[k,idxl[k]] = 1;\n \n for k in np.arange(1,kl):\n i = i+1\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\n u[i-1] = ulk\n treeG[j_tr]['u'] = u\n # update uc and N0\n# uc = copy.deepcopy(u)\n uc = u\n N0 = N1\n return treeG","def best_genome(self) -> Genome:\n return self._candidate","def get_orfs(genome, min_num_aa):\n allowed = \"ATGC\"\n if not isinstance(genome, str) or len(genome) == 0 or not all(c in allowed for c in genome):\n raise TypeError\n start_codon = \"ATG\"\n stop_codon = ['TAA', 'TAG', 'TGA']\n ref_dict = {\"T\" : \"A\", \"A\" : \"T\", \"G\" : \"C\", \"C\" : \"G\"}\n amino_dict = {\n 'L' : ['CTC', 'CTT', 'CTA', 'CTG', 'TTA', 'TTG'],\n 'S' : ['TCA', 'TCT', 'TCC', 'TCG', 'AGC', 'AGT'],\n 'R' : ['CGA', 'CGC', 'CGT', 'CGG', 'AGA', 'AGG'],\n 'V' : ['GTA', 'GTG', 'GTC', 'GTT'],\n 'P' : ['CCC', 'CCA', 'CCG', 'CCT'],\n 'T' : ['ACC', 'ACG', 'ACT', 'ACA'],\n 'A' : ['GCA', 'GCC', 'GCG', 'GCT'],\n 'G' : ['GGA', 'GGC', 'GGT', 'GGG'],\n 'I' : ['ATA', 'ATC', 'ATT'],\n 'F' : ['TTT', 'TTC'],\n 'Y' : ['TAT', 'TAC'],\n 'H' : ['CAC', 'CAT'],\n 'Q' : ['CAG', 'CAA'],\n 'N' : ['AAC', 'AAT'],\n 'K' : ['AAA', 'AAG'],\n 'D' : ['GAC', 'GAT'],\n 'E' : ['GAA', 'GAG'],\n 'C' : ['TGC', 'TGT'],\n 'M' : ['ATG'],\n 'W' : ['TGG']\n\n }\n comp_genome = \"\"\n for stra in genome:\n comp_genome += ref_dict[stra]\n main_orfs = find_orfs(genome, start_codon, stop_codon, min_num_aa, amino_dict, False)\n comp_orfs = find_orfs(comp_genome[::-1], start_codon, stop_codon, min_num_aa, amino_dict, True)\n circular_orfs = find_cir_orfs(genome, main_orfs, start_codon, stop_codon, min_num_aa, amino_dict, False)\n \n circular_orfs_comp = find_cir_orfs(comp_genome[::-1], comp_orfs, start_codon, stop_codon, min_num_aa, amino_dict, True)\n \n for main_orf in main_orfs:\n for cir_orf in circular_orfs:\n if main_orf[0] <= cir_orf[1] and main_orf[1] <= cir_orf[1] or len(main_orf) == 5:\n main_orfs.remove(main_orf)\n for comp_orf in comp_orfs:\n for cir_orf in circular_orfs_comp:\n if comp_orf[1] == cir_orf[1] or len(comp_orf) == 5:\n comp_orfs.remove(comp_orf)\n\n final_orf = main_orfs + comp_orfs + circular_orfs + circular_orfs_comp\n #print(len(comp_orfs))\n \n \n \n return final_orf","def goe(\n\tgenelist,\n\tgo_file,\n\tgoa_file,\n\tbg=None,\n\tnmin=5,\n\tconversion=None,\n\tevidence_set={\n\t\t'EXP', 'IDA', 'IPI', 'IMP', 'IGI', 'HTP', 'HDA', 'HMP', 'HGI', 'IBA',\n\t\t'IBD', 'IKR', 'IRD', 'ISS', 'ISO', 'ISA', 'ISM'}):\n\tfrom tempfile import NamedTemporaryFile\n\tfrom os import linesep\n\tfrom goatools.go_enrichment import GOEnrichmentStudy\n\tfrom goatools.obo_parser import GODag\n\tfrom goatools.associations import read_gaf\n\tfrom collections import defaultdict\n\timport itertools\n\tfrom biothings_client import get_client\n\timport pandas as pd\n\timport logging\n\tassert type(genelist) is list and len(genelist) > 0\n\tif nmin < 1:\n\t\tnmin = 1\n\n\tbg0 = bg\n\t# Convert gene names\n\tif conversion is not None:\n\t\tassert len(conversion) == 3\n\t\tname_from, name_to, species = conversion\n\t\tmg = get_client('gene')\n\t\tans = set(genelist)\n\t\tif bg is not None:\n\t\t\tt1 = set(bg)\n\t\t\tassert len(ans - t1) == 0\n\t\t\tans |= t1\n\t\tans = list(ans)\n\t\tans = mg.querymany(ans, scopes=name_from, fields=name_to, species=species)\n\t\tt1 = set(['query', '_score', name_to.split('.')[0]])\n\t\tans = list(filter(lambda x: len(t1 - set(x)) == 0, ans))\n\t\tans = sorted(ans, key=lambda x: x['_score'])\n\t\tconvert = {x['query']: x for x in ans}\n\t\tfor xi in name_to.split('.'):\n\t\t\tconvert = filter(lambda x: xi in x[1], convert.items())\n\t\t\tconvert = {x[0]: x[1][xi] for x in convert}\n\t\tconvert = {\n\t\t\tx[0]: x[1] if type(x[1]) is str else x[1][0]\n\t\t\tfor x in convert.items()}\n\t\tgenelist2 = list(\n\t\t\tset([convert[x] for x in filter(lambda x: x in convert, genelist)]))\n\t\tif bg is not None:\n\t\t\tbg = list(set([convert[x] for x in filter(lambda x: x in convert, bg)]))\n\t\tt1 = set(genelist)\n\t\tconverti = list(filter(lambda x: x[0] in t1, convert.items()))\n\t\tt1 = defaultdict(list)\n\t\tfor xi in converti:\n\t\t\tt1[xi[1]].append(xi[0])\n\t\tconverti = dict(t1)\n\t\tt1 = defaultdict(list)\n\t\tfor xi in convert.items():\n\t\t\tt1[xi[1]].append(xi[0])\n\t\tconvertia = dict(t1)\n\telse:\n\t\tgenelist2 = genelist\n\n\t# Load GO DAG and association files\n\tlogging.debug('Reading GO DAG file ' + go_file)\n\tgodag = GODag(go_file)\n\tlogging.debug('Reading GO association file ' + goa_file)\n\tgoa = read_gaf(goa_file, evidence_set=evidence_set)\n\tif bg is None:\n\t\tbg = list(goa.keys())\n\n\t# Compute enrichment\n\tgoe = GOEnrichmentStudy(bg, goa, godag)\n\tans = goe.run_study(genelist2)\n\t# Format output\n\twith NamedTemporaryFile() as f:\n\t\tgoe.wr_tsv(f.name, ans)\n\t\tans = f.read()\n\tans = ans.decode()\n\tans = [x.split('\\t') for x in ans.split(linesep)]\n\tif len(ans[-1]) < 2:\n\t\tans = ans[:-1]\n\tif len(ans) == 0 or len(ans[0]) == 0:\n\t\traise ValueError('No enrichment found. Check your input ID type.')\n\tans[0][0] = ans[0][0].strip('# ')\n\tans = pd.DataFrame(ans[1:], columns=ans[0])\n\tans.drop(['NS', 'enrichment', 'study_count', 'p_sidak', 'p_holm'],\n\t\t\t axis=1,\n\t\t\t inplace=True)\n\tfor xj in ['p_uncorrected', 'p_bonferroni']:\n\t\tans[xj] = pd.to_numeric(ans[xj], errors='raise')\n\tans['depth'] = pd.to_numeric(ans['depth'],\n\t\t\t\t\t\t\t\t errors='raise',\n\t\t\t\t\t\t\t\t downcast='unsigned')\n\t# Odds ratio column and sort column\n\tans['odds_ratio'] = toratio(ans['ratio_in_study']) / toratio(\n\t\tans['ratio_in_pop'])\n\tans = ans[[\n\t\t'name', 'depth', 'p_uncorrected', 'p_bonferroni', 'odds_ratio',\n\t\t'ratio_in_study', 'ratio_in_pop', 'GO', 'study_items']]\n\tans['study_items'] = ans['study_items'].apply(lambda x: x.replace(' ', ''))\n\t# Convert back study_items\n\tif conversion is not None:\n\t\tans['study_items'] = ans['study_items'].apply(lambda x: ','.join(\n\t\t\tlist(itertools.chain.from_iterable([converti[y] for y in x.split(',')])))\n\t\t\t\t\t\t\t\t\t\t\t\t\t if len(x) > 0 else x)\n\tans.sort_values('p_uncorrected', inplace=True)\n\n\t# Get top enriched GO by P-value\n\tgotop = ans[\n\t\t(ans['odds_ratio'] > 1)\n\t\t& ans['ratio_in_study'].apply(lambda x: int(x.split('/')[0]) >= nmin)]\n\tif len(gotop) == 0:\n\t\traise ValueError('No GO enrichment found for given criteria.')\n\tgotop = str(gotop.iloc[0]['GO'])\n\tif bg0 is not None:\n\t\t# Children GOs\n\t\tgos = set([gotop] + list(godag.query_term(gotop).get_all_children()))\n\t\t# Look for genes\n\t\tgenes = list(\n\t\t\tfilter(lambda x: len(list(filter(lambda y: y in gos, goa[x]))) > 0, goa))\n\t\tif conversion is not None:\n\t\t\tgenes = [convertia[x] for x in filter(lambda x: x in convertia, genes)]\n\t\t\tgenes = list(set(list(itertools.chain.from_iterable(genes))))\n\t\tgenes = set(genes)\n\t\tgenes = list(filter(lambda x: x in genes, bg0))\n\telse:\n\t\tgenes = None\n\treturn (ans, gotop, genes)","def cohighest_root(self):\n return self.highest_root().associated_coroot()","def bipartite_vertex_cover(bigraph, algo=\"Hopcroft-Karp\"):\n if algo == \"Hopcroft-Karp\":\n coord = [(irow,icol) for irow,cols in enumerate(bigraph) for icol in cols]\n coord = np.array(coord)\n graph = csr_matrix((np.ones(coord.shape[0]),(coord[:,0],coord[:,1])))\n matchV = maximum_bipartite_matching(graph, perm_type='row')\n matchV = [None if x==-1 else x for x in matchV]\n nU, nV = graph.shape\n assert len(matchV) == nV\n elif algo == \"Hungarian\":\n matchV = max_bipartite_matching2(bigraph)\n nU, nV = len(bigraph), len(matchV)\n else:\n assert False\n\n matchU = [None] * nU\n \n for v in range(nV): # -- build the mapping from U to V\n if matchV[v] is not None:\n matchU[matchV[v]] = v\n \n def old_konig():\n visitU = [False] * nU # -- build max alternating forest\n visitV = [False] * nV\n for u in range(nU):\n if matchU[u] is None: # -- starting with free vertices in U\n _alternate(u, bigraph, visitU, visitV, matchV)\n inverse = [not b for b in visitU]\n return (inverse, visitV)\n \n def new_konig():\n # solve the limitation of huge number of recursive calls\n visitU = [False] * nU # -- build max alternating forest\n visitV = [False] * nV\n wait_u = set(range(nU)) - set(matchV) \n while len(wait_u) > 0:\n u = wait_u.pop()\n visitU[u] = True\n for v in bigraph[u]:\n if not visitV[v]:\n visitV[v] = True\n assert matchV[v] is not None # otherwise match is not maximum\n assert matchV[v] not in wait_u\n wait_u.add(matchV[v])\n inverse = [not b for b in visitU]\n return (inverse, visitV)\n \n #res_old = old_konig()\n res_new = new_konig()\n #assert res_old == res_new\n return res_new","def select_best_chanels():\r\n \r\n \r\n all_paths = [['data_bci\\\\row_data\\\\subject1\\\\'], ['data_bci\\\\row_data\\\\subject2\\\\'],['data_bci\\\\row_data\\\\subject3\\\\']]\r\n\r\n train_subjects = ['01']\r\n test_subject = '02'\r\n freq = 512\r\n\r\n cutoff_beggining = 0\r\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\r\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\r\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\r\n seq_len = 0\r\n cut_step = 0\r\n num_perseg = freq\r\n num_overlap = int(num_perseg/2)\r\n min_freq=8\r\n max_freq=45\r\n \r\n chanels_rank = rank_chanels()\r\n \r\n result = []\r\n for i in range(1, len(chanels_rank)):\r\n intermidiate_result = []\r\n for path in all_paths:\r\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\r\n\r\n train_psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq)\r\n test_psd_signals = eval_psd_not_modulated(test_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \r\n\r\n train_psd_signals = flatten_data(train_psd_signals[:,:,chanels_rank[:i]])\r\n test_psd_signals = flatten_data(test_psd_signals[:,:,chanels_rank[:i]])\r\n \r\n acc = evalute_subset(train_psd_signals, test_psd_signals, train_full_anots, test_full_annoations)\r\n intermidiate_result.append(acc)\r\n \r\n result.append(intermidiate_result)\r\n #mean_subject_acc = np.array([sum(humans_acc)/len(humans_acc) for humans_acc in result])\r\n #best_idx = np.argmax(mean_subject_acc)\r\n\r\n return result, chanels_rank","def gagps(data_src, min_supp=MIN_SUPPORT, max_iteration=MAX_ITERATIONS, n_pop=N_POPULATION, pc=PC,\n gamma=GAMMA, mu=MU, sigma=SIGMA, return_gps=False):\n\n # Prepare data set\n d_set = DataGP(data_src, min_supp)\n d_set.init_attributes()\n attr_keys = [GI(x[0], x[1].decode()).as_string() for x in d_set.valid_bins[:, 0]]\n\n if d_set.no_bins:\n return []\n\n # Problem Information\n # costfxn\n\n # Parameters\n # pc: Proportion of children (if its 1, then nc == npop\n it_count = 0\n eval_count = 0\n counter = 0\n var_min = 0\n var_max = int(''.join(['1'] * len(attr_keys)), 2)\n\n nc = int(np.round(pc * n_pop / 2) * 2) # Number of children. np.round is used to get even number of children\n\n # Empty Individual Template\n empty_individual = structure()\n empty_individual.position = None\n empty_individual.cost = None\n\n # Initialize Population\n pop = empty_individual.repeat(n_pop)\n for i in range(n_pop):\n pop[i].position = random.randrange(var_min, var_max)\n pop[i].cost = 1 # costfxn(pop[i].position, attr_keys, d_set)\n # if pop[i].cost < best_sol.cost:\n # best_sol = pop[i].deepcopy()\n\n # Best Solution Ever Found\n best_sol = empty_individual.deepcopy()\n best_sol.position = pop[0].position\n best_sol.cost = costfxn(best_sol.position, attr_keys, d_set)\n\n # Best Cost of Iteration\n best_costs = np.empty(max_iteration)\n best_patterns = list()\n str_best_gps = list()\n str_iter = ''\n str_eval = ''\n\n repeated = 0\n while counter < max_iteration:\n # while eval_count < max_evaluations:\n # while repeated < 1:\n\n c_pop = [] # Children population\n for _ in range(nc // 2):\n # Select Parents\n q = np.random.permutation(n_pop)\n p1 = pop[q[0]]\n p2 = pop[q[1]]\n\n # a. Perform Crossover\n c1, c2 = crossover(p1, p2, gamma)\n\n # Apply Bound\n apply_bound(c1, var_min, var_max)\n apply_bound(c2, var_min, var_max)\n\n # Evaluate First Offspring\n c1.cost = costfxn(c1.position, attr_keys, d_set)\n if c1.cost < best_sol.cost:\n best_sol = c1.deepcopy()\n eval_count += 1\n str_eval += \"{}: {} \\n\".format(eval_count, best_sol.cost)\n\n # Evaluate Second Offspring\n c2.cost = costfxn(c2.position, attr_keys, d_set)\n if c2.cost < best_sol.cost:\n best_sol = c2.deepcopy()\n eval_count += 1\n str_eval += \"{}: {} \\n\".format(eval_count, best_sol.cost)\n\n # b. Perform Mutation\n c1 = mutate(c1, mu, sigma)\n c2 = mutate(c2, mu, sigma)\n\n # Apply Bound\n apply_bound(c1, var_min, var_max)\n apply_bound(c2, var_min, var_max)\n\n # Evaluate First Offspring\n c1.cost = costfxn(c1.position, attr_keys, d_set)\n if c1.cost < best_sol.cost:\n best_sol = c1.deepcopy()\n eval_count += 1\n str_eval += \"{}: {} \\n\".format(eval_count, best_sol.cost)\n\n # Evaluate Second Offspring\n c2.cost = costfxn(c2.position, attr_keys, d_set)\n if c2.cost < best_sol.cost:\n best_sol = c2.deepcopy()\n eval_count += 1\n str_eval += \"{}: {} \\n\".format(eval_count, best_sol.cost)\n\n # c. Add Offsprings to c_pop\n c_pop.append(c1)\n c_pop.append(c2)\n\n # Merge, Sort and Select\n pop += c_pop\n pop = sorted(pop, key=lambda x: x.cost)\n pop = pop[0:n_pop]\n\n best_gp = validategp(d_set, decodegp(attr_keys, best_sol.position))\n \"\"\":type best_gp: GP\"\"\"\n is_present = isduplicate(best_gp, best_patterns)\n is_sub = amcheck(best_patterns, best_gp, subset=True)\n if is_present or is_sub:\n repeated += 1\n else:\n if best_gp.support >= min_supp:\n best_patterns.append(best_gp)\n str_best_gps.append(best_gp.print(d_set.titles))\n # else:\n # best_sol.cost = 1\n\n try:\n # Show Iteration Information\n # Store Best Cost\n best_costs[it_count] = best_sol.cost\n str_iter += \"{}: {} \\n\".format(it_count, best_sol.cost)\n except IndexError:\n pass\n it_count += 1\n\n if max_iteration == 1:\n counter = repeated\n else:\n counter = it_count\n # Output\n out = json.dumps({\"Algorithm\": \"GA-GRAD\", \"Best Patterns\": str_best_gps, \"Iterations\": it_count})\n \"\"\":type out: object\"\"\"\n if return_gps:\n return out, best_patterns\n else:\n return out","def enhancer2gene(\n self,\n peak_pr,\n up=100_000,\n down=100_000,\n alpha=1e4,\n promoter=2000,\n full_weight_region=5000,\n ):\n genes = region_gene_overlap(peak_pr, self.gene_bed)\n\n # Get the distance from center of enhancer to TSS\n # Correct for extension\n genes[\"dist\"] = (\n (genes[\"Start_b\"] + genes[\"End_b\"]) / 2 - genes[\"Start\"]\n ).astype(int)\n genes.loc[genes[\"Strand\"] == \"+\", \"dist\"] -= up\n genes.loc[genes[\"Strand\"] == \"-\", \"dist\"] -= down\n genes[\"dist\"] = np.abs(genes[\"dist\"])\n\n # Create region in chr:start:end format\n genes[\"loc\"] = (\n genes[\"Chromosome\"].astype(str)\n + \":\"\n + genes[\"Start_b\"].astype(str)\n + \"-\"\n + genes[\"End_b\"].astype(str)\n )\n\n # Keep the gene-enhancer combination with the smallest distance\n genes = genes.sort_values(\"dist\").drop_duplicates(\n subset=[\"loc\", \"Name\"], keep=\"first\"\n )\n\n # Return the right stuff\n genes = genes.set_index(\"loc\")[[\"Name\", \"dist\"]].rename(\n columns={\"Name\": \"gene\"}\n )\n\n # Get distance-based wight\n weight = self.distance_weight(\n include_promoter=self.include_promoter,\n include_enhancer=self.include_enhancer,\n alpha=alpha,\n promoter_region=promoter,\n full_weight_region=full_weight_region,\n ).set_index(\"dist\")\n genes = genes.join(weight, on=\"dist\")\n\n return genes","def main():\n G = nx.gnp_random_graph(100, 0.5)\n centrality = nx.eigenvector_centrality(G)\n avg_centrality = sum(centrality.values()) / len(G)\n\n def has_high_centrality(v):\n return centrality[v] >= avg_centrality\n\n source = 0\n value = centrality.get\n condition = has_high_centrality\n\n found_node = progressive_widening_search(G, source, value, condition)\n c = centrality[found_node]\n print('found node {0} with centrality {1}'.format(found_node, c))","def vis_hierarchy(corexes, row_label=None, column_label=None, max_edges=100, prefix=''):\n if column_label is None:\n column_label = list(map(str, range(corexes[0].alpha.shape[1])))\n if row_label is None:\n row_label = list(map(str, range(corexes[0].labels.shape[0])))\n\n f = safe_open(prefix + '/text_files/higher_layer_group_tcs.txt', 'w+')\n params = ['dim_hidden', 'eps', 'marginal_description', 'max_iter', 'max_samples', 'missing_values', 'n_cpu',\n 'n_hidden', 'n_repeat', 'n_samples', 'n_visible', 'ram', 'smooth_marginals']\n parameter_dict = {}\n for j, corex in enumerate(corexes):\n parameter_dict[j] = {}\n for param in params:\n parameter_dict[j][param] = getattr(corex, param, None)\n f.write('At layer: %d, Total TC: %0.3f\\n' % (j, corex.tc))\n f.write('Individual TCS:' + str(corex.tcs) + '\\n')\n plot_convergence(corex.tc_history, prefix=prefix, prefix2=j)\n g = safe_open('{}/text_files/mis_layer{}.csv'.format(prefix, j), 'w+')\n h = safe_open('{}/text_files/weights_layer{}.csv'.format(prefix, j), 'w+')\n if j == 0:\n g.write('factor,' + ','.join(column_label) + '\\n')\n h.write('factor,' + ','.join(column_label) + '\\n')\n else:\n g.write('factor,'+ ','.join(map(str, list(range(len(corex.mis[0,:]))))) + '\\n')\n h.write('factor,'+ ','.join(map(str, list(range(len(corex.mis[0,:]))))) + '\\n')\n mis = corex.mis / np.log(2)\n alpha = corex.alpha\n for ir, r in enumerate(mis):\n g.write(str(ir) + ',' + ','.join(map(str, mis[ir])) + '\\n')\n h.write(str(ir) + ',' + ','.join(map(str, mis[ir] * alpha[ir].ravel())) + '\\n')\n g.close()\n h.close()\n f.close()\n with open('{}/text_files/parameters.json'.format(prefix), 'w') as fp:\n json.dump(parameter_dict, fp)\n\n import textwrap\n column_label = list(map(lambda q: '\\n'.join(textwrap.wrap(q, width=17, break_long_words=False)), column_label))\n\n # Construct non-tree graph\n weights = [corex.alpha[:, :, 0].clip(0, 1) * corex.mis for corex in corexes]\n node_weights = [corex.tcs for corex in corexes]\n g = make_graph(weights, node_weights, column_label, max_edges=max_edges)\n\n # Display pruned version\n h = g.copy() # trim(g.copy(), max_parents=max_parents, max_children=max_children)\n edge2pdf(h, prefix + '/graphs/graph_prune_' + str(max_edges), labels='label', directed=True, makepdf=True)\n\n # Display tree version\n tree = g.copy()\n tree = trim(tree, max_parents=1, max_children=False)\n edge2pdf(tree, prefix + '/graphs/tree', labels='label', directed=True, makepdf=True)\n\n return g","def evolution(inipop):\n popmorph = inipop\n countgenerations = 0\n terminalcount = 0\n bestindiv = inipop[0]\n print(\"initializing with fitness: \",bestindiv.fitness)\n \n \n while terminalcount != 25:\n \n\n selection(popmorph)\n \n generationsbest = top_individual(popmorph)\n print(\"evaluating generation: \",countgenerations)\n countgenerations += 1\n \n \n if generationsbest.fitness > bestindiv.fitness:\n \n bestindiv = generationsbest\n print(\"Better individual found in generation\",countgenerations,\"! Top fitness now: \",bestindiv.fitness)\n terminalcount = 0\n else:\n terminalcount += 1\n\n \n \n popmorph = next_generation(popmorph)\n \n \n return(bestindiv, countgenerations)","def detection_algorithm(G, edge_weight):\n Gc = G.copy()\n set_node_attributes(Gc, attr_name='k-index')\n seed_node2communities = {}\n\n from operator import itemgetter\n while Gc.number_of_nodes() > 0:\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\n Gc.remove_nodes_from(nodes_in_community)\n return seed_node2communities","def __top_Algs_ ( self ) :\n _algs = self.TopAlg\n\n def _alg_name_ ( _n ):\n\n _p = _n.rfind('/')\n if 0 > _p : return _n\n return _n[_p:]\n\n def _pyAlg ( _n ) :\n for _a in self.pyalgorithms :\n if _n == _a.name() : return _a\n return None \n \n algs = [] \n for _a in _algs :\n # get the proper name \n _n = _alg_name_ ( _a )\n # check if it is pyalgorithm:\n _pa = _pyAlg ( _n )\n if _pa :\n algs += [ _pa ]\n else :\n _alg = self.algorithm ( _a , True )\n algs += [ _alg ]\n \n return algs","def __top_Algs_ ( self ) :\n _algs = self.TopAlg\n\n def _alg_name_ ( _n ):\n\n _p = _n.rfind('/')\n if 0 > _p : return _n\n return _n[_p:]\n\n def _pyAlg ( _n ) :\n for _a in self.pyalgorithms :\n if _n == _a.name() : return _a\n return None \n \n algs = [] \n for _a in _algs :\n # get the proper name \n _n = _alg_name_ ( _a )\n # check if it is pyalgorithm:\n _pa = _pyAlg ( _n )\n if _pa :\n algs += [ _pa ]\n else :\n _alg = self.algorithm ( _a , True )\n algs += [ _alg ]\n \n return algs","def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\n\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n\n #this is just printing stuff for easier terminal reading\n if h_agent is not None:\n hstr = \"Specialized Human\"\n else:\n hstr = \"Random Human\"\n if coagent is not None:\n coagenthelp = True\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\n else:\n coagenthelp = False\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\n\n liRewards = []\n liRewardsPenalized = []\n actionsctli =[]\n heatmap = np.zeros((7, 7))\n for i in range(episodes):\n grid.reset()\n actionct = 0\n misstepct = 0\n heatmap[0,0] += 1\n while (not grid.isEnd) and (grid.numSteps <=200):\n state = grid.state\n width = grid.getBoardDim()[0]\n state_ind = state[1]*(width+1)+state[0]\n\n if 'disjoint' in mode:\n actions = [0, 1, 2, 3]\n else:\n #'up','right','down','left','upri','dori','dole','uple'\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n #if we have a special human agent use it, if not use random human\n if h_agent is None:\n action = np.random.choice(actions, 1)[0]\n h_action = action\n else:\n action = h_agent.get_action(state_ind)\n h_action = action\n if coagenthelp:\n q_vals = coagent.get_q_values(state_ind)\n best_action = coagent.get_action(state_ind)\n best_q = q_vals[best_action]\n min_q = min(q_vals)\n human_q = q_vals[action]\n\n #closest actions dictionary\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\n #value = action index if radial\n #key = actual action index\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\n #actions in order of circle\n a_radial = [0,4,1,5,2,6,3,7]\n #co-pilot action choices\n #override to optimal if suboptimal action selected\n if \"override\" in mode:\n #random percent to decide when to help if wrong action taken\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\n actionct += 1\n action = best_action\n #select best closest action if human action q-value is negative\n elif mode == \"q-neg\" and human_q < 0:\n actionct += 1\n a_li = closest_a[action]\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\n #Shared Autonomy\n #select better closest action if difference between best q and human q is past some threshold\n elif mode == \"q-diff\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\n actionct += 1\n for i in range(1,5):\n radial_a = a_dist_ind[action]\n ccw_ra = (radial_a - i) % len(actions)\n ccw_a = a_radial[ccw_ra]\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = ccw_a\n break\n cw_ra = (radial_a + i) % len(actions)\n cw_a = a_radial[cw_ra]\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\n action = cw_a\n break\n #take the potentiallny new action\n grid.step(action)\n\n if h_agent is not None:\n heatmap[grid.state[1],grid.state[0]] += 1\n\n #add metrics to their respective lists\n liRewards.append(grid.reward)\n liRewardsPenalized.append(grid.reward-actionct)\n actionsctli.append(actionct)\n #convert lists to numpy arrays\n rewards = np.array(liRewards)\n rewards_penalized = np.array(liRewardsPenalized)\n actionsctli = np.array(actionsctli)\n #print some metrics if we want to\n if verbose:\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\n if h_agent is not None:\n plt.figure()\n print(heatmap)\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\n plt.savefig('two.png')\n\n return rewards, actionsctli, rewards_penalized","def find_common_interactor():\n # 1. filter the unique fusion gene pairs.\n # fusionGenePair = pd.read_csv(\"./fusionGenePair.csv\", header=0, sep=' ')\n # unique_fusionGenePair = fusionGenePair.drop_duplicates()\n # unique_fusionGenePair.to_csv(\"./uniqueFusion.csv\", sep=' ', index=False)\n unique_fusionGenePair = pd.read_csv(\"./uniqueFusion.csv\", sep=' ', header=0)\n\n # 2. for each gene pairs, get all the interactors each partner has.\n\n # Store the 5' partner gene and 3' partner gene in two lists.\n FivePartnerGenelist = []\n ThreePartnerGenelist = []\n for index, row in unique_fusionGenePair.iterrows():\n FivePartnerGenelist.append(row['5_PARTNER_GENE'])\n ThreePartnerGenelist.append(row['3_PARTNER_GENE'])\n # Get the unique gene in each pair\n uniqueFPGL = list(OrderedDict.fromkeys(FivePartnerGenelist))\n uniqueTPGL = list(OrderedDict.fromkeys(ThreePartnerGenelist))\n uniqueGene = list(OrderedDict.fromkeys(uniqueTPGL + uniqueFPGL))\n\n # Find each gene's interactor in the PPI datasets\n PPIS = pd.read_csv(\"./IID results/PPIs_final.tsv\", sep='\\t', header=0)\n\n # Put each gene interactor into a dictionary.\n geneIntDic = {}\n for item in uniqueGene:\n for index, row in PPIS.iterrows():\n if row['Query Symbol'] == item:\n if item in geneIntDic:\n geneIntDic[item].append(row['Partner Symbol'])\n else:\n key = item\n geneIntDic.setdefault(key, [])\n geneIntDic[item].append(row['Partner Symbol'])\n if row['Partner Symbol'] == item:\n if item in geneIntDic:\n geneIntDic[item].append(row['Query Symbol'])\n else:\n key = item\n geneIntDic.setdefault(key, [])\n geneIntDic[item].append(row['Query Symbol'])\n w = csv.writer(open(\"./geneIntDic.csv\", \"w\"))\n for key, val in geneIntDic.items():\n w.writerow([key, val])","def sense(self, agents, agent_index, top_down_map=None):\n host_agent = agents[agent_index]\n other_agent_dists = {}\n sorted_pairs = sorted(other_agent_dists.items(),\n key=operator.itemgetter(1))\n\n sorting_criteria = []\n for i, other_agent in enumerate(agents):\n if other_agent.id == host_agent.id:\n continue\n # project other elements onto the new reference frame\n rel_pos_to_other_global_frame = other_agent.pos_global_frame - \\\n host_agent.pos_global_frame\n p_parallel_ego_frame = np.dot(rel_pos_to_other_global_frame, host_agent.ref_prll)\n p_orthog_ego_frame = np.dot(rel_pos_to_other_global_frame, host_agent.ref_orth)\n dist_between_agent_centers = vec2_l2_norm(rel_pos_to_other_global_frame)\n dist_2_other = dist_between_agent_centers - host_agent.radius - other_agent.radius\n combined_radius = host_agent.radius + other_agent.radius\n\n if dist_between_agent_centers > Config.SENSING_HORIZON:\n # print(\"Agent too far away\")\n continue\n\n if self.agent_sorting_method != \"time_to_impact\":\n time_to_impact = None\n else:\n time_to_impact = compute_time_to_impact(host_agent.pos_global_frame,\n other_agent.pos_global_frame,\n host_agent.vel_global_frame,\n other_agent.vel_global_frame,\n combined_radius)\n\n sorting_criteria.append([i, round(dist_2_other,2), p_orthog_ego_frame, time_to_impact])\n\n clipped_sorted_inds = self.get_clipped_sorted_inds(sorting_criteria)\n clipped_sorted_agents = [agents[i] for i in clipped_sorted_inds]\n\n other_agents_states = np.zeros((Config.MAX_NUM_OTHER_AGENTS_OBSERVED, 7))\n other_agent_count = 0\n for other_agent in clipped_sorted_agents:\n if other_agent.id == host_agent.id:\n continue\n # project other elements onto the new reference frame\n rel_pos_to_other_global_frame = other_agent.pos_global_frame - \\\n host_agent.pos_global_frame\n p_parallel_ego_frame = np.dot(rel_pos_to_other_global_frame,\n host_agent.ref_prll)\n p_orthog_ego_frame = np.dot(rel_pos_to_other_global_frame,\n host_agent.ref_orth)\n v_parallel_ego_frame = np.dot(other_agent.vel_global_frame,\n host_agent.ref_prll)\n v_orthog_ego_frame = np.dot(other_agent.vel_global_frame,\n host_agent.ref_orth)\n dist_2_other = np.linalg.norm(rel_pos_to_other_global_frame) - \\\n host_agent.radius - other_agent.radius\n combined_radius = host_agent.radius + other_agent.radius\n\n other_obs = np.array([p_parallel_ego_frame,\n p_orthog_ego_frame,\n v_parallel_ego_frame,\n v_orthog_ego_frame,\n other_agent.radius,\n combined_radius,\n dist_2_other])\n \n if other_agent_count == 0:\n host_agent.other_agent_states[:] = other_obs\n\n other_agents_states[other_agent_count,:] = other_obs\n other_agent_count += 1\n\n host_agent.num_other_agents_observed = other_agent_count\n\n return other_agents_states","def finetune_intron_boundaries(abfgp_genemodel,introndata,\n array_algpresence,array_algsimilarity,verbose=True):\n\n # Global Variable Imports\n FINETUNE_ACCEPTOR_NT_OFFSET = 12\n FINETUNE_DONOR_NT_OFFSET = 12\n FINETUNE_ACCEPTOR_NT_OFFSET = 18\n FINETUNE_DONOR_NT_OFFSET = 18\n from settings.genestructure import MIN_INTRON_NT_LENGTH\n\n # list with adjusted boundaries\n refined_boundaries = []\n\n # recreate lists of ABGFP exons & introns\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\n\n for intron_pos in range(0,len(abfgp_introns)):\n intron = abfgp_introns[intron_pos]\n if not intron: continue\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\n has_been_printed = False\n finetune_acceptor_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1)\n finetune_donor_range = range(intron.donor.pos-FINETUNE_DONOR_NT_OFFSET,\n intron.donor.pos+FINETUNE_DONOR_NT_OFFSET+1)\n\n # assign branchpoint in current intron\n intron.assign_bp_and_ppts()\n\n # start searching acceptor based\n alternatives = []\n for acceptor in intron.orfAcceptor._acceptor_sites:\n if acceptor.pos != intron.acceptor.pos and\\\n acceptor.phase != intron.acceptor.phase and\\\n acceptor.pos in finetune_acceptor_range:\n # now see if we can find a donor for this phase too\n for donor in intron.orfDonor._donor_sites:\n if donor.pos != intron.donor.pos and\\\n donor.phase != intron.donor.phase and\\\n donor.phase == acceptor.phase and\\\n donor.pos in finetune_donor_range:\n # get the next exon (3'of this intron)\n next_exon = abfgp_exons[intron_pos+1]\n prev_exon = abfgp_exons[intron_pos]\n\n if not has_been_printed:\n has_been_printed = True\n ####################################################\n if verbose: print \"FINETUNING INTRON::\", intron\n ####################################################\n\n # get data on this alternative acceptor/donor combination\n test_intron = IntronConnectingOrfs(donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\n test_intron.assign_bp_and_ppts()\n\n # test if refinement will result in a long enough intron\n if test_intron.length < MIN_INTRON_NT_LENGTH: continue\n\n scorelist = []\n # score 1: is donor.pssm_score `higher`?\n scorelist.append( _finetune_splicesite_comparison(intron.donor,donor) )\n # score 2: is acceptor.pssm_score `higher`?\n scorelist.append( _finetune_splicesite_comparison(intron.acceptor,acceptor) )\n # score 3: branchpoint comparison?\n scorelist.append( _branchpoint_comparison(intron,test_intron) )\n # score 4: ppt comparison?\n scorelist.append( _polypyrimidinetract_comparison(intron,test_intron) )\n # score 5: is algsimilarity ratio increased (==better)?\n scorelist.append( _algsimilarity_comparison(intron,test_intron,prev_exon,next_exon,array_algsimilarity) )\n\n # evaluate scorelist; improved intron boundary or not?\n # use donor, acceptor, branchpoint & ppt, do *NOT* use algsim score\n if scorelist[0:4].count(False) == 0 and scorelist[0:4].count(True) >= 1:\n alternatives.append( ( donor, acceptor, scorelist ) )\n is_accepted = True\n else:\n is_accepted = False\n\n ########################################################\n if verbose:\n print \"alternatives:\", donor, acceptor,\n print intron.donor.pos - donor.pos,\n print intron.acceptor.pos - acceptor.pos,\n print scorelist, is_accepted,\n print \"BPcur:\",intron.get_branchpoint_nt_distance(),\n print \"alt:\",\n print test_intron.get_branchpoint_nt_distance()\n ########################################################\n\n # now evaluate the alternatived and take the best one\n if not alternatives:\n continue\n elif len(alternatives) == 1:\n refined_boundaries.append( ( intron.donor, alternatives[0][0] ) )\n refined_boundaries.append( ( intron.acceptor, alternatives[0][1] ) )\n else:\n # multiple! again, take the *best* one\n pass\n\n # return list of refined_boundaries\n return refined_boundaries","def remove_hi_confidence_chromosome(G):\n to_remove = []\n for nd in G.nodes():\n if get_length_from_spades_name(nd) > PARAMS.CHROMOSOME_LEN_THRESH and \\\n G.nodes[nd]['score'] < PARAMS.CHROMOSOME_SCORE_THRESH:\n to_remove.append(nd)\n to_remove.append(rc_node(nd))\n G.remove_nodes_from(to_remove)\n logger.info(\"Removed %d long, likely chromosomal nodes\" % len(set(to_remove)))","def analysis_go_RSA(self, s_go, S_hit, S_score, N_total=0, SRC_GENE=None, min_overlap=3, p_cutoff=0.01, l_keep_most=True):\n c={'GO':s_go, '#TotalGeneInLibrary':N_total, '#GeneInGO':0, '#GeneInHitList':0, '#GeneInGOAndHitList':0, 'Cutoff':None, '#HitRemain':0, '#HitInGORemain':0, 'LogP':0.0, 'Enrichment':0}\n #if SRC_GENE is not None:\n # print \"SRC_GENE: \"+str(len(SRC_GENE))\n S_gene=self.GO_GENE[s_go]\n if len(S_gene)>=Cache.N_TRIVIAL:\n return None\n if not N_total:\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\n t_hit=pd.DataFrame(data={'Hit':S_hit, 'Score':S_score})\n if SRC_GENE is not None:\n S_gene=S_gene.intersection(SRC_GENE)\n t_hit=t_hit[ t_hit.Hit.apply(lambda x: x in SRC_GENE) ]\n S_hit=set(t_hit.Hit)\n else:\n S_hit=set(S_hit)\n t_hit.sort_values('Score', inplace=True)\n c['#GeneInGO']=len(S_gene)\n c['#GeneInHitList']=len(S_hit)\n if c['#GeneInGO']<min_overlap or c['#GeneInHitList']<min_overlap:\n return None\n S_both=S_gene.intersection(S_hit)\n c['#GeneInGOAndHitList']=len(S_both)\n if c['#GeneInGOAndHitList']<min_overlap:\n return None\n\n I_index=np.arange(len(t_hit))[t_hit.Hit.apply(lambda x: x in S_gene).values]\n I_rank=stats.RSA_rank(t_hit.Score.values, I_index)\n rslt=stats.RSA_score(I_rank, N_total, l_BonferroniCorrection=True, l_keep_most=l_keep_most, p_cutoff=p_cutoff)\n c['#HitInGORemain']=rslt[\"cutoff\"]+1\n if c['#HitInGORemain']<min_overlap: return None\n c['#HitRemain']=I_rank[rslt[\"cutoff\"]]\n c['Cutoff']=t_hit.Score.values[rslt[\"cutoff\"]]\n c['%InGO']=c['#HitInGORemain']*100.0/c['#HitRemain']\n q=min(max(c['%InGO']/100, 1.0/c['#HitRemain']), 1-1.0/c['#HitRemain'])\n c['STDV %InGO']=np.sqrt(q*(1-q)/c['#HitRemain'])*100\n c['Enrichment']=c['%InGO']/100.0*N_total/c['#GeneInGO']\n S=[int(x) for x in S_both]\n S.sort()\n c['GeneID_All']='|'.join([str(x) for x in S])\n S=[int(x) for x in list(t_hit.Hit[: rslt[\"cutoff\"]+1])]\n S.sort()\n c['GeneID']='|'.join([str(x) for x in S])\n c['LogP']=rslt['logP']\n return c","def _find_solution(self, population, num_of_best_chromosomes):\n data = self._Individuals()\n for x in population:\n curr_fit = self._fitness(x)\n data.append_object(self._Individual(curr_fit, x))\n return data.sort_objects()[:num_of_best_chromosomes]","def all_best_nr(potential_coverage, all_coverage, covered):\n ## get redundancy count\n potential_redundancy = {grna_seq: len(set(hit.target_id for hit in hits\n if hit.target_id in covered))\n for grna_seq, hits in all_coverage.items()\n if grna_seq in potential_coverage}\n best_redundancy = min(potential_redundancy.values())\n return {grna_seq: potential_coverage[grna_seq]\n for grna_seq, redundancy in potential_redundancy.items()\n if redundancy == best_redundancy}","def analysis(self, S_hit, S_score=None, S_go=None, SRC_GENE=None, min_overlap=3, min_enrichment=0, p_cutoff=0.01, n_CPU=0, l_rsa_keep_most=True, S_go_category=None, l_background_by_ontology=False):\n\n def go_filtered(S_go, S_go_category):\n return [x for x in S_go if self.get_category_id(x) in S_go_category]\n\n S_all_go_filtered=[]\n def all_go_filtered(S_go_category):\n if len(S_all_go_filtered)==0:\n S_go=self.GO_GENE_ENRICH\n S_all_go_filtered.append(go_filtered(S_go, S_go_category))\n return S_all_go_filtered[0]\n\n N_go=0\n if S_go_category is not None and len(S_go_category)>0:\n # hard code for now, to be fixed later\n if type(S_go_category) in (int, str):\n S_go_category=[S_go_category]\n S_go_category={int(x) for x in S_go_category if self.CATEGORY_COUNT.get(x,0)>0 }\n for x in S_go_category:\n N_go+=self.CATEGORY_COUNT[x]\n else:\n N_go=sum(self.CATEGORY_COUNT.values())\n\n l_multi_list=type(S_hit) is dict\n if S_go is None:\n if l_multi_list:\n S_go={}\n for k in S_hit.keys():\n S_go[k]=all_go_filtered(S_go_category)\n else:\n S_go=all_go_filtered(S_go_category)\n else:\n if l_multi_list:\n for k in S_hit.keys():\n if S_go.get(k, None) is None:\n S_go[k]=all_go_filtered(S_go_category)\n else:\n S_go[k]=go_filtered(S_go[k], S_go_category)\n else:\n S_go=go_filtered(S_go, S_go_category)\n\n if SRC_GENE is not None:\n if type(SRC_GENE) is list:\n SRC_GENE=set(SRC_GENE)\n SRC_GENE=self.ALL_GENE.intersection(SRC_GENE) # remove genes from background, if it is not in self.ALL_GENE\n N_total=len(SRC_GENE) #self.ALL_GENE.intersection(SRC_GENE))\n elif l_background_by_ontology:\n # GeneGo uses this\n if l_multi_list:\n X=set()\n for x in S_go.values():\n X.add(set(x))\n src_genes=self.gene_count(list(X))\n else:\n src_genes=self.gene_count(S_go)\n N_total=len(src_genes)\n SRC_GENE=set(src_genes.keys())\n else:\n if self.is_L1000():\n N_total=len(self.ALL_GENE)\n else:\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\n #N_total=len(self.ALL_GENE)\n # prefiltering uninteresting GO terms\n # already converted to multiple hit list situation\n sw=util.StopWatch()\n L=[] # list of (S_hit, s_go)\n\n def spread_input(S_hit, S_go, key):\n #S_hit, S_go, key=(X[0], X[1], X[2])\n # may not worth it\n #c_cnt=self.go_count(S_hit, S_go)\n #S_go=[s_go for s_go in S_go if c_cnt.get(s_go,0)>=min_overlap ]\n # minimum size\n MIN_BATCH=2000\n S_go2=util.split(S_go, chunk_size=MIN_BATCH)\n return [(key, S_hit, x) for x in S_go2]\n\n #sw.check('To spreadout')\n if l_multi_list:\n #mp=parallel.MP()\n #m=1 if len(S_hit)<=3 else n_CPU\n #mp.start(f=spread_input, n_CPU=m)\n #L=[(X, S_go[k], k) for k,X in S_hit.items() if len(X)>=min_overlap]\n #out=mp.map(L)\n #L=[y for X in out for y in X]\n L=[]\n for k,X in S_hit.items():\n if len(X)<min_overlap: continue\n L.extend(spread_input(X, S_go[k], k))\n random.shuffle(L)\n else:\n if len(S_hit)>=min_overlap:\n L=spread_input(S_hit, S_go, 'Default')\n\n if self.eg is None:\n self.eg=ez.EntrezGene(tax_id=self.tax_id, l_use_GPDB=self.GPDB)\n if n_CPU==0: n_CPU=1\n #print \">>>>>>>>>>>>>>\", len(L)\n S_chunk=util.split(L, n_chunk=n_CPU)\n #sw.check('Spreadout tasks: %d' % len(L))\n\n def analyze(L):\n \"\"\"L is a list of [[s_name, S_hit, s_go]], s_go can also be a list\"\"\"\n rslt=[]\n #p=util.Progress(len(L))\n i=0\n import multiprocessing\n s_pid=str(multiprocessing.current_process().pid)\n for s_name, S_hit, S_go in L:\n i+=1\n #if (i % 50000): p.check(i, s_pid)\n if type(S_go) is str: S_go=[S_go]\n for s_go in S_go:\n if s_go not in self.GO_GENE: continue\n if S_score is None:\n c=self.analysis_go(s_go, S_hit, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff)\n else:\n c=self.analysis_go_RSA(s_go, S_hit, S_score, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff, l_keep_most=l_rsa_keep_most)\n if c is None:\n continue\n c['Name']=s_name\n if min_enrichment>0 and c['Enrichment']<min_enrichment: continue\n if p_cutoff<1 and 10**c['LogP']>p_cutoff: continue\n c['Description']= self.go_description(s_go)\n S_gene=c['GeneID'].split('|')\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\n c['Hits']='|'.join(S_symbol)\n if 'GeneID_All' in c:\n S_gene=c['GeneID_All'].split('|')\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\n c['Hits_All']='|'.join(S_symbol)\n if self.GPDB:\n c['CategoryID'] = self.get_category_id(c['GO'])\n c['Category'] = self.CATEGORY.get(self.get_category_id(c['GO']))\n c['GO'] = self.get_source_id(c['GO'])\n rslt.append(c)\n return rslt\n out=parallel.parmap(analyze, S_chunk, n_CPU=n_CPU)\n #if n_CPU>1:\n # mp=parallel.MP()\n # mp.start(f=analyze, n_CPU=n_CPU)\n # out=mp.map(S_chunk)\n #else:\n # out=[analyze(x) for x in S_chunk]\n\n #mp.start(n_CPU=n_CPU)\n #sw.check('P-value Calculation')\n #sw.check('P-value Calculation Done')\n rslt=[]\n for x in out:\n if len(x): rslt.extend(x)\n\n if len(rslt):\n #sw.check('Length: %d' % len(rslt))\n t=pd.DataFrame(rslt)\n #sw.check('Table DONE')\n if S_score is None:\n t=t.sort_values(['LogP','Enrichment','#GeneInGOAndHitList'], ascending=[True,False,False])\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\n '#GeneInGO','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits']\n else:\n t=t.sort_values(['LogP','Enrichment','#HitInGORemain','#GeneInGOAndHitList'], ascending=[True,False,False,False])\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\n '#GeneInGO','#HitRemain','#HitInGORemain','Cutoff','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits','GeneID_All','Hits_All']\n if self.GPDB:\n #cols.insert(1,'field1')\n cols.insert(1,'CategoryID')\n cols.insert(1,'Category')\n #sw.check('sorted DONE')\n t=t.reindex(columns=cols)\n # FDR\n #print \">>> N_go: \", N_go\n #sw.check('reindex DONE')\n t['Log(q-value)']=np.log10(np.clip(stats.adjust_p(np.power(10, t.LogP.values), N=N_go), 1e-100, 1.0))\n #sw.check('q-value DONE')\n if not l_multi_list:\n t.drop('Name', axis=1, inplace=True)\n return t\n else:\n return None","def nearest_common_parent(self, go_ids=None):\n # Take the element at maximum depth\n ncp = max(self.common_parents(go_ids=go_ids), key=lambda t: self.dict_go[t].depth)\n return ncp","def get_compound_hets(args):\n gq = GeminiQuery.GeminiQuery(args.db, include_gt_cols=True)\n idx_to_sample = gq.idx_to_sample\n subjects_dict = subjects.get_subjects(gq.c)\n \n if args.columns is not None:\n custom_columns = _add_necessary_columns(args, str(args.columns)) \n query = \"SELECT \" + custom_columns + \\\n \" FROM variants \" + \\\n \" WHERE (is_exonic = 1 or impact_severity != 'LOW') \"\n else:\n # report the kitchen sink\n query = \"SELECT *\" + \\\n \", gts, gt_types, gt_phases, gt_depths, \\\n gt_ref_depths, gt_alt_depths, gt_quals\" + \\\n \" FROM variants \" + \\\n \" WHERE (is_exonic = 1 or impact_severity != 'LOW') \"\n\n # add any non-genotype column limits to the where clause\n if args.filter:\n query += \" AND \" + args.filter\n\n # run the query applying any genotype filters provided by the user.\n gq.run(query)\n\n comp_hets = collections.defaultdict(lambda: collections.defaultdict(list))\n\n for row in gq:\n gt_types = row['gt_types']\n gts = row['gts']\n gt_bases = row['gts']\n gt_phases = row['gt_phases']\n \n site = Site(row)\n\n # track each sample that is heteroyzgous at this site.\n for idx, gt_type in enumerate(gt_types):\n if gt_type == HET:\n sample = idx_to_sample[idx]\n \n if args.only_affected and not subjects_dict[sample].affected:\n continue\n\n # sample = \"NA19002\"\n sample_site = copy(site)\n sample_site.phased = gt_phases[idx]\n\n # require phased genotypes\n if not sample_site.phased and not args.ignore_phasing:\n continue\n\n sample_site.gt = gt_bases[idx]\n # add the site to the list of candidates\n # for this sample/gene\n comp_hets[sample][site.row['gene']].append(sample_site)\n\n # header\n print \"family\\tsample\\tcomp_het_id\\t\" + str(gq.header)\n\n # step 2. now, cull the list of candidate heterozygotes for each\n # gene/sample to those het pairs where the alternate alleles\n # were inherited on opposite haplotypes. \n comp_het_id = 1\n for sample in comp_hets:\n for gene in comp_hets[sample]:\n\n # we only care about combinations, not permutations\n # (e.g. only need site1,site2, not site1,site2 _and site2,site1)\n # thus we can do this in a ~ linear pass instead of a ~ N^2 pass\n for idx, site1 in enumerate(comp_hets[sample][gene]):\n for site2 in comp_hets[sample][gene][idx + 1:]:\n\n # expand the genotypes for this sample\n # at each site into it's composite\n # alleles. e.g. A|G -> ['A', 'G']\n alleles_site1 = []\n alleles_site2 = []\n if not args.ignore_phasing:\n alleles_site1 = site1.gt.split('|')\n alleles_site2 = site2.gt.split('|')\n else:\n # split on phased (|) or unphased (/) genotypes\n alleles_site1 = re.split('\\||/', site1.gt)\n alleles_site2 = re.split('\\||/', site2.gt)\n \n # it is only a true compound heterozygote IFF\n # the alternates are on opposite haplotypes.\n if not args.ignore_phasing:\n # return the haplotype on which the alternate\n # allele was observed for this sample at each\n # candidate het. site.\n # e.g., if ALT=G and alleles_site1=['A', 'G']\n # then alt_hap_1 = 1. if ALT=A, then alt_hap_1 = 0\n if \",\" in str(site1.row['alt']) or \\\n \",\" in str(site2.row['alt']):\n sys.stderr.write(\"WARNING: Skipping candidate for sample\"\n \" %s b/c variants with mult. alt.\"\n \" alleles are not yet supported. The sites are:\"\n \" %s and %s.\\n\" % (sample, site1, site2))\n continue\n\n alt_hap_1 = alleles_site1.index(site1.row['alt'])\n alt_hap_2 = alleles_site2.index(site2.row['alt'])\n\n # report if \n # 1. phasing is considered AND the alt alleles are on\n # different haplotypes\n # OR\n # 2. the user doesn't care about phasing.\n if (not args.ignore_phasing and alt_hap_1 != alt_hap_2) \\\n or args.ignore_phasing:\n print \\\n \"\\t\".join([str(subjects_dict[sample].family_id), \n sample,\n str(comp_het_id),\n str(site1.row)])\n print \\\n \"\\t\".join([str(subjects_dict[sample].family_id), \n sample,\n str(comp_het_id),\n str(site2.row)])\n\n comp_het_id += 1","def proposal_target_layer(object_rois, gt_objects, gt_relationships, gt_regions,\n num_classes, voc_sign):\n\n # object_rois: (1 x H x W x A, 5) [0, x1, y1, x2, y2]\n # region_rois: (1 x H x W x A, 5) [0, x1, y1, x2, y2]\n # gt_objects: (G_obj, 5) [x1 ,y1 ,x2, y2, obj_class] float\n # gt_relationships: (G_obj, G_obj) [pred_class] int (-1 for no relationship)\n # gt_regions: (G_region, 4+40) [x1, y1, x2, y2, word_index] (imdb.eos for padding)\n # # gt_ishard: (G_region, 4+40) {0 | 1} 1 indicates hard\n # # dontcare_areas: (D, 4) [ x1, y1, x2, y2]\n # n_classes_obj\n # n_classes_pred\n # is_training to indicate whether in training scheme\n # overlaps: (rois x gt_boxes)\n ########################\n ## sample object ROIs ##\n ########################\n num_images = 1\n object_rois_per_image = cfg.TRAIN.BATCH_SIZE / num_images\n object_keep_inds, object_gt_assignment, object_fg_indicator, object_fg_duplicate = \\\n _sample_rois(object_rois[:, 1:5], gt_objects[:, :4], object_rois_per_image, cfg.TRAIN.FG_FRACTION)\n object_labels = gt_objects[object_gt_assignment, 4]\n # Clamp labels for the background RoIs to 0\n object_labels[np.logical_not(object_fg_indicator)] = 0\n object_selected_rois = object_rois[object_keep_inds]\n\n\n object_bbox_targets_temp = bbox_transform(object_selected_rois[:, 1:5], gt_objects[object_gt_assignment, :4])\n object_bbox_target_data = np.hstack(\n (object_labels[:, np.newaxis], object_bbox_targets_temp)).astype(np.float32, copy=False)\n object_bbox_targets, object_bbox_inside_weights = \\\n _get_bbox_regression_labels(object_bbox_target_data, num_classes)\n\n ##########################\n ## sample relationships ##\n ##########################\n\n\n rel_per_image = int(cfg.TRAIN.BATCH_SIZE_RELATIONSHIP / num_images)\n rel_bg_num = rel_per_image\n object_fg_inds = object_keep_inds[object_fg_indicator]\n if object_fg_inds.size > 0:\n id_i, id_j = np.meshgrid(xrange(object_fg_inds.size), xrange(object_fg_inds.size), indexing='ij') # Grouping the input object rois\n id_i = id_i.reshape(-1)\n id_j = id_j.reshape(-1)\n pair_labels = gt_relationships[object_gt_assignment[id_i], object_gt_assignment[id_j]]\n fg_id_rel = np.where(pair_labels > 0)[0]\n rel_fg_num = fg_id_rel.size\n rel_fg_num = int(min(np.round(rel_per_image * cfg.TRAIN.FG_FRACTION_RELATIONSHIP), rel_fg_num))\n # print 'rel_fg_num'\n # print rel_fg_num\n if rel_fg_num > 0:\n fg_id_rel = npr.choice(fg_id_rel, size=rel_fg_num, replace=False)\n else:\n fg_id_rel = np.empty(0, dtype=int)\n rel_labels_fg = pair_labels[fg_id_rel]\n sub_assignment_fg = id_i[fg_id_rel]\n obj_assignment_fg = id_j[fg_id_rel]\n sub_list_fg = object_fg_inds[sub_assignment_fg]\n obj_list_fg = object_fg_inds[obj_assignment_fg]\n rel_bg_num = rel_per_image - rel_fg_num\n\n phrase_labels = np.zeros(rel_bg_num, dtype=np.float)\n sub_assignment = npr.choice(xrange(object_keep_inds.size), size=rel_bg_num, replace=True)\n obj_assignment = npr.choice(xrange(object_keep_inds.size), size=rel_bg_num, replace=True)\n if (sub_assignment == obj_assignment).any(): # an ugly hack for the issue\n obj_assignment[sub_assignment == obj_assignment] = (obj_assignment[sub_assignment == obj_assignment] + 1) % object_keep_inds.size\n\n\n\n if object_fg_inds.size > 0:\n phrase_labels = np.append(rel_labels_fg, phrase_labels, )\n sub_assignment = np.append(sub_assignment_fg, sub_assignment,)\n obj_assignment = np.append(obj_assignment_fg, obj_assignment, )\n\n object_selected_rois, region_selected_rois, mat_object, mat_relationship, mat_region = \\\n _setup_connection(object_selected_rois, nms_thres=cfg.TRAIN.REGION_NMS_THRES,\n sub_assignment_select = sub_assignment,\n obj_assignment_select = obj_assignment)\n #print '[Training] Region ROI num: {0:d}'.format(region_selected_rois.shape[0])\n region_labels, bbox_targets_region, bbox_inside_weight_region, region_assignments = \\\n _sample_regions(region_selected_rois, gt_regions, voc_sign)\n\n # assert region_labels.shape[1] == cfg.TRAIN.LANGUAGE_MAX_LENGTH\n object_labels = object_labels.reshape(-1, 1)\n phrase_labels = phrase_labels.reshape(-1, 1)\n object_fg_duplicate = np.stack([object_fg_indicator, object_fg_duplicate], axis=1)\n\n return (object_labels, object_selected_rois, object_bbox_targets, object_bbox_inside_weights, mat_object, object_fg_duplicate), \\\n (phrase_labels, mat_relationship), \\\n (region_selected_rois[:, :5], mat_region), \\\n (region_labels, bbox_targets_region, bbox_inside_weight_region, region_assignments)","def testqry_topinterpretationspergene(self):\n e = {('-', 'Benign'): 7644,\n ('BRCA2', 'Uncertain significance'): 4187,\n (('TTN', 'TTN-AS1'), 'Uncertain significance'): 3399,\n ('-', 'Uncertain significance'): 3371, # '-' means no gene defined\n ('BRCA2', 'Pathogenic'): 3300,\n ('APC', 'Uncertain significance'): 2925,\n ('BRCA1', 'Pathogenic'): 2861,\n ('TTN', 'Uncertain significance'): 2847,\n ('BRCA1', 'Uncertain significance'): 2286,\n ('ATM', 'Uncertain significance'): 2153}\n r = qry.topinterpretationspergene({}, limit=10)\n r_ = dict()\n for i in r:\n _id, ab = i['_id'], i['abundance']\n if 'gene' in _id:\n if isinstance(_id['gene'], list):\n gene = tuple(_id['gene'])\n else:\n gene = _id['gene']\n else:\n gene = '-'\n r_[(gene, _id['desc'])] = ab\n self.comparepairs(r_, e)","def fix_COO_and_NH(pdb):\n M = Molecule(pdb)\n ds = M.ds\n g = M.g\n m = Chem.MolFromPDBFile(pdb, removeHs=True) # don't use True, otherwise Error\n mc = Chem.EditableMol(m)\n q = Chem.MolFromSmarts( 'C(~[O])~[O]' )\n matches = m.GetSubstructMatches(q)\n #bom = Chem.GetAdjacencyMatrix(m,useBO=True)\n for (i,j,k) in matches:\n d1, d2 = ds[i,j], ds[i,k]\n b1 = m.GetBondBetweenAtoms(i,j)\n b2 = m.GetBondBetweenAtoms(i,k)\n if d1 < d2:\n bij = 2.0; bik = 1.0\n else:\n bij = 1.0; bik = 2.0\n mc.RemoveBond(i,j)\n mc.RemoveBond(i,k)\n mc.AddBond(i,j,bo2bt['%.1f'%bij])\n mc.AddBond(i,k,bo2bt['%.1f'%bik])\n mu = mc.GetMol()\n return mu\n # NX4, e.g., >[N+]<, >[NH+]-, >[NH2+], -[NH3+]\n #q = Chem.MolFromSmarts( '[NX4]' )\n\n # [*]~NX2, e.g., >C=[NH2+]\n\n # [*]~NX, e.g., >C=[NH+]-","def _propose_atg_on_orf(orfObj,inwpCBG): \n # donor only -> create FirstExonOnOrf (and hope for the best)\n if orfObj.has_methionine():\n # RESCAN TSS pssm sites in any case. List might have been edited\n # in exceptional cases somewhere earlier in ABFGP flow\n orfObj.scan_orf_for_pssm_tss(forced=True)\n if orfObj._tss_sites and inwpCBG:\n maxsr = inwpCBG.maximal_spanning_range(organism=inwpCBG._get_target_organism())\n minsr = inwpCBG.minimal_spanning_range(organism=inwpCBG._get_target_organism())\n firstexon_array_algpresence = PCG2codingarray(inwpCBG,inwpCBG._get_target_organism(),max(maxsr)+1)\n firstexon_array_algsimilarity = PCG2similarityarray(inwpCBG,inwpCBG._get_target_organism(),max(maxsr)+1)\n score2tssobj = []\n for tss in orfObj._tss_sites:\n tsspos = (tss.pos - orfObj.frame)/3\n exon_estim_end = max(minsr)+1\n len5p = tsspos - min(maxsr)\n len3p = exon_estim_end - tsspos\n score5P = sum(firstexon_array_algpresence[min(maxsr):tsspos])\n score3P = sum(firstexon_array_algpresence[tsspos:exon_estim_end])\n score5S = sum(firstexon_array_algsimilarity[min(maxsr):tsspos])\n score3S = sum(firstexon_array_algsimilarity[tsspos:exon_estim_end])\n if len3p > 0:\n if len5p > 0:\n scoreP = float(score3P)/float(len3p) - float(score5P)/float(len5p)\n scoreS = float(score3S)/float(len3p) - float(score5S)/float(len5p)\n elif len5p < 0:\n scoreP = float(score3P)/float(len3p) - 1.0 - float(-len5p)/50.0\n scoreS = float(score3S)/float(len3p) - 1.0 - float(-len5p)/50.0\n else:\n scoreP = float(score3P)/float(len3p)\n scoreS = float(score3S)/float(len3p)\n else:\n scoreP = -float(score5P)/float(len5p)\n scoreS = -float(score5S)/float(len5p)\n\n print \"\\t_propose_atg::\", scoreP + scoreS + tss.pssm_score, tss \n\n # append overall score and tssobj to list ONLY WHEN scoreP + scoreS > 0\n if scoreP + scoreS > 0:\n score2tssobj.append( ( scoreP + scoreS + tss.pssm_score, tss ) )\n #print \"\\t\", tss, tsspos, scoreP, scoreS, (len5p,len3p), (score5P,score3P),(score5S,score3S),\n #print sum(firstexon_array_algpresence), sum(firstexon_array_algsimilarity), len(firstexon_array_algsimilarity)\n\n if score2tssobj:\n # get highest scoring TSS\n score2tssobj.sort()\n score2tssobj.reverse()\n atg = score2tssobj[0][1]\n else:\n # no sensible Methionine/StartSite\n atg = False\n elif orfObj._tss_sites: \n # no inwpCBG applied -> return first tss in line\n atg = orfObj._tss_sites[0] \n else:\n # get first Methionine coordinate\n atg = orfObj.potential_start_nt_positions()[0]\n # return this TSS object or ATG coordinate\n return atg\n else:\n # no methionines -> Orf can never become first one...\n return False","def do_go_analysis(go_data, genes, p_value_threshold, method='weight', elim_cut_off=0.01):\n\n # update the go data with the given genes\n go_data = update_go_data(go_data, genes)\n\n # get the significant groups\n if 'weight' == method:\n test_stat = r.new(\n \"weightCount\",\n testStatistic=r.GOFisherTest,\n name=\"Fisher test\",\n sigRatio=\"ratio\"\n )\n elif 'classic' == method:\n test_stat = r.new(\n \"classicCount\",\n testStatistic=r.GOFisherTest,\n name=\"Fisher test\"\n )\n elif 'elim' == method:\n test_stat = r.new(\n \"elimCount\",\n testStatistic=r.GOFisherTest,\n name=\"Fisher test\",\n cutOff = elim_cut_off\n )\n else:\n raise ValueError('%s: Unknown topGO method' % method)\n sig_groups = r.getSigGroups(go_data, test_stat)\n\n args = {method : sig_groups}\n results_unthresholded = r.GenTable(\n go_data,\n #ranksOf=\"classic\",\n orderBy=method,\n **args\n )\n\n # only keep those results above the threshold\n assert method == results_unthresholded.colnames()[5] # make sure looking at correct column\n # which rows are above the threshold?\n passed = rpy2.robjects.BoolVector([p_value_from_r(p) <= p_value_threshold for p in results_unthresholded[5]])\n return r.subset(results_unthresholded, passed)","def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has dimensions:\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\n coverage = np.hstack(i for i in self.coverage_matrices)\n print coverage\n print coverage.shape \n \n #Diagonal matrix of the values of each target\n #(for the scenarios where we don't care about maximizing covered value,\n #target_values is just all ones, so this is just the identity matrix)\n V = np.diag(self.target_values)\n \n #If doing scenario where we want to fortify weakest link, only makes\n #sense if all targets are equal value:\n if self.objective_type == 'min_entries':\n V = np.eye(len(self.target_values))\n\n #Get the matrix of coverage values / expected value saved:\n C = np.dot(V,coverage)\n print 'V', V\n print 'coverage', coverage\n print 'C', C\n \n \n #Since not gauranteed to reach global optimum on any particular initialization,\n #run a few times and take the best result.\n #Just define \"best result\" as the result which had the most overall \n #\"converged\" x, combined over all tower kinds. \n# for j in xrange(self.N_random_starts_max):\n \n \n a = 2. #1.\n tau = 1e-4\n N = sum(i for i in self.N_tower_sites)\n w = np.zeros(N)\n ones = np.ones(N)\n p = 1. #the exponents power when doing he exponent method:\n \n for i in xrange(self.N_reweighting_iterations_max):\n #The concatenated vector of occupancies: Concatenated over all\n #of the kinds of towers.\n x = cvx.Variable(N)\n \n #Different objective functions depending on which optimization problem.\n #These are defined in the scenarios in the main function.\n if self.objective_type == 'min_entries':\n operation = cvx.min_entries\n elif self.objective_type == 'sum_entries':\n operation = cvx.sum_entries\n else:\n raise Exception('must specify valid objective_type')\n \n #Objective function includes penalty term for non-binary x values\n if self.penalty_type == 'reweighted_L1':\n #objective = cvx.Maximize(t - x.T*w)\n objective = cvx.Maximize(operation(C*x - x.T*w))\n\n\n #Main constraints on 0<=x<=1\n constraints = [0<=x, x<=1]\n \n \n #And then for each kind of tower, append the constraint that there\n #be exactly N_i towers, or <= quota (depending on constraint type)\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n print before_sum\n print before_sum + self.N_tower_sites[tk]\n if self.constraints__type == 'fixed_N_towers':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )==self.N_towers[tk])\n elif self.constraints__type == 'tower_quotas':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )<=self.budget__tower_quotas[tk])\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\n \n elif self.constraints__type == 'total_cost':\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \n \n \n \n\n\n \n \n print 'penalty_type', self.penalty_type\n print 'objective_type', self.objective_type\n print 'constraints__type', self.constraints__type\n print 'budget__tower_quotas', self.budget__tower_quotas\n print 'operation', operation\n print 'objective', objective\n print 'constraints', constraints\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\n x = np.array(x.value).flatten()\n print 'x', x\n w = a/(tau+np.abs(x))\n p += 1.\n plt.figure(figsize=(5,5))\n plt.plot(x,marker='o')\n plt.savefig('histrograms_{}.png'.format(i))\n print \n \n \n \n \n #From the solution x, get the coordinates of those tower sites where we\n #really do want to place a tower\n #use = np.isclose(x,1.)\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\n inds = np.argsort(y)\n s = y[inds]\n use = np.where(s>.5)[0]\n print inds\n print s\n print use \n if self.constraints__type == 'fixed_N_towers':\n if len(use) != self.N_towers[tk]:\n print 'Solution did not converge properly. Choosing the K best towers.'\n print self.N_towers[tk], len(use)\n # use = use[-self.N_towers[tk]:]\n use = inds[-self.N_towers[tk]:]\n elif self.constraints__type == 'tower_quotas':\n pass #Just use the towers thresholded at > .5\n print use\n \n \n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])","def main():\n\n # Accept up to three command-line arguments\n input_terms = \"<input_GO_terms_file>\"\n input_annotations = \"<input_gene_associations_file>\"\n output_filename = \"<output_filename>\"\n\n\n # The first two arguments are required GO terms file ending with .obo\n # and gene association GAF file ending with .gaf\n if len(sys.argv) < 3:\n sys.exit(\"Please provide required GO terms .obo file and gene \" +\n \"assocatiion .gaf file.\")\n elif not sys.argv[1].endswith(\".obo\"):\n sys.exit(\"Please provide a GO terms .obo file.\")\n elif not sys.argv[2].endswith(\".gaf\"):\n sys.exit(\"Please provide a gene association .gaf file.\")\n else:\n input_terms = sys.argv[1]\n input_annotations = sys.argv[2]\n\n\n # Check if the provided import .obo or .gaf files exist\n if not input_terms:\n sys.exit(input_terms + \" not found. Check the file path and try again.\")\n elif not input_annotations:\n sys.exit(input_annotations + \" not found. Check the file path and try again.\")\n elif len(sys.argv) == 3:\n output_filename = \"results.tsv\"\n sys.stdout = open(\"results.tsv\", \"w\")\n elif len(sys.argv) == 4:\n output_filename = sys.argv[3] + \".tsv\"\n sys.stdout = open(output_filename, \"w\")\n\n\n # parse id and is_valeus and make a go_dict\n split_input_terms = split_terms(input_terms)\n go_dict = {}\n for record in split_input_terms:\n (go_id, is_a) = parse_go_term(record)\n key_go_dict = \"\".join(go_id)\n go_dict[key_go_dict] = is_a\n\n\n # Export an annotation gene information to tsv format into the output file\n gene_association_map = map_protein_to_go(input_annotations)\n for protein, go_ids in sorted(gene_association_map.items()):\n print(protein, end=\"\")\n\n for go_id in sorted(go_ids):\n parent_go_ids = find_parent_terms(go_id, go_dict)\n\n count = 0\n for parent_go_id in sorted(parent_go_ids):\n\n if count == 0:\n print(\"\\t\", go_id, \"\\t\", parent_go_id)\n count += 1\n else:\n print(\"\\t\", parent_go_id, sep=\"\\t\")\n\n sys.stdout.close()","def meshRelationships(Objects):\r\n # Create some variables to be used to store objects\r\n foreheadVariable = []\r\n noseBridgeVariable = []\r\n noseVariable = []\r\n eyeVariable = []\r\n mouthLoopVariable = []\r\n mouthVariable = []\r\n cheekVariable = []\r\n chinVariable = []\r\n earVariable = []\r\n backHeadVariable = []\r\n lowerBackHeadVariable = []\r\n\r\n # Create the relationshipList\r\n relationshipList = []\r\n\r\n for forehead in Objects:\r\n if \"TubxForehead_geo_\" in forehead:\r\n foreheadVariable.append(forehead)\r\n\r\n for noseBridge in Objects:\r\n if \"TubxNoseBridge_geo_\" in noseBridge:\r\n noseBridgeVariable.append(noseBridge)\r\n for forehead in foreheadVariable:\r\n createRelationships(relationshipList, noseBridge, forehead)\r\n\r\n for eye in Objects:\r\n if \"TubxEye_geo_\" in eye:\r\n eyeVariable.append(eye)\r\n for forehead in foreheadVariable:\r\n createRelationships(relationshipList, eye, forehead)\r\n for noseBridge in noseBridgeVariable:\r\n createRelationships(relationshipList, eye, noseBridge)\r\n\r\n for nose in Objects:\r\n if \"TubxNose_geo_\" in nose:\r\n noseVariable.append(nose)\r\n for noseBridge in noseBridgeVariable:\r\n createRelationships(relationshipList, nose, noseBridge)\r\n\r\n for mouthLoop in Objects:\r\n if \"TubxMouthLoop_geo_\" in mouthLoop:\r\n mouthLoopVariable.append(mouthLoop)\r\n for nose in noseVariable:\r\n createRelationships(relationshipList, mouthLoop, nose)\r\n\r\n for mouth in Objects:\r\n if \"TubxMouth_geo_\" in mouth:\r\n mouthVariable.append(mouth)\r\n for mouthLoop in mouthLoopVariable:\r\n createRelationships(relationshipList, mouth, mouthLoop)\r\n\r\n for cheek in Objects:\r\n if \"TubxCheek_geo_\" in cheek:\r\n cheekVariable.append(cheek)\r\n for mouthLoop in mouthLoopVariable:\r\n createRelationships(relationshipList, cheek, mouthLoop)\r\n\r\n for chin in Objects:\r\n if \"TubxChin_geo_\" in chin:\r\n chinVariable.append(chin)\r\n for mouthLoop in mouthLoopVariable:\r\n createRelationships(relationshipList, chin, mouthLoop)\r\n for cheek in cheekVariable:\r\n createRelationships(relationshipList, chin, cheek)\r\n\r\n for ear in Objects:\r\n if \"TubxEar_geo_\" in ear:\r\n earVariable.append(ear)\r\n for forehead in foreheadVariable:\r\n createRelationships(relationshipList, ear, forehead)\r\n for cheek in cheekVariable:\r\n createRelationships(relationshipList, ear, cheek)\r\n\r\n for backhead in Objects:\r\n if \"TubxBackHead_geo_\" in backhead:\r\n backHeadVariable.append(backhead)\r\n for forehead in foreheadVariable:\r\n createRelationships(relationshipList, backhead, forehead)\r\n for ear in earVariable:\r\n createRelationships(relationshipList, backhead, ear)\r\n\r\n for lowerbackhead in Objects:\r\n if \"TubxLowerBackHead_geo_\" in lowerbackhead:\r\n lowerBackHeadVariable.append(lowerbackhead)\r\n for ear in earVariable:\r\n createRelationships(relationshipList, lowerbackhead, ear)\r\n for backhead in backHeadVariable:\r\n createRelationships(relationshipList, lowerbackhead, backhead)\r\n\r\n for default in Objects:\r\n for forehead in foreheadVariable:\r\n createRelationships(relationshipList, default, forehead)\r\n for noseBridge in noseBridgeVariable:\r\n createRelationships(relationshipList, default, noseBridge)\r\n for nose in noseVariable:\r\n createRelationships(relationshipList,default,nose)\r\n for eye in eyeVariable:\r\n createRelationships(relationshipList, default, eye)\r\n for mouthLoop in mouthLoopVariable:\r\n createRelationships(relationshipList, default, mouthLoop)\r\n for mouth in mouthVariable:\r\n createRelationships(relationshipList, default, mouth)\r\n for cheek in cheekVariable:\r\n createRelationships(relationshipList, default, cheek)\r\n for chin in chinVariable:\r\n createRelationships(relationshipList, default, chin)\r\n for ear in earVariable:\r\n createRelationships(relationshipList, default, ear)\r\n for backhead in backHeadVariable:\r\n createRelationships(relationshipList, default, backhead)\r\n for lowerbackhead in lowerBackHeadVariable:\r\n createRelationships(relationshipList, default, lowerbackhead)\r\n\r\n return relationshipList","def get_imc_topo(topo_file):\n topo_graph = nx.Graph()\n with open(topo_file, 'r') as f:\n for line in f.readlines():\n if (len(line) > 10) and (line[0] != '#'):\n split_data = line.split()\n source = split_data[0]\n dest = split_data[2]\n #capacity = 1000 # We are fixing this to one.\n capacity = get_imc_capacity(split_data[1], split_data[3])\n if not topo_graph.has_edge(source, dest):\n topo_graph.add_edge(source, dest, capacity = capacity)\n # Checks graph for any componnets and returns the largest one.\n topo_graph = validate_graph(topo_graph)\n f.close()\n return topo_graph","def main():\n # files\n summary_file = sys.argv[1]\n pwms_to_tfs_file = sys.argv[2]\n expressed_tfs_file = sys.argv[3] # TODO\n\n # TODO pull in num regions to resize things? but complicated with overlaps etc\n # TODO edit edges with type of interaction\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\n \n # read in data\n summary = pd.read_csv(summary_file, sep=\"\\t\")\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\"\\t\")\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\"expressed\"].notna()]\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\n for line_idx in range(pwms_to_tfs.shape[0]):\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\n pwm_name = pwm_info[\"hclust_model_name\"]\n pwm_to_tf = dict(zip(pwm_info[\"expressed\"].split(\";\"), pwm_info[\"expressed_hgnc\"].split(\";\")))\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\n\n \n # filter expressed hgncs for dynamic ones only\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\"\\t\", index_col=0)\n for pwm_name in pwms_to_filt_tfs.keys():\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\n for ensembl_tf in tfs_tmp.keys():\n if ensembl_tf not in tfs_filt.index:\n del tfs_tmp[ensembl_tf]\n if len(tfs_tmp.keys()) == 0:\n del pwms_to_filt_tfs[pwm_name]\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\n\n # add in tfs column\n tf1 = []\n for pwm in summary[\"pwm1\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n # TODO try add in max point\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf1.append(tf_str)\n summary[\"tf1\"] = tf1\n\n tf2 = []\n for pwm in summary[\"pwm2\"]:\n tf_str = []\n for ensembl_id in pwms_to_filt_tfs[pwm]:\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\n expression = tfs_filt.loc[ensembl_id,:]\n max_idx = np.argmax(expression.values)\n tf_str.append(str(max_idx))\n tf_str = (\";\").join(tf_str)\n tf2.append(tf_str)\n summary[\"tf2\"] = tf2\n \n # remove failed rules\n summary = summary[~summary[\"interaction\"].str.contains(\"FAILED\")]\n \n # make graph\n graph = nx.from_pandas_edgelist(summary, \"tf1\", \"tf2\")\n\n # set up positions\n #pos = graphviz_layout(graph, prog=\"dot\")\n pos = graphviz_layout(graph, prog=\"neato\")\n scale_factor = 3\n for key in pos.keys():\n coords = pos[key]\n pos[key] = {\"x\": scale_factor*coords[0], \"y\": -scale_factor*coords[1]}\n nx.set_node_attributes(graph, pos, \"graphics\") # note this is diff from v1 to v2 in networkx\n \n # add graphics\n add_graphics_theme_to_nx_graph(graph)\n\n # write gml\n out_file = \"summary.gml\"\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\n\n # tfs: for each tf, get gene column\n \n \n return","def all_best_pos(potential_coverage, all_coverage, covered):\n ## get closeness to 5'\n proximity = {grna_seq: sum((hit.target_len - hit.range[1] if\n hit.target.sense == '-' else\n hit.range[0])\n for hit in hits)/len(hits)\n for grna_seq, hits in potential_coverage.items()}\n best_proximity = min(proximity.values())\n return {grna_seq: potential_coverage[grna_seq]\n for grna_seq, prox in proximity.items()\n if prox == best_proximity}","def search_a_for_genetic(env:RailEnv,randomized):\r\n schedules = []\r\n occupancy_map=[[] for i in range(len(env.agents))]\r\n\r\n n_timesteps = np.array([])\r\n state_schedule =[]\r\n conv = StateConverter(env)\r\n # Compute the transition and valid action table\r\n model = convert_to_transition(env, conv)\r\n # Calculate the shortest dist from one state to another state\r\n shortest = all_pairs_shortest_paths(conv.num_states, model[0])\r\n random_order_agent = randomized\r\n print(random_order_agent)\r\n\r\n for i in random_order_agent:\r\n # Compute occupancy map\r\n occupancy_map[i] = compute_map(i, random_order_agent, n_timesteps, state_schedule, conv)\r\n\r\n # Compute schedule for each agent based on the occupancy map\r\n each_schedule = a_star_search(SearchEnv(env,conv,model,shortest,i).get_root_node(),occupancy_map[i])\r\n #print(each_schedule)\r\n schedules.append(each_schedule[0])\r\n state_schedule.append(each_schedule[1])\r\n n_timesteps = np.append(n_timesteps, [len(each_schedule[1])])\r\n\r\n # Combine separate actions into a list\r\n actions = combine(schedules,random_order_agent,int(np.max(n_timesteps)))\r\n\r\n return actions","def get_eco_details(self, pgn_data):\n result = eco_mapping['unknown']\n\n try:\n moves = self.get_moves(pgn_data)\n current_sequence = ''\n\n for move in moves:\n half_move = '.'.join([move[0], move[1]])\n current_sequence += half_move\n\n if current_sequence in eco_mapping:\n result = eco_mapping[current_sequence]\n else:\n break\n\n current_sequence = ' '.join([current_sequence, move[2]])\n\n if current_sequence in eco_mapping:\n result = eco_mapping[current_sequence]\n else:\n break\n\n current_sequence += ' '\n except:\n pass\n\n return result","def detect_primary_objects(gray, haar_file, params, num_primary_obj=1, max_iter=10, boost_flag=True, verbose=False):\n haar_cascade = cv.CascadeClassifier(haar_file)\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\n num_detected = len(detected_objects)\n num_detected_prev = num_detected\n if verbose:\n print(f\"Initial # of Objects Detected = {num_detected}\")\n num_iter = 0\n boost_factor = 1\n while num_detected != num_primary_obj and num_iter != max_iter:\n num_iter += 1\n if verbose:\n print(f\"Iteration # = {num_iter}\")\n # Update minNeighbors value in copy of params dict\n if num_iter == 1:\n params_new = params.copy()\n elif num_iter == max_iter:\n print(f\"Maximum # of iterations ({max_iter}) reached!\")\n # Change minNeighbors up/down depending on whether num detected is too high/low\n # Steps up are twice as big as steps down, and boost_factor determines step size\n if num_detected < num_primary_obj and params_new['minNeighbors'] > 4:\n params_new['minNeighbors'] -= boost_factor\n elif num_detected < num_primary_obj and params_new['minNeighbors'] > 1:\n params_new['minNeighbors'] -= 1 \n elif num_detected > num_primary_obj:\n params_new['minNeighbors'] += 2 * boost_factor\n else:\n print(f\"Unable to detect {num_primary_obj} primary object(s) in input image\")\n print(f\"Verify that either 1) num_detected is zero ({num_detected==0}) and minNeighbors is one ({params_new['minNeighbors']==1})\")\n print(f\"OR 2) the maximum # of iterations has been reached ({num_iter==max_iter})\")\n print(\"If either of these scenarios occurs, consider changing the input scaleFactor and/or initial minNeighbors value. If neither 1) or 2) applies, then there is an unknown bug somewhere that should be investigated!!!\")\n if verbose:\n print(f\"minNeighbors = {params_new['minNeighbors']}\")\n detected_objects = haar_cascade.detectMultiScale(gray, **params_new)\n num_detected = len(detected_objects)\n if num_detected == num_detected_prev and boost_flag:\n boost_factor += 1\n else:\n boost_factor = 1\n num_detected_prev = num_detected\n if verbose:\n print(f\"Final # of Objects Detected = {num_detected}\")\n return detected_objects","def main():\n # get commmand line args\n args = parse_arguments()\n \n adj_file = args.adj # open(\"UCSC_VIPER/pathways/extended_pathways_transcriptional.adj\", \"r\")\n \n # this set isn't actually used in the script, but I was curious...\n adj_gene_set = set() \n \n cutoff_number = args.cutoff_number\n #cutoff_percent = args.cutoff_percent\n \n expr_gene_file = args.expr_genes #open(\"stanford_batchK1-12.HUGO_only_genes.lst\", 'r')\n expr_genes = [line.strip() for line in expr_gene_file] \n \n # for each line, check that the regulator and other genes are in the\n # expression matrix gene set. if not, remove them, or remove the whole\n # line if the regulator isn't in the set or if too few genes remain\n for line in adj_file:\n \n line_list = line.strip().split()\n regulator_plus_gene_list = [x for x in line_list if x !=\"1.0\"]\n regulator = regulator_plus_gene_list[0]\n \n if regulator not in expr_genes:\n # remove the whole regulator + regulon\n print(\"Skipped a line (regulator not in expr genes): \", \n line_list[0], file=sys.stderr) \n continue\n \n gene_list = regulator_plus_gene_list[1:]\n list_size = len(gene_list)\n adj_gene_set.update(gene_list)\n \n how_many_to_remove= 0\n good_genes = []\n \n for gene in gene_list:\n if gene not in expr_genes:\n how_many_to_remove += 1\n else:\n good_genes.append(gene)\n \n #print(\"\\n\")\n #pdb.set_trace()\n #if (100-how_many_to_remove/list_size*100 < cutoff_percent) and (list_size-how_many_to_remove < cutoff_number):\n if (list_size-how_many_to_remove < cutoff_number):\n print(\"Skipped a line (too many removed): \", line_list[0], file=sys.stderr)\n \n else:\n # re-generate the new line of the .adj file with kept genes\n #genes_to_print = good_genes.insert(0, regulator)\n regulated_genes = \"\\t1.0\\t\".join(good_genes)\n print(regulator+\"\\t\"+regulated_genes+\"\\t1.0\")","def discover_structure_from_pops(self, pops, data):\n\n def create_maximal_pgm(pops):\n pgm = nx.DiGraph()\n pgm.add_nodes_from(pops) # create nodes\n for node in pops:\n edges = [(parent, node) for parent in pops.get(node) if\n node.rsplit('_', 1)[0] != parent.rsplit('_', 1)[0]]\n pgm.add_edges_from(edges) # add edges\n return pgm\n\n def markov_blanket(graph, parent_node, node):\n mb = set(pa for pa in graph.predecessors(node)) # add parent nodes\n mb |= set(ch for ch in graph.successors(node)) # add child nodes\n for child in graph.successors(node): # add parents of children\n mb |= set(pa for pa in graph.predecessors(child))\n if node in mb: # remove node\n mb.remove(node)\n if parent_node in mb: # remove parent_node\n mb.remove(parent_node)\n return mb\n\n max_pgm = create_maximal_pgm(pops)\n\n if self.draw:\n plt.title('Maximal PGM (only intra-edges)')\n signal_pos_map = {}\n pos = {}\n for node in max_pgm.nodes:\n if node.rsplit('_', 1)[0] not in signal_pos_map:\n signal_pos_map.update({node.rsplit('_', 1)[0]: len(signal_pos_map)})\n x_coordinate = int(node[-1:])\n y_coordinate = signal_pos_map.get(node.rsplit('_', 1)[0])\n pos.update({node: [x_coordinate, y_coordinate]})\n nx.draw(max_pgm, pos=pos, with_labels=True)\n plt.show()\n pass\n\n if isinstance(data, ADTree):\n cb_estimator = GSquareEstimator(adtree=data)\n else:\n cb_estimator = BaseEstimator(data=data, complete_samples_only=False)\n # procedure similar to PC algorithm\n pgm = max_pgm.copy()\n condition_set_size = 0\n L().log.debug('---------------------------------------------------')\n L().log.debug('---- Conditional Independence Tests ---------------')\n L().log.debug('---------------------------------------------------')\n\n #\n if self.optimization_chi_square:\n import scipy.stats as scs\n def chi_square_of_df_cols(df, col1, col2):\n df_col1, df_col2 = df[col1], df[col2]\n categories_2 = list(df_col2.unique())\n categories_1 = list(df_col1.unique())\n result = [[sum((df_col1 == cat1) & (df_col2 == cat2))\n for cat2 in categories_2]\n for cat1 in categories_1]\n\n chi = scs.chi2_contingency(result)\n\n\n return chi\n\n remove_edges = []\n for (source, target) in pgm.edges():\n # check how correlated those two edges are / independent of MB and all the other stuff\n dat = chi_square_of_df_cols(self.data, source, target) # 1 = more corr. 0 = less corr.\n chi2, p, sufficient_data = dat[0], dat[1], dat[2]\n #print(\"%s Chi = %s, p=%s\" % (str([source, target]), str(chi2), str(p)))\n\n if chi2 < self.chi_square_thresh and pgm.has_edge(source, target):\n L().log.debug('remove edge ' + str((source, target)))\n remove_edges.append((source, target))\n pgm.remove_edges_from(remove_edges)\n #import sys\n #sys.exit(0)\n\n\n # additionally remove edges which are conditionally independent\n # e.g. given a-> b c->b and given a, c is independent of b, then I can remove c!!!\n remove_edges = []\n for (source, target) in pgm.edges():\n condition_set = [a for a in pgm.predecessors(target) if a != source]\n if not condition_set:continue\n _, p_val, _ = cb_estimator.test_conditional_independence(source, target, list(condition_set))\n if p_val > self.alpha:\n if pgm.has_edge(source, target):\n L().log.debug('remove edge ' + str((source, target)))\n remove_edges.append((source, target))\n pgm.remove_edges_from(remove_edges)\n\n else:\n while True:\n cont = False\n remove_edges = []\n for (source, target) in pgm.edges():\n mb = markov_blanket(pgm, target, source)\n if len(mb) >= condition_set_size:\n L().log.debug('testing ' + source + ' --> ' + target)\n L().log.debug('markov blanket of ' + source + ' is ' + str(mb))\n for condition_set in combinations(mb, condition_set_size):\n L().log.debug(\n 'independence test of ' + source + ' and ' + target + ' with subset ' + str(condition_set))\n _, p_val, _ = cb_estimator.test_conditional_independence(source, target, list(condition_set))\n #if isnan(p_val): # pgmpy CI test returns NaN instead of 1\n # p_val = 1\n L().log.debug('p_val = ' + str(p_val))\n if p_val > self.alpha:\n if pgm.has_edge(source, target):\n L().log.debug('remove edge ' + str((source, target)))\n remove_edges.append((source, target))\n break\n pass\n cont = True\n pass\n condition_set_size += 1\n pgm.remove_edges_from(remove_edges)\n if cont is False:\n break\n if condition_set_size > self.max_reach:\n break\n\n if self.draw:\n plt.title('PGM after CI tests (only inter-edges)')\n signal_pos_map = {}\n pos = {}\n for node in pgm.nodes:\n if node.rsplit('_', 1)[0] not in signal_pos_map:\n signal_pos_map.update({node.rsplit('_', 1)[0]: len(signal_pos_map)})\n x_coordinate = int(node[-1:])\n y_coordinate = signal_pos_map.get(node.rsplit('_', 1)[0])\n pos.update({node: [x_coordinate, y_coordinate]})\n nx.draw(pgm, pos=pos, with_labels=True)\n plt.show()\n pass\n\n nodes = list(pops.keys())\n edges = [list(edge) for edge in pgm.edges]\n return nodes, edges","def pick_gynodioecious_parents(simu, config):\n rng = simu.getRNG()\n runif = rng.randUniform\n rint = rng.randInt\n try:\n sstar = config.sstar\n H = config.H\n def compound_generator(pop):\n \"\"\"\n Picks up parent(s) under gynodioecy using compound parameters.\n \"\"\"\n gen = -1\n while True:\n ngen = pop.dvars().gen\n if gen != ngen:\n # At the beginning of a generation, extract the\n # sex-specific subpopulations from a parental\n # population. The sex-specific subpopulations are used\n # throughout mating events in one generation.\n gen = ngen\n h = pop.extractSubPops(subPops=[(0, 0)])\n f = pop.extractSubPops(subPops=[(0, 1)])\n Nh = h.popSize()\n Nf = f.popSize()\n\n if runif() < sstar: # uniparental\n yield h.individual(rint(Nh))\n else: # biparental\n if runif() < H: # having a hermaphroditic seed parent\n first, second = rint(Nh), rint(Nh)\n while first == second:\n second = rint(Nh)\n yield [h.individual(first), h.individual(second)]\n else: # female seed parent\n yield [h.individual(rint(Nh)), f.individual(rint(Nf))]\n return compound_generator\n except KeyError:\n a = config.a\n sigma = config.sigma\n tau = config.tau\n def fundamental_generator(pop):\n \"\"\"\n Picks up parent(s) under gynodioecy using fundamental parameters.\n \"\"\"\n gen = -1\n while True:\n ngen = pop.dvars().gen\n if gen != ngen:\n # At the beginning of a generation, extract the\n # sex-specific subpopulations from a parental\n # population. The sex-specific subpopulations are used\n # throughout mating events in one generation.\n gen = ngen\n h = pop.extractSubPops(subPops=[(0, 0)])\n f = pop.extractSubPops(subPops=[(0, 1)])\n Nh = h.popSize()\n Nf = f.popSize()\n hermseed = Nh / (Nh * Nf * sigma)\n\n if runif() < hermseed: # hermaphroditic seed parent\n if runif() < a: # self-pollen\n yield h.individual(rint(Nh))\n else: # non self-pollen\n first, second = rint(Nh), rint(Nh)\n while first == second:\n second = rint(Nh)\n yield [h.individual(first), h.individual(second)]\n else: # female seed parent\n if runif() < tau:\n yield [h.individual(rint(Nh)), f.individual(rint(Nf))]\n return fundamental_generator","def get_gene_methylation(ensemble, methylation_type, gene, grouping, clustering, level, outliers, tsne_type='mCH_ndim2_perp20', \n\tmax_points='10000'):\n\n\t# Prevent SQL injected since column names cannot be parameterized.\n\tif \";\" in ensemble or \";\" in methylation_type or \";\" in grouping or \";\" in clustering or \";\" in tsne_type:\n\t\treturn None\n\n\t# This query is just to fix gene id's missing the ensemble version number.\n\t# Necessary because the table name must match exactly with whats on the MySQL database.\n\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\n\tresult = db.get_engine(current_app, 'methylation_data').execute(\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\", (gene+\"%\",)).fetchone()\n\tgene_table_name = 'gene_' + result.gene_id.replace('.','_')\n\n\tcontext = methylation_type[1:]\n\tif grouping in ['annotation','cluster']:\n\t\tgroupingu = ensemble+\".\"+grouping+\"_\"+clustering\n\telif grouping in ['NeuN']:\n\t\tgroupingu = \"CONCAT('NeuN',cells.\"+grouping+\")\"\n\telif grouping in ['dataset','sex','brain_region','target_region']:\n\t\tgroupingu = \"datasets.\"+grouping\n\telif grouping in ['broad_brain_region']:\n\t\tgroupingu = \"ABA_regions.ABA_broad_acronym\"\n\telse:\n\t\tgroupingu = \"cells.\"+grouping\n\n\tensemble = ensemble.replace('EnsEns','Ens')\n\n\tif 'ndim2' in tsne_type:\n\t\tquery = \"SELECT cells.cell_id, cells.dataset, %(ensemble)s.cluster_%(clustering)s, datasets.target_region, \\\n\t\t\t%(ensemble)s.annotation_%(clustering)s, %(gene_table_name)s.%(methylation_type)s, \\\n\t\t\tcells.global_%(methylation_type)s, %(groupingu)s as grouping, \\\n\t\t\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, \\\n\t\t\t%(gene_table_name)s.%(context)s, datasets.sex \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \\\n\t\t\tLEFT JOIN ABA_regions ON datasets.brain_region=ABA_regions.ABA_acronym\" % {'ensemble': ensemble, 'groupingu': groupingu,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'tsne_type': tsne_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'methylation_type': methylation_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'context': context,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'clustering': clustering,}\n\telse:\n\t\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, cells.global_%(methylation_type)s, \\\n\t\t\t%(ensemble)s.annotation_%(clustering)s, %(ensemble)s.cluster_%(clustering)s, \\\n\t\t\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, %(ensemble)s.tsne_z_%(tsne_type)s, \\\n\t\t\t%(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s, \\\n\t\t\tdatasets.target_region, datasets.sex \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'tsne_type': tsne_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'methylation_type': methylation_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'context': context,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'clustering': clustering,}\n\tif max_points.isdigit():\n\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s\" % {'max_points': max_points}\n\t\t# TODO: Check whether we need to randomize the rows\n\n\ttry:\n\t\tdf = pd.read_sql(query, db.get_engine(current_app, 'methylation_data'))\n\texcept exc.ProgrammingError as e:\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_methylation): {}\".format(str(now), e))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tif df[context].isnull().all(): # If no data in column, return None\n\t\treturn None\n\n\tif level == 'original':\n\t\tdf[methylation_type + '/' + context + '_' + level] = df[methylation_type] / df[context]\n\telse:\n\t\tdf[methylation_type + '/' + context + '_' + level] = (df[methylation_type] / df[context]) / df['global_'+methylation_type]\n\n\tif not outliers:\n\t\t# Outliers not wanted, remove rows > 99%ile\n\t\tthree_std_dev = df[methylation_type + '/' + context + '_' + level].quantile(0.99)\n\t\tdf = df[df[methylation_type + '/' + context + '_' + level] < three_std_dev]\n\n\n\tif grouping == 'annotation':\n\t\tdf.fillna({'grouping': 'None'}, inplace=True)\n\t\tdf['annotation_cat'] = pd.Categorical(df['grouping'], cluster_annotation_order)\n\t\tdf.sort_values(by='annotation_cat', inplace=True)\n\t\tdf.drop('annotation_cat', axis=1, inplace=True)\n\telif grouping == 'cluster':\n\t\tdf.sort_values(by='cluster_'+clustering, inplace=True)\n\n\t# # Add number of cells in each cluster to the cluster name\n\t# ncells = df.groupby(by=grouping, sort=False).count()\n\t# for label, i in df[grouping]:\n\t# ncells[0]\n\n\treturn df","def getNet(chrom, loops, genes, pdis=2000, gap=1):\n #step 1 get merged anchors\n anchors = stichAnchors(chrom, loops, margin=gap)\n #step 2 annotate anchors\n nanchors = {}\n ts = np.array([[tss] for tss in genes.keys()])\n tree = KDTree(ts)\n for anchor in anchors:\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\n anchor.end)\n if len(gs) > 1:\n t = \"Promoter\"\n d = 0\n else:\n d = ds[0]\n if abs(d) <= pdis:\n t = \"Promoter\"\n else:\n t = \"Enhancer\"\n n = anchor.chrom + \":\" + str(anchor.start) + \"-\" + str(\n anchor.end) + \"|\" + t\n nanchors[n] = {\n \"chrom\":\n anchor.chrom,\n \"start\":\n anchor.start,\n \"end\":\n anchor.end,\n \"type\":\n n.split(\"|\")[-1],\n \"nearestDistanceToTSS\":\n d,\n \"nearestGene\":\n \",\".join([g.name for g in gs]),\n \"nearestGeneLoc\":\n \",\".join([\n g.chrom + \":\" + str(g.start) + \"-\" + str(g.end) + \"|\" +\n g.strand + \"|\" + g.name for g in gs\n ])\n }\n anchors = nanchors\n del nanchors\n #step 3 assign each anchor to merged annotated anchor and build the network\n anchorCov = {}\n for k, v in anchors.items():\n for i in range(v[\"start\"], v[\"end\"] + 1):\n anchorCov[i] = k\n ds = {} #anchor annotations\n nets = {} #net information\n G = nx.Graph() #networkx graph structure\n for loop in loops:\n xt, yt = None, None\n for i in range(loop.x_start, loop.x_end + 1):\n if i in anchorCov:\n xt = anchorCov[i]\n break\n for i in range(loop.y_start, loop.y_end + 1):\n if i in anchorCov:\n yt = anchorCov[i]\n break\n ds[loop.id] = {\n \"mergedAnchorA\": xt,\n \"mergedAnchorB\": yt,\n }\n if xt == yt:\n continue\n ns = [xt, yt]\n ns.sort() #sort for converging keys\n if ns[0] not in nets:\n nets[ns[0]] = set()\n nets[ns[0]].add(ns[1])\n #network edges\n G.add_edge(ns[0], ns[1])\n #step 4 find all enhancers linked to target gene\n targets = {}\n #step 4.1 find the direct enhancer that link to promoter\n for node in G.nodes:\n if node.split(\"|\")[-1] == \"Promoter\":\n if node in targets:\n continue\n targets[node] = {\n \"targetGene\": anchors[node][\"nearestGeneLoc\"],\n \"directEnhancer\": set(),\n \"indirectEnhancer\": set(),\n \"directPromoter\": set(),\n \"indirectPromoter\": set()\n }\n ns = list(nx.descendants(G, node))\n #find all releated nodes\n for n in ns:\n p = nx.algorithms.shortest_path(G, source=node, target=n)\n if n.split(\"|\")[-1] == \"Promoter\":\n if len(p) == 2:\n targets[node][\"directPromoter\"].add(n)\n else:\n targets[node][\"indirectPromoter\"].add(n)\n if n.split(\"|\")[-1] == \"Enhancer\":\n if len(p) == 2:\n targets[node][\"directEnhancer\"].add(n)\n else:\n targets[node][\"indirectEnhancer\"].add(n)\n #step 4.2. find hub enhancer\n #only using non-redundant node to find hubs\n nns = []\n tmp = set()\n for n in ns:\n tn = n.split(\"|\")[0]\n if tn not in tmp:\n nns.append(n)\n tmp.add(tn)\n ns = list(nns)\n ns.append(node)\n subg = G.subgraph(ns)\n try:\n hubs, authorities = nx.hits(subg,\n max_iter=1000,\n normalized=True)\n except:\n print(\n \"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\"\n % node)\n targets[node][\"directEnhancerHub\"] = \"\"\n targets[node][\"indirectEnhancerHub\"] = \"\"\n continue\n hubs = pd.Series(hubs)\n hubs = hubs.sort_values(inplace=False, ascending=False)\n if len(targets[node][\"directEnhancer\"]) >= 2:\n des = hubs[list(targets[node][\"directEnhancer\"])]\n des = des.sort_values(inplace=False, ascending=False)\n targets[node][\"directEnhancerHub\"] = des.index[0]\n else:\n targets[node][\"directEnhancerHub\"] = \"\"\n if len(targets[node][\"indirectEnhancer\"]) >= 2:\n indes = hubs[list(targets[node][\"indirectEnhancer\"])]\n indes = indes.sort_values(inplace=False, ascending=False)\n targets[node][\"indirectEnhancerHub\"] = indes.index[0]\n else:\n targets[node][\"indirectEnhancerHub\"] = \"\"\n return anchors, ds, nets, targets","def identify_expressed_gRNA_families(gRNAs, mRNAs, init_seq_len):\n gRNA_families = {'family_no':[], 'family_end':[], 'family_id':[]}\n strand_name = {'coding':'', 'template':'t'}\n index = []\n\n gRNAs['gene_mRNA_end'] = gRNAs['mRNA_end']+gRNAs['rel_pos'].apply(lambda x: 0 if x is pd.NA else x)\n gRNAs['gene_mRNA_end'] = gRNAs['gene_mRNA_end'].astype('Int32')\n gRNAs['tmp'] = gRNAs.apply(lambda x: x['cassette_label']+strand_name[x['strand']], axis=1)\n\n for mRNA_name, mRNA in sorted(mRNAs.items()):\n # get all gRNAs with an init_pos for this mRNA\n # nonexpressed gRNAs can be in an editing group if they have a init_seq. this is because\n # they have transcripts in the init_position but not enough to be called expressed\n # gRNAs without an init_seq have no transcripts within the initiation site\n # these are added to a group below\n mask1 = gRNAs['mRNA_name'] == mRNA_name\n mask2 = gRNAs['init_seq'].notnull()\n g = gRNAs[mask1 & mask2]\n\n # positions where the start of expressed gRNAs align to mRNA\n a = np.zeros(mRNA['length']+100)\n i = np.array(g['gene_mRNA_end']-1, dtype=int)\n for ii in range(init_seq_len):\n a[i-ii] = 1\n a = ''.join([str(int(i)) for i in a])\n g_end = 'gene_mRNA_end'\n\n tmp_g = []\n family_no = 0\n\n # find regions where groups of gRNAs anchor to mRNA starting from 3' end of edited mRNA\n for m in re.finditer('1+', a):\n s, e = m.start(0), m.end(0)\n # get all gRNAs that anchor at this region\n anchor_group = g[(g[g_end] >= s) & (g[g_end] <= e)]\n\n if len(anchor_group) == 0:\n continue\n\n # for each cassette position of these gRNAs create a dictionary of cassette position and editing position\n cas_pos = {}\n for _, gRNA in anchor_group.iterrows():\n pos = gRNA['tmp']\n if pos not in cas_pos:\n cas_pos[pos] = gRNA[g_end]\n cas_pos[pos] = max(gRNA[g_end], cas_pos[pos])\n\n # group gRNAs with the same cassette position ordered by editing position\n for pos, end in sorted(cas_pos.items(), key=lambda kv: kv[1]):\n group = anchor_group.query('tmp == @pos')\n index.extend(group.index.values)\n gRNA_families['family_no'].extend([family_no]*len(group))\n gRNA_families['family_end'].extend([end]*len(group))\n gRNA_families['family_id'].extend([f'{mRNA_name}-{pos}-{int(end)}']*len(group))\n tmp_g.append((family_no, end, f'{mRNA_name}-{pos}-{int(end)}'))\n family_no += 1\n\n # gRNAs without an init_seq\n mask2 = gRNAs['init_seq'].isnull()\n unknown = gRNAs[mask1 & mask2]\n # for each unknown gRNA\n for idx, gRNA in unknown.iterrows():\n # search for a group that ends just after mRNA_end of this unknown gRMA\n for f_no, gene_mRNA_end, family_id in sorted(tmp_g, key=itemgetter(1)):\n [g_mRNA_name, g_pos, g_end] = family_id.split('-')\n if g_mRNA_name == mRNA_name and gRNA['mRNA_end']-1 <= gene_mRNA_end and gRNA['cassette_label'] == g_pos:\n index.append(idx)\n gRNA_families['family_no'].append(f_no)\n gRNA_families['family_end'].append(gene_mRNA_end)\n gRNA_families['family_id'].append(f'{family_id}')\n break\n else:\n # no suitable gRNA found, so make a unique family for this non-expressed gRNA \n index.append(idx)\n gRNA_families['family_no'].append(family_no)\n gRNA_families['family_end'].append(gRNA['mRNA_end'])\n gRNA_families['family_id'].append(f'{mRNA_name}-{gRNA[\"cassette_label\"]}-{gRNA[\"mRNA_end\"]}')\n family_no += 1\n\n gRNAs = gRNAs.drop(['tmp'], axis=1)\n gRNAs = gRNAs.join(pd.DataFrame(gRNA_families, index=index))\n gRNAs['family_no'] = gRNAs['family_no'].astype('Int64')\n gRNAs['family_end'] = gRNAs['family_end'].astype('Int64')\n return gRNAs","def consolidation_heuristics(to_print = False):\n # Instantiate the data problem.\n data = create_data_model()\n # Create the routing index manager.\n manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),\n data['num_vehicles'], data['depot'])\n # Create Routing Model.\n routing = pywrapcp.RoutingModel(manager)\n # Create and register a transit callback.\n def distance_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return data['distance_matrix'][from_node][to_node]\n def pending_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return data['post'][to_node]\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n pending_callback_index = routing.RegisterTransitCallback(pending_callback)\n # Define cost of each arc.\n for i in range(data['num_vehicles']-1):\n routing.SetArcCostEvaluatorOfVehicle(transit_callback_index, i) #Transit cost\n routing.SetFixedCostOfVehicle(data['fixed_cost'], i) #Fixed cost\n routing.SetArcCostEvaluatorOfVehicle(pending_callback_index, data['num_vehicles']-1) #Postponement and/or NonService cost\n # Add Capacity constraint.\n def demand_callback(from_index): #\n \"\"\"Returns the demand of the node.\"\"\"\n # Convert from routing variable Index to demands NodeIndex.\n from_node = manager.IndexToNode(from_index) \n return data['demands'][from_node]\n demand_callback_index = routing.RegisterUnaryTransitCallback(\n demand_callback)\n routing.AddDimensionWithVehicleCapacity(\n demand_callback_index,\n 0, # null capacity slack\n data['vehicle_capacities'], # vehicle maximum capacities\n True, # start cumul to zero\n 'Capacity')\n # Add time constraint.\n def time_callback(from_index,to_index): #\n \"\"\"Returns the demand of the node.\"\"\"\n # Convert from routing variable Index to NodeIndex in time\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return time_matrix[from_node][to_node] \n time_callback_index = routing.RegisterTransitCallback(time_callback) \n routing.AddDimensionWithVehicleCapacity(\n time_callback_index,\n 0, # null capacity slack\n data['time_capacities'], # vehicle maximum capacities\n True, # start cumul to zero\n 'Time')\n # Setting solution heuristic-procedure.\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.local_search_metaheuristic = (\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\n search_parameters.time_limit.seconds = 5 #10 # 60 #20 #3000\n search_parameters.log_search = True\n # Solve the problem.\n assignment = routing.SolveWithParameters(search_parameters)\n # Print solution on console.\n if assignment:\n sent, sol_results, routes_results = print_solution(data, manager, routing, assignment) \n return sent, sol_results, routes_results","def eval_genome_eer(g, conf, batch, backprop=False, use_gate=True):\n\n # inputs: batch_size x t x bins\n # outputs: batch_size\n inputs, targets = batch\n # inputs: t x batch_size x bins\n inputs = inputs.transpose(0, 1)\n\n net = neat_local.nn.RecurrentNet.create(g, conf, device=\"cpu\", dtype=torch.float32)\n assert not backprop\n net.reset(len(targets))\n\n contribution = torch.zeros(len(targets))\n norm = torch.zeros(len(targets))\n for input_t in inputs:\n # input_t: batch_size x bins\n\n xo = net.activate(input_t) # batch_size x 2\n score = xo[:, 1]\n confidence = xo[:, 0] if use_gate else torch.ones_like(score)\n contribution += score * confidence # batch_size\n norm += confidence # batch_size\n\n jitter = 1e-8\n prediction = contribution / (norm + jitter) # batch_size\n\n target_scores = prediction[targets == 1].numpy() # select with mask when target == 1\n non_target_scores = prediction[targets == 0].numpy() # select with mask when target == 0\n\n pmiss, pfa = rocch(target_scores, non_target_scores)\n eer = rocch2eer(pmiss, pfa)\n\n return 2 * (.5 - eer)","def remove_alt_confs (hierarchy, always_keep_one_conformer=False) :\n for model in hierarchy.models() :\n for chain in model.chains() :\n for residue_group in chain.residue_groups() :\n atom_groups = residue_group.atom_groups()\n assert (len(atom_groups) > 0)\n if always_keep_one_conformer :\n if (len(atom_groups) == 1) and (atom_groups[0].altloc == '') :\n continue\n atom_groups_and_occupancies = []\n for atom_group in atom_groups :\n if (atom_group.altloc == '') :\n continue\n mean_occ = flex.mean(atom_group.atoms().extract_occ())\n atom_groups_and_occupancies.append((atom_group, mean_occ))\n atom_groups_and_occupancies.sort(lambda a,b: cmp(b[1], a[1]))\n for atom_group, occ in atom_groups_and_occupancies[1:] :\n residue_group.remove_atom_group(atom_group=atom_group)\n single_conf, occ = atom_groups_and_occupancies[0]\n single_conf.altloc = ''\n else :\n for atom_group in atom_groups :\n if (not atom_group.altloc in [\"\", \"A\"]) :\n residue_group.remove_atom_group(atom_group=atom_group)\n else :\n atom_group.altloc = \"\"\n if (len(residue_group.atom_groups()) == 0) :\n chain.remove_residue_group(residue_group=residue_group)\n if (len(chain.residue_groups()) == 0) :\n model.remove_chain(chain=chain)\n atoms = hierarchy.atoms()\n new_occ = flex.double(atoms.size(), 1.0)\n atoms.set_occ(new_occ)","def find_progenitors_until_z_EAGLE(self, mtree, nodeID, z1, z2):\n snapcount = 0\n print(':Read MergerTree from %d until %d' % (z2, z1))\n for ss in range(z2, z1, -1):\n if ss == z2:\n df_target = pd.DataFrame({'nodeID':nodeID})\n _indx = np.where(mtree.data.snapnum.values == ss-1)\n nodeID_prog = mtree.data.index.values[_indx]\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\n _indx = np.where((nodeID_prog_desc < 1e15) &\n (nodeID_prog_desc > 1e11))\n nodeID_prog = nodeID_prog[_indx]\n nodeID_prog_desc = nodeID_prog_desc[_indx]\n\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog,\n 'nodeID_target' : nodeID_prog_desc})\n\n # Initiliaze Output Array\n progcounts = np.zeros((df_target['nodeID'].size, z2-z1))\n\n # nodeID_prog_desc_unic is sorted\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\n return_counts=True)\n # remove -1's\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\n\n # Nr. of progenitors for sub-&halos at snapshot z2\n s = pd.Index(df_target['nodeID'].tolist())\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\n progcounts[_indx_now[now_sort_indx], snapcount] = count[pro_sort_indx]\n \n else:\n df_now = df_prog\n _indx = np.where(mtree.data.snapnum.values == ss-1)\n nodeID_prog = mtree.data.index.values[_indx]\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\n #_indx = np.where((nodeID_prog_desc < 1e15) &\n # (nodeID_prog_desc > 1e10))\n #nodeID_prog = nodeID_prog[_indx]\n #nodeID_prog_desc = nodeID_prog_desc[_indx]\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog})\n \n progcounts_local = np.zeros(df_now['nodeID'].size)\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\n return_counts=True)\n # remove -1's\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\n \n # progenitors for snapshot ss\n s = pd.Index(df_now['nodeID'].tolist())\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n now_sort_indx = np.argsort(df_now['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\n progcounts_local[_indx_now[now_sort_indx]] = count[pro_sort_indx]\n df_now['progcount'] = pd.Series(progcounts_local,\n index=df_now.index, dtype=int)\n\n # Nr. of progenitors for sub-&halos at snapshot z2\n df_inter = df_now.groupby(['nodeID_target'],\n as_index=False)['progcount'].sum()\n # only real progeniteurs\n df_inter = df_inter[(df_inter['nodeID_target'] > 1e10) & \n (df_inter['nodeID_target'] < 1e15)]\n df_inter = df_inter.drop_duplicates(subset=['nodeID_target'],\n keep='first')\n \n s = pd.Index(df_target['nodeID'].tolist())\n _indx_now = s.get_indexer(df_inter['nodeID_target'].tolist())\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\n pro_sort_indx = np.argsort(df_inter['nodeID_target'].values)\n progcounts[_indx_now[now_sort_indx], snapcount] = df_inter['progcount'].values[pro_sort_indx]\n\n # sort nodeID_prog to nodeID\n #s = pd.Index(df_now['nodeID'].tolist())\n #_indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\n #df_now['nodeID_target'].values[_indx_now]\n \n obs_ref_local = np.zeros(df_prog['nodeID'].size)\n for ii in range(len(nodeID_prog_desc_unic)):\n tarID = df_now.loc[\n df_now['nodeID'] == nodeID_prog_desc_unic[ii],\n 'nodeID_target'].values.astype(int)\n if tarID:\n _indx = np.where(\n nodeID_prog_desc == nodeID_prog_desc_unic[ii])\n obs_ref_local[_indx] = tarID\n df_prog['nodeID_target'] = pd.Series(obs_ref_local,\n index=df_prog.index)\n\n snapcount += 1\n del nodeID_prog_desc\n del df_now, df_inter, df_prog\n return np.asarray(df_target['nodeID'].tolist()), progcounts","def PathEnzReg(dic,organism):\n\t#calculation\n\tppcorrp = [0] * (len(dic.plst)*len(dic.plst))\n\tppcorrn = [0] * (len(dic.plst)*len(dic.plst))\n\tfor e in dic.elst:\n\t\tcs = e.cs[0]\n\t\tr = e.rct\n\t\tif e.activation == None:\n\t\t\tcontinue\n\t\tfor (i,p1) in enumerate(dic.plst):\n\t\t\tfor (j,p2) in enumerate(dic.plst):\n\t\t\t\tif cs in p1.sclst and r not in p1.srlst and cs not in p2.sclst and r in p2.srlst and p1 not in p2.splst and p2 not in p1.splst and p1 != p2:\n\t\t\t\t\tif e.activation == True:\n\t\t\t\t\t\tppcorrp[i*len(dic.plst)+j] += 1\n\t\t\t\t\telif e.activation == False:\n\t\t\t\t\t\tppcorrn[i*len(dic.plst)+j] += 1\n\n\t\n\t#output\n\twith open('./results/'+organism+'/logfiles/logpath.log','w') as out:\n\t\tout.write('#List of the XX couples of most interactive pathways:\\n#those pathways that have the biggest number of enzymes (EITHER + OR -) going exclusively from one to the other.\\n#FORMAT:\\n#number of interactions from p1 to p2 (from p2 to p1) [from p1 to p2 with opposite sign, from p2 to p1 with opposite sign]\\n#p1 name \\t p2 name\\n\\nACTIVATION:\\n')\n\t\tppcorrtp = ppcorrp[:]\n\t\tppcorrtn = ppcorrn[:]\n\t\tfor i in range(20):\n\t\t\tj = ppcorrp.index(max(ppcorrp))\n\t\t\t(m,n) = ((j-j%len(dic.plst))/len(dic.plst),j%len(dic.plst))\n\t\t\t(p1,p2) = (dic.plst[m],dic.plst[n])\n\t\t\tout.write(p1.name+'\\t'+p2.name+'\\n'+str(ppcorrtp[j])+'\\t('+str(ppcorrtp[n*len(dic.plst)+m])+')\\t'+str([ppcorrtn[j],ppcorrtn[n*len(dic.plst)+m]])+'\\n')\n\t\t\tppcorrp[m*len(dic.plst)+n] = 0\n\t\t\tppcorrp[n*len(dic.plst)+m] = 0\n\n\n\t\tout.write('\\n-------------------------------------------------------------------------------------\\n\\nINHIBITION:\\n')\n\t\tfor i in range(20):\n\t\t\tj = ppcorrn.index(max(ppcorrn))\n\t\t\t(m,n) = ((j-j%len(dic.plst))/len(dic.plst),j%len(dic.plst))\n\t\t\t(p1,p2) = (dic.plst[m],dic.plst[n])\n\t\t\tout.write(p1.name+'\\t'+p2.name+'\\n'+str(ppcorrtn[j])+'\\t('+str(ppcorrtn[n*len(dic.plst)+m])+')\\t'+str([ppcorrtp[j],ppcorrtp[n*len(dic.plst)+m]])+'\\n')\n\t\t\tppcorrn[m*len(dic.plst)+n] = 0\n\t\t\tppcorrn[n*len(dic.plst)+m] = 0","def find_best_free_param_configuration_LOO_adj_sen(p):\n\n measures_res = linux_base_path+ \"/measures_res\"+setup+\"/\"\n# measures_res = base_path +\"\\\\measures_res\"+setup+\"\\\\\"\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n claim_dict = read_pickle(\"claim_dict\")\n claim_num_list = [4,7,17,21,36,37,39,40,41,42,45,46,47,50,51,53,54,55,57,58,59,60,61,62,66,69,70,79,80]\n# claim_num_list = [4,47,53,58,7,54]\n best_configuration_for_nDCG_AP_prec_at_k_left_out_res = {} #key is left out claim and and value is the alpha,beta,lambda configuration that led to best measures - avg nDCG and AP across the train claims\n measures_res_of_left_out_in_its_best_conf = {} #key - left out claim num, and value is the measures of it, in the best configuration without it.\n \n k_val = 50\n prec_at_k_train = rcdtype.recordtype('prec_at_k_train', 'at_5 at_10')\n max_prec_at_k = rcdtype.recordtype('max_prec_at_k', 'max_val max_conf')\n try:\n for left_out_claim_indx in range(len(claim_num_list)):\n max_nDCG = 0\n max_MAP = 0\n max_nDCG_conf = []\n max_MAP_conf = []\n max_prec_at_5 = max_prec_at_k(0,\"\")\n max_prec_at_10 = max_prec_at_k(0,\"\")\n \n left_out_claim_num = claim_num_list[left_out_claim_indx]\n temp_claim_num_list = claim_num_list[:]\n temp_claim_num_list.remove(left_out_claim_num)\n for alpha in range(0,7,1): #change just for test!\n for beta in range(0,10,1):\n for lambda_int in range(0,11,1):\n for delta_1 in range(0,10,1):\n for delta_2 in range(0,10,1):\n if not delta_1+delta_2 >9: \n lambda_f = turn_to_float([lambda_int])\n (alpha_f,beta_f,delta_1_f,delta_2_f) = turn_to_float([alpha,beta,delta_1,delta_2])\n measures_all_claims = utils_linux.read_pickle(measures_res+\"measures_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_delta1_\"+str(delta_1_f)+\"_delta2_\"+str(delta_2_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f))\n \n # AP_all_claims_curr_param_values = read_pickle(nDCG_MAP_res+\"AP_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f))\n # nDCG_all_claims_curr_param_values = read_pickle(nDCG_MAP_res+\"NDCG_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f)+\"_at_\"+str(p))\n # prec_at_k_all_claims_params_values = read_pickle(nDCG_MAP_res+\"prec_at_k_all_claims_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f))\n avg_nDCG_on_train = 0\n MAP_on_train = 0\n p_at_k_train_avg = prec_at_k_train(0,0)\n for clm_num_train in temp_claim_num_list:\n avg_nDCG_on_train += measures_all_claims[str(clm_num_train)][0]\n MAP_on_train += measures_all_claims[str(clm_num_train)][1] #in this config' -> get the measures\n p_at_k_train_avg.at_5 += measures_all_claims[str(clm_num_train)][2]\n p_at_k_train_avg.at_10 += measures_all_claims[str(clm_num_train)][3]\n avg_nDCG_on_train = float(float(avg_nDCG_on_train)/float(len(temp_claim_num_list)))\n MAP_on_train = float(float(MAP_on_train)/float(len(temp_claim_num_list)))\n p_at_k_train_avg.at_5 = float(float(p_at_k_train_avg.at_5)/float(len(temp_claim_num_list)))\n p_at_k_train_avg.at_10 = float(float(p_at_k_train_avg.at_10)/float(len(temp_claim_num_list)))\n \n if avg_nDCG_on_train > max_nDCG:\n max_nDCG = avg_nDCG_on_train\n max_nDCG_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\n if MAP_on_train > max_MAP:\n max_MAP = MAP_on_train\n max_MAP_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\n if p_at_k_train_avg.at_5 > max_prec_at_5.max_val:\n max_prec_at_5.max_val = p_at_k_train_avg.at_5\n max_prec_at_5.max_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\n if p_at_k_train_avg.at_10 > max_prec_at_10.max_val:\n max_prec_at_10.max_val = p_at_k_train_avg.at_10\n max_prec_at_10.max_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\n best_configuration_for_nDCG_AP_prec_at_k_left_out_res[left_out_claim_num] = [(max_nDCG,max_nDCG_conf),(max_MAP,max_MAP_conf),(max_prec_at_5.max_val,max_prec_at_5.max_conf),(max_prec_at_10.max_val,max_prec_at_10.max_conf)]\n #finished leaving out,\n #now calculate the nDCG and MAP of the left out claims with its best configuration results\n avg_nDCG_on_left_out = 0\n MAP_on_left_out = 0\n avg_prec_at_5_on_left_out = 0\n avg_prec_at_10_on_left_out = 0\n for clm_num in claim_num_list:\n (best_alpha_nDCG,best_beta_nDCG,best_lambda_nDCG,best_delta1_nDCG,best_delta2_nDCG) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1]\n (best_alpha_MAP,best_beta_MAP,best_lambda_MAP,best_delta1_MAP,best_delta2_MAP) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1]\n (best_alpha_prec_at_5,best_beta_prec_at_5,best_lambda_prec_at_5,best_delta1_prec_at_5,best_delta2_prec_at_5) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1]\n (best_alpha_prec_at_10,best_beta_prec_at_10,best_lambda_prec_at_10,best_delta1_prec_at_10,best_delta2_prec_at_10) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1]\n #read the best config' dict\n best_config_of_nDCG_dict = read_pickle(measures_res+\"measures_all_claims_alpha_\"+str(best_alpha_nDCG)+\"_beta_\"+str(best_beta_nDCG)+\"_delta1_\"+str(best_delta1_nDCG)+\"_delta2_\"+str(best_delta2_nDCG)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(best_lambda_nDCG))\n best_config_of_AP_dict = read_pickle(measures_res+\"measures_all_claims_alpha_\"+str(best_alpha_MAP)+\"_beta_\"+str(best_beta_MAP)+\"_delta1_\"+str(best_delta1_MAP)+\"_delta2_\"+str(best_delta2_MAP)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(best_lambda_MAP))\n best_config_of_prec_at_5_dict = read_pickle(measures_res+\"measures_all_claims_alpha_\"+str(best_alpha_prec_at_5)+\"_beta_\"+str(best_beta_prec_at_5)+\"_delta1_\"+str(best_delta1_prec_at_5)+\"_delta2_\"+str(best_delta2_prec_at_5)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(best_lambda_prec_at_5)) #take only the first item in the tuple\n best_config_prec_of_at_10_dict = read_pickle(measures_res+\"measures_all_claims_alpha_\"+str(best_alpha_prec_at_10)+\"_beta_\"+str(best_beta_prec_at_10)+\"_delta1_\"+str(best_delta1_prec_at_10)+\"_delta2_\"+str(best_delta2_prec_at_10)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(best_lambda_prec_at_10)) #take only the second item in the tuple\n measures_res_of_left_out_in_its_best_conf[clm_num] = (best_config_of_nDCG_dict[str(clm_num)][0],best_config_of_AP_dict[str(clm_num)][1],best_config_of_prec_at_5_dict[str(clm_num)][2],best_config_prec_of_at_10_dict[str(clm_num)][3])\n avg_nDCG_on_left_out += best_config_of_nDCG_dict[str(clm_num)][0]\n MAP_on_left_out += best_config_of_AP_dict[str(clm_num)][1]\n avg_prec_at_5_on_left_out += best_config_of_prec_at_5_dict[str(clm_num)][2]\n avg_prec_at_10_on_left_out += best_config_prec_of_at_10_dict[str(clm_num)][3]\n \n save_pickle(measures_res+\"measures_res_of_left_out_in_its_best_conf_k_top_docs_\"+str(k_val)+\"_at_\"+str(p), measures_res_of_left_out_in_its_best_conf)\n #report the avg\n avg_nDCG_on_left_out = float(float(avg_nDCG_on_left_out)/float(len(claim_num_list))) \n MAP_on_left_out = float(float(MAP_on_left_out)/float(len(claim_num_list))) \n avg_prec_at_5_on_left_out = float(float(avg_prec_at_5_on_left_out)/float(len(claim_num_list)))\n avg_prec_at_10_on_left_out = float(float(avg_prec_at_10_on_left_out)/float(len(claim_num_list)))\n #write res to file:\n # claim text, the best nDCG conf and result on train, the nDCG it really has, and the same for AP\n with open(measures_res+\"nDCG_AP_prec_at_k_res_of_left_out_in_its_best_conf_k_top_docs_\"+str(k_val)+\"_at_\"+str(p)+\".csv\", 'wb') as csvfile:\n w = csv.writer(csvfile)\n row = \"claim|best_nDCG|alpha,beta,lambda,delta_1,delta_2,delta_3|best_AP|alpha,beta,lambda,delta_1,delta_2,delta_3|best_prec_at_5|alpha,beta,lambda,delta_1,delta_2,delta_3|best_prec_at_10|alpha,beta,lambda,delta_1,delta_2,delta_3\"\n w.writerow([row])\n for (clm_num,(nDCG,AP,prec_at_5,prec_at_10)) in measures_res_of_left_out_in_its_best_conf.items():\n row = claim_dict[str(clm_num)]+\"&\"+'%.3f'%nDCG+\"&\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][0])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][1])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][2])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][3])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][4])+\",\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][3])\n row += \"&\"+'%.3f'%AP+\"&\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][0])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][1])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][2])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][3])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][4])+\",\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][3])\n row += \"&\"+'%.3f'%prec_at_5+ \"&\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][0])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][1])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][2])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][3])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][4])+\",\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][3])\n row += \"&\"+'%.3f'%prec_at_10+ \"&\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][0])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][1])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][2])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][3])+\",\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][4])+\",\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][3])\n w.writerow([row])\n w.writerow([\"avg_nDCG_on_left_out: \"+ '%.4f'%avg_nDCG_on_left_out ])\n w.writerow([\"MAP_on_left_out: \"+ '%.4f'%MAP_on_left_out])\n w.writerow([\"avg_prec_at_5_on_left_out: \"+ '%.4f'%avg_prec_at_5_on_left_out])\n w.writerow([\"avg_prec_at_10_on_left_out: \"+ '%.4f'%avg_prec_at_10_on_left_out])\n except Exception as err: \n sys.stderr.write('problem in LOO') \n print err","def correct_intron_boundaries_by_exonsignal(abfgp_genemodel,organism,PCG,introndata,\n array_algpresence,array_algsimilarity,verbose=True):\n\n # Global Variable Imports\n CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET = 200\n CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET = 200\n FINETUNE_ACCEPTOR_NT_OFFSET = 12\n FINETUNE_DONOR_NT_OFFSET = 12\n from settings.genestructure import MIN_INTRON_NT_LENGTH\n\n\n # list with adjusted boundaries\n refined_boundaries = []\n\n # recreate lists of ABGFP exons & introns\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\n\n for intron_pos in range(0,len(abfgp_introns)):\n intron = abfgp_introns[intron_pos]\n if not intron: continue\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\n\n next_exon = abfgp_exons[intron_pos+1]\n prev_exon = abfgp_exons[intron_pos]\n\n # make elegiable correction range\n correct_acceptor_range = range(\n intron.acceptor.pos-CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET,\n min([ next_exon.donor.pos-6, intron.acceptor.pos+CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET+1 ]) )\n correct_donor_range = range(\n max([ prev_exon.acceptor.pos+6, intron.donor.pos-CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET]),\n intron.donor.pos+CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET+1)\n finetune_acceptor_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1)\n finetune_donor_range = range(intron.donor.pos-FINETUNE_DONOR_NT_OFFSET,\n intron.donor.pos+FINETUNE_DONOR_NT_OFFSET+1)\n\n\n staI,endI = intron.donor.pos/3, intron.acceptor.pos/3\n staE,endE = intron.acceptor.pos/3, next_exon.donor.pos/3\n algsim_intron = sum(array_algsimilarity[staI:endI])\n algsim_next_exon = sum(array_algsimilarity[staE:endE])\n algsim_score_abs = float(algsim_intron)/algsim_next_exon\n algsim_score_rel = float(algsim_intron)/algsim_next_exon * (float(endE-staE)/float(endI-staI))\n\n print \"CORRECT\", intron\n print intron.acceptor, intron.acceptor.pos, algsim_score_abs, algsim_score_rel\n print [ a.pos for a in intron.orfAcceptor._acceptor_sites ]\n\n\n possible_acceptor_boundaries = []\n possible_donor_boundaries = []\n\n for acceptor in intron.orfAcceptor._acceptor_sites:\n if acceptor.pos - intron.donor.pos < MIN_INTRON_NT_LENGTH: continue\n if acceptor.pos not in correct_acceptor_range: continue\n if acceptor.pos == intron.acceptor.pos: continue\n if _finetune_splicesite_comparison(intron.acceptor,acceptor) == False: continue\n\n # if here, generate stats\n staI,endI = intron.donor.pos/3, acceptor.pos/3\n algsim_intron_pos = sum(array_algsimilarity[staI:endI])\n staE,endE = acceptor.pos/3, next_exon.donor.pos/3\n algsim_next_exon_pos = sum(array_algsimilarity[staE:endE]) \n # check if no similarity left of exon; avoid ZeroDivisionError\n if algsim_next_exon_pos == 0: continue\n\n # calculate score ratios\n alternative_algsim_score_abs = float(algsim_intron_pos)/algsim_next_exon_pos\n alternative_algsim_score_rel = alternative_algsim_score_abs * (float(endE-staE)/float(endI-staI))\n\n # test if exon signal is an improvement\n #if alternative_algsim_score_abs > algsim_score_abs: continue\n #if alternative_algsim_score_rel > algsim_score_rel: continue\n\n\n if acceptor.phase == intron.donor.phase:\n # get data on this alternative acceptor/donor combination\n test_intron = IntronConnectingOrfs(intron.donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\n test_intron.assign_bp_and_ppts()\n else:\n test_intron = None\n\n print acceptor, acceptor.pos, \n print alternative_algsim_score_abs,\n print alternative_algsim_score_rel,\n if test_intron:\n print _branchpoint_comparison(intron,test_intron),\n print _polypyrimidinetract_comparison(intron,test_intron)\n else:\n print \"OTHER PHASE\"\n\n\n staI,endI = intron.donor.pos/3, intron.acceptor.pos/3\n staE,endE = prev_exon.acceptor.pos/3, intron.donor.pos/3, \n algsim_intron = sum(array_algsimilarity[staI:endI])\n algsim_prev_exon = sum(array_algsimilarity[staE:endE])\n algsim_score_abs = float(algsim_intron)/algsim_prev_exon\n algsim_score_rel = float(algsim_intron)/algsim_prev_exon * (float(endE-staE)/float(endI-staI))\n\n print intron.donor, intron.donor.pos, algsim_score_abs, algsim_score_rel\n print [ d.pos for d in intron.orfDonor._donor_sites ]\n\n for donor in intron.orfDonor._donor_sites:\n if intron.acceptor.pos - donor.pos < MIN_INTRON_NT_LENGTH: continue\n if donor.pos == intron.donor.pos: continue\n if donor.pos not in correct_donor_range: continue\n if _finetune_splicesite_comparison(intron.donor,donor) == False: continue\n\n # if here, generate stats\n staI,endI = donor.pos/3, intron.acceptor.pos/3\n algsim_intron_pos = sum(array_algsimilarity[staI:endI])\n staE,endE = prev_exon.acceptor.pos/3, donor.pos/3\n algsim_prev_exon_pos = sum(array_algsimilarity[staE:endE]) \n # check if no similarity left of exon; avoid ZeroDivisionError\n if algsim_prev_exon_pos == 0: continue\n\n # calculate score ratios\n alternative_algsim_score_abs = float(algsim_intron_pos)/algsim_prev_exon_pos\n alternative_algsim_score_rel = alternative_algsim_score_abs * (float(endE-staE)/float(endI-staI))\n\n # test if exon signal is an improvement\n #if alternative_algsim_score_abs > algsim_score_abs: continue\n #if alternative_algsim_score_rel > algsim_score_rel: continue\n\n if donor.phase == intron.acceptor.phase:\n # get data on this alternative acceptor/donor combination\n test_intron = IntronConnectingOrfs(donor,intron.acceptor,None,intron.orfDonor,intron.orfAcceptor)\n test_intron.assign_bp_and_ppts()\n else:\n test_intron = None\n\n print donor, donor.pos, \n print alternative_algsim_score_abs,\n print alternative_algsim_score_rel,\n if test_intron:\n print _branchpoint_comparison(intron,test_intron),\n print _polypyrimidinetract_comparison(intron,test_intron)\n else:\n print \"OTHER PHASE\"\n\n\n #for position in range(intron.acceptor.pos,intron.orfAcceptor.start,-10):\n # staI,endI = intron.donor.pos/3, position/3\n # if endI <= staI: break\n # algsim_intron_pos = sum(array_algsimilarity[staI:endI])\n # staE,endE = position/3, next_exon.donor.pos/3\n # algsim_next_exon_pos = sum(array_algsimilarity[staE:endE]) \n # print position, scoreA, scoreB,\n # print float(algsim_intron_pos)/algsim_next_exon_pos,\n # print float(algsim_intron_pos)/algsim_next_exon_pos * (float(endE-staE)/float(endI-staI))","def gen_static_landscape(pop,conc):\n # get final landscape and seascape\n landscape = np.zeros(pop.n_genotype)\n for kk in range(pop.n_genotype):\n landscape[kk] = gen_fitness(pop,\n kk,\n pop.static_topo_dose,\n pop.drugless_rates,\n pop.ic50)\n \n if min(landscape) == 0:\n zero_indx_land = np.argwhere(landscape==0)\n landscape_t = np.delete(landscape,zero_indx_land)\n min_landscape = min(landscape_t)\n else:\n min_landscape = min(landscape)\n zero_indx_land = []\n \n seascape = np.zeros(pop.n_genotype)\n for gen in range(pop.n_genotype):\n seascape[gen] = gen_fitness(gen,conc,pop.drugless_rates,pop.ic50,pop=pop)\n \n if min(seascape) == 0:\n zero_indx_sea = np.argwhere(seascape==0)\n seascape_t = np.delete(seascape,zero_indx_sea)\n min_seascape = min(seascape_t)\n else:\n min_seascape = min(seascape)\n \n landscape = landscape - min_landscape\n landscape = landscape/max(landscape)\n \n rng = max(seascape) - min_seascape\n \n landscape = landscape*rng + min_seascape\n \n landscape[zero_indx_land] = 0\n return landscape","def _format_subgraph_improper(m, top):\n (sort_by_n_connections, _) = _get_sorted_by_n_connections(m)\n if len(sort_by_n_connections) == 4:\n central = sort_by_n_connections[3]\n branch1, branch2, branch3 = sorted(\n sort_by_n_connections[:3],\n key=lambda x: top.get_index(x),\n )\n return (\n top.get_index(central),\n top.get_index(branch1),\n top.get_index(branch2),\n top.get_index(branch3),\n )\n return None","def describe(self, gpos, args):\n\n rg = RegAnno()\n\n rg.dist2tss = gpos - self.exons[0][0] if self.strand == '+' else self.exons[-1][1] - gpos\n if rg.dist2tss >= -args.prombeg and rg.dist2tss <= args.promend:\n rg.promoter = True\n\n # intergenic, NOTE USE describe_intergenic_neighbors\n if gpos < self.exons[0][0]:\n rg.intergenic = (self.exons[0][0] - gpos, 'upstream' if self.strand == '+' else 'downstream')\n return rg\n if gpos > self.exons[-1][1]:\n rg.intergenic = (gpos - self.exons[-1][1], 'downstream' if self.strand == '+' else 'upstream')\n return rg\n\n if gpos < self.cds_beg:\n rg.UTR = '5' if self.strand == '+' else '3'\n if gpos > self.cds_end:\n rg.UTR = '3' if self.strand == '+' else '5'\n\n for i, exon in enumerate(self.exons):\n exind = i+1 if self.strand == '+' else len(self.exons) - i\n if exon[0] <= gpos and exon[1] >= gpos: # exonic\n rg.exonic = True\n if gpos >= self.cds_beg and gpos <= self.cds_end:\n rg.cds = True\n if gpos == self.cds_beg:\n rg.start = True\n if gpos == self.cds_end:\n rg.stop = True\n if gpos == exon[1]:\n rg.splice = 'NextToDonor' if self.strand == '+' else 'NextToAcceptor'\n if gpos == exon[0]:\n rg.splice = 'NextToAcceptor' if self.strand == '+' else 'NextToDonor'\n rg.exon = exind\n return rg\n if i > 0:\n pexon = self.exons[i-1]\n if gpos > pexon[1] and gpos < exon[0]: # intronic\n rg.intronic = True\n if self.strand == '+':\n rg.intron_exon1 = exind-1\n rg.intron_exon2 = exind\n else:\n rg.intron_exon1 = exind\n rg.intron_exon2 = exind+1\n if gpos in [pexon[1]+1, pexon[1]+2]:\n rg.splice = 'Donor' if self.strand == '+' else 'Acceptor'\n if gpos in [exon[0]-2, exon[0]-1]:\n rg.splice = 'Acceptor' if self.strand == '-' else 'Donor'\n return rg\n\n raise Exception('unknown_error') # you shouldn't reach here","def process_gene(header, gene):\n ID = get_geneID(header=header)\n GC = DNA.gc(gene)\n gline = '{} {:4d} {:.2%} {}'.format(ID, len(gene), GC/100, '\\n')\n return gline","def generate_CS_corr_lib(CS_FS_file, cutoff, prefix):\r\n f1 = CS_FS_file # File containing sgRNA ID, gene name, CS & FS\r\n sgRNA = []; gene = []; CS = []; FS = [] # Lists for storing sgRNA ID, gene name, CS & FS of sgRNA\r\n with open(f1,'r') as f:\r\n reader = csv.reader(f, delimiter = '\\t')\r\n for row in reader:\r\n sgRNA.append(row[0])\r\n gene.append(row[1])\r\n CS.append(row[2])\r\n FS.append(row[3])\r\n sgRNA.remove(sgRNA[0]); gene.remove(gene[0]); CS.remove(CS[0]); FS.remove(FS[0])\r\n guide_details = tuple(zip(sgRNA,gene,CS,FS))\r\n # guide_details is a tuple, each element of which is a tuple of the form (sgRNA ID, gene, CS, FS) \r\n gene_set = list(set(gene)) # List of genes covered by the GW-library\r\n \r\n gene_guides = defaultdict(list) # A dictionary for storing gene name as key and a list of attributes (i.e., ID, gene, CS, FS) of all sgRNA targeting that gene as values\r\n for g in gene_set:\r\n for i in range(len(guide_details)):\r\n if g in guide_details[i][1]: gene_guides[g].append(guide_details[i])\r\n \r\n val = []; # List for storing details of guides included in the CS-corrected library\r\n \r\n for g in gene_guides:\r\n c = 0; # Counts the number of good cutters (CS > cutoff) targeting a gene\r\n y = np.array(gene_guides[g])\r\n for i in range(y.shape[0]):\r\n if float(y[i,2]) > cutoff:\r\n c += 1\r\n val.append(y[i])\r\n if c == 0: # if no good cutters target a gene, the best of the existing cutters is picked\r\n p = y[:,2].astype(float) # Converting CS values to float from str\r\n x = np.where(p == max(p)) # Finding the array position of guide having max. CS (best cutter)\r\n val.append(y[x[0][0]])\r\n \r\n # Writing results in a new .TAB file\r\n g = prefix + '_corrected_guide_CS_FS.tab'\r\n with open(g,'w',newline = '') as f:\r\n writer = csv.writer(f, delimiter = '\\t')\r\n writer.writerow(['Guide ID','gene','CS','FS'])\r\n for i in val:\r\n row = []\r\n row.append(i[0])\r\n row.append(i[1])\r\n row.append(float(i[2]))\r\n row.append(float(i[3]))\r\n writer.writerow(row)","def GetInteriorEdgesPent(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesPent()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesPent()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def eo_edges(self):\n logger.info(\"eo_edges called\")\n permutations = []\n original_state = self.state[:]\n original_solution = self.solution[:]\n tmp_solution_len = len(self.solution)\n\n # Build a list of the wing strings at each midge\n wing_strs = []\n\n for _, square_index, partner_index in midges_recolor_tuples_555:\n square_value = self.state[square_index]\n partner_value = self.state[partner_index]\n wing_str = square_value + partner_value\n wing_str = wing_str_map[square_value + partner_value]\n wing_strs.append(wing_str)\n\n # build a list of all possible EO permutations...an even number of edges must be high\n for num in range(4096):\n num = str(bin(num)).lstrip(\"0b\").zfill(12)\n if num.count(\"1\") % 2 == 0:\n permutations.append(list(map(int, num)))\n\n # Put all 2048 starting states in a file and point ida-via-graph\n # at the file so it can solve all of them and apply the one that is the shortest.\n lr_center_stage_states = []\n eo_outer_orbit_states = []\n eo_inner_orbit_states = []\n\n for permutation in permutations:\n must_be_uppercase = []\n must_be_lowercase = []\n self.state = original_state[:]\n\n for wing_str, uppercase in zip(wing_strs, permutation):\n if uppercase:\n must_be_uppercase.append(wing_str)\n else:\n must_be_lowercase.append(wing_str)\n\n # logger.info(\"%s: %s permutation %s\" % (self, index, \"\".join(map(str, permutation))))\n self.edges_flip_orientation(must_be_uppercase, must_be_lowercase)\n\n # build lists of the states that we need to find state_indexes for\n lr_center_stage_states.append(self.lt_phase3_lr_center_stage.state())\n eo_outer_orbit_states.append(self.lt_phase3_eo_outer_orbit.state())\n eo_inner_orbit_states.append(self.lt_phase3_eo_inner_orbit.state())\n\n # now we have a huge list of states to lookup, do a binary search on multiple states at once (this is drastically faster\n # than binary searching for them individually). state_index_multiple() will return a dict where the state is the key\n # and the state_index is the value.\n lr_center_stage_eo_inner_orbit_state_indexes = self.lt_phase3_lr_center_stage.state_index_multiple(\n lr_center_stage_states\n )\n eo_outer_orbit_state_indexes = self.lt_phase3_eo_outer_orbit.state_index_multiple(eo_outer_orbit_states)\n eo_inner_orbit_state_indexes = self.lt_phase3_eo_inner_orbit.state_index_multiple(eo_inner_orbit_states)\n\n # build a list of tuples of the state indexes\n pt_state_indexes = []\n for lr_center_stage_eo_inner_orbit_state, eo_outer_orbit_state, eo_inner_orbit_state in zip(\n lr_center_stage_states, eo_outer_orbit_states, eo_inner_orbit_states\n ):\n pt_state_indexes.append(\n (\n lr_center_stage_eo_inner_orbit_state_indexes[lr_center_stage_eo_inner_orbit_state],\n eo_outer_orbit_state_indexes[eo_outer_orbit_state],\n eo_inner_orbit_state_indexes[eo_inner_orbit_state],\n )\n )\n\n self.state = original_state[:]\n self.solution = original_solution[:]\n\n # When solve_via_c is passed pt_state_indexes (2048 lines of states in this case), it will try all 2048 of them\n # to find the state that has the shortest solution.\n self.lt_phase3.solve_via_c(pt_states=pt_state_indexes)\n\n self.print_cube_add_comment(\"edges EOed into high/low groups\", tmp_solution_len)\n self.post_eo_state = self.state[:]\n self.post_eo_solution = self.solution[:]\n\n # re-color the cube so that the edges are oriented correctly so we can\n # pair 4-edges then 8-edges. After all edge pairing is done we will uncolor\n # the cube and re-apply the solution.\n self.edges_flip_orientation(wing_strs, [])\n self.highlow_edges_print()","def _find_all_top_level_non_gene_features(chrom: str, db: FeatureDB, feature_types: List[str]) -> Iterable[Feature]:\n for feature in db.region(seqid=chrom, featuretype=feature_types):\n try:\n _ = next(db.parents(feature.id))\n except StopIteration:\n yield feature","def calculate_GNOp_initial(self):\n\n # Initialise\n Transform2NormIndOp = Transform2NormInd()\n\n # Directories\n dataset_paths = self.dataset_paths\n sensor_data_path = self.sensor_data_path\n output_dir = self.output_dir\n\n ################################################################################################################\n # 1.\tRead Harmonisation Matchup Data\n ################################################################################################################\n\n print \"Match-up Dataset:\"\n for path in dataset_paths:\n print \">\", path\n\n print \"\\nSensor Data File:\"\n print \"> \"+sensor_data_path\n\n print \"\\nOpening data...\"\n HData = self.data_reader(dataset_paths, sensor_data_path, open_uncertainty=True)\n\n ################################################################################################################\n # 2.\tPerform harmonisation\n ################################################################################################################\n\n print \"Complete\"\n\n print \"\\nData Info\"\n print \"==========\"\n print \"Reference Sensors - \", [str(sensor) for sensor in HData.idx['sensors']\n if sensor not in HData.idx[\"parameter_sensor\"]]\n print \"Harmonising Sensors - \", [str(sensor) for sensor in HData.idx['sensors']\n if sensor in HData.idx[\"parameter_sensor\"]]\n print \"Total Match-Ups - \", HData.idx['cNm'][-1]\n print \"Total Sensor State Data Values - \", HData.idx['idx'][-1]\n print \"Total Harmonisation Paramaters - \", len(HData.idx['parameter_sensor'])\n\n print \"\\nComputing Initial GN Value...\"\n # a. reparameterise input data such that output data are independent quantities\n HData = Transform2NormIndOp.run(HData)\n\n # b. run GN algorithm on modified data\n GNOp = GNAlgo(HData)\n\n ################################################################################################################\n # 3.\tWrite data to file\n ################################################################################################################\n\n print '\\nWriting data to file...'\n\n # Write data\n save_directory_GNOp = pjoin(output_dir, \"temp\", \"GNOp_initial\")\n try:\n os.makedirs(save_directory_GNOp)\n except OSError:\n pass\n\n GNOp.save(save_directory_GNOp)\n\n print \"Output Data Written To:\"\n print \">\", save_directory_GNOp","def FindCA(e,PV,F,w,m):\n global MAX\n le=len(e)\n if le > MAX:\n MAX = le\n #print the new best columns and how many they are\n system('clear')\n print \"So far, the best columns are %s and MAX is %d\" % (e,MAX)\n PV=ComputeCand(e,PV,F,w,m)\n lp=len(PV)\n if le+lp > MAX:\n for i in range(le+lp-MAX):\n newe=e+[PV[i]]\n test=collections.deque(columns2bin(newe, w))\n if is_necklace(test):\n FindCA(newe,PV[i+1:],F,w,m)\n else:\n break","def process_graph(self, threshold=None):\r\n\r\n def find_head_end(head_name, descendant, end_op):\r\n # This helper function finds ends of Class Net and Box Net, based on a model type. \r\n # :param head_name: This is a common name that nodes in either Class or Box Nets start with.\r\n # :param descendant: Descendant of head_name, identified by operation (Transpose, MatMul, etc.).\r\n # :param end_op: Operation of a node you would like to get in the end of each Net.\r\n # These end_op nodes bring together prediction data based on type of model.\r\n # The Class Net end node will have shape [batch_size, num_anchors, num_classes],\r\n # and the Box Net end node has the shape [batch_size, num_anchors, 4].\r\n # These end nodes can be be found by searching for all end_op's operation nodes and checking if the node two\r\n # steps above in the graph has a name that begins with one of head_names for Class Net and Box Net respectively.\r\n for node in [node for node in self.graph.nodes if node.op == descendant and head_name in node.name]:\r\n target_node = self.graph.find_descendant_by_op(node, end_op)\r\n log.info(\"Found {} node '{}' as the tip of {}\".format(target_node.op, target_node.name, head_name))\r\n return target_node\r\n\r\n def extract_anchors_tensor(split):\r\n # This will find the anchors that have been hardcoded somewhere within the ONNX graph.\r\n # The function will return a gs.Constant that can be directly used as an input to the NMS plugin.\r\n # The anchor tensor shape will be [1, num_anchors, 4]. Note that '1' is kept as first dim, regardless of\r\n # batch size, as it's not necessary to replicate the anchors for all images in the batch.\r\n\r\n # The anchors are available (one per coordinate) hardcoded as constants within certain box decoder nodes.\r\n # Each of these four constants have shape [1, num_anchors], so some numpy operations are used to expand the\r\n # dims and concatenate them as needed.\r\n\r\n # These constants can be found by starting from the Box Net's split operation , and for each coordinate,\r\n # walking down in the graph until either an Add or specific Mul node is found. The second input on this nodes will\r\n # be the anchor data required.\r\n\r\n # Get Add anchor nodes\r\n def get_anchor_add(output_idx, op):\r\n node = self.graph.find_descendant_by_op(split.o(0, output_idx), op)\r\n assert node\r\n val = np.squeeze(node.inputs[1].values)\r\n return np.expand_dims(val.flatten(), axis=(0, 2))\r\n\r\n # Get Mul anchor nodes\r\n def get_anchor_mul(name, op):\r\n node = [node for node in self.graph.nodes if node.op == op and name == node.name][0]\r\n assert node\r\n val = np.squeeze(node.inputs[1].values)\r\n return np.expand_dims(val.flatten(), axis=(0, 2))\r\n\r\n \r\n anchors_y = get_anchor_add(0, \"Add\")\r\n anchors_x = get_anchor_add(1, \"Add\")\r\n anchors_h = None\r\n anchors_w = None\r\n\r\n # Based on a model type, naming of Mul nodes is slightly different, this will be improved in future to exclude branching.\r\n if \"ssd\" in self.model:\r\n anchors_h = get_anchor_mul(\"StatefulPartitionedCall/Postprocessor/Decode/mul_1\",\"Mul\")\r\n anchors_w = get_anchor_mul(\"StatefulPartitionedCall/Postprocessor/Decode/mul\",\"Mul\")\r\n elif \"faster_rcnn\" in self.model:\r\n anchors_h = get_anchor_mul(\"StatefulPartitionedCall/Decode/mul_1\",\"Mul\")\r\n anchors_w = get_anchor_mul(\"StatefulPartitionedCall/Decode/mul\",\"Mul\") \r\n\r\n batched_anchors = np.concatenate([anchors_y, anchors_x, anchors_h, anchors_w], axis=2)\r\n # Identify num of anchors without repetitions.\r\n num_anchors = int(batched_anchors.shape[1]/self.batch_size)\r\n # Trim total number of anchors in order to not have copies introduced by growing number of batch_size.\r\n anchors = batched_anchors[0:num_anchors,0:num_anchors]\r\n return gs.Constant(name=\"nms/anchors:0\", values=anchors)\r\n\r\n self.infer()\r\n\r\n def first_nms(background_class, score_activation, threshold):\r\n \"\"\"\r\n Updates the graph to replace the NMS op by BatchedNMS_TRT TensorRT plugin node.\r\n :param background_class: Set EfficientNMS_TRT's background_class atribute. \r\n :param score_activation: Set EfficientNMS_TRT's score_activation atribute. \r\n \"\"\"\r\n # Identify Class Net and Box Net head names based on model type.\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \r\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\r\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\r\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\r\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\r\n\r\n class_net = None\r\n box_net = None\r\n\r\n # Getting SSD's Class and Box Nets final tensors.\r\n if \"ssd\" in self.model:\r\n # Find the concat node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Concat\")\r\n\r\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\r\n slice_start = np.asarray([1], dtype=np.int64)\r\n slice_end = np.asarray([91], dtype=np.int64)\r\n # Second list element but third tensor dimension.\r\n slice_axes = np.asarray([2], dtype=np.int64)\r\n slice_out = self.graph.elt_const_slice(\"Slice\", head_names[0]+\"/slicer\", class_net.outputs[0], slice_start, slice_end, slice_axes)\r\n\r\n # Final Class Net tensor.\r\n class_net_tensor = slice_out[0]\r\n\r\n if self.model == 'ssd_mobilenet_v2_keras':\r\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \"Squeeze\")\r\n box_net_output = box_net_squeeze.outputs[0]\r\n\r\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \r\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \r\n self.model == 'ssd_resnet152_v1_fpn_keras'):\r\n # Find the concat node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Concat\")\r\n box_net_output = box_net.outputs[0]\r\n\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", box_net_output, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n \r\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\r\n elif \"faster_rcnn\" in self.model:\r\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \r\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \"faster_rcnn_inception_resnet_v2_keras\"):\r\n # Find the softmax node at the end of the class net (multi-scale class predictor).\r\n class_net = find_head_end(head_names[0], \"Transpose\", \"Softmax\")\r\n\r\n # Final Class Net tensor\r\n class_net_tensor = class_net.outputs[0] \r\n\r\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\r\n box_net = find_head_end(head_names[1], \"Transpose\", \"Reshape\")\r\n # Final Box Net tensor.\r\n box_net_output = box_net.outputs[0]\r\n\r\n #Insert a squeeze node\r\n squeeze_node = self.graph.squeeze(head_names[1]+\"/squeeze\", box_net_output)\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\r\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n scale_out = self.graph.elt_const(\"Mul\", head_names[1]+\"/scale\", squeeze_node, scale_adj)\r\n\r\n # Final Box Net tensor.\r\n box_net_tensor = scale_out[0]\r\n\r\n\r\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\r\n box_net_split = self.graph.find_descendant_by_op(box_net, \"Split\")\r\n assert box_net_split and len(box_net_split.outputs) == 4\r\n\r\n # Set score threshold\r\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\r\n\r\n # NMS Inputs and Attributes\r\n # NMS expects these shapes for its input tensors:\r\n # box_net: [batch_size, number_boxes, 4]\r\n # class_net: [batch_size, number_boxes, number_classes]\r\n # anchors: [1, number_boxes, 4] (if used)\r\n nms_op = None\r\n nms_attrs = None\r\n nms_inputs = None\r\n\r\n # EfficientNMS TensorRT Plugin is suitable for our use case.\r\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\r\n # three inputs are given to the NMS TensorRT node:\r\n # - The box predictions (from the Box Net node found above)\r\n # - The class predictions (from the Class Net node found above)\r\n # - The default anchor coordinates (from the extracted anchor constants)\r\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\r\n # because this is the internal box coding format used by the network.\r\n anchors_tensor = extract_anchors_tensor(box_net_split)\r\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\r\n nms_op = \"EfficientNMS_TRT\"\r\n nms_attrs = {\r\n 'plugin_version': \"1\",\r\n 'background_class': background_class,\r\n 'max_output_boxes': self.first_stage_max_proposals,\r\n 'score_threshold': max(0.01, score_threshold),\r\n 'iou_threshold': self.first_stage_nms_iou_threshold,\r\n 'score_activation': score_activation,\r\n 'box_coding': 1,\r\n }\r\n nms_output_classes_dtype = np.int32\r\n\r\n # NMS Outputs.\r\n nms_output_num_detections = gs.Variable(name=\"num_detections\", dtype=np.int32, shape=[self.batch_size, 1])\r\n nms_output_boxes = gs.Variable(name=\"detection_boxes\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\r\n nms_output_scores = gs.Variable(name=\"detection_scores\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n nms_output_classes = gs.Variable(name=\"detection_classes\", dtype=nms_output_classes_dtype,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n\r\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\r\n\r\n # Create the NMS Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=nms_op,\r\n name=\"nms/non_maximum_suppression_first\",\r\n inputs=nms_inputs,\r\n outputs=nms_outputs,\r\n attrs=nms_attrs)\r\n log.info(\"Created NMS plugin '{}' with attributes: {}\".format(nms_op, nms_attrs))\r\n\r\n # If model type is SSD, then you are done with conversion and optimizations.\r\n if \"ssd\" in self.model:\r\n self.graph.outputs = nms_outputs\r\n self.infer()\r\n return None\r\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\r\n # next step is CropAndResize. \r\n elif \"faster_rcnn\" in self.model:\r\n return nms_outputs[1]\r\n\r\n def crop_and_resize(input):\r\n \"\"\"\r\n Updates the graph to replace the cropAndResize op by CropAndResize TensorRT plugin node.\r\n :param input: Input tensor is the output from previous first_nms() step. \r\n \"\"\"\r\n\r\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\r\n # necessary for CropAndResize plugin.\r\n relu_name = \"StatefulPartitionedCall/model/\"\r\n relu_node = [node for node in self.graph.nodes if node.op == \"Relu\" and relu_name in node.name][-1]\r\n\r\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\r\n # Clipping happens for coordinates that are less than 0 and more than self.height.\r\n # Normalization is just divison of every coordinate by self.height.\r\n clip_min = np.asarray([0], dtype=np.float32)\r\n clip_max = np.asarray([self.height], dtype=np.float32)\r\n clip_out = self.graph.elt_const_clip(\"Clip\", \"FirstNMS/detection_boxes_clipper\", input, clip_min, clip_max)\r\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\r\n div_out = self.graph.elt_const(\"Div\", \"FirstNMS/detection_boxes_normalizer\", clip_out[0], div_const)\r\n\r\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\r\n # to CenterSize encoding.\r\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\r\n matmul_out = self.graph.elt_const(\"MatMul\", \"FirstNMS/detection_boxes_conversion\", div_out[0], matmul_const)\r\n\r\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\r\n # we need to add unsqeeze node to make tensor 4 dimensional. \r\n unsqueeze_node = self.graph.unsqueeze( \"FirstNMS/detection_boxes_unsqueeze\", div_out)\r\n\r\n # CropAndResizePlugin's inputs \r\n feature_maps = relu_node.outputs[0]\r\n rois = unsqueeze_node[0]\r\n\r\n # CropAndResize TensorRT Plugin.\r\n # Two inputs are given to the CropAndResize TensorRT node:\r\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\r\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\r\n cnr_inputs = [feature_maps, rois]\r\n cnr_op = \"CropAndResize\"\r\n cnr_attrs = {\r\n 'crop_width': self.initial_crop_size,\r\n 'crop_height': self.initial_crop_size,\r\n }\r\n\r\n # CropAndResize Outputs.\r\n cnr_pfmap = gs.Variable(name=\"pfmap\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\r\n cnr_outputs = [cnr_pfmap]\r\n\r\n # Create the CropandResize Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=cnr_op,\r\n name=\"cnr/crop_and_resize\",\r\n inputs=cnr_inputs,\r\n outputs=cnr_outputs,\r\n attrs=cnr_attrs)\r\n log.info(\"Created CropAndResize plugin '{}' with attributes: {}\".format(cnr_op, cnr_attrs))\r\n\r\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\r\n # after that is 2nd backbone that leads us to final 2nd NMS.\r\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\r\n reshape_node = self.graph.elt_const(\"Reshape\", \"StatefulPartitionedCall/CropandResize/reshape\", cnr_outputs[0], reshape_shape)\r\n maxpl_name = \"StatefulPartitionedCall/MaxPool2D/MaxPool\"\r\n maxpool_node = [node for node in self.graph.nodes if node.op == \"MaxPool\" and maxpl_name == node.name][0]\r\n maxpool_node.inputs[0] = reshape_node[0]\r\n\r\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \r\n # so we need to pass and connect it to 2nd NMS.\r\n return matmul_out[0]\r\n\r\n def second_nms(input, threshold):\r\n \"\"\"\r\n Updates the graph to replace the 2nd NMS op by BatchedNMS_TRT TensorRT plugin node.\r\n :param input: MatMul node that sits between 1st and 2nd NMS nodes.\r\n \"\"\"\r\n\r\n # Identify Class Net and Box Net head names.\r\n second_head_names = ['StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_class_head/ClassPredictor_dense',\r\n 'StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_box_head/BoxEncodingPredictor_dense']\r\n\r\n # Find the softmax node at the end of the 2nd class net (multi-scale class predictor).\r\n second_class_net = find_head_end(second_head_names[0], \"MatMul\", \"Softmax\")\r\n\r\n # Faster R-CNN's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\r\n slice_start = np.asarray([1], dtype=np.int64)\r\n slice_end = np.asarray([91], dtype=np.int64)\r\n # Second list element but third tensor dimension.\r\n slice_axes = np.asarray([2], dtype=np.int64)\r\n slice_out = self.graph.elt_const_slice(\"Slice\", second_head_names[0]+\"/slicer\", second_class_net.outputs[0], slice_start, slice_end, slice_axes)\r\n\r\n # Final Class Net tensor.\r\n second_class_net_tensor = slice_out[0]\r\n \r\n # Find the add node at the end of the box net (multi-scale localization predictor).\r\n second_box_net = find_head_end(second_head_names[1], \"MatMul\", \"Add\")\r\n # Final Box Net tensor.\r\n second_box_net_output = second_box_net.outputs[0]\r\n\r\n # Reshape node that is preparing second_box_net_output's output shape for Mul scaling node that comes next.\r\n reshape_shape_second = np.asarray([self.batch_size, self.first_stage_max_proposals, second_box_net.outputs[0].shape[1]], dtype=np.int64)\r\n reshape_node_second = self.graph.elt_const(\"Reshape\", second_head_names[1]+\"/reshape\", second_box_net_output, reshape_shape_second)\r\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale second_box_net_output, in order to get accurate coordinates.\r\n second_scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\r\n second_scale_out = self.graph.elt_const(\"Mul\", second_head_names[1]+\"/scale_second\", reshape_node_second[0], second_scale_adj)\r\n\r\n # Final Box Net tensor.\r\n second_box_net_tensor = second_scale_out[0]\r\n\r\n # Set score threshold\r\n score_threshold = self.second_score_threshold if threshold is None else threshold\r\n\r\n # NMS Inputs and Attributes\r\n # NMS expects these shapes for its input tensors:\r\n # box_net: [batch_size, number_boxes, 4]\r\n # class_net: [batch_size, number_boxes, number_classes]\r\n # anchors: [1, number_boxes, 4] (if used)\r\n second_nms_op = None\r\n second_nms_attrs = None\r\n second_nms_inputs = None\r\n\r\n # EfficientNMS TensorRT Plugin is suitable for our use case.\r\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\r\n # three inputs are given to the NMS TensorRT node:\r\n # - The box predictions (from the Box Net node found above)\r\n # - The class predictions (from the Class Net node found above)\r\n # - The default anchor coordinates (from the extracted anchor constants)\r\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\r\n # because this is the internal box coding format used by the network.\r\n second_nms_inputs = [second_box_net_tensor, second_class_net_tensor, input]\r\n second_nms_op = \"EfficientNMS_TRT\"\r\n second_nms_attrs = {\r\n 'plugin_version': \"1\",\r\n 'background_class': -1,\r\n 'max_output_boxes': self.first_stage_max_proposals,\r\n 'score_threshold': max(0.01, score_threshold),\r\n 'iou_threshold': self.second_iou_threshold,\r\n 'score_activation': False,\r\n 'box_coding': 1,\r\n }\r\n second_nms_output_classes_dtype = np.int32\r\n\r\n # NMS Outputs.\r\n second_nms_output_num_detections = gs.Variable(name=\"second_num_detections\", dtype=np.int32, shape=[self.batch_size, 1])\r\n second_nms_output_boxes = gs.Variable(name=\"second_detection_boxes\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\r\n second_nms_output_scores = gs.Variable(name=\"second_detection_scores\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n second_nms_output_classes = gs.Variable(name=\"second_detection_classes\", dtype=second_nms_output_classes_dtype,\r\n shape=[self.batch_size, self.first_stage_max_proposals])\r\n\r\n second_nms_outputs = [second_nms_output_num_detections, second_nms_output_boxes, second_nms_output_scores, second_nms_output_classes]\r\n\r\n # Create the NMS Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=second_nms_op,\r\n name=\"nms/non_maximum_suppression_second\",\r\n inputs=second_nms_inputs,\r\n outputs=second_nms_outputs,\r\n attrs=second_nms_attrs)\r\n log.info(\"Created NMS plugin '{}' with attributes: {}\".format(second_nms_op, second_nms_attrs))\r\n \r\n # Set graph outputs.\r\n self.graph.outputs = second_nms_outputs\r\n\r\n self.infer()\r\n\r\n # If you model is SSD, you need only one NMS and nothin else.\r\n if \"ssd\" in self.model:\r\n first_nms_output = first_nms(-1, True, threshold)\r\n # If your model is Faster R-CNN, you will need 2 NMS nodes with CropAndResize in between.\r\n elif \"faster_rcnn\" in self.model:\r\n first_nms_output = first_nms(0, False, threshold)\r\n cnr_output = crop_and_resize(first_nms_output)\r\n second_nms(cnr_output, threshold)","def parse_geno_file(folder,return_flag):\n\n perc_alt = defaultdict(list)\n perc_ref = defaultdict(list)\n abs_alt = defaultdict(list)\n abs_ref = defaultdict(list)\n\n perc_alt_inv = defaultdict(dict)\n perc_ref_inv = defaultdict(dict)\n abs_alt_inv = defaultdict(dict)\n abs_ref_inv = defaultdict(dict)\n\n for geno_file in glob.glob(folder+'*_test_summary.tsv'):\n strain = geno_file.split('/')[-1].split('_')[0]\n #print strain\n prev_coordinate = \"0\"\n count = 0\n alt_allele = {}\n amb_allele = {}\n ref_allele = {}\n flag = 0 \n\n TEMP_HANDLE = open(geno_file,'r')\n for line in TEMP_HANDLE:\n line = line.rstrip('\\n')\n\n if(line[0]!='v'): ## Skip the header\n coordinate = line.split('\\t')[0].split('::')[-1]\n if(coordinate != prev_coordinate):\n #prev_coordinate = coordinate\n count = count + 1\n if(count == 1):\n if(line.split('\\t')[-3]!='alt'): ## No reads supporting the alternate allele\n flag = 1 \n alt_allele[coordinate] = 0\n amb_allele[coordinate] = int(line.split('\\t')[-1])\n #print line\n else:\n alt_allele[coordinate] = int(line.split('\\t')[-1])\n if(count == 2):\n amb_allele[coordinate] = int(line.split('\\t')[-1])\n if(count == 3):\n if(line.split('\\t')[-3]!='ref'): ## No reads supporting the reference allele (all are ambiguous)\n ref_allele[coordinate] = 0\n else:\n ref_allele[coordinate] = int(line.split('\\t')[-1])\n prev_coordinate = coordinate\n count = 0\n if(flag == 1): ## The case where there are no alternate allele reads, counter is incremented to account for changed numbering\n count = count + 1 \n flag = 0 \n\n \n for key in alt_allele:\n if(alt_allele[key]+ref_allele[key]!= 0): ## Check to see if the denominator is not zero\n abs_alt[strain].append(float(alt_allele[key]))\n abs_ref[strain].append(float(ref_allele[key]))\n perc_alt[strain].append(float(alt_allele[key])/(alt_allele[key]+ref_allele[key]))\n perc_ref[strain].append(float(ref_allele[key])/(alt_allele[key]+ref_allele[key]))\n\n\n abs_alt_inv[strain][key] = float(alt_allele[key])\n abs_ref_inv[strain][key] = float(ref_allele[key])\n perc_alt_inv[strain][key] = float(alt_allele[key])/(alt_allele[key]+ref_allele[key])\n perc_ref_inv[strain][key] = float(ref_allele[key])/(alt_allele[key]+ref_allele[key])\n \n \n\n ## Keep only the common inversions, i.e. those between MC and the rest \n all_inversions = []\n common_inversions = []\n abs_alt_set = defaultdict(list)\n perc_alt_set = defaultdict(list)\n\n abs_alt_inv_set = defaultdict(dict)\n perc_alt_inv_set = defaultdict(dict)\n abs_ref_inv_set = defaultdict(dict)\n perc_ref_inv_set = defaultdict(dict)\n\n Rock = ['AC', 'CL','CM','CN','TI','PN','MC']\n Sand = ['MZ','DC','LF','MP','MS','CV']\n\n\n sand_inversions = []\n rock_inversions = []\n\n for strain in abs_alt_inv.keys():\n for inversion in abs_alt_inv[strain].keys():\n if(strain in Rock):\n rock_inversions.append(inversion)\n else:\n sand_inversions.append(inversion)\n all_inversions.append(inversion)\n \n \n common_inversions_sand = Counter(sand_inversions)\n common_inversions_rock = Counter(rock_inversions)\n #count_sand = 0\n common_inversions = Counter(all_inversions)\n return_inversions = []\n \n \n #print common_inversions\n for inversion in common_inversions.keys():\n if(common_inversions[inversion]==13):\n return_inversions.append(inversion)\n for strain in abs_alt_inv.keys():\n abs_alt_set[strain].append(abs_alt_inv[strain][inversion])\n perc_alt_set[strain].append(perc_alt_inv[strain][inversion])\n\n abs_alt_inv_set[strain][inversion] = abs_alt_inv[strain][inversion]\n perc_alt_inv_set[strain][inversion] = perc_alt_inv[strain][inversion]\n abs_ref_inv_set[strain][inversion] = abs_ref_inv[strain][inversion]\n perc_ref_inv_set[strain][inversion] = perc_ref_inv[strain][inversion]\n\n\n for inversion in abs_alt_inv_set['MC']:\n alternate_allele_sum_rock = 0\n reference_allele_sum_rock = 0\n alternate_allele_sum_sand = 0\n reference_allele_sum_sand = 0 \n for strain in Rock:\n alternate_allele_sum_rock = alternate_allele_sum_rock + abs_alt_inv_set[strain][inversion]\n reference_allele_sum_rock = reference_allele_sum_rock + abs_ref_inv_set[strain][inversion]\n\n for strain in Sand:\n alternate_allele_sum_sand = alternate_allele_sum_sand + abs_alt_inv_set[strain][inversion]\n reference_allele_sum_sand = reference_allele_sum_sand + abs_ref_inv_set[strain][inversion]\n\n abs_alt_set['Rock'].append(alternate_allele_sum_rock)\n perc_alt_set['Rock'].append(float((alternate_allele_sum_rock)/(alternate_allele_sum_rock + reference_allele_sum_rock)))\n \n abs_alt_set['Sand'].append(alternate_allele_sum_sand)\n perc_alt_set['Sand'].append(float((alternate_allele_sum_sand)/(alternate_allele_sum_sand + reference_allele_sum_sand)))\n \n with open('log_file.txt','a') as LOG_FILE:\n if(float((alternate_allele_sum_rock)/(alternate_allele_sum_rock + reference_allele_sum_rock))>float(sys.argv[2]) or float((alternate_allele_sum_sand)/(alternate_allele_sum_sand + reference_allele_sum_sand))>float(sys.argv[2])):\n print >> LOG_FILE,inversion \n \n\n print \"Sand : \"+str(count_sand)\n\n if return_flag == True:\n #print len([abs_alt_inv_set,abs_ref_inv_set,perc_alt_inv_set,perc_ref_inv_set])\n return perc_alt_inv_set\n else:\n return [abs_alt_set,perc_alt_set]","def make_control_knowledge(self, horizon):\n\n \"\"\" *** YOUR CODE HERE *** \"\"\"\n\n # ADD_RULE1_COUNT = 0\n # ADD_RULE2_COUNT = 0\n # ADD_RULE3_COUNT = 0\n\n close = list()\n far = list()\n\n for g in self.problem.goal:\n for p in self.problem.propositions:\n if re.match(r'at\\spackage\\d+\\scity\\d+-\\d+', str(p)):\n p_split = str(p).split()\n g_split = str(g).split()\n\n # if \"at\" and \"package[oo]\" match\n if p_split[0] == g_split[0] and p_split[1] == g_split[1]:\n # also \"city[oo]-[xx]\" match\n if p_split[2][:-2] == g_split[2][:-2]:\n close.append(p)\n else:\n far.append(p)\n\n # Rule 1:\n # ===============================\n # If a package is at its goal location, then it must remain there.\n # p@t and goal@t) -> p@t+1), where p is at(package, location)\n # cnf: not p@t or not goal@t or p@t+1\n\n for g in self.problem.goal:\n for t in range(0, horizon):\n clause = list()\n clause.append(-self.proposition_fluent_codes[(g, t)])\n clause.append(self.proposition_fluent_codes[(g, t + 1)])\n self.add_clause(clause, \"control\")\n # ADD_RULE1_COUNT += 1\n\n for t in range(0, horizon):\n for a in self.problem.actions:\n\n # Rule 2\n # ===============================\n\n # RULE\n # close -> do not load airplane\n # p1: close@t\n # p2: at the location of an airport @t\n # p3: airplane at this location @t\n # p4: plane is not loaded\n # a: load this airplane\n #\n # p1@t and p2@t and p3@t and p4@t => a@t\n # not p1@t or not p2@t or not p3@t or not p4@t or a@t\n # cnf: not p@t or not a@t\n if str(a).startswith('load-airplane'):\n for i in close:\n package = str(i).split()[1]\n if str(a).split()[1] == package:\n clause = list()\n clause.append(\n -self.proposition_fluent_codes[(i, t)])\n clause.append(-self.action_fluent_codes[(a, t)])\n self.add_clause(clause, \"control\")\n # ADD_RULE2_COUNT += 1\n\n # Rule 3\n # ===============================\n\n # RULE\n # far -> do not unload airplane\n # p@t -> not a@t, where p is far, a is unload-airplane\n # cnf: not p@t or not a@t\n if str(a).startswith('unload-airplane'):\n for j in far:\n package = str(j).split()[1]\n if str(a).split()[1] == package:\n clause = list()\n clause.append(\n -self.proposition_fluent_codes[(j, t)])\n clause.append(-self.action_fluent_codes[(a, t)])\n self.add_clause(clause, \"control\")\n # ADD_RULE3_COUNT += 1\n\n # # RULE\n # # if an airplane has a package on it and the package's\n # # destination is close do not fly this airplane.\n # # in fact, if the destination of package is far,\n # # fly this plane to it.\n # #\n # # p1: package on airplane @ t\n # # p2: package at a place @ t\n # # p3: the place and the goal are in the same city\n # # rule: p1@t and p2@t and p@3 => not fly plane@t\n # # and unload the plane@t\n #\n # # not p1@t or not p2@t or not fly@t\n # # not p1@t or not p2@t or unload\n #\n # # rule: p1@t and p2@t and not p3@t => fly plane@t and not\n # # unload the plane@t\n #\n # if str(a).startswith('fly-airplane'):\n # plane = str(a).split()[1]\n # # loc_from = str(a).split()[2]\n # for p1 in self.problem.propositions:\n # if str(p1).startswith('in package') and str(p1).split()[2] == plane: # in package plane\n # package = str(p1).split()[1]\n # for p2 in self.problem.propositions:\n # if p2 in close and str(p2).split()[1] == package: # at package location\n # clause = list()\n # clause.append(-self.proposition_fluent_codes[p1, t])\n # clause.append(-self.proposition_fluent_codes[p2, t])\n # clause.append(-self.action_fluent_codes[a, t])\n # self.add_clause(clause, 'control')\n # ADD_RULE2_COUNT += 1\n #\n #\n # for g in self.problem.goal:\n # if str(g).split()[1] == package:\n # destination = str(g).split()[2]\n # for do in self.problem.actions:\n # # unload-airplane package00 plane00 city00-00\n # if str(do).startswith('unload') and str(do).split()[1] == package and str(do).split()[2] == plane and str(do).split()[3] == destination:\n # clause2 = list()\n # clause2.append(-\n # self.proposition_fluent_codes[\n # p1, t])\n # clause2.append(-\n # self.proposition_fluent_codes[\n # p2, t])\n # clause2.append(\n # self.action_fluent_codes[\n # do, t])\n # self.add_clause(clause2,\n # 'control')\n #\n # ADD_RULE3_COUNT += 1\n\n # RULE\n # if there is no package needs to be transferred at a location,\n # and the location has a truck\n # drive the truck to its airport\n\n # p1: (at package__ city__-__ /\\ (it is a goal)@t\n # p2: (at truck__ city__-__)@t\n # p3: (city__-__ is not airport)\n # not p1/\\p2/\\p3 => drive_truck_to_its_airport@t\n #\n #\n # CNF: p1 V not p2 V not p3 V drive_truck_to_its_airport@t\n # if str(a).startswith('DRIVE-TRUCK'):\n # for p1 in self.problem.goal:\n # city = str(p1).split()[2]\n # for p2 in self.problem.propositions:\n # if str(p2).startswith('at truck') and str(p2).split()[2] == city:\n # for p3 in self.problem.propositions:\n # if str(p3).startswith('airport') and str(p3).split()[1] == city:\n # clause = list()\n # clause.append(self.proposition_fluent_codes[(p1, t)])\n # clause.append(-self.proposition_fluent_codes[(p2, t)])\n # clause.append(-self.proposition_fluent_codes[(p3, t)])\n # clause.append(self.action_fluent_codes[(a, t)])\n # self.add_clause(clause, \"control\")\n\n # RULE\n # if there is an airplane is loaded with a package need\n # transfer (to another city), fly airplane to the corresponding\n # city.\n\n # p1: (at airplane__ city__-__)@t\n # p2: (in package__ airplane__)@t\n # p3: ( p2 is in far)\n # p1/\\p2/\\p3 => fly_airplane_to_its_airport@t\n #\n #\n # CNF: not p1@t V not p2@t V not p3@t V fly_plane_to_airport@t\n\n # print(\"ADDED RULE 1:\")\n # print(ADD_RULE1_COUNT)\n #\n # print(\"ADDED RULE 2:\")\n # print(ADD_RULE2_COUNT)\n #\n # print(\"ADDED RULE 3:\")\n # print(ADD_RULE3_COUNT)","def ica(n_components, ecg_ch_name, eog_ch_name):\n from neuropype_ephy.interfaces.mne.preproc import CompIca\n ica_node = pe.Node(interface=CompIca(), name='ica')\n ica_node.inputs.n_components = n_components\n ica_node.inputs.ecg_ch_name = ecg_ch_name\n ica_node.inputs.eog_ch_name = eog_ch_name\n return ica_node","def finetune_acceptor_boundaries(abfgp_genemodel,introndata,\n array_algpresence,array_algsimilarity,verbose=True):\n\n # Global Variable Imports\n from settings.genestructure import MIN_INTRON_NT_LENGTH\n FINETUNE_ACCEPTOR_NT_OFFSET = 18\n\n # list with adjusted boundaries\n refined_boundaries = []\n\n # recreate lists of ABGFP exons & introns\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\n\n for intron_pos in range(0,len(abfgp_introns)):\n intron = abfgp_introns[intron_pos]\n if not intron: continue\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\n\n # assign branchpoint in current intron\n intron.assign_bp_and_ppts()\n\n has_been_printed = False\n\n # list of alternatives & associated scores\n alternatives = []\n finetune_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1,3)\n\n for acceptor in intron.orfAcceptor._acceptor_sites:\n if acceptor.pos != intron.acceptor.pos and\\\n acceptor.pos in finetune_range:\n # get the next exon (3'of this intron)\n next_exon = abfgp_exons[intron_pos+1]\n if not has_been_printed:\n has_been_printed = True\n ############################################################\n if verbose: print \"FINETUNING ACCEPTOR::\", intron\n ############################################################\n\n # get data on this alternative acceptor position\n test_intron = IntronConnectingOrfs(intron.donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\n test_intron.assign_bp_and_ppts()\n\n # test if refinement will result in a long enough intron\n if test_intron.length < MIN_INTRON_NT_LENGTH: continue\n\n scorelist = []\n # score 1: is acceptor.pssm_score `higher`?\n scorelist.append( _finetune_splicesite_comparison(intron.acceptor,test_intron.acceptor) )\n # score 2: branchpoint comparison?\n scorelist.append( _branchpoint_comparison(intron,test_intron) )\n # score 3: ppt comparison?\n scorelist.append( _polypyrimidinetract_comparison(intron,test_intron) )\n # score 4: is algsimilarity ratio increased (==better)?\n scorelist.append( _algsimilarity_comparison(intron,test_intron,None,next_exon,array_algsimilarity) )\n\n # evaluate scorelist; improved intron boundary or not?\n # use acceptor, branchpoint & ppt, do *NOT* use algsim score\n if scorelist[0:3].count(False) == 0 and scorelist[0:3].count(True) >= 1:\n alternatives.append( ( acceptor, scorelist ) )\n is_accepted = True\n else:\n is_accepted = False\n\n ################################################################\n if verbose:\n print \"alternative:\", acceptor,\n print intron.acceptor.pos - acceptor.pos, scorelist,\n print is_accepted, \"BP:\",\n print intron.get_branchpoint_nt_distance(),\n print \"alt:\",\n print test_intron.get_branchpoint_nt_distance()\n ################################################################\n\n # now evaluate the alternatived and take the best one\n if not alternatives:\n continue\n elif len(alternatives) == 1:\n refined_boundaries.append( ( intron.acceptor, alternatives[0][0] ) )\n else:\n # multiple! again, take the *best* one\n pass\n\n # return list of refined_boundaries\n return refined_boundaries","def genPrimerPairs_5Ext(primer_length=20, anneal_length=10, GC_low=40, GC_high=60):\n\n print('Primers for 5\\' extension half-asstemers')\n\n forwTemplate5_3 = GenOligoGC(primer_length,GC_low, GC_high)\n \"\"\"re.match checks if the first 2 Nuc are GC in the forward and backwards direction\"\"\"\n while not (re.match(\"[GC]{2}\",str(forwTemplate5_3)) and\n re.match(\"[GC]{2}\", str(forwTemplate5_3[::-1])) and\n re.match(\"[GC]{2}\", str(forwTemplate5_3[10:12]))):\n\n forwTemplate5_3 = GenOligoGC(primer_length,GC_low, GC_high)\n\n forwTemp3_5 = forwTemplate5_3[::-1]\n forwPrimer5_3 = forwTemp3_5.complement()\n print(f\"Template Seq 3\\' - > 5\\': {forwTemp3_5}\")\n print(f\"ForwPrimer Seq 5\\' - > 3\\': {forwPrimer5_3}\")\n\n forwPrimer_f10 = forwPrimer5_3[:10]\n print(f\"First 10 Nucleotides of forward primer: {forwPrimer_f10}\")\n\n revPrimer_f10 = GenOligoGC(10,GC_low, GC_high)\n while not re.match(\"[GC]{2}\",str(revPrimer_f10)):\n revPrimer_f10 = GenOligoGC(10,GC_low, GC_high)\n\n revPrimer5_3 = revPrimer_f10 + forwPrimer_f10\n\n print(f\"RevPrimer Seq 5\\' - > 3\\': {revPrimer5_3}\")\n\n return forwPrimer5_3, revPrimer5_3","def part_one():\n return \"\".join(networkx.lexicographical_topological_sort(G))","def _graph_priority(self, nodes):\n \n fakes = self.fakes(nodes)\n \n # There theoretically should only be one fake per subgraph\n if len(fakes) == 1:\n return fakes[0]\n\n # If for some reason there is more, its likely due to poor indexes and just pick one\n elif len(fakes) > 1:\n logger.error('More Than One Fake Node In Subgraph {}, \\\n Paths between fake nodes results in unreliable sequence!'.format(fakes))\n return np.random.choice(fakes)\n\n # If there is no fake node in the subgraph, its not close to infastructure and thus priority is given to MAX(priority metric)\n else:\n return self.metrics[self.priority_metric].ix[nodes].idxmax()","def create_GO(init_file, no_COOH, no_epoxy, no_OH, filename1):\n global atoms\n global bond_list\n bond_list = bond_list_1\n atoms = read_in_graphene(init_file)\n global anywhere_map\n anywhere_map = get_map_anywhere(atoms)\n global edge_map\n edge_map = get_map_edge(atoms)\n \n list_residue_numbers = [x.residue_number for x in atoms]\n added_functional_groups = max(list_residue_numbers)\n \n must_add = no_COOH + no_epoxy + no_OH\n while (must_add > 0):\n print(\"Left to add: \", \"cooh: \", no_COOH, \"epoxy: \", no_epoxy, \"hydroxyl: \", no_OH)\n chosen = random.choice(pick_to_add(no_COOH, no_epoxy, no_OH))\n if (chosen == \"carboxyl\"):\n attempt = 0\n while (attempt < 50):\n old_length = len(atoms)\n new_atoms = add_carboxyl(random_pick_spot(\"carboxyl\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\n if (old_length != len(new_atoms)):\n atoms = new_atoms\n added_functional_groups += 1\n must_add -= 1\n no_COOH -= 1\n attempt = 1888\n else:\n attempt += 1\n if (attempt == 50):\n must_add = -1\n elif (chosen == \"epoxy\"): \n attempt = 0\n while (attempt < 50):\n old_length = len(atoms)\n new_atoms = add_epoxy(random_pick_spot(\"epoxy\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\n if (old_length != len(new_atoms)):\n atoms = new_atoms\n added_functional_groups += 1\n must_add -= 1\n no_epoxy -= 1\n attempt = 1888\n else:\n attempt += 1\n if (attempt == 50):\n must_add = -1\n elif (chosen == \"hydroxyl\"):\n attempt = 0\n while (attempt < 50):\n old_length = len(atoms)\n new_atoms = add_hydroxyl(random_pick_spot(\"hydroxyl\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\n if (old_length != len(new_atoms)):\n atoms = new_atoms\n added_functional_groups += 1\n must_add -= 1\n no_OH -=1\n attempt = 1888 \n else:\n attempt += 1\n if (attempt == 50):\n must_add = -1\n atno = 1\n new_list = []\n for atom in atoms:\n if (atom.atom_name == \"CX\"):\n New_CX = Atom(atno, \"CX\", \"GGG\", atno, atom.x, atom.y, atom.z)\n new_list.append(New_CX)\n atno += 1 \n \n for atom in atoms:\n if (atom.atom_name == \"C4\"):\n check = False\n for atom_CY in atoms:\n if ((atom_CY.atom_name == \"CY\") and (atom_CY.residue_name == \"C1A\") and (atom_CY.residue_number == atom.residue_number)):\n for atom_OJ in atoms:\n if ((atom_OJ.atom_name == \"OJ\") and (atom_OJ.residue_name == \"C1A\") and (atom_OJ.residue_number == atom.residue_number)):\n for atom_OK in atoms:\n if ((atom_OK.atom_name == \"OK\") and (atom_OK.residue_name == \"C1A\") and (atom_OK.residue_number == atom.residue_number)):\n for atom_HK in atoms:\n if ((atom_HK.atom_name == \"HK\") and (atom_HK.residue_name == \"C1A\") and (atom_HK.residue_number == atom.residue_number)):\n New_CY = Atom(atno + 0, \"CY\", \"C1A\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z )\n New_C4 = Atom(atno + 1, \"C4\", \"C1A\", atom.residue_number, atom.x, atom.y, atom.z)\n New_OJ = Atom(atno + 2, \"OJ\", \"C1A\", atom.residue_number, atom_OJ.x, atom_OJ.y, atom_OJ.z)\n New_OK = Atom(atno + 3, \"OK\", \"C1A\", atom.residue_number, atom_OK.x, atom_OK.y, atom_OK.z)\n New_HK = Atom(atno + 4, \"HK\", \"C1A\", atom.residue_number, atom_HK.x, atom_HK.y, atom_HK.z)\n atno += 5\n new_list.append(New_CY); new_list.append(New_C4); new_list.append(New_OJ); new_list.append(New_OK); new_list.append(New_HK);\n check = True\n break\n if (check == True):\n break\n if (check == True):\n break\n if (check == True):\n break \n \n elif (atom.atom_name == \"OE\"): \n check = False\n for atom_CY in atoms:\n if ((atom_CY.atom_name == \"CY\") and (atom_CY.residue_name == \"E1A\") and (atom_CY.residue_number == atom.residue_number)):\n for atom_CY2 in atoms: \n if ((atom_CY2.atom_name == \"CZ\") and (atom_CY2.residue_name == \"E1A\") and (atom_CY2.residue_number == atom.residue_number) and (atom_CY2 != atom_CY)):\n New_CY = Atom( atno + 0, \"CY\", \"E1A\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z)\n New_CY2 = Atom(atno + 1, \"CZ\", \"E1A\", atom.residue_number, atom_CY2.x, atom_CY2.y, atom_CY2.z)\n New_OE = Atom( atno + 2, \"OE\", \"E1A\", atom.residue_number, atom.x, atom.y, atom.z)\n atno += 3\n new_list.append(New_CY); new_list.append(New_CY2); new_list.append(New_OE);\n check = True\n break\n if (check == True):\n break\n elif (atom.atom_name == \"OL\"):\n check = False\n for atom_CY in atoms:\n if ((atom_CY.atom_name == \"CY\") and (atom_CY.residue_name == \"H1A\") and (atom_CY.residue_number == atom.residue_number)):\n for atom_HK in atoms:\n if ((atom_HK.atom_name == \"HK\") and (atom_HK.residue_name == \"H1A\") and (atom_HK.residue_number == atom.residue_number)):\n New_CY = Atom(atno + 0, \"CY\", \"H1A\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z)\n New_OL = Atom(atno + 1, \"OL\", \"H1A\", atom.residue_number, atom.x, atom.y, atom.z)\n New_HK = Atom(atno + 2, \"HK\", \"H1A\", atom.residue_number, atom_HK.x, atom_HK.y, atom_HK.z)\n atno += 3\n new_list.append(New_CY); new_list.append(New_OL); new_list.append(New_HK);\n check = True\n break\n if (check == True):\n break\n \n atoms = new_list.copy()\n writepdb(atoms, filename1)\n sum_c1a = 0; sum_e1a = 0; sum_h1a = 0; sum_ggg = 0\n for atom in atoms:\n if (atom.residue_name == \"C1A\"):\n sum_c1a += 1\n elif (atom.residue_name == \"E1A\"):\n sum_e1a += 1\n elif (atom.residue_name == \"H1A\"):\n sum_h1a += 1\n elif (atom.residue_name == \"GGG\"):\n sum_ggg += 1\n print(\"Placed:\")\n print(\"carboxyl: \", sum_c1a/5)\n print(\"epoxy: \", sum_e1a/3)\n print(\"hydroxyl: \", sum_h1a/3)\n print(\"graphene atoms (CX - GGG) left: \", sum_ggg)\n return 'done.'","def aco(self, gens, current_gen, client):\n # The time at the start of the algorithm\n time_start = time.time()\n\n # Initalise the colony and its parameters\n self.colony = Colony()\n self.colony.ants = self.ants\n self.colony.shortest_path = self.shortest_path\n self.colony.min_distance = self.min_distance\n\n # Initialise an array to be append with nodes\n shortest_path = []\n\n # Do generations from the current generation to the generation number needed\n for i in range(current_gen, gens):\n\n # The current time\n time_now = time.time()\n time_elapsed = time_now-time_start\n # If exectutiion time has reached 25 seconds, return result\n if (time_elapsed) > 25:\n break\n\n # Ants within colony perform their tours\n self.colony.perform_tours(self)\n\n # Get the shortest tour found by the ants\n shortest_path = self.colony.shortest_path\n\n # Global update of pheromones\n self.update_pheromones(self.colony)\n\n # Generation successful, thus increase the generation reached\n gen_reached = i+1\n\n # Update Instance parameters to be returned to client\n self.shortest_path = shortest_path\n self.min_distance = self.colony.min_distance\n msg = \"Generation \" + str(i) + \" distance \" + str(round(self.colony.min_distance, 3)) + \" path \" + str(shortest_path)\n\n # Emit a message using SocketIO for a dynamic console\n socketio.emit('my event', msg, room=client)\n socketio.sleep(0.00000000001)\n\n return gen_reached, shortest_path, self.colony.min_distance","def test_get_top_step_matches(self):\n\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\n\n self.assertEqual(len(results._top_step_matches), 2)\n\n cad3_top_matches = results.get_sample_matches('C_chlorochromatii_CaD3', top=True)\n dsm_273_top_matches = results.get_sample_matches('C_luteolum_DSM_273', top=True)\n\n self.assertEqual(len(cad3_top_matches), 1)\n self.assertEqual(len(dsm_273_top_matches), 1)\n\n self.assertEqual(cad3_top_matches['Protein_Accession'].tolist()[0], 'NC_007514.1_940')\n self.assertEqual(dsm_273_top_matches['Protein_Accession'].tolist()[0], 'NC_007512.1_1088')","def add_initial_side_chains_from_propensities(\n self, G, raw_or_rank, test=False, input_num={}\n ):\n\n # Initialises dictionary of starting sequences\n initial_networks = OrderedDict()\n ids_list = []\n for num in range(2*self.pop_size):\n unique_id = ''.join(\n [random.choice(string.ascii_letters + string.digits)\n for i in range(10)]\n )\n initial_networks[unique_id] = copy.deepcopy(G)\n ids_list.append(unique_id)\n\n # Extracts individual amino acid propensity scales for the surface\n intext_index = self.dict_name_indices['intorext']\n eoc_index = self.dict_name_indices['edgeorcent']\n prop_index = self.dict_name_indices['prop1']\n pairindv_index = self.dict_name_indices['pairorindv']\n discorcont_index = self.dict_name_indices['discorcont']\n proporfreq_index = self.dict_name_indices['proporfreq']\n dicts = OrderedDict({\n dict_label: scale_dict for dict_label, scale_dict in\n {**self.propensity_dicts, **self.frequency_dicts}.items()\n if dict_label.split('_')[pairindv_index] == 'indv'\n })\n\n for node_index, node in enumerate(list(G.nodes())):\n if G.nodes()[node]['type'] == 'loop':\n continue\n\n int_ext = G.nodes()[node]['int_ext']\n sub_dicts = OrderedDict(\n {dict_label: scale_dict for dict_label, scale_dict in dicts.items()\n if dict_label.split('_')[intext_index] in [int_ext, '-']}\n )\n if self.barrel_or_sandwich == '2.60':\n # Filters propensity and frequency scales depending upon\n # whether the node is in an edge or a central strand\n eoc = G.nodes()[node]['eoc']\n sub_dicts = OrderedDict(\n {dict_label: scale_dict for dict_label, scale_dict in sub_dicts.items()\n if dict_label.split('_')[eoc_index] in [eoc, '-']}\n )\n\n if sub_dicts == {}:\n if test is True: # Avoids code crashing if e.g. there are no\n # dicts for ext residues\n continue\n else:\n raise ValueError('No propensity or scoring metrics '\n 'available for node {}'.format(node))\n\n # Calculates summed propensity for each amino acid across all\n # structural features considered in the design process\n node_indv_propensities = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\n node_indv_frequencies = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\n\n for dict_index, dict_label in enumerate(list(sub_dicts.keys())):\n scale_dict = sub_dicts[dict_label]\n dict_weight = self.dict_weights[dict_label]\n node_prop = dict_label.split('_')[prop_index]\n node_val = np.nan\n\n if node_prop != '-':\n try:\n node_val = G.nodes()[node][node_prop]\n except KeyError:\n raise KeyError('{} not defined for node {}'.format(node_prop, node))\n # Converts non-float values into np.nan\n if node_val in ['', 'nan', 'NaN', np.nan]:\n node_val = np.nan\n\n value = np.nan\n if dict_label.split('_')[discorcont_index] == 'cont' and not np.isnan(node_val):\n if dict_label.split('_')[proporfreq_index] != 'propensity':\n raise Exception(\n 'Unexpected dictionary {} - expect only continuous '\n 'propensity dictionaries'.format(dict_label)\n )\n\n # Interpolate dictionary\n for aa, aa_scale in scale_dict.items():\n aa_index = self.aa_list.index(aa)\n value = linear_interpolation(node_val, aa_scale, dict_label)\n\n if value <= 0:\n raise ValueError(\n '{} returned after interpolation of {} for node'\n ' {}'.format(value, dict_label, node)\n )\n\n if np.isnan(value):\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n value = 0.0001 # Since dataset used to generate\n # prop and freq dicts is ~10,000 aas => smallest\n # propensity could be is ((1/5000)/(5001/10000)\n # = 0.0004 (for a discrete propensity))\n\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n node_indv_propensities[dict_index][aa_index] = (\n dict_weight*np.negative(np.log(value))\n )\n\n elif dict_label.split('_')[discorcont_index] == 'disc':\n # Filter dataframe\n scale_dict_copy = copy.deepcopy(scale_dict).set_index('FASTA', drop=True)\n for aa_index, aa in enumerate(self.aa_list):\n if node_prop == '-':\n try:\n value = scale_dict_copy.iloc[:,0][aa]\n except KeyError:\n raise Exception('{} not defined in {}'.format(aa, dict_label))\n elif node_prop == 'phipsi':\n if not np.isnan(node_val):\n try:\n value = scale_dict_copy[node_val][aa]\n except KeyError:\n raise Exception('{},{} not defined in {}'.format(\n node_val, aa, dict_label\n ))\n\n if value <= 0:\n raise ValueError(\n '{} returned after interpolation of {} for node'\n ' {}'.format(value, dict_label, node)\n )\n\n if np.isnan(value):\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n value = 0.0001 # Since dataset used to generate\n # prop and freq dicts is ~10,000 aas => smallest\n # propensity could be is ((1/5000)/(5001/10000)\n # = 0.0004 (for a discrete propensity))\n else:\n value = 0\n\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n node_indv_propensities[dict_index][aa_index] = (\n dict_weight*np.negative(np.log(value))\n )\n elif dict_label.split('_')[proporfreq_index] == 'frequency':\n node_indv_frequencies[dict_index][aa_index] = dict_weight*value\n\n # Sums propensity and frequency values, then filters to remove amino\n # acids with a propensity / frequency of 0\n node_indv_propensities = np.nansum(node_indv_propensities, axis=0)\n node_indv_frequencies = np.nansum(node_indv_frequencies, axis=0)\n\n if (\n set(node_indv_propensities) == {0}\n or (self.frequency_dicts != {} and set(node_indv_frequencies) == {0})\n ):\n raise Exception('Cannot select side chain identity for node '\n '{}'.format(node))\n\n # Removes aas for which all propensity and/or frequency readings (as\n # appropriate) are np.nan\n filt_aa_list = []\n filt_node_prop = []\n filt_node_freq = []\n for aa_index, aa in enumerate(self.aa_list):\n prop = node_indv_propensities[aa_index]\n freq = node_indv_frequencies[aa_index]\n if (\n (self.frequency_dicts == {} and prop == 0)\n or (self.frequency_dicts != {} and prop == 0 and freq == 0)\n ):\n continue\n filt_aa_list.append(aa)\n filt_node_prop.append(prop)\n filt_node_freq.append(freq)\n filt_aa_list = np.array(filt_aa_list)\n filt_node_prop = np.array(filt_node_prop)\n filt_node_freq = np.array(filt_node_freq)\n\n # Converts propensities and frequencies into probability\n # distributions\n (node_prop_index, node_prop, node_prop_probabilities\n ) = calc_probability_distribution(\n node_indv_propensities, 'propensity', raw_or_rank, test\n )\n node_prop_index = node_prop_index.astype(int)\n if self.frequency_dicts != {}:\n (node_freq_index, node_freq, node_freq_probabilities\n ) = calc_probability_distribution(\n filt_node_freq, 'frequency', raw_or_rank, test\n )\n else:\n node_freq_index = copy.deepcopy(node_prop_index)\n node_freq = np.full(filt_node_freq.shape, 0)\n node_freq_probabilities = np.full(filt_node_freq.shape, 0)\n node_freq_index = node_freq_index.astype(int)\n\n node_probabilities = np.full(node_prop_probabilities.shape, np.nan)\n for index_prop, aa in np.ndenumerate(copy.deepcopy(node_prop_index)):\n index_freq = np.where(node_freq_index == aa)[0][0]\n propensity = node_prop_probabilities[index_prop]\n frequency = node_freq_probabilities[index_freq]\n\n # Since propensity_weight is a hyperparameter to be optimised\n # with hyperopt, for initial sequence generation the propensity\n # and frequency scales are weighted equally (unless not\n # performing hyperparameter optimisation, in which case use the\n # propensity_weight specified in the input file)\n try:\n prop_weight = self.propensity_weight\n freq_weight = 1 - self.propensity_weight\n except AttributeError:\n prop_weight = 0.5\n freq_weight = 0.5\n probability = (prop_weight*propensity) + (freq_weight*frequency)\n node_probabilities[index_prop] = probability\n filt_aa_list = filt_aa_list[node_prop_index]\n node_cumulative_probabilities = gen_cumulative_probabilities(\n node_probabilities, node\n )\n\n # Selects amino acid weighted by its probability\n for unique_id in ids_list:\n if test is False:\n random_number = random.uniform(0, 1)\n elif test is True:\n random_number = input_num[node]\n nearest_index = (np.abs(node_cumulative_probabilities-random_number)).argmin()\n\n if node_cumulative_probabilities[nearest_index] >= random_number:\n selected_aa = filt_aa_list[nearest_index]\n else:\n selected_aa = filt_aa_list[nearest_index+1]\n\n nx.set_node_attributes(\n initial_networks[unique_id],\n values={'{}'.format(node): {'aa_id': '{}'.format(selected_aa)}}\n )\n\n return initial_networks","def localization(Gint, focal_genes, num_reps = 10, sample_frac = 0.8, method = 'numedges', plot = True, print_counter = False,\n background_list=None):\n\n # Create degree bins to sample from\n bins = get_degree_binning(Gint, 10)\n min_degree, max_degree, genes_binned = zip(*bins)\n bin_df = pd.DataFrame({'min_degree':min_degree, 'max_degree':max_degree, 'genes_binned':genes_binned})\n \n # create a lookup table for degree and index\n actual_degree_to_bin_df_idx = {}\n for i in range(0, bin_df['max_degree'].max() + 1):\n idx_temp = bin_df[ (bin_df['min_degree'].lt(i + 1)) & (bin_df['max_degree'].gt(i - 1)) ].index.tolist()\n\n if len(idx_temp) > 0: # there are some degrees which aren't represented in the graph\n actual_degree_to_bin_df_idx[i] = idx_temp[0]\n \n focal_genes = list(np.intersect1d(focal_genes, Gint.nodes())) # only use focal_genes which are in Gint\n\n numedges_list = []\n numedges_rand = []\n LCC_list = []\n LCC_rand = []\n \n if background_list==None:\n background_list=Gint.nodes()\n \n for r in range(num_reps):\n\n if print_counter == True:\n # so user knows how far along the process is\n if (r % 25) == 0:\n print(r)\n\n focal_80 = focal_genes\n np.random.shuffle(focal_80)\n focal_80 = focal_80[:int(len(focal_80)*sample_frac)]\n\n # find genes with similar degrees to focal gene degree\n seed_random = []\n for g in focal_80:\n degree_temp = nx.degree(Gint,g)\n genes_temp = bin_df.loc[actual_degree_to_bin_df_idx[degree_temp]]['genes_binned'] # use the lookup table for speed\n np.random.shuffle(genes_temp) # shuffle them\n while (genes_temp[0] in seed_random) or (genes_temp[0] not in background_list): # make sure the gene isn't already in the list, but is in the background_list\n np.random.shuffle(genes_temp) # shuffle them\n \n seed_random.append(genes_temp[0]) # build the seed_D1_random list\n \n #print(len(focal_80))\n #print(len(seed_random))\n #print(len(np.unique(seed_random)))\n\n if (method == 'numedges') or (method == 'both'):\n \n # number edges calc on focal set\n numedges_temp = len(nx.subgraph(Gint,focal_80).edges())\n numedges_list.append(numedges_temp)\n \n # number edges calc on random sample\n numedges_temp_rand = len(nx.subgraph(Gint,seed_random).edges())\n numedges_rand.append(numedges_temp_rand)\n \n if (method == 'LCC') or (method == 'both'):\n \n # LLC calc on focal set\n G_sub_temp = nx.Graph(nx.subgraph(Gint, focal_80))\n G_sub_temp = max(nx.connected_component_subgraphs(G_sub_temp), key = len)\n LCC_list.append(len(G_sub_temp.nodes()))\n \n # LLC calc on random sample\n G_sub_temp = nx.Graph(nx.subgraph(Gint, seed_random))\n G_sub_temp = max(nx.connected_component_subgraphs(G_sub_temp), key=len)\n LCC_rand.append(len(G_sub_temp.nodes()))\n \n if plot == True:\n if (method == 'numedges') or (method == 'both'):\n fig, ax = plt.subplots(figsize = (12, 7))\n sns.distplot(numedges_list, ax = ax, hist = True, label = 'focal genes')\n sns.distplot(numedges_rand, ax = ax, hist = True, label = 'random set')\n plt.ylabel('frequency', fontsize = 16)\n plt.xlabel('number of edges', fontsize = 16)\n plt.title('Number of Edges Localization', fontsize = 18)\n plt.legend(loc = 'upper right', fontsize = 14)\n \n if (method == 'LCC') or (method == 'both'):\n fig, ax = plt.subplots(figsize = (12, 7))\n sns.distplot(LCC_list, ax = ax, hist = True, label = 'focal genes')\n sns.distplot(LCC_rand, ax = ax, hist = True, label = 'random set')\n plt.ylabel('frequency', fontsize = 16)\n plt.xlabel('largest connected component size', fontsize = 16)\n plt.title('Largest Connected Component Localization', fontsize = 18)\n plt.legend(loc = 'upper right', fontsize = 14)\n \n return numedges_list, numedges_rand, LCC_list, LCC_rand","def get_cuckoos(nest, best, Lb, Ub):\n\tn = nest.shape[0]\n\tbeta=3/2;\n\tsigma=(sp.gamma(1+beta)*np.sin(np.pi*beta/2)/(sp.gamma((1+beta)/2)*beta*2**((beta-1)/2)))**(1/beta);\n\tfor j in range(n):\n\t\ts = nest[j,:]\n\t\t#u=np.random.randn(s.shape[0])*sigma\n\t\t#v=np.random.randn(s.shape[0])\n\t\t#step=u/abs(v)**(1/beta)\n\t\t#stepsize=0.01*step*(s-best);\n\t\ts=s+ss.levy.rvs(size=21)*1e-40\n\t\tnest[j,:]=simple_bounds(s, Lb, Ub)\n\treturn nest","def find_top(self, gravityDir):\n dirs = [\"-X\", \"+X\", \"-Y\", \"+Y\", \"-Z\", \"+Z\"]\n for dir in dirs:\n argsval = [\"NAME:\" + dir + \" Padding Data\", \"Value:=\", \"0\"]\n args = [\n \"NAME:AllTabs\",\n [\n \"NAME:Geometry3DCmdTab\",\n [\"NAME:PropServers\", \"Region:CreateRegion:1\"],\n [\"NAME:ChangedProps\", argsval],\n ],\n ]\n self.modeler.oeditor.ChangeProperty(args)\n oBoundingBox = self.modeler.get_model_bounding_box()\n if gravityDir < 3:\n return oBoundingBox[gravityDir + 3]\n else:\n return oBoundingBox[gravityDir - 3]"],"string":"[\n \"def GetTopConfidenceNodes(g, dia, topn=20):\\r\\n conf_hf = {}\\r\\n for i in g.nodes(data=True):\\r\\n n, distr = i\\r\\n if (distr['class_distribution']['No Diagnosis'] != 0):\\r\\n conf_hf[n] = distr['class_distribution']['Diagnosis'] / (\\r\\n distr['class_distribution']['Diagnosis'] + distr['class_distribution']['No Diagnosis'])\\r\\n nx.set_node_attributes(g, conf_hf, 'confidence')\\r\\n nodeconf = {i[0]: i[1]['confidence'] for i in g.nodes(data=True) if\\r\\n (i[1]['class_distribution']['No Diagnosis'] != 0)}\\r\\n nodeconf_sorted = sorted(nodeconf.items(), key=operator.itemgetter(1), reverse=True)\\r\\n PrintCodeDescr(g, dia, nodeconf_sorted[:topn], mode=\\\"node\\\")\",\n \"def most_discriminating( features_df, labels_df, top=5):\\n \\n columns = features_df.shape[1]\\n labels_df = labels_df[['file', 'candy_id']].set_index('file')\\n qualities = np.zeros(columns)\\n \\n _left = 0\\n _right = 1\\n\\n _c = 0\\n _h = 1\\n\\n # globals\\n cases = float(labels_df['candy_id'].count()) # total cases\\n\\n p_c_A = (labels_df['candy_id'] == 0).sum() / cases\\n p_h_A = 1.0 - p_c_A\\n\\n\\n for feature in range(columns):\\n\\n branch_cases = np.zeros(2) # total on each branch\\n pi = np.zeros(2) # proportion on each branch\\n\\n split = np.array([\\n #c, h\\n [0, 0], #left\\n [0, 0] #right\\n ])\\n\\n for index, value in features_df[feature].iteritems():\\n split[value][labels_df.loc[index][0]] += 1\\n\\n branch_cases[_left] = split[_left].sum()\\n branch_cases[_right] = split[_right].sum()\\n \\n if branch_cases[_left] == 0.0 or branch_cases[_right] == 0.0:\\n qualities[feature] = 0\\n continue\\n \\n pi[_left] = branch_cases[_left] / cases\\n pi[_right] = branch_cases[_right] / cases\\n\\n p_c_B = split[_left][_c] / branch_cases[_left]\\n p_h_B = split[_left][_h] / branch_cases[_left]\\n\\n p_c_C = split[_right][_c] / branch_cases[_right]\\n p_h_C = split[_right][_h] / branch_cases[_right]\\n\\n gini_tree = 1.0 - (math.pow(p_c_A, 2) + math.pow(p_h_A, 2))\\n\\n gini_left = 1.0 - (math.pow(p_c_B, 2) + math.pow(p_h_B, 2))\\n gini_right = 1.0 - (math.pow(p_c_C, 2) + math.pow(p_h_C, 2))\\n\\n quality = gini_tree - pi[_left] * gini_left - pi[_right] * gini_right\\n\\n qualities[feature] = quality\\n return list(reversed(qualities.argsort()))[:top]\",\n \"def GetTopConfidenceEdges(g, dia, topn=20):\\r\\n edgez = {(e[0], e[1]): e[2]['z'] for e in g.edges(data=True)}\\r\\n edgeconf = {(e[0], e[1]): e[2]['frac_minority'] for e in g.edges(data=True)}\\r\\n edgenum = {(e[0], e[1]): e[2]['num_patients'] for e in g.edges(data=True)}\\r\\n edgez_sorted = sorted(edgez.items(), key=operator.itemgetter(1), reverse=True)[:topn]\\r\\n newedgez_sorted = []\\r\\n for e in edgez_sorted:\\r\\n e = list(e)\\r\\n edge = e[0]\\r\\n e.append(edgenum[e[0]])\\r\\n e.append(edgeconf[e[0]])\\r\\n newedgez_sorted.append(e)\\r\\n PrintCodeDescr(g, dia, newedgez_sorted, mode=\\\"edge\\\")\",\n \"def get_functional_enrichment(enrichment_file, go, remove_parents=False, only_biological_processes=False, only_slim=False, logodds_cutoff=0):\\n\\n #from toolbox import OboParser\\n #g=OboParser.getOboGraph(\\\"/home/emre/arastirma/celldiff/data/GO/gene_ontology.1_2.obo\\\")\\n g=go\\n\\n go_terms = None\\n name = None\\n name_to_go_terms ={}\\n\\n altid_to_goid = {}\\n for goid, data in g.nodes(data=True):\\n for altid in data[\\\"x\\\"]:\\n altid_to_goid[altid] = goid\\n\\n f = open(enrichment_file)\\n for line in f:\\n line = line.strip()\\n if line.startswith(\\\"# of\\\"):\\n go_terms = set()\\n elif line.startswith(\\\"#\\\"):\\n if go_terms is not None: \\n if name is None:\\n name = \\\"generic\\\"\\n if remove_parents:\\n go_terms = remove_parent_terms(go_terms, g)\\n name_to_go_terms[name] = go_terms\\n #print name, go_terms\\n name = line \\n else:\\n words = line.split(\\\"\\\\t\\\")\\n try:\\n n = int(words[0])\\n #pval = float(words[4]) # contains text like <0.0067\\n except:\\n print(words)\\n continue\\n go_term = words[5]\\n lodds = float(words[2])\\n if lodds < logodds_cutoff:\\n continue\\n if go_term in altid_to_goid:\\n go_term = altid_to_goid[go_term]\\n if only_biological_processes:\\n if g.node[go_term]['t'] == \\\"biological_process\\\": # and 'a' in g.node[go_term]: #is bp and slim # (\\\"molecular_function\\\", \\\"biological_process\\\"):\\n if only_slim:\\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\\n go_terms.add(go_term)\\n else:\\n go_terms.add(go_term)\\n else:\\n if only_slim:\\n if 'a' in g.node[go_term] and g.node[go_term]['a']:\\n go_terms.add(go_term)\\n else:\\n go_terms.add(go_term)\\n\\n f.close()\\n\\n if name is None:\\n name = \\\"generic\\\"\\n if remove_parents:\\n go_terms = remove_parent_terms(go_terms, g)\\n name_to_go_terms[name] = go_terms\\n #print name, go_terms\\n\\n if \\\"generic\\\" in name_to_go_terms:\\n return name_to_go_terms[\\\"generic\\\"]\\n\\n return name_to_go_terms\",\n \"def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\\n\\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\\n\\n print \\\"%-4d kegg pathways from %d DEGs\\\" % (len(deg_keggs), len(degs) )\\n print \\\"%-4d kegg pathways from %d nonDEGs\\\" % (len(neg_keggs), len(negs) )\\n\\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\\n pathwaytype_dict = {}\\n pathway_dict = {}\\n pathway_lookup = {}\\n\\n print \\\"extracting pathways...\\\"\\n ko1_h = open(dbpaths['kegg'], 'rb')\\n for line in ko1_h:\\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\\n pathtype_f = re.search('B.*<b>(.*)<', line)\\n if pathtype_f is not None:\\n pathtype = pathtype_f.group(1)\\n else:\\n pathtype = 'unknown'\\n pathwaytype_dict[pathtype] = {}\\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\\n pathway_f = re.search(\\\"C +([0-9]*) *(.*)\\\\[PATH\\\", line)\\n if pathway_f is not None:\\n pathway_id = pathway_f.group(1)\\n pathway_name = pathway_f.group(2)\\n else:\\n pathway_id = 'unknown'\\n pathway_name = 'unknown'\\n pathway_dict[pathway_id] = {}\\n pathway_lookup[pathway_id] = pathway_name\\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\\n koterm_f = re.search(\\\"(K[0-9]*)\\\", line)\\n if koterm_f is not None:\\n koterm = koterm_f.group(1)\\n else:\\n koterm = 'unknown'\\n pathwaytype_dict[pathtype][koterm] = 1\\n pathway_dict[pathway_id][koterm] = 1\\n\\n\\n print \\\"calculating enrichment...\\\"\\n pathwaytype_ps = {}\\n pathway_ps = {}\\n # count number of degs and negs in each pathway:\\n for pathwaytype in pathwaytype_dict:\\n pwtsize = len(pathwaytype_dict)\\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathwaytype_ps[pathwaytype] = pval\\n\\n if pval < pthresh:\\n print \\\"%s\\\\n \\\\\\n In Path Not in Path\\\\n\\\\\\n DEG : %-7d %d\\\\n\\\\\\n non-DEG: %-7d %d\\\\n\\\\\\n Odds Ratio:%.3f\\\\n\\\\\\n P-value:%.4f\\\\n\\\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\\n oddrat, pval)\\n\\n\\n for pathway in pathway_dict:\\n pwtsize = len(pathway_dict)\\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\\n\\n ## Fisher's Exact Test:\\n # In Pathway: Not in Pathway:\\n # DEG : degs_in_path degs_not_in\\n # non-DEG : negs_in_path negs_not_in\\n #\\n\\n return pathwaytype_ps, pathway_ps\",\n \"def calc_genotype(self, arch_param):\\n\\n def _parse(weights, genos):\\n gene = []\\n n = 2\\n start = 0\\n for i in range(self.steps):\\n end = start + n\\n W = weights[start:end].copy()\\n G = genos[start:end].copy()\\n edges = sorted(range(i + 2),\\n key=lambda x: -max(W[x][k] for k in range(len(W[x])) if G[x][k] != 'none'))[:2]\\n for j in edges:\\n k_best = None\\n for k in range(len(W[j])):\\n if G[j][k] != 'none':\\n if k_best is None or W[j][k] > W[j][k_best]:\\n k_best = k\\n gene.append([G[j][k_best], i + 2, j])\\n start = end\\n n += 1\\n return gene\\n\\n normal_param = np.array(self.darts_cfg.super_network.normal.genotype)\\n reduce_param = np.array(self.darts_cfg.super_network.reduce.genotype)\\n geno_normal = _parse(arch_param[0], normal_param[:, 0])\\n geno_reduce = _parse(arch_param[1], reduce_param[:, 0])\\n return [geno_normal, geno_reduce]\",\n \"def get_GO_presence_labels(genes_of_interest, min_GO_size=200, max_GO_size=300):\\n genes = pd.Series(genes_of_interest)\\n go_group_presence = {}\\n\\n for GO in go2geneIDs:\\n gene_ids = go2geneIDs[GO]\\n\\n # boolean vector (length is num of genes in embedding)\\n in_go_group_vector = genes.isin(gene_ids)\\n\\n if (in_go_group_vector.sum() > min_GO_size) & (in_go_group_vector.sum() < max_GO_size):\\n go_group_presence[GO] = in_go_group_vector\\n\\n result = pd.DataFrame(go_group_presence)\\n result.index = genes\\n result.index.name = 'entrezgene'\\n return result\",\n \"def brh_cogs2(DB, species, missing_factor=0.0, seed_sp=None, min_score=0):\\n def _sort_cogs(cogs1, cogs2):\\n seed1, mx1, avg1, ncogs1 = cogs1\\n seed2, mx2, avg2, ncogs2 = cogs2\\n for i, j in ((mx1, mx2), (avg1, avg2), (ncogs1, ncogs2)):\\n v = -1 * cmp(i, j)\\n if v != 0:\\n break\\n return v\\n \\n log.log(26, \\\"Searching BRH orthologs\\\")\\n species = set(map(str, species))\\n \\n min_species = len(species) - round(missing_factor * len(species))\\n \\n if seed_sp == \\\"auto\\\":\\n sp_to_test = list(species)\\n elif seed_sp == \\\"largest\\\":\\n cmd = \\\"\\\"\\\"SELECT taxid, size FROM species\\\"\\\"\\\"\\n db.seqcursor.execute(cmd)\\n sp2size = {}\\n for tax, counter in db.seqcursor.fetchall():\\n if tax in species: \\n sp2size[tax] = counter\\n \\n sorted_sp = sorted(sp2size.items(), lambda x,y: cmp(x[1],y[1]))\\n log.log(24, sorted_sp[:6])\\n largest_sp = sorted_sp[-1][0]\\n sp_to_test = [largest_sp]\\n log.log(28, \\\"Using %s as search seed. Proteome size=%s genes\\\" %\\\\\\n (largest_sp, sp2size[largest_sp]))\\n else:\\n sp_to_test = [str(seed_sp)]\\n\\n analysis_txt = StringIO()\\n if sp_to_test:\\n log.log(26, \\\"Finding best COG selection...\\\")\\n seed2size = get_sorted_seeds(seed_sp, species, sp_to_test, min_species, DB)\\n size_analysis = []\\n for seedname, content in seed2size.iteritems():\\n cog_sizes = [size for seq, size in content]\\n mx, avg = _max(cog_sizes), round(_mean(cog_sizes))\\n size_analysis.append([seedname, mx, avg, len(content)])\\n size_analysis.sort(_sort_cogs) \\n #print '\\\\n'.join(map(str, size_analysis))\\n seed = size_analysis[0][0]\\n print_as_table(size_analysis[:25], stdout=analysis_txt,\\n header=[\\\"Seed\\\",\\\"largest COG\\\", \\\"avg COG size\\\", \\\"total COGs\\\"])\\n if size_analysis[0][1] < len(species)-1:\\n print size_analysis[0][1]\\n raise ValueError(\\\"Current COG selection parameters do not permit to cover all species\\\")\\n \\n log.log(28, analysis_txt.getvalue())\\n # The following loop tests each possible seed if none is\\n # specified.\\n log.log(28, \\\"Computing Clusters of Orthologs groups (COGs)\\\")\\n log.log(28, \\\"Min number of species per COG: %d\\\" %min_species)\\n cogs_selection = []\\n log.log(26,\\\"Using seed species:%s\\\", seed)\\n species_side1 = ','.join(map(quote, [s for s in species if str(s)>str(seed)]))\\n species_side2 = ','.join(map(quote, [s for s in species if str(s)<str(seed)]))\\n pairs1 = []\\n pairs2 = []\\n # Select all ids with matches in the target species, and\\n # return the total number of species covered by each of\\n # such ids.\\n if species_side1 != \\\"\\\":\\n cmd = \\\"\\\"\\\"SELECT seqid1, taxid1, seqid2, taxid2 from ortho_pair WHERE\\n taxid1=\\\"%s\\\" AND taxid2 IN (%s) \\\"\\\"\\\" % (seed, species_side1)\\n DB.orthocursor.execute(cmd)\\n pairs1 = DB.orthocursor.fetchall()\\n\\n if species_side2 != \\\"\\\":\\n cmd = \\\"\\\"\\\"SELECT seqid2, taxid2, seqid1, taxid1 from ortho_pair WHERE\\n taxid1 IN (%s) AND taxid2 = \\\"%s\\\" \\\"\\\"\\\" % (species_side2, seed)\\n DB.orthocursor.execute(cmd)\\n pairs2 = DB.orthocursor.fetchall()\\n \\n cog_candidates = defaultdict(set)\\n for seq1, sp1, seq2, sp2 in pairs1 + pairs2:\\n s1 = (sp1, seq1)\\n s2 = (sp2, seq2)\\n cog_candidates[(sp1, seq1)].update([s1, s2])\\n\\n all_cogs = [cand for cand in cog_candidates.values() if\\n len(cand) >= min_species]\\n\\n # CHECK CONSISTENCY\\n seqs = set()\\n for cand in all_cogs:\\n seqs.update([b for a,b in cand if a == seed])\\n pre_selected_seqs = set([v[0] for v in seed2size[seed]])\\n if len(seqs & pre_selected_seqs) != len(set(seed2size[seed])) or\\\\\\n len(seqs & pre_selected_seqs) != len(seqs): \\n print \\\"old method seqs\\\", len(seqs), \\\"new seqs\\\", len(set(seed2size[seed])), \\\"Common\\\", len(seqs & pre_selected_seqs)\\n raise ValueError(\\\"ooops\\\")\\n \\n cog_sizes = [len(cog) for cog in all_cogs]\\n cog_spsizes = [len(set([e[0] for e in cog])) for cog in all_cogs]\\n\\n if [1 for i in xrange(len(cog_sizes)) if cog_sizes[i] != cog_spsizes[i]]:\\n raise ValueError(\\\"Inconsistent COG found\\\")\\n \\n if cog_sizes: \\n cogs_selection.append([seed, all_cogs])\\n log.log(26, \\\"Found %d COGs\\\" % len(all_cogs))\\n \\n recoded_cogs = []\\n for cog in all_cogs:\\n named_cog = map(lambda x: \\\"%s%s%s\\\" %(x[0], GLOBALS[\\\"spname_delimiter\\\"],x[1]), cog)\\n recoded_cogs.append(named_cog)\\n\\n return recoded_cogs, analysis_txt.getvalue()\",\n \"def termination_heuristics(self, state):\\n\\n point_state = state[0][0]\\n target_mask = get_target_mask(point_state)\\n point_state = point_state[:3, target_mask].T\\n depth_heuristics = self.graspnet_closure(point_state) \\n if (depth_heuristics):\\n print('object inside gripper? start retracting...')\\n return depth_heuristics\",\n \"def read_obs_neo_top_mid_bot(ring):\\n fobs_neo = \\\"/srv/ccrc/data25/z5218916/data/Eucface_data/swc_at_depth/FACE_P0018_RA_NEUTRON_20120430-20190510_L1.csv\\\"\\n neo = pd.read_csv(fobs_neo, usecols = ['Ring','Depth','Date','VWC'])\\n neo['Date'] = pd.to_datetime(neo['Date'],format=\\\"%d/%m/%y\\\",infer_datetime_format=False)\\n neo['Date'] = neo['Date'] - pd.datetime(2011,12,31)\\n neo['Date'] = neo['Date'].dt.days\\n neo = neo.sort_values(by=['Date','Depth'])\\n\\n if ring == 'amb':\\n subset = neo[neo['Ring'].isin(['R2','R3','R6'])]\\n elif ring == 'ele':\\n subset = neo[neo['Ring'].isin(['R1','R4','R5'])]\\n else:\\n subset = neo[neo['Ring'].isin([ring])]\\n\\n subset = subset.groupby(by=[\\\"Depth\\\",\\\"Date\\\"]).mean()\\n subset = subset.xs('VWC', axis=1, drop_level=True)\\n x = subset.index.get_level_values(1).values\\n y = subset.index.get_level_values(0).values\\n value = subset.values\\n\\n X = subset[(25)].index.values[20:]\\n Y = np.arange(0.5,460,1)\\n\\n grid_X, grid_Y = np.meshgrid(X,Y)\\n\\n grid_data = griddata((x, y) , value, (grid_X, grid_Y), method='nearest')\\n\\n neo_data = pd.DataFrame(subset[(25)].index.values[20:], columns=['dates'])\\n neo_data[\\\"SM_15m\\\"] = np.mean(grid_data[0:150,:],axis=0)/100.\\n neo_data[\\\"SM_all\\\"] = np.mean(grid_data[:,:],axis=0)/100.\\n neo_data[\\\"SM_top\\\"] = np.mean(grid_data[0:30,:],axis=0)/100.\\n neo_data[\\\"SM_mid\\\"] = np.mean(grid_data[30:150,:],axis=0)/100.\\n neo_data[\\\"SM_bot\\\"] = np.mean(grid_data[150:460,:],axis=0)/100.\\n neo_data[\\\"WA_all\\\"] = np.sum(grid_data[:,:]/100.*10.,axis=0)\\n neo_data = neo_data.set_index('dates')\\n return neo_data\",\n \"def brh_cogs(DB, species, missing_factor=0.0, seed_sp=None, min_score=0):\\n log.log(26, \\\"Searching BRH orthologs\\\")\\n species = set(map(str, species))\\n\\n min_species = len(species) - round(missing_factor * len(species))\\n \\n if seed_sp == \\\"auto\\\":\\n # seed2size = get_sorted_seeds(seed_sp, species, species, min_species, DB)\\n # sort_seeds = sorted([(len(size), sp) for sp, size in seed2size.iteritems()])\\n # sp_to_test = [sort_seeds[-1][1]]\\n sp_to_test = list(species)\\n elif seed_sp == \\\"largest\\\":\\n cmd = \\\"\\\"\\\"SELECT taxid, size FROM species\\\"\\\"\\\"\\n db.seqcursor.execute(cmd)\\n sp2size = {}\\n for tax, counter in db.seqcursor.fetchall():\\n if tax in species: \\n sp2size[tax] = counter\\n \\n sorted_sp = sorted(sp2size.items(), lambda x,y: cmp(x[1],y[1]))\\n log.log(24, sorted_sp[:6])\\n largest_sp = sorted_sp[-1][0]\\n sp_to_test = [largest_sp]\\n log.log(28, \\\"Using %s as search seed. Proteome size=%s genes\\\" %\\\\\\n (largest_sp, sp2size[largest_sp]))\\n else:\\n sp_to_test = [str(seed_sp)]\\n \\n # The following loop tests each possible seed if none is\\n # specified.\\n log.log(28, \\\"Detecting Clusters of Orthologs groups (COGs)\\\")\\n log.log(28, \\\"Min number of species per COG: %d\\\" %min_species)\\n cogs_selection = []\\n \\n for j, seed in enumerate(sp_to_test):\\n log.log(26,\\\"Testing new seed species:%s (%d/%d)\\\", seed, j+1, len(sp_to_test))\\n species_side1 = ','.join(map(quote, [s for s in species if str(s)>str(seed)]))\\n species_side2 = ','.join(map(quote, [s for s in species if str(s)<str(seed)]))\\n pairs1 = []\\n pairs2 = []\\n # Select all ids with matches in the target species, and\\n # return the total number of species covered by each of\\n # such ids.\\n if species_side1 != \\\"\\\":\\n cmd = \\\"\\\"\\\"SELECT seqid1, taxid1, seqid2, taxid2 from ortho_pair WHERE\\n taxid1=\\\"%s\\\" AND taxid2 IN (%s) \\\"\\\"\\\" %\\\\\\n (seed, species_side1)\\n DB.orthocursor.execute(cmd)\\n pairs1 = DB.orthocursor.fetchall()\\n\\n if species_side2 != \\\"\\\":\\n cmd = \\\"\\\"\\\"SELECT seqid2, taxid2, seqid1, taxid1 from ortho_pair WHERE\\n taxid1 IN (%s) AND taxid2 = \\\"%s\\\" \\\"\\\"\\\" %\\\\\\n (species_side2, seed)\\n\\n #taxid2=\\\"%s\\\" AND taxid1 IN (%s) AND score >= %s\\\"\\\"\\\" %\\\\\\n #(seed, species_side2, min_score)\\n DB.orthocursor.execute(cmd)\\n pairs2 = DB.orthocursor.fetchall()\\n\\n cog_candidates = defaultdict(set)\\n for seq1, sp1, seq2, sp2 in pairs1 + pairs2:\\n s1 = (sp1, seq1)\\n s2 = (sp2, seq2)\\n cog_candidates[(sp1, seq1)].update([s1, s2])\\n\\n all_cogs = [cand for cand in cog_candidates.values() if\\n len(cand) >= min_species]\\n \\n cog_sizes = [len(cog) for cog in all_cogs]\\n cog_spsizes = [len(set([e[0] for e in cog])) for cog in all_cogs]\\n\\n if [1 for i in xrange(len(cog_sizes)) if cog_sizes[i] != cog_spsizes[i]]:\\n # for i in xrange(len(cog_sizes)):\\n # if cog_sizes[i] != cog_spsizes[i]:\\n # print cog_sizes[i], cog_spsizes[i]\\n # raw_input()\\n raise ValueError(\\\"Inconsistent COG found\\\")\\n \\n if cog_sizes: \\n cogs_selection.append([seed, all_cogs])\\n log.log(26, \\\"Found %d COGs\\\" % len(all_cogs))\\n\\n def _sort_cogs(cogs1, cogs2):\\n cogs1 = cogs1[1] # discard seed info\\n cogs2 = cogs2[1] # discard seed info \\n cog_sizes1 = [len(cog) for cog in cogs1]\\n cog_sizes2 = [len(cog) for cog in cogs2]\\n mx1, mn1, avg1 = _max(cog_sizes1), _min(cog_sizes1), round(_mean(cog_sizes1))\\n mx2, mn2, avg2 = _max(cog_sizes2), _min(cog_sizes2), round(_mean(cog_sizes2))\\n \\n # we want to maximize all these values in the following order:\\n for i, j in ((mx1, mx2), (avg1, avg2), (len(cogs1), len(cogs2))):\\n v = -1 * cmp(i, j)\\n if v != 0:\\n break\\n return v\\n \\n log.log(26, \\\"Finding best COG selection...\\\")\\n cogs_selection.sort(_sort_cogs)\\n lines = []\\n for seed, all_cogs in cogs_selection:\\n cog_sizes = [len(cog) for cog in all_cogs]\\n mx, mn, avg = max(cog_sizes), min(cog_sizes), round(_mean(cog_sizes))\\n lines.append([seed, mx, mn, avg, len(all_cogs)])\\n analysis_txt = StringIO()\\n print_as_table(lines[:25], stdout=analysis_txt,\\n header=[\\\"Seed\\\",\\\"largest COG\\\", \\\"smallest COGs\\\", \\\"avg COG size\\\", \\\"total COGs\\\"])\\n log.log(28, \\\"Analysis details:\\\\n\\\"+analysis_txt.getvalue())\\n best_seed, best_cogs = cogs_selection[0]\\n cog_sizes = [len(cog) for cog in best_cogs]\\n\\n # Not necessary since they will be sorted differently later on\\n #best_cogs.sort(lambda x,y: cmp(len(x), len(y)), reverse=True)\\n \\n if max(cog_sizes) < len(species):\\n raise ValueError(\\\"Current COG selection parameters do not permit to cover all species\\\")\\n\\n recoded_cogs = []\\n for cog in best_cogs:\\n named_cog = map(lambda x: \\\"%s%s%s\\\" %(x[0], GLOBALS[\\\"spname_delimiter\\\"],x[1]), cog)\\n recoded_cogs.append(named_cog)\\n\\n return recoded_cogs, analysis_txt.getvalue()\",\n \"def get_genes_graph(genes_path, save_path, method='pearson', thresh=0.95, p_value=False):\\r\\n if not os.path.exists(save_path):\\r\\n os.makedirs(save_path)\\r\\n genes_exp_df = pd.read_csv(os.path.join(genes_path, 'exp.csv'), index_col=0)\\r\\n\\r\\n # calculate correlation matrix\\r\\n genes_exp_corr = genes_exp_df.corr(method=method)\\r\\n genes_exp_corr = genes_exp_corr.apply(lambda x: abs(x))\\r\\n n = genes_exp_df.shape[0]\\r\\n\\r\\n # binarize\\r\\n if p_value == True:\\r\\n dist = scipy.stats.beta(n / 2 - 1, n / 2 - 1, loc=-1, scale=2)\\r\\n thresh = dist.isf(0.05)\\r\\n\\r\\n adj = np.where(genes_exp_corr > thresh, 1, 0)\\r\\n adj = adj - np.eye(genes_exp_corr.shape[0], dtype=np.int)\\r\\n edge_index = np.nonzero(adj)\\r\\n np.save(os.path.join(save_path, 'edge_index_{}_{}.npy').format(method, thresh), edge_index)\\r\\n\\r\\n return n, edge_index\",\n \"def best_genome(self):\\n return self.best_genomes(1)[0]\",\n \"def newcogfind(ncf_cogs, ncf_twogs, ncf_prots):\\n coglijst_hoogste_waarde = list(set([y.split()[0] for y in ncf_cogs]))\\n werkgetal = vindhoogstecognummer(coglijst_hoogste_waarde)\\n ncf_list = []\\n for prot in ncf_prots:\\n prot_in_twogs = zoekinlijst(prot, ncf_twogs, 1)\\n posible_found_twogs = verbrogentwogs(prot, ncf_twogs, prot_in_twogs)\\n if posible_found_twogs != list():\\n newcog = list(set(\\\" \\\".join(posible_found_twogs).split()))\\n werkgetal += 1\\n for incog in newcog:\\n cogzin = \\\"%s\\\\t%s\\\\n\\\" % ((\\\"0000000000%s\\\" % werkgetal)[-8:], incog)\\n ncf_list.append(cogzin)\\n twogremove(zoekinlijst(incog, ncf_twogs, 0), ncf_twogs)\\n voegtoeaancog(ncf_list)\",\n \"def get_final_main_cgovtype_ori_agency(file_path):\\n final_main_df = pd.read_csv(file_path)\\n final_main_fips_ori_agency = final_main_df[['ORI', 'AGENCY', 'CGOVTYPE', 'FIPS_STATE', 'FIPS_PLACE']]\\n\\n \\\"\\\"\\\"\\n 1. Obtain only unique records from the final main file - key: fips place + fips state\\n \\\"\\\"\\\"\\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency.drop_duplicates(['FIPS_STATE', 'FIPS_PLACE']) # --> 11,602 rows\\n\\n \\\"\\\"\\\"\\n 2. Rename CGOVTYPE, FIPS_STATE, FIPS_PLACE to Govt_level, 'STATEFP', 'place_fips' to match national census file\\n \\\"\\\"\\\"\\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency_unique.rename(\\n {'CGOVTYPE': 'Govt_level', 'FIPS_STATE': 'STATEFP', 'FIPS_PLACE': 'place_fips'}, axis='columns')\\n\\n \\\"\\\"\\\"\\n 3. Get only those records from 90 final main file whose cgovtype is 1,2 or 3\\n \\\"\\\"\\\"\\n final_main_fips_ori_agency_unique = final_main_fips_ori_agency_unique.loc[final_main_fips_ori_agency_unique['Govt_level'].isin([1, 2, 3])]\\n\\n return final_main_fips_ori_agency_unique\",\n \"def best(self):\\n self.population.ascendent_sort()\\n self.best_genome = self.population.collection[0]\\n return self.best_genome\",\n \"def GoAnnot(prots, gos, onlyProts=False):\\r\\n with resources.open_text(\\\"autoprot.data\\\",\\\"Homo_sapiens.gene_info\\\") as d:\\r\\n geneInfo = pd.read_csv(d, sep='\\\\t')\\r\\n with resources.open_text(\\\"autoprot.data\\\",\\\"gene2go_alt\\\") as d:\\r\\n gene2go = pd.read_csv(d, sep='\\\\t')\\r\\n prots = pd.DataFrame(pd.Series([str(i).upper().split(';')[0] for i in prots]), columns=[\\\"Gene names\\\"])\\r\\n prots = prots.merge(geneInfo[[\\\"Symbol\\\", \\\"GeneID\\\"]], left_on=\\\"Gene names\\\", right_on=\\\"Symbol\\\", how='inner')\\r\\n \\r\\n prots = prots.merge(gene2go[[\\\"GeneID\\\", \\\"GO_ID\\\", \\\"GO_term\\\"]], on=\\\"GeneID\\\", how='inner')\\r\\n if onlyProts == True:\\r\\n for idx, go in enumerate(gos):\\r\\n if idx == 0:\\r\\n redProts = prots[\\\"Symbol\\\"][prots[\\\"GO_term\\\"].str.contains(go)]\\r\\n else:\\r\\n redProts = redProts.append(prots[\\\"Symbol\\\"][prots[\\\"GO_term\\\"].str.contains(go)])\\r\\n return redProts.drop_duplicates()\\r\\n else: \\r\\n for idx, go in enumerate(gos):\\r\\n if idx == 0:\\r\\n redProts = prots[prots[\\\"GO_term\\\"]==go]\\r\\n else:\\r\\n redProts = redProts.append(prots[prots[\\\"GO_term\\\"]==go])\\r\\n return redProts.drop_duplicates()\",\n \"def getNetCharge( top, gro, mdpfile, maxwarn = None):\\n\\n startdir = os.getcwd()\\n #Copy to a temporary directory to avoid generating output files in the working directory\\n tempdir = tempfile.mkdtemp()\\n shutil.copy( top, os.path.join( tempdir, 'tmp.top') )\\n shutil.copy( gro, os.path.join( tempdir, 'tmp.gro') )\\n shutil.copy( mdpfile, os.path.join( tempdir, 'tmp.mdp') )\\n os.chdir(tempdir)\\n\\n\\n #Run grompp and extract output\\n if maxwarn:\\n rungmxcmd = 'grompp -f tmp.mdp -p tmp.top -c tmp.gro -maxwarn %(maxwarn)s' % vars()\\n else:\\n rungmxcmd = 'grompp -f tmp.mdp -p tmp.top -c tmp.gro'\\n gromppout = commands.getoutput( rungmxcmd )\\n \\n #Find total charge in output\\n totalcharge = None\\n for line in gromppout.split('\\\\n'):\\n if 'total charge' in line and not 'State B' in line:\\n line = line.replace('System has non-zero total charge:','')\\n charge = float( line.split()[0].strip() )\\n totalcharge = int( round(charge) )\\n break #Break at first occurrence, to avoid going on to, for example, state B charge if present.\\n if not totalcharge:\\n #If the net charge is already zero, it will not be printed. We can attempt to read it from the topology file, as this will often be tracked there. The following code will do so, but assumes the topology file contains only a single [ atoms ] block which is followed by a [ bonds ] block; it reads the last line of the section preceding the [ bonds ] block and atempts to find 'qtot' at the end of the line. \\n file = open('tmp.top', 'r')\\n text = file.readlines()\\n file.close()\\n bondsstart = text.index('[ bonds ]\\\\n')\\n lastatomline = bondsstart-1\\n while len(text[ lastatomline]) < 20 or text[lastatomline].find( ';' ) < 2: #While the line is too short or starts with a comment, keep reading back\\n lastatomline -=1\\n #Now extract qtot from line if present\\n if 'qtot' in text[ lastatomline ]:\\n lastsec = text[ lastatomline ].split('qtot')[1]\\n qtot = lastsec.split()[0].strip()\\n totalcharge = float(qtot)\\n else: \\n #Attempt to get it by summing the charges in the topology file's atoms section\\n indices = extract_section( text, 'atoms' )\\n totalcharge = None\\n for index in indices:\\n line, comments = stripcomments( text[index] )\\n elements = line.split()\\n if len( elements ) > 7:\\n if totalcharge == None: totalcharge = 0.0\\n totalcharge += float(elements[6])\\n if totalcharge == None:\\n #Otherwise give up and we'll raise an exception below\\n print \\\"No total charge found in topology file.\\\"\\n\\n if totalcharge == None: #If we still can't find the total charge\\n print \\\"ERROR while calculating total charge; Work done in %s...\\\" % os.getcwd()\\n raise RuntimeError('Error: Could not read total charge from grompp output: %s' % gromppout )\\n\\n #Clean up\\n os.chdir( startdir ) \\n shutil.rmtree(tempdir)\\n\\n #Return\\n return totalcharge\",\n \"def challenge2(self):\\n # Let's try an octree-type approach\\n # For each grid cube we should be able to find whether a nanobot:\\n # 1) is not in range (is outside grid cube and not in range of nearest face)\\n # 2) is in range of whole cube (all 8 corners are in range)\\n # 3) is in range of part of the cube (i.e. not 1 or 2)\\n # Root node: figure out extent of whole space\\n mins = []\\n maxs = []\\n for axis in range(3):\\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n\\n for count in range(len(self.nanobots), 0, -1):\\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\\n if results and results[0].count >= count:\\n break\\n\\n print(f\\\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\\\")\\n\\n # Find result coord closest to origin\\n closest_dist = np.iinfo(np.int32).max\\n best_coord = None\\n for result in results:\\n for corner in itertools.product(*zip(result.mins, result.maxs)):\\n d = manhattan_dist(corner, (0, 0, 0))\\n if d < closest_dist:\\n closest_dist = d\\n best_coord = corner\\n\\n print(f\\\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\\\")\",\n \"def parse_grism_associations(exposure_groups, \\n best_direct=DIRECT_ORDER,\\n get_max_overlap=True):\\n N = len(exposure_groups)\\n \\n grism_groups = []\\n for i in range(N):\\n f_i = exposure_groups[i]['product'].split('-')[-1]\\n root_i = exposure_groups[i]['product'].split('-'+f_i)[0]\\n \\n if f_i.startswith('g'):\\n group = OrderedDict(grism=exposure_groups[i], \\n direct=None)\\n else:\\n continue\\n \\n fp_i = exposure_groups[i]['footprint']\\n olap_i = 0.\\n d_i = f_i\\n \\n #print('\\\\nx\\\\n')\\n d_idx = 10\\n for j in range(N):\\n f_j = exposure_groups[j]['product'].split('-')[-1]\\n if f_j.startswith('g'):\\n continue\\n \\n fp_j = exposure_groups[j]['footprint']\\n olap = fp_i.intersection(fp_j)\\n root_j = exposure_groups[j]['product'].split('-'+f_j)[0]\\n\\n #print(root_j, root_i, root_j == root_i)\\n if (root_j == root_i):\\n # if (group['direct'] is not None):\\n # pass\\n # if (group['direct']['product'].startswith(root_i)) & (d_i.upper() == best_direct[f_i.upper()]):\\n # continue\\n \\n if best_direct[f_i.upper()].index(f_j.upper()) < d_idx:\\n d_idx = best_direct[f_i.upper()].index(f_j.upper())\\n group['direct'] = exposure_groups[j]\\n olap_i = olap.area\\n d_i = f_j\\n #print(0,group['grism']['product'], group['direct']['product'])\\n # continue\\n \\n #print(exposure_groups[i]['product'], exposure_groups[j]['product'], olap.area*3600.)\\n \\n # #print(exposure_groups[j]['product'], olap_i, olap.area)\\n # if olap.area > 0:\\n # if group['direct'] is None:\\n # group['direct'] = exposure_groups[j]\\n # olap_i = olap.area\\n # d_i = f_j\\n # #print(1,group['grism']['product'], group['direct']['product'])\\n # else:\\n # #if (f_j.upper() == best_direct[f_i.upper()]):\\n # if get_max_overlap:\\n # if olap.area < olap_i:\\n # continue\\n # \\n # if d_i.upper() == best_direct[f_i.upper()]:\\n # continue\\n # \\n # group['direct'] = exposure_groups[j]\\n # #print(exposure_groups[j]['product'])\\n # olap_i = olap.area\\n # d_i = f_j\\n # #print(2,group['grism']['product'], group['direct']['product'])\\n \\n grism_groups.append(group)\\n \\n return grism_groups\",\n \"def eui_modesign():\\n\\n # setup design space\\n # N ds ws wc lc g\\n GAP = Struct()\\n GAP.gd_min = np.array([1, 1e-3, 1e-3, 1e-3, 1e-3, 1e-5])\\n GAP.gd_max = np.array([1e3, 1e-1, 1e-1, 1e-1, 1e-1, 1e-2])\\n\\n\\n # setup genetic algorithm parameters--------------------------------------\\n nobj=2 # number of objectives\\n ngen=100 # number of generations\\n npop = 100 # population size\\n \\n problem = MyProblem()\\n problem.n_var = len(GAP.gd_min)\\n problem.n_obj = nobj\\n problem.n_constr = 2\\n problem.xl = GAP.gd_min\\n problem.xu = GAP.gd_max\\n problem.elementwise_evaluation = True\\n\\n algorithm = NSGA2(\\n pop_size=npop,\\n eliminate_duplicates=True\\n )\\n \\n # conduct the optimization-------------------------------------------------\\n res = minimize(problem, algorithm, (\\\"n_gen\\\", ngen), verbose=True)\\n\\n # save results-------------------------------------------------------------\\n return res\",\n \"def process_component(COMP, G, max_k, min_length, max_CV, SEQS, bamfile, pool, use_scores=False, use_genes=False, num_procs=1):\\n\\n ###############MOVED FROM OUTER CODE ON WHOLE G\\n if use_scores: remove_hi_confidence_chromosome(COMP) ##################################\\n\\n # initialize shortest path set considered\\n path_count = 0\\n seen_unoriented_paths = set([])\\n paths_set = set([]) #the set of paths found\\n\\n\\n # first look for paths starting from the nodes annotated with plasmid genes\\n if use_genes:\\n plasmid_gene_nodes = get_plasmid_gene_nodes(COMP)\\n potential_plasmid_mass_tuples = [(get_spades_base_mass(COMP,nd),nd) for nd in plasmid_gene_nodes]\\n potential_plasmid_mass_tuples.sort(key = lambda n: n[0])\\n while potential_plasmid_mass_tuples: # could be removing other nodes from the list\\n top_node = potential_plasmid_mass_tuples.pop() # highest mass node\\n top_node_name = top_node[1]\\n path = get_high_mass_shortest_path(top_node_name,COMP,use_scores,use_genes) #######\\n if path is None: continue\\n # check coverage variation\\n path_CV = get_wgtd_path_coverage_CV(path,G,SEQS,max_k_val=max_k)\\n logger.info(\\\"Plasmid gene path: %s, CV: %4f\\\" % (str(path),path_CV))\\n if path_CV <= max_CV and is_good_cyc(path,G,bamfile):\\n logger.info(\\\"Added plasmid gene path %s\\\" % (str(path)))\\n\\n # prevent checking nodes that have been removed\\n i = 0\\n while i < len(potential_plasmid_mass_tuples):\\n if potential_plasmid_mass_tuples[i][1] in path or \\\\\\n rc_node(potential_plasmid_mass_tuples[i][1]) in path:\\n potential_plasmid_mass_tuples.pop(i)\\n else: i += 1\\n\\n seen_unoriented_paths.add(get_unoriented_sorted_str(path))\\n before_cov, _ = get_path_mean_std(path, G, SEQS, max_k)\\n covs = update_path_coverage_vals(path, G, SEQS, max_k)\\n update_path_with_covs(path, COMP, covs)\\n path_count += 1\\n paths_set.add((path,before_cov))\\n\\n else:\\n logger.info(\\\"Did not add plasmid gene path: %s\\\" % (str(path)))\\n\\n # then look for circular paths that start from hi confidence plasmid nodes\\n if use_scores:\\n potential_plasmid_nodes = get_hi_conf_plasmids(COMP)\\n potential_plasmid_mass_tuples = [(get_spades_base_mass(COMP,nd),nd) for nd in potential_plasmid_nodes]\\n potential_plasmid_mass_tuples.sort(key = lambda n: n[0])\\n while potential_plasmid_mass_tuples: # could be removing other nodes from the list\\n top_node = potential_plasmid_mass_tuples.pop() # highest mass node\\n top_node_name = top_node[1]\\n path = get_high_mass_shortest_path(top_node_name,COMP,use_scores,use_genes)\\n if path is None: continue\\n # check coverage variation\\n path_CV = get_wgtd_path_coverage_CV(path,G,SEQS,max_k_val=max_k)\\n logger.info(\\\"Hi conf path: %s, CV: %4f\\\" % (str(path),path_CV))\\n\\n if path_CV <= max_CV and is_good_cyc(path,G,bamfile):\\n logger.info(\\\"Added hi conf path %s\\\" % (str(path)))\\n\\n # prevent checking nodes that have been removed\\n i = 0\\n while i < len(potential_plasmid_mass_tuples):\\n if potential_plasmid_mass_tuples[i][1] in path or \\\\\\n rc_node(potential_plasmid_mass_tuples[i][1]) in path:\\n potential_plasmid_mass_tuples.pop(i)\\n else: i += 1\\n\\n seen_unoriented_paths.add(get_unoriented_sorted_str(path))\\n before_cov, _ = get_path_mean_std(path, G, SEQS, max_k)\\n #before_cov, _ = get_path_mean_std(path, COMP, SEQS, max_k)\\n covs = update_path_coverage_vals(path, G, SEQS, max_k)##########################\\n update_path_with_covs(path, COMP, covs) ####################################\\n path_count += 1\\n paths_set.add((path,before_cov))\\n\\n else:\\n logger.info(\\\"Did not add hi-conf path: %s\\\" % (str(path)))\\n\\n # 3rd step. Run Recycler algorithm that looks for circular high mass shortest\\n # paths and accept them as plasmid predictions if the coverages and mate pairs\\n # match the required thresholds\\n#######################################################################################\\n#######################################################################################\\n\\n\\n paths = enum_high_mass_shortest_paths(COMP, pool, use_scores,use_genes,seen_unoriented_paths)\\n last_path_count = 0\\n last_node_count = 0\\n\\n # continue as long as you either removed a low mass path\\n # from the component or added a new path to final paths\\n while(path_count!=last_path_count or\\\\\\n len(COMP.nodes())!=last_node_count):\\n\\n last_node_count = len(COMP.nodes())\\n last_path_count = path_count\\n\\n # make tuples of (CV, path)\\n path_tuples = []\\n for p in paths:\\n if len(get_seq_from_path(p, SEQS, max_k_val=max_k)) < min_length:\\n seen_unoriented_paths.add(get_unoriented_sorted_str(p))\\n logger.info(\\\"Num seen paths: %d\\\" % (len(seen_unoriented_paths)))\\n continue\\n path_tuples.append((get_wgtd_path_coverage_CV(p,G,SEQS,max_k_val=max_k), p))\\n\\n logger.info(\\\"Num path tuples: %d\\\" % (len(path_tuples)))\\n if(len(path_tuples)==0): break\\n\\n # sort in ascending CV order\\n path_tuples.sort(key=lambda path: path[0])\\n\\n for pt in path_tuples:\\n curr_path = pt[1]\\n curr_path_CV = pt[0]\\n logger.info(\\\"Path: %s\\\" % (\\\",\\\".join(curr_path)))\\n if get_unoriented_sorted_str(curr_path) not in seen_unoriented_paths:\\n\\n ## only report if low CV and matches mate pair info\\n if (curr_path_CV <= (max_CV) and \\\\\\n is_good_cyc(curr_path,G,bamfile)):\\n\\n logger.info(\\\"Added path %s\\\" % \\\", \\\".join(curr_path))\\n logger.info(\\\"\\\\tCV: %4f\\\" % curr_path_CV)\\n seen_unoriented_paths.add(get_unoriented_sorted_str(curr_path))\\n #before_cov, _ = get_path_mean_std(curr_path, COMP, SEQS, max_k)\\n before_cov, _ = get_path_mean_std(curr_path, G, SEQS, max_k)\\n covs = update_path_coverage_vals(curr_path, G, SEQS, max_k)\\n update_path_with_covs(curr_path, COMP, covs)\\n path_count += 1\\n paths_set.add((curr_path,before_cov))\\n break\\n\\n else:\\n logger.info(\\\"Did not add path: %s\\\" % (\\\", \\\".join(curr_path)))\\n logger.info(\\\"\\\\tCV: %4f\\\" % curr_path_CV)\\n if curr_path_CV > max_CV:\\n break # sorted by CV\\n else: # not good mate pairs\\n seen_unoriented_paths.add(get_unoriented_sorted_str(curr_path))\\n\\n # recalculate paths on the component\\n print(str(len(COMP.nodes())) + \\\" nodes remain in component\\\")\\n logger.info(\\\"Remaining nodes: %d\\\" % (len(COMP.nodes())))\\n paths = enum_high_mass_shortest_paths(COMP, pool, use_scores,use_genes,seen_unoriented_paths)\\n\\n #end while\\n return paths_set\",\n \"def go_enrichment(genelist, background_go=None, go_info=None, return_odds=False, gofile=dbpaths['goterms']):\\n # if background list of GO terms is not supplied, make one:\\n if background_go:\\n go_obj = background_go\\n else:\\n go_obj = GO_maker(gofile)\\n\\n f_squares = [] # where the Fisher's Exact Tables will be held (and returned)\\n\\n god = {}\\n goodds = {}\\n gopval = {}\\n\\n for godict in go_obj.fetch_gos(genelist):\\n for goterm in godict:\\n try:\\n god[goterm] += 1\\n except KeyError:\\n god[goterm] = 1\\n\\n for goterm in god:\\n if goterm == \\\"GO:######\\\":\\n continue\\n dip = god[goterm]\\n\\n go_w_deg = dip\\n go_wo_deg = len(go_obj.fetch_genes(goterm)) - dip\\n nogo_w_deg = len(genelist) - dip\\n nogo_wo_deg = go_obj.count_genes() - len(go_obj.fetch_genes(goterm)) - len(genelist) + dip\\n\\n if isinstance(go_info,dict):\\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm, go_info[goterm]))\\n else:\\n f_squares.append(Fisher_square(go_w_deg, nogo_w_deg, go_wo_deg, nogo_wo_deg, goterm))\\n\\n verbalise(\\\"B\\\", \\\"Performing Fisher's Exact Test on %d squares\\\" % (len(f_squares)))\\n for square in f_squares:\\n square.fisher_test()\\n\\n return f_squares\",\n \"def HaarGOB(treeG):\\n # number of level of the chain (or tree)\\n Ntr = len(treeG)\\n # reorder chain (optional) \\n # reordering each level so that in each level the nodes are in the\\n # descent order of degrees\\n # compute u_l^c for level J_0 (top level)\\n clusterJ0 = treeG[Ntr-1]['clusters']\\n N0 = len(clusterJ0)\\n # generate indicator function on G^c\\n chic = np.identity(N0)\\n uc = [None]*N0\\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\\n for l in np.arange(1, N0):\\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\\n# u = copy.deepcopy(uc)\\n treeG[Ntr-1]['u'] = uc\\n # compute the next level orthonormal basis ulk and stored into u\\n for j_tr in np.arange(0, Ntr-1)[::-1]:\\n N1 = len(treeG[j_tr]['clusters'])\\n u = [None]*N1\\n i = N0\\n for l in range(N0):\\n clusterl = treeG[j_tr+1]['clusters'][l]\\n kl = len(clusterl)\\n #for k==1\\n ucl = uc[l]\\n ul1 = np.zeros(N1)\\n for j in range(N0):\\n idxj = treeG[j_tr+1]['clusters'][j]\\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\\n u[l] = ul1\\n if kl>1:\\n chil = np.zeros((kl,N1))\\n for k in range(kl):\\n idxl = treeG[j_tr+1]['clusters'][l]\\n chil[k,idxl[k]] = 1;\\n \\n for k in np.arange(1,kl):\\n i = i+1\\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\\n u[i-1] = ulk\\n treeG[j_tr]['u'] = u\\n # update uc and N0\\n# uc = copy.deepcopy(u)\\n uc = u\\n N0 = N1\\n return treeG\",\n \"def best_genome(self) -> Genome:\\n return self._candidate\",\n \"def get_orfs(genome, min_num_aa):\\n allowed = \\\"ATGC\\\"\\n if not isinstance(genome, str) or len(genome) == 0 or not all(c in allowed for c in genome):\\n raise TypeError\\n start_codon = \\\"ATG\\\"\\n stop_codon = ['TAA', 'TAG', 'TGA']\\n ref_dict = {\\\"T\\\" : \\\"A\\\", \\\"A\\\" : \\\"T\\\", \\\"G\\\" : \\\"C\\\", \\\"C\\\" : \\\"G\\\"}\\n amino_dict = {\\n 'L' : ['CTC', 'CTT', 'CTA', 'CTG', 'TTA', 'TTG'],\\n 'S' : ['TCA', 'TCT', 'TCC', 'TCG', 'AGC', 'AGT'],\\n 'R' : ['CGA', 'CGC', 'CGT', 'CGG', 'AGA', 'AGG'],\\n 'V' : ['GTA', 'GTG', 'GTC', 'GTT'],\\n 'P' : ['CCC', 'CCA', 'CCG', 'CCT'],\\n 'T' : ['ACC', 'ACG', 'ACT', 'ACA'],\\n 'A' : ['GCA', 'GCC', 'GCG', 'GCT'],\\n 'G' : ['GGA', 'GGC', 'GGT', 'GGG'],\\n 'I' : ['ATA', 'ATC', 'ATT'],\\n 'F' : ['TTT', 'TTC'],\\n 'Y' : ['TAT', 'TAC'],\\n 'H' : ['CAC', 'CAT'],\\n 'Q' : ['CAG', 'CAA'],\\n 'N' : ['AAC', 'AAT'],\\n 'K' : ['AAA', 'AAG'],\\n 'D' : ['GAC', 'GAT'],\\n 'E' : ['GAA', 'GAG'],\\n 'C' : ['TGC', 'TGT'],\\n 'M' : ['ATG'],\\n 'W' : ['TGG']\\n\\n }\\n comp_genome = \\\"\\\"\\n for stra in genome:\\n comp_genome += ref_dict[stra]\\n main_orfs = find_orfs(genome, start_codon, stop_codon, min_num_aa, amino_dict, False)\\n comp_orfs = find_orfs(comp_genome[::-1], start_codon, stop_codon, min_num_aa, amino_dict, True)\\n circular_orfs = find_cir_orfs(genome, main_orfs, start_codon, stop_codon, min_num_aa, amino_dict, False)\\n \\n circular_orfs_comp = find_cir_orfs(comp_genome[::-1], comp_orfs, start_codon, stop_codon, min_num_aa, amino_dict, True)\\n \\n for main_orf in main_orfs:\\n for cir_orf in circular_orfs:\\n if main_orf[0] <= cir_orf[1] and main_orf[1] <= cir_orf[1] or len(main_orf) == 5:\\n main_orfs.remove(main_orf)\\n for comp_orf in comp_orfs:\\n for cir_orf in circular_orfs_comp:\\n if comp_orf[1] == cir_orf[1] or len(comp_orf) == 5:\\n comp_orfs.remove(comp_orf)\\n\\n final_orf = main_orfs + comp_orfs + circular_orfs + circular_orfs_comp\\n #print(len(comp_orfs))\\n \\n \\n \\n return final_orf\",\n \"def goe(\\n\\tgenelist,\\n\\tgo_file,\\n\\tgoa_file,\\n\\tbg=None,\\n\\tnmin=5,\\n\\tconversion=None,\\n\\tevidence_set={\\n\\t\\t'EXP', 'IDA', 'IPI', 'IMP', 'IGI', 'HTP', 'HDA', 'HMP', 'HGI', 'IBA',\\n\\t\\t'IBD', 'IKR', 'IRD', 'ISS', 'ISO', 'ISA', 'ISM'}):\\n\\tfrom tempfile import NamedTemporaryFile\\n\\tfrom os import linesep\\n\\tfrom goatools.go_enrichment import GOEnrichmentStudy\\n\\tfrom goatools.obo_parser import GODag\\n\\tfrom goatools.associations import read_gaf\\n\\tfrom collections import defaultdict\\n\\timport itertools\\n\\tfrom biothings_client import get_client\\n\\timport pandas as pd\\n\\timport logging\\n\\tassert type(genelist) is list and len(genelist) > 0\\n\\tif nmin < 1:\\n\\t\\tnmin = 1\\n\\n\\tbg0 = bg\\n\\t# Convert gene names\\n\\tif conversion is not None:\\n\\t\\tassert len(conversion) == 3\\n\\t\\tname_from, name_to, species = conversion\\n\\t\\tmg = get_client('gene')\\n\\t\\tans = set(genelist)\\n\\t\\tif bg is not None:\\n\\t\\t\\tt1 = set(bg)\\n\\t\\t\\tassert len(ans - t1) == 0\\n\\t\\t\\tans |= t1\\n\\t\\tans = list(ans)\\n\\t\\tans = mg.querymany(ans, scopes=name_from, fields=name_to, species=species)\\n\\t\\tt1 = set(['query', '_score', name_to.split('.')[0]])\\n\\t\\tans = list(filter(lambda x: len(t1 - set(x)) == 0, ans))\\n\\t\\tans = sorted(ans, key=lambda x: x['_score'])\\n\\t\\tconvert = {x['query']: x for x in ans}\\n\\t\\tfor xi in name_to.split('.'):\\n\\t\\t\\tconvert = filter(lambda x: xi in x[1], convert.items())\\n\\t\\t\\tconvert = {x[0]: x[1][xi] for x in convert}\\n\\t\\tconvert = {\\n\\t\\t\\tx[0]: x[1] if type(x[1]) is str else x[1][0]\\n\\t\\t\\tfor x in convert.items()}\\n\\t\\tgenelist2 = list(\\n\\t\\t\\tset([convert[x] for x in filter(lambda x: x in convert, genelist)]))\\n\\t\\tif bg is not None:\\n\\t\\t\\tbg = list(set([convert[x] for x in filter(lambda x: x in convert, bg)]))\\n\\t\\tt1 = set(genelist)\\n\\t\\tconverti = list(filter(lambda x: x[0] in t1, convert.items()))\\n\\t\\tt1 = defaultdict(list)\\n\\t\\tfor xi in converti:\\n\\t\\t\\tt1[xi[1]].append(xi[0])\\n\\t\\tconverti = dict(t1)\\n\\t\\tt1 = defaultdict(list)\\n\\t\\tfor xi in convert.items():\\n\\t\\t\\tt1[xi[1]].append(xi[0])\\n\\t\\tconvertia = dict(t1)\\n\\telse:\\n\\t\\tgenelist2 = genelist\\n\\n\\t# Load GO DAG and association files\\n\\tlogging.debug('Reading GO DAG file ' + go_file)\\n\\tgodag = GODag(go_file)\\n\\tlogging.debug('Reading GO association file ' + goa_file)\\n\\tgoa = read_gaf(goa_file, evidence_set=evidence_set)\\n\\tif bg is None:\\n\\t\\tbg = list(goa.keys())\\n\\n\\t# Compute enrichment\\n\\tgoe = GOEnrichmentStudy(bg, goa, godag)\\n\\tans = goe.run_study(genelist2)\\n\\t# Format output\\n\\twith NamedTemporaryFile() as f:\\n\\t\\tgoe.wr_tsv(f.name, ans)\\n\\t\\tans = f.read()\\n\\tans = ans.decode()\\n\\tans = [x.split('\\\\t') for x in ans.split(linesep)]\\n\\tif len(ans[-1]) < 2:\\n\\t\\tans = ans[:-1]\\n\\tif len(ans) == 0 or len(ans[0]) == 0:\\n\\t\\traise ValueError('No enrichment found. Check your input ID type.')\\n\\tans[0][0] = ans[0][0].strip('# ')\\n\\tans = pd.DataFrame(ans[1:], columns=ans[0])\\n\\tans.drop(['NS', 'enrichment', 'study_count', 'p_sidak', 'p_holm'],\\n\\t\\t\\t axis=1,\\n\\t\\t\\t inplace=True)\\n\\tfor xj in ['p_uncorrected', 'p_bonferroni']:\\n\\t\\tans[xj] = pd.to_numeric(ans[xj], errors='raise')\\n\\tans['depth'] = pd.to_numeric(ans['depth'],\\n\\t\\t\\t\\t\\t\\t\\t\\t errors='raise',\\n\\t\\t\\t\\t\\t\\t\\t\\t downcast='unsigned')\\n\\t# Odds ratio column and sort column\\n\\tans['odds_ratio'] = toratio(ans['ratio_in_study']) / toratio(\\n\\t\\tans['ratio_in_pop'])\\n\\tans = ans[[\\n\\t\\t'name', 'depth', 'p_uncorrected', 'p_bonferroni', 'odds_ratio',\\n\\t\\t'ratio_in_study', 'ratio_in_pop', 'GO', 'study_items']]\\n\\tans['study_items'] = ans['study_items'].apply(lambda x: x.replace(' ', ''))\\n\\t# Convert back study_items\\n\\tif conversion is not None:\\n\\t\\tans['study_items'] = ans['study_items'].apply(lambda x: ','.join(\\n\\t\\t\\tlist(itertools.chain.from_iterable([converti[y] for y in x.split(',')])))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t if len(x) > 0 else x)\\n\\tans.sort_values('p_uncorrected', inplace=True)\\n\\n\\t# Get top enriched GO by P-value\\n\\tgotop = ans[\\n\\t\\t(ans['odds_ratio'] > 1)\\n\\t\\t& ans['ratio_in_study'].apply(lambda x: int(x.split('/')[0]) >= nmin)]\\n\\tif len(gotop) == 0:\\n\\t\\traise ValueError('No GO enrichment found for given criteria.')\\n\\tgotop = str(gotop.iloc[0]['GO'])\\n\\tif bg0 is not None:\\n\\t\\t# Children GOs\\n\\t\\tgos = set([gotop] + list(godag.query_term(gotop).get_all_children()))\\n\\t\\t# Look for genes\\n\\t\\tgenes = list(\\n\\t\\t\\tfilter(lambda x: len(list(filter(lambda y: y in gos, goa[x]))) > 0, goa))\\n\\t\\tif conversion is not None:\\n\\t\\t\\tgenes = [convertia[x] for x in filter(lambda x: x in convertia, genes)]\\n\\t\\t\\tgenes = list(set(list(itertools.chain.from_iterable(genes))))\\n\\t\\tgenes = set(genes)\\n\\t\\tgenes = list(filter(lambda x: x in genes, bg0))\\n\\telse:\\n\\t\\tgenes = None\\n\\treturn (ans, gotop, genes)\",\n \"def cohighest_root(self):\\n return self.highest_root().associated_coroot()\",\n \"def bipartite_vertex_cover(bigraph, algo=\\\"Hopcroft-Karp\\\"):\\n if algo == \\\"Hopcroft-Karp\\\":\\n coord = [(irow,icol) for irow,cols in enumerate(bigraph) for icol in cols]\\n coord = np.array(coord)\\n graph = csr_matrix((np.ones(coord.shape[0]),(coord[:,0],coord[:,1])))\\n matchV = maximum_bipartite_matching(graph, perm_type='row')\\n matchV = [None if x==-1 else x for x in matchV]\\n nU, nV = graph.shape\\n assert len(matchV) == nV\\n elif algo == \\\"Hungarian\\\":\\n matchV = max_bipartite_matching2(bigraph)\\n nU, nV = len(bigraph), len(matchV)\\n else:\\n assert False\\n\\n matchU = [None] * nU\\n \\n for v in range(nV): # -- build the mapping from U to V\\n if matchV[v] is not None:\\n matchU[matchV[v]] = v\\n \\n def old_konig():\\n visitU = [False] * nU # -- build max alternating forest\\n visitV = [False] * nV\\n for u in range(nU):\\n if matchU[u] is None: # -- starting with free vertices in U\\n _alternate(u, bigraph, visitU, visitV, matchV)\\n inverse = [not b for b in visitU]\\n return (inverse, visitV)\\n \\n def new_konig():\\n # solve the limitation of huge number of recursive calls\\n visitU = [False] * nU # -- build max alternating forest\\n visitV = [False] * nV\\n wait_u = set(range(nU)) - set(matchV) \\n while len(wait_u) > 0:\\n u = wait_u.pop()\\n visitU[u] = True\\n for v in bigraph[u]:\\n if not visitV[v]:\\n visitV[v] = True\\n assert matchV[v] is not None # otherwise match is not maximum\\n assert matchV[v] not in wait_u\\n wait_u.add(matchV[v])\\n inverse = [not b for b in visitU]\\n return (inverse, visitV)\\n \\n #res_old = old_konig()\\n res_new = new_konig()\\n #assert res_old == res_new\\n return res_new\",\n \"def select_best_chanels():\\r\\n \\r\\n \\r\\n all_paths = [['data_bci\\\\\\\\row_data\\\\\\\\subject1\\\\\\\\'], ['data_bci\\\\\\\\row_data\\\\\\\\subject2\\\\\\\\'],['data_bci\\\\\\\\row_data\\\\\\\\subject3\\\\\\\\']]\\r\\n\\r\\n train_subjects = ['01']\\r\\n test_subject = '02'\\r\\n freq = 512\\r\\n\\r\\n cutoff_beggining = 0\\r\\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\\r\\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\\r\\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\\r\\n seq_len = 0\\r\\n cut_step = 0\\r\\n num_perseg = freq\\r\\n num_overlap = int(num_perseg/2)\\r\\n min_freq=8\\r\\n max_freq=45\\r\\n \\r\\n chanels_rank = rank_chanels()\\r\\n \\r\\n result = []\\r\\n for i in range(1, len(chanels_rank)):\\r\\n intermidiate_result = []\\r\\n for path in all_paths:\\r\\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\\r\\n\\r\\n train_psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq)\\r\\n test_psd_signals = eval_psd_not_modulated(test_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \\r\\n\\r\\n train_psd_signals = flatten_data(train_psd_signals[:,:,chanels_rank[:i]])\\r\\n test_psd_signals = flatten_data(test_psd_signals[:,:,chanels_rank[:i]])\\r\\n \\r\\n acc = evalute_subset(train_psd_signals, test_psd_signals, train_full_anots, test_full_annoations)\\r\\n intermidiate_result.append(acc)\\r\\n \\r\\n result.append(intermidiate_result)\\r\\n #mean_subject_acc = np.array([sum(humans_acc)/len(humans_acc) for humans_acc in result])\\r\\n #best_idx = np.argmax(mean_subject_acc)\\r\\n\\r\\n return result, chanels_rank\",\n \"def gagps(data_src, min_supp=MIN_SUPPORT, max_iteration=MAX_ITERATIONS, n_pop=N_POPULATION, pc=PC,\\n gamma=GAMMA, mu=MU, sigma=SIGMA, return_gps=False):\\n\\n # Prepare data set\\n d_set = DataGP(data_src, min_supp)\\n d_set.init_attributes()\\n attr_keys = [GI(x[0], x[1].decode()).as_string() for x in d_set.valid_bins[:, 0]]\\n\\n if d_set.no_bins:\\n return []\\n\\n # Problem Information\\n # costfxn\\n\\n # Parameters\\n # pc: Proportion of children (if its 1, then nc == npop\\n it_count = 0\\n eval_count = 0\\n counter = 0\\n var_min = 0\\n var_max = int(''.join(['1'] * len(attr_keys)), 2)\\n\\n nc = int(np.round(pc * n_pop / 2) * 2) # Number of children. np.round is used to get even number of children\\n\\n # Empty Individual Template\\n empty_individual = structure()\\n empty_individual.position = None\\n empty_individual.cost = None\\n\\n # Initialize Population\\n pop = empty_individual.repeat(n_pop)\\n for i in range(n_pop):\\n pop[i].position = random.randrange(var_min, var_max)\\n pop[i].cost = 1 # costfxn(pop[i].position, attr_keys, d_set)\\n # if pop[i].cost < best_sol.cost:\\n # best_sol = pop[i].deepcopy()\\n\\n # Best Solution Ever Found\\n best_sol = empty_individual.deepcopy()\\n best_sol.position = pop[0].position\\n best_sol.cost = costfxn(best_sol.position, attr_keys, d_set)\\n\\n # Best Cost of Iteration\\n best_costs = np.empty(max_iteration)\\n best_patterns = list()\\n str_best_gps = list()\\n str_iter = ''\\n str_eval = ''\\n\\n repeated = 0\\n while counter < max_iteration:\\n # while eval_count < max_evaluations:\\n # while repeated < 1:\\n\\n c_pop = [] # Children population\\n for _ in range(nc // 2):\\n # Select Parents\\n q = np.random.permutation(n_pop)\\n p1 = pop[q[0]]\\n p2 = pop[q[1]]\\n\\n # a. Perform Crossover\\n c1, c2 = crossover(p1, p2, gamma)\\n\\n # Apply Bound\\n apply_bound(c1, var_min, var_max)\\n apply_bound(c2, var_min, var_max)\\n\\n # Evaluate First Offspring\\n c1.cost = costfxn(c1.position, attr_keys, d_set)\\n if c1.cost < best_sol.cost:\\n best_sol = c1.deepcopy()\\n eval_count += 1\\n str_eval += \\\"{}: {} \\\\n\\\".format(eval_count, best_sol.cost)\\n\\n # Evaluate Second Offspring\\n c2.cost = costfxn(c2.position, attr_keys, d_set)\\n if c2.cost < best_sol.cost:\\n best_sol = c2.deepcopy()\\n eval_count += 1\\n str_eval += \\\"{}: {} \\\\n\\\".format(eval_count, best_sol.cost)\\n\\n # b. Perform Mutation\\n c1 = mutate(c1, mu, sigma)\\n c2 = mutate(c2, mu, sigma)\\n\\n # Apply Bound\\n apply_bound(c1, var_min, var_max)\\n apply_bound(c2, var_min, var_max)\\n\\n # Evaluate First Offspring\\n c1.cost = costfxn(c1.position, attr_keys, d_set)\\n if c1.cost < best_sol.cost:\\n best_sol = c1.deepcopy()\\n eval_count += 1\\n str_eval += \\\"{}: {} \\\\n\\\".format(eval_count, best_sol.cost)\\n\\n # Evaluate Second Offspring\\n c2.cost = costfxn(c2.position, attr_keys, d_set)\\n if c2.cost < best_sol.cost:\\n best_sol = c2.deepcopy()\\n eval_count += 1\\n str_eval += \\\"{}: {} \\\\n\\\".format(eval_count, best_sol.cost)\\n\\n # c. Add Offsprings to c_pop\\n c_pop.append(c1)\\n c_pop.append(c2)\\n\\n # Merge, Sort and Select\\n pop += c_pop\\n pop = sorted(pop, key=lambda x: x.cost)\\n pop = pop[0:n_pop]\\n\\n best_gp = validategp(d_set, decodegp(attr_keys, best_sol.position))\\n \\\"\\\"\\\":type best_gp: GP\\\"\\\"\\\"\\n is_present = isduplicate(best_gp, best_patterns)\\n is_sub = amcheck(best_patterns, best_gp, subset=True)\\n if is_present or is_sub:\\n repeated += 1\\n else:\\n if best_gp.support >= min_supp:\\n best_patterns.append(best_gp)\\n str_best_gps.append(best_gp.print(d_set.titles))\\n # else:\\n # best_sol.cost = 1\\n\\n try:\\n # Show Iteration Information\\n # Store Best Cost\\n best_costs[it_count] = best_sol.cost\\n str_iter += \\\"{}: {} \\\\n\\\".format(it_count, best_sol.cost)\\n except IndexError:\\n pass\\n it_count += 1\\n\\n if max_iteration == 1:\\n counter = repeated\\n else:\\n counter = it_count\\n # Output\\n out = json.dumps({\\\"Algorithm\\\": \\\"GA-GRAD\\\", \\\"Best Patterns\\\": str_best_gps, \\\"Iterations\\\": it_count})\\n \\\"\\\"\\\":type out: object\\\"\\\"\\\"\\n if return_gps:\\n return out, best_patterns\\n else:\\n return out\",\n \"def enhancer2gene(\\n self,\\n peak_pr,\\n up=100_000,\\n down=100_000,\\n alpha=1e4,\\n promoter=2000,\\n full_weight_region=5000,\\n ):\\n genes = region_gene_overlap(peak_pr, self.gene_bed)\\n\\n # Get the distance from center of enhancer to TSS\\n # Correct for extension\\n genes[\\\"dist\\\"] = (\\n (genes[\\\"Start_b\\\"] + genes[\\\"End_b\\\"]) / 2 - genes[\\\"Start\\\"]\\n ).astype(int)\\n genes.loc[genes[\\\"Strand\\\"] == \\\"+\\\", \\\"dist\\\"] -= up\\n genes.loc[genes[\\\"Strand\\\"] == \\\"-\\\", \\\"dist\\\"] -= down\\n genes[\\\"dist\\\"] = np.abs(genes[\\\"dist\\\"])\\n\\n # Create region in chr:start:end format\\n genes[\\\"loc\\\"] = (\\n genes[\\\"Chromosome\\\"].astype(str)\\n + \\\":\\\"\\n + genes[\\\"Start_b\\\"].astype(str)\\n + \\\"-\\\"\\n + genes[\\\"End_b\\\"].astype(str)\\n )\\n\\n # Keep the gene-enhancer combination with the smallest distance\\n genes = genes.sort_values(\\\"dist\\\").drop_duplicates(\\n subset=[\\\"loc\\\", \\\"Name\\\"], keep=\\\"first\\\"\\n )\\n\\n # Return the right stuff\\n genes = genes.set_index(\\\"loc\\\")[[\\\"Name\\\", \\\"dist\\\"]].rename(\\n columns={\\\"Name\\\": \\\"gene\\\"}\\n )\\n\\n # Get distance-based wight\\n weight = self.distance_weight(\\n include_promoter=self.include_promoter,\\n include_enhancer=self.include_enhancer,\\n alpha=alpha,\\n promoter_region=promoter,\\n full_weight_region=full_weight_region,\\n ).set_index(\\\"dist\\\")\\n genes = genes.join(weight, on=\\\"dist\\\")\\n\\n return genes\",\n \"def main():\\n G = nx.gnp_random_graph(100, 0.5)\\n centrality = nx.eigenvector_centrality(G)\\n avg_centrality = sum(centrality.values()) / len(G)\\n\\n def has_high_centrality(v):\\n return centrality[v] >= avg_centrality\\n\\n source = 0\\n value = centrality.get\\n condition = has_high_centrality\\n\\n found_node = progressive_widening_search(G, source, value, condition)\\n c = centrality[found_node]\\n print('found node {0} with centrality {1}'.format(found_node, c))\",\n \"def vis_hierarchy(corexes, row_label=None, column_label=None, max_edges=100, prefix=''):\\n if column_label is None:\\n column_label = list(map(str, range(corexes[0].alpha.shape[1])))\\n if row_label is None:\\n row_label = list(map(str, range(corexes[0].labels.shape[0])))\\n\\n f = safe_open(prefix + '/text_files/higher_layer_group_tcs.txt', 'w+')\\n params = ['dim_hidden', 'eps', 'marginal_description', 'max_iter', 'max_samples', 'missing_values', 'n_cpu',\\n 'n_hidden', 'n_repeat', 'n_samples', 'n_visible', 'ram', 'smooth_marginals']\\n parameter_dict = {}\\n for j, corex in enumerate(corexes):\\n parameter_dict[j] = {}\\n for param in params:\\n parameter_dict[j][param] = getattr(corex, param, None)\\n f.write('At layer: %d, Total TC: %0.3f\\\\n' % (j, corex.tc))\\n f.write('Individual TCS:' + str(corex.tcs) + '\\\\n')\\n plot_convergence(corex.tc_history, prefix=prefix, prefix2=j)\\n g = safe_open('{}/text_files/mis_layer{}.csv'.format(prefix, j), 'w+')\\n h = safe_open('{}/text_files/weights_layer{}.csv'.format(prefix, j), 'w+')\\n if j == 0:\\n g.write('factor,' + ','.join(column_label) + '\\\\n')\\n h.write('factor,' + ','.join(column_label) + '\\\\n')\\n else:\\n g.write('factor,'+ ','.join(map(str, list(range(len(corex.mis[0,:]))))) + '\\\\n')\\n h.write('factor,'+ ','.join(map(str, list(range(len(corex.mis[0,:]))))) + '\\\\n')\\n mis = corex.mis / np.log(2)\\n alpha = corex.alpha\\n for ir, r in enumerate(mis):\\n g.write(str(ir) + ',' + ','.join(map(str, mis[ir])) + '\\\\n')\\n h.write(str(ir) + ',' + ','.join(map(str, mis[ir] * alpha[ir].ravel())) + '\\\\n')\\n g.close()\\n h.close()\\n f.close()\\n with open('{}/text_files/parameters.json'.format(prefix), 'w') as fp:\\n json.dump(parameter_dict, fp)\\n\\n import textwrap\\n column_label = list(map(lambda q: '\\\\n'.join(textwrap.wrap(q, width=17, break_long_words=False)), column_label))\\n\\n # Construct non-tree graph\\n weights = [corex.alpha[:, :, 0].clip(0, 1) * corex.mis for corex in corexes]\\n node_weights = [corex.tcs for corex in corexes]\\n g = make_graph(weights, node_weights, column_label, max_edges=max_edges)\\n\\n # Display pruned version\\n h = g.copy() # trim(g.copy(), max_parents=max_parents, max_children=max_children)\\n edge2pdf(h, prefix + '/graphs/graph_prune_' + str(max_edges), labels='label', directed=True, makepdf=True)\\n\\n # Display tree version\\n tree = g.copy()\\n tree = trim(tree, max_parents=1, max_children=False)\\n edge2pdf(tree, prefix + '/graphs/tree', labels='label', directed=True, makepdf=True)\\n\\n return g\",\n \"def evolution(inipop):\\n popmorph = inipop\\n countgenerations = 0\\n terminalcount = 0\\n bestindiv = inipop[0]\\n print(\\\"initializing with fitness: \\\",bestindiv.fitness)\\n \\n \\n while terminalcount != 25:\\n \\n\\n selection(popmorph)\\n \\n generationsbest = top_individual(popmorph)\\n print(\\\"evaluating generation: \\\",countgenerations)\\n countgenerations += 1\\n \\n \\n if generationsbest.fitness > bestindiv.fitness:\\n \\n bestindiv = generationsbest\\n print(\\\"Better individual found in generation\\\",countgenerations,\\\"! Top fitness now: \\\",bestindiv.fitness)\\n terminalcount = 0\\n else:\\n terminalcount += 1\\n\\n \\n \\n popmorph = next_generation(popmorph)\\n \\n \\n return(bestindiv, countgenerations)\",\n \"def detection_algorithm(G, edge_weight):\\n Gc = G.copy()\\n set_node_attributes(Gc, attr_name='k-index')\\n seed_node2communities = {}\\n\\n from operator import itemgetter\\n while Gc.number_of_nodes() > 0:\\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\\n Gc.remove_nodes_from(nodes_in_community)\\n return seed_node2communities\",\n \"def __top_Algs_ ( self ) :\\n _algs = self.TopAlg\\n\\n def _alg_name_ ( _n ):\\n\\n _p = _n.rfind('/')\\n if 0 > _p : return _n\\n return _n[_p:]\\n\\n def _pyAlg ( _n ) :\\n for _a in self.pyalgorithms :\\n if _n == _a.name() : return _a\\n return None \\n \\n algs = [] \\n for _a in _algs :\\n # get the proper name \\n _n = _alg_name_ ( _a )\\n # check if it is pyalgorithm:\\n _pa = _pyAlg ( _n )\\n if _pa :\\n algs += [ _pa ]\\n else :\\n _alg = self.algorithm ( _a , True )\\n algs += [ _alg ]\\n \\n return algs\",\n \"def __top_Algs_ ( self ) :\\n _algs = self.TopAlg\\n\\n def _alg_name_ ( _n ):\\n\\n _p = _n.rfind('/')\\n if 0 > _p : return _n\\n return _n[_p:]\\n\\n def _pyAlg ( _n ) :\\n for _a in self.pyalgorithms :\\n if _n == _a.name() : return _a\\n return None \\n \\n algs = [] \\n for _a in _algs :\\n # get the proper name \\n _n = _alg_name_ ( _a )\\n # check if it is pyalgorithm:\\n _pa = _pyAlg ( _n )\\n if _pa :\\n algs += [ _pa ]\\n else :\\n _alg = self.algorithm ( _a , True )\\n algs += [ _alg ]\\n \\n return algs\",\n \"def grid_human_co(episodes = 1000, h_agent=None, coagent= None, threshold = 1.0, verbose = True, mode='override'):\\n\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n\\n #this is just printing stuff for easier terminal reading\\n if h_agent is not None:\\n hstr = \\\"Specialized Human\\\"\\n else:\\n hstr = \\\"Random Human\\\"\\n if coagent is not None:\\n coagenthelp = True\\n if verbose: print(grid.name + ' with '+hstr+' and CoAgent('+ mode +')')\\n else:\\n coagenthelp = False\\n if verbose: print(grid.name + ' with '+hstr+' Agent Alone')\\n\\n liRewards = []\\n liRewardsPenalized = []\\n actionsctli =[]\\n heatmap = np.zeros((7, 7))\\n for i in range(episodes):\\n grid.reset()\\n actionct = 0\\n misstepct = 0\\n heatmap[0,0] += 1\\n while (not grid.isEnd) and (grid.numSteps <=200):\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n state_ind = state[1]*(width+1)+state[0]\\n\\n if 'disjoint' in mode:\\n actions = [0, 1, 2, 3]\\n else:\\n #'up','right','down','left','upri','dori','dole','uple'\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n #if we have a special human agent use it, if not use random human\\n if h_agent is None:\\n action = np.random.choice(actions, 1)[0]\\n h_action = action\\n else:\\n action = h_agent.get_action(state_ind)\\n h_action = action\\n if coagenthelp:\\n q_vals = coagent.get_q_values(state_ind)\\n best_action = coagent.get_action(state_ind)\\n best_q = q_vals[best_action]\\n min_q = min(q_vals)\\n human_q = q_vals[action]\\n\\n #closest actions dictionary\\n closest_a = {0:[4,7],1:[4,5],2:[5,6],3:[6,7],4:[0,1],5:[1,2],6:[2,3],7:[0,3]}\\n #value = action index if radial\\n #key = actual action index\\n a_dist_ind = {0:0, 1:2, 2:4, 3:6, 4:1, 5:3 ,6:5 ,7:7}\\n #actions in order of circle\\n a_radial = [0,4,1,5,2,6,3,7]\\n #co-pilot action choices\\n #override to optimal if suboptimal action selected\\n if \\\"override\\\" in mode:\\n #random percent to decide when to help if wrong action taken\\n if (human_q < best_q) and np.random.uniform() <= 1-threshold:\\n actionct += 1\\n action = best_action\\n #select best closest action if human action q-value is negative\\n elif mode == \\\"q-neg\\\" and human_q < 0:\\n actionct += 1\\n a_li = closest_a[action]\\n action = a_li[np.argmax([q_vals[a] for a in a_li])]\\n #Shared Autonomy\\n #select better closest action if difference between best q and human q is past some threshold\\n elif mode == \\\"q-diff\\\" and (human_q-min_q)<(1-threshold)*(best_q-min_q):\\n actionct += 1\\n for i in range(1,5):\\n radial_a = a_dist_ind[action]\\n ccw_ra = (radial_a - i) % len(actions)\\n ccw_a = a_radial[ccw_ra]\\n if q_vals[ccw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = ccw_a\\n break\\n cw_ra = (radial_a + i) % len(actions)\\n cw_a = a_radial[cw_ra]\\n if q_vals[cw_a]-min_q >= (1-threshold)*(best_q-min_q):\\n action = cw_a\\n break\\n #take the potentiallny new action\\n grid.step(action)\\n\\n if h_agent is not None:\\n heatmap[grid.state[1],grid.state[0]] += 1\\n\\n #add metrics to their respective lists\\n liRewards.append(grid.reward)\\n liRewardsPenalized.append(grid.reward-actionct)\\n actionsctli.append(actionct)\\n #convert lists to numpy arrays\\n rewards = np.array(liRewards)\\n rewards_penalized = np.array(liRewardsPenalized)\\n actionsctli = np.array(actionsctli)\\n #print some metrics if we want to\\n if verbose:\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n print('Avg num of interventions:', np.mean(actionsctli, axis=0))\\n #heatmap makes a nice drawing for the paths taken if we have a specialized human\\n if h_agent is not None:\\n plt.figure()\\n print(heatmap)\\n plt.imshow(heatmap, cmap='cool', interpolation='nearest')\\n plt.savefig('two.png')\\n\\n return rewards, actionsctli, rewards_penalized\",\n \"def find_common_interactor():\\n # 1. filter the unique fusion gene pairs.\\n # fusionGenePair = pd.read_csv(\\\"./fusionGenePair.csv\\\", header=0, sep=' ')\\n # unique_fusionGenePair = fusionGenePair.drop_duplicates()\\n # unique_fusionGenePair.to_csv(\\\"./uniqueFusion.csv\\\", sep=' ', index=False)\\n unique_fusionGenePair = pd.read_csv(\\\"./uniqueFusion.csv\\\", sep=' ', header=0)\\n\\n # 2. for each gene pairs, get all the interactors each partner has.\\n\\n # Store the 5' partner gene and 3' partner gene in two lists.\\n FivePartnerGenelist = []\\n ThreePartnerGenelist = []\\n for index, row in unique_fusionGenePair.iterrows():\\n FivePartnerGenelist.append(row['5_PARTNER_GENE'])\\n ThreePartnerGenelist.append(row['3_PARTNER_GENE'])\\n # Get the unique gene in each pair\\n uniqueFPGL = list(OrderedDict.fromkeys(FivePartnerGenelist))\\n uniqueTPGL = list(OrderedDict.fromkeys(ThreePartnerGenelist))\\n uniqueGene = list(OrderedDict.fromkeys(uniqueTPGL + uniqueFPGL))\\n\\n # Find each gene's interactor in the PPI datasets\\n PPIS = pd.read_csv(\\\"./IID results/PPIs_final.tsv\\\", sep='\\\\t', header=0)\\n\\n # Put each gene interactor into a dictionary.\\n geneIntDic = {}\\n for item in uniqueGene:\\n for index, row in PPIS.iterrows():\\n if row['Query Symbol'] == item:\\n if item in geneIntDic:\\n geneIntDic[item].append(row['Partner Symbol'])\\n else:\\n key = item\\n geneIntDic.setdefault(key, [])\\n geneIntDic[item].append(row['Partner Symbol'])\\n if row['Partner Symbol'] == item:\\n if item in geneIntDic:\\n geneIntDic[item].append(row['Query Symbol'])\\n else:\\n key = item\\n geneIntDic.setdefault(key, [])\\n geneIntDic[item].append(row['Query Symbol'])\\n w = csv.writer(open(\\\"./geneIntDic.csv\\\", \\\"w\\\"))\\n for key, val in geneIntDic.items():\\n w.writerow([key, val])\",\n \"def sense(self, agents, agent_index, top_down_map=None):\\n host_agent = agents[agent_index]\\n other_agent_dists = {}\\n sorted_pairs = sorted(other_agent_dists.items(),\\n key=operator.itemgetter(1))\\n\\n sorting_criteria = []\\n for i, other_agent in enumerate(agents):\\n if other_agent.id == host_agent.id:\\n continue\\n # project other elements onto the new reference frame\\n rel_pos_to_other_global_frame = other_agent.pos_global_frame - \\\\\\n host_agent.pos_global_frame\\n p_parallel_ego_frame = np.dot(rel_pos_to_other_global_frame, host_agent.ref_prll)\\n p_orthog_ego_frame = np.dot(rel_pos_to_other_global_frame, host_agent.ref_orth)\\n dist_between_agent_centers = vec2_l2_norm(rel_pos_to_other_global_frame)\\n dist_2_other = dist_between_agent_centers - host_agent.radius - other_agent.radius\\n combined_radius = host_agent.radius + other_agent.radius\\n\\n if dist_between_agent_centers > Config.SENSING_HORIZON:\\n # print(\\\"Agent too far away\\\")\\n continue\\n\\n if self.agent_sorting_method != \\\"time_to_impact\\\":\\n time_to_impact = None\\n else:\\n time_to_impact = compute_time_to_impact(host_agent.pos_global_frame,\\n other_agent.pos_global_frame,\\n host_agent.vel_global_frame,\\n other_agent.vel_global_frame,\\n combined_radius)\\n\\n sorting_criteria.append([i, round(dist_2_other,2), p_orthog_ego_frame, time_to_impact])\\n\\n clipped_sorted_inds = self.get_clipped_sorted_inds(sorting_criteria)\\n clipped_sorted_agents = [agents[i] for i in clipped_sorted_inds]\\n\\n other_agents_states = np.zeros((Config.MAX_NUM_OTHER_AGENTS_OBSERVED, 7))\\n other_agent_count = 0\\n for other_agent in clipped_sorted_agents:\\n if other_agent.id == host_agent.id:\\n continue\\n # project other elements onto the new reference frame\\n rel_pos_to_other_global_frame = other_agent.pos_global_frame - \\\\\\n host_agent.pos_global_frame\\n p_parallel_ego_frame = np.dot(rel_pos_to_other_global_frame,\\n host_agent.ref_prll)\\n p_orthog_ego_frame = np.dot(rel_pos_to_other_global_frame,\\n host_agent.ref_orth)\\n v_parallel_ego_frame = np.dot(other_agent.vel_global_frame,\\n host_agent.ref_prll)\\n v_orthog_ego_frame = np.dot(other_agent.vel_global_frame,\\n host_agent.ref_orth)\\n dist_2_other = np.linalg.norm(rel_pos_to_other_global_frame) - \\\\\\n host_agent.radius - other_agent.radius\\n combined_radius = host_agent.radius + other_agent.radius\\n\\n other_obs = np.array([p_parallel_ego_frame,\\n p_orthog_ego_frame,\\n v_parallel_ego_frame,\\n v_orthog_ego_frame,\\n other_agent.radius,\\n combined_radius,\\n dist_2_other])\\n \\n if other_agent_count == 0:\\n host_agent.other_agent_states[:] = other_obs\\n\\n other_agents_states[other_agent_count,:] = other_obs\\n other_agent_count += 1\\n\\n host_agent.num_other_agents_observed = other_agent_count\\n\\n return other_agents_states\",\n \"def finetune_intron_boundaries(abfgp_genemodel,introndata,\\n array_algpresence,array_algsimilarity,verbose=True):\\n\\n # Global Variable Imports\\n FINETUNE_ACCEPTOR_NT_OFFSET = 12\\n FINETUNE_DONOR_NT_OFFSET = 12\\n FINETUNE_ACCEPTOR_NT_OFFSET = 18\\n FINETUNE_DONOR_NT_OFFSET = 18\\n from settings.genestructure import MIN_INTRON_NT_LENGTH\\n\\n # list with adjusted boundaries\\n refined_boundaries = []\\n\\n # recreate lists of ABGFP exons & introns\\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\\n\\n for intron_pos in range(0,len(abfgp_introns)):\\n intron = abfgp_introns[intron_pos]\\n if not intron: continue\\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\\n has_been_printed = False\\n finetune_acceptor_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1)\\n finetune_donor_range = range(intron.donor.pos-FINETUNE_DONOR_NT_OFFSET,\\n intron.donor.pos+FINETUNE_DONOR_NT_OFFSET+1)\\n\\n # assign branchpoint in current intron\\n intron.assign_bp_and_ppts()\\n\\n # start searching acceptor based\\n alternatives = []\\n for acceptor in intron.orfAcceptor._acceptor_sites:\\n if acceptor.pos != intron.acceptor.pos and\\\\\\n acceptor.phase != intron.acceptor.phase and\\\\\\n acceptor.pos in finetune_acceptor_range:\\n # now see if we can find a donor for this phase too\\n for donor in intron.orfDonor._donor_sites:\\n if donor.pos != intron.donor.pos and\\\\\\n donor.phase != intron.donor.phase and\\\\\\n donor.phase == acceptor.phase and\\\\\\n donor.pos in finetune_donor_range:\\n # get the next exon (3'of this intron)\\n next_exon = abfgp_exons[intron_pos+1]\\n prev_exon = abfgp_exons[intron_pos]\\n\\n if not has_been_printed:\\n has_been_printed = True\\n ####################################################\\n if verbose: print \\\"FINETUNING INTRON::\\\", intron\\n ####################################################\\n\\n # get data on this alternative acceptor/donor combination\\n test_intron = IntronConnectingOrfs(donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\\n test_intron.assign_bp_and_ppts()\\n\\n # test if refinement will result in a long enough intron\\n if test_intron.length < MIN_INTRON_NT_LENGTH: continue\\n\\n scorelist = []\\n # score 1: is donor.pssm_score `higher`?\\n scorelist.append( _finetune_splicesite_comparison(intron.donor,donor) )\\n # score 2: is acceptor.pssm_score `higher`?\\n scorelist.append( _finetune_splicesite_comparison(intron.acceptor,acceptor) )\\n # score 3: branchpoint comparison?\\n scorelist.append( _branchpoint_comparison(intron,test_intron) )\\n # score 4: ppt comparison?\\n scorelist.append( _polypyrimidinetract_comparison(intron,test_intron) )\\n # score 5: is algsimilarity ratio increased (==better)?\\n scorelist.append( _algsimilarity_comparison(intron,test_intron,prev_exon,next_exon,array_algsimilarity) )\\n\\n # evaluate scorelist; improved intron boundary or not?\\n # use donor, acceptor, branchpoint & ppt, do *NOT* use algsim score\\n if scorelist[0:4].count(False) == 0 and scorelist[0:4].count(True) >= 1:\\n alternatives.append( ( donor, acceptor, scorelist ) )\\n is_accepted = True\\n else:\\n is_accepted = False\\n\\n ########################################################\\n if verbose:\\n print \\\"alternatives:\\\", donor, acceptor,\\n print intron.donor.pos - donor.pos,\\n print intron.acceptor.pos - acceptor.pos,\\n print scorelist, is_accepted,\\n print \\\"BPcur:\\\",intron.get_branchpoint_nt_distance(),\\n print \\\"alt:\\\",\\n print test_intron.get_branchpoint_nt_distance()\\n ########################################################\\n\\n # now evaluate the alternatived and take the best one\\n if not alternatives:\\n continue\\n elif len(alternatives) == 1:\\n refined_boundaries.append( ( intron.donor, alternatives[0][0] ) )\\n refined_boundaries.append( ( intron.acceptor, alternatives[0][1] ) )\\n else:\\n # multiple! again, take the *best* one\\n pass\\n\\n # return list of refined_boundaries\\n return refined_boundaries\",\n \"def remove_hi_confidence_chromosome(G):\\n to_remove = []\\n for nd in G.nodes():\\n if get_length_from_spades_name(nd) > PARAMS.CHROMOSOME_LEN_THRESH and \\\\\\n G.nodes[nd]['score'] < PARAMS.CHROMOSOME_SCORE_THRESH:\\n to_remove.append(nd)\\n to_remove.append(rc_node(nd))\\n G.remove_nodes_from(to_remove)\\n logger.info(\\\"Removed %d long, likely chromosomal nodes\\\" % len(set(to_remove)))\",\n \"def analysis_go_RSA(self, s_go, S_hit, S_score, N_total=0, SRC_GENE=None, min_overlap=3, p_cutoff=0.01, l_keep_most=True):\\n c={'GO':s_go, '#TotalGeneInLibrary':N_total, '#GeneInGO':0, '#GeneInHitList':0, '#GeneInGOAndHitList':0, 'Cutoff':None, '#HitRemain':0, '#HitInGORemain':0, 'LogP':0.0, 'Enrichment':0}\\n #if SRC_GENE is not None:\\n # print \\\"SRC_GENE: \\\"+str(len(SRC_GENE))\\n S_gene=self.GO_GENE[s_go]\\n if len(S_gene)>=Cache.N_TRIVIAL:\\n return None\\n if not N_total:\\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\\n t_hit=pd.DataFrame(data={'Hit':S_hit, 'Score':S_score})\\n if SRC_GENE is not None:\\n S_gene=S_gene.intersection(SRC_GENE)\\n t_hit=t_hit[ t_hit.Hit.apply(lambda x: x in SRC_GENE) ]\\n S_hit=set(t_hit.Hit)\\n else:\\n S_hit=set(S_hit)\\n t_hit.sort_values('Score', inplace=True)\\n c['#GeneInGO']=len(S_gene)\\n c['#GeneInHitList']=len(S_hit)\\n if c['#GeneInGO']<min_overlap or c['#GeneInHitList']<min_overlap:\\n return None\\n S_both=S_gene.intersection(S_hit)\\n c['#GeneInGOAndHitList']=len(S_both)\\n if c['#GeneInGOAndHitList']<min_overlap:\\n return None\\n\\n I_index=np.arange(len(t_hit))[t_hit.Hit.apply(lambda x: x in S_gene).values]\\n I_rank=stats.RSA_rank(t_hit.Score.values, I_index)\\n rslt=stats.RSA_score(I_rank, N_total, l_BonferroniCorrection=True, l_keep_most=l_keep_most, p_cutoff=p_cutoff)\\n c['#HitInGORemain']=rslt[\\\"cutoff\\\"]+1\\n if c['#HitInGORemain']<min_overlap: return None\\n c['#HitRemain']=I_rank[rslt[\\\"cutoff\\\"]]\\n c['Cutoff']=t_hit.Score.values[rslt[\\\"cutoff\\\"]]\\n c['%InGO']=c['#HitInGORemain']*100.0/c['#HitRemain']\\n q=min(max(c['%InGO']/100, 1.0/c['#HitRemain']), 1-1.0/c['#HitRemain'])\\n c['STDV %InGO']=np.sqrt(q*(1-q)/c['#HitRemain'])*100\\n c['Enrichment']=c['%InGO']/100.0*N_total/c['#GeneInGO']\\n S=[int(x) for x in S_both]\\n S.sort()\\n c['GeneID_All']='|'.join([str(x) for x in S])\\n S=[int(x) for x in list(t_hit.Hit[: rslt[\\\"cutoff\\\"]+1])]\\n S.sort()\\n c['GeneID']='|'.join([str(x) for x in S])\\n c['LogP']=rslt['logP']\\n return c\",\n \"def _find_solution(self, population, num_of_best_chromosomes):\\n data = self._Individuals()\\n for x in population:\\n curr_fit = self._fitness(x)\\n data.append_object(self._Individual(curr_fit, x))\\n return data.sort_objects()[:num_of_best_chromosomes]\",\n \"def all_best_nr(potential_coverage, all_coverage, covered):\\n ## get redundancy count\\n potential_redundancy = {grna_seq: len(set(hit.target_id for hit in hits\\n if hit.target_id in covered))\\n for grna_seq, hits in all_coverage.items()\\n if grna_seq in potential_coverage}\\n best_redundancy = min(potential_redundancy.values())\\n return {grna_seq: potential_coverage[grna_seq]\\n for grna_seq, redundancy in potential_redundancy.items()\\n if redundancy == best_redundancy}\",\n \"def analysis(self, S_hit, S_score=None, S_go=None, SRC_GENE=None, min_overlap=3, min_enrichment=0, p_cutoff=0.01, n_CPU=0, l_rsa_keep_most=True, S_go_category=None, l_background_by_ontology=False):\\n\\n def go_filtered(S_go, S_go_category):\\n return [x for x in S_go if self.get_category_id(x) in S_go_category]\\n\\n S_all_go_filtered=[]\\n def all_go_filtered(S_go_category):\\n if len(S_all_go_filtered)==0:\\n S_go=self.GO_GENE_ENRICH\\n S_all_go_filtered.append(go_filtered(S_go, S_go_category))\\n return S_all_go_filtered[0]\\n\\n N_go=0\\n if S_go_category is not None and len(S_go_category)>0:\\n # hard code for now, to be fixed later\\n if type(S_go_category) in (int, str):\\n S_go_category=[S_go_category]\\n S_go_category={int(x) for x in S_go_category if self.CATEGORY_COUNT.get(x,0)>0 }\\n for x in S_go_category:\\n N_go+=self.CATEGORY_COUNT[x]\\n else:\\n N_go=sum(self.CATEGORY_COUNT.values())\\n\\n l_multi_list=type(S_hit) is dict\\n if S_go is None:\\n if l_multi_list:\\n S_go={}\\n for k in S_hit.keys():\\n S_go[k]=all_go_filtered(S_go_category)\\n else:\\n S_go=all_go_filtered(S_go_category)\\n else:\\n if l_multi_list:\\n for k in S_hit.keys():\\n if S_go.get(k, None) is None:\\n S_go[k]=all_go_filtered(S_go_category)\\n else:\\n S_go[k]=go_filtered(S_go[k], S_go_category)\\n else:\\n S_go=go_filtered(S_go, S_go_category)\\n\\n if SRC_GENE is not None:\\n if type(SRC_GENE) is list:\\n SRC_GENE=set(SRC_GENE)\\n SRC_GENE=self.ALL_GENE.intersection(SRC_GENE) # remove genes from background, if it is not in self.ALL_GENE\\n N_total=len(SRC_GENE) #self.ALL_GENE.intersection(SRC_GENE))\\n elif l_background_by_ontology:\\n # GeneGo uses this\\n if l_multi_list:\\n X=set()\\n for x in S_go.values():\\n X.add(set(x))\\n src_genes=self.gene_count(list(X))\\n else:\\n src_genes=self.gene_count(S_go)\\n N_total=len(src_genes)\\n SRC_GENE=set(src_genes.keys())\\n else:\\n if self.is_L1000():\\n N_total=len(self.ALL_GENE)\\n else:\\n N_total=len(self.GENE_GO) #len(self.ALL_GENE), only count genes that has GO annotation\\n #N_total=len(self.ALL_GENE)\\n # prefiltering uninteresting GO terms\\n # already converted to multiple hit list situation\\n sw=util.StopWatch()\\n L=[] # list of (S_hit, s_go)\\n\\n def spread_input(S_hit, S_go, key):\\n #S_hit, S_go, key=(X[0], X[1], X[2])\\n # may not worth it\\n #c_cnt=self.go_count(S_hit, S_go)\\n #S_go=[s_go for s_go in S_go if c_cnt.get(s_go,0)>=min_overlap ]\\n # minimum size\\n MIN_BATCH=2000\\n S_go2=util.split(S_go, chunk_size=MIN_BATCH)\\n return [(key, S_hit, x) for x in S_go2]\\n\\n #sw.check('To spreadout')\\n if l_multi_list:\\n #mp=parallel.MP()\\n #m=1 if len(S_hit)<=3 else n_CPU\\n #mp.start(f=spread_input, n_CPU=m)\\n #L=[(X, S_go[k], k) for k,X in S_hit.items() if len(X)>=min_overlap]\\n #out=mp.map(L)\\n #L=[y for X in out for y in X]\\n L=[]\\n for k,X in S_hit.items():\\n if len(X)<min_overlap: continue\\n L.extend(spread_input(X, S_go[k], k))\\n random.shuffle(L)\\n else:\\n if len(S_hit)>=min_overlap:\\n L=spread_input(S_hit, S_go, 'Default')\\n\\n if self.eg is None:\\n self.eg=ez.EntrezGene(tax_id=self.tax_id, l_use_GPDB=self.GPDB)\\n if n_CPU==0: n_CPU=1\\n #print \\\">>>>>>>>>>>>>>\\\", len(L)\\n S_chunk=util.split(L, n_chunk=n_CPU)\\n #sw.check('Spreadout tasks: %d' % len(L))\\n\\n def analyze(L):\\n \\\"\\\"\\\"L is a list of [[s_name, S_hit, s_go]], s_go can also be a list\\\"\\\"\\\"\\n rslt=[]\\n #p=util.Progress(len(L))\\n i=0\\n import multiprocessing\\n s_pid=str(multiprocessing.current_process().pid)\\n for s_name, S_hit, S_go in L:\\n i+=1\\n #if (i % 50000): p.check(i, s_pid)\\n if type(S_go) is str: S_go=[S_go]\\n for s_go in S_go:\\n if s_go not in self.GO_GENE: continue\\n if S_score is None:\\n c=self.analysis_go(s_go, S_hit, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff)\\n else:\\n c=self.analysis_go_RSA(s_go, S_hit, S_score, N_total, SRC_GENE=SRC_GENE, min_overlap=min_overlap, p_cutoff=p_cutoff, l_keep_most=l_rsa_keep_most)\\n if c is None:\\n continue\\n c['Name']=s_name\\n if min_enrichment>0 and c['Enrichment']<min_enrichment: continue\\n if p_cutoff<1 and 10**c['LogP']>p_cutoff: continue\\n c['Description']= self.go_description(s_go)\\n S_gene=c['GeneID'].split('|')\\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\\n c['Hits']='|'.join(S_symbol)\\n if 'GeneID_All' in c:\\n S_gene=c['GeneID_All'].split('|')\\n S_symbol=[self.eg.C_GENENEW[x] if x in self.eg.C_GENENEW else x for x in S_gene]\\n c['Hits_All']='|'.join(S_symbol)\\n if self.GPDB:\\n c['CategoryID'] = self.get_category_id(c['GO'])\\n c['Category'] = self.CATEGORY.get(self.get_category_id(c['GO']))\\n c['GO'] = self.get_source_id(c['GO'])\\n rslt.append(c)\\n return rslt\\n out=parallel.parmap(analyze, S_chunk, n_CPU=n_CPU)\\n #if n_CPU>1:\\n # mp=parallel.MP()\\n # mp.start(f=analyze, n_CPU=n_CPU)\\n # out=mp.map(S_chunk)\\n #else:\\n # out=[analyze(x) for x in S_chunk]\\n\\n #mp.start(n_CPU=n_CPU)\\n #sw.check('P-value Calculation')\\n #sw.check('P-value Calculation Done')\\n rslt=[]\\n for x in out:\\n if len(x): rslt.extend(x)\\n\\n if len(rslt):\\n #sw.check('Length: %d' % len(rslt))\\n t=pd.DataFrame(rslt)\\n #sw.check('Table DONE')\\n if S_score is None:\\n t=t.sort_values(['LogP','Enrichment','#GeneInGOAndHitList'], ascending=[True,False,False])\\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\\n '#GeneInGO','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits']\\n else:\\n t=t.sort_values(['LogP','Enrichment','#HitInGORemain','#GeneInGOAndHitList'], ascending=[True,False,False,False])\\n cols = ['Name','GO','Description','LogP','Enrichment','Z-score','#TotalGeneInLibrary',\\n '#GeneInGO','#HitRemain','#HitInGORemain','Cutoff','#GeneInHitList','#GeneInGOAndHitList','%InGO','STDV %InGO','GeneID','Hits','GeneID_All','Hits_All']\\n if self.GPDB:\\n #cols.insert(1,'field1')\\n cols.insert(1,'CategoryID')\\n cols.insert(1,'Category')\\n #sw.check('sorted DONE')\\n t=t.reindex(columns=cols)\\n # FDR\\n #print \\\">>> N_go: \\\", N_go\\n #sw.check('reindex DONE')\\n t['Log(q-value)']=np.log10(np.clip(stats.adjust_p(np.power(10, t.LogP.values), N=N_go), 1e-100, 1.0))\\n #sw.check('q-value DONE')\\n if not l_multi_list:\\n t.drop('Name', axis=1, inplace=True)\\n return t\\n else:\\n return None\",\n \"def nearest_common_parent(self, go_ids=None):\\n # Take the element at maximum depth\\n ncp = max(self.common_parents(go_ids=go_ids), key=lambda t: self.dict_go[t].depth)\\n return ncp\",\n \"def get_compound_hets(args):\\n gq = GeminiQuery.GeminiQuery(args.db, include_gt_cols=True)\\n idx_to_sample = gq.idx_to_sample\\n subjects_dict = subjects.get_subjects(gq.c)\\n \\n if args.columns is not None:\\n custom_columns = _add_necessary_columns(args, str(args.columns)) \\n query = \\\"SELECT \\\" + custom_columns + \\\\\\n \\\" FROM variants \\\" + \\\\\\n \\\" WHERE (is_exonic = 1 or impact_severity != 'LOW') \\\"\\n else:\\n # report the kitchen sink\\n query = \\\"SELECT *\\\" + \\\\\\n \\\", gts, gt_types, gt_phases, gt_depths, \\\\\\n gt_ref_depths, gt_alt_depths, gt_quals\\\" + \\\\\\n \\\" FROM variants \\\" + \\\\\\n \\\" WHERE (is_exonic = 1 or impact_severity != 'LOW') \\\"\\n\\n # add any non-genotype column limits to the where clause\\n if args.filter:\\n query += \\\" AND \\\" + args.filter\\n\\n # run the query applying any genotype filters provided by the user.\\n gq.run(query)\\n\\n comp_hets = collections.defaultdict(lambda: collections.defaultdict(list))\\n\\n for row in gq:\\n gt_types = row['gt_types']\\n gts = row['gts']\\n gt_bases = row['gts']\\n gt_phases = row['gt_phases']\\n \\n site = Site(row)\\n\\n # track each sample that is heteroyzgous at this site.\\n for idx, gt_type in enumerate(gt_types):\\n if gt_type == HET:\\n sample = idx_to_sample[idx]\\n \\n if args.only_affected and not subjects_dict[sample].affected:\\n continue\\n\\n # sample = \\\"NA19002\\\"\\n sample_site = copy(site)\\n sample_site.phased = gt_phases[idx]\\n\\n # require phased genotypes\\n if not sample_site.phased and not args.ignore_phasing:\\n continue\\n\\n sample_site.gt = gt_bases[idx]\\n # add the site to the list of candidates\\n # for this sample/gene\\n comp_hets[sample][site.row['gene']].append(sample_site)\\n\\n # header\\n print \\\"family\\\\tsample\\\\tcomp_het_id\\\\t\\\" + str(gq.header)\\n\\n # step 2. now, cull the list of candidate heterozygotes for each\\n # gene/sample to those het pairs where the alternate alleles\\n # were inherited on opposite haplotypes. \\n comp_het_id = 1\\n for sample in comp_hets:\\n for gene in comp_hets[sample]:\\n\\n # we only care about combinations, not permutations\\n # (e.g. only need site1,site2, not site1,site2 _and site2,site1)\\n # thus we can do this in a ~ linear pass instead of a ~ N^2 pass\\n for idx, site1 in enumerate(comp_hets[sample][gene]):\\n for site2 in comp_hets[sample][gene][idx + 1:]:\\n\\n # expand the genotypes for this sample\\n # at each site into it's composite\\n # alleles. e.g. A|G -> ['A', 'G']\\n alleles_site1 = []\\n alleles_site2 = []\\n if not args.ignore_phasing:\\n alleles_site1 = site1.gt.split('|')\\n alleles_site2 = site2.gt.split('|')\\n else:\\n # split on phased (|) or unphased (/) genotypes\\n alleles_site1 = re.split('\\\\||/', site1.gt)\\n alleles_site2 = re.split('\\\\||/', site2.gt)\\n \\n # it is only a true compound heterozygote IFF\\n # the alternates are on opposite haplotypes.\\n if not args.ignore_phasing:\\n # return the haplotype on which the alternate\\n # allele was observed for this sample at each\\n # candidate het. site.\\n # e.g., if ALT=G and alleles_site1=['A', 'G']\\n # then alt_hap_1 = 1. if ALT=A, then alt_hap_1 = 0\\n if \\\",\\\" in str(site1.row['alt']) or \\\\\\n \\\",\\\" in str(site2.row['alt']):\\n sys.stderr.write(\\\"WARNING: Skipping candidate for sample\\\"\\n \\\" %s b/c variants with mult. alt.\\\"\\n \\\" alleles are not yet supported. The sites are:\\\"\\n \\\" %s and %s.\\\\n\\\" % (sample, site1, site2))\\n continue\\n\\n alt_hap_1 = alleles_site1.index(site1.row['alt'])\\n alt_hap_2 = alleles_site2.index(site2.row['alt'])\\n\\n # report if \\n # 1. phasing is considered AND the alt alleles are on\\n # different haplotypes\\n # OR\\n # 2. the user doesn't care about phasing.\\n if (not args.ignore_phasing and alt_hap_1 != alt_hap_2) \\\\\\n or args.ignore_phasing:\\n print \\\\\\n \\\"\\\\t\\\".join([str(subjects_dict[sample].family_id), \\n sample,\\n str(comp_het_id),\\n str(site1.row)])\\n print \\\\\\n \\\"\\\\t\\\".join([str(subjects_dict[sample].family_id), \\n sample,\\n str(comp_het_id),\\n str(site2.row)])\\n\\n comp_het_id += 1\",\n \"def proposal_target_layer(object_rois, gt_objects, gt_relationships, gt_regions,\\n num_classes, voc_sign):\\n\\n # object_rois: (1 x H x W x A, 5) [0, x1, y1, x2, y2]\\n # region_rois: (1 x H x W x A, 5) [0, x1, y1, x2, y2]\\n # gt_objects: (G_obj, 5) [x1 ,y1 ,x2, y2, obj_class] float\\n # gt_relationships: (G_obj, G_obj) [pred_class] int (-1 for no relationship)\\n # gt_regions: (G_region, 4+40) [x1, y1, x2, y2, word_index] (imdb.eos for padding)\\n # # gt_ishard: (G_region, 4+40) {0 | 1} 1 indicates hard\\n # # dontcare_areas: (D, 4) [ x1, y1, x2, y2]\\n # n_classes_obj\\n # n_classes_pred\\n # is_training to indicate whether in training scheme\\n # overlaps: (rois x gt_boxes)\\n ########################\\n ## sample object ROIs ##\\n ########################\\n num_images = 1\\n object_rois_per_image = cfg.TRAIN.BATCH_SIZE / num_images\\n object_keep_inds, object_gt_assignment, object_fg_indicator, object_fg_duplicate = \\\\\\n _sample_rois(object_rois[:, 1:5], gt_objects[:, :4], object_rois_per_image, cfg.TRAIN.FG_FRACTION)\\n object_labels = gt_objects[object_gt_assignment, 4]\\n # Clamp labels for the background RoIs to 0\\n object_labels[np.logical_not(object_fg_indicator)] = 0\\n object_selected_rois = object_rois[object_keep_inds]\\n\\n\\n object_bbox_targets_temp = bbox_transform(object_selected_rois[:, 1:5], gt_objects[object_gt_assignment, :4])\\n object_bbox_target_data = np.hstack(\\n (object_labels[:, np.newaxis], object_bbox_targets_temp)).astype(np.float32, copy=False)\\n object_bbox_targets, object_bbox_inside_weights = \\\\\\n _get_bbox_regression_labels(object_bbox_target_data, num_classes)\\n\\n ##########################\\n ## sample relationships ##\\n ##########################\\n\\n\\n rel_per_image = int(cfg.TRAIN.BATCH_SIZE_RELATIONSHIP / num_images)\\n rel_bg_num = rel_per_image\\n object_fg_inds = object_keep_inds[object_fg_indicator]\\n if object_fg_inds.size > 0:\\n id_i, id_j = np.meshgrid(xrange(object_fg_inds.size), xrange(object_fg_inds.size), indexing='ij') # Grouping the input object rois\\n id_i = id_i.reshape(-1)\\n id_j = id_j.reshape(-1)\\n pair_labels = gt_relationships[object_gt_assignment[id_i], object_gt_assignment[id_j]]\\n fg_id_rel = np.where(pair_labels > 0)[0]\\n rel_fg_num = fg_id_rel.size\\n rel_fg_num = int(min(np.round(rel_per_image * cfg.TRAIN.FG_FRACTION_RELATIONSHIP), rel_fg_num))\\n # print 'rel_fg_num'\\n # print rel_fg_num\\n if rel_fg_num > 0:\\n fg_id_rel = npr.choice(fg_id_rel, size=rel_fg_num, replace=False)\\n else:\\n fg_id_rel = np.empty(0, dtype=int)\\n rel_labels_fg = pair_labels[fg_id_rel]\\n sub_assignment_fg = id_i[fg_id_rel]\\n obj_assignment_fg = id_j[fg_id_rel]\\n sub_list_fg = object_fg_inds[sub_assignment_fg]\\n obj_list_fg = object_fg_inds[obj_assignment_fg]\\n rel_bg_num = rel_per_image - rel_fg_num\\n\\n phrase_labels = np.zeros(rel_bg_num, dtype=np.float)\\n sub_assignment = npr.choice(xrange(object_keep_inds.size), size=rel_bg_num, replace=True)\\n obj_assignment = npr.choice(xrange(object_keep_inds.size), size=rel_bg_num, replace=True)\\n if (sub_assignment == obj_assignment).any(): # an ugly hack for the issue\\n obj_assignment[sub_assignment == obj_assignment] = (obj_assignment[sub_assignment == obj_assignment] + 1) % object_keep_inds.size\\n\\n\\n\\n if object_fg_inds.size > 0:\\n phrase_labels = np.append(rel_labels_fg, phrase_labels, )\\n sub_assignment = np.append(sub_assignment_fg, sub_assignment,)\\n obj_assignment = np.append(obj_assignment_fg, obj_assignment, )\\n\\n object_selected_rois, region_selected_rois, mat_object, mat_relationship, mat_region = \\\\\\n _setup_connection(object_selected_rois, nms_thres=cfg.TRAIN.REGION_NMS_THRES,\\n sub_assignment_select = sub_assignment,\\n obj_assignment_select = obj_assignment)\\n #print '[Training] Region ROI num: {0:d}'.format(region_selected_rois.shape[0])\\n region_labels, bbox_targets_region, bbox_inside_weight_region, region_assignments = \\\\\\n _sample_regions(region_selected_rois, gt_regions, voc_sign)\\n\\n # assert region_labels.shape[1] == cfg.TRAIN.LANGUAGE_MAX_LENGTH\\n object_labels = object_labels.reshape(-1, 1)\\n phrase_labels = phrase_labels.reshape(-1, 1)\\n object_fg_duplicate = np.stack([object_fg_indicator, object_fg_duplicate], axis=1)\\n\\n return (object_labels, object_selected_rois, object_bbox_targets, object_bbox_inside_weights, mat_object, object_fg_duplicate), \\\\\\n (phrase_labels, mat_relationship), \\\\\\n (region_selected_rois[:, :5], mat_region), \\\\\\n (region_labels, bbox_targets_region, bbox_inside_weight_region, region_assignments)\",\n \"def testqry_topinterpretationspergene(self):\\n e = {('-', 'Benign'): 7644,\\n ('BRCA2', 'Uncertain significance'): 4187,\\n (('TTN', 'TTN-AS1'), 'Uncertain significance'): 3399,\\n ('-', 'Uncertain significance'): 3371, # '-' means no gene defined\\n ('BRCA2', 'Pathogenic'): 3300,\\n ('APC', 'Uncertain significance'): 2925,\\n ('BRCA1', 'Pathogenic'): 2861,\\n ('TTN', 'Uncertain significance'): 2847,\\n ('BRCA1', 'Uncertain significance'): 2286,\\n ('ATM', 'Uncertain significance'): 2153}\\n r = qry.topinterpretationspergene({}, limit=10)\\n r_ = dict()\\n for i in r:\\n _id, ab = i['_id'], i['abundance']\\n if 'gene' in _id:\\n if isinstance(_id['gene'], list):\\n gene = tuple(_id['gene'])\\n else:\\n gene = _id['gene']\\n else:\\n gene = '-'\\n r_[(gene, _id['desc'])] = ab\\n self.comparepairs(r_, e)\",\n \"def fix_COO_and_NH(pdb):\\n M = Molecule(pdb)\\n ds = M.ds\\n g = M.g\\n m = Chem.MolFromPDBFile(pdb, removeHs=True) # don't use True, otherwise Error\\n mc = Chem.EditableMol(m)\\n q = Chem.MolFromSmarts( 'C(~[O])~[O]' )\\n matches = m.GetSubstructMatches(q)\\n #bom = Chem.GetAdjacencyMatrix(m,useBO=True)\\n for (i,j,k) in matches:\\n d1, d2 = ds[i,j], ds[i,k]\\n b1 = m.GetBondBetweenAtoms(i,j)\\n b2 = m.GetBondBetweenAtoms(i,k)\\n if d1 < d2:\\n bij = 2.0; bik = 1.0\\n else:\\n bij = 1.0; bik = 2.0\\n mc.RemoveBond(i,j)\\n mc.RemoveBond(i,k)\\n mc.AddBond(i,j,bo2bt['%.1f'%bij])\\n mc.AddBond(i,k,bo2bt['%.1f'%bik])\\n mu = mc.GetMol()\\n return mu\\n # NX4, e.g., >[N+]<, >[NH+]-, >[NH2+], -[NH3+]\\n #q = Chem.MolFromSmarts( '[NX4]' )\\n\\n # [*]~NX2, e.g., >C=[NH2+]\\n\\n # [*]~NX, e.g., >C=[NH+]-\",\n \"def _propose_atg_on_orf(orfObj,inwpCBG): \\n # donor only -> create FirstExonOnOrf (and hope for the best)\\n if orfObj.has_methionine():\\n # RESCAN TSS pssm sites in any case. List might have been edited\\n # in exceptional cases somewhere earlier in ABFGP flow\\n orfObj.scan_orf_for_pssm_tss(forced=True)\\n if orfObj._tss_sites and inwpCBG:\\n maxsr = inwpCBG.maximal_spanning_range(organism=inwpCBG._get_target_organism())\\n minsr = inwpCBG.minimal_spanning_range(organism=inwpCBG._get_target_organism())\\n firstexon_array_algpresence = PCG2codingarray(inwpCBG,inwpCBG._get_target_organism(),max(maxsr)+1)\\n firstexon_array_algsimilarity = PCG2similarityarray(inwpCBG,inwpCBG._get_target_organism(),max(maxsr)+1)\\n score2tssobj = []\\n for tss in orfObj._tss_sites:\\n tsspos = (tss.pos - orfObj.frame)/3\\n exon_estim_end = max(minsr)+1\\n len5p = tsspos - min(maxsr)\\n len3p = exon_estim_end - tsspos\\n score5P = sum(firstexon_array_algpresence[min(maxsr):tsspos])\\n score3P = sum(firstexon_array_algpresence[tsspos:exon_estim_end])\\n score5S = sum(firstexon_array_algsimilarity[min(maxsr):tsspos])\\n score3S = sum(firstexon_array_algsimilarity[tsspos:exon_estim_end])\\n if len3p > 0:\\n if len5p > 0:\\n scoreP = float(score3P)/float(len3p) - float(score5P)/float(len5p)\\n scoreS = float(score3S)/float(len3p) - float(score5S)/float(len5p)\\n elif len5p < 0:\\n scoreP = float(score3P)/float(len3p) - 1.0 - float(-len5p)/50.0\\n scoreS = float(score3S)/float(len3p) - 1.0 - float(-len5p)/50.0\\n else:\\n scoreP = float(score3P)/float(len3p)\\n scoreS = float(score3S)/float(len3p)\\n else:\\n scoreP = -float(score5P)/float(len5p)\\n scoreS = -float(score5S)/float(len5p)\\n\\n print \\\"\\\\t_propose_atg::\\\", scoreP + scoreS + tss.pssm_score, tss \\n\\n # append overall score and tssobj to list ONLY WHEN scoreP + scoreS > 0\\n if scoreP + scoreS > 0:\\n score2tssobj.append( ( scoreP + scoreS + tss.pssm_score, tss ) )\\n #print \\\"\\\\t\\\", tss, tsspos, scoreP, scoreS, (len5p,len3p), (score5P,score3P),(score5S,score3S),\\n #print sum(firstexon_array_algpresence), sum(firstexon_array_algsimilarity), len(firstexon_array_algsimilarity)\\n\\n if score2tssobj:\\n # get highest scoring TSS\\n score2tssobj.sort()\\n score2tssobj.reverse()\\n atg = score2tssobj[0][1]\\n else:\\n # no sensible Methionine/StartSite\\n atg = False\\n elif orfObj._tss_sites: \\n # no inwpCBG applied -> return first tss in line\\n atg = orfObj._tss_sites[0] \\n else:\\n # get first Methionine coordinate\\n atg = orfObj.potential_start_nt_positions()[0]\\n # return this TSS object or ATG coordinate\\n return atg\\n else:\\n # no methionines -> Orf can never become first one...\\n return False\",\n \"def do_go_analysis(go_data, genes, p_value_threshold, method='weight', elim_cut_off=0.01):\\n\\n # update the go data with the given genes\\n go_data = update_go_data(go_data, genes)\\n\\n # get the significant groups\\n if 'weight' == method:\\n test_stat = r.new(\\n \\\"weightCount\\\",\\n testStatistic=r.GOFisherTest,\\n name=\\\"Fisher test\\\",\\n sigRatio=\\\"ratio\\\"\\n )\\n elif 'classic' == method:\\n test_stat = r.new(\\n \\\"classicCount\\\",\\n testStatistic=r.GOFisherTest,\\n name=\\\"Fisher test\\\"\\n )\\n elif 'elim' == method:\\n test_stat = r.new(\\n \\\"elimCount\\\",\\n testStatistic=r.GOFisherTest,\\n name=\\\"Fisher test\\\",\\n cutOff = elim_cut_off\\n )\\n else:\\n raise ValueError('%s: Unknown topGO method' % method)\\n sig_groups = r.getSigGroups(go_data, test_stat)\\n\\n args = {method : sig_groups}\\n results_unthresholded = r.GenTable(\\n go_data,\\n #ranksOf=\\\"classic\\\",\\n orderBy=method,\\n **args\\n )\\n\\n # only keep those results above the threshold\\n assert method == results_unthresholded.colnames()[5] # make sure looking at correct column\\n # which rows are above the threshold?\\n passed = rpy2.robjects.BoolVector([p_value_from_r(p) <= p_value_threshold for p in results_unthresholded[5]])\\n return r.subset(results_unthresholded, passed)\",\n \"def solve_environment(self):\\n \\n #The first problem formulation\\n #K kinds of towers\\n #See more details about problem formulation in the writeup \\n \\n #Get a full matrix of the concatenated coverage matrices for \\n #each tower type. THis new matrix has dimensions:\\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\\n coverage = np.hstack(i for i in self.coverage_matrices)\\n print coverage\\n print coverage.shape \\n \\n #Diagonal matrix of the values of each target\\n #(for the scenarios where we don't care about maximizing covered value,\\n #target_values is just all ones, so this is just the identity matrix)\\n V = np.diag(self.target_values)\\n \\n #If doing scenario where we want to fortify weakest link, only makes\\n #sense if all targets are equal value:\\n if self.objective_type == 'min_entries':\\n V = np.eye(len(self.target_values))\\n\\n #Get the matrix of coverage values / expected value saved:\\n C = np.dot(V,coverage)\\n print 'V', V\\n print 'coverage', coverage\\n print 'C', C\\n \\n \\n #Since not gauranteed to reach global optimum on any particular initialization,\\n #run a few times and take the best result.\\n #Just define \\\"best result\\\" as the result which had the most overall \\n #\\\"converged\\\" x, combined over all tower kinds. \\n# for j in xrange(self.N_random_starts_max):\\n \\n \\n a = 2. #1.\\n tau = 1e-4\\n N = sum(i for i in self.N_tower_sites)\\n w = np.zeros(N)\\n ones = np.ones(N)\\n p = 1. #the exponents power when doing he exponent method:\\n \\n for i in xrange(self.N_reweighting_iterations_max):\\n #The concatenated vector of occupancies: Concatenated over all\\n #of the kinds of towers.\\n x = cvx.Variable(N)\\n \\n #Different objective functions depending on which optimization problem.\\n #These are defined in the scenarios in the main function.\\n if self.objective_type == 'min_entries':\\n operation = cvx.min_entries\\n elif self.objective_type == 'sum_entries':\\n operation = cvx.sum_entries\\n else:\\n raise Exception('must specify valid objective_type')\\n \\n #Objective function includes penalty term for non-binary x values\\n if self.penalty_type == 'reweighted_L1':\\n #objective = cvx.Maximize(t - x.T*w)\\n objective = cvx.Maximize(operation(C*x - x.T*w))\\n\\n\\n #Main constraints on 0<=x<=1\\n constraints = [0<=x, x<=1]\\n \\n \\n #And then for each kind of tower, append the constraint that there\\n #be exactly N_i towers, or <= quota (depending on constraint type)\\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n print before_sum\\n print before_sum + self.N_tower_sites[tk]\\n if self.constraints__type == 'fixed_N_towers':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )==self.N_towers[tk])\\n elif self.constraints__type == 'tower_quotas':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )<=self.budget__tower_quotas[tk])\\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\\n \\n elif self.constraints__type == 'total_cost':\\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \\n \\n \\n \\n\\n\\n \\n \\n print 'penalty_type', self.penalty_type\\n print 'objective_type', self.objective_type\\n print 'constraints__type', self.constraints__type\\n print 'budget__tower_quotas', self.budget__tower_quotas\\n print 'operation', operation\\n print 'objective', objective\\n print 'constraints', constraints\\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\\n x = np.array(x.value).flatten()\\n print 'x', x\\n w = a/(tau+np.abs(x))\\n p += 1.\\n plt.figure(figsize=(5,5))\\n plt.plot(x,marker='o')\\n plt.savefig('histrograms_{}.png'.format(i))\\n print \\n \\n \\n \\n \\n #From the solution x, get the coordinates of those tower sites where we\\n #really do want to place a tower\\n #use = np.isclose(x,1.)\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\\n inds = np.argsort(y)\\n s = y[inds]\\n use = np.where(s>.5)[0]\\n print inds\\n print s\\n print use \\n if self.constraints__type == 'fixed_N_towers':\\n if len(use) != self.N_towers[tk]:\\n print 'Solution did not converge properly. Choosing the K best towers.'\\n print self.N_towers[tk], len(use)\\n # use = use[-self.N_towers[tk]:]\\n use = inds[-self.N_towers[tk]:]\\n elif self.constraints__type == 'tower_quotas':\\n pass #Just use the towers thresholded at > .5\\n print use\\n \\n \\n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])\",\n \"def main():\\n\\n # Accept up to three command-line arguments\\n input_terms = \\\"<input_GO_terms_file>\\\"\\n input_annotations = \\\"<input_gene_associations_file>\\\"\\n output_filename = \\\"<output_filename>\\\"\\n\\n\\n # The first two arguments are required GO terms file ending with .obo\\n # and gene association GAF file ending with .gaf\\n if len(sys.argv) < 3:\\n sys.exit(\\\"Please provide required GO terms .obo file and gene \\\" +\\n \\\"assocatiion .gaf file.\\\")\\n elif not sys.argv[1].endswith(\\\".obo\\\"):\\n sys.exit(\\\"Please provide a GO terms .obo file.\\\")\\n elif not sys.argv[2].endswith(\\\".gaf\\\"):\\n sys.exit(\\\"Please provide a gene association .gaf file.\\\")\\n else:\\n input_terms = sys.argv[1]\\n input_annotations = sys.argv[2]\\n\\n\\n # Check if the provided import .obo or .gaf files exist\\n if not input_terms:\\n sys.exit(input_terms + \\\" not found. Check the file path and try again.\\\")\\n elif not input_annotations:\\n sys.exit(input_annotations + \\\" not found. Check the file path and try again.\\\")\\n elif len(sys.argv) == 3:\\n output_filename = \\\"results.tsv\\\"\\n sys.stdout = open(\\\"results.tsv\\\", \\\"w\\\")\\n elif len(sys.argv) == 4:\\n output_filename = sys.argv[3] + \\\".tsv\\\"\\n sys.stdout = open(output_filename, \\\"w\\\")\\n\\n\\n # parse id and is_valeus and make a go_dict\\n split_input_terms = split_terms(input_terms)\\n go_dict = {}\\n for record in split_input_terms:\\n (go_id, is_a) = parse_go_term(record)\\n key_go_dict = \\\"\\\".join(go_id)\\n go_dict[key_go_dict] = is_a\\n\\n\\n # Export an annotation gene information to tsv format into the output file\\n gene_association_map = map_protein_to_go(input_annotations)\\n for protein, go_ids in sorted(gene_association_map.items()):\\n print(protein, end=\\\"\\\")\\n\\n for go_id in sorted(go_ids):\\n parent_go_ids = find_parent_terms(go_id, go_dict)\\n\\n count = 0\\n for parent_go_id in sorted(parent_go_ids):\\n\\n if count == 0:\\n print(\\\"\\\\t\\\", go_id, \\\"\\\\t\\\", parent_go_id)\\n count += 1\\n else:\\n print(\\\"\\\\t\\\", parent_go_id, sep=\\\"\\\\t\\\")\\n\\n sys.stdout.close()\",\n \"def meshRelationships(Objects):\\r\\n # Create some variables to be used to store objects\\r\\n foreheadVariable = []\\r\\n noseBridgeVariable = []\\r\\n noseVariable = []\\r\\n eyeVariable = []\\r\\n mouthLoopVariable = []\\r\\n mouthVariable = []\\r\\n cheekVariable = []\\r\\n chinVariable = []\\r\\n earVariable = []\\r\\n backHeadVariable = []\\r\\n lowerBackHeadVariable = []\\r\\n\\r\\n # Create the relationshipList\\r\\n relationshipList = []\\r\\n\\r\\n for forehead in Objects:\\r\\n if \\\"TubxForehead_geo_\\\" in forehead:\\r\\n foreheadVariable.append(forehead)\\r\\n\\r\\n for noseBridge in Objects:\\r\\n if \\\"TubxNoseBridge_geo_\\\" in noseBridge:\\r\\n noseBridgeVariable.append(noseBridge)\\r\\n for forehead in foreheadVariable:\\r\\n createRelationships(relationshipList, noseBridge, forehead)\\r\\n\\r\\n for eye in Objects:\\r\\n if \\\"TubxEye_geo_\\\" in eye:\\r\\n eyeVariable.append(eye)\\r\\n for forehead in foreheadVariable:\\r\\n createRelationships(relationshipList, eye, forehead)\\r\\n for noseBridge in noseBridgeVariable:\\r\\n createRelationships(relationshipList, eye, noseBridge)\\r\\n\\r\\n for nose in Objects:\\r\\n if \\\"TubxNose_geo_\\\" in nose:\\r\\n noseVariable.append(nose)\\r\\n for noseBridge in noseBridgeVariable:\\r\\n createRelationships(relationshipList, nose, noseBridge)\\r\\n\\r\\n for mouthLoop in Objects:\\r\\n if \\\"TubxMouthLoop_geo_\\\" in mouthLoop:\\r\\n mouthLoopVariable.append(mouthLoop)\\r\\n for nose in noseVariable:\\r\\n createRelationships(relationshipList, mouthLoop, nose)\\r\\n\\r\\n for mouth in Objects:\\r\\n if \\\"TubxMouth_geo_\\\" in mouth:\\r\\n mouthVariable.append(mouth)\\r\\n for mouthLoop in mouthLoopVariable:\\r\\n createRelationships(relationshipList, mouth, mouthLoop)\\r\\n\\r\\n for cheek in Objects:\\r\\n if \\\"TubxCheek_geo_\\\" in cheek:\\r\\n cheekVariable.append(cheek)\\r\\n for mouthLoop in mouthLoopVariable:\\r\\n createRelationships(relationshipList, cheek, mouthLoop)\\r\\n\\r\\n for chin in Objects:\\r\\n if \\\"TubxChin_geo_\\\" in chin:\\r\\n chinVariable.append(chin)\\r\\n for mouthLoop in mouthLoopVariable:\\r\\n createRelationships(relationshipList, chin, mouthLoop)\\r\\n for cheek in cheekVariable:\\r\\n createRelationships(relationshipList, chin, cheek)\\r\\n\\r\\n for ear in Objects:\\r\\n if \\\"TubxEar_geo_\\\" in ear:\\r\\n earVariable.append(ear)\\r\\n for forehead in foreheadVariable:\\r\\n createRelationships(relationshipList, ear, forehead)\\r\\n for cheek in cheekVariable:\\r\\n createRelationships(relationshipList, ear, cheek)\\r\\n\\r\\n for backhead in Objects:\\r\\n if \\\"TubxBackHead_geo_\\\" in backhead:\\r\\n backHeadVariable.append(backhead)\\r\\n for forehead in foreheadVariable:\\r\\n createRelationships(relationshipList, backhead, forehead)\\r\\n for ear in earVariable:\\r\\n createRelationships(relationshipList, backhead, ear)\\r\\n\\r\\n for lowerbackhead in Objects:\\r\\n if \\\"TubxLowerBackHead_geo_\\\" in lowerbackhead:\\r\\n lowerBackHeadVariable.append(lowerbackhead)\\r\\n for ear in earVariable:\\r\\n createRelationships(relationshipList, lowerbackhead, ear)\\r\\n for backhead in backHeadVariable:\\r\\n createRelationships(relationshipList, lowerbackhead, backhead)\\r\\n\\r\\n for default in Objects:\\r\\n for forehead in foreheadVariable:\\r\\n createRelationships(relationshipList, default, forehead)\\r\\n for noseBridge in noseBridgeVariable:\\r\\n createRelationships(relationshipList, default, noseBridge)\\r\\n for nose in noseVariable:\\r\\n createRelationships(relationshipList,default,nose)\\r\\n for eye in eyeVariable:\\r\\n createRelationships(relationshipList, default, eye)\\r\\n for mouthLoop in mouthLoopVariable:\\r\\n createRelationships(relationshipList, default, mouthLoop)\\r\\n for mouth in mouthVariable:\\r\\n createRelationships(relationshipList, default, mouth)\\r\\n for cheek in cheekVariable:\\r\\n createRelationships(relationshipList, default, cheek)\\r\\n for chin in chinVariable:\\r\\n createRelationships(relationshipList, default, chin)\\r\\n for ear in earVariable:\\r\\n createRelationships(relationshipList, default, ear)\\r\\n for backhead in backHeadVariable:\\r\\n createRelationships(relationshipList, default, backhead)\\r\\n for lowerbackhead in lowerBackHeadVariable:\\r\\n createRelationships(relationshipList, default, lowerbackhead)\\r\\n\\r\\n return relationshipList\",\n \"def get_imc_topo(topo_file):\\n topo_graph = nx.Graph()\\n with open(topo_file, 'r') as f:\\n for line in f.readlines():\\n if (len(line) > 10) and (line[0] != '#'):\\n split_data = line.split()\\n source = split_data[0]\\n dest = split_data[2]\\n #capacity = 1000 # We are fixing this to one.\\n capacity = get_imc_capacity(split_data[1], split_data[3])\\n if not topo_graph.has_edge(source, dest):\\n topo_graph.add_edge(source, dest, capacity = capacity)\\n # Checks graph for any componnets and returns the largest one.\\n topo_graph = validate_graph(topo_graph)\\n f.close()\\n return topo_graph\",\n \"def main():\\n # files\\n summary_file = sys.argv[1]\\n pwms_to_tfs_file = sys.argv[2]\\n expressed_tfs_file = sys.argv[3] # TODO\\n\\n # TODO pull in num regions to resize things? but complicated with overlaps etc\\n # TODO edit edges with type of interaction\\n # TODO may want to color by trajectory, to demonstrate waves of trajectory\\n \\n # read in data\\n summary = pd.read_csv(summary_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pd.read_csv(pwms_to_tfs_file, sep=\\\"\\\\t\\\")\\n pwms_to_tfs = pwms_to_tfs[pwms_to_tfs[\\\"expressed\\\"].notna()]\\n pwms_to_filt_tfs = {} # dict: key - pwm names, vals - dict of ensembl ids to hgnc ids\\n for line_idx in range(pwms_to_tfs.shape[0]):\\n pwm_info = pwms_to_tfs.iloc[line_idx,:]\\n pwm_name = pwm_info[\\\"hclust_model_name\\\"]\\n pwm_to_tf = dict(zip(pwm_info[\\\"expressed\\\"].split(\\\";\\\"), pwm_info[\\\"expressed_hgnc\\\"].split(\\\";\\\")))\\n pwms_to_filt_tfs[pwm_name] = pwm_to_tf\\n\\n \\n # filter expressed hgncs for dynamic ones only\\n tfs_filt = pd.read_csv(expressed_tfs_file, sep=\\\"\\\\t\\\", index_col=0)\\n for pwm_name in pwms_to_filt_tfs.keys():\\n tfs_tmp = pwms_to_filt_tfs[pwm_name]\\n for ensembl_tf in tfs_tmp.keys():\\n if ensembl_tf not in tfs_filt.index:\\n del tfs_tmp[ensembl_tf]\\n if len(tfs_tmp.keys()) == 0:\\n del pwms_to_filt_tfs[pwm_name]\\n pwms_to_filt_tfs[pwm_name] = tfs_tmp\\n\\n # add in tfs column\\n tf1 = []\\n for pwm in summary[\\\"pwm1\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n # TODO try add in max point\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf1.append(tf_str)\\n summary[\\\"tf1\\\"] = tf1\\n\\n tf2 = []\\n for pwm in summary[\\\"pwm2\\\"]:\\n tf_str = []\\n for ensembl_id in pwms_to_filt_tfs[pwm]:\\n tf_str.append(pwms_to_filt_tfs[pwm][ensembl_id])\\n expression = tfs_filt.loc[ensembl_id,:]\\n max_idx = np.argmax(expression.values)\\n tf_str.append(str(max_idx))\\n tf_str = (\\\";\\\").join(tf_str)\\n tf2.append(tf_str)\\n summary[\\\"tf2\\\"] = tf2\\n \\n # remove failed rules\\n summary = summary[~summary[\\\"interaction\\\"].str.contains(\\\"FAILED\\\")]\\n \\n # make graph\\n graph = nx.from_pandas_edgelist(summary, \\\"tf1\\\", \\\"tf2\\\")\\n\\n # set up positions\\n #pos = graphviz_layout(graph, prog=\\\"dot\\\")\\n pos = graphviz_layout(graph, prog=\\\"neato\\\")\\n scale_factor = 3\\n for key in pos.keys():\\n coords = pos[key]\\n pos[key] = {\\\"x\\\": scale_factor*coords[0], \\\"y\\\": -scale_factor*coords[1]}\\n nx.set_node_attributes(graph, pos, \\\"graphics\\\") # note this is diff from v1 to v2 in networkx\\n \\n # add graphics\\n add_graphics_theme_to_nx_graph(graph)\\n\\n # write gml\\n out_file = \\\"summary.gml\\\"\\n nx.write_gml(stringize_nx_graph(graph), out_file, stringizer=str)\\n\\n # tfs: for each tf, get gene column\\n \\n \\n return\",\n \"def all_best_pos(potential_coverage, all_coverage, covered):\\n ## get closeness to 5'\\n proximity = {grna_seq: sum((hit.target_len - hit.range[1] if\\n hit.target.sense == '-' else\\n hit.range[0])\\n for hit in hits)/len(hits)\\n for grna_seq, hits in potential_coverage.items()}\\n best_proximity = min(proximity.values())\\n return {grna_seq: potential_coverage[grna_seq]\\n for grna_seq, prox in proximity.items()\\n if prox == best_proximity}\",\n \"def search_a_for_genetic(env:RailEnv,randomized):\\r\\n schedules = []\\r\\n occupancy_map=[[] for i in range(len(env.agents))]\\r\\n\\r\\n n_timesteps = np.array([])\\r\\n state_schedule =[]\\r\\n conv = StateConverter(env)\\r\\n # Compute the transition and valid action table\\r\\n model = convert_to_transition(env, conv)\\r\\n # Calculate the shortest dist from one state to another state\\r\\n shortest = all_pairs_shortest_paths(conv.num_states, model[0])\\r\\n random_order_agent = randomized\\r\\n print(random_order_agent)\\r\\n\\r\\n for i in random_order_agent:\\r\\n # Compute occupancy map\\r\\n occupancy_map[i] = compute_map(i, random_order_agent, n_timesteps, state_schedule, conv)\\r\\n\\r\\n # Compute schedule for each agent based on the occupancy map\\r\\n each_schedule = a_star_search(SearchEnv(env,conv,model,shortest,i).get_root_node(),occupancy_map[i])\\r\\n #print(each_schedule)\\r\\n schedules.append(each_schedule[0])\\r\\n state_schedule.append(each_schedule[1])\\r\\n n_timesteps = np.append(n_timesteps, [len(each_schedule[1])])\\r\\n\\r\\n # Combine separate actions into a list\\r\\n actions = combine(schedules,random_order_agent,int(np.max(n_timesteps)))\\r\\n\\r\\n return actions\",\n \"def get_eco_details(self, pgn_data):\\n result = eco_mapping['unknown']\\n\\n try:\\n moves = self.get_moves(pgn_data)\\n current_sequence = ''\\n\\n for move in moves:\\n half_move = '.'.join([move[0], move[1]])\\n current_sequence += half_move\\n\\n if current_sequence in eco_mapping:\\n result = eco_mapping[current_sequence]\\n else:\\n break\\n\\n current_sequence = ' '.join([current_sequence, move[2]])\\n\\n if current_sequence in eco_mapping:\\n result = eco_mapping[current_sequence]\\n else:\\n break\\n\\n current_sequence += ' '\\n except:\\n pass\\n\\n return result\",\n \"def detect_primary_objects(gray, haar_file, params, num_primary_obj=1, max_iter=10, boost_flag=True, verbose=False):\\n haar_cascade = cv.CascadeClassifier(haar_file)\\n detected_objects = haar_cascade.detectMultiScale(gray, **params)\\n num_detected = len(detected_objects)\\n num_detected_prev = num_detected\\n if verbose:\\n print(f\\\"Initial # of Objects Detected = {num_detected}\\\")\\n num_iter = 0\\n boost_factor = 1\\n while num_detected != num_primary_obj and num_iter != max_iter:\\n num_iter += 1\\n if verbose:\\n print(f\\\"Iteration # = {num_iter}\\\")\\n # Update minNeighbors value in copy of params dict\\n if num_iter == 1:\\n params_new = params.copy()\\n elif num_iter == max_iter:\\n print(f\\\"Maximum # of iterations ({max_iter}) reached!\\\")\\n # Change minNeighbors up/down depending on whether num detected is too high/low\\n # Steps up are twice as big as steps down, and boost_factor determines step size\\n if num_detected < num_primary_obj and params_new['minNeighbors'] > 4:\\n params_new['minNeighbors'] -= boost_factor\\n elif num_detected < num_primary_obj and params_new['minNeighbors'] > 1:\\n params_new['minNeighbors'] -= 1 \\n elif num_detected > num_primary_obj:\\n params_new['minNeighbors'] += 2 * boost_factor\\n else:\\n print(f\\\"Unable to detect {num_primary_obj} primary object(s) in input image\\\")\\n print(f\\\"Verify that either 1) num_detected is zero ({num_detected==0}) and minNeighbors is one ({params_new['minNeighbors']==1})\\\")\\n print(f\\\"OR 2) the maximum # of iterations has been reached ({num_iter==max_iter})\\\")\\n print(\\\"If either of these scenarios occurs, consider changing the input scaleFactor and/or initial minNeighbors value. If neither 1) or 2) applies, then there is an unknown bug somewhere that should be investigated!!!\\\")\\n if verbose:\\n print(f\\\"minNeighbors = {params_new['minNeighbors']}\\\")\\n detected_objects = haar_cascade.detectMultiScale(gray, **params_new)\\n num_detected = len(detected_objects)\\n if num_detected == num_detected_prev and boost_flag:\\n boost_factor += 1\\n else:\\n boost_factor = 1\\n num_detected_prev = num_detected\\n if verbose:\\n print(f\\\"Final # of Objects Detected = {num_detected}\\\")\\n return detected_objects\",\n \"def main():\\n # get commmand line args\\n args = parse_arguments()\\n \\n adj_file = args.adj # open(\\\"UCSC_VIPER/pathways/extended_pathways_transcriptional.adj\\\", \\\"r\\\")\\n \\n # this set isn't actually used in the script, but I was curious...\\n adj_gene_set = set() \\n \\n cutoff_number = args.cutoff_number\\n #cutoff_percent = args.cutoff_percent\\n \\n expr_gene_file = args.expr_genes #open(\\\"stanford_batchK1-12.HUGO_only_genes.lst\\\", 'r')\\n expr_genes = [line.strip() for line in expr_gene_file] \\n \\n # for each line, check that the regulator and other genes are in the\\n # expression matrix gene set. if not, remove them, or remove the whole\\n # line if the regulator isn't in the set or if too few genes remain\\n for line in adj_file:\\n \\n line_list = line.strip().split()\\n regulator_plus_gene_list = [x for x in line_list if x !=\\\"1.0\\\"]\\n regulator = regulator_plus_gene_list[0]\\n \\n if regulator not in expr_genes:\\n # remove the whole regulator + regulon\\n print(\\\"Skipped a line (regulator not in expr genes): \\\", \\n line_list[0], file=sys.stderr) \\n continue\\n \\n gene_list = regulator_plus_gene_list[1:]\\n list_size = len(gene_list)\\n adj_gene_set.update(gene_list)\\n \\n how_many_to_remove= 0\\n good_genes = []\\n \\n for gene in gene_list:\\n if gene not in expr_genes:\\n how_many_to_remove += 1\\n else:\\n good_genes.append(gene)\\n \\n #print(\\\"\\\\n\\\")\\n #pdb.set_trace()\\n #if (100-how_many_to_remove/list_size*100 < cutoff_percent) and (list_size-how_many_to_remove < cutoff_number):\\n if (list_size-how_many_to_remove < cutoff_number):\\n print(\\\"Skipped a line (too many removed): \\\", line_list[0], file=sys.stderr)\\n \\n else:\\n # re-generate the new line of the .adj file with kept genes\\n #genes_to_print = good_genes.insert(0, regulator)\\n regulated_genes = \\\"\\\\t1.0\\\\t\\\".join(good_genes)\\n print(regulator+\\\"\\\\t\\\"+regulated_genes+\\\"\\\\t1.0\\\")\",\n \"def discover_structure_from_pops(self, pops, data):\\n\\n def create_maximal_pgm(pops):\\n pgm = nx.DiGraph()\\n pgm.add_nodes_from(pops) # create nodes\\n for node in pops:\\n edges = [(parent, node) for parent in pops.get(node) if\\n node.rsplit('_', 1)[0] != parent.rsplit('_', 1)[0]]\\n pgm.add_edges_from(edges) # add edges\\n return pgm\\n\\n def markov_blanket(graph, parent_node, node):\\n mb = set(pa for pa in graph.predecessors(node)) # add parent nodes\\n mb |= set(ch for ch in graph.successors(node)) # add child nodes\\n for child in graph.successors(node): # add parents of children\\n mb |= set(pa for pa in graph.predecessors(child))\\n if node in mb: # remove node\\n mb.remove(node)\\n if parent_node in mb: # remove parent_node\\n mb.remove(parent_node)\\n return mb\\n\\n max_pgm = create_maximal_pgm(pops)\\n\\n if self.draw:\\n plt.title('Maximal PGM (only intra-edges)')\\n signal_pos_map = {}\\n pos = {}\\n for node in max_pgm.nodes:\\n if node.rsplit('_', 1)[0] not in signal_pos_map:\\n signal_pos_map.update({node.rsplit('_', 1)[0]: len(signal_pos_map)})\\n x_coordinate = int(node[-1:])\\n y_coordinate = signal_pos_map.get(node.rsplit('_', 1)[0])\\n pos.update({node: [x_coordinate, y_coordinate]})\\n nx.draw(max_pgm, pos=pos, with_labels=True)\\n plt.show()\\n pass\\n\\n if isinstance(data, ADTree):\\n cb_estimator = GSquareEstimator(adtree=data)\\n else:\\n cb_estimator = BaseEstimator(data=data, complete_samples_only=False)\\n # procedure similar to PC algorithm\\n pgm = max_pgm.copy()\\n condition_set_size = 0\\n L().log.debug('---------------------------------------------------')\\n L().log.debug('---- Conditional Independence Tests ---------------')\\n L().log.debug('---------------------------------------------------')\\n\\n #\\n if self.optimization_chi_square:\\n import scipy.stats as scs\\n def chi_square_of_df_cols(df, col1, col2):\\n df_col1, df_col2 = df[col1], df[col2]\\n categories_2 = list(df_col2.unique())\\n categories_1 = list(df_col1.unique())\\n result = [[sum((df_col1 == cat1) & (df_col2 == cat2))\\n for cat2 in categories_2]\\n for cat1 in categories_1]\\n\\n chi = scs.chi2_contingency(result)\\n\\n\\n return chi\\n\\n remove_edges = []\\n for (source, target) in pgm.edges():\\n # check how correlated those two edges are / independent of MB and all the other stuff\\n dat = chi_square_of_df_cols(self.data, source, target) # 1 = more corr. 0 = less corr.\\n chi2, p, sufficient_data = dat[0], dat[1], dat[2]\\n #print(\\\"%s Chi = %s, p=%s\\\" % (str([source, target]), str(chi2), str(p)))\\n\\n if chi2 < self.chi_square_thresh and pgm.has_edge(source, target):\\n L().log.debug('remove edge ' + str((source, target)))\\n remove_edges.append((source, target))\\n pgm.remove_edges_from(remove_edges)\\n #import sys\\n #sys.exit(0)\\n\\n\\n # additionally remove edges which are conditionally independent\\n # e.g. given a-> b c->b and given a, c is independent of b, then I can remove c!!!\\n remove_edges = []\\n for (source, target) in pgm.edges():\\n condition_set = [a for a in pgm.predecessors(target) if a != source]\\n if not condition_set:continue\\n _, p_val, _ = cb_estimator.test_conditional_independence(source, target, list(condition_set))\\n if p_val > self.alpha:\\n if pgm.has_edge(source, target):\\n L().log.debug('remove edge ' + str((source, target)))\\n remove_edges.append((source, target))\\n pgm.remove_edges_from(remove_edges)\\n\\n else:\\n while True:\\n cont = False\\n remove_edges = []\\n for (source, target) in pgm.edges():\\n mb = markov_blanket(pgm, target, source)\\n if len(mb) >= condition_set_size:\\n L().log.debug('testing ' + source + ' --> ' + target)\\n L().log.debug('markov blanket of ' + source + ' is ' + str(mb))\\n for condition_set in combinations(mb, condition_set_size):\\n L().log.debug(\\n 'independence test of ' + source + ' and ' + target + ' with subset ' + str(condition_set))\\n _, p_val, _ = cb_estimator.test_conditional_independence(source, target, list(condition_set))\\n #if isnan(p_val): # pgmpy CI test returns NaN instead of 1\\n # p_val = 1\\n L().log.debug('p_val = ' + str(p_val))\\n if p_val > self.alpha:\\n if pgm.has_edge(source, target):\\n L().log.debug('remove edge ' + str((source, target)))\\n remove_edges.append((source, target))\\n break\\n pass\\n cont = True\\n pass\\n condition_set_size += 1\\n pgm.remove_edges_from(remove_edges)\\n if cont is False:\\n break\\n if condition_set_size > self.max_reach:\\n break\\n\\n if self.draw:\\n plt.title('PGM after CI tests (only inter-edges)')\\n signal_pos_map = {}\\n pos = {}\\n for node in pgm.nodes:\\n if node.rsplit('_', 1)[0] not in signal_pos_map:\\n signal_pos_map.update({node.rsplit('_', 1)[0]: len(signal_pos_map)})\\n x_coordinate = int(node[-1:])\\n y_coordinate = signal_pos_map.get(node.rsplit('_', 1)[0])\\n pos.update({node: [x_coordinate, y_coordinate]})\\n nx.draw(pgm, pos=pos, with_labels=True)\\n plt.show()\\n pass\\n\\n nodes = list(pops.keys())\\n edges = [list(edge) for edge in pgm.edges]\\n return nodes, edges\",\n \"def pick_gynodioecious_parents(simu, config):\\n rng = simu.getRNG()\\n runif = rng.randUniform\\n rint = rng.randInt\\n try:\\n sstar = config.sstar\\n H = config.H\\n def compound_generator(pop):\\n \\\"\\\"\\\"\\n Picks up parent(s) under gynodioecy using compound parameters.\\n \\\"\\\"\\\"\\n gen = -1\\n while True:\\n ngen = pop.dvars().gen\\n if gen != ngen:\\n # At the beginning of a generation, extract the\\n # sex-specific subpopulations from a parental\\n # population. The sex-specific subpopulations are used\\n # throughout mating events in one generation.\\n gen = ngen\\n h = pop.extractSubPops(subPops=[(0, 0)])\\n f = pop.extractSubPops(subPops=[(0, 1)])\\n Nh = h.popSize()\\n Nf = f.popSize()\\n\\n if runif() < sstar: # uniparental\\n yield h.individual(rint(Nh))\\n else: # biparental\\n if runif() < H: # having a hermaphroditic seed parent\\n first, second = rint(Nh), rint(Nh)\\n while first == second:\\n second = rint(Nh)\\n yield [h.individual(first), h.individual(second)]\\n else: # female seed parent\\n yield [h.individual(rint(Nh)), f.individual(rint(Nf))]\\n return compound_generator\\n except KeyError:\\n a = config.a\\n sigma = config.sigma\\n tau = config.tau\\n def fundamental_generator(pop):\\n \\\"\\\"\\\"\\n Picks up parent(s) under gynodioecy using fundamental parameters.\\n \\\"\\\"\\\"\\n gen = -1\\n while True:\\n ngen = pop.dvars().gen\\n if gen != ngen:\\n # At the beginning of a generation, extract the\\n # sex-specific subpopulations from a parental\\n # population. The sex-specific subpopulations are used\\n # throughout mating events in one generation.\\n gen = ngen\\n h = pop.extractSubPops(subPops=[(0, 0)])\\n f = pop.extractSubPops(subPops=[(0, 1)])\\n Nh = h.popSize()\\n Nf = f.popSize()\\n hermseed = Nh / (Nh * Nf * sigma)\\n\\n if runif() < hermseed: # hermaphroditic seed parent\\n if runif() < a: # self-pollen\\n yield h.individual(rint(Nh))\\n else: # non self-pollen\\n first, second = rint(Nh), rint(Nh)\\n while first == second:\\n second = rint(Nh)\\n yield [h.individual(first), h.individual(second)]\\n else: # female seed parent\\n if runif() < tau:\\n yield [h.individual(rint(Nh)), f.individual(rint(Nf))]\\n return fundamental_generator\",\n \"def get_gene_methylation(ensemble, methylation_type, gene, grouping, clustering, level, outliers, tsne_type='mCH_ndim2_perp20', \\n\\tmax_points='10000'):\\n\\n\\t# Prevent SQL injected since column names cannot be parameterized.\\n\\tif \\\";\\\" in ensemble or \\\";\\\" in methylation_type or \\\";\\\" in grouping or \\\";\\\" in clustering or \\\";\\\" in tsne_type:\\n\\t\\treturn None\\n\\n\\t# This query is just to fix gene id's missing the ensemble version number.\\n\\t# Necessary because the table name must match exactly with whats on the MySQL database.\\n\\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\\n\\tresult = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\\\", (gene+\\\"%\\\",)).fetchone()\\n\\tgene_table_name = 'gene_' + result.gene_id.replace('.','_')\\n\\n\\tcontext = methylation_type[1:]\\n\\tif grouping in ['annotation','cluster']:\\n\\t\\tgroupingu = ensemble+\\\".\\\"+grouping+\\\"_\\\"+clustering\\n\\telif grouping in ['NeuN']:\\n\\t\\tgroupingu = \\\"CONCAT('NeuN',cells.\\\"+grouping+\\\")\\\"\\n\\telif grouping in ['dataset','sex','brain_region','target_region']:\\n\\t\\tgroupingu = \\\"datasets.\\\"+grouping\\n\\telif grouping in ['broad_brain_region']:\\n\\t\\tgroupingu = \\\"ABA_regions.ABA_broad_acronym\\\"\\n\\telse:\\n\\t\\tgroupingu = \\\"cells.\\\"+grouping\\n\\n\\tensemble = ensemble.replace('EnsEns','Ens')\\n\\n\\tif 'ndim2' in tsne_type:\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.dataset, %(ensemble)s.cluster_%(clustering)s, datasets.target_region, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_%(clustering)s, %(gene_table_name)s.%(methylation_type)s, \\\\\\n\\t\\t\\tcells.global_%(methylation_type)s, %(groupingu)s as grouping, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, \\\\\\n\\t\\t\\t%(gene_table_name)s.%(context)s, datasets.sex \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \\\\\\n\\t\\t\\tLEFT JOIN ABA_regions ON datasets.brain_region=ABA_regions.ABA_acronym\\\" % {'ensemble': ensemble, 'groupingu': groupingu,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'tsne_type': tsne_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'methylation_type': methylation_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'context': context,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'clustering': clustering,}\\n\\telse:\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, cells.global_%(methylation_type)s, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_%(clustering)s, %(ensemble)s.cluster_%(clustering)s, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, %(ensemble)s.tsne_z_%(tsne_type)s, \\\\\\n\\t\\t\\t%(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s, \\\\\\n\\t\\t\\tdatasets.target_region, datasets.sex \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'tsne_type': tsne_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'methylation_type': methylation_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'context': context,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'clustering': clustering,}\\n\\tif max_points.isdigit():\\n\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s\\\" % {'max_points': max_points}\\n\\t\\t# TODO: Check whether we need to randomize the rows\\n\\n\\ttry:\\n\\t\\tdf = pd.read_sql(query, db.get_engine(current_app, 'methylation_data'))\\n\\texcept exc.ProgrammingError as e:\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_methylation): {}\\\".format(str(now), e))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tif df[context].isnull().all(): # If no data in column, return None\\n\\t\\treturn None\\n\\n\\tif level == 'original':\\n\\t\\tdf[methylation_type + '/' + context + '_' + level] = df[methylation_type] / df[context]\\n\\telse:\\n\\t\\tdf[methylation_type + '/' + context + '_' + level] = (df[methylation_type] / df[context]) / df['global_'+methylation_type]\\n\\n\\tif not outliers:\\n\\t\\t# Outliers not wanted, remove rows > 99%ile\\n\\t\\tthree_std_dev = df[methylation_type + '/' + context + '_' + level].quantile(0.99)\\n\\t\\tdf = df[df[methylation_type + '/' + context + '_' + level] < three_std_dev]\\n\\n\\n\\tif grouping == 'annotation':\\n\\t\\tdf.fillna({'grouping': 'None'}, inplace=True)\\n\\t\\tdf['annotation_cat'] = pd.Categorical(df['grouping'], cluster_annotation_order)\\n\\t\\tdf.sort_values(by='annotation_cat', inplace=True)\\n\\t\\tdf.drop('annotation_cat', axis=1, inplace=True)\\n\\telif grouping == 'cluster':\\n\\t\\tdf.sort_values(by='cluster_'+clustering, inplace=True)\\n\\n\\t# # Add number of cells in each cluster to the cluster name\\n\\t# ncells = df.groupby(by=grouping, sort=False).count()\\n\\t# for label, i in df[grouping]:\\n\\t# ncells[0]\\n\\n\\treturn df\",\n \"def getNet(chrom, loops, genes, pdis=2000, gap=1):\\n #step 1 get merged anchors\\n anchors = stichAnchors(chrom, loops, margin=gap)\\n #step 2 annotate anchors\\n nanchors = {}\\n ts = np.array([[tss] for tss in genes.keys()])\\n tree = KDTree(ts)\\n for anchor in anchors:\\n gs, ds = findOverlapOrNearest(genes, ts, tree, anchor.start,\\n anchor.end)\\n if len(gs) > 1:\\n t = \\\"Promoter\\\"\\n d = 0\\n else:\\n d = ds[0]\\n if abs(d) <= pdis:\\n t = \\\"Promoter\\\"\\n else:\\n t = \\\"Enhancer\\\"\\n n = anchor.chrom + \\\":\\\" + str(anchor.start) + \\\"-\\\" + str(\\n anchor.end) + \\\"|\\\" + t\\n nanchors[n] = {\\n \\\"chrom\\\":\\n anchor.chrom,\\n \\\"start\\\":\\n anchor.start,\\n \\\"end\\\":\\n anchor.end,\\n \\\"type\\\":\\n n.split(\\\"|\\\")[-1],\\n \\\"nearestDistanceToTSS\\\":\\n d,\\n \\\"nearestGene\\\":\\n \\\",\\\".join([g.name for g in gs]),\\n \\\"nearestGeneLoc\\\":\\n \\\",\\\".join([\\n g.chrom + \\\":\\\" + str(g.start) + \\\"-\\\" + str(g.end) + \\\"|\\\" +\\n g.strand + \\\"|\\\" + g.name for g in gs\\n ])\\n }\\n anchors = nanchors\\n del nanchors\\n #step 3 assign each anchor to merged annotated anchor and build the network\\n anchorCov = {}\\n for k, v in anchors.items():\\n for i in range(v[\\\"start\\\"], v[\\\"end\\\"] + 1):\\n anchorCov[i] = k\\n ds = {} #anchor annotations\\n nets = {} #net information\\n G = nx.Graph() #networkx graph structure\\n for loop in loops:\\n xt, yt = None, None\\n for i in range(loop.x_start, loop.x_end + 1):\\n if i in anchorCov:\\n xt = anchorCov[i]\\n break\\n for i in range(loop.y_start, loop.y_end + 1):\\n if i in anchorCov:\\n yt = anchorCov[i]\\n break\\n ds[loop.id] = {\\n \\\"mergedAnchorA\\\": xt,\\n \\\"mergedAnchorB\\\": yt,\\n }\\n if xt == yt:\\n continue\\n ns = [xt, yt]\\n ns.sort() #sort for converging keys\\n if ns[0] not in nets:\\n nets[ns[0]] = set()\\n nets[ns[0]].add(ns[1])\\n #network edges\\n G.add_edge(ns[0], ns[1])\\n #step 4 find all enhancers linked to target gene\\n targets = {}\\n #step 4.1 find the direct enhancer that link to promoter\\n for node in G.nodes:\\n if node.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if node in targets:\\n continue\\n targets[node] = {\\n \\\"targetGene\\\": anchors[node][\\\"nearestGeneLoc\\\"],\\n \\\"directEnhancer\\\": set(),\\n \\\"indirectEnhancer\\\": set(),\\n \\\"directPromoter\\\": set(),\\n \\\"indirectPromoter\\\": set()\\n }\\n ns = list(nx.descendants(G, node))\\n #find all releated nodes\\n for n in ns:\\n p = nx.algorithms.shortest_path(G, source=node, target=n)\\n if n.split(\\\"|\\\")[-1] == \\\"Promoter\\\":\\n if len(p) == 2:\\n targets[node][\\\"directPromoter\\\"].add(n)\\n else:\\n targets[node][\\\"indirectPromoter\\\"].add(n)\\n if n.split(\\\"|\\\")[-1] == \\\"Enhancer\\\":\\n if len(p) == 2:\\n targets[node][\\\"directEnhancer\\\"].add(n)\\n else:\\n targets[node][\\\"indirectEnhancer\\\"].add(n)\\n #step 4.2. find hub enhancer\\n #only using non-redundant node to find hubs\\n nns = []\\n tmp = set()\\n for n in ns:\\n tn = n.split(\\\"|\\\")[0]\\n if tn not in tmp:\\n nns.append(n)\\n tmp.add(tn)\\n ns = list(nns)\\n ns.append(node)\\n subg = G.subgraph(ns)\\n try:\\n hubs, authorities = nx.hits(subg,\\n max_iter=1000,\\n normalized=True)\\n except:\\n print(\\n \\\"For %s, hard to find the hub by running HITS algorithm of 1000 iteration.\\\"\\n % node)\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n continue\\n hubs = pd.Series(hubs)\\n hubs = hubs.sort_values(inplace=False, ascending=False)\\n if len(targets[node][\\\"directEnhancer\\\"]) >= 2:\\n des = hubs[list(targets[node][\\\"directEnhancer\\\"])]\\n des = des.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"directEnhancerHub\\\"] = des.index[0]\\n else:\\n targets[node][\\\"directEnhancerHub\\\"] = \\\"\\\"\\n if len(targets[node][\\\"indirectEnhancer\\\"]) >= 2:\\n indes = hubs[list(targets[node][\\\"indirectEnhancer\\\"])]\\n indes = indes.sort_values(inplace=False, ascending=False)\\n targets[node][\\\"indirectEnhancerHub\\\"] = indes.index[0]\\n else:\\n targets[node][\\\"indirectEnhancerHub\\\"] = \\\"\\\"\\n return anchors, ds, nets, targets\",\n \"def identify_expressed_gRNA_families(gRNAs, mRNAs, init_seq_len):\\n gRNA_families = {'family_no':[], 'family_end':[], 'family_id':[]}\\n strand_name = {'coding':'', 'template':'t'}\\n index = []\\n\\n gRNAs['gene_mRNA_end'] = gRNAs['mRNA_end']+gRNAs['rel_pos'].apply(lambda x: 0 if x is pd.NA else x)\\n gRNAs['gene_mRNA_end'] = gRNAs['gene_mRNA_end'].astype('Int32')\\n gRNAs['tmp'] = gRNAs.apply(lambda x: x['cassette_label']+strand_name[x['strand']], axis=1)\\n\\n for mRNA_name, mRNA in sorted(mRNAs.items()):\\n # get all gRNAs with an init_pos for this mRNA\\n # nonexpressed gRNAs can be in an editing group if they have a init_seq. this is because\\n # they have transcripts in the init_position but not enough to be called expressed\\n # gRNAs without an init_seq have no transcripts within the initiation site\\n # these are added to a group below\\n mask1 = gRNAs['mRNA_name'] == mRNA_name\\n mask2 = gRNAs['init_seq'].notnull()\\n g = gRNAs[mask1 & mask2]\\n\\n # positions where the start of expressed gRNAs align to mRNA\\n a = np.zeros(mRNA['length']+100)\\n i = np.array(g['gene_mRNA_end']-1, dtype=int)\\n for ii in range(init_seq_len):\\n a[i-ii] = 1\\n a = ''.join([str(int(i)) for i in a])\\n g_end = 'gene_mRNA_end'\\n\\n tmp_g = []\\n family_no = 0\\n\\n # find regions where groups of gRNAs anchor to mRNA starting from 3' end of edited mRNA\\n for m in re.finditer('1+', a):\\n s, e = m.start(0), m.end(0)\\n # get all gRNAs that anchor at this region\\n anchor_group = g[(g[g_end] >= s) & (g[g_end] <= e)]\\n\\n if len(anchor_group) == 0:\\n continue\\n\\n # for each cassette position of these gRNAs create a dictionary of cassette position and editing position\\n cas_pos = {}\\n for _, gRNA in anchor_group.iterrows():\\n pos = gRNA['tmp']\\n if pos not in cas_pos:\\n cas_pos[pos] = gRNA[g_end]\\n cas_pos[pos] = max(gRNA[g_end], cas_pos[pos])\\n\\n # group gRNAs with the same cassette position ordered by editing position\\n for pos, end in sorted(cas_pos.items(), key=lambda kv: kv[1]):\\n group = anchor_group.query('tmp == @pos')\\n index.extend(group.index.values)\\n gRNA_families['family_no'].extend([family_no]*len(group))\\n gRNA_families['family_end'].extend([end]*len(group))\\n gRNA_families['family_id'].extend([f'{mRNA_name}-{pos}-{int(end)}']*len(group))\\n tmp_g.append((family_no, end, f'{mRNA_name}-{pos}-{int(end)}'))\\n family_no += 1\\n\\n # gRNAs without an init_seq\\n mask2 = gRNAs['init_seq'].isnull()\\n unknown = gRNAs[mask1 & mask2]\\n # for each unknown gRNA\\n for idx, gRNA in unknown.iterrows():\\n # search for a group that ends just after mRNA_end of this unknown gRMA\\n for f_no, gene_mRNA_end, family_id in sorted(tmp_g, key=itemgetter(1)):\\n [g_mRNA_name, g_pos, g_end] = family_id.split('-')\\n if g_mRNA_name == mRNA_name and gRNA['mRNA_end']-1 <= gene_mRNA_end and gRNA['cassette_label'] == g_pos:\\n index.append(idx)\\n gRNA_families['family_no'].append(f_no)\\n gRNA_families['family_end'].append(gene_mRNA_end)\\n gRNA_families['family_id'].append(f'{family_id}')\\n break\\n else:\\n # no suitable gRNA found, so make a unique family for this non-expressed gRNA \\n index.append(idx)\\n gRNA_families['family_no'].append(family_no)\\n gRNA_families['family_end'].append(gRNA['mRNA_end'])\\n gRNA_families['family_id'].append(f'{mRNA_name}-{gRNA[\\\"cassette_label\\\"]}-{gRNA[\\\"mRNA_end\\\"]}')\\n family_no += 1\\n\\n gRNAs = gRNAs.drop(['tmp'], axis=1)\\n gRNAs = gRNAs.join(pd.DataFrame(gRNA_families, index=index))\\n gRNAs['family_no'] = gRNAs['family_no'].astype('Int64')\\n gRNAs['family_end'] = gRNAs['family_end'].astype('Int64')\\n return gRNAs\",\n \"def consolidation_heuristics(to_print = False):\\n # Instantiate the data problem.\\n data = create_data_model()\\n # Create the routing index manager.\\n manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),\\n data['num_vehicles'], data['depot'])\\n # Create Routing Model.\\n routing = pywrapcp.RoutingModel(manager)\\n # Create and register a transit callback.\\n def distance_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return data['distance_matrix'][from_node][to_node]\\n def pending_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return data['post'][to_node]\\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\\n pending_callback_index = routing.RegisterTransitCallback(pending_callback)\\n # Define cost of each arc.\\n for i in range(data['num_vehicles']-1):\\n routing.SetArcCostEvaluatorOfVehicle(transit_callback_index, i) #Transit cost\\n routing.SetFixedCostOfVehicle(data['fixed_cost'], i) #Fixed cost\\n routing.SetArcCostEvaluatorOfVehicle(pending_callback_index, data['num_vehicles']-1) #Postponement and/or NonService cost\\n # Add Capacity constraint.\\n def demand_callback(from_index): #\\n \\\"\\\"\\\"Returns the demand of the node.\\\"\\\"\\\"\\n # Convert from routing variable Index to demands NodeIndex.\\n from_node = manager.IndexToNode(from_index) \\n return data['demands'][from_node]\\n demand_callback_index = routing.RegisterUnaryTransitCallback(\\n demand_callback)\\n routing.AddDimensionWithVehicleCapacity(\\n demand_callback_index,\\n 0, # null capacity slack\\n data['vehicle_capacities'], # vehicle maximum capacities\\n True, # start cumul to zero\\n 'Capacity')\\n # Add time constraint.\\n def time_callback(from_index,to_index): #\\n \\\"\\\"\\\"Returns the demand of the node.\\\"\\\"\\\"\\n # Convert from routing variable Index to NodeIndex in time\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return time_matrix[from_node][to_node] \\n time_callback_index = routing.RegisterTransitCallback(time_callback) \\n routing.AddDimensionWithVehicleCapacity(\\n time_callback_index,\\n 0, # null capacity slack\\n data['time_capacities'], # vehicle maximum capacities\\n True, # start cumul to zero\\n 'Time')\\n # Setting solution heuristic-procedure.\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.local_search_metaheuristic = (\\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\\n search_parameters.time_limit.seconds = 5 #10 # 60 #20 #3000\\n search_parameters.log_search = True\\n # Solve the problem.\\n assignment = routing.SolveWithParameters(search_parameters)\\n # Print solution on console.\\n if assignment:\\n sent, sol_results, routes_results = print_solution(data, manager, routing, assignment) \\n return sent, sol_results, routes_results\",\n \"def eval_genome_eer(g, conf, batch, backprop=False, use_gate=True):\\n\\n # inputs: batch_size x t x bins\\n # outputs: batch_size\\n inputs, targets = batch\\n # inputs: t x batch_size x bins\\n inputs = inputs.transpose(0, 1)\\n\\n net = neat_local.nn.RecurrentNet.create(g, conf, device=\\\"cpu\\\", dtype=torch.float32)\\n assert not backprop\\n net.reset(len(targets))\\n\\n contribution = torch.zeros(len(targets))\\n norm = torch.zeros(len(targets))\\n for input_t in inputs:\\n # input_t: batch_size x bins\\n\\n xo = net.activate(input_t) # batch_size x 2\\n score = xo[:, 1]\\n confidence = xo[:, 0] if use_gate else torch.ones_like(score)\\n contribution += score * confidence # batch_size\\n norm += confidence # batch_size\\n\\n jitter = 1e-8\\n prediction = contribution / (norm + jitter) # batch_size\\n\\n target_scores = prediction[targets == 1].numpy() # select with mask when target == 1\\n non_target_scores = prediction[targets == 0].numpy() # select with mask when target == 0\\n\\n pmiss, pfa = rocch(target_scores, non_target_scores)\\n eer = rocch2eer(pmiss, pfa)\\n\\n return 2 * (.5 - eer)\",\n \"def remove_alt_confs (hierarchy, always_keep_one_conformer=False) :\\n for model in hierarchy.models() :\\n for chain in model.chains() :\\n for residue_group in chain.residue_groups() :\\n atom_groups = residue_group.atom_groups()\\n assert (len(atom_groups) > 0)\\n if always_keep_one_conformer :\\n if (len(atom_groups) == 1) and (atom_groups[0].altloc == '') :\\n continue\\n atom_groups_and_occupancies = []\\n for atom_group in atom_groups :\\n if (atom_group.altloc == '') :\\n continue\\n mean_occ = flex.mean(atom_group.atoms().extract_occ())\\n atom_groups_and_occupancies.append((atom_group, mean_occ))\\n atom_groups_and_occupancies.sort(lambda a,b: cmp(b[1], a[1]))\\n for atom_group, occ in atom_groups_and_occupancies[1:] :\\n residue_group.remove_atom_group(atom_group=atom_group)\\n single_conf, occ = atom_groups_and_occupancies[0]\\n single_conf.altloc = ''\\n else :\\n for atom_group in atom_groups :\\n if (not atom_group.altloc in [\\\"\\\", \\\"A\\\"]) :\\n residue_group.remove_atom_group(atom_group=atom_group)\\n else :\\n atom_group.altloc = \\\"\\\"\\n if (len(residue_group.atom_groups()) == 0) :\\n chain.remove_residue_group(residue_group=residue_group)\\n if (len(chain.residue_groups()) == 0) :\\n model.remove_chain(chain=chain)\\n atoms = hierarchy.atoms()\\n new_occ = flex.double(atoms.size(), 1.0)\\n atoms.set_occ(new_occ)\",\n \"def find_progenitors_until_z_EAGLE(self, mtree, nodeID, z1, z2):\\n snapcount = 0\\n print(':Read MergerTree from %d until %d' % (z2, z1))\\n for ss in range(z2, z1, -1):\\n if ss == z2:\\n df_target = pd.DataFrame({'nodeID':nodeID})\\n _indx = np.where(mtree.data.snapnum.values == ss-1)\\n nodeID_prog = mtree.data.index.values[_indx]\\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\\n _indx = np.where((nodeID_prog_desc < 1e15) &\\n (nodeID_prog_desc > 1e11))\\n nodeID_prog = nodeID_prog[_indx]\\n nodeID_prog_desc = nodeID_prog_desc[_indx]\\n\\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog,\\n 'nodeID_target' : nodeID_prog_desc})\\n\\n # Initiliaze Output Array\\n progcounts = np.zeros((df_target['nodeID'].size, z2-z1))\\n\\n # nodeID_prog_desc_unic is sorted\\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\\n return_counts=True)\\n # remove -1's\\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\\n\\n # Nr. of progenitors for sub-&halos at snapshot z2\\n s = pd.Index(df_target['nodeID'].tolist())\\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\\n progcounts[_indx_now[now_sort_indx], snapcount] = count[pro_sort_indx]\\n \\n else:\\n df_now = df_prog\\n _indx = np.where(mtree.data.snapnum.values == ss-1)\\n nodeID_prog = mtree.data.index.values[_indx]\\n nodeID_prog_desc = mtree.data.descendantIndex.values[_indx]\\n #_indx = np.where((nodeID_prog_desc < 1e15) &\\n # (nodeID_prog_desc > 1e10))\\n #nodeID_prog = nodeID_prog[_indx]\\n #nodeID_prog_desc = nodeID_prog_desc[_indx]\\n df_prog = pd.DataFrame({'nodeID' : nodeID_prog})\\n \\n progcounts_local = np.zeros(df_now['nodeID'].size)\\n nodeID_prog_desc_unic, count = np.unique(nodeID_prog_desc,\\n return_counts=True)\\n # remove -1's\\n nodeID_prog_desc_unic=nodeID_prog_desc_unic[1:]; count=count[1:]\\n \\n # progenitors for snapshot ss\\n s = pd.Index(df_now['nodeID'].tolist())\\n _indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n now_sort_indx = np.argsort(df_now['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(nodeID_prog_desc_unic)\\n progcounts_local[_indx_now[now_sort_indx]] = count[pro_sort_indx]\\n df_now['progcount'] = pd.Series(progcounts_local,\\n index=df_now.index, dtype=int)\\n\\n # Nr. of progenitors for sub-&halos at snapshot z2\\n df_inter = df_now.groupby(['nodeID_target'],\\n as_index=False)['progcount'].sum()\\n # only real progeniteurs\\n df_inter = df_inter[(df_inter['nodeID_target'] > 1e10) & \\n (df_inter['nodeID_target'] < 1e15)]\\n df_inter = df_inter.drop_duplicates(subset=['nodeID_target'],\\n keep='first')\\n \\n s = pd.Index(df_target['nodeID'].tolist())\\n _indx_now = s.get_indexer(df_inter['nodeID_target'].tolist())\\n now_sort_indx = np.argsort(df_target['nodeID'].values[_indx_now])\\n pro_sort_indx = np.argsort(df_inter['nodeID_target'].values)\\n progcounts[_indx_now[now_sort_indx], snapcount] = df_inter['progcount'].values[pro_sort_indx]\\n\\n # sort nodeID_prog to nodeID\\n #s = pd.Index(df_now['nodeID'].tolist())\\n #_indx_now = s.get_indexer(list(nodeID_prog_desc_unic))\\n #df_now['nodeID_target'].values[_indx_now]\\n \\n obs_ref_local = np.zeros(df_prog['nodeID'].size)\\n for ii in range(len(nodeID_prog_desc_unic)):\\n tarID = df_now.loc[\\n df_now['nodeID'] == nodeID_prog_desc_unic[ii],\\n 'nodeID_target'].values.astype(int)\\n if tarID:\\n _indx = np.where(\\n nodeID_prog_desc == nodeID_prog_desc_unic[ii])\\n obs_ref_local[_indx] = tarID\\n df_prog['nodeID_target'] = pd.Series(obs_ref_local,\\n index=df_prog.index)\\n\\n snapcount += 1\\n del nodeID_prog_desc\\n del df_now, df_inter, df_prog\\n return np.asarray(df_target['nodeID'].tolist()), progcounts\",\n \"def PathEnzReg(dic,organism):\\n\\t#calculation\\n\\tppcorrp = [0] * (len(dic.plst)*len(dic.plst))\\n\\tppcorrn = [0] * (len(dic.plst)*len(dic.plst))\\n\\tfor e in dic.elst:\\n\\t\\tcs = e.cs[0]\\n\\t\\tr = e.rct\\n\\t\\tif e.activation == None:\\n\\t\\t\\tcontinue\\n\\t\\tfor (i,p1) in enumerate(dic.plst):\\n\\t\\t\\tfor (j,p2) in enumerate(dic.plst):\\n\\t\\t\\t\\tif cs in p1.sclst and r not in p1.srlst and cs not in p2.sclst and r in p2.srlst and p1 not in p2.splst and p2 not in p1.splst and p1 != p2:\\n\\t\\t\\t\\t\\tif e.activation == True:\\n\\t\\t\\t\\t\\t\\tppcorrp[i*len(dic.plst)+j] += 1\\n\\t\\t\\t\\t\\telif e.activation == False:\\n\\t\\t\\t\\t\\t\\tppcorrn[i*len(dic.plst)+j] += 1\\n\\n\\t\\n\\t#output\\n\\twith open('./results/'+organism+'/logfiles/logpath.log','w') as out:\\n\\t\\tout.write('#List of the XX couples of most interactive pathways:\\\\n#those pathways that have the biggest number of enzymes (EITHER + OR -) going exclusively from one to the other.\\\\n#FORMAT:\\\\n#number of interactions from p1 to p2 (from p2 to p1) [from p1 to p2 with opposite sign, from p2 to p1 with opposite sign]\\\\n#p1 name \\\\t p2 name\\\\n\\\\nACTIVATION:\\\\n')\\n\\t\\tppcorrtp = ppcorrp[:]\\n\\t\\tppcorrtn = ppcorrn[:]\\n\\t\\tfor i in range(20):\\n\\t\\t\\tj = ppcorrp.index(max(ppcorrp))\\n\\t\\t\\t(m,n) = ((j-j%len(dic.plst))/len(dic.plst),j%len(dic.plst))\\n\\t\\t\\t(p1,p2) = (dic.plst[m],dic.plst[n])\\n\\t\\t\\tout.write(p1.name+'\\\\t'+p2.name+'\\\\n'+str(ppcorrtp[j])+'\\\\t('+str(ppcorrtp[n*len(dic.plst)+m])+')\\\\t'+str([ppcorrtn[j],ppcorrtn[n*len(dic.plst)+m]])+'\\\\n')\\n\\t\\t\\tppcorrp[m*len(dic.plst)+n] = 0\\n\\t\\t\\tppcorrp[n*len(dic.plst)+m] = 0\\n\\n\\n\\t\\tout.write('\\\\n-------------------------------------------------------------------------------------\\\\n\\\\nINHIBITION:\\\\n')\\n\\t\\tfor i in range(20):\\n\\t\\t\\tj = ppcorrn.index(max(ppcorrn))\\n\\t\\t\\t(m,n) = ((j-j%len(dic.plst))/len(dic.plst),j%len(dic.plst))\\n\\t\\t\\t(p1,p2) = (dic.plst[m],dic.plst[n])\\n\\t\\t\\tout.write(p1.name+'\\\\t'+p2.name+'\\\\n'+str(ppcorrtn[j])+'\\\\t('+str(ppcorrtn[n*len(dic.plst)+m])+')\\\\t'+str([ppcorrtp[j],ppcorrtp[n*len(dic.plst)+m]])+'\\\\n')\\n\\t\\t\\tppcorrn[m*len(dic.plst)+n] = 0\\n\\t\\t\\tppcorrn[n*len(dic.plst)+m] = 0\",\n \"def find_best_free_param_configuration_LOO_adj_sen(p):\\n\\n measures_res = linux_base_path+ \\\"/measures_res\\\"+setup+\\\"/\\\"\\n# measures_res = base_path +\\\"\\\\\\\\measures_res\\\"+setup+\\\"\\\\\\\\\\\"\\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n claim_dict = read_pickle(\\\"claim_dict\\\")\\n claim_num_list = [4,7,17,21,36,37,39,40,41,42,45,46,47,50,51,53,54,55,57,58,59,60,61,62,66,69,70,79,80]\\n# claim_num_list = [4,47,53,58,7,54]\\n best_configuration_for_nDCG_AP_prec_at_k_left_out_res = {} #key is left out claim and and value is the alpha,beta,lambda configuration that led to best measures - avg nDCG and AP across the train claims\\n measures_res_of_left_out_in_its_best_conf = {} #key - left out claim num, and value is the measures of it, in the best configuration without it.\\n \\n k_val = 50\\n prec_at_k_train = rcdtype.recordtype('prec_at_k_train', 'at_5 at_10')\\n max_prec_at_k = rcdtype.recordtype('max_prec_at_k', 'max_val max_conf')\\n try:\\n for left_out_claim_indx in range(len(claim_num_list)):\\n max_nDCG = 0\\n max_MAP = 0\\n max_nDCG_conf = []\\n max_MAP_conf = []\\n max_prec_at_5 = max_prec_at_k(0,\\\"\\\")\\n max_prec_at_10 = max_prec_at_k(0,\\\"\\\")\\n \\n left_out_claim_num = claim_num_list[left_out_claim_indx]\\n temp_claim_num_list = claim_num_list[:]\\n temp_claim_num_list.remove(left_out_claim_num)\\n for alpha in range(0,7,1): #change just for test!\\n for beta in range(0,10,1):\\n for lambda_int in range(0,11,1):\\n for delta_1 in range(0,10,1):\\n for delta_2 in range(0,10,1):\\n if not delta_1+delta_2 >9: \\n lambda_f = turn_to_float([lambda_int])\\n (alpha_f,beta_f,delta_1_f,delta_2_f) = turn_to_float([alpha,beta,delta_1,delta_2])\\n measures_all_claims = utils_linux.read_pickle(measures_res+\\\"measures_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_delta1_\\\"+str(delta_1_f)+\\\"_delta2_\\\"+str(delta_2_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f))\\n \\n # AP_all_claims_curr_param_values = read_pickle(nDCG_MAP_res+\\\"AP_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f))\\n # nDCG_all_claims_curr_param_values = read_pickle(nDCG_MAP_res+\\\"NDCG_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f)+\\\"_at_\\\"+str(p))\\n # prec_at_k_all_claims_params_values = read_pickle(nDCG_MAP_res+\\\"prec_at_k_all_claims_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f))\\n avg_nDCG_on_train = 0\\n MAP_on_train = 0\\n p_at_k_train_avg = prec_at_k_train(0,0)\\n for clm_num_train in temp_claim_num_list:\\n avg_nDCG_on_train += measures_all_claims[str(clm_num_train)][0]\\n MAP_on_train += measures_all_claims[str(clm_num_train)][1] #in this config' -> get the measures\\n p_at_k_train_avg.at_5 += measures_all_claims[str(clm_num_train)][2]\\n p_at_k_train_avg.at_10 += measures_all_claims[str(clm_num_train)][3]\\n avg_nDCG_on_train = float(float(avg_nDCG_on_train)/float(len(temp_claim_num_list)))\\n MAP_on_train = float(float(MAP_on_train)/float(len(temp_claim_num_list)))\\n p_at_k_train_avg.at_5 = float(float(p_at_k_train_avg.at_5)/float(len(temp_claim_num_list)))\\n p_at_k_train_avg.at_10 = float(float(p_at_k_train_avg.at_10)/float(len(temp_claim_num_list)))\\n \\n if avg_nDCG_on_train > max_nDCG:\\n max_nDCG = avg_nDCG_on_train\\n max_nDCG_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\\n if MAP_on_train > max_MAP:\\n max_MAP = MAP_on_train\\n max_MAP_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\\n if p_at_k_train_avg.at_5 > max_prec_at_5.max_val:\\n max_prec_at_5.max_val = p_at_k_train_avg.at_5\\n max_prec_at_5.max_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\\n if p_at_k_train_avg.at_10 > max_prec_at_10.max_val:\\n max_prec_at_10.max_val = p_at_k_train_avg.at_10\\n max_prec_at_10.max_conf = (alpha_f,beta_f,lambda_f,delta_1_f,delta_2_f)\\n best_configuration_for_nDCG_AP_prec_at_k_left_out_res[left_out_claim_num] = [(max_nDCG,max_nDCG_conf),(max_MAP,max_MAP_conf),(max_prec_at_5.max_val,max_prec_at_5.max_conf),(max_prec_at_10.max_val,max_prec_at_10.max_conf)]\\n #finished leaving out,\\n #now calculate the nDCG and MAP of the left out claims with its best configuration results\\n avg_nDCG_on_left_out = 0\\n MAP_on_left_out = 0\\n avg_prec_at_5_on_left_out = 0\\n avg_prec_at_10_on_left_out = 0\\n for clm_num in claim_num_list:\\n (best_alpha_nDCG,best_beta_nDCG,best_lambda_nDCG,best_delta1_nDCG,best_delta2_nDCG) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1]\\n (best_alpha_MAP,best_beta_MAP,best_lambda_MAP,best_delta1_MAP,best_delta2_MAP) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1]\\n (best_alpha_prec_at_5,best_beta_prec_at_5,best_lambda_prec_at_5,best_delta1_prec_at_5,best_delta2_prec_at_5) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1]\\n (best_alpha_prec_at_10,best_beta_prec_at_10,best_lambda_prec_at_10,best_delta1_prec_at_10,best_delta2_prec_at_10) = best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1]\\n #read the best config' dict\\n best_config_of_nDCG_dict = read_pickle(measures_res+\\\"measures_all_claims_alpha_\\\"+str(best_alpha_nDCG)+\\\"_beta_\\\"+str(best_beta_nDCG)+\\\"_delta1_\\\"+str(best_delta1_nDCG)+\\\"_delta2_\\\"+str(best_delta2_nDCG)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(best_lambda_nDCG))\\n best_config_of_AP_dict = read_pickle(measures_res+\\\"measures_all_claims_alpha_\\\"+str(best_alpha_MAP)+\\\"_beta_\\\"+str(best_beta_MAP)+\\\"_delta1_\\\"+str(best_delta1_MAP)+\\\"_delta2_\\\"+str(best_delta2_MAP)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(best_lambda_MAP))\\n best_config_of_prec_at_5_dict = read_pickle(measures_res+\\\"measures_all_claims_alpha_\\\"+str(best_alpha_prec_at_5)+\\\"_beta_\\\"+str(best_beta_prec_at_5)+\\\"_delta1_\\\"+str(best_delta1_prec_at_5)+\\\"_delta2_\\\"+str(best_delta2_prec_at_5)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(best_lambda_prec_at_5)) #take only the first item in the tuple\\n best_config_prec_of_at_10_dict = read_pickle(measures_res+\\\"measures_all_claims_alpha_\\\"+str(best_alpha_prec_at_10)+\\\"_beta_\\\"+str(best_beta_prec_at_10)+\\\"_delta1_\\\"+str(best_delta1_prec_at_10)+\\\"_delta2_\\\"+str(best_delta2_prec_at_10)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(best_lambda_prec_at_10)) #take only the second item in the tuple\\n measures_res_of_left_out_in_its_best_conf[clm_num] = (best_config_of_nDCG_dict[str(clm_num)][0],best_config_of_AP_dict[str(clm_num)][1],best_config_of_prec_at_5_dict[str(clm_num)][2],best_config_prec_of_at_10_dict[str(clm_num)][3])\\n avg_nDCG_on_left_out += best_config_of_nDCG_dict[str(clm_num)][0]\\n MAP_on_left_out += best_config_of_AP_dict[str(clm_num)][1]\\n avg_prec_at_5_on_left_out += best_config_of_prec_at_5_dict[str(clm_num)][2]\\n avg_prec_at_10_on_left_out += best_config_prec_of_at_10_dict[str(clm_num)][3]\\n \\n save_pickle(measures_res+\\\"measures_res_of_left_out_in_its_best_conf_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p), measures_res_of_left_out_in_its_best_conf)\\n #report the avg\\n avg_nDCG_on_left_out = float(float(avg_nDCG_on_left_out)/float(len(claim_num_list))) \\n MAP_on_left_out = float(float(MAP_on_left_out)/float(len(claim_num_list))) \\n avg_prec_at_5_on_left_out = float(float(avg_prec_at_5_on_left_out)/float(len(claim_num_list)))\\n avg_prec_at_10_on_left_out = float(float(avg_prec_at_10_on_left_out)/float(len(claim_num_list)))\\n #write res to file:\\n # claim text, the best nDCG conf and result on train, the nDCG it really has, and the same for AP\\n with open(measures_res+\\\"nDCG_AP_prec_at_k_res_of_left_out_in_its_best_conf_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p)+\\\".csv\\\", 'wb') as csvfile:\\n w = csv.writer(csvfile)\\n row = \\\"claim|best_nDCG|alpha,beta,lambda,delta_1,delta_2,delta_3|best_AP|alpha,beta,lambda,delta_1,delta_2,delta_3|best_prec_at_5|alpha,beta,lambda,delta_1,delta_2,delta_3|best_prec_at_10|alpha,beta,lambda,delta_1,delta_2,delta_3\\\"\\n w.writerow([row])\\n for (clm_num,(nDCG,AP,prec_at_5,prec_at_10)) in measures_res_of_left_out_in_its_best_conf.items():\\n row = claim_dict[str(clm_num)]+\\\"&\\\"+'%.3f'%nDCG+\\\"&\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][0])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][1])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][2])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][3])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][4])+\\\",\\\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][0][1][3])\\n row += \\\"&\\\"+'%.3f'%AP+\\\"&\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][0])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][1])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][2])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][3])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][4])+\\\",\\\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][1][1][3])\\n row += \\\"&\\\"+'%.3f'%prec_at_5+ \\\"&\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][0])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][1])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][2])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][3])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][4])+\\\",\\\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][2][1][3])\\n row += \\\"&\\\"+'%.3f'%prec_at_10+ \\\"&\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][0])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][1])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][2])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][3])+\\\",\\\"+str(best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][4])+\\\",\\\"+str(0.9-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][4]-best_configuration_for_nDCG_AP_prec_at_k_left_out_res[clm_num][3][1][3])\\n w.writerow([row])\\n w.writerow([\\\"avg_nDCG_on_left_out: \\\"+ '%.4f'%avg_nDCG_on_left_out ])\\n w.writerow([\\\"MAP_on_left_out: \\\"+ '%.4f'%MAP_on_left_out])\\n w.writerow([\\\"avg_prec_at_5_on_left_out: \\\"+ '%.4f'%avg_prec_at_5_on_left_out])\\n w.writerow([\\\"avg_prec_at_10_on_left_out: \\\"+ '%.4f'%avg_prec_at_10_on_left_out])\\n except Exception as err: \\n sys.stderr.write('problem in LOO') \\n print err\",\n \"def correct_intron_boundaries_by_exonsignal(abfgp_genemodel,organism,PCG,introndata,\\n array_algpresence,array_algsimilarity,verbose=True):\\n\\n # Global Variable Imports\\n CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET = 200\\n CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET = 200\\n FINETUNE_ACCEPTOR_NT_OFFSET = 12\\n FINETUNE_DONOR_NT_OFFSET = 12\\n from settings.genestructure import MIN_INTRON_NT_LENGTH\\n\\n\\n # list with adjusted boundaries\\n refined_boundaries = []\\n\\n # recreate lists of ABGFP exons & introns\\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\\n\\n for intron_pos in range(0,len(abfgp_introns)):\\n intron = abfgp_introns[intron_pos]\\n if not intron: continue\\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\\n\\n next_exon = abfgp_exons[intron_pos+1]\\n prev_exon = abfgp_exons[intron_pos]\\n\\n # make elegiable correction range\\n correct_acceptor_range = range(\\n intron.acceptor.pos-CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET,\\n min([ next_exon.donor.pos-6, intron.acceptor.pos+CORRECT_BY_EXONSIGNAL_ACCEPTOR_NT_OFFSET+1 ]) )\\n correct_donor_range = range(\\n max([ prev_exon.acceptor.pos+6, intron.donor.pos-CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET]),\\n intron.donor.pos+CORRECT_BY_EXONSIGNAL_DONOR_NT_OFFSET+1)\\n finetune_acceptor_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1)\\n finetune_donor_range = range(intron.donor.pos-FINETUNE_DONOR_NT_OFFSET,\\n intron.donor.pos+FINETUNE_DONOR_NT_OFFSET+1)\\n\\n\\n staI,endI = intron.donor.pos/3, intron.acceptor.pos/3\\n staE,endE = intron.acceptor.pos/3, next_exon.donor.pos/3\\n algsim_intron = sum(array_algsimilarity[staI:endI])\\n algsim_next_exon = sum(array_algsimilarity[staE:endE])\\n algsim_score_abs = float(algsim_intron)/algsim_next_exon\\n algsim_score_rel = float(algsim_intron)/algsim_next_exon * (float(endE-staE)/float(endI-staI))\\n\\n print \\\"CORRECT\\\", intron\\n print intron.acceptor, intron.acceptor.pos, algsim_score_abs, algsim_score_rel\\n print [ a.pos for a in intron.orfAcceptor._acceptor_sites ]\\n\\n\\n possible_acceptor_boundaries = []\\n possible_donor_boundaries = []\\n\\n for acceptor in intron.orfAcceptor._acceptor_sites:\\n if acceptor.pos - intron.donor.pos < MIN_INTRON_NT_LENGTH: continue\\n if acceptor.pos not in correct_acceptor_range: continue\\n if acceptor.pos == intron.acceptor.pos: continue\\n if _finetune_splicesite_comparison(intron.acceptor,acceptor) == False: continue\\n\\n # if here, generate stats\\n staI,endI = intron.donor.pos/3, acceptor.pos/3\\n algsim_intron_pos = sum(array_algsimilarity[staI:endI])\\n staE,endE = acceptor.pos/3, next_exon.donor.pos/3\\n algsim_next_exon_pos = sum(array_algsimilarity[staE:endE]) \\n # check if no similarity left of exon; avoid ZeroDivisionError\\n if algsim_next_exon_pos == 0: continue\\n\\n # calculate score ratios\\n alternative_algsim_score_abs = float(algsim_intron_pos)/algsim_next_exon_pos\\n alternative_algsim_score_rel = alternative_algsim_score_abs * (float(endE-staE)/float(endI-staI))\\n\\n # test if exon signal is an improvement\\n #if alternative_algsim_score_abs > algsim_score_abs: continue\\n #if alternative_algsim_score_rel > algsim_score_rel: continue\\n\\n\\n if acceptor.phase == intron.donor.phase:\\n # get data on this alternative acceptor/donor combination\\n test_intron = IntronConnectingOrfs(intron.donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\\n test_intron.assign_bp_and_ppts()\\n else:\\n test_intron = None\\n\\n print acceptor, acceptor.pos, \\n print alternative_algsim_score_abs,\\n print alternative_algsim_score_rel,\\n if test_intron:\\n print _branchpoint_comparison(intron,test_intron),\\n print _polypyrimidinetract_comparison(intron,test_intron)\\n else:\\n print \\\"OTHER PHASE\\\"\\n\\n\\n staI,endI = intron.donor.pos/3, intron.acceptor.pos/3\\n staE,endE = prev_exon.acceptor.pos/3, intron.donor.pos/3, \\n algsim_intron = sum(array_algsimilarity[staI:endI])\\n algsim_prev_exon = sum(array_algsimilarity[staE:endE])\\n algsim_score_abs = float(algsim_intron)/algsim_prev_exon\\n algsim_score_rel = float(algsim_intron)/algsim_prev_exon * (float(endE-staE)/float(endI-staI))\\n\\n print intron.donor, intron.donor.pos, algsim_score_abs, algsim_score_rel\\n print [ d.pos for d in intron.orfDonor._donor_sites ]\\n\\n for donor in intron.orfDonor._donor_sites:\\n if intron.acceptor.pos - donor.pos < MIN_INTRON_NT_LENGTH: continue\\n if donor.pos == intron.donor.pos: continue\\n if donor.pos not in correct_donor_range: continue\\n if _finetune_splicesite_comparison(intron.donor,donor) == False: continue\\n\\n # if here, generate stats\\n staI,endI = donor.pos/3, intron.acceptor.pos/3\\n algsim_intron_pos = sum(array_algsimilarity[staI:endI])\\n staE,endE = prev_exon.acceptor.pos/3, donor.pos/3\\n algsim_prev_exon_pos = sum(array_algsimilarity[staE:endE]) \\n # check if no similarity left of exon; avoid ZeroDivisionError\\n if algsim_prev_exon_pos == 0: continue\\n\\n # calculate score ratios\\n alternative_algsim_score_abs = float(algsim_intron_pos)/algsim_prev_exon_pos\\n alternative_algsim_score_rel = alternative_algsim_score_abs * (float(endE-staE)/float(endI-staI))\\n\\n # test if exon signal is an improvement\\n #if alternative_algsim_score_abs > algsim_score_abs: continue\\n #if alternative_algsim_score_rel > algsim_score_rel: continue\\n\\n if donor.phase == intron.acceptor.phase:\\n # get data on this alternative acceptor/donor combination\\n test_intron = IntronConnectingOrfs(donor,intron.acceptor,None,intron.orfDonor,intron.orfAcceptor)\\n test_intron.assign_bp_and_ppts()\\n else:\\n test_intron = None\\n\\n print donor, donor.pos, \\n print alternative_algsim_score_abs,\\n print alternative_algsim_score_rel,\\n if test_intron:\\n print _branchpoint_comparison(intron,test_intron),\\n print _polypyrimidinetract_comparison(intron,test_intron)\\n else:\\n print \\\"OTHER PHASE\\\"\\n\\n\\n #for position in range(intron.acceptor.pos,intron.orfAcceptor.start,-10):\\n # staI,endI = intron.donor.pos/3, position/3\\n # if endI <= staI: break\\n # algsim_intron_pos = sum(array_algsimilarity[staI:endI])\\n # staE,endE = position/3, next_exon.donor.pos/3\\n # algsim_next_exon_pos = sum(array_algsimilarity[staE:endE]) \\n # print position, scoreA, scoreB,\\n # print float(algsim_intron_pos)/algsim_next_exon_pos,\\n # print float(algsim_intron_pos)/algsim_next_exon_pos * (float(endE-staE)/float(endI-staI))\",\n \"def gen_static_landscape(pop,conc):\\n # get final landscape and seascape\\n landscape = np.zeros(pop.n_genotype)\\n for kk in range(pop.n_genotype):\\n landscape[kk] = gen_fitness(pop,\\n kk,\\n pop.static_topo_dose,\\n pop.drugless_rates,\\n pop.ic50)\\n \\n if min(landscape) == 0:\\n zero_indx_land = np.argwhere(landscape==0)\\n landscape_t = np.delete(landscape,zero_indx_land)\\n min_landscape = min(landscape_t)\\n else:\\n min_landscape = min(landscape)\\n zero_indx_land = []\\n \\n seascape = np.zeros(pop.n_genotype)\\n for gen in range(pop.n_genotype):\\n seascape[gen] = gen_fitness(gen,conc,pop.drugless_rates,pop.ic50,pop=pop)\\n \\n if min(seascape) == 0:\\n zero_indx_sea = np.argwhere(seascape==0)\\n seascape_t = np.delete(seascape,zero_indx_sea)\\n min_seascape = min(seascape_t)\\n else:\\n min_seascape = min(seascape)\\n \\n landscape = landscape - min_landscape\\n landscape = landscape/max(landscape)\\n \\n rng = max(seascape) - min_seascape\\n \\n landscape = landscape*rng + min_seascape\\n \\n landscape[zero_indx_land] = 0\\n return landscape\",\n \"def _format_subgraph_improper(m, top):\\n (sort_by_n_connections, _) = _get_sorted_by_n_connections(m)\\n if len(sort_by_n_connections) == 4:\\n central = sort_by_n_connections[3]\\n branch1, branch2, branch3 = sorted(\\n sort_by_n_connections[:3],\\n key=lambda x: top.get_index(x),\\n )\\n return (\\n top.get_index(central),\\n top.get_index(branch1),\\n top.get_index(branch2),\\n top.get_index(branch3),\\n )\\n return None\",\n \"def describe(self, gpos, args):\\n\\n rg = RegAnno()\\n\\n rg.dist2tss = gpos - self.exons[0][0] if self.strand == '+' else self.exons[-1][1] - gpos\\n if rg.dist2tss >= -args.prombeg and rg.dist2tss <= args.promend:\\n rg.promoter = True\\n\\n # intergenic, NOTE USE describe_intergenic_neighbors\\n if gpos < self.exons[0][0]:\\n rg.intergenic = (self.exons[0][0] - gpos, 'upstream' if self.strand == '+' else 'downstream')\\n return rg\\n if gpos > self.exons[-1][1]:\\n rg.intergenic = (gpos - self.exons[-1][1], 'downstream' if self.strand == '+' else 'upstream')\\n return rg\\n\\n if gpos < self.cds_beg:\\n rg.UTR = '5' if self.strand == '+' else '3'\\n if gpos > self.cds_end:\\n rg.UTR = '3' if self.strand == '+' else '5'\\n\\n for i, exon in enumerate(self.exons):\\n exind = i+1 if self.strand == '+' else len(self.exons) - i\\n if exon[0] <= gpos and exon[1] >= gpos: # exonic\\n rg.exonic = True\\n if gpos >= self.cds_beg and gpos <= self.cds_end:\\n rg.cds = True\\n if gpos == self.cds_beg:\\n rg.start = True\\n if gpos == self.cds_end:\\n rg.stop = True\\n if gpos == exon[1]:\\n rg.splice = 'NextToDonor' if self.strand == '+' else 'NextToAcceptor'\\n if gpos == exon[0]:\\n rg.splice = 'NextToAcceptor' if self.strand == '+' else 'NextToDonor'\\n rg.exon = exind\\n return rg\\n if i > 0:\\n pexon = self.exons[i-1]\\n if gpos > pexon[1] and gpos < exon[0]: # intronic\\n rg.intronic = True\\n if self.strand == '+':\\n rg.intron_exon1 = exind-1\\n rg.intron_exon2 = exind\\n else:\\n rg.intron_exon1 = exind\\n rg.intron_exon2 = exind+1\\n if gpos in [pexon[1]+1, pexon[1]+2]:\\n rg.splice = 'Donor' if self.strand == '+' else 'Acceptor'\\n if gpos in [exon[0]-2, exon[0]-1]:\\n rg.splice = 'Acceptor' if self.strand == '-' else 'Donor'\\n return rg\\n\\n raise Exception('unknown_error') # you shouldn't reach here\",\n \"def process_gene(header, gene):\\n ID = get_geneID(header=header)\\n GC = DNA.gc(gene)\\n gline = '{} {:4d} {:.2%} {}'.format(ID, len(gene), GC/100, '\\\\n')\\n return gline\",\n \"def generate_CS_corr_lib(CS_FS_file, cutoff, prefix):\\r\\n f1 = CS_FS_file # File containing sgRNA ID, gene name, CS & FS\\r\\n sgRNA = []; gene = []; CS = []; FS = [] # Lists for storing sgRNA ID, gene name, CS & FS of sgRNA\\r\\n with open(f1,'r') as f:\\r\\n reader = csv.reader(f, delimiter = '\\\\t')\\r\\n for row in reader:\\r\\n sgRNA.append(row[0])\\r\\n gene.append(row[1])\\r\\n CS.append(row[2])\\r\\n FS.append(row[3])\\r\\n sgRNA.remove(sgRNA[0]); gene.remove(gene[0]); CS.remove(CS[0]); FS.remove(FS[0])\\r\\n guide_details = tuple(zip(sgRNA,gene,CS,FS))\\r\\n # guide_details is a tuple, each element of which is a tuple of the form (sgRNA ID, gene, CS, FS) \\r\\n gene_set = list(set(gene)) # List of genes covered by the GW-library\\r\\n \\r\\n gene_guides = defaultdict(list) # A dictionary for storing gene name as key and a list of attributes (i.e., ID, gene, CS, FS) of all sgRNA targeting that gene as values\\r\\n for g in gene_set:\\r\\n for i in range(len(guide_details)):\\r\\n if g in guide_details[i][1]: gene_guides[g].append(guide_details[i])\\r\\n \\r\\n val = []; # List for storing details of guides included in the CS-corrected library\\r\\n \\r\\n for g in gene_guides:\\r\\n c = 0; # Counts the number of good cutters (CS > cutoff) targeting a gene\\r\\n y = np.array(gene_guides[g])\\r\\n for i in range(y.shape[0]):\\r\\n if float(y[i,2]) > cutoff:\\r\\n c += 1\\r\\n val.append(y[i])\\r\\n if c == 0: # if no good cutters target a gene, the best of the existing cutters is picked\\r\\n p = y[:,2].astype(float) # Converting CS values to float from str\\r\\n x = np.where(p == max(p)) # Finding the array position of guide having max. CS (best cutter)\\r\\n val.append(y[x[0][0]])\\r\\n \\r\\n # Writing results in a new .TAB file\\r\\n g = prefix + '_corrected_guide_CS_FS.tab'\\r\\n with open(g,'w',newline = '') as f:\\r\\n writer = csv.writer(f, delimiter = '\\\\t')\\r\\n writer.writerow(['Guide ID','gene','CS','FS'])\\r\\n for i in val:\\r\\n row = []\\r\\n row.append(i[0])\\r\\n row.append(i[1])\\r\\n row.append(float(i[2]))\\r\\n row.append(float(i[3]))\\r\\n writer.writerow(row)\",\n \"def GetInteriorEdgesPent(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesPent()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesPent()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def eo_edges(self):\\n logger.info(\\\"eo_edges called\\\")\\n permutations = []\\n original_state = self.state[:]\\n original_solution = self.solution[:]\\n tmp_solution_len = len(self.solution)\\n\\n # Build a list of the wing strings at each midge\\n wing_strs = []\\n\\n for _, square_index, partner_index in midges_recolor_tuples_555:\\n square_value = self.state[square_index]\\n partner_value = self.state[partner_index]\\n wing_str = square_value + partner_value\\n wing_str = wing_str_map[square_value + partner_value]\\n wing_strs.append(wing_str)\\n\\n # build a list of all possible EO permutations...an even number of edges must be high\\n for num in range(4096):\\n num = str(bin(num)).lstrip(\\\"0b\\\").zfill(12)\\n if num.count(\\\"1\\\") % 2 == 0:\\n permutations.append(list(map(int, num)))\\n\\n # Put all 2048 starting states in a file and point ida-via-graph\\n # at the file so it can solve all of them and apply the one that is the shortest.\\n lr_center_stage_states = []\\n eo_outer_orbit_states = []\\n eo_inner_orbit_states = []\\n\\n for permutation in permutations:\\n must_be_uppercase = []\\n must_be_lowercase = []\\n self.state = original_state[:]\\n\\n for wing_str, uppercase in zip(wing_strs, permutation):\\n if uppercase:\\n must_be_uppercase.append(wing_str)\\n else:\\n must_be_lowercase.append(wing_str)\\n\\n # logger.info(\\\"%s: %s permutation %s\\\" % (self, index, \\\"\\\".join(map(str, permutation))))\\n self.edges_flip_orientation(must_be_uppercase, must_be_lowercase)\\n\\n # build lists of the states that we need to find state_indexes for\\n lr_center_stage_states.append(self.lt_phase3_lr_center_stage.state())\\n eo_outer_orbit_states.append(self.lt_phase3_eo_outer_orbit.state())\\n eo_inner_orbit_states.append(self.lt_phase3_eo_inner_orbit.state())\\n\\n # now we have a huge list of states to lookup, do a binary search on multiple states at once (this is drastically faster\\n # than binary searching for them individually). state_index_multiple() will return a dict where the state is the key\\n # and the state_index is the value.\\n lr_center_stage_eo_inner_orbit_state_indexes = self.lt_phase3_lr_center_stage.state_index_multiple(\\n lr_center_stage_states\\n )\\n eo_outer_orbit_state_indexes = self.lt_phase3_eo_outer_orbit.state_index_multiple(eo_outer_orbit_states)\\n eo_inner_orbit_state_indexes = self.lt_phase3_eo_inner_orbit.state_index_multiple(eo_inner_orbit_states)\\n\\n # build a list of tuples of the state indexes\\n pt_state_indexes = []\\n for lr_center_stage_eo_inner_orbit_state, eo_outer_orbit_state, eo_inner_orbit_state in zip(\\n lr_center_stage_states, eo_outer_orbit_states, eo_inner_orbit_states\\n ):\\n pt_state_indexes.append(\\n (\\n lr_center_stage_eo_inner_orbit_state_indexes[lr_center_stage_eo_inner_orbit_state],\\n eo_outer_orbit_state_indexes[eo_outer_orbit_state],\\n eo_inner_orbit_state_indexes[eo_inner_orbit_state],\\n )\\n )\\n\\n self.state = original_state[:]\\n self.solution = original_solution[:]\\n\\n # When solve_via_c is passed pt_state_indexes (2048 lines of states in this case), it will try all 2048 of them\\n # to find the state that has the shortest solution.\\n self.lt_phase3.solve_via_c(pt_states=pt_state_indexes)\\n\\n self.print_cube_add_comment(\\\"edges EOed into high/low groups\\\", tmp_solution_len)\\n self.post_eo_state = self.state[:]\\n self.post_eo_solution = self.solution[:]\\n\\n # re-color the cube so that the edges are oriented correctly so we can\\n # pair 4-edges then 8-edges. After all edge pairing is done we will uncolor\\n # the cube and re-apply the solution.\\n self.edges_flip_orientation(wing_strs, [])\\n self.highlow_edges_print()\",\n \"def _find_all_top_level_non_gene_features(chrom: str, db: FeatureDB, feature_types: List[str]) -> Iterable[Feature]:\\n for feature in db.region(seqid=chrom, featuretype=feature_types):\\n try:\\n _ = next(db.parents(feature.id))\\n except StopIteration:\\n yield feature\",\n \"def calculate_GNOp_initial(self):\\n\\n # Initialise\\n Transform2NormIndOp = Transform2NormInd()\\n\\n # Directories\\n dataset_paths = self.dataset_paths\\n sensor_data_path = self.sensor_data_path\\n output_dir = self.output_dir\\n\\n ################################################################################################################\\n # 1.\\tRead Harmonisation Matchup Data\\n ################################################################################################################\\n\\n print \\\"Match-up Dataset:\\\"\\n for path in dataset_paths:\\n print \\\">\\\", path\\n\\n print \\\"\\\\nSensor Data File:\\\"\\n print \\\"> \\\"+sensor_data_path\\n\\n print \\\"\\\\nOpening data...\\\"\\n HData = self.data_reader(dataset_paths, sensor_data_path, open_uncertainty=True)\\n\\n ################################################################################################################\\n # 2.\\tPerform harmonisation\\n ################################################################################################################\\n\\n print \\\"Complete\\\"\\n\\n print \\\"\\\\nData Info\\\"\\n print \\\"==========\\\"\\n print \\\"Reference Sensors - \\\", [str(sensor) for sensor in HData.idx['sensors']\\n if sensor not in HData.idx[\\\"parameter_sensor\\\"]]\\n print \\\"Harmonising Sensors - \\\", [str(sensor) for sensor in HData.idx['sensors']\\n if sensor in HData.idx[\\\"parameter_sensor\\\"]]\\n print \\\"Total Match-Ups - \\\", HData.idx['cNm'][-1]\\n print \\\"Total Sensor State Data Values - \\\", HData.idx['idx'][-1]\\n print \\\"Total Harmonisation Paramaters - \\\", len(HData.idx['parameter_sensor'])\\n\\n print \\\"\\\\nComputing Initial GN Value...\\\"\\n # a. reparameterise input data such that output data are independent quantities\\n HData = Transform2NormIndOp.run(HData)\\n\\n # b. run GN algorithm on modified data\\n GNOp = GNAlgo(HData)\\n\\n ################################################################################################################\\n # 3.\\tWrite data to file\\n ################################################################################################################\\n\\n print '\\\\nWriting data to file...'\\n\\n # Write data\\n save_directory_GNOp = pjoin(output_dir, \\\"temp\\\", \\\"GNOp_initial\\\")\\n try:\\n os.makedirs(save_directory_GNOp)\\n except OSError:\\n pass\\n\\n GNOp.save(save_directory_GNOp)\\n\\n print \\\"Output Data Written To:\\\"\\n print \\\">\\\", save_directory_GNOp\",\n \"def FindCA(e,PV,F,w,m):\\n global MAX\\n le=len(e)\\n if le > MAX:\\n MAX = le\\n #print the new best columns and how many they are\\n system('clear')\\n print \\\"So far, the best columns are %s and MAX is %d\\\" % (e,MAX)\\n PV=ComputeCand(e,PV,F,w,m)\\n lp=len(PV)\\n if le+lp > MAX:\\n for i in range(le+lp-MAX):\\n newe=e+[PV[i]]\\n test=collections.deque(columns2bin(newe, w))\\n if is_necklace(test):\\n FindCA(newe,PV[i+1:],F,w,m)\\n else:\\n break\",\n \"def process_graph(self, threshold=None):\\r\\n\\r\\n def find_head_end(head_name, descendant, end_op):\\r\\n # This helper function finds ends of Class Net and Box Net, based on a model type. \\r\\n # :param head_name: This is a common name that nodes in either Class or Box Nets start with.\\r\\n # :param descendant: Descendant of head_name, identified by operation (Transpose, MatMul, etc.).\\r\\n # :param end_op: Operation of a node you would like to get in the end of each Net.\\r\\n # These end_op nodes bring together prediction data based on type of model.\\r\\n # The Class Net end node will have shape [batch_size, num_anchors, num_classes],\\r\\n # and the Box Net end node has the shape [batch_size, num_anchors, 4].\\r\\n # These end nodes can be be found by searching for all end_op's operation nodes and checking if the node two\\r\\n # steps above in the graph has a name that begins with one of head_names for Class Net and Box Net respectively.\\r\\n for node in [node for node in self.graph.nodes if node.op == descendant and head_name in node.name]:\\r\\n target_node = self.graph.find_descendant_by_op(node, end_op)\\r\\n log.info(\\\"Found {} node '{}' as the tip of {}\\\".format(target_node.op, target_node.name, head_name))\\r\\n return target_node\\r\\n\\r\\n def extract_anchors_tensor(split):\\r\\n # This will find the anchors that have been hardcoded somewhere within the ONNX graph.\\r\\n # The function will return a gs.Constant that can be directly used as an input to the NMS plugin.\\r\\n # The anchor tensor shape will be [1, num_anchors, 4]. Note that '1' is kept as first dim, regardless of\\r\\n # batch size, as it's not necessary to replicate the anchors for all images in the batch.\\r\\n\\r\\n # The anchors are available (one per coordinate) hardcoded as constants within certain box decoder nodes.\\r\\n # Each of these four constants have shape [1, num_anchors], so some numpy operations are used to expand the\\r\\n # dims and concatenate them as needed.\\r\\n\\r\\n # These constants can be found by starting from the Box Net's split operation , and for each coordinate,\\r\\n # walking down in the graph until either an Add or specific Mul node is found. The second input on this nodes will\\r\\n # be the anchor data required.\\r\\n\\r\\n # Get Add anchor nodes\\r\\n def get_anchor_add(output_idx, op):\\r\\n node = self.graph.find_descendant_by_op(split.o(0, output_idx), op)\\r\\n assert node\\r\\n val = np.squeeze(node.inputs[1].values)\\r\\n return np.expand_dims(val.flatten(), axis=(0, 2))\\r\\n\\r\\n # Get Mul anchor nodes\\r\\n def get_anchor_mul(name, op):\\r\\n node = [node for node in self.graph.nodes if node.op == op and name == node.name][0]\\r\\n assert node\\r\\n val = np.squeeze(node.inputs[1].values)\\r\\n return np.expand_dims(val.flatten(), axis=(0, 2))\\r\\n\\r\\n \\r\\n anchors_y = get_anchor_add(0, \\\"Add\\\")\\r\\n anchors_x = get_anchor_add(1, \\\"Add\\\")\\r\\n anchors_h = None\\r\\n anchors_w = None\\r\\n\\r\\n # Based on a model type, naming of Mul nodes is slightly different, this will be improved in future to exclude branching.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n anchors_h = get_anchor_mul(\\\"StatefulPartitionedCall/Postprocessor/Decode/mul_1\\\",\\\"Mul\\\")\\r\\n anchors_w = get_anchor_mul(\\\"StatefulPartitionedCall/Postprocessor/Decode/mul\\\",\\\"Mul\\\")\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n anchors_h = get_anchor_mul(\\\"StatefulPartitionedCall/Decode/mul_1\\\",\\\"Mul\\\")\\r\\n anchors_w = get_anchor_mul(\\\"StatefulPartitionedCall/Decode/mul\\\",\\\"Mul\\\") \\r\\n\\r\\n batched_anchors = np.concatenate([anchors_y, anchors_x, anchors_h, anchors_w], axis=2)\\r\\n # Identify num of anchors without repetitions.\\r\\n num_anchors = int(batched_anchors.shape[1]/self.batch_size)\\r\\n # Trim total number of anchors in order to not have copies introduced by growing number of batch_size.\\r\\n anchors = batched_anchors[0:num_anchors,0:num_anchors]\\r\\n return gs.Constant(name=\\\"nms/anchors:0\\\", values=anchors)\\r\\n\\r\\n self.infer()\\r\\n\\r\\n def first_nms(background_class, score_activation, threshold):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the NMS op by BatchedNMS_TRT TensorRT plugin node.\\r\\n :param background_class: Set EfficientNMS_TRT's background_class atribute. \\r\\n :param score_activation: Set EfficientNMS_TRT's score_activation atribute. \\r\\n \\\"\\\"\\\"\\r\\n # Identify Class Net and Box Net head names based on model type.\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n head_names = ['StatefulPartitionedCall/BoxPredictor/ConvolutionalClassHead_', \\r\\n 'StatefulPartitionedCall/BoxPredictor/ConvolutionalBoxHead_']\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n head_names = ['StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalClassHead',\\r\\n 'StatefulPartitionedCall/WeightSharedConvolutionalBoxPredictor/WeightSharedConvolutionalBoxHead']\\r\\n elif (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n head_names = ['StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalClassHead_0/ClassPredictor',\\r\\n 'StatefulPartitionedCall/FirstStageBoxPredictor/ConvolutionalBoxHead_0/BoxEncodingPredictor']\\r\\n\\r\\n class_net = None\\r\\n box_net = None\\r\\n\\r\\n # Getting SSD's Class and Box Nets final tensors.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n # Find the concat node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n\\r\\n # SSD's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\\r\\n slice_start = np.asarray([1], dtype=np.int64)\\r\\n slice_end = np.asarray([91], dtype=np.int64)\\r\\n # Second list element but third tensor dimension.\\r\\n slice_axes = np.asarray([2], dtype=np.int64)\\r\\n slice_out = self.graph.elt_const_slice(\\\"Slice\\\", head_names[0]+\\\"/slicer\\\", class_net.outputs[0], slice_start, slice_end, slice_axes)\\r\\n\\r\\n # Final Class Net tensor.\\r\\n class_net_tensor = slice_out[0]\\r\\n\\r\\n if self.model == 'ssd_mobilenet_v2_keras':\\r\\n # Find the squeeze node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_squeeze = self.graph.find_descendant_by_op(box_net, \\\"Squeeze\\\")\\r\\n box_net_output = box_net_squeeze.outputs[0]\\r\\n\\r\\n elif (self.model == 'ssd_mobilenet_v1_fpn_keras' or self.model == 'ssd_mobilenet_v2_fpn_keras' or \\r\\n self.model == 'ssd_resnet50_v1_fpn_keras' or self.model == 'ssd_resnet101_v1_fpn_keras' or \\r\\n self.model == 'ssd_resnet152_v1_fpn_keras'):\\r\\n # Find the concat node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Concat\\\")\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", box_net_output, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n \\r\\n # Getting Faster R-CNN's 1st Class and Box Nets tensors.\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n if (self.model == 'faster_rcnn_resnet50_keras' or self.model == 'faster_rcnn_resnet101_keras' or \\r\\n self.model == 'faster_rcnn_resnet152_keras' or self.model == \\\"faster_rcnn_inception_resnet_v2_keras\\\"):\\r\\n # Find the softmax node at the end of the class net (multi-scale class predictor).\\r\\n class_net = find_head_end(head_names[0], \\\"Transpose\\\", \\\"Softmax\\\")\\r\\n\\r\\n # Final Class Net tensor\\r\\n class_net_tensor = class_net.outputs[0] \\r\\n\\r\\n # Find the reshape node at the end of the box net (multi-scale localization predictor).\\r\\n box_net = find_head_end(head_names[1], \\\"Transpose\\\", \\\"Reshape\\\")\\r\\n # Final Box Net tensor.\\r\\n box_net_output = box_net.outputs[0]\\r\\n\\r\\n #Insert a squeeze node\\r\\n squeeze_node = self.graph.squeeze(head_names[1]+\\\"/squeeze\\\", box_net_output)\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale box_net_output, in order to get accurate coordinates.\\r\\n scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n scale_out = self.graph.elt_const(\\\"Mul\\\", head_names[1]+\\\"/scale\\\", squeeze_node, scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n box_net_tensor = scale_out[0]\\r\\n\\r\\n\\r\\n # 3. Find the split node that separates the box net coordinates and feeds them into the box decoder.\\r\\n box_net_split = self.graph.find_descendant_by_op(box_net, \\\"Split\\\")\\r\\n assert box_net_split and len(box_net_split.outputs) == 4\\r\\n\\r\\n # Set score threshold\\r\\n score_threshold = self.first_stage_nms_score_threshold if threshold is None else threshold\\r\\n\\r\\n # NMS Inputs and Attributes\\r\\n # NMS expects these shapes for its input tensors:\\r\\n # box_net: [batch_size, number_boxes, 4]\\r\\n # class_net: [batch_size, number_boxes, number_classes]\\r\\n # anchors: [1, number_boxes, 4] (if used)\\r\\n nms_op = None\\r\\n nms_attrs = None\\r\\n nms_inputs = None\\r\\n\\r\\n # EfficientNMS TensorRT Plugin is suitable for our use case.\\r\\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\\r\\n # three inputs are given to the NMS TensorRT node:\\r\\n # - The box predictions (from the Box Net node found above)\\r\\n # - The class predictions (from the Class Net node found above)\\r\\n # - The default anchor coordinates (from the extracted anchor constants)\\r\\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\\r\\n # because this is the internal box coding format used by the network.\\r\\n anchors_tensor = extract_anchors_tensor(box_net_split)\\r\\n nms_inputs = [box_net_tensor, class_net_tensor, anchors_tensor]\\r\\n nms_op = \\\"EfficientNMS_TRT\\\"\\r\\n nms_attrs = {\\r\\n 'plugin_version': \\\"1\\\",\\r\\n 'background_class': background_class,\\r\\n 'max_output_boxes': self.first_stage_max_proposals,\\r\\n 'score_threshold': max(0.01, score_threshold),\\r\\n 'iou_threshold': self.first_stage_nms_iou_threshold,\\r\\n 'score_activation': score_activation,\\r\\n 'box_coding': 1,\\r\\n }\\r\\n nms_output_classes_dtype = np.int32\\r\\n\\r\\n # NMS Outputs.\\r\\n nms_output_num_detections = gs.Variable(name=\\\"num_detections\\\", dtype=np.int32, shape=[self.batch_size, 1])\\r\\n nms_output_boxes = gs.Variable(name=\\\"detection_boxes\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\\r\\n nms_output_scores = gs.Variable(name=\\\"detection_scores\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n nms_output_classes = gs.Variable(name=\\\"detection_classes\\\", dtype=nms_output_classes_dtype,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n\\r\\n nms_outputs = [nms_output_num_detections, nms_output_boxes, nms_output_scores, nms_output_classes]\\r\\n\\r\\n # Create the NMS Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=nms_op,\\r\\n name=\\\"nms/non_maximum_suppression_first\\\",\\r\\n inputs=nms_inputs,\\r\\n outputs=nms_outputs,\\r\\n attrs=nms_attrs)\\r\\n log.info(\\\"Created NMS plugin '{}' with attributes: {}\\\".format(nms_op, nms_attrs))\\r\\n\\r\\n # If model type is SSD, then you are done with conversion and optimizations.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n self.graph.outputs = nms_outputs\\r\\n self.infer()\\r\\n return None\\r\\n # If model is Faster R-CNN, then you continue with conversion and optimizations,\\r\\n # next step is CropAndResize. \\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n return nms_outputs[1]\\r\\n\\r\\n def crop_and_resize(input):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the cropAndResize op by CropAndResize TensorRT plugin node.\\r\\n :param input: Input tensor is the output from previous first_nms() step. \\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\\r\\n # necessary for CropAndResize plugin.\\r\\n relu_name = \\\"StatefulPartitionedCall/model/\\\"\\r\\n relu_node = [node for node in self.graph.nodes if node.op == \\\"Relu\\\" and relu_name in node.name][-1]\\r\\n\\r\\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\\r\\n # Clipping happens for coordinates that are less than 0 and more than self.height.\\r\\n # Normalization is just divison of every coordinate by self.height.\\r\\n clip_min = np.asarray([0], dtype=np.float32)\\r\\n clip_max = np.asarray([self.height], dtype=np.float32)\\r\\n clip_out = self.graph.elt_const_clip(\\\"Clip\\\", \\\"FirstNMS/detection_boxes_clipper\\\", input, clip_min, clip_max)\\r\\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\\r\\n div_out = self.graph.elt_const(\\\"Div\\\", \\\"FirstNMS/detection_boxes_normalizer\\\", clip_out[0], div_const)\\r\\n\\r\\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\\r\\n # to CenterSize encoding.\\r\\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\\r\\n matmul_out = self.graph.elt_const(\\\"MatMul\\\", \\\"FirstNMS/detection_boxes_conversion\\\", div_out[0], matmul_const)\\r\\n\\r\\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\\r\\n # we need to add unsqeeze node to make tensor 4 dimensional. \\r\\n unsqueeze_node = self.graph.unsqueeze( \\\"FirstNMS/detection_boxes_unsqueeze\\\", div_out)\\r\\n\\r\\n # CropAndResizePlugin's inputs \\r\\n feature_maps = relu_node.outputs[0]\\r\\n rois = unsqueeze_node[0]\\r\\n\\r\\n # CropAndResize TensorRT Plugin.\\r\\n # Two inputs are given to the CropAndResize TensorRT node:\\r\\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\\r\\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\\r\\n cnr_inputs = [feature_maps, rois]\\r\\n cnr_op = \\\"CropAndResize\\\"\\r\\n cnr_attrs = {\\r\\n 'crop_width': self.initial_crop_size,\\r\\n 'crop_height': self.initial_crop_size,\\r\\n }\\r\\n\\r\\n # CropAndResize Outputs.\\r\\n cnr_pfmap = gs.Variable(name=\\\"pfmap\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\\r\\n cnr_outputs = [cnr_pfmap]\\r\\n\\r\\n # Create the CropandResize Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=cnr_op,\\r\\n name=\\\"cnr/crop_and_resize\\\",\\r\\n inputs=cnr_inputs,\\r\\n outputs=cnr_outputs,\\r\\n attrs=cnr_attrs)\\r\\n log.info(\\\"Created CropAndResize plugin '{}' with attributes: {}\\\".format(cnr_op, cnr_attrs))\\r\\n\\r\\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\\r\\n # after that is 2nd backbone that leads us to final 2nd NMS.\\r\\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\\r\\n reshape_node = self.graph.elt_const(\\\"Reshape\\\", \\\"StatefulPartitionedCall/CropandResize/reshape\\\", cnr_outputs[0], reshape_shape)\\r\\n maxpl_name = \\\"StatefulPartitionedCall/MaxPool2D/MaxPool\\\"\\r\\n maxpool_node = [node for node in self.graph.nodes if node.op == \\\"MaxPool\\\" and maxpl_name == node.name][0]\\r\\n maxpool_node.inputs[0] = reshape_node[0]\\r\\n\\r\\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \\r\\n # so we need to pass and connect it to 2nd NMS.\\r\\n return matmul_out[0]\\r\\n\\r\\n def second_nms(input, threshold):\\r\\n \\\"\\\"\\\"\\r\\n Updates the graph to replace the 2nd NMS op by BatchedNMS_TRT TensorRT plugin node.\\r\\n :param input: MatMul node that sits between 1st and 2nd NMS nodes.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Identify Class Net and Box Net head names.\\r\\n second_head_names = ['StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_class_head/ClassPredictor_dense',\\r\\n 'StatefulPartitionedCall/mask_rcnn_keras_box_predictor/mask_rcnn_box_head/BoxEncodingPredictor_dense']\\r\\n\\r\\n # Find the softmax node at the end of the 2nd class net (multi-scale class predictor).\\r\\n second_class_net = find_head_end(second_head_names[0], \\\"MatMul\\\", \\\"Softmax\\\")\\r\\n\\r\\n # Faster R-CNN's slice operation to adjust third dimension of Class Net's last node tensor (adjusting class values).\\r\\n slice_start = np.asarray([1], dtype=np.int64)\\r\\n slice_end = np.asarray([91], dtype=np.int64)\\r\\n # Second list element but third tensor dimension.\\r\\n slice_axes = np.asarray([2], dtype=np.int64)\\r\\n slice_out = self.graph.elt_const_slice(\\\"Slice\\\", second_head_names[0]+\\\"/slicer\\\", second_class_net.outputs[0], slice_start, slice_end, slice_axes)\\r\\n\\r\\n # Final Class Net tensor.\\r\\n second_class_net_tensor = slice_out[0]\\r\\n \\r\\n # Find the add node at the end of the box net (multi-scale localization predictor).\\r\\n second_box_net = find_head_end(second_head_names[1], \\\"MatMul\\\", \\\"Add\\\")\\r\\n # Final Box Net tensor.\\r\\n second_box_net_output = second_box_net.outputs[0]\\r\\n\\r\\n # Reshape node that is preparing second_box_net_output's output shape for Mul scaling node that comes next.\\r\\n reshape_shape_second = np.asarray([self.batch_size, self.first_stage_max_proposals, second_box_net.outputs[0].shape[1]], dtype=np.int64)\\r\\n reshape_node_second = self.graph.elt_const(\\\"Reshape\\\", second_head_names[1]+\\\"/reshape\\\", second_box_net_output, reshape_shape_second)\\r\\n # 0.1, 0.1, 0.2, 0.2 are localization head variance numbers, they scale second_box_net_output, in order to get accurate coordinates.\\r\\n second_scale_adj = np.expand_dims(np.asarray([0.1, 0.1, 0.2, 0.2], dtype=np.float32), axis=(0, 1))\\r\\n second_scale_out = self.graph.elt_const(\\\"Mul\\\", second_head_names[1]+\\\"/scale_second\\\", reshape_node_second[0], second_scale_adj)\\r\\n\\r\\n # Final Box Net tensor.\\r\\n second_box_net_tensor = second_scale_out[0]\\r\\n\\r\\n # Set score threshold\\r\\n score_threshold = self.second_score_threshold if threshold is None else threshold\\r\\n\\r\\n # NMS Inputs and Attributes\\r\\n # NMS expects these shapes for its input tensors:\\r\\n # box_net: [batch_size, number_boxes, 4]\\r\\n # class_net: [batch_size, number_boxes, number_classes]\\r\\n # anchors: [1, number_boxes, 4] (if used)\\r\\n second_nms_op = None\\r\\n second_nms_attrs = None\\r\\n second_nms_inputs = None\\r\\n\\r\\n # EfficientNMS TensorRT Plugin is suitable for our use case.\\r\\n # Fusing the decoder will always be faster, so this is the default NMS method supported. In this case,\\r\\n # three inputs are given to the NMS TensorRT node:\\r\\n # - The box predictions (from the Box Net node found above)\\r\\n # - The class predictions (from the Class Net node found above)\\r\\n # - The default anchor coordinates (from the extracted anchor constants)\\r\\n # As the original tensors from given model will be used, the NMS code type is set to 1 (Center+Size),\\r\\n # because this is the internal box coding format used by the network.\\r\\n second_nms_inputs = [second_box_net_tensor, second_class_net_tensor, input]\\r\\n second_nms_op = \\\"EfficientNMS_TRT\\\"\\r\\n second_nms_attrs = {\\r\\n 'plugin_version': \\\"1\\\",\\r\\n 'background_class': -1,\\r\\n 'max_output_boxes': self.first_stage_max_proposals,\\r\\n 'score_threshold': max(0.01, score_threshold),\\r\\n 'iou_threshold': self.second_iou_threshold,\\r\\n 'score_activation': False,\\r\\n 'box_coding': 1,\\r\\n }\\r\\n second_nms_output_classes_dtype = np.int32\\r\\n\\r\\n # NMS Outputs.\\r\\n second_nms_output_num_detections = gs.Variable(name=\\\"second_num_detections\\\", dtype=np.int32, shape=[self.batch_size, 1])\\r\\n second_nms_output_boxes = gs.Variable(name=\\\"second_detection_boxes\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, 4])\\r\\n second_nms_output_scores = gs.Variable(name=\\\"second_detection_scores\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n second_nms_output_classes = gs.Variable(name=\\\"second_detection_classes\\\", dtype=second_nms_output_classes_dtype,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals])\\r\\n\\r\\n second_nms_outputs = [second_nms_output_num_detections, second_nms_output_boxes, second_nms_output_scores, second_nms_output_classes]\\r\\n\\r\\n # Create the NMS Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=second_nms_op,\\r\\n name=\\\"nms/non_maximum_suppression_second\\\",\\r\\n inputs=second_nms_inputs,\\r\\n outputs=second_nms_outputs,\\r\\n attrs=second_nms_attrs)\\r\\n log.info(\\\"Created NMS plugin '{}' with attributes: {}\\\".format(second_nms_op, second_nms_attrs))\\r\\n \\r\\n # Set graph outputs.\\r\\n self.graph.outputs = second_nms_outputs\\r\\n\\r\\n self.infer()\\r\\n\\r\\n # If you model is SSD, you need only one NMS and nothin else.\\r\\n if \\\"ssd\\\" in self.model:\\r\\n first_nms_output = first_nms(-1, True, threshold)\\r\\n # If your model is Faster R-CNN, you will need 2 NMS nodes with CropAndResize in between.\\r\\n elif \\\"faster_rcnn\\\" in self.model:\\r\\n first_nms_output = first_nms(0, False, threshold)\\r\\n cnr_output = crop_and_resize(first_nms_output)\\r\\n second_nms(cnr_output, threshold)\",\n \"def parse_geno_file(folder,return_flag):\\n\\n perc_alt = defaultdict(list)\\n perc_ref = defaultdict(list)\\n abs_alt = defaultdict(list)\\n abs_ref = defaultdict(list)\\n\\n perc_alt_inv = defaultdict(dict)\\n perc_ref_inv = defaultdict(dict)\\n abs_alt_inv = defaultdict(dict)\\n abs_ref_inv = defaultdict(dict)\\n\\n for geno_file in glob.glob(folder+'*_test_summary.tsv'):\\n strain = geno_file.split('/')[-1].split('_')[0]\\n #print strain\\n prev_coordinate = \\\"0\\\"\\n count = 0\\n alt_allele = {}\\n amb_allele = {}\\n ref_allele = {}\\n flag = 0 \\n\\n TEMP_HANDLE = open(geno_file,'r')\\n for line in TEMP_HANDLE:\\n line = line.rstrip('\\\\n')\\n\\n if(line[0]!='v'): ## Skip the header\\n coordinate = line.split('\\\\t')[0].split('::')[-1]\\n if(coordinate != prev_coordinate):\\n #prev_coordinate = coordinate\\n count = count + 1\\n if(count == 1):\\n if(line.split('\\\\t')[-3]!='alt'): ## No reads supporting the alternate allele\\n flag = 1 \\n alt_allele[coordinate] = 0\\n amb_allele[coordinate] = int(line.split('\\\\t')[-1])\\n #print line\\n else:\\n alt_allele[coordinate] = int(line.split('\\\\t')[-1])\\n if(count == 2):\\n amb_allele[coordinate] = int(line.split('\\\\t')[-1])\\n if(count == 3):\\n if(line.split('\\\\t')[-3]!='ref'): ## No reads supporting the reference allele (all are ambiguous)\\n ref_allele[coordinate] = 0\\n else:\\n ref_allele[coordinate] = int(line.split('\\\\t')[-1])\\n prev_coordinate = coordinate\\n count = 0\\n if(flag == 1): ## The case where there are no alternate allele reads, counter is incremented to account for changed numbering\\n count = count + 1 \\n flag = 0 \\n\\n \\n for key in alt_allele:\\n if(alt_allele[key]+ref_allele[key]!= 0): ## Check to see if the denominator is not zero\\n abs_alt[strain].append(float(alt_allele[key]))\\n abs_ref[strain].append(float(ref_allele[key]))\\n perc_alt[strain].append(float(alt_allele[key])/(alt_allele[key]+ref_allele[key]))\\n perc_ref[strain].append(float(ref_allele[key])/(alt_allele[key]+ref_allele[key]))\\n\\n\\n abs_alt_inv[strain][key] = float(alt_allele[key])\\n abs_ref_inv[strain][key] = float(ref_allele[key])\\n perc_alt_inv[strain][key] = float(alt_allele[key])/(alt_allele[key]+ref_allele[key])\\n perc_ref_inv[strain][key] = float(ref_allele[key])/(alt_allele[key]+ref_allele[key])\\n \\n \\n\\n ## Keep only the common inversions, i.e. those between MC and the rest \\n all_inversions = []\\n common_inversions = []\\n abs_alt_set = defaultdict(list)\\n perc_alt_set = defaultdict(list)\\n\\n abs_alt_inv_set = defaultdict(dict)\\n perc_alt_inv_set = defaultdict(dict)\\n abs_ref_inv_set = defaultdict(dict)\\n perc_ref_inv_set = defaultdict(dict)\\n\\n Rock = ['AC', 'CL','CM','CN','TI','PN','MC']\\n Sand = ['MZ','DC','LF','MP','MS','CV']\\n\\n\\n sand_inversions = []\\n rock_inversions = []\\n\\n for strain in abs_alt_inv.keys():\\n for inversion in abs_alt_inv[strain].keys():\\n if(strain in Rock):\\n rock_inversions.append(inversion)\\n else:\\n sand_inversions.append(inversion)\\n all_inversions.append(inversion)\\n \\n \\n common_inversions_sand = Counter(sand_inversions)\\n common_inversions_rock = Counter(rock_inversions)\\n #count_sand = 0\\n common_inversions = Counter(all_inversions)\\n return_inversions = []\\n \\n \\n #print common_inversions\\n for inversion in common_inversions.keys():\\n if(common_inversions[inversion]==13):\\n return_inversions.append(inversion)\\n for strain in abs_alt_inv.keys():\\n abs_alt_set[strain].append(abs_alt_inv[strain][inversion])\\n perc_alt_set[strain].append(perc_alt_inv[strain][inversion])\\n\\n abs_alt_inv_set[strain][inversion] = abs_alt_inv[strain][inversion]\\n perc_alt_inv_set[strain][inversion] = perc_alt_inv[strain][inversion]\\n abs_ref_inv_set[strain][inversion] = abs_ref_inv[strain][inversion]\\n perc_ref_inv_set[strain][inversion] = perc_ref_inv[strain][inversion]\\n\\n\\n for inversion in abs_alt_inv_set['MC']:\\n alternate_allele_sum_rock = 0\\n reference_allele_sum_rock = 0\\n alternate_allele_sum_sand = 0\\n reference_allele_sum_sand = 0 \\n for strain in Rock:\\n alternate_allele_sum_rock = alternate_allele_sum_rock + abs_alt_inv_set[strain][inversion]\\n reference_allele_sum_rock = reference_allele_sum_rock + abs_ref_inv_set[strain][inversion]\\n\\n for strain in Sand:\\n alternate_allele_sum_sand = alternate_allele_sum_sand + abs_alt_inv_set[strain][inversion]\\n reference_allele_sum_sand = reference_allele_sum_sand + abs_ref_inv_set[strain][inversion]\\n\\n abs_alt_set['Rock'].append(alternate_allele_sum_rock)\\n perc_alt_set['Rock'].append(float((alternate_allele_sum_rock)/(alternate_allele_sum_rock + reference_allele_sum_rock)))\\n \\n abs_alt_set['Sand'].append(alternate_allele_sum_sand)\\n perc_alt_set['Sand'].append(float((alternate_allele_sum_sand)/(alternate_allele_sum_sand + reference_allele_sum_sand)))\\n \\n with open('log_file.txt','a') as LOG_FILE:\\n if(float((alternate_allele_sum_rock)/(alternate_allele_sum_rock + reference_allele_sum_rock))>float(sys.argv[2]) or float((alternate_allele_sum_sand)/(alternate_allele_sum_sand + reference_allele_sum_sand))>float(sys.argv[2])):\\n print >> LOG_FILE,inversion \\n \\n\\n print \\\"Sand : \\\"+str(count_sand)\\n\\n if return_flag == True:\\n #print len([abs_alt_inv_set,abs_ref_inv_set,perc_alt_inv_set,perc_ref_inv_set])\\n return perc_alt_inv_set\\n else:\\n return [abs_alt_set,perc_alt_set]\",\n \"def make_control_knowledge(self, horizon):\\n\\n \\\"\\\"\\\" *** YOUR CODE HERE *** \\\"\\\"\\\"\\n\\n # ADD_RULE1_COUNT = 0\\n # ADD_RULE2_COUNT = 0\\n # ADD_RULE3_COUNT = 0\\n\\n close = list()\\n far = list()\\n\\n for g in self.problem.goal:\\n for p in self.problem.propositions:\\n if re.match(r'at\\\\spackage\\\\d+\\\\scity\\\\d+-\\\\d+', str(p)):\\n p_split = str(p).split()\\n g_split = str(g).split()\\n\\n # if \\\"at\\\" and \\\"package[oo]\\\" match\\n if p_split[0] == g_split[0] and p_split[1] == g_split[1]:\\n # also \\\"city[oo]-[xx]\\\" match\\n if p_split[2][:-2] == g_split[2][:-2]:\\n close.append(p)\\n else:\\n far.append(p)\\n\\n # Rule 1:\\n # ===============================\\n # If a package is at its goal location, then it must remain there.\\n # p@t and goal@t) -> p@t+1), where p is at(package, location)\\n # cnf: not p@t or not goal@t or p@t+1\\n\\n for g in self.problem.goal:\\n for t in range(0, horizon):\\n clause = list()\\n clause.append(-self.proposition_fluent_codes[(g, t)])\\n clause.append(self.proposition_fluent_codes[(g, t + 1)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE1_COUNT += 1\\n\\n for t in range(0, horizon):\\n for a in self.problem.actions:\\n\\n # Rule 2\\n # ===============================\\n\\n # RULE\\n # close -> do not load airplane\\n # p1: close@t\\n # p2: at the location of an airport @t\\n # p3: airplane at this location @t\\n # p4: plane is not loaded\\n # a: load this airplane\\n #\\n # p1@t and p2@t and p3@t and p4@t => a@t\\n # not p1@t or not p2@t or not p3@t or not p4@t or a@t\\n # cnf: not p@t or not a@t\\n if str(a).startswith('load-airplane'):\\n for i in close:\\n package = str(i).split()[1]\\n if str(a).split()[1] == package:\\n clause = list()\\n clause.append(\\n -self.proposition_fluent_codes[(i, t)])\\n clause.append(-self.action_fluent_codes[(a, t)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE2_COUNT += 1\\n\\n # Rule 3\\n # ===============================\\n\\n # RULE\\n # far -> do not unload airplane\\n # p@t -> not a@t, where p is far, a is unload-airplane\\n # cnf: not p@t or not a@t\\n if str(a).startswith('unload-airplane'):\\n for j in far:\\n package = str(j).split()[1]\\n if str(a).split()[1] == package:\\n clause = list()\\n clause.append(\\n -self.proposition_fluent_codes[(j, t)])\\n clause.append(-self.action_fluent_codes[(a, t)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE3_COUNT += 1\\n\\n # # RULE\\n # # if an airplane has a package on it and the package's\\n # # destination is close do not fly this airplane.\\n # # in fact, if the destination of package is far,\\n # # fly this plane to it.\\n # #\\n # # p1: package on airplane @ t\\n # # p2: package at a place @ t\\n # # p3: the place and the goal are in the same city\\n # # rule: p1@t and p2@t and p@3 => not fly plane@t\\n # # and unload the plane@t\\n #\\n # # not p1@t or not p2@t or not fly@t\\n # # not p1@t or not p2@t or unload\\n #\\n # # rule: p1@t and p2@t and not p3@t => fly plane@t and not\\n # # unload the plane@t\\n #\\n # if str(a).startswith('fly-airplane'):\\n # plane = str(a).split()[1]\\n # # loc_from = str(a).split()[2]\\n # for p1 in self.problem.propositions:\\n # if str(p1).startswith('in package') and str(p1).split()[2] == plane: # in package plane\\n # package = str(p1).split()[1]\\n # for p2 in self.problem.propositions:\\n # if p2 in close and str(p2).split()[1] == package: # at package location\\n # clause = list()\\n # clause.append(-self.proposition_fluent_codes[p1, t])\\n # clause.append(-self.proposition_fluent_codes[p2, t])\\n # clause.append(-self.action_fluent_codes[a, t])\\n # self.add_clause(clause, 'control')\\n # ADD_RULE2_COUNT += 1\\n #\\n #\\n # for g in self.problem.goal:\\n # if str(g).split()[1] == package:\\n # destination = str(g).split()[2]\\n # for do in self.problem.actions:\\n # # unload-airplane package00 plane00 city00-00\\n # if str(do).startswith('unload') and str(do).split()[1] == package and str(do).split()[2] == plane and str(do).split()[3] == destination:\\n # clause2 = list()\\n # clause2.append(-\\n # self.proposition_fluent_codes[\\n # p1, t])\\n # clause2.append(-\\n # self.proposition_fluent_codes[\\n # p2, t])\\n # clause2.append(\\n # self.action_fluent_codes[\\n # do, t])\\n # self.add_clause(clause2,\\n # 'control')\\n #\\n # ADD_RULE3_COUNT += 1\\n\\n # RULE\\n # if there is no package needs to be transferred at a location,\\n # and the location has a truck\\n # drive the truck to its airport\\n\\n # p1: (at package__ city__-__ /\\\\ (it is a goal)@t\\n # p2: (at truck__ city__-__)@t\\n # p3: (city__-__ is not airport)\\n # not p1/\\\\p2/\\\\p3 => drive_truck_to_its_airport@t\\n #\\n #\\n # CNF: p1 V not p2 V not p3 V drive_truck_to_its_airport@t\\n # if str(a).startswith('DRIVE-TRUCK'):\\n # for p1 in self.problem.goal:\\n # city = str(p1).split()[2]\\n # for p2 in self.problem.propositions:\\n # if str(p2).startswith('at truck') and str(p2).split()[2] == city:\\n # for p3 in self.problem.propositions:\\n # if str(p3).startswith('airport') and str(p3).split()[1] == city:\\n # clause = list()\\n # clause.append(self.proposition_fluent_codes[(p1, t)])\\n # clause.append(-self.proposition_fluent_codes[(p2, t)])\\n # clause.append(-self.proposition_fluent_codes[(p3, t)])\\n # clause.append(self.action_fluent_codes[(a, t)])\\n # self.add_clause(clause, \\\"control\\\")\\n\\n # RULE\\n # if there is an airplane is loaded with a package need\\n # transfer (to another city), fly airplane to the corresponding\\n # city.\\n\\n # p1: (at airplane__ city__-__)@t\\n # p2: (in package__ airplane__)@t\\n # p3: ( p2 is in far)\\n # p1/\\\\p2/\\\\p3 => fly_airplane_to_its_airport@t\\n #\\n #\\n # CNF: not p1@t V not p2@t V not p3@t V fly_plane_to_airport@t\\n\\n # print(\\\"ADDED RULE 1:\\\")\\n # print(ADD_RULE1_COUNT)\\n #\\n # print(\\\"ADDED RULE 2:\\\")\\n # print(ADD_RULE2_COUNT)\\n #\\n # print(\\\"ADDED RULE 3:\\\")\\n # print(ADD_RULE3_COUNT)\",\n \"def ica(n_components, ecg_ch_name, eog_ch_name):\\n from neuropype_ephy.interfaces.mne.preproc import CompIca\\n ica_node = pe.Node(interface=CompIca(), name='ica')\\n ica_node.inputs.n_components = n_components\\n ica_node.inputs.ecg_ch_name = ecg_ch_name\\n ica_node.inputs.eog_ch_name = eog_ch_name\\n return ica_node\",\n \"def finetune_acceptor_boundaries(abfgp_genemodel,introndata,\\n array_algpresence,array_algsimilarity,verbose=True):\\n\\n # Global Variable Imports\\n from settings.genestructure import MIN_INTRON_NT_LENGTH\\n FINETUNE_ACCEPTOR_NT_OFFSET = 18\\n\\n # list with adjusted boundaries\\n refined_boundaries = []\\n\\n # recreate lists of ABGFP exons & introns\\n abfgp_exons = [ abfgp_genemodel[pos] for pos in range(0,len(abfgp_genemodel),2) ]\\n abfgp_introns = [ abfgp_genemodel[pos] for pos in range(1,len(abfgp_genemodel),2) ]\\n\\n for intron_pos in range(0,len(abfgp_introns)):\\n intron = abfgp_introns[intron_pos]\\n if not intron: continue\\n if intron.__class__.__name__ == 'SequenceErrorConnectingOrfs': continue\\n\\n # assign branchpoint in current intron\\n intron.assign_bp_and_ppts()\\n\\n has_been_printed = False\\n\\n # list of alternatives & associated scores\\n alternatives = []\\n finetune_range = range(intron.acceptor.pos-FINETUNE_ACCEPTOR_NT_OFFSET,\\n intron.acceptor.pos+FINETUNE_ACCEPTOR_NT_OFFSET+1,3)\\n\\n for acceptor in intron.orfAcceptor._acceptor_sites:\\n if acceptor.pos != intron.acceptor.pos and\\\\\\n acceptor.pos in finetune_range:\\n # get the next exon (3'of this intron)\\n next_exon = abfgp_exons[intron_pos+1]\\n if not has_been_printed:\\n has_been_printed = True\\n ############################################################\\n if verbose: print \\\"FINETUNING ACCEPTOR::\\\", intron\\n ############################################################\\n\\n # get data on this alternative acceptor position\\n test_intron = IntronConnectingOrfs(intron.donor,acceptor,None,intron.orfDonor,intron.orfAcceptor)\\n test_intron.assign_bp_and_ppts()\\n\\n # test if refinement will result in a long enough intron\\n if test_intron.length < MIN_INTRON_NT_LENGTH: continue\\n\\n scorelist = []\\n # score 1: is acceptor.pssm_score `higher`?\\n scorelist.append( _finetune_splicesite_comparison(intron.acceptor,test_intron.acceptor) )\\n # score 2: branchpoint comparison?\\n scorelist.append( _branchpoint_comparison(intron,test_intron) )\\n # score 3: ppt comparison?\\n scorelist.append( _polypyrimidinetract_comparison(intron,test_intron) )\\n # score 4: is algsimilarity ratio increased (==better)?\\n scorelist.append( _algsimilarity_comparison(intron,test_intron,None,next_exon,array_algsimilarity) )\\n\\n # evaluate scorelist; improved intron boundary or not?\\n # use acceptor, branchpoint & ppt, do *NOT* use algsim score\\n if scorelist[0:3].count(False) == 0 and scorelist[0:3].count(True) >= 1:\\n alternatives.append( ( acceptor, scorelist ) )\\n is_accepted = True\\n else:\\n is_accepted = False\\n\\n ################################################################\\n if verbose:\\n print \\\"alternative:\\\", acceptor,\\n print intron.acceptor.pos - acceptor.pos, scorelist,\\n print is_accepted, \\\"BP:\\\",\\n print intron.get_branchpoint_nt_distance(),\\n print \\\"alt:\\\",\\n print test_intron.get_branchpoint_nt_distance()\\n ################################################################\\n\\n # now evaluate the alternatived and take the best one\\n if not alternatives:\\n continue\\n elif len(alternatives) == 1:\\n refined_boundaries.append( ( intron.acceptor, alternatives[0][0] ) )\\n else:\\n # multiple! again, take the *best* one\\n pass\\n\\n # return list of refined_boundaries\\n return refined_boundaries\",\n \"def genPrimerPairs_5Ext(primer_length=20, anneal_length=10, GC_low=40, GC_high=60):\\n\\n print('Primers for 5\\\\' extension half-asstemers')\\n\\n forwTemplate5_3 = GenOligoGC(primer_length,GC_low, GC_high)\\n \\\"\\\"\\\"re.match checks if the first 2 Nuc are GC in the forward and backwards direction\\\"\\\"\\\"\\n while not (re.match(\\\"[GC]{2}\\\",str(forwTemplate5_3)) and\\n re.match(\\\"[GC]{2}\\\", str(forwTemplate5_3[::-1])) and\\n re.match(\\\"[GC]{2}\\\", str(forwTemplate5_3[10:12]))):\\n\\n forwTemplate5_3 = GenOligoGC(primer_length,GC_low, GC_high)\\n\\n forwTemp3_5 = forwTemplate5_3[::-1]\\n forwPrimer5_3 = forwTemp3_5.complement()\\n print(f\\\"Template Seq 3\\\\' - > 5\\\\': {forwTemp3_5}\\\")\\n print(f\\\"ForwPrimer Seq 5\\\\' - > 3\\\\': {forwPrimer5_3}\\\")\\n\\n forwPrimer_f10 = forwPrimer5_3[:10]\\n print(f\\\"First 10 Nucleotides of forward primer: {forwPrimer_f10}\\\")\\n\\n revPrimer_f10 = GenOligoGC(10,GC_low, GC_high)\\n while not re.match(\\\"[GC]{2}\\\",str(revPrimer_f10)):\\n revPrimer_f10 = GenOligoGC(10,GC_low, GC_high)\\n\\n revPrimer5_3 = revPrimer_f10 + forwPrimer_f10\\n\\n print(f\\\"RevPrimer Seq 5\\\\' - > 3\\\\': {revPrimer5_3}\\\")\\n\\n return forwPrimer5_3, revPrimer5_3\",\n \"def part_one():\\n return \\\"\\\".join(networkx.lexicographical_topological_sort(G))\",\n \"def _graph_priority(self, nodes):\\n \\n fakes = self.fakes(nodes)\\n \\n # There theoretically should only be one fake per subgraph\\n if len(fakes) == 1:\\n return fakes[0]\\n\\n # If for some reason there is more, its likely due to poor indexes and just pick one\\n elif len(fakes) > 1:\\n logger.error('More Than One Fake Node In Subgraph {}, \\\\\\n Paths between fake nodes results in unreliable sequence!'.format(fakes))\\n return np.random.choice(fakes)\\n\\n # If there is no fake node in the subgraph, its not close to infastructure and thus priority is given to MAX(priority metric)\\n else:\\n return self.metrics[self.priority_metric].ix[nodes].idxmax()\",\n \"def create_GO(init_file, no_COOH, no_epoxy, no_OH, filename1):\\n global atoms\\n global bond_list\\n bond_list = bond_list_1\\n atoms = read_in_graphene(init_file)\\n global anywhere_map\\n anywhere_map = get_map_anywhere(atoms)\\n global edge_map\\n edge_map = get_map_edge(atoms)\\n \\n list_residue_numbers = [x.residue_number for x in atoms]\\n added_functional_groups = max(list_residue_numbers)\\n \\n must_add = no_COOH + no_epoxy + no_OH\\n while (must_add > 0):\\n print(\\\"Left to add: \\\", \\\"cooh: \\\", no_COOH, \\\"epoxy: \\\", no_epoxy, \\\"hydroxyl: \\\", no_OH)\\n chosen = random.choice(pick_to_add(no_COOH, no_epoxy, no_OH))\\n if (chosen == \\\"carboxyl\\\"):\\n attempt = 0\\n while (attempt < 50):\\n old_length = len(atoms)\\n new_atoms = add_carboxyl(random_pick_spot(\\\"carboxyl\\\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\\n if (old_length != len(new_atoms)):\\n atoms = new_atoms\\n added_functional_groups += 1\\n must_add -= 1\\n no_COOH -= 1\\n attempt = 1888\\n else:\\n attempt += 1\\n if (attempt == 50):\\n must_add = -1\\n elif (chosen == \\\"epoxy\\\"): \\n attempt = 0\\n while (attempt < 50):\\n old_length = len(atoms)\\n new_atoms = add_epoxy(random_pick_spot(\\\"epoxy\\\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\\n if (old_length != len(new_atoms)):\\n atoms = new_atoms\\n added_functional_groups += 1\\n must_add -= 1\\n no_epoxy -= 1\\n attempt = 1888\\n else:\\n attempt += 1\\n if (attempt == 50):\\n must_add = -1\\n elif (chosen == \\\"hydroxyl\\\"):\\n attempt = 0\\n while (attempt < 50):\\n old_length = len(atoms)\\n new_atoms = add_hydroxyl(random_pick_spot(\\\"hydroxyl\\\", edge_map, anywhere_map), atoms, added_functional_groups, top_or_down())\\n if (old_length != len(new_atoms)):\\n atoms = new_atoms\\n added_functional_groups += 1\\n must_add -= 1\\n no_OH -=1\\n attempt = 1888 \\n else:\\n attempt += 1\\n if (attempt == 50):\\n must_add = -1\\n atno = 1\\n new_list = []\\n for atom in atoms:\\n if (atom.atom_name == \\\"CX\\\"):\\n New_CX = Atom(atno, \\\"CX\\\", \\\"GGG\\\", atno, atom.x, atom.y, atom.z)\\n new_list.append(New_CX)\\n atno += 1 \\n \\n for atom in atoms:\\n if (atom.atom_name == \\\"C4\\\"):\\n check = False\\n for atom_CY in atoms:\\n if ((atom_CY.atom_name == \\\"CY\\\") and (atom_CY.residue_name == \\\"C1A\\\") and (atom_CY.residue_number == atom.residue_number)):\\n for atom_OJ in atoms:\\n if ((atom_OJ.atom_name == \\\"OJ\\\") and (atom_OJ.residue_name == \\\"C1A\\\") and (atom_OJ.residue_number == atom.residue_number)):\\n for atom_OK in atoms:\\n if ((atom_OK.atom_name == \\\"OK\\\") and (atom_OK.residue_name == \\\"C1A\\\") and (atom_OK.residue_number == atom.residue_number)):\\n for atom_HK in atoms:\\n if ((atom_HK.atom_name == \\\"HK\\\") and (atom_HK.residue_name == \\\"C1A\\\") and (atom_HK.residue_number == atom.residue_number)):\\n New_CY = Atom(atno + 0, \\\"CY\\\", \\\"C1A\\\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z )\\n New_C4 = Atom(atno + 1, \\\"C4\\\", \\\"C1A\\\", atom.residue_number, atom.x, atom.y, atom.z)\\n New_OJ = Atom(atno + 2, \\\"OJ\\\", \\\"C1A\\\", atom.residue_number, atom_OJ.x, atom_OJ.y, atom_OJ.z)\\n New_OK = Atom(atno + 3, \\\"OK\\\", \\\"C1A\\\", atom.residue_number, atom_OK.x, atom_OK.y, atom_OK.z)\\n New_HK = Atom(atno + 4, \\\"HK\\\", \\\"C1A\\\", atom.residue_number, atom_HK.x, atom_HK.y, atom_HK.z)\\n atno += 5\\n new_list.append(New_CY); new_list.append(New_C4); new_list.append(New_OJ); new_list.append(New_OK); new_list.append(New_HK);\\n check = True\\n break\\n if (check == True):\\n break\\n if (check == True):\\n break\\n if (check == True):\\n break \\n \\n elif (atom.atom_name == \\\"OE\\\"): \\n check = False\\n for atom_CY in atoms:\\n if ((atom_CY.atom_name == \\\"CY\\\") and (atom_CY.residue_name == \\\"E1A\\\") and (atom_CY.residue_number == atom.residue_number)):\\n for atom_CY2 in atoms: \\n if ((atom_CY2.atom_name == \\\"CZ\\\") and (atom_CY2.residue_name == \\\"E1A\\\") and (atom_CY2.residue_number == atom.residue_number) and (atom_CY2 != atom_CY)):\\n New_CY = Atom( atno + 0, \\\"CY\\\", \\\"E1A\\\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z)\\n New_CY2 = Atom(atno + 1, \\\"CZ\\\", \\\"E1A\\\", atom.residue_number, atom_CY2.x, atom_CY2.y, atom_CY2.z)\\n New_OE = Atom( atno + 2, \\\"OE\\\", \\\"E1A\\\", atom.residue_number, atom.x, atom.y, atom.z)\\n atno += 3\\n new_list.append(New_CY); new_list.append(New_CY2); new_list.append(New_OE);\\n check = True\\n break\\n if (check == True):\\n break\\n elif (atom.atom_name == \\\"OL\\\"):\\n check = False\\n for atom_CY in atoms:\\n if ((atom_CY.atom_name == \\\"CY\\\") and (atom_CY.residue_name == \\\"H1A\\\") and (atom_CY.residue_number == atom.residue_number)):\\n for atom_HK in atoms:\\n if ((atom_HK.atom_name == \\\"HK\\\") and (atom_HK.residue_name == \\\"H1A\\\") and (atom_HK.residue_number == atom.residue_number)):\\n New_CY = Atom(atno + 0, \\\"CY\\\", \\\"H1A\\\", atom.residue_number, atom_CY.x, atom_CY.y, atom_CY.z)\\n New_OL = Atom(atno + 1, \\\"OL\\\", \\\"H1A\\\", atom.residue_number, atom.x, atom.y, atom.z)\\n New_HK = Atom(atno + 2, \\\"HK\\\", \\\"H1A\\\", atom.residue_number, atom_HK.x, atom_HK.y, atom_HK.z)\\n atno += 3\\n new_list.append(New_CY); new_list.append(New_OL); new_list.append(New_HK);\\n check = True\\n break\\n if (check == True):\\n break\\n \\n atoms = new_list.copy()\\n writepdb(atoms, filename1)\\n sum_c1a = 0; sum_e1a = 0; sum_h1a = 0; sum_ggg = 0\\n for atom in atoms:\\n if (atom.residue_name == \\\"C1A\\\"):\\n sum_c1a += 1\\n elif (atom.residue_name == \\\"E1A\\\"):\\n sum_e1a += 1\\n elif (atom.residue_name == \\\"H1A\\\"):\\n sum_h1a += 1\\n elif (atom.residue_name == \\\"GGG\\\"):\\n sum_ggg += 1\\n print(\\\"Placed:\\\")\\n print(\\\"carboxyl: \\\", sum_c1a/5)\\n print(\\\"epoxy: \\\", sum_e1a/3)\\n print(\\\"hydroxyl: \\\", sum_h1a/3)\\n print(\\\"graphene atoms (CX - GGG) left: \\\", sum_ggg)\\n return 'done.'\",\n \"def aco(self, gens, current_gen, client):\\n # The time at the start of the algorithm\\n time_start = time.time()\\n\\n # Initalise the colony and its parameters\\n self.colony = Colony()\\n self.colony.ants = self.ants\\n self.colony.shortest_path = self.shortest_path\\n self.colony.min_distance = self.min_distance\\n\\n # Initialise an array to be append with nodes\\n shortest_path = []\\n\\n # Do generations from the current generation to the generation number needed\\n for i in range(current_gen, gens):\\n\\n # The current time\\n time_now = time.time()\\n time_elapsed = time_now-time_start\\n # If exectutiion time has reached 25 seconds, return result\\n if (time_elapsed) > 25:\\n break\\n\\n # Ants within colony perform their tours\\n self.colony.perform_tours(self)\\n\\n # Get the shortest tour found by the ants\\n shortest_path = self.colony.shortest_path\\n\\n # Global update of pheromones\\n self.update_pheromones(self.colony)\\n\\n # Generation successful, thus increase the generation reached\\n gen_reached = i+1\\n\\n # Update Instance parameters to be returned to client\\n self.shortest_path = shortest_path\\n self.min_distance = self.colony.min_distance\\n msg = \\\"Generation \\\" + str(i) + \\\" distance \\\" + str(round(self.colony.min_distance, 3)) + \\\" path \\\" + str(shortest_path)\\n\\n # Emit a message using SocketIO for a dynamic console\\n socketio.emit('my event', msg, room=client)\\n socketio.sleep(0.00000000001)\\n\\n return gen_reached, shortest_path, self.colony.min_distance\",\n \"def test_get_top_step_matches(self):\\n\\n results = GenomePropertiesResultsWithMatches(*self.test_genome_property_results, properties_tree=self.test_tree)\\n\\n self.assertEqual(len(results._top_step_matches), 2)\\n\\n cad3_top_matches = results.get_sample_matches('C_chlorochromatii_CaD3', top=True)\\n dsm_273_top_matches = results.get_sample_matches('C_luteolum_DSM_273', top=True)\\n\\n self.assertEqual(len(cad3_top_matches), 1)\\n self.assertEqual(len(dsm_273_top_matches), 1)\\n\\n self.assertEqual(cad3_top_matches['Protein_Accession'].tolist()[0], 'NC_007514.1_940')\\n self.assertEqual(dsm_273_top_matches['Protein_Accession'].tolist()[0], 'NC_007512.1_1088')\",\n \"def add_initial_side_chains_from_propensities(\\n self, G, raw_or_rank, test=False, input_num={}\\n ):\\n\\n # Initialises dictionary of starting sequences\\n initial_networks = OrderedDict()\\n ids_list = []\\n for num in range(2*self.pop_size):\\n unique_id = ''.join(\\n [random.choice(string.ascii_letters + string.digits)\\n for i in range(10)]\\n )\\n initial_networks[unique_id] = copy.deepcopy(G)\\n ids_list.append(unique_id)\\n\\n # Extracts individual amino acid propensity scales for the surface\\n intext_index = self.dict_name_indices['intorext']\\n eoc_index = self.dict_name_indices['edgeorcent']\\n prop_index = self.dict_name_indices['prop1']\\n pairindv_index = self.dict_name_indices['pairorindv']\\n discorcont_index = self.dict_name_indices['discorcont']\\n proporfreq_index = self.dict_name_indices['proporfreq']\\n dicts = OrderedDict({\\n dict_label: scale_dict for dict_label, scale_dict in\\n {**self.propensity_dicts, **self.frequency_dicts}.items()\\n if dict_label.split('_')[pairindv_index] == 'indv'\\n })\\n\\n for node_index, node in enumerate(list(G.nodes())):\\n if G.nodes()[node]['type'] == 'loop':\\n continue\\n\\n int_ext = G.nodes()[node]['int_ext']\\n sub_dicts = OrderedDict(\\n {dict_label: scale_dict for dict_label, scale_dict in dicts.items()\\n if dict_label.split('_')[intext_index] in [int_ext, '-']}\\n )\\n if self.barrel_or_sandwich == '2.60':\\n # Filters propensity and frequency scales depending upon\\n # whether the node is in an edge or a central strand\\n eoc = G.nodes()[node]['eoc']\\n sub_dicts = OrderedDict(\\n {dict_label: scale_dict for dict_label, scale_dict in sub_dicts.items()\\n if dict_label.split('_')[eoc_index] in [eoc, '-']}\\n )\\n\\n if sub_dicts == {}:\\n if test is True: # Avoids code crashing if e.g. there are no\\n # dicts for ext residues\\n continue\\n else:\\n raise ValueError('No propensity or scoring metrics '\\n 'available for node {}'.format(node))\\n\\n # Calculates summed propensity for each amino acid across all\\n # structural features considered in the design process\\n node_indv_propensities = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\\n node_indv_frequencies = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\\n\\n for dict_index, dict_label in enumerate(list(sub_dicts.keys())):\\n scale_dict = sub_dicts[dict_label]\\n dict_weight = self.dict_weights[dict_label]\\n node_prop = dict_label.split('_')[prop_index]\\n node_val = np.nan\\n\\n if node_prop != '-':\\n try:\\n node_val = G.nodes()[node][node_prop]\\n except KeyError:\\n raise KeyError('{} not defined for node {}'.format(node_prop, node))\\n # Converts non-float values into np.nan\\n if node_val in ['', 'nan', 'NaN', np.nan]:\\n node_val = np.nan\\n\\n value = np.nan\\n if dict_label.split('_')[discorcont_index] == 'cont' and not np.isnan(node_val):\\n if dict_label.split('_')[proporfreq_index] != 'propensity':\\n raise Exception(\\n 'Unexpected dictionary {} - expect only continuous '\\n 'propensity dictionaries'.format(dict_label)\\n )\\n\\n # Interpolate dictionary\\n for aa, aa_scale in scale_dict.items():\\n aa_index = self.aa_list.index(aa)\\n value = linear_interpolation(node_val, aa_scale, dict_label)\\n\\n if value <= 0:\\n raise ValueError(\\n '{} returned after interpolation of {} for node'\\n ' {}'.format(value, dict_label, node)\\n )\\n\\n if np.isnan(value):\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n value = 0.0001 # Since dataset used to generate\\n # prop and freq dicts is ~10,000 aas => smallest\\n # propensity could be is ((1/5000)/(5001/10000)\\n # = 0.0004 (for a discrete propensity))\\n\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n node_indv_propensities[dict_index][aa_index] = (\\n dict_weight*np.negative(np.log(value))\\n )\\n\\n elif dict_label.split('_')[discorcont_index] == 'disc':\\n # Filter dataframe\\n scale_dict_copy = copy.deepcopy(scale_dict).set_index('FASTA', drop=True)\\n for aa_index, aa in enumerate(self.aa_list):\\n if node_prop == '-':\\n try:\\n value = scale_dict_copy.iloc[:,0][aa]\\n except KeyError:\\n raise Exception('{} not defined in {}'.format(aa, dict_label))\\n elif node_prop == 'phipsi':\\n if not np.isnan(node_val):\\n try:\\n value = scale_dict_copy[node_val][aa]\\n except KeyError:\\n raise Exception('{},{} not defined in {}'.format(\\n node_val, aa, dict_label\\n ))\\n\\n if value <= 0:\\n raise ValueError(\\n '{} returned after interpolation of {} for node'\\n ' {}'.format(value, dict_label, node)\\n )\\n\\n if np.isnan(value):\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n value = 0.0001 # Since dataset used to generate\\n # prop and freq dicts is ~10,000 aas => smallest\\n # propensity could be is ((1/5000)/(5001/10000)\\n # = 0.0004 (for a discrete propensity))\\n else:\\n value = 0\\n\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n node_indv_propensities[dict_index][aa_index] = (\\n dict_weight*np.negative(np.log(value))\\n )\\n elif dict_label.split('_')[proporfreq_index] == 'frequency':\\n node_indv_frequencies[dict_index][aa_index] = dict_weight*value\\n\\n # Sums propensity and frequency values, then filters to remove amino\\n # acids with a propensity / frequency of 0\\n node_indv_propensities = np.nansum(node_indv_propensities, axis=0)\\n node_indv_frequencies = np.nansum(node_indv_frequencies, axis=0)\\n\\n if (\\n set(node_indv_propensities) == {0}\\n or (self.frequency_dicts != {} and set(node_indv_frequencies) == {0})\\n ):\\n raise Exception('Cannot select side chain identity for node '\\n '{}'.format(node))\\n\\n # Removes aas for which all propensity and/or frequency readings (as\\n # appropriate) are np.nan\\n filt_aa_list = []\\n filt_node_prop = []\\n filt_node_freq = []\\n for aa_index, aa in enumerate(self.aa_list):\\n prop = node_indv_propensities[aa_index]\\n freq = node_indv_frequencies[aa_index]\\n if (\\n (self.frequency_dicts == {} and prop == 0)\\n or (self.frequency_dicts != {} and prop == 0 and freq == 0)\\n ):\\n continue\\n filt_aa_list.append(aa)\\n filt_node_prop.append(prop)\\n filt_node_freq.append(freq)\\n filt_aa_list = np.array(filt_aa_list)\\n filt_node_prop = np.array(filt_node_prop)\\n filt_node_freq = np.array(filt_node_freq)\\n\\n # Converts propensities and frequencies into probability\\n # distributions\\n (node_prop_index, node_prop, node_prop_probabilities\\n ) = calc_probability_distribution(\\n node_indv_propensities, 'propensity', raw_or_rank, test\\n )\\n node_prop_index = node_prop_index.astype(int)\\n if self.frequency_dicts != {}:\\n (node_freq_index, node_freq, node_freq_probabilities\\n ) = calc_probability_distribution(\\n filt_node_freq, 'frequency', raw_or_rank, test\\n )\\n else:\\n node_freq_index = copy.deepcopy(node_prop_index)\\n node_freq = np.full(filt_node_freq.shape, 0)\\n node_freq_probabilities = np.full(filt_node_freq.shape, 0)\\n node_freq_index = node_freq_index.astype(int)\\n\\n node_probabilities = np.full(node_prop_probabilities.shape, np.nan)\\n for index_prop, aa in np.ndenumerate(copy.deepcopy(node_prop_index)):\\n index_freq = np.where(node_freq_index == aa)[0][0]\\n propensity = node_prop_probabilities[index_prop]\\n frequency = node_freq_probabilities[index_freq]\\n\\n # Since propensity_weight is a hyperparameter to be optimised\\n # with hyperopt, for initial sequence generation the propensity\\n # and frequency scales are weighted equally (unless not\\n # performing hyperparameter optimisation, in which case use the\\n # propensity_weight specified in the input file)\\n try:\\n prop_weight = self.propensity_weight\\n freq_weight = 1 - self.propensity_weight\\n except AttributeError:\\n prop_weight = 0.5\\n freq_weight = 0.5\\n probability = (prop_weight*propensity) + (freq_weight*frequency)\\n node_probabilities[index_prop] = probability\\n filt_aa_list = filt_aa_list[node_prop_index]\\n node_cumulative_probabilities = gen_cumulative_probabilities(\\n node_probabilities, node\\n )\\n\\n # Selects amino acid weighted by its probability\\n for unique_id in ids_list:\\n if test is False:\\n random_number = random.uniform(0, 1)\\n elif test is True:\\n random_number = input_num[node]\\n nearest_index = (np.abs(node_cumulative_probabilities-random_number)).argmin()\\n\\n if node_cumulative_probabilities[nearest_index] >= random_number:\\n selected_aa = filt_aa_list[nearest_index]\\n else:\\n selected_aa = filt_aa_list[nearest_index+1]\\n\\n nx.set_node_attributes(\\n initial_networks[unique_id],\\n values={'{}'.format(node): {'aa_id': '{}'.format(selected_aa)}}\\n )\\n\\n return initial_networks\",\n \"def localization(Gint, focal_genes, num_reps = 10, sample_frac = 0.8, method = 'numedges', plot = True, print_counter = False,\\n background_list=None):\\n\\n # Create degree bins to sample from\\n bins = get_degree_binning(Gint, 10)\\n min_degree, max_degree, genes_binned = zip(*bins)\\n bin_df = pd.DataFrame({'min_degree':min_degree, 'max_degree':max_degree, 'genes_binned':genes_binned})\\n \\n # create a lookup table for degree and index\\n actual_degree_to_bin_df_idx = {}\\n for i in range(0, bin_df['max_degree'].max() + 1):\\n idx_temp = bin_df[ (bin_df['min_degree'].lt(i + 1)) & (bin_df['max_degree'].gt(i - 1)) ].index.tolist()\\n\\n if len(idx_temp) > 0: # there are some degrees which aren't represented in the graph\\n actual_degree_to_bin_df_idx[i] = idx_temp[0]\\n \\n focal_genes = list(np.intersect1d(focal_genes, Gint.nodes())) # only use focal_genes which are in Gint\\n\\n numedges_list = []\\n numedges_rand = []\\n LCC_list = []\\n LCC_rand = []\\n \\n if background_list==None:\\n background_list=Gint.nodes()\\n \\n for r in range(num_reps):\\n\\n if print_counter == True:\\n # so user knows how far along the process is\\n if (r % 25) == 0:\\n print(r)\\n\\n focal_80 = focal_genes\\n np.random.shuffle(focal_80)\\n focal_80 = focal_80[:int(len(focal_80)*sample_frac)]\\n\\n # find genes with similar degrees to focal gene degree\\n seed_random = []\\n for g in focal_80:\\n degree_temp = nx.degree(Gint,g)\\n genes_temp = bin_df.loc[actual_degree_to_bin_df_idx[degree_temp]]['genes_binned'] # use the lookup table for speed\\n np.random.shuffle(genes_temp) # shuffle them\\n while (genes_temp[0] in seed_random) or (genes_temp[0] not in background_list): # make sure the gene isn't already in the list, but is in the background_list\\n np.random.shuffle(genes_temp) # shuffle them\\n \\n seed_random.append(genes_temp[0]) # build the seed_D1_random list\\n \\n #print(len(focal_80))\\n #print(len(seed_random))\\n #print(len(np.unique(seed_random)))\\n\\n if (method == 'numedges') or (method == 'both'):\\n \\n # number edges calc on focal set\\n numedges_temp = len(nx.subgraph(Gint,focal_80).edges())\\n numedges_list.append(numedges_temp)\\n \\n # number edges calc on random sample\\n numedges_temp_rand = len(nx.subgraph(Gint,seed_random).edges())\\n numedges_rand.append(numedges_temp_rand)\\n \\n if (method == 'LCC') or (method == 'both'):\\n \\n # LLC calc on focal set\\n G_sub_temp = nx.Graph(nx.subgraph(Gint, focal_80))\\n G_sub_temp = max(nx.connected_component_subgraphs(G_sub_temp), key = len)\\n LCC_list.append(len(G_sub_temp.nodes()))\\n \\n # LLC calc on random sample\\n G_sub_temp = nx.Graph(nx.subgraph(Gint, seed_random))\\n G_sub_temp = max(nx.connected_component_subgraphs(G_sub_temp), key=len)\\n LCC_rand.append(len(G_sub_temp.nodes()))\\n \\n if plot == True:\\n if (method == 'numedges') or (method == 'both'):\\n fig, ax = plt.subplots(figsize = (12, 7))\\n sns.distplot(numedges_list, ax = ax, hist = True, label = 'focal genes')\\n sns.distplot(numedges_rand, ax = ax, hist = True, label = 'random set')\\n plt.ylabel('frequency', fontsize = 16)\\n plt.xlabel('number of edges', fontsize = 16)\\n plt.title('Number of Edges Localization', fontsize = 18)\\n plt.legend(loc = 'upper right', fontsize = 14)\\n \\n if (method == 'LCC') or (method == 'both'):\\n fig, ax = plt.subplots(figsize = (12, 7))\\n sns.distplot(LCC_list, ax = ax, hist = True, label = 'focal genes')\\n sns.distplot(LCC_rand, ax = ax, hist = True, label = 'random set')\\n plt.ylabel('frequency', fontsize = 16)\\n plt.xlabel('largest connected component size', fontsize = 16)\\n plt.title('Largest Connected Component Localization', fontsize = 18)\\n plt.legend(loc = 'upper right', fontsize = 14)\\n \\n return numedges_list, numedges_rand, LCC_list, LCC_rand\",\n \"def get_cuckoos(nest, best, Lb, Ub):\\n\\tn = nest.shape[0]\\n\\tbeta=3/2;\\n\\tsigma=(sp.gamma(1+beta)*np.sin(np.pi*beta/2)/(sp.gamma((1+beta)/2)*beta*2**((beta-1)/2)))**(1/beta);\\n\\tfor j in range(n):\\n\\t\\ts = nest[j,:]\\n\\t\\t#u=np.random.randn(s.shape[0])*sigma\\n\\t\\t#v=np.random.randn(s.shape[0])\\n\\t\\t#step=u/abs(v)**(1/beta)\\n\\t\\t#stepsize=0.01*step*(s-best);\\n\\t\\ts=s+ss.levy.rvs(size=21)*1e-40\\n\\t\\tnest[j,:]=simple_bounds(s, Lb, Ub)\\n\\treturn nest\",\n \"def find_top(self, gravityDir):\\n dirs = [\\\"-X\\\", \\\"+X\\\", \\\"-Y\\\", \\\"+Y\\\", \\\"-Z\\\", \\\"+Z\\\"]\\n for dir in dirs:\\n argsval = [\\\"NAME:\\\" + dir + \\\" Padding Data\\\", \\\"Value:=\\\", \\\"0\\\"]\\n args = [\\n \\\"NAME:AllTabs\\\",\\n [\\n \\\"NAME:Geometry3DCmdTab\\\",\\n [\\\"NAME:PropServers\\\", \\\"Region:CreateRegion:1\\\"],\\n [\\\"NAME:ChangedProps\\\", argsval],\\n ],\\n ]\\n self.modeler.oeditor.ChangeProperty(args)\\n oBoundingBox = self.modeler.get_model_bounding_box()\\n if gravityDir < 3:\\n return oBoundingBox[gravityDir + 3]\\n else:\\n return oBoundingBox[gravityDir - 3]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5159819","0.5115306","0.504334","0.48993444","0.48605645","0.48025545","0.47738016","0.4770416","0.47697255","0.4766613","0.4763854","0.4754322","0.47231025","0.47138077","0.4684063","0.46748742","0.4669275","0.46637076","0.46562827","0.46556216","0.4651941","0.46467322","0.46235722","0.4614849","0.46047115","0.45959854","0.45896468","0.45840994","0.4583401","0.4558843","0.45363423","0.451875","0.4492508","0.44849032","0.44844118","0.44805035","0.4479484","0.4479484","0.44769716","0.44748956","0.4472085","0.44663304","0.44637316","0.44466642","0.44453797","0.44436628","0.44408175","0.44382477","0.44299328","0.44296914","0.44239965","0.44182113","0.4413163","0.44101748","0.44077882","0.4407504","0.44061843","0.4403774","0.43928596","0.43864098","0.43831143","0.43712902","0.4369311","0.43649977","0.43602133","0.4351931","0.43479803","0.4347795","0.43434495","0.43337792","0.43309614","0.4323434","0.4318851","0.4313586","0.43073562","0.42982554","0.42935687","0.42908964","0.42840007","0.4282522","0.42811063","0.42791894","0.42683342","0.42670536","0.42652366","0.42637426","0.4256382","0.4252202","0.42511415","0.4250132","0.4247438","0.4242401","0.42410567","0.42377105","0.42372274","0.4232991","0.42270216","0.4226447","0.4226406","0.42263144","0.42260724"],"string":"[\n \"0.5159819\",\n \"0.5115306\",\n \"0.504334\",\n \"0.48993444\",\n \"0.48605645\",\n \"0.48025545\",\n \"0.47738016\",\n \"0.4770416\",\n \"0.47697255\",\n \"0.4766613\",\n \"0.4763854\",\n \"0.4754322\",\n \"0.47231025\",\n \"0.47138077\",\n \"0.4684063\",\n \"0.46748742\",\n \"0.4669275\",\n \"0.46637076\",\n \"0.46562827\",\n \"0.46556216\",\n \"0.4651941\",\n \"0.46467322\",\n \"0.46235722\",\n \"0.4614849\",\n \"0.46047115\",\n \"0.45959854\",\n \"0.45896468\",\n \"0.45840994\",\n \"0.4583401\",\n \"0.4558843\",\n \"0.45363423\",\n \"0.451875\",\n \"0.4492508\",\n \"0.44849032\",\n \"0.44844118\",\n \"0.44805035\",\n \"0.4479484\",\n \"0.4479484\",\n \"0.44769716\",\n \"0.44748956\",\n \"0.4472085\",\n \"0.44663304\",\n \"0.44637316\",\n \"0.44466642\",\n \"0.44453797\",\n \"0.44436628\",\n \"0.44408175\",\n \"0.44382477\",\n \"0.44299328\",\n \"0.44296914\",\n \"0.44239965\",\n \"0.44182113\",\n \"0.4413163\",\n \"0.44101748\",\n \"0.44077882\",\n \"0.4407504\",\n \"0.44061843\",\n \"0.4403774\",\n \"0.43928596\",\n \"0.43864098\",\n \"0.43831143\",\n \"0.43712902\",\n \"0.4369311\",\n \"0.43649977\",\n \"0.43602133\",\n \"0.4351931\",\n \"0.43479803\",\n \"0.4347795\",\n \"0.43434495\",\n \"0.43337792\",\n \"0.43309614\",\n \"0.4323434\",\n \"0.4318851\",\n \"0.4313586\",\n \"0.43073562\",\n \"0.42982554\",\n \"0.42935687\",\n \"0.42908964\",\n \"0.42840007\",\n \"0.4282522\",\n \"0.42811063\",\n \"0.42791894\",\n \"0.42683342\",\n \"0.42670536\",\n \"0.42652366\",\n \"0.42637426\",\n \"0.4256382\",\n \"0.4252202\",\n \"0.42511415\",\n \"0.4250132\",\n \"0.4247438\",\n \"0.4242401\",\n \"0.42410567\",\n \"0.42377105\",\n \"0.42372274\",\n \"0.4232991\",\n \"0.42270216\",\n \"0.4226447\",\n \"0.4226406\",\n \"0.42263144\",\n \"0.42260724\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":107,"numItemsPerPage":100,"numTotalItems":95772,"offset":10700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDQ3MDI4MCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQ0NzM4ODAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.MHVpheYQ_Qmg4IeTl_crzABTF0c2NJ2rmrHCstfsD5hr6X7S1z3quDAA0ljIIB7qscjbi3zyCCt6Q3jchTZkAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
Print table from list of messages. | def print_table(headers, rows):
try:
if headers:
print('\n')
print(tabulate.tabulate(
rows, headers=headers,
tablefmt="plain", numalign="left"
))
print('\n')
except Exception as e:
print(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_table(emojis):\n if len(emojis) > 0:\n table = []\n for i in emojis:\n table.append([i.get('id'), i.get('title'), i.get('emoji')])\n print(tabulate(table, headers=[\"ID\", \"Title\", \"Emoji\"]))\n else:\n print(\"¯\\_(ツ)_/¯ Nothing to see here...\")",
"def ... | [
"0.69499284",
"0.66310364",
"0.65664935",
"0.64629143",
"0.64629143",
"0.6451159",
"0.6444036",
"0.6387004",
"0.63242275",
"0.63035125",
"0.6296198",
"0.629306",
"0.62866634",
"0.6281273",
"0.62464696",
"0.6153312",
"0.6153312",
"0.61344033",
"0.6124151",
"0.60984",
"0.608824... | 0.6430923 | 7 |
Manages Docker containers' execution on batch systems. | def bdocker(ctx, host):
ctx.obj = commands.CommandController(endpoint=host) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def docker_worker():",
"def main():\n client = docker.from_env()\n parser = argparse.ArgumentParser(description='')\n parser.add_argument('--package_id', default='0',\n help='provide id for the work package, comma separated if multiple')\n parser.add_argument('--load_quicksave'... | [
"0.7041346",
"0.64235425",
"0.6416735",
"0.63321793",
"0.6304628",
"0.62385863",
"0.61790556",
"0.6143068",
"0.61176145",
"0.60870963",
"0.6064856",
"0.6035837",
"0.6028406",
"0.60254467",
"0.59756327",
"0.59450024",
"0.5940408",
"0.59361523",
"0.5926757",
"0.5865155",
"0.583... | 0.5935382 | 18 |
Configure credentials and batch environment. It creates a token credential for the user, and configure the batch environment to run dockers and control de accounting. Command executed by the root in prolog | def configure_environment(ctx, user):
try:
out = ctx.obj.configuration(
user
)
print_message(out["path"])
except BaseException as e:
print_error(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configuration(self, data):\n required = {'admin_token', 'user_credentials'}\n api.validate(data, required)\n admin_token = data['admin_token']\n session_data = data['user_credentials']\n user_token = self.credentials_module.authenticate(\n admin_token, session_data... | [
"0.6231196",
"0.6169389",
"0.584659",
"0.578861",
"0.57143813",
"0.56795084",
"0.557102",
"0.55013365",
"0.54908735",
"0.54244846",
"0.53997415",
"0.53970516",
"0.5373382",
"0.53675306",
"0.53632724",
"0.53570175",
"0.5325696",
"0.5263796",
"0.52633834",
"0.5260048",
"0.52404... | 0.5082915 | 34 |
Clean credentials and batch environment. It cleans a token credential for the user, and the batch environment, in addition to delete all dockers. Also, Command executed by the root in prolog | def clean_environment(ctx, token):
try:
out = ctx.obj.clean_environment(token)
print_message(out)
except BaseException as e:
print_error(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self, data):\n required = {'admin_token', 'token'}\n api.validate(data, required)\n admin_token = data['admin_token']\n force = True\n self.credentials_module.authorize_admin(admin_token)\n token = data['token']\n containers = self.credentials_module.list_... | [
"0.74475706",
"0.61287606",
"0.6078283",
"0.6048094",
"0.59989303",
"0.5986939",
"0.59787303",
"0.59101623",
"0.590741",
"0.5895125",
"0.58949953",
"0.58100575",
"0.5757535",
"0.5750923",
"0.5743235",
"0.57311714",
"0.5729552",
"0.57249904",
"0.57111883",
"0.5707326",
"0.5699... | 0.6538844 | 1 |
Pull image from repository | def container_pull(ctx, token, source):
try:
out = ctx.obj.container_pull(token, source)
print_message(out)
except BaseException as e:
print_error(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pull(self, data):\n required = {'token', 'source'}\n api.validate(data, required)\n token = data['token']\n repo = data['source']\n self.credentials_module.authorize(token)\n result = self.docker_module.pull_image(repo)\n # credentials_module.add_image(token, re... | [
"0.79796773",
"0.77487904",
"0.75974673",
"0.73926455",
"0.7349597",
"0.72877115",
"0.7240513",
"0.700893",
"0.69396365",
"0.6846112",
"0.6773135",
"0.6690871",
"0.6616364",
"0.6582388",
"0.6545659",
"0.6466452",
"0.64300317",
"0.64291394",
"0.64272416",
"0.64215964",
"0.6408... | 0.5703203 | 63 |
List all the containers running | def container_list(ctx, token, all):
try:
out = ctx.obj.container_list(token, all)
headers = ['CONTAINER ID', 'IMAGE', 'COMMAND',
'CREATED', 'STATUS', 'PORTS', 'NAMES']
print_table(headers, out)
except BaseException as e:
print_error(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def containers():\n # TODO: can there be multiple names?\n cmd = [ 'docker', 'ps', '--format', '{{.Names}}' ]\n with popen_text(cmd) as docker:\n for ln in docker.stdout:\n yield ln[:-1]",
"def ls():\n # TODO: listing all availabe containers form sequence\n return",
"def list(s... | [
"0.79300845",
"0.76792014",
"0.76520234",
"0.7499341",
"0.74776196",
"0.7367797",
"0.72929794",
"0.71087295",
"0.7014272",
"0.6956588",
"0.6936781",
"0.6914076",
"0.6901331",
"0.69012845",
"0.67714363",
"0.6749582",
"0.6717529",
"0.6671837",
"0.66680163",
"0.6631425",
"0.6581... | 0.7676674 | 2 |
Show the log of a container | def container_logs(ctx, token, container_id):
try:
out = ctx.obj.container_logs(token, container_id)
print_message(out)
except BaseException:
m = ("Error: No container related to %s" %
container_id)
print_error(m) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logs(self, container: Container) -> str:",
"def logs(name):\n\n try:\n container = CLIENT.containers.get(name)\n click.secho(str(container.logs()), bg='blue', fg='white')\n except docker.errors.NotFound as err:\n print(err)",
"def stream_container_logs(container: Container) -> No... | [
"0.8408397",
"0.7773719",
"0.73624533",
"0.7354112",
"0.71977407",
"0.71710056",
"0.7030652",
"0.6592035",
"0.6587888",
"0.65538996",
"0.63391703",
"0.62804216",
"0.62721485",
"0.6259622",
"0.62353",
"0.61764807",
"0.61363643",
"0.613622",
"0.61057305",
"0.60767347",
"0.60549... | 0.7430669 | 2 |
Return the low level information | def container_inspect(ctx, token, container_id):
try:
out = ctx.obj.container_inspect(token, container_id)
print_message(out)
except BaseException:
m = ("Error: No such container: %s" %
container_id)
print_error(m) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getInfo():",
"def info() -> None:",
"def get_info(self):\n pass",
"def get_info(self):\n pass",
"def info(self) -> dict:",
"def _get_information(self):\n pass",
"def info(self):",
"def info(self):",
"def get_info(self):\n return \"TODO !\"",
"def get_info(self):\n ... | [
"0.81291723",
"0.7838908",
"0.76136756",
"0.76136756",
"0.7582691",
"0.7491799",
"0.7458383",
"0.7458383",
"0.7445192",
"0.7323257",
"0.7281161",
"0.7077621",
"0.70342135",
"0.69988096",
"0.6942593",
"0.6920749",
"0.68934894",
"0.68923295",
"0.68902117",
"0.67708105",
"0.6769... | 0.0 | -1 |
Delete a container or list of them. | def container_delete(ctx, token, container_ids, force):
try:
out = ctx.obj.container_delete(token, container_ids, force)
print_message(out)
except exceptions.DockerException as e:
m = e.message
print_error(m) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_container(self, container: Container):",
"def DeleteContainers(self):\n for container in itertools.chain(*list(self.containers.values())):\n container.Delete()",
"def delete_container(ContainerName=None):\n pass",
"def delete_container(self, account, container):\n \n pass"... | [
"0.80328494",
"0.7434844",
"0.7386382",
"0.7215402",
"0.6816788",
"0.66818416",
"0.66644293",
"0.65226024",
"0.6510037",
"0.65017575",
"0.64464664",
"0.62738705",
"0.62296575",
"0.6196632",
"0.6169314",
"0.60266644",
"0.6006505",
"0.59684145",
"0.5931678",
"0.59242857",
"0.59... | 0.7737605 | 1 |
Copy files/folders Copy files/folders between a container and the local filesystem. | def copy(ctx, token, path):
try:
container_id = path["container_id"]
container_path = path["container_path"]
host_path = path["host_path"]
host_to_container = path["host_to_container"]
out = ctx.obj.copy_to_from_container(token,
container_id,
container_path,
host_path,
host_to_container)
print_message(out)
except BaseException as e:
print_error(e.message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_container_dirs(project_name, container_dir_to_copy):\n copy_containers_dirs_func(project_name, container_dir_to_copy)",
"def test_6c_copy_data_btw_containers(self):\n if (not GST.logged_in) or (not GST.data_testing_swift_mounted):\n raise unittest.SkipTest(\"Skipped for failed login... | [
"0.68293494",
"0.6804402",
"0.672718",
"0.66085654",
"0.65086794",
"0.65060276",
"0.64967877",
"0.64833045",
"0.64071506",
"0.6400087",
"0.6289071",
"0.6253664",
"0.6189857",
"0.6166261",
"0.61502683",
"0.6096343",
"0.6089863",
"0.6087521",
"0.608357",
"0.60329944",
"0.602137... | 0.6554481 | 4 |
Movement simulation for n+1 agents Agent can either be human or robot. humans are controlled by a unknown and fixed policy. robot is controlled by a known and learnable policy. | def __init__(self):
self.time_limit = None
self.time_step = None
self.robot = None
self.humans = None
self.global_time = None
self.robot_sensor_range = None
# reward function
self.success_reward = None
self.collision_penalty = None
self.discomfort_dist = None
self.discomfort_penalty_factor = None
# simulation configuration
self.config = None
self.case_capacity = None
self.case_size = None
self.case_counter = None
self.randomize_attributes = None
self.train_val_scenario = None
self.test_scenario = None
self.current_scenario = None
self.square_width = None
self.circle_radius = None
self.human_num = None
self.group_num = None
self.group_size = None
self.nonstop_human = None
self.centralized_planning = None
self.centralized_planner = None
# for visualization
self.states = None
self.action_values = None
self.attention_weights = None
self.robot_actions = None
self.rewards = None
self.As = None
self.Xs = None
self.feats = None
self.trajs = list()
self.save_scene_dir = None
self.panel_width = 10
self.panel_height = 10
self.panel_scale = 1
self.test_scene_seeds = []
self.dynamic_human_num = []
self.human_starts = []
self.human_goals = []
#for debug
self.add_human = []
self.delete_human = []
self.total_group_size = 0
self.hp_25 = {}
self.ha_25 = {}
self.phase = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulation(nepisodes):\n # Initialize robots\n # print('I am inside the simulation')\n agents = [] # List containing all robots\n a1 = Agent(start = [0, 0], end = [grid_size-1, grid_size-1], nr = 1) # Create agent 1\n a2 = Agent(start = [0, grid_size-1], end = [grid_size-1, 0], nr = 2) # Create ... | [
"0.7247015",
"0.662848",
"0.6565805",
"0.6498094",
"0.63772035",
"0.6343703",
"0.6315927",
"0.6275957",
"0.6245939",
"0.6235411",
"0.622889",
"0.61916804",
"0.6190207",
"0.61158586",
"0.6092612",
"0.60810214",
"0.6073287",
"0.60604274",
"0.60397756",
"0.59972614",
"0.5987725"... | 0.0 | -1 |
Set px, py, gx, gy, vx, vy, theta for robot and humans | def reset(self, phase='test', test_case=None):
assert phase in ['train', 'val', 'test']
self.phase = phase
if self.robot is None:
raise AttributeError('Robot has to be set!')
if test_case is not None:
self.case_counter[phase] = test_case
self.global_time = 0
base_seed = {'train': self.case_capacity['val'] + self.case_capacity['test'],
'val': 0, 'test': self.case_capacity['val']}
self.robot.set(0, -self.circle_radius, 0, self.circle_radius, 0, 0, np.pi / 2)
if self.case_counter[phase] >= 0:
np.random.seed(base_seed[phase] + self.case_counter[phase])
random.seed(base_seed[phase] + self.case_counter[phase])
if phase == 'test':
logging.debug('current test seed is:{}'.format(base_seed[phase] + self.case_counter[phase]))
if not self.robot.policy.multiagent_training and phase in ['train', 'val']:
# only CADRL trains in circle crossing simulation
human_num = 1
self.current_scenario = 'circle_crossing'
else:
self.current_scenario = self.test_scenario
human_num = self.human_num
self.humans = []
for _ in range(human_num):
self.humans.append(self.generate_human())
# case_counter is always between 0 and case_size[phase]
self.case_counter[phase] = (self.case_counter[phase] + 1) % self.case_size[phase]
else:
assert phase == 'test'
if self.case_counter[phase] == -1:
# for debugging purposes
self.human_num = 3
self.humans = [Human(self.config, 'humans') for _ in range(self.human_num)]
self.humans[0].set(0, -6, 0, 5, 0, 0, np.pi / 2)
self.humans[1].set(-5, -5, -5, 5, 0, 0, np.pi / 2)
self.humans[2].set(5, -5, 5, 5, 0, 0, np.pi / 2)
else:
raise NotImplementedError
#sha:
#potential issue of set agent'time_step and agent.policy.time_step here
#is that when agent is not add at the method self.reset(), then...
for agent in [self.robot] + self.humans:
agent.time_step = self.time_step
agent.policy.time_step = self.time_step
if self.centralized_planning:
self.centralized_planner.time_step = self.time_step
self.states = list()
self.robot_actions = list()
self.rewards = list()
if hasattr(self.robot.policy, 'action_values'):
self.action_values = list()
if hasattr(self.robot.policy, 'get_attention_weights'):
self.attention_weights = list()
if hasattr(self.robot.policy, 'get_matrix_A'):
self.As = list()
if hasattr(self.robot.policy, 'get_feat'):
self.feats = list()
if hasattr(self.robot.policy, 'get_X'):
self.Xs = list()
if hasattr(self.robot.policy, 'trajs'):
self.trajs = list()
# get current observation
if self.robot.sensor == 'coordinates':
ob = self.compute_observation_for(self.robot)
elif self.robot.sensor == 'RGB':
raise NotImplementedError
return ob | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_robot_pos(self):\n\t\tx,y,z = self.geo2desiredENU(self.curr_lat, self.curr_lon, self.gpsAlt)\n\t\tself.robot_msg.point.x = x\n\t\tself.robot_msg.point.y = y\n\t\tself.robot_msg.point.z = z",
"def set_robot(self, x, y):\n state = ModelState()\n state.model_name = 'turtlebot3_waffle_pi'\n ... | [
"0.66958505",
"0.6607154",
"0.6463861",
"0.64320457",
"0.6316836",
"0.63069874",
"0.6251611",
"0.61822575",
"0.6169917",
"0.6128124",
"0.604274",
"0.6007004",
"0.6003148",
"0.5984499",
"0.5962923",
"0.59606934",
"0.5928108",
"0.59259844",
"0.5916356",
"0.5914894",
"0.5906806"... | 0.0 | -1 |
Compute actions for all agents, detect collision, update environment and return (ob, reward, done, info) | def step(self, action, update=True):
if self.centralized_planning:
agent_states = [human.get_full_state() for human in self.humans]
if self.robot.visible:
agent_states.append(self.robot.get_full_state())
human_actions = self.centralized_planner.predict(agent_states)[:-1]
else:
human_actions = self.centralized_planner.predict(agent_states)
else:
human_actions = []
for human in self.humans:
ob = self.compute_observation_for(human)
human_actions.append(human.act(ob))
# collision detection
dmin = float('inf')
collision = False
for i, human in enumerate(self.humans):
px = human.px - self.robot.px
py = human.py - self.robot.py
if self.robot.kinematics == 'holonomic':
vx = human.vx - action.vx
vy = human.vy - action.vy
else:
vx = human.vx - action.v * np.cos(action.r + self.robot.theta)
vy = human.vy - action.v * np.sin(action.r + self.robot.theta)
ex = px + vx * self.time_step
ey = py + vy * self.time_step
# closest distance between boundaries of two agents
closest_dist = point_to_segment_dist(px, py, ex, ey, 0, 0) - human.radius - self.robot.radius
if closest_dist < 0:
collision = True
logging.debug("Collision: distance between robot and p{} is {:.2E} at time {:.2E}".format(human.id, closest_dist, self.global_time))
break
elif closest_dist < dmin:
dmin = closest_dist
# collision detection between humans
human_num = len(self.humans)
for i in range(human_num):
for j in range(i + 1, human_num):
dx = self.humans[i].px - self.humans[j].px
dy = self.humans[i].py - self.humans[j].py
dist = (dx ** 2 + dy ** 2) ** (1 / 2) - self.humans[i].radius - self.humans[j].radius
if dist < 0:
# detect collision but don't take humans' collision into account
logging.debug('Collision happens between humans in step()')
# check if reaching the goal
end_position = np.array(self.robot.compute_position(action, self.time_step))
reaching_goal = norm(end_position - np.array(self.robot.get_goal_position())) < self.robot.radius
if self.global_time >= self.time_limit - 1:
reward = 0
done = True
info = Timeout()
elif collision:
reward = self.collision_penalty
done = True
info = Collision()
elif reaching_goal:
reward = self.success_reward
done = True
info = ReachGoal()
elif dmin < self.discomfort_dist:
# adjust the reward based on FPS
reward = (dmin - self.discomfort_dist) * self.discomfort_penalty_factor * self.time_step
done = False
info = Discomfort(dmin)
else:
reward = 0
done = False
info = Nothing()
if update:
# store state, action value and attention weights
if hasattr(self.robot.policy, 'action_values'):
self.action_values.append(self.robot.policy.action_values)
if hasattr(self.robot.policy, 'get_attention_weights'):
self.attention_weights.append(self.robot.policy.get_attention_weights())
if hasattr(self.robot.policy, 'get_matrix_A'):
self.As.append(self.robot.policy.get_matrix_A())
if hasattr(self.robot.policy, 'get_feat'):
self.feats.append(self.robot.policy.get_feat())
if hasattr(self.robot.policy, 'get_X'):
self.Xs.append(self.robot.policy.get_X())
if hasattr(self.robot.policy, 'traj'):
self.trajs.append(self.robot.policy.get_traj())
# update all agents
self.robot.step(action)
for human, action in zip(self.humans, human_actions):
human.step(action)
if self.nonstop_human and human.reached_destination():
self.generate_human(human)
self.global_time += self.time_step
self.states.append([self.robot.get_full_state(), [human.get_full_state() for human in self.humans],
[human.id for human in self.humans]])
self.robot_actions.append(action)
self.rewards.append(reward)
# compute the observation
if self.robot.sensor == 'coordinates':
ob = self.compute_observation_for(self.robot)
elif self.robot.sensor == 'RGB':
raise NotImplementedError
else:
if self.robot.sensor == 'coordinates':
ob = [human.get_next_observable_state(action) for human, action in zip(self.humans, human_actions)]
elif self.robot.sensor == 'RGB':
raise NotImplementedError
return ob, reward, done, info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def step(self, actions): # actions is a list,\n\n assert len(actions) == len(self.agents), \"Number of actions (\" + str(\n len(actions)) + \") does not match number of agents (\" + str(self.n_agents) + \")\"\n\n # Process movement based on real states (not belief)\n\n\n rewards = ... | [
"0.69635177",
"0.6676281",
"0.6554985",
"0.64697844",
"0.63891464",
"0.6335718",
"0.6276497",
"0.627058",
"0.6184203",
"0.61650044",
"0.6161578",
"0.6150834",
"0.61403406",
"0.61149937",
"0.6105217",
"0.6084121",
"0.6073783",
"0.60636634",
"0.60587096",
"0.6010782",
"0.601078... | 0.64085144 | 4 |
Compute the softmax of each element along an axis of X. | def softmax(X, theta = 1.0, axis = None):
# make X at least 2d
y = np.atleast_2d(X)
# find axis
if axis is None:
axis = next(j[0] for j in enumerate(y.shape) if j[1] > 1)
# multiply y against the theta parameter,
y = y * float(theta)
# subtract the max for numerical stability
y = y - np.expand_dims(np.max(y, axis = axis), axis)
# exponentiate y
y = np.exp(y)
# take the sum along the specified axis
ax_sum = np.expand_dims(np.sum(y, axis = axis), axis)
# finally: divide elementwise
p = y / ax_sum
# flatten if X was 1D
if len(X.shape) == 1: p = p.flatten()
return p | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def softmax(self, x):\n\n out = np.zeros(x.shape)\n for i in range(x.shape[0]):\n max_x = x[i] - np.max(x[i])\n out[i] = np.exp(max_x) / np.sum(np.exp(max_x), axis=0)\n\n return out",
"def softmax(x: npt.NDArray) -> npt.NDArray:\n row_wise_max = np.max(x, axis=1).res... | [
"0.86482805",
"0.8523447",
"0.8501702",
"0.8450376",
"0.8424998",
"0.8401389",
"0.83826745",
"0.8379566",
"0.83725315",
"0.8363791",
"0.83552516",
"0.83450276",
"0.8326659",
"0.8309501",
"0.8274441",
"0.82731706",
"0.8266031",
"0.8248805",
"0.8248805",
"0.8244989",
"0.824277"... | 0.0 | -1 |
floor the point to the next lower multiple of bucket_size | def bucketize(point, bucket_size):
return bucket_size * math.floor(point / bucket_size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucketize(point, bucket_size):\n return bucket_size * math.floor(point / bucket_size)",
"def bucketize(point, bucket_size):\n return bucket_size * math.floor(point / bucket_size)",
"def bucket_boundaries(self, bucket):\n\n if bucket < 0 or bucket >= self.total_buckets:\n raise IndexError('buc... | [
"0.7870765",
"0.7870765",
"0.6348058",
"0.61719537",
"0.61719537",
"0.5968876",
"0.59520507",
"0.5859526",
"0.5772838",
"0.57719916",
"0.5732552",
"0.57283777",
"0.5643887",
"0.5643887",
"0.5638288",
"0.56255656",
"0.5601112",
"0.55790997",
"0.55427814",
"0.5534332",
"0.55317... | 0.79474443 | 0 |
buckets the points and counts how many in each bucket | def make_histogram(points, bucket_size):
return Counter(bucketize(point, bucket_size) for point in points) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_histogram(points, bucket_size):\n return Counter(bucketize(point, bucket_size) for point in points)",
"def make_histogram(points, bucket_size):\n return Counter(bucketize(point, bucket_size) for point in points)",
"def bucketize(point, bucket_size):\r\n return bucket_size * math.floor(point /... | [
"0.7339186",
"0.7339186",
"0.6404966",
"0.63198906",
"0.63145477",
"0.6261517",
"0.6261517",
"0.6104376",
"0.6046917",
"0.5988437",
"0.59414226",
"0.58722836",
"0.58446556",
"0.5792215",
"0.57895434",
"0.57877",
"0.56928134",
"0.5675051",
"0.56433356",
"0.5634637",
"0.5604564... | 0.7430182 | 0 |
find approximate inverse using binary search | def inverse_normal_cdf(p, mu=0, sigma=1, tolerance=0.00001):
# if not standard, compute standard and rescale
if mu != 0 or sigma != 1:
return mu + sigma * inverse_normal_cdf(p, tolerance=tolerance)
low_z, low_p = -10.0, 0 # normal_cdf(-10) is (very close to) 0
hi_z, hi_p = 10.0, 1 # normal_cdf(10) is (very close to) 1
while hi_z - low_z > tolerance:
mid_z = (low_z + hi_z) / 2 # consider the midpoint
mid_p = normal_cdf(mid_z) # and the cdf's value there
if mid_p < p:
# midpoint is still too low, search above it
low_z, low_p = mid_z, mid_p
elif mid_p > p:
# midpoint is still too high, search below it
hi_z, hi_p = mid_z, mid_p
else:
break
return mid_z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def binarysearch(a, i):\n l = 0\n r = len(a) - 1\n \n while l < r:\n m = l + (r-l)/2\n \n if a[m] == i:\n return m\n elif a[m] < i:\n l = m + 1\n else:\n ... | [
"0.62011486",
"0.6161687",
"0.6134568",
"0.61064506",
"0.60823286",
"0.60589427",
"0.60270196",
"0.60241973",
"0.59456474",
"0.58296686",
"0.58176553",
"0.5816624",
"0.5789889",
"0.578986",
"0.57876474",
"0.5786067",
"0.57808775",
"0.5775977",
"0.5749061",
"0.57435906",
"0.57... | 0.0 | -1 |
returns a random draw from a standard normal distribution | def random_normal():
return inverse_normal_cdf(random.random()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_normal():\n return inverse_normal_cdf(random.random())",
"def normal(mean, std):\n\n return random.gauss(mean, std)",
"def get_standard_normal_distribution():\n return np.random.normal(0, 1)",
"def draw_normal(self):\n means, scale = self.get_means_and_scales()\n ret... | [
"0.80372727",
"0.8026352",
"0.7671266",
"0.758368",
"0.72377944",
"0.6984565",
"0.67650646",
"0.6753574",
"0.67039895",
"0.6645325",
"0.66249055",
"0.65704095",
"0.6569231",
"0.6554965",
"0.65050215",
"0.6493456",
"0.6487899",
"0.64656204",
"0.64537066",
"0.64235955",
"0.6408... | 0.80891997 | 0 |
Function to execute the graph export pipeline | def run(self,
example_input : Union[str,Path,None] = None) -> EasyDict :
outputs = []
ok = True
for export_config in self.export_configs :
exporter = create_exporter(
config=export_config,
experiment_name=self.experiment_name,
image_size=self.image_size,
output_directory=(self.experiment_directory),
)
ok = exporter(
predictor=self.predictor,
class_names=self.class_names,
example_image_path=example_input
) and ok
outputs.append(str(exporter.filename))
print('model is exported to:', ', '.join(outputs))
# TODO specify which export is failed
result = EasyDict({'export_status' : ok})
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call(argv):\n known_args, beam_options = parse_args(argv)\n\n yaml_string = known_args.dag.decode('string_escape')\n dag = yaml.load(yaml_string)\n\n pipeline_options = PipelineOptions(beam_options)\n pipeline_options.view_as(SetupOptions).save_main_session = True\n\n p = beam.Pipeline(options=pipeline_o... | [
"0.6055563",
"0.5933445",
"0.5930202",
"0.592405",
"0.58405817",
"0.5824905",
"0.57319194",
"0.5693886",
"0.56896466",
"0.56853735",
"0.5645192",
"0.56450754",
"0.56329167",
"0.56210643",
"0.5618542",
"0.5617108",
"0.5615359",
"0.55950373",
"0.5586101",
"0.55649096",
"0.55558... | 0.5214862 | 50 |
Transform request data to dict with 2 level of depth | def request_data_to_dict(data):
if not isinstance(data, ImmutableMultiDict):
raise ValueError('Input must be ImmutableMultiDict type.')
res = {}
for (key, value) in data.to_dict().items():
matches = re.match('(.*)\[(.*)\]', key)
if matches:
(key_lv_1, key_lv_2) = matches.groups()
if key_lv_1 not in res:
res[key_lv_1] = {}
res[key_lv_1][key_lv_2] = value
else:
res[key] = value
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _to_request_dict(self):\n return {\"attr1\": self.attr1, \"attr2\": \"test\"}",
"def to_dict(self, request) -> Dict[str, Any]:\n adict = self.__dict__.copy()\n adict[\"url\"] = self.href(adict[\"url\"], request)\n adict[\"img\"] = self.href(adict[\"img\"], request)\n if... | [
"0.6378962",
"0.63289046",
"0.6227822",
"0.60884583",
"0.6052619",
"0.60420406",
"0.60407573",
"0.6025036",
"0.59494644",
"0.5901705",
"0.5876816",
"0.5818334",
"0.5817537",
"0.57859",
"0.5757327",
"0.5757108",
"0.5747224",
"0.5745498",
"0.5735476",
"0.5723966",
"0.57147676",... | 0.7102085 | 0 |
Sweeping from low to high brightness and back, continuously. | def Demo(controller_name, outputs):
print 'Initiating controller %r ...\n' % controller_name
box = getattr(controller, controller_name).FirstDevice(outputs=outputs)
print '\nFade to white and back.'
FadeOutputs(box, '#fff')
FadeOutputs(box, '#000')
print 'Fade to a random color and back to black, ad nauseum.'
while True:
FadeOutputs(box, utils.RandomColor())
FadeOutputs(box, '#000') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def twinkle(self, wait: float = DEFAULT_SPEED, count: int = 10):\n last = None\n for _ in range(count):\n c = randint(0, len(COLOR_TUPLE_LIST) - 1) # Choose random color index\n j = randint(0, self.np.n - 1) # Choose random pixel\n\n # Check that the pixel is off (d... | [
"0.6644794",
"0.6367496",
"0.63170844",
"0.6283884",
"0.6260947",
"0.62575155",
"0.6218248",
"0.6202204",
"0.6158688",
"0.61483514",
"0.6132683",
"0.61230457",
"0.6123004",
"0.6075169",
"0.6070032",
"0.6054008",
"0.603593",
"0.60226864",
"0.6017028",
"0.60140914",
"0.6007782"... | 0.0 | -1 |
Fades all outputs to the given color and waits for it to complete. | def FadeOutputs(box, color, steps=50):
for output in box:
output.Fade(color=color, steps=steps)
time.sleep(steps / (float(box.frequency) / len(box))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_fade_colour(l, leds, r, g, b, duration):\n l._do_multi_led_command(\n create_fade_colour_command, leds, r, g, b, duration\n )",
"def color_chase(self, color: tuple = CYAN, wait: float = DEFAULT_SPEED):\n for i in range(self.np.n):\n self.np[i] = color\n ... | [
"0.6856355",
"0.66404843",
"0.64948034",
"0.6415791",
"0.6347536",
"0.62956667",
"0.6144092",
"0.6049132",
"0.5983142",
"0.59646887",
"0.5947122",
"0.5939072",
"0.59066415",
"0.58729315",
"0.57774615",
"0.5768261",
"0.5764425",
"0.5718582",
"0.56916755",
"0.56897503",
"0.5660... | 0.8030329 | 0 |
Processes commandline input to setup the demo. | def main():
import optparse
import sys
parser = optparse.OptionParser()
parser.add_option('-c', '--controller', default='NewController',
help='Controller class to instantiate.')
parser.add_option('-o', '--outputs', type='int', default=5,
help='Number of outputs to use on the hardware.')
options, _arguments = parser.parse_args()
try:
Demo(options.controller, options.outputs)
except controller.ConnectionError:
sys.exit('ABORT: Could not find a suitable device.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup():\n try:\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--rows\", type=int, default=10, help=\"Number of rows to generate in demo file\")\n parser.add_argument(\"--filename\", type=str, default=\"..//data//demo.csv\", help=\"Filename of demo data\")\n parser.... | [
"0.67759037",
"0.6695762",
"0.66869605",
"0.6590389",
"0.643101",
"0.6393426",
"0.63334584",
"0.63311416",
"0.62942785",
"0.6283842",
"0.6267345",
"0.6248693",
"0.6248693",
"0.6229788",
"0.6229788",
"0.62010115",
"0.6191372",
"0.61896974",
"0.6173674",
"0.6158222",
"0.6149269... | 0.0 | -1 |
A method for scrolling the page. | def scroll_down(driver):
# Get scroll height.
last_height = driver.execute_script(
"return document.body.scrollHeight")
while True:
# Scroll down to the bottom.
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
# Wait to load the page.
time.sleep(2)
# Calculate new scroll height and compare with last scroll height.
new_height = driver.execute_script(
"return document.body.scrollHeight")
if new_height == last_height:
break
last_height = new_height | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scroll(*args):",
"def scroll_to(self):\n\n if self:\n pass",
"def scroll_page(self):\n scroll_down = self.driver.find_element_by_tag_name(\"html\")\n scroll_down.send_keys(Keys.END)\n sleep(TestData.DELAY)\n scroll_down.send_keys(Keys.CONTROL + Keys.HOME)\n ... | [
"0.7725844",
"0.71696216",
"0.71549976",
"0.7153446",
"0.71490943",
"0.7085735",
"0.70825195",
"0.6995313",
"0.6939542",
"0.69198406",
"0.6776687",
"0.6771578",
"0.67377883",
"0.6731459",
"0.67016435",
"0.6660212",
"0.65802693",
"0.64700073",
"0.6467011",
"0.6460393",
"0.6429... | 0.0 | -1 |
This function returns the predicted integer. The imput is the pixel values from the imageprepare() function. | def predictint(test_images):
# Define the model (same as when creating the model file)
x = tf.placeholder(tf.float32, [None, image_size])
W = tf.Variable(tf.zeros([image_size, image_labels]))
b = tf.Variable(tf.zeros([image_labels]))
is_test = tf.placeholder(tf.bool)
# Model Parameters
W_conv1 = tf.get_variable("W_conv1", shape=[5, 5, 1, 32], initializer=weight_xavier_init(5 * 5 * 1, 32))
W_conv2 = tf.get_variable("W_conv2", shape=[5, 5, 32, 64], initializer=weight_xavier_init(5 * 5 * 32, 64))
W_fc1 = tf.get_variable("W_fc1", shape=[64 * 7 * 7, 1024], initializer=weight_xavier_init(64 * 7 * 7, 1024))
W_fc2 = tf.get_variable("W_fc2", shape=[1024, image_labels], initializer=weight_xavier_init(1024, image_labels))
b_conv1 = bias_variable([32])
b_conv2 = bias_variable([64])
b_fc1 = bias_variable([1024])
b_fc2 = bias_variable([image_labels])
x_image = tf.reshape(x, [-1, image_width, image_height, 1])
conv1 = conv2d(x_image, W_conv1) + b_conv1
conv1_bn = batchnorm(conv1, b_conv1, is_test, True)
h_conv1 = tf.nn.relu(conv1_bn)
h_pool1 = max_pool_2x2(h_conv1)
conv2 = conv2d(h_pool1, W_conv2) + b_conv2
conv2_bn = batchnorm(conv2, b_conv2, is_test, True)
h_conv2 = tf.nn.relu(conv2_bn)
h_pool2 = max_pool_2x2(h_conv2)
h_pool2_flat = tf.reshape(h_pool2, [-1, W_fc1.get_shape().as_list()[0]])
fc1 = tf.matmul(h_pool2_flat, W_fc1) + b_fc1
fc1_bn = batchnorm(fc1, b_fc1, is_test, False)
h_fc1 = tf.nn.relu(fc1_bn)
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
init_op = tf.initialize_all_variables()
saver = tf.train.Saver()
"""
Load the my-model file
file is stored in the same directory as this python script is started
Use the model to predict the integer. Integer is returend as list.
Based on the documentatoin at
https://www.tensorflow.org/versions/master/how_tos/variables/index.html
"""
predicted_lables = np.zeros(test_images.shape[0])
with tf.Session() as sess:
sess.run(init_op)
saver.restore(sess, "F:\PycharmProject\CNN_mnist_base\model\my-model")
# print ("Model restored.")
predict = tf.argmax(y_conv, 1)
for i in range(0, test_images.shape[0]):
imagein = test_images[i]
predicted_lables[i] = predict.eval(feed_dict={x: [imagein], keep_prob: 1.0, is_test: False}, session=sess)
sess.close()
return predicted_lables | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, img):\n return self._predict([img])[0]",
"def get_predictions(self, img):\n \n predictions = self.tf_model.predict_proba(img)\n prediction = np.argmax(predictions, axis=-1)\n \n return prediction",
"def predict(image):\n with tf.Session(graph=graph... | [
"0.7003327",
"0.6524388",
"0.6392707",
"0.6391232",
"0.6360505",
"0.63116616",
"0.63055545",
"0.62496394",
"0.6202126",
"0.614478",
"0.60959804",
"0.60379404",
"0.6035026",
"0.6001941",
"0.59648454",
"0.59607786",
"0.5958487",
"0.59524536",
"0.59420645",
"0.5912935",
"0.59101... | 0.0 | -1 |
Returns the name the function should have in the Python api, based on the c++function name. For entry_type 'function', the cpp_name is used unmodified, otherwise strip everything before the first underscore, so that | def to_py_name(cpp_name, entry_type):
if entry_type == 'function':
return cpp_name
first_underscore = cpp_name.find('_')
assert(first_underscore != -1)
return cpp_name[first_underscore + 1:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _plugin_funcname(func):\n funcname = func.__name__.rstrip(\"_\")\n if funcname.startswith(\"__\"):\n return funcname + \"__\"\n return funcname",
"def wrapper_function_name(text):\n text = GLGenerator.split_to_body_and_ext(text)\n body = text[0]\n ext = text[1]\n ... | [
"0.67665726",
"0.6633372",
"0.64924026",
"0.64650005",
"0.6389167",
"0.63741195",
"0.6252101",
"0.62447554",
"0.62166333",
"0.61651427",
"0.61233187",
"0.6080773",
"0.6080773",
"0.60069233",
"0.59802777",
"0.5970677",
"0.5940581",
"0.5938672",
"0.5932276",
"0.5924244",
"0.592... | 0.84663165 | 0 |
Returns the name the property should have in the Python api, based on the C++ struct name. | def property_to_py_name(cpp_struct_name):
first_underscore = cpp_struct_name.find('_')
assert first_underscore != -1
return cpp_struct_name[first_underscore + 1:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PropertyName(self) -> str:",
"def property_name(self) -> str:\n return str(self.prop_name)",
"def _get_name(x):\r\n if isinstance(x, Property) or isinstance(x, KeyIndex):\r\n return x.name\r\n elif isinstance(x, Edge):\r\n return x.label\r\n ... | [
"0.7078016",
"0.6528718",
"0.65224946",
"0.6521",
"0.6296151",
"0.6226451",
"0.622544",
"0.6218055",
"0.61775655",
"0.615941",
"0.6148613",
"0.6143576",
"0.6141541",
"0.61411786",
"0.6134688",
"0.6088676",
"0.6088676",
"0.6035033",
"0.6035033",
"0.6035033",
"0.6035033",
"0.... | 0.8263242 | 0 |
Remove spurious endlines and such from the docstring specified in the comment preceding the C++python functions. | def clean_doc(doc):
# Replace regular enter (i.e. mere comment formatting in cpp file)
# with space
doc = doc.replace("\n", " ")
# The removal can cause a "hard enter" (literal \n) to get an unintended
# trailing space - trim those.
doc = doc.replace("\\n ", "\\n")
return '"%s"' % doc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strip_docstring(blob):\n docstring = True\n while docstring == True:\n match_docstring = re.search('\\n\\s*\"\"\"[^\"\"\"]*\"\"\"', blob)\n if not match_docstring:\n docstring = False\n else:\n blob = blob.replace(blob[match_docstring.span()[0]:match_docstring.s... | [
"0.7409109",
"0.7175777",
"0.71319836",
"0.69368535",
"0.69084775",
"0.67596537",
"0.64949363",
"0.64829695",
"0.6481948",
"0.6396861",
"0.6369261",
"0.63360715",
"0.6248399",
"0.6155236",
"0.61414677",
"0.6126157",
"0.61031824",
"0.6062932",
"0.60486543",
"0.6028124",
"0.600... | 0.6236144 | 13 |
Determines the Python method type (METH_NOARGS or METH_VARARGS) from the C++ argument list and type of function. | def get_type(args_str, entry_type):
# The C-method-implementations accept self as the first argument,
# so a one-argument method will be invoked with zero arguments in Python.
no_args = 1 if entry_type == "method" else 0
return ("METH_NOARGS" if len(args_str.split(",")) == no_args
else "METH_VARARGS") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pytype(self, c_arg, parse_arg):\n if isinstance(c_arg, FunctionAddress):\n return 'O'\n else:\n try:\n return pytype_parse_registry[(parse_arg.dtype, parse_arg.precision)]\n except KeyError as e:\n raise NotImplementedError(\"Type... | [
"0.61319065",
"0.60803515",
"0.5884141",
"0.5874044",
"0.58434784",
"0.5799301",
"0.56729174",
"0.56608915",
"0.5459384",
"0.54216975",
"0.54152423",
"0.53767866",
"0.53465176",
"0.5273557",
"0.52425903",
"0.51958585",
"0.51934904",
"0.513849",
"0.5122222",
"0.5119435",
"0.50... | 0.6993184 | 0 |
Find any comment for including additional method definitions (e.g. handwritten for special cases) inside the generated methoddefs array. | def find_extra_include(file_name):
extra_includes = []
with open(file_name) as f:
for m in re.finditer(regex.extra_include, f.read()):
extra_includes.append(m.groups(1))
return extra_includes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __find_methods(self):\r\n while self.__advance():\r\n if self.__tokenizer.token_type() == TYPES_DIC[\"KEYWORD\"] and \\\r\n self.__tokenizer.identifier() == TYPES_DIC[\"METHOD\"]:\r\n self.__advance(n=2)\r\n self.__method_list.append(self.__tok... | [
"0.58155406",
"0.5515345",
"0.54595226",
"0.54332846",
"0.5404431",
"0.53915465",
"0.5368009",
"0.5353553",
"0.5258822",
"0.52563065",
"0.5255658",
"0.5237434",
"0.52109283",
"0.520928",
"0.5189513",
"0.51740175",
"0.5138967",
"0.51203406",
"0.5094661",
"0.5094661",
"0.507519... | 0.0 | -1 |
Uses a more permissive variant of the commentregex used to recognize C++ methods to catch malformed comments. Raises ValueError if anything problematic is discovered. | def check_file(file_name):
result = []
with open(file_name) as f:
text = f.read()
for m in re.finditer(regex.function_lenient, text, re.DOTALL|re.MULTILINE):
m2 = re.match(regex.function_strict,
m.group(0), re.DOTALL|re.MULTILINE)
if m2:
if m2.group(2).find('"') != -1:
raise ValueError('Extra quote (") in method markup: %s' %
m.group(0))
else:
raise ValueError("Invalid method markup: %s" % m.group(0))
result.append(m.group(0))
end = m.end(0)
if not text[end] == '\n':
raise ValueError("Missing endline after method markup.")
# Verify that the function is static.
# This helps ensure that all functions are included in the
# method-def (otherwise the compiler warns about unused static
# function).
#
# Regular Faint functions aren't made specifically for a methoddef,
# and may have external linkage (e.g. bitmap draw functions),
# so allow extern as well, but require stating so explicitly.
static = text[end+1:].startswith("static")
extern = text[end+1:].startswith("extern")
template = text[end+1:].startswith("template<typename T>")
if not static and not extern and not template:
rest = text[end+1:]
methodLine = rest[:rest.find('\n')]
raise ValueError("Marked up method not static or extern:\n%s "
% methodLine[:-1])
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_comments(self, args):\n\n for submission in args.comments:\n if any(char.isalpha() for char in submission[1]) \\\n or self._illegal_chars.search(submission[1]) != None:\n raise ValueError",
"def parse_comment(comment: Union[Token, PsuedoToken]) -> str:\n #... | [
"0.656411",
"0.628157",
"0.6194034",
"0.610862",
"0.60144717",
"0.59669393",
"0.59666216",
"0.5915157",
"0.5909202",
"0.58375543",
"0.58352786",
"0.5832811",
"0.5806706",
"0.5784541",
"0.57556933",
"0.57461137",
"0.57419854",
"0.57343096",
"0.57110506",
"0.5686666",
"0.567892... | 0.0 | -1 |
Creates one entry for a PyMethodDef array from the entries for one function (as returned by parse_file). | def to_PyMethodDef_entry(items):
entry_type = items[0]
items = items[1:]
if entry_type == 'method':
return 'FORWARDER(%s, %s, "%s", %s)' % items
elif entry_type == 'function':
return 'FREE_FORWARDER(%s, %s, "%s", %s)' % items
elif entry_type == 'method_template':
return 'FORWARDER(%s<common_type>, %s, "%s", %s)' % items
else:
assert False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_PyMethodDef(name, entries, extra_includes):\r\n\r\n methodEntries = [to_PyMethodDef_entry(items) for items in entries]\r\n if name is not None:\r\n methodDef = ('static PyMethodDef %s_methods[] = {\\n ' % name +\r\n ',\\n '.join(methodEntries) + ',\\n ')\r\n else:\r\n me... | [
"0.75998366",
"0.5944248",
"0.55603445",
"0.5401207",
"0.5332072",
"0.5176276",
"0.5170217",
"0.5108655",
"0.50803465",
"0.5051816",
"0.50399566",
"0.5013269",
"0.4962817",
"0.4942569",
"0.49400118",
"0.49136788",
"0.4911339",
"0.49019086",
"0.4900917",
"0.48928633",
"0.48558... | 0.7316116 | 1 |
Creates one entry for a PyGetSetDef array from the entries for one propertystruct (as returned by parse_file). | def to_PyGetSetDef_entry(cpp_struct_name, py_name, doc):
return 'PROPERTY_FORWARDER(%s, "%s", %s)' % (
cpp_struct_name, py_name, doc) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_PyGetSetDef(name, entries):\r\n getSetDefEntries = [to_PyGetSetDef_entry(*items) for items in entries]\r\n getSetDef = ('static PyGetSetDef %s_getseters[] = {\\n ' % name +\r\n ',\\n '.join(getSetDefEntries) + ',\\n ')\r\n getSetDef += '{nullptr,nullptr,nullptr,nullptr,nullptr} /... | [
"0.71594757",
"0.5288491",
"0.50017947",
"0.49717405",
"0.49567866",
"0.49039754",
"0.48913658",
"0.47898185",
"0.47757462",
"0.47685832",
"0.47616416",
"0.47450364",
"0.47120082",
"0.46812397",
"0.46606937",
"0.46587437",
"0.46313342",
"0.46271035",
"0.4625974",
"0.46091345",
... | 0.5890328 | 1 |
Creates a string of a CPyGetSetDef array named _getseters, containing all entries in the list (as created by to_PyGetSetDef_entry). | def to_PyGetSetDef(name, entries):
getSetDefEntries = [to_PyGetSetDef_entry(*items) for items in entries]
getSetDef = ('static PyGetSetDef %s_getseters[] = {\n ' % name +
',\n '.join(getSetDefEntries) + ',\n ')
getSetDef += '{nullptr,nullptr,nullptr,nullptr,nullptr} // Sentinel\n};'
return getSetDef | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSets():",
"def get_drivers():\n return [str(d) for d in drivers.values()]",
"def getset(self, name, value):\r\n return self.format_bulk('GETSET', name, value)",
"def get_reader_funcs():\n return READERS",
"def get_all(self):\n return [self.get(name) for name in self.factories.ite... | [
"0.5476404",
"0.5249653",
"0.51922673",
"0.51390755",
"0.5105949",
"0.50751984",
"0.5071153",
"0.5018218",
"0.50118506",
"0.5000767",
"0.4974314",
"0.4955749",
"0.49450973",
"0.49285832",
"0.49245515",
"0.49245515",
"0.4890076",
"0.48870137",
"0.48566785",
"0.48400316",
"0.48... | 0.72217596 | 0 |
Creates a string of a CPyMethodDef array named _methods, containing all the entries in the list (as created by to_PyMethodDef_entry). Includes any include in the extra_includes list after the regular entries (before the sentinel). | def to_PyMethodDef(name, entries, extra_includes):
methodEntries = [to_PyMethodDef_entry(items) for items in entries]
if name is not None:
methodDef = ('static PyMethodDef %s_methods[] = {\n ' % name +
',\n '.join(methodEntries) + ',\n ')
else:
methodDef = ',\n'.join(methodEntries) + ',\n '
for include in extra_includes:
methodDef += '#include "%s"\n' % include
if name is not None:
methodDef += '{nullptr,nullptr,0,nullptr} // Sentinel\n};'
return methodDef | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_PyMethodDef_entry(items):\r\n\r\n entry_type = items[0]\r\n items = items[1:]\r\n if entry_type == 'method':\r\n return 'FORWARDER(%s, %s, \"%s\", %s)' % items\r\n elif entry_type == 'function':\r\n return 'FREE_FORWARDER(%s, %s, \"%s\", %s)' % items\r\n elif entry_type == 'meth... | [
"0.6497351",
"0.6201312",
"0.59603804",
"0.5856507",
"0.57363343",
"0.5670631",
"0.56094706",
"0.56094706",
"0.5410812",
"0.5366973",
"0.5323587",
"0.52034914",
"0.51885706",
"0.51738644",
"0.5158081",
"0.51455",
"0.51223594",
"0.5052642",
"0.5005883",
"0.49957657",
"0.494654... | 0.7831075 | 0 |
Writes a PyMethodDef array and/or a PyGetSetDef to the specified file, featuring entries from the entries lists (as returned by parse_file). | def write_result(file_name, name, entries, extra_includes, src_file_names):
with open(file_name, 'w', newline='\n') as f:
f.write('// Generated by %s\n' % os.path.basename(__file__))
f.write('// Based on %s: %s\n' %
(("this file" if len(src_file_names) < 2 else
"these files"), ", ".join(src_file_names)))
methods = entries[0]
if len(methods) != 0:
f.write(to_PyMethodDef(name, methods, extra_includes))
f.write('\n')
properties = entries[1]
if len(properties) != 0:
f.write('\n')
f.write(to_PyGetSetDef(name, properties)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_PyMethodDef(name, entries, extra_includes):\r\n\r\n methodEntries = [to_PyMethodDef_entry(items) for items in entries]\r\n if name is not None:\r\n methodDef = ('static PyMethodDef %s_methods[] = {\\n ' % name +\r\n ',\\n '.join(methodEntries) + ',\\n ')\r\n else:\r\n me... | [
"0.6717636",
"0.5957228",
"0.5844461",
"0.5257296",
"0.52116394",
"0.51606745",
"0.5049752",
"0.49500108",
"0.4917279",
"0.4909298",
"0.48687622",
"0.4865209",
"0.4790585",
"0.47357494",
"0.46259487",
"0.46080807",
"0.45991012",
"0.45667055",
"0.45524898",
"0.4544485",
"0.453... | 0.5458704 | 3 |
Makes the docstring more suitable for html. | def doc_to_html(doc):
doc = (doc.replace('\\n','<br>')
.replace('->','→')
.replace('...', '…')
.replace('\\\\', '\\'))
if doc.startswith('"'):
doc = doc[1:]
if doc.endswith('"'):
doc = doc[:-1]
return doc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DocString():\n return",
"def main_docstring():",
"def docstring_hack():\n pass",
"def documentation():\n return auto.html()",
"def documentation():\n return render_template('help.html')",
"def func_doc():",
"def __doc__(self, ???):",
"def _add_doc(func, doc):\r\n func.__doc__ = doc... | [
"0.7670118",
"0.76439434",
"0.7628076",
"0.7477301",
"0.7309437",
"0.7032047",
"0.6866492",
"0.6863824",
"0.6863824",
"0.6863824",
"0.6820424",
"0.6789934",
"0.67546",
"0.67455196",
"0.6693798",
"0.6692449",
"0.66803527",
"0.6592285",
"0.6549525",
"0.65468615",
"0.654198",
... | 0.0 | -1 |
Writes an htmlfile documenting the passed in methods, using the docstrings (as returned by parse_file) | def write_method_doc(file_name, entries):
with open(file_name, 'w', newline='\n') as f:
f.write('<table border="0">')
f.write('<tr><td><b>Method</b></td><td><b>Description</b></td></tr>')
for items in sorted(entries, key=itemgetter(3)):
f.write('<tr><td valign="top">%s</td><td>%s</td></tr>' %
(items[3], doc_to_html(items[4])))
f.write('</table>') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_member_documentation_pages(\n documenter: sphinx.ext.autodoc.Documenter):\n for entry in _get_documenter_members(documenter):\n if entry.is_inherited:\n continue\n if (entry.overload and entry.overload.overload_id and\n re.fullmatch('[0-9]+', entry.overload.overload_id)):\n lo... | [
"0.60740525",
"0.59743536",
"0.59427845",
"0.5824418",
"0.5816547",
"0.57680935",
"0.5738121",
"0.5711054",
"0.56876665",
"0.5671265",
"0.56643975",
"0.56380713",
"0.5587306",
"0.55807567",
"0.5538951",
"0.55344105",
"0.5531077",
"0.5515236",
"0.54965585",
"0.54924417",
"0.54... | 0.75820845 | 0 |
Writes an htmlfile documenting the passed in properties, using the docstrings (as returned by parse_file) Expects a list of (propertyname, docstr)tuples. | def write_property_doc(file_name, entries):
if len(entries) == 0:
return
with open(file_name, 'w', newline='\n') as f:
f.write('<!-- Generated by %s -->' % os.path.basename(__file__))
f.write('<table border="0">')
f.write('<tr><td><b>Property</b></td><td><b>Description</b></td></tr>')
for items in entries:
f.write('<tr><td valign="top">%s</td><td>%s</td></tr>' %
(items[1], doc_to_html(items[2])))
f.write('</table>') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_to_file(properties,file):\n properties['tempfile']=None\n properties['remove_temp']=True\n properties['outfile']=file",
"def write_html(filelist):\n tmp = tempfile.NamedTemporaryFile(mode=\"w+\", suffix=\".html\", delete=False)\n\n tmp.write(r\"\"\"<!doctype html>\n <html>\... | [
"0.587501",
"0.5714326",
"0.55795753",
"0.55168897",
"0.5469178",
"0.54641604",
"0.5401127",
"0.5393503",
"0.538135",
"0.5371805",
"0.53659755",
"0.53104347",
"0.52841675",
"0.5282833",
"0.5242343",
"0.51993394",
"0.5180886",
"0.51743466",
"0.51662326",
"0.510156",
"0.5079105... | 0.7246242 | 0 |
Generate the Python methoddef header and html documentation for the c++file indicated by src_file_name, by locating "special" Ccomments. The header is saved to dst_file_name and the html documentation to dst_doc_file_name. The name is used for the PyMethodDef and PyGetSetDef. | def generate(src_file_names,
dst_file_name,
dst_doc_file_name,
dst_property_doc_file_name,
name):
methods = []
properties = []
extra_includes = []
entries = (methods, properties)
for src_file_name in src_file_names:
check_file(src_file_name)
m, p = parse_file(src_file_name)
methods.extend(m)
properties.extend(p)
extra_includes.extend(find_extra_include(src_file_name))
if len(entries[0]) == 0 and len(entries[1]) == 0:
print("No entries found in %s." % src_file_name)
exit(1)
write_result(dst_file_name, name, entries, extra_includes, src_file_names)
write_method_doc(dst_doc_file_name, entries[0])
write_property_doc(dst_property_doc_file_name, entries[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_headers(src_files, out_root, doc_root):\r\n\r\n if not os.path.exists(out_root):\r\n os.makedirs(out_root)\r\n did_print_heading = False\r\n changed = False\r\n for (name, files) in src_files:\r\n if files.__class__ == str:\r\n src = files\r\n files = (... | [
"0.67592466",
"0.58502406",
"0.58490044",
"0.5828653",
"0.5795212",
"0.5750393",
"0.57325697",
"0.5689374",
"0.5534153",
"0.5486456",
"0.5484368",
"0.54745",
"0.546431",
"0.54593277",
"0.5433575",
"0.5428016",
"0.5416794",
"0.5406283",
"0.537415",
"0.53738326",
"0.53385717",
... | 0.6063957 | 1 |
Generate headers with a Python methoddef array and html documentation tables for the listed source files. | def generate_headers(src_files, out_root, doc_root):
if not os.path.exists(out_root):
os.makedirs(out_root)
did_print_heading = False
changed = False
for (name, files) in src_files:
if files.__class__ == str:
src = files
files = (src,)
else:
src = files[0]
dst = src.replace(".hh", "-method-def.hh")
dst = dst.replace(".cpp", "-method-def.hh")
dst = os.path.join(out_root, os.path.split(dst)[1])
dst_doc = src.replace(".hh", '-methods.txt')
dst_doc = dst_doc.replace(".cpp", '-methods.txt')
dst_doc_filename = os.path.split(dst_doc)[1]
dst_doc_filename = os.path.join(doc_root, dst_doc_filename)
dst_prop_doc = src.replace(".cpp", '-properties.txt')
dst_doc_prop_filename = os.path.split(dst_prop_doc)[1]
dst_doc_prop_filename = os.path.join(doc_root, dst_doc_prop_filename)
if util.changed(src, dst):
if not did_print_heading:
print("* Generating Python method definitions.")
did_print_heading = True
generate(files, dst, dst_doc_filename, dst_doc_prop_filename, name)
changed = True
if not changed:
print("* Python method definitions up to date.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_included_function_list_readme():\n import iteration_utilities\n from iteration_utilities import Iterable\n from itertools import chain\n from operator import itemgetter\n from astropy.table import Table\n from astropy.io.ascii import RST\n\n rtd_link = '`{name} <http://iteration-uti... | [
"0.6388133",
"0.63291883",
"0.6162227",
"0.61605513",
"0.605548",
"0.5960463",
"0.5946018",
"0.58367574",
"0.582316",
"0.58196837",
"0.58120084",
"0.5807799",
"0.5753701",
"0.57469726",
"0.57268125",
"0.5716415",
"0.5679393",
"0.56756175",
"0.5639785",
"0.5602997",
"0.5587299... | 0.77620685 | 0 |
Fetch all the teams that are participating in a league. | def crawl_competition(cls, competition: Competition, follow_pagination: bool = False) -> int:
count = 0
logger = CrawlerLogger.get_logger_for_class(cls)
url = competition.get_fixtures_url()
try:
logger.log("crawl per league {}".format(url))
count = count + cls.crawl_by_url(competition, url)
if follow_pagination:
count = count + cls.follow_pagination(competition, url)
except Exception as e:
logger.error(e)
rollbar.report_exc_info(sys.exc_info())
# TODO: statistics
# if lock:
# with lock:
# self.statistics['fixtures'] += count
# else:
# self.statistics['fixtures'] += count
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_teams(self):\n return self._db.Teams.find({})",
"def get_teams():",
"def getAllTeams(self):\n return []",
"def get_teams(self):\n url = 'teams'\n result = self.get(url)\n return result.get('teams', result)",
"def get_all_matches_by_league(self):\n raise... | [
"0.73225325",
"0.7137867",
"0.70343244",
"0.6934072",
"0.69133794",
"0.68307376",
"0.6677932",
"0.6623947",
"0.659409",
"0.6592349",
"0.6555678",
"0.6542481",
"0.64531434",
"0.6439132",
"0.6427429",
"0.6416407",
"0.6407396",
"0.64073485",
"0.6385755",
"0.6368741",
"0.6295079"... | 0.0 | -1 |
Construct an instance of ``client_class`` and register it under given alias. | def create_connection(self, alias='async', client_class=AsyncElasticsearch, **kwargs):
kwargs.setdefault('serializer', serializer)
conn = self._conns[alias] = client_class(**kwargs)
return conn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_client(self, client, client_name):\n self.clients[client_name] = client",
"def create_client(self, module_name, version, client_class):\n # NOTE(kiennt): Get created client rather create a new one.\n # The key is the combination of module_name and version.\n ... | [
"0.5862595",
"0.57551134",
"0.57218677",
"0.56946874",
"0.56426543",
"0.5604221",
"0.5513979",
"0.5479135",
"0.5450147",
"0.54027754",
"0.53822577",
"0.5351544",
"0.5310474",
"0.53071845",
"0.5302867",
"0.5245894",
"0.52256596",
"0.5221313",
"0.52094626",
"0.52094626",
"0.520... | 0.64954954 | 0 |
Return the offset in hours from UTC as a float. | def get_tz(self):
for _, element in etree.iterparse(self.source):
if element.tag == TIMEZONE:
return float(element.text or 0.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tz_offset(self) -> float:\n return self.AD.tz.utcoffset(self.datetime()).total_seconds() / 60",
"def get_utc_offset():\n timedelta = datetime.datetime.now() - datetime.datetime.utcnow()\n # XXX: `return -time.timezone`?\n return timedelta.total_seconds()",
"def get_tz_offset_seconds() -... | [
"0.70775425",
"0.6989547",
"0.6908614",
"0.67074597",
"0.6508781",
"0.64082044",
"0.6225916",
"0.6165682",
"0.61237943",
"0.6042478",
"0.6030816",
"0.59795976",
"0.58823085",
"0.5826774",
"0.57685786",
"0.5765773",
"0.57652164",
"0.5705759",
"0.5696149",
"0.5687313",
"0.56625... | 0.4868406 | 78 |
Localize tznaive TimeSeries to a fixedoffset time zone. Most time zones are offset from UTC by a whole number of hours, but a few are offset by 30 or 45 minutes. An offset of 0 is specialcased to return UTC. | def tz_localize(dataframe, offset_in_hours=0, copy=True):
return dataframe.tz_localize(FixedOffset(offset_in_hours * 60), copy=copy) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fixed_timezone(offset):\n\n if isinstance(offset, timedelta):\n offset = offset.total_seconds() // 60\n\n sign = \"-\" if offset < 0 else \"+\"\n hhmm = \"%02d%02d\" % divmod(abs(offset), 60)\n name = sign + hhmm\n\n return timezone(timedelta(minutes=offset), name)",
"def get_fixed_... | [
"0.733858",
"0.73315036",
"0.7123728",
"0.6075806",
"0.5935274",
"0.58467084",
"0.5763584",
"0.5721623",
"0.5694093",
"0.56887317",
"0.56338304",
"0.5555357",
"0.555062",
"0.55430114",
"0.5529573",
"0.5487007",
"0.54707557",
"0.54601884",
"0.5453896",
"0.5438302",
"0.5430976"... | 0.64824516 | 3 |
Convert sequence of evenly spaced nonnegative ints to equivalent slice. If the returned slice object is `s = slice(start, stop, step)`, the | def _range_to_slice(index):
if not len(index):
return slice(None, 0, None)
if any(i < 0 for i in index):
raise ValueError(f'Could not convert {index} to a slice '
'(contains negative elements)')
increments_left = set(np.diff(index))
step = increments_left.pop() if increments_left else 1
if step == 0 or increments_left:
raise ValueError(f'Could not convert {index} to a slice '
'(unevenly spaced or zero increments)')
start = index[0]
stop = index[-1] + step
# Avoid descending below 0 and thereby wrapping back to the top
return slice(start, stop if stop >= 0 else None, step) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slicer(seq, start=None, stop=None, step=None):\n return seq[start:stop:step]",
"def normalize_slice(s):\n start, stop, step = s.start, s.stop, s.step\n if start is None:\n start = 0\n if step is None:\n step = 1\n if start < 0 or step < 0 or stop is not None and stop < 0:\n ... | [
"0.8011135",
"0.7739454",
"0.74094546",
"0.72735506",
"0.717713",
"0.70792943",
"0.7041868",
"0.690513",
"0.6796296",
"0.6779164",
"0.6697571",
"0.6686825",
"0.66782004",
"0.66213644",
"0.6585468",
"0.6580096",
"0.647419",
"0.6415965",
"0.64123",
"0.63498336",
"0.63340086",
... | 0.7165115 | 5 |
Generate an equivalent index expression that is cheaper to evaluate. Advanced ("fancy") indexing using arrays/lists of booleans or ints is much slower than basic indexing using slices and scalar ints in dask. If the fancy index on a specific axis/dimension selects a range with a fixed (nonzero) step size between indices, however, it can be converted into an equivalent slice to get a simple index instead. Note that when indexing along multiple axes with arrays, this may change the semantics of the indexing (see NumPy's `NEP 21`_ for details). This simplification is only guaranteed to be safe when used with outer indexing. | def _simplify_index(indices, shape):
# First clean up and check indices, unpacking ellipsis and boolean arrays
indices = da.slicing.normalize_index(indices, shape)
out = []
axis = 0
for index in indices:
if index is not np.newaxis:
length = shape[axis]
axis += 1
# If there is 1-D fancy index on this axis, try to convert to slice
if isinstance(index, np.ndarray) and index.ndim == 1:
try:
index = _range_to_slice(index)
except ValueError:
pass
else:
index = da.slicing.normalize_slice(index, length)
out.append(index)
return tuple(out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self, arr, idx, temp = True, name = None):\n \n temp = temp or name is not None\n \n arr_t = arr.type\n\n if isinstance(arr_t, ScalarT):\n # even though it's not correct externally, it's\n # often more convenient to treat indexing\n # into scalars as the identity function.\n... | [
"0.658317",
"0.6367172",
"0.6293228",
"0.629157",
"0.62566864",
"0.60536855",
"0.60536855",
"0.60373294",
"0.5884561",
"0.58782953",
"0.58534575",
"0.58327305",
"0.5827532",
"0.5753103",
"0.5751057",
"0.5711585",
"0.5674995",
"0.5662051",
"0.56028384",
"0.5559749",
"0.5525",
... | 0.6160974 | 5 |
Perform outer indexing on dask array `x`, one dimension at a time. It is assumed that `indices` is suitably normalised (no ellipsis, etc.) | def _dask_oindex(x, indices):
axis = 0
for index in indices:
x = da.take(x, index, axis=axis)
# If axis wasn't dropped by a scalar index:
if not isinstance(index, Integral):
axis += 1
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dask_getitem(x, indices):\n indices = _simplify_index(indices, x.shape)\n try:\n out = x[indices]\n except NotImplementedError:\n out = _dask_oindex(x, indices)\n # dask does culling anyway as part of optimization, but it first calls\n # ensure_dict, which copies all the keys, pres... | [
"0.6630981",
"0.65513384",
"0.625214",
"0.60793054",
"0.5899021",
"0.58930767",
"0.584284",
"0.58320093",
"0.57988596",
"0.57887155",
"0.57549566",
"0.5752462",
"0.57381105",
"0.5714157",
"0.5673157",
"0.5671463",
"0.56660175",
"0.56258434",
"0.56149113",
"0.5592513",
"0.5555... | 0.75664073 | 0 |
Index a dask array, with ND fancy index support and better performance. This is a dropin replacement for ``x[indices]`` that goes one further by implementing "ND fancy indexing" which is still unsupported in dask. If `indices` contains multiple fancy indices, perform outer (`oindex`) indexing. This behaviour deviates from NumPy, which performs the more general (but also more obtuse) vectorized (`vindex`) indexing in this case. See NumPy `NEP 21`_, `dask 433`_ and `h5py 652`_ for more details. | def dask_getitem(x, indices):
indices = _simplify_index(indices, x.shape)
try:
out = x[indices]
except NotImplementedError:
out = _dask_oindex(x, indices)
# dask does culling anyway as part of optimization, but it first calls
# ensure_dict, which copies all the keys, presumably to speed up the
# case where most keys are retained. A lazy indexer is normally used to
# fetch a small part of the data.
if np.product(out.numblocks) < 0.5 * np.product(x.numblocks):
dsk = dask.optimization.cull(out.dask, out.__dask_keys__())[0]
out.dask = dask.highlevelgraph.HighLevelGraph.from_collections(out.name, dsk)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dask_oindex(x, indices):\n axis = 0\n for index in indices:\n x = da.take(x, index, axis=axis)\n # If axis wasn't dropped by a scalar index:\n if not isinstance(index, Integral):\n axis += 1\n return x",
"def array_array_index(array, indices):\n if indices.shape[1... | [
"0.7357183",
"0.70139194",
"0.6808042",
"0.678235",
"0.65021425",
"0.6417131",
"0.6361745",
"0.6331414",
"0.6304895",
"0.6261165",
"0.60468435",
"0.5991131",
"0.5980531",
"0.5952801",
"0.5908524",
"0.58395267",
"0.5770695",
"0.57215935",
"0.5679449",
"0.56439877",
"0.564334",... | 0.6581825 | 4 |
Determine appropriate name for callable `f` (akin to function name). | def _callable_name(f):
try:
return f.__name__
except AttributeError:
if isinstance(f, partial):
return f.func.__name__
return f.__class__.__name__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_callable_name(func):\n if isinstance(func, functools.partial):\n return get_callable_name(func.func)\n else:\n return func.__name__",
"def funcname(func):\n try:\n return '%s()' % func.__name__\n except AttributeError:\n return repr(func)",
"def name_func(func, num, params):... | [
"0.72435784",
"0.68455863",
"0.67366433",
"0.6668289",
"0.6594174",
"0.6500698",
"0.6486582",
"0.6452623",
"0.6450915",
"0.64476234",
"0.640476",
"0.640476",
"0.63907254",
"0.63632125",
"0.63278747",
"0.6300249",
"0.6296908",
"0.6286463",
"0.62828344",
"0.6204712",
"0.6204712... | 0.8215907 | 0 |
Short humanfriendly string representation of lazy transform object. | def __repr__(self):
class_name = self.__class__.__name__
dtype = 'unchanged' if self.dtype is None else self.dtype
return f"<katdal.{class_name} '{self.name}': type '{dtype}' at {id(self):#x}>" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n names = [self.name]\n names += [_callable_name(transform) for transform in self.transforms]\n return ' | '.join(names) + f' -> {self.shape} {self.dtype}'",
"def __repr__(self):\n format_string = self.__class__.__name__ + '('\n for t in self.transforms:\n ... | [
"0.68118584",
"0.6719526",
"0.6454018",
"0.6439769",
"0.62236834",
"0.62182367",
"0.6107003",
"0.60770506",
"0.6071675",
"0.6052423",
"0.6029779",
"0.5984073",
"0.5969814",
"0.5924413",
"0.59127647",
"0.5897758",
"0.5897036",
"0.58890736",
"0.5888635",
"0.586922",
"0.5840094"... | 0.0 | -1 |
Transform data (`keep` is userspecified secondstage index). | def __call__(self, data, keep):
return self.transform(data, keep) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform(self, dataframe: DataFrame) -> DataFrame:",
"def convert_index_select(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n index = g.get_node(op.input(\"Index\")[0])\n axis = op.attr(\"dim\")\n out = _op.transform.take(x, index, axis, mode=\"wrap\")\n g.add_node(op.output(\"Out\")... | [
"0.55106413",
"0.54800296",
"0.53775775",
"0.5366347",
"0.5208422",
"0.52055204",
"0.51941574",
"0.5188958",
"0.5141277",
"0.51131773",
"0.5106497",
"0.510201",
"0.50470954",
"0.5045959",
"0.502488",
"0.49978232",
"0.49935693",
"0.4965403",
"0.49543115",
"0.4952945",
"0.49435... | 0.5873317 | 0 |
Short humanfriendly string representation of lazy indexer object. | def __repr__(self):
return "<katdal.{} '{}': shape {}, type {} at {:#x}>".format(
self.__class__.__name__, self.name, self.shape, self.dtype, id(self)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return \"{}_human\".format(self.index)",
"def __str__(self) -> str:\n return f\"K{self._index_to_unicode(self.index)}\"",
"def __repr__(self):\n return str(self.index)",
"def __repr__(self):\n return \"%s[%s]\" % (self.index_type, self.query)",
"def short_st... | [
"0.6915522",
"0.68598956",
"0.6718207",
"0.6625014",
"0.6598968",
"0.65907544",
"0.6485251",
"0.64300734",
"0.6380875",
"0.62672544",
"0.62349004",
"0.6124259",
"0.609269",
"0.60701317",
"0.60654444",
"0.6030815",
"0.60238296",
"0.59876156",
"0.59537524",
"0.5930237",
"0.5860... | 0.0 | -1 |
Helper function to create strings for display (limits dtype length). | def _name_shape_dtype(self, name, shape, dtype):
dtype_str = (str(dtype)[:50] + '...') if len(str(dtype)) > 50 else str(dtype)
return f"{name} -> {shape} {dtype_str}" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n largest_element = max(self)\n length = int(log10(largest_element)) + 1\n\n s = '\\n'.join([' '.join([\n f\"{elem:>{length}}\" for elem in row])\n for row in self.data])\n return s + '\\n'",
"def __str__(self):\n if self.defau... | [
"0.66722065",
"0.6646886",
"0.66436577",
"0.6635707",
"0.6561914",
"0.6553865",
"0.64629567",
"0.6437168",
"0.6394366",
"0.63221836",
"0.6237532",
"0.62296236",
"0.6201392",
"0.61959225",
"0.61572546",
"0.615381",
"0.61407906",
"0.612819",
"0.61144656",
"0.610394",
"0.6093792... | 0.5689976 | 93 |
Verbose humanfriendly string representation of lazy indexer object. | def __str__(self):
shape, dtype = self._initial_shape, self._initial_dtype
descr = [self._name_shape_dtype(self.name, shape, dtype)]
for transform in self.transforms:
shape, dtype = transform.new_shape(shape), transform.dtype if transform.dtype is not None else dtype
descr += ['-> ' + self._name_shape_dtype(transform.name, shape, dtype)]
return '\n'.join(descr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n return str(self.index)",
"def __str__(self):\n return \"{}_human\".format(self.index)",
"def __repr__(self) -> str:\n return f\"{self.__class__.__name__}({self.indices})\"",
"def __repr__(self):\n return \"%s[%s]\" % (self.index_type, self.query)",
"def get... | [
"0.67205507",
"0.67017853",
"0.6618106",
"0.65178007",
"0.6516238",
"0.6503144",
"0.62764376",
"0.6239224",
"0.6238777",
"0.6221722",
"0.6112763",
"0.6100795",
"0.6047101",
"0.6037867",
"0.6026874",
"0.6009232",
"0.6002592",
"0.59721404",
"0.5880291",
"0.58769834",
"0.5845483... | 0.0 | -1 |
Extract a selected array from the underlying dataset. This applies the given secondstage index on top of the firststage index and retrieves the relevant data from the dataset as an array, optionally transforming it afterwards. | def __getitem__(self, keep):
ndim = len(self.dataset.shape)
# Ensure that keep is a tuple (then turn it into a list to simplify further processing)
keep = list(keep) if isinstance(keep, tuple) else [keep]
# The original keep tuple will be passed to data transform chain
original_keep = tuple(keep)
# Ensure that keep is same length as data dimension (truncate or pad with blanket slices as necessary)
keep = keep[:ndim] + [slice(None)] * (ndim - len(keep))
# Map current selection to original data indices based on any existing initial selection, per data dimension
keep = [(dkeep if dlookup is None else dlookup[dkeep]) for dkeep, dlookup in zip(keep, self._lookup)]
# Iterate over dimensions of dataset, storing information on selection on each dimension:
# `selection` is a list with one element per dimension; each element is a list of contiguous segments along
# the dimension, and each segment is represented by a tuple of 3 elements:
# (dataset selection, post-selection, output array selection)
# Similarly, `segment_sizes` is a list of lists of segment lengths (empty lists for scalar-selected dimensions)
selection, segment_sizes = [], []
for dim_keep, dim_len in zip(keep, self.dataset.shape):
if np.isscalar(dim_keep):
# If selection is a scalar, pass directly to dataset selector and remove dimension from output
selection.append([(dim_keep, None, None)])
segment_sizes.append([])
elif isinstance(dim_keep, slice):
# If selection is a slice, pass directly to dataset selector without post-selection
start, stop, stride = dim_keep.indices(dim_len)
segm_size = len(range(start, stop, stride))
selection.append([(slice(start, stop, stride), slice(None), slice(0, segm_size, 1))])
segment_sizes.append([segm_size])
elif len(dim_keep) == 0:
# If selection is empty, pass to post-selector, as HDF5 datasets do not support zero-length selection
selection.append([(slice(0, 1, 1), slice(0, 0, 1), slice(0, 0, 1))])
segment_sizes.append([0])
else:
# Anything else is advanced indexing via bool or integer sequences
dim_keep = np.atleast_1d(dim_keep)
# Turn boolean mask into integer indices (True means keep that index)
if dim_keep.dtype == bool and len(dim_keep) == dim_len:
dim_keep = np.nonzero(dim_keep)[0]
elif not np.all(dim_keep == np.unique(dim_keep)):
raise TypeError('LazyIndexer cannot handle duplicate or unsorted advanced integer indices')
# Split indices into multiple contiguous segments (specified by first and one-past-last data indices)
jumps = np.nonzero(np.diff(dim_keep) > 1)[0]
first = [dim_keep[0]] + dim_keep[jumps + 1].tolist()
last = dim_keep[jumps].tolist() + [dim_keep[-1]]
segments = np.c_[first, np.array(last) + 1]
if len(dim_keep) > 0.2 * dim_len and len(segments) > 1:
# If more than 20% of data are selected in 2 or more separate segments (the Ratcliffian benchmark),
# select data at dataset level with a single slice spanning segments and then postselect the ndarray
selection.append([(slice(segments[0, 0], segments[-1, 1], 1),
dim_keep - dim_keep[0], slice(0, len(dim_keep), 1))])
segment_sizes.append([len(dim_keep)])
else:
# Turn each segment into a separate slice at dataset level without post-selection,
# and construct contiguous output slices of the same segment sizes
segm_sizes = [end - start for start, end in segments]
segm_starts = np.cumsum([0] + segm_sizes)
selection.append([(slice(start, end, 1), slice(None), slice(segm_starts[n], segm_starts[n + 1], 1))
for n, (start, end) in enumerate(segments)])
segment_sizes.append(segm_sizes)
# Short-circuit the selection if all dimensions are selected with scalars (resulting in a scalar output)
if segment_sizes == [[]] * ndim:
out_data = self.dataset[tuple([select[0][0] for select in selection])]
else:
# Use dense N-dimensional meshgrid to slice data set into chunks, based on segments along each dimension
chunk_indices = np.mgrid[[slice(0, len(select), 1) for select in selection]]
# Pre-allocate output ndarray to have the correct shape and dtype (will be at least 1-dimensional)
out_data = np.empty([np.sum(segments) for segments in segment_sizes if segments], dtype=self.dataset.dtype)
# Iterate over chunks, extracting them from dataset and inserting them into the right spot in output array
for chunk_index in chunk_indices.reshape(ndim, -1).T:
# Extract chunk from dataset (don't use any advanced indexing here, only scalars and slices)
dataset_select = tuple([select[segment][0] for select, segment in zip(selection, chunk_index)])
chunk = self.dataset[dataset_select]
# Perform post-selection on chunk (can be fancier / advanced indexing because chunk is now an ndarray)
post_select = [select[segment][1] for select, segment in zip(selection, chunk_index)]
# If any dimensions were dropped due to scalar indexing, drop them from post_select/out_select tuples
post_select = tuple([select for select in post_select if select is not None])
# Do post-selection one dimension at a time, as ndarray does not allow simultaneous advanced indexing
# on more than one dimension. This caters for the scenario where more than one dimension satisfies
# the Ratcliffian benchmark (the only way to get advanced post-selection).
for dim in range(len(chunk.shape)):
# Only do post-selection on this dimension if non-trivial (otherwise an unnecessary copy happens)
if not (isinstance(post_select[dim], slice) and post_select[dim] == slice(None)):
# Prepend the appropriate number of colons to the selection to place it at correct dimension
chunk = chunk[[slice(None)] * dim + [post_select[dim]]]
# Determine appropriate output selection and insert chunk into output array
out_select = [select[segment][2] for select, segment in zip(selection, chunk_index)]
out_select = tuple([select for select in out_select if select is not None])
out_data[out_select] = chunk
# Apply transform chain to output data, if any
return reduce(lambda data, transform: transform(data, original_keep), self.transforms, out_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select(arrays, index):\n if arrays is None or any(i is None for i in arrays):\n return arrays\n return tuple(i.ravel()[index] for i in arrays)",
"def __getitem__(self, index: int) -> Tuple[Any, Any]:\n datum, target = self.data[index], self.targets[index]\n \n if self.transf... | [
"0.5978752",
"0.57524294",
"0.5708342",
"0.55696416",
"0.556528",
"0.5534159",
"0.55027837",
"0.54934233",
"0.54812884",
"0.54775065",
"0.54741627",
"0.54486006",
"0.5447731",
"0.54420215",
"0.54378104",
"0.5379849",
"0.537284",
"0.5363644",
"0.5344681",
"0.5316661",
"0.53088... | 0.5002727 | 73 |
Transformations that are applied after firststage indexing. | def transforms(self):
return self._transforms | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform():",
"def _apply_transform(self):\n pass",
"def transform():\n pass",
"def transform(self):",
"def reconstruct_input(self, ix):",
"def _calculate_transforms(self):\n\n self._logger.info(\"Generating transformations.\")\n\n # Calculate partial transforms - get par... | [
"0.64521396",
"0.6436142",
"0.625093",
"0.60931164",
"0.59010315",
"0.5887653",
"0.5802023",
"0.5802023",
"0.5802023",
"0.5802023",
"0.5802023",
"0.5802023",
"0.5802023",
"0.5789174",
"0.5749093",
"0.57337826",
"0.57290673",
"0.5708371",
"0.5691743",
"0.56447583",
"0.5632075"... | 0.0 | -1 |
Array after firststage indexing and transformation. | def dataset(self):
with self._lock:
if self._dataset is None:
if isinstance(self._orig_dataset, DaskLazyIndexer):
self._orig_dataset = self._orig_dataset.dataset
dataset = dask_getitem(self._orig_dataset, self.keep)
for transform in self.transforms:
dataset = transform(dataset)
self._dataset = dataset
self._orig_dataset = None
return self._dataset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def array(self):",
"def _idxs_postformat_array(self):\n self.idxs = np.array(self.idxs)",
"def __array__(self):\n return self.array",
"def __array__(self):\n return np.asarray(self.data)",
"def transform(self, x: Array2D) -> Array2D:",
"def __call__(self):\n return self.array"... | [
"0.7165916",
"0.6688537",
"0.65816486",
"0.6539245",
"0.6529321",
"0.65116245",
"0.6501995",
"0.6398836",
"0.6352268",
"0.63407344",
"0.6338532",
"0.62778264",
"0.6249261",
"0.6225504",
"0.62233794",
"0.62099195",
"0.6193239",
"0.618922",
"0.61748564",
"0.61565554",
"0.615107... | 0.0 | -1 |
Extract a selected array from the underlying dataset. This applies the given secondstage index on top of the current dataset, which already has a firststage index and optional transforms applied to it. The indexer also finally stops being lazy and triggers dask computation to arrive at the output array. Both indexing stages perform "outer" indexing (aka oindex), which indexes each dimension independently. This is especially relevant for advanced or fancy indexing. | def __getitem__(self, keep):
return self.get([self], keep)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batched_index_select(input, dim, index):\n views = [input.shape[0]] + [1 if i != dim else -1 for i in range(1, len(input.shape))]\n expanse = list(input.shape)\n expanse[0] = -1\n expanse[dim] = -1\n index = index.view(views).expand(expanse)\n return torch.gather(input, dim, index)",
"def c... | [
"0.6476484",
"0.61325866",
"0.5939623",
"0.5834367",
"0.5815109",
"0.5787023",
"0.578326",
"0.5776111",
"0.56746083",
"0.563971",
"0.5628474",
"0.5548305",
"0.5501211",
"0.5498332",
"0.5483299",
"0.54740727",
"0.54704463",
"0.5469028",
"0.54643875",
"0.54544646",
"0.54269475"... | 0.0 | -1 |
Extract several arrays from the underlying dataset. | def get(cls, arrays, keep, out=None):
kept = [dask_getitem(array.dataset, keep) for array in arrays]
# Workaround for https://github.com/dask/dask/issues/7187
# This is equivalent to da.compute(kept), but does not allocate
# excessive memory and is potentially faster.
if out is None:
out = [np.empty(array.shape, array.dtype) for array in kept]
da.store(kept, out, lock=False)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_iter_data(dataset):\n num_samples = dataset.num_examples\n\n handle = dataset.open()\n features = []\n targets = []\n for i in xrange(num_samples):\n data = dataset.get_data(handle)\n features.append(data[0])\n targets.append(data[1])\n\n dataset.close(handle)\n\n ... | [
"0.6656692",
"0.66058266",
"0.65474606",
"0.65298635",
"0.6464468",
"0.64520764",
"0.6305162",
"0.624804",
"0.62314004",
"0.6222413",
"0.62146145",
"0.6206641",
"0.61618036",
"0.6148572",
"0.61412054",
"0.60787904",
"0.6073376",
"0.6064661",
"0.6064661",
"0.6059199",
"0.60515... | 0.0 | -1 |
Short humanfriendly string representation of indexer object. | def __repr__(self):
return "<katdal.{} '{}': shape {}, type {} at {:#x}>".format(
self.__class__.__name__, self.name, self.shape, self.dtype, id(self)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self) -> str:\n return f\"K{self._index_to_unicode(self.index)}\"",
"def __str__(self):\n return \"{}_human\".format(self.index)",
"def __repr__(self):\n return \"%s[%s]\" % (self.index_type, self.query)",
"def __repr__(self):\n return str(self.index)",
"def __repr__... | [
"0.7194278",
"0.7162457",
"0.711871",
"0.69272774",
"0.6822385",
"0.6694754",
"0.6636655",
"0.6632189",
"0.66048366",
"0.6591673",
"0.65751594",
"0.65524185",
"0.640755",
"0.63549006",
"0.62816143",
"0.61983436",
"0.6137607",
"0.6099416",
"0.60898465",
"0.6058687",
"0.6045976... | 0.0 | -1 |
Verbose humanfriendly string representation of indexer object. | def __str__(self):
names = [self.name]
names += [_callable_name(transform) for transform in self.transforms]
return ' | '.join(names) + f' -> {self.shape} {self.dtype}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n return \"%s[%s]\" % (self.index_type, self.query)",
"def __str__(self):\n return \"{}_human\".format(self.index)",
"def __repr__(self):\n return str(self.index)",
"def __repr__(self) -> str:\n return f\"{self.__class__.__name__}({self.indices})\"",
"def __s... | [
"0.7050152",
"0.70169646",
"0.7002474",
"0.6923666",
"0.6894936",
"0.67668396",
"0.66782624",
"0.6649045",
"0.6633035",
"0.65953916",
"0.6495072",
"0.639294",
"0.63205606",
"0.63171315",
"0.63001937",
"0.6277957",
"0.6208957",
"0.6134051",
"0.608598",
"0.6084308",
"0.6039816"... | 0.0 | -1 |
Shape of array after firststage indexing and transformation. | def shape(self):
return self.dataset.shape | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self):\n return self.array.shape",
"def shape(self):\n return self.to_array().shape",
"def shape(self):\n return self.X.shape",
"def shape(self):\n return self[0].shape",
"def shape(self,squeeze=True):\n return np.shape(self.getData(squeeze=squeeze))",
"def sh... | [
"0.74618185",
"0.72965395",
"0.72233784",
"0.7130862",
"0.71119326",
"0.70900625",
"0.697013",
"0.6945931",
"0.6945931",
"0.6945931",
"0.6945931",
"0.6945931",
"0.69400984",
"0.68968654",
"0.68968654",
"0.68957853",
"0.68937385",
"0.68937385",
"0.68937385",
"0.684294",
"0.683... | 0.66548723 | 26 |
Data type of array after firststage indexing and transformation. | def dtype(self):
return self.dataset.dtype | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datatype_name(self):\n return 'array'",
"def type_array():\n return []",
"def get_data_type(self, idx):\n return(self.data[idx].dtype)",
"def astype(self, dtype):\n return NoneArray",
"def dtype(self):\n return self.array.dtype",
"def test_hk_getdata_field_array_typ... | [
"0.7009306",
"0.68862",
"0.6857213",
"0.6660171",
"0.6584545",
"0.6563583",
"0.6512989",
"0.6492781",
"0.64653784",
"0.64411944",
"0.6405585",
"0.64019823",
"0.63657856",
"0.63524574",
"0.6346064",
"0.63260984",
"0.6315588",
"0.6220689",
"0.6218643",
"0.62170565",
"0.6210315"... | 0.62220097 | 17 |
Save the post data when adding a new item. | def perform_create(self, serializer):
serializer.save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _store(self):\n self._post_item.save()\n self._attachment_item.save()\n self._marshaller.marshall(self._post_item)",
"def post(self, item):\n\n db.session.add(item)\n\n return item",
"def post(self):\n data = request.json\n return save_new_post(data=data)",
... | [
"0.73508483",
"0.7192973",
"0.71141416",
"0.6993671",
"0.6968998",
"0.6730203",
"0.6696825",
"0.66588724",
"0.66392076",
"0.6593812",
"0.65399164",
"0.65288574",
"0.64822817",
"0.64620656",
"0.645195",
"0.6377771",
"0.63727283",
"0.636567",
"0.63141656",
"0.6302436",
"0.62708... | 0.0 | -1 |
Initialises the ``InputDevice`` object and starts ``pifacecad.SwitchEventListener``. Also, registers callbacks to ``press_key`` method. | def __init__(self):
self.cad = pifacecad.PiFaceCAD()
self.listener = pifacecad.SwitchEventListener(chip=self.cad)
for i in range(8):
self.listener.register(i, pifacecad.IODIR_FALLING_EDGE, self.press_key)
self.listener.activate()
atexit.register(self.atexit) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_listener():\n listener = keyboard.Listener(\n on_press=on_press\n )\n listener.start()",
"def setInput(self):\n gpio.setup(self.bcm_id, gpio.IN, pull_up_down=self.pull)\n self.mode = gpio.IN",
"def startCallback (self):\n if self.hasCallback:\n return\n... | [
"0.6211504",
"0.6013261",
"0.5729392",
"0.56921124",
"0.5665231",
"0.5625194",
"0.5592315",
"0.5584637",
"0.5559815",
"0.5458288",
"0.54401493",
"0.53518695",
"0.5323422",
"0.5239154",
"0.5230533",
"0.5202559",
"0.51961684",
"0.5169283",
"0.5162053",
"0.51603216",
"0.5147439"... | 0.6555623 | 0 |
Does nothing as it's not easy to stop SwitchEventListener and be able to start it afterwards. Sets a flag for press_key, though. | def start(self):
self.active = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_press(key):\n try:\n # gets pressed key char value and searches it from dict with get method.\n mapped_key = key_mappings.get(key.char) # gets value and type tuple or None\n if mapped_key:\n module.pressed_key = mapped_key\n except AttributeError:\n traceback.pr... | [
"0.6753262",
"0.6747262",
"0.6747262",
"0.6744969",
"0.652294",
"0.6501145",
"0.6453141",
"0.64297837",
"0.63286453",
"0.6319466",
"0.63019174",
"0.6213256",
"0.62122375",
"0.6172587",
"0.6166433",
"0.6166433",
"0.6082926",
"0.60826945",
"0.60654783",
"0.606481",
"0.6039859",... | 0.0 | -1 |
Does nothing as it's not easy to stop SwitchEventListener and be able to start it afterwards. Unsets a flag for press_key, though. | def stop(self):
self.active = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_press(self):\n self.pressed = True",
"def on_press(self):\n self.pressed = True",
"def on_press(key):\n global key_pressed\n try:\n if key == keyboard.Key.enter:\n key_pressed = True\n # Stop listener\n return False\n except AttributeError:\... | [
"0.66097456",
"0.66097456",
"0.6510256",
"0.65034145",
"0.6415514",
"0.6415514",
"0.6330303",
"0.6317401",
"0.63108677",
"0.6278477",
"0.6265347",
"0.61935896",
"0.61799365",
"0.6156864",
"0.6116449",
"0.61161727",
"0.6018095",
"0.6011536",
"0.5990823",
"0.5985273",
"0.596756... | 0.0 | -1 |
Converts event numbers to keycodes using ``mapping`` and sends them to ``send_key``. Is a callback for ``SwitchEventListener``. | def press_key(self, event):
if self.active:
keycode = self.mapping[event.pin_num]
while self.busy:
sleep(0.01)
self.busy = True
self.send_key(keycode)
self.busy = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _handle_key_event(self, key, modifiers, mapping):\n if key in mapping:\n for callback in mapping[key]:\n callback()",
"def send_key_event(self, event_code):\r\n self.adb.exec_cmd(\"shell input keyevent %s\", event_code)",
"def on_key_press(self, key, callback):\n ... | [
"0.6784899",
"0.597635",
"0.56877905",
"0.5675784",
"0.5614539",
"0.5593338",
"0.5532968",
"0.55294126",
"0.55215394",
"0.540672",
"0.5382363",
"0.53706765",
"0.5357638",
"0.53537667",
"0.53112364",
"0.5301527",
"0.5283345",
"0.52698326",
"0.5251863",
"0.5233475",
"0.52283376... | 0.5923485 | 2 |
A hook to be overridden by ``InputListener``. Otherwise, prints out key names as soon as they're pressed so is useful for debugging. | def send_key(self, keycode):
print(keycode) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_press_show_key(key):\n print(f\"{key} pressed\")",
"def keyboard(self, *args):\n return _ida_hexrays.Hexrays_Hooks_keyboard(self, *args)",
"def keyboard_action(self, event):\n name = event.name\n if len(name) > 1:\n if name == \"space\":\n name = \" \"\n... | [
"0.7189773",
"0.66043854",
"0.6394544",
"0.62418854",
"0.6209634",
"0.619093",
"0.6109771",
"0.6083051",
"0.59850484",
"0.5918823",
"0.5909523",
"0.58950806",
"0.587085",
"0.5851221",
"0.5839298",
"0.57863104",
"0.57457864",
"0.57444",
"0.573886",
"0.5733217",
"0.5726372",
... | 0.53978956 | 45 |
Just sets the flag, listener is already running from the very start | def activate(self):
self.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_start(self):\n self.state = STARTED",
"def on_start(self):\n pass",
"def on_start(self):\n pass",
"def on_start(self):\n pass",
"def on_start(self):\n pass",
"def on_start(self):\n pass",
"def on_start(self):\n pass",
"def on_start(self):\n ... | [
"0.68543714",
"0.67638534",
"0.67638534",
"0.67638534",
"0.67638534",
"0.67638534",
"0.67638534",
"0.67638534",
"0.67638534",
"0.6648839",
"0.66194665",
"0.6617628",
"0.6617628",
"0.65768045",
"0.651719",
"0.6454057",
"0.64307195",
"0.6423843",
"0.63908666",
"0.6331499",
"0.6... | 0.0 | -1 |
Compute x @ y, broadcasting over the first `N 2` ranks. | def _matmul_broadcast(x, y, name):
with tf.variable_scope(name) as scope:
return tf.reduce_sum(
tf.nn.dropout(x[..., tf.newaxis] * y[..., tf.newaxis, :, :],1), axis=-2
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def brute_multiply(x, y):\n \n n = x.shape[0]\n res = np.zeros(x.shape)\n \n for i in range(n):\n for j in range(n):\n for k in range(n):\n res[i, j] += x[i, k] * y[k, j]\n \n return res",
"def associate_comp(x, y):\n return torch.cat([x[:1] * y[:1] - x[1:... | [
"0.564049",
"0.5376758",
"0.5373917",
"0.53423446",
"0.53102696",
"0.5265047",
"0.5245262",
"0.5209597",
"0.5205773",
"0.51244324",
"0.51001847",
"0.5094103",
"0.5083796",
"0.5059849",
"0.5039474",
"0.50308985",
"0.50294924",
"0.49719357",
"0.49697846",
"0.49624175",
"0.49606... | 0.50320524 | 15 |
Wrapper over _get_variable_wrapper() to get weights, with weights decay factor in loss. | def _get_weights_wrapper(
name, shape, dtype=tf.float32, initializer=initializers.xavier_initializer(),
weights_decay_factor=None
):
weights = _get_variable_wrapper(
name=name, shape=shape, dtype=dtype, initializer=initializer
)
if weights_decay_factor is not None and weights_decay_factor > 0.0:
weights_wd = tf.multiply(
tf.nn.l2_loss(weights), weights_decay_factor, name=name + '/l2loss'
)
tf.add_to_collection('losses', weights_wd)
return weights | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _variable_with_weight_decay(self, shape, stddev, wd):\n\n initializer = tf.truncated_normal_initializer(stddev=stddev)\n var = tf.get_variable('weights', shape=shape,\n initializer=initializer)\n\n# if wd and (not tf.get_variable_scope().reuse):\n# w... | [
"0.77637476",
"0.77271247",
"0.7695299",
"0.75827795",
"0.75666004",
"0.75396603",
"0.7501326",
"0.7492685",
"0.7492685",
"0.74766654",
"0.74586254",
"0.74359125",
"0.73115295",
"0.7291328",
"0.72828215",
"0.72800875",
"0.7099408",
"0.68967044",
"0.67947274",
"0.6773664",
"0.... | 0.78818905 | 0 |
Wrapper over _get_variable_wrapper() to get bias. | def _get_biases_wrapper(
name, shape, dtype=tf.float32, initializer=tf.constant_initializer(0.0)
):
biases = _get_variable_wrapper(
name=name, shape=shape, dtype=dtype, initializer=initializer
)
return biases | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bias(self):",
"def get_bias(self):\n return self._bias",
"def _get_bias(self) -> JTensor:\n p = self.params\n b = self.local_theta().b\n if p.forget_gate_bias != 0.0:\n b = b + self.get_adjustment()\n\n return b",
"def bias_variable(shape):\n initial = tf.constant(0.1, shape=... | [
"0.7734493",
"0.73660034",
"0.72554916",
"0.7221981",
"0.72132975",
"0.71687686",
"0.7135788",
"0.7027468",
"0.69401133",
"0.68844694",
"0.681897",
"0.67968893",
"0.67830056",
"0.67830056",
"0.67830056",
"0.67757607",
"0.67674106",
"0.67601573",
"0.67601573",
"0.67601573",
"0... | 0.63800156 | 36 |
Get variables in a triple pattern | def get_vars(triple):
return set([v for k, v in triple.items() if v.startswith('?')]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variables(s):\n result = set([])\n def walk(s):\n if is_variable(s):\n result.add(s)\n else:\n for arg in s.args:\n walk(arg)\n walk(s)\n return result",
"def variables(self):\n return tuple(flatten([a.variables for a in self.args]))",
"... | [
"0.65504885",
"0.62275475",
"0.60280734",
"0.58704334",
"0.58324313",
"0.5800524",
"0.5797577",
"0.57811517",
"0.5696571",
"0.56887144",
"0.5681551",
"0.56710494",
"0.5640094",
"0.56376356",
"0.56341684",
"0.56109506",
"0.56105363",
"0.55877894",
"0.5572952",
"0.5562894",
"0.... | 0.6889056 | 0 |
Find the first pattern in a set of triples pattern connected to a set of variables | def find_connected_pattern(variables, triples):
pos = 0
for triple in triples:
tripleVars = get_vars(triple['triple'])
if len(variables & tripleVars) > 0:
return triple, pos, variables | tripleVars
pos += 1
return None, None, variables | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_match(s,patterns):\n\n for p in patterns:\n m=p.match(s)\n if m:\n return p,m\n return None,None",
"def __extract_pattern_nodes(graph):\n tp_nodes = graph.subjects(RDF.type, AGORA.TriplePattern)\n for tpn in tp_nodes:\n subject = list(graph.objects(tpn, AGORA.subject)).pop()\n... | [
"0.56770355",
"0.54898673",
"0.5466495",
"0.54459643",
"0.5443161",
"0.5358336",
"0.527935",
"0.5254748",
"0.525361",
"0.5221164",
"0.52143013",
"0.51818883",
"0.51779795",
"0.5138044",
"0.5081138",
"0.5056731",
"0.49985862",
"0.49973455",
"0.4994104",
"0.49817485",
"0.498029... | 0.7778533 | 0 |
Find all variables from triple pattern with the same name, and then returns the equality expression + the triple pattern used to evaluate correctly the pattern. | def equality_variables(subject, predicate, obj):
if subject == predicate:
return "{} = {}".format(subject, predicate + '__2'), (subject, predicate + '__2', obj), ""
elif subject == obj:
return "{} = {}".format(subject, obj + '__2'), (subject, predicate, obj + '__2')
elif predicate == obj:
return "{} = {}".format(predicate, obj + '__2'), (subject, predicate, obj + '__2')
return None, (subject, predicate, obj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_connected_pattern(variables, triples):\n pos = 0\n for triple in triples:\n tripleVars = get_vars(triple['triple'])\n if len(variables & tripleVars) > 0:\n return triple, pos, variables | tripleVars\n pos += 1\n return None, None, variables",
"def get_matching(va... | [
"0.5852751",
"0.57515645",
"0.5609051",
"0.5592503",
"0.53491706",
"0.52757096",
"0.5234036",
"0.50917244",
"0.50880814",
"0.5063958",
"0.5033563",
"0.4941532",
"0.4936441",
"0.49216276",
"0.49144816",
"0.49125922",
"0.48900846",
"0.4889691",
"0.48858666",
"0.48518804",
"0.48... | 0.5591187 | 4 |
returns the frequency of a tone. formulas from | def tone_to_freq(tone):
return math.pow(2, (tone - 69.0) / 12.0) * 440.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tone_frequency(self):\n return self.tone_frequency",
"def tone(n, base_freq=440.0):\n # -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12\n # G G# A A# B C C# D D# E F F# G G# A\n # G Ab A Bb B C Db D Eb E F Gb G Ab A\n return base_freq * 2 ** (n/12)",
"def freq():",
"de... | [
"0.7913658",
"0.77914226",
"0.7399102",
"0.7215293",
"0.7153386",
"0.7143531",
"0.7114183",
"0.70356035",
"0.69720876",
"0.695965",
"0.69546825",
"0.6954073",
"0.69424343",
"0.69303775",
"0.6903233",
"0.6880722",
"0.68684185",
"0.6841452",
"0.6833891",
"0.6807867",
"0.6769327... | 0.87280464 | 0 |
this function adds 5 cards from the deck to the hand | def deal_poker_hand(self, deck):
for i in range(5):
self.hand.append(deck.drawCard()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_card(self, added_cards):\n\n self.hand[:0] = added_cards",
"def add_a_card_to_hand(self, hand, deck):\n hand.append(deck.pop())",
"def deal(self, num_cards=7):\n self.deck.shuffle()\n for player in self.players:\n for i in range(num_cards):\n self.h... | [
"0.72352415",
"0.7053274",
"0.6955573",
"0.6879287",
"0.6851322",
"0.68399423",
"0.68385714",
"0.6816445",
"0.68131894",
"0.680666",
"0.6777246",
"0.67551434",
"0.6744151",
"0.672975",
"0.6721525",
"0.67009944",
"0.6674014",
"0.6656667",
"0.6654007",
"0.66452503",
"0.6627303"... | 0.7919288 | 0 |
prints all cards in hand | def print_hand(self):
for card in self.hand:
card.printCard() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_hand(self):\n for card in self.hand:\n print(card)",
"def player_show_hand(self):\n for card in self.get_hand():\n print(card.get_card())",
"def show_hand(self):\n\n print(f\"{self.name.title()}'s cards are:\")\n for card in self.hand:\n pri... | [
"0.86974907",
"0.83651304",
"0.8254563",
"0.79101205",
"0.790326",
"0.78862673",
"0.7541825",
"0.74812996",
"0.7473956",
"0.7269598",
"0.7237259",
"0.7206232",
"0.72048044",
"0.71964407",
"0.7182787",
"0.7144437",
"0.71311176",
"0.70919424",
"0.6971113",
"0.6928701",
"0.68750... | 0.8903049 | 0 |
There are values in the xls that have descriptions in one cell and the value to the left, this function is a helper in those cases | def get_horizontal_field_value(xls, row_index, description_index, fields_count=1, description=None, partial_match=False):
if description:
actual_description = get_cell_value(xls, row_index, description_index)
if not actual_description:
raise ValueError("empty cell at coordinate: {}:{}".format(row_index, description_index))
mismatch = False
if partial_match:
if description not in actual_description:
mismatch = True
else:
if description != actual_description:
mismatch = True
if mismatch:
raise ValueError("Mismatch between expected description and actual description: \"{}\" != \"{}\""
.format(description, actual_description))
output = []
for i in range(1, fields_count + 1, 1):
cell_value = get_cell_value(xls, row_index, description_index + i)
if cell_value is not None:
output.append(cell_value)
if not output:
return None
return ' '.join(v for v in output) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_data_labels(sheet, row, col):\n final_column = col\n header_row = _FIELDS['cell_value']['header']['row']\n # Abstract this sort of thing\n header = sheet.cell(row + header_row, final_column).value\n while any(header.startswith(label) for label\n in _FIELDS['isotherm tabular']['... | [
"0.57297254",
"0.54683656",
"0.544114",
"0.5382319",
"0.53744954",
"0.5310725",
"0.5275922",
"0.52674615",
"0.5236666",
"0.5231945",
"0.5164695",
"0.51571536",
"0.51552546",
"0.5144152",
"0.5134118",
"0.5122181",
"0.51046264",
"0.51006085",
"0.5028648",
"0.50078714",
"0.50003... | 0.62578756 | 0 |
r"""Audio Microfrontend Op. This Op converts a sequence of audio data into one or more feature vectors containing filterbanks of the input. The | def audio_microfrontend(audio, sample_rate=16000, window_size=25, window_step=10, num_channels=32, upper_band_limit=7500, lower_band_limit=125, smoothing_bits=10, even_smoothing=0.025, odd_smoothing=0.06, min_signal_remaining=0.05, enable_pcan=False, pcan_strength=0.95, pcan_offset=80, gain_bits=21, enable_log=True, scale_shift=6, left_context=0, right_context=0, frame_stride=1, zero_padding=False, out_scale=1, out_type=_dtypes.uint16, name=None):
_ctx = _context._context or _context.context()
tld = _ctx._thread_local_data
if tld.is_eager:
try:
_result = pywrap_tfe.TFE_Py_FastPathExecute(
_ctx._context_handle, tld.device_name, "AudioMicrofrontend", name,
tld.op_callbacks, audio, "sample_rate", sample_rate, "window_size",
window_size, "window_step", window_step, "num_channels", num_channels,
"upper_band_limit", upper_band_limit, "lower_band_limit",
lower_band_limit, "smoothing_bits", smoothing_bits, "even_smoothing",
even_smoothing, "odd_smoothing", odd_smoothing,
"min_signal_remaining", min_signal_remaining, "enable_pcan",
enable_pcan, "pcan_strength", pcan_strength, "pcan_offset",
pcan_offset, "gain_bits", gain_bits, "enable_log", enable_log,
"scale_shift", scale_shift, "left_context", left_context,
"right_context", right_context, "frame_stride", frame_stride,
"zero_padding", zero_padding, "out_scale", out_scale, "out_type",
out_type)
return _result
except _core._FallbackException:
try:
return audio_microfrontend_eager_fallback(
audio, sample_rate=sample_rate, window_size=window_size,
window_step=window_step, num_channels=num_channels,
upper_band_limit=upper_band_limit,
lower_band_limit=lower_band_limit, smoothing_bits=smoothing_bits,
even_smoothing=even_smoothing, odd_smoothing=odd_smoothing,
min_signal_remaining=min_signal_remaining,
enable_pcan=enable_pcan, pcan_strength=pcan_strength,
pcan_offset=pcan_offset, gain_bits=gain_bits,
enable_log=enable_log, scale_shift=scale_shift,
left_context=left_context, right_context=right_context,
frame_stride=frame_stride, zero_padding=zero_padding,
out_scale=out_scale, out_type=out_type, name=name, ctx=_ctx)
except _core._SymbolicException:
pass # Add nodes to the TensorFlow graph.
except (TypeError, ValueError):
result = _dispatch.dispatch(
audio_microfrontend, audio=audio, sample_rate=sample_rate,
window_size=window_size,
window_step=window_step,
num_channels=num_channels,
upper_band_limit=upper_band_limit,
lower_band_limit=lower_band_limit,
smoothing_bits=smoothing_bits,
even_smoothing=even_smoothing,
odd_smoothing=odd_smoothing,
min_signal_remaining=min_signal_remaining,
enable_pcan=enable_pcan,
pcan_strength=pcan_strength,
pcan_offset=pcan_offset,
gain_bits=gain_bits, enable_log=enable_log,
scale_shift=scale_shift,
left_context=left_context,
right_context=right_context,
frame_stride=frame_stride,
zero_padding=zero_padding,
out_scale=out_scale, out_type=out_type,
name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
except _core._NotOkStatusException as e:
_ops.raise_from_not_ok_status(e, name)
# Add nodes to the TensorFlow graph.
if sample_rate is None:
sample_rate = 16000
sample_rate = _execute.make_int(sample_rate, "sample_rate")
if window_size is None:
window_size = 25
window_size = _execute.make_int(window_size, "window_size")
if window_step is None:
window_step = 10
window_step = _execute.make_int(window_step, "window_step")
if num_channels is None:
num_channels = 32
num_channels = _execute.make_int(num_channels, "num_channels")
if upper_band_limit is None:
upper_band_limit = 7500
upper_band_limit = _execute.make_float(upper_band_limit, "upper_band_limit")
if lower_band_limit is None:
lower_band_limit = 125
lower_band_limit = _execute.make_float(lower_band_limit, "lower_band_limit")
if smoothing_bits is None:
smoothing_bits = 10
smoothing_bits = _execute.make_int(smoothing_bits, "smoothing_bits")
if even_smoothing is None:
even_smoothing = 0.025
even_smoothing = _execute.make_float(even_smoothing, "even_smoothing")
if odd_smoothing is None:
odd_smoothing = 0.06
odd_smoothing = _execute.make_float(odd_smoothing, "odd_smoothing")
if min_signal_remaining is None:
min_signal_remaining = 0.05
min_signal_remaining = _execute.make_float(min_signal_remaining, "min_signal_remaining")
if enable_pcan is None:
enable_pcan = False
enable_pcan = _execute.make_bool(enable_pcan, "enable_pcan")
if pcan_strength is None:
pcan_strength = 0.95
pcan_strength = _execute.make_float(pcan_strength, "pcan_strength")
if pcan_offset is None:
pcan_offset = 80
pcan_offset = _execute.make_float(pcan_offset, "pcan_offset")
if gain_bits is None:
gain_bits = 21
gain_bits = _execute.make_int(gain_bits, "gain_bits")
if enable_log is None:
enable_log = True
enable_log = _execute.make_bool(enable_log, "enable_log")
if scale_shift is None:
scale_shift = 6
scale_shift = _execute.make_int(scale_shift, "scale_shift")
if left_context is None:
left_context = 0
left_context = _execute.make_int(left_context, "left_context")
if right_context is None:
right_context = 0
right_context = _execute.make_int(right_context, "right_context")
if frame_stride is None:
frame_stride = 1
frame_stride = _execute.make_int(frame_stride, "frame_stride")
if zero_padding is None:
zero_padding = False
zero_padding = _execute.make_bool(zero_padding, "zero_padding")
if out_scale is None:
out_scale = 1
out_scale = _execute.make_int(out_scale, "out_scale")
if out_type is None:
out_type = _dtypes.uint16
out_type = _execute.make_type(out_type, "out_type")
try:
_, _, _op, _outputs = _op_def_library._apply_op_helper(
"AudioMicrofrontend", audio=audio, sample_rate=sample_rate,
window_size=window_size,
window_step=window_step,
num_channels=num_channels,
upper_band_limit=upper_band_limit,
lower_band_limit=lower_band_limit,
smoothing_bits=smoothing_bits,
even_smoothing=even_smoothing,
odd_smoothing=odd_smoothing,
min_signal_remaining=min_signal_remaining,
enable_pcan=enable_pcan,
pcan_strength=pcan_strength,
pcan_offset=pcan_offset, gain_bits=gain_bits,
enable_log=enable_log, scale_shift=scale_shift,
left_context=left_context,
right_context=right_context,
frame_stride=frame_stride,
zero_padding=zero_padding, out_scale=out_scale,
out_type=out_type, name=name)
except (TypeError, ValueError):
result = _dispatch.dispatch(
audio_microfrontend, audio=audio, sample_rate=sample_rate,
window_size=window_size,
window_step=window_step,
num_channels=num_channels,
upper_band_limit=upper_band_limit,
lower_band_limit=lower_band_limit,
smoothing_bits=smoothing_bits,
even_smoothing=even_smoothing,
odd_smoothing=odd_smoothing,
min_signal_remaining=min_signal_remaining,
enable_pcan=enable_pcan,
pcan_strength=pcan_strength,
pcan_offset=pcan_offset, gain_bits=gain_bits,
enable_log=enable_log, scale_shift=scale_shift,
left_context=left_context,
right_context=right_context,
frame_stride=frame_stride,
zero_padding=zero_padding, out_scale=out_scale,
out_type=out_type, name=name)
if result is not _dispatch.OpDispatcher.NOT_SUPPORTED:
return result
raise
_result = _outputs[:]
if _execute.must_record_gradient():
_attrs = ("sample_rate", _op._get_attr_int("sample_rate"), "window_size",
_op._get_attr_int("window_size"), "window_step",
_op._get_attr_int("window_step"), "num_channels",
_op._get_attr_int("num_channels"), "upper_band_limit",
_op.get_attr("upper_band_limit"), "lower_band_limit",
_op.get_attr("lower_band_limit"), "smoothing_bits",
_op._get_attr_int("smoothing_bits"), "even_smoothing",
_op.get_attr("even_smoothing"), "odd_smoothing",
_op.get_attr("odd_smoothing"), "min_signal_remaining",
_op.get_attr("min_signal_remaining"), "enable_pcan",
_op._get_attr_bool("enable_pcan"), "pcan_strength",
_op.get_attr("pcan_strength"), "pcan_offset",
_op.get_attr("pcan_offset"), "gain_bits",
_op._get_attr_int("gain_bits"), "enable_log",
_op._get_attr_bool("enable_log"), "scale_shift",
_op._get_attr_int("scale_shift"), "left_context",
_op._get_attr_int("left_context"), "right_context",
_op._get_attr_int("right_context"), "frame_stride",
_op._get_attr_int("frame_stride"), "zero_padding",
_op._get_attr_bool("zero_padding"), "out_scale",
_op._get_attr_int("out_scale"), "out_type",
_op._get_attr_type("out_type"))
_inputs_flat = _op.inputs
_execute.record_gradient(
"AudioMicrofrontend", _inputs_flat, _attrs, _result)
_result, = _result
return _result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, audio, feat_kinds=['sp','mcc','f0','ap','en']):\n device = audio.device\n audio = audio.detach().cpu().numpy()\n feat = dict()\n for feat_kind in feat_kinds:\n feat[feat_kind] = list()\n\n for x in audio:\n # Preprocess\n x = x *... | [
"0.6214952",
"0.6180612",
"0.5916665",
"0.5807464",
"0.574993",
"0.57417107",
"0.5674335",
"0.5656726",
"0.559542",
"0.5592476",
"0.5391799",
"0.53891623",
"0.53865993",
"0.536583",
"0.5343574",
"0.53194135",
"0.52970415",
"0.5287498",
"0.52824646",
"0.5269765",
"0.5267847",
... | 0.5350822 | 14 |
Show url landing page to allow users to sign in or register | def display_loginpage():
login_form = LoginForm()
register_new_user_form = RegisterForm()
return render_template('loginpage.html',
register_new_user_form = register_new_user_form,
login_form = login_form) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def landing():\n if g.user:\n return render_template('landing.html', user=g.user)\n return redirect(url_for('login'))",
"def homepage():\n if g.user:\n return redirect(f\"/user/{g.user.id}\")\n else:\n return redirect(\"/landing\")",
"def home():\n\n if not current_user.is_a... | [
"0.78786206",
"0.76203156",
"0.7580162",
"0.74616975",
"0.74271345",
"0.72606593",
"0.72573274",
"0.72572017",
"0.72520787",
"0.720815",
"0.7148061",
"0.7125707",
"0.7108026",
"0.70950717",
"0.7052123",
"0.7041136",
"0.7038737",
"0.7005974",
"0.7005249",
"0.6992043",
"0.69885... | 0.67882955 | 36 |
Validating entered user info with the DB | def login():
login_form = LoginForm()
user = User.query.filter_by(username=login_form.username.data).first()
if login_form.validate_on_submit():
if user:
if user.password == login_form.password.data:
login_user(user)
return redirect('/searchpage')
else:
flash("Sorry, the information you entered is incorrect")
return redirect('/') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self):\n\n # Fetch cleaned email and username data.\n email = self.cleaned_data.get('email')\n username = self.cleaned_data.get('username')\n\n # Fetch possible user objects from the database\n # based on provided and email and password.\n user_email = User.objec... | [
"0.71897084",
"0.69053745",
"0.68623877",
"0.68019813",
"0.673602",
"0.671058",
"0.66788834",
"0.6658235",
"0.6556224",
"0.65534216",
"0.64900243",
"0.6401189",
"0.6394674",
"0.6372971",
"0.63576025",
"0.63221467",
"0.6296865",
"0.6296594",
"0.6270587",
"0.62569064",
"0.61645... | 0.0 | -1 |
Adding a new user to the DB | def register_new_user():
register_new_user_form = RegisterForm()
user = User.query.filter_by(username=register_new_user_form.username.data).first()
email = User.query.filter_by(email = register_new_user_form.email.data).first()
if user or email:
flash("Sorry, the username or email already exists in the database")
return redirect('/')
elif register_new_user_form.validate_on_submit():
new_user = User(username=register_new_user_form.username.data,
email=register_new_user_form.email.data,
password=register_new_user_form.password.data)
db.session.add(new_user)
db.session.commit()
login_user(new_user)
return redirect('/searchpage') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_user(self):\n query = \"INSERT INTO users (first_name, last_name, email, password) VALUES (%s, %s, %s, %s)\"\n self.cursor.execute(query,(\n self.first_name, \n self.last_name, \n self.email, \n self.password))",
"def add_new_user_to_db():\n fi... | [
"0.84153813",
"0.8296184",
"0.8227132",
"0.8195087",
"0.8158671",
"0.8113021",
"0.80605036",
"0.80300426",
"0.8006185",
"0.7954521",
"0.7898283",
"0.78795296",
"0.78635365",
"0.7859975",
"0.78550875",
"0.78340864",
"0.7817653",
"0.7773862",
"0.7768065",
"0.77598983",
"0.77367... | 0.0 | -1 |
Displays the searchpage. This is the user's homepage | def display_search_page():
favorite_players = []
favorites = Favorite.query.filter_by(id = current_user.id).all()
if len(favorites) > 0:
for favorite in favorites:
player = get_favorites(favorite.favorited_item)
player_info = player[0]
favorite_players.append(player_info)
else:
favorite_players = []
return render_template('searchpage.html',
favorite_players = favorite_players) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search():\r\n return render_template(\"/home/search.html\")",
"def search_page():\n return render_template('page_query.html', search_label=g_search_type)",
"def go_to_search():\n\tuser_id = session.get(\"user_id\")\n\tuser = User.query.filter_by(user_id=user_id).first()\n\n\treturn render_template(\"... | [
"0.8220182",
"0.81900704",
"0.7612297",
"0.7570061",
"0.74575865",
"0.73217803",
"0.72212404",
"0.7209977",
"0.71231586",
"0.708114",
"0.70068485",
"0.70039576",
"0.6972065",
"0.6970202",
"0.69344836",
"0.6908577",
"0.68495345",
"0.68272036",
"0.6818644",
"0.6812315",
"0.6807... | 0.6964854 | 14 |
The user clicked to update their favorites. This checks whether or not to remove the athlete in the session as a favorite | def update_favorites():
check_favorite = Favorite.query.filter(Favorite.favorited_item==session["athlete_id"]).first()
route = f'/athletes/{session["athlete_id"]}'
if check_favorite is None:
new_update = Favorite(id=current_user.id, favorited_item=session["athlete_id"])
db.session.add(new_update)
else:
db.session.delete(check_favorite)
db.session.commit()
return redirect(route) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_favourites(self, item_info, status):\r\n if status == \"Add\":\r\n return self.model.add_to_favourites(item_info)\r\n elif status == \"Remove\":\r\n return self.model.delete_from_favourites(item_info)",
"def favourite(self, favourite):\n\n self._favourite = f... | [
"0.69176424",
"0.688864",
"0.68283784",
"0.66788083",
"0.6618724",
"0.65838104",
"0.64054716",
"0.62992626",
"0.6211721",
"0.6205134",
"0.61849916",
"0.61616564",
"0.6160226",
"0.60770786",
"0.60408217",
"0.60285735",
"0.6025413",
"0.60150605",
"0.60038364",
"0.59932923",
"0.... | 0.7853664 | 0 |
Logs out the user | def logout():
logout_user()
return redirect('/') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_out_user(self):\n flask_login.logout_user()",
"def logout_user():\n pass",
"def logout():\n return logout_user()",
"def logOut(self):\n self.client.logout()",
"def logout():",
"def logout():\n login()",
"def logout(self):\n self.change_user(self.username, None, Non... | [
"0.8877641",
"0.8626286",
"0.839422",
"0.8392201",
"0.8352932",
"0.8337815",
"0.82495695",
"0.8176587",
"0.8166211",
"0.8124933",
"0.81026566",
"0.80388916",
"0.80171776",
"0.800409",
"0.79627264",
"0.7959641",
"0.79488003",
"0.79390985",
"0.7923234",
"0.7908623",
"0.7902515"... | 0.7743278 | 43 |
Run all the parts of this task. | def main():
# delete the database file if it already exists
db_path = Path('../../data/db.sqlite')
db_path.unlink(missing_ok=True)
# create the database
with sqlite3.connect(db_path) as connection:
create_database(connection) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n try:\n self._run()\n except Exception as err:\n # TODO: Do Task Failure to run exception handling\n pass",
"def run(self):\n self.run()",
"def run(self):\n\n self._get_routes()\n self._calculate_emissions()",
"def run(self):... | [
"0.7519389",
"0.7507399",
"0.7174385",
"0.71610844",
"0.70846206",
"0.706648",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
"0.7065904",
... | 0.0 | -1 |
Create tables for orders, delivery, and clicks. | def create_database(connection):
cursor = connection.cursor()
# create an orders table, dropping some duplicate rows to satisfy the primary key constraint
print("Creating orders table ...")
cursor.execute('''
CREATE TABLE JD_order_data (
order_ID TEXT NOT NULL CHECK(LENGTH(order_ID) = 10),
sku_ID TEXT NOT NULL CHECK(LENGTH(sku_ID) = 10),
user_ID TEXT NOT NULL CHECK(LENGTH(user_ID) = 10),
order_time DATETIME NOT NULL,
quantity INT NOT NULL,
final_unit_price REAL NOT NULL,
PRIMARY KEY (order_ID, sku_ID)
)
''')
orders = pd.read_csv('../../data/JD_order_data.csv', low_memory=False)
orders = orders[['order_ID', 'sku_ID', 'user_ID', 'order_time', 'quantity', 'final_unit_price']]
orders = orders.groupby(['order_ID', 'sku_ID'], as_index=False).first()
orders.to_sql('JD_order_data', connection, index=False, if_exists='append')
cursor.execute('CREATE INDEX orders_user_index ON JD_order_data (user_ID)')
# create a delivery table
print("Creating delivery table ...")
cursor.execute('''
CREATE TABLE JD_delivery_data (
order_ID TEXT NOT NULL CHECK(LENGTH(order_ID) = 10),
package_ID TEXT NOT NULL CHECK(LENGTH(package_ID) = 10),
ship_out_time DATETIME NOT NULL,
PRIMARY KEY (order_ID, package_ID),
FOREIGN KEY (order_ID) REFERENCES JD_order_data (order_ID)
)
''')
delivery = pd.read_csv('../../data/JD_delivery_data.csv', parse_dates=['ship_out_time'])
delivery = delivery[['order_ID', 'package_ID', 'ship_out_time']]
delivery.to_sql('JD_delivery_data', connection, index=False, if_exists='append')
# create a clicks table
print("Creating clicks table ...")
cursor.execute('''
CREATE TABLE JD_click_data (
user_ID TEXT NOT NULL CHECK(LENGTH(user_ID) = 10),
sku_ID TEXT NOT NULL CHECK(LENGTH(sku_ID) = 10),
request_time DATETIME NOT NULL,
FOREIGN KEY (user_ID) REFERENCES JD_order_data (user_ID),
FOREIGN KEY (sku_ID) REFERENCES JD_order_data (sku_ID)
)
''')
clicks = pd.read_csv('../../data/JD_click_data.csv', parse_dates=['request_time'])
clicks = clicks[clicks['user_ID'] != '-']
clicks = clicks[['user_ID', 'sku_ID', 'request_time']]
clicks.to_sql('JD_click_data', connection, index=False, if_exists='append')
cursor.execute('CREATE INDEX clicks_user_index ON JD_click_data (user_ID)')
cursor.execute('CREATE INDEX clicks_sku_index ON JD_click_data (sku_ID)')
# Create a user table
print("Creating users table ...")
cursor.execute('''
CREATE TABLE JD_user_data (
user_ID TEXT NOT NULL CHECK(LENGTH(user_ID) = 10),
plus INT NOT NULL CHECK (plus IN (0, 1)),
PRIMARY KEY (user_ID)
)
''')
users = pd.read_csv('../../data/JD_user_data.csv', low_memory=False)
users = users[['user_ID', 'plus']]
users = users.groupby(['user_ID'], as_index=False).first()
users.to_sql('JD_user_data', connection, index=False, if_exists='append')
cursor.execute('CREATE INDEX users_user_index ON JD_user_data (user_ID)') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_tables(self):\n for t in self.tables:\n self.add_table(groupname=t['groupname'],\n tablename=t['tablename'],\n description=t['description'],\n tabletitle=t['tabletitle'])",
"def create_tables(self):\n ... | [
"0.752659",
"0.73547345",
"0.69034",
"0.6883073",
"0.6853905",
"0.68315214",
"0.67800254",
"0.6657214",
"0.6652979",
"0.65973955",
"0.65843534",
"0.6528014",
"0.65207535",
"0.6505119",
"0.6502627",
"0.64933836",
"0.6487306",
"0.6475528",
"0.6457907",
"0.64303106",
"0.64230615... | 0.0 | -1 |
Add single hopping to hopping matrix. | def set_element(self, rel_unit_cell, element, hop):
self.dict[element[0]][rel_unit_cell + (element[1],)] = hop | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addNeighbor(self, neighbor):",
"def add_neighbor(self, neighbor):\r\n self.neighbors.append(neighbor)",
"def add_neighbor(self, cell):\n self.__neighbors.append(cell)",
"def __heappush(heap, nodes, node):\n pos = len(heap)\n heap.append(node)\n nodes[node[1]] = pos\n ... | [
"0.6541676",
"0.5901997",
"0.5716449",
"0.5625333",
"0.554359",
"0.5538659",
"0.5529868",
"0.5503152",
"0.54820204",
"0.5470297",
"0.5470127",
"0.5427927",
"0.54236084",
"0.54061526",
"0.5405852",
"0.5400103",
"0.53873384",
"0.5377393",
"0.5375697",
"0.536957",
"0.5349497",
... | 0.5005826 | 43 |
Adds hopping conjugates to self.dict. | def add_conjugates(self):
# declare new dict
self.new_dict = copy.deepcopy(self.dict)
# iterate over items
for i in range(len(self.dict)):
for rel_tag, hopping in self.dict[i].items():
x, y, z, j = rel_tag
reverse_tag = (-x, -y, -z, i)
reverse_hopping = np.conjugate(np.transpose(hopping))
if reverse_tag not in self.new_dict[j]:
self.new_dict[j][reverse_tag] = reverse_hopping
# done
self.dict = self.new_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def buildDict(self, words):\n for word in words:\n self.word_set.add(word)\n for candidate in self.candidates(word):\n self.neighbors[candidate] += 1",
"def makeGraphDictionary(self):\n graph_dict_incomplete = {}\n # dictionary contains all links, no matt... | [
"0.5047579",
"0.5037985",
"0.502265",
"0.5007653",
"0.49975562",
"0.49723896",
"0.49697816",
"0.48349583",
"0.48268276",
"0.48259962",
"0.48032284",
"0.47840226",
"0.4778364",
"0.47758386",
"0.47497863",
"0.4746505",
"0.47428873",
"0.4741161",
"0.47241557",
"0.47111377",
"0.4... | 0.65367895 | 0 |
Add a gaussian noise to to the result of Dense layer. The added gaussian noise is not related to the origin input. | def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):
super().__init__()
for u in hidden_units:
self.add(GaussianNoise(0.4)) # Or use kwargs
self.add(Dense(u, act_fn))
if out_layer:
self.add(GaussianNoise(0.4))
self.add(Dense(output_shape, out_activation)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_gaussian_noise(x, std):\n noise = x.new_zeros(x.size()).normal_(std=std)\n return x + noise",
"def add_gaussian_noise(X, mu=0, sigma=0.1):\n noise = np.random.normal(0.0, sigma, size=X.size)\n return X + noise.reshape(X.shape)",
"def add_gaussian_noise(self, samples):\n\n if 'sigma' ... | [
"0.7656182",
"0.7478594",
"0.71226805",
"0.7062763",
"0.7007418",
"0.69041336",
"0.66500264",
"0.66093963",
"0.65894604",
"0.65828973",
"0.65525967",
"0.6540314",
"0.65288055",
"0.65264595",
"0.64818",
"0.64335525",
"0.6431225",
"0.6427232",
"0.64240474",
"0.6390431",
"0.6390... | 0.0 | -1 |
Shift input ids one token to the right, and wrap the last non pad token (usually ). | def shift_tokens_right(self, input_ids, pad_token_id):
prev_output_tokens = input_ids.clone()
index_of_eos = (input_ids.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)
prev_output_tokens[:, 0] = input_ids.gather(1, index_of_eos).squeeze()
prev_output_tokens[:, 1:] = input_ids[:, :-1]
return prev_output_tokens | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift_tokens_right(input_ids, pad_token_id):\r\n prev_output_tokens = input_ids.clone()\r\n index_of_eos = (input_ids.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)\r\n prev_output_tokens[:, 0] = input_ids.gather(1, index_of_eos).squeeze()\r\n prev_output_tokens[:, 1:] = input_ids[:, :-1]\r\n re... | [
"0.8174382",
"0.7355779",
"0.730172",
"0.62766033",
"0.5987434",
"0.59027076",
"0.5735923",
"0.5567176",
"0.5503809",
"0.54715633",
"0.54715633",
"0.54715633",
"0.5460714",
"0.54170334",
"0.5338661",
"0.53169227",
"0.52875674",
"0.52819985",
"0.5207631",
"0.51908386",
"0.5179... | 0.81405616 | 1 |
Visualizes in a pyplot window an image and a label pair from provided paths. For reading files, Pillow is used so all paths and formats must be Pillowcompatible. The task definition is used to define colors for label ids (see panoptic_parts/utils/defs/template_v1.0.yaml). | def visualize_from_paths(image_path, label_path, task_def_path):
# sid2color is a mapping from all possible sids to colors
with open(task_def_path) as fp:
task_def = yaml.load(fp, Loader=yaml.Loader)
sid2color = task_def['sid2color']
# add colors for all sids that may exist in labels, but don't have a color from task_def
sid2color.update({sid: sid2color[-1] # we use the void color here
for sid in range(task_def['max_sid'])
if not (sid in task_def['valid_sids'] or sid in sid2color)})
# reduce resolution for faster execution
image = Image.open(image_path)
label = Image.open(label_path)
uids = np.array(label, dtype=np.int32)
# optionally transform parts ids
# here we trasform the pids from the original dataset to another set of pids according
# to sid2pids_groups, where parts for some scene-level semantic classes are grouped
# TODO(panos): consider moving this functionality to colorize_label
if 'sid2pids_groups' in task_def.keys():
uids = _transform_uids(uids, task_def['max_sid'], task_def['sid2pids_groups'])
# create the colorized label images
uids_sem_inst_parts_colored, uids_sem_colored, uids_sem_inst_colored = \
experimental_colorize_label(uids,
sid2color=sid2color,
return_sem=True,
return_sem_inst=True,
emphasize_instance_boundaries=True)
# plot
# initialize figure for plotting
_, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
# for ax in axes:
# ax.set_axis_off()
ax1.imshow(image)
ax1.set_title('image')
ax2.imshow(uids_sem_colored)
ax2.set_title('labels colored on semantic level')
ax3.imshow(uids_sem_inst_colored)
ax3.set_title('labels colored on semantic and instance levels')
ax4.imshow(uids_sem_inst_parts_colored)
ax4.set_title('labels colored on semantic, instance, and parts levels')
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_oneshot_task(pairs):\n fig,(ax1,ax2) = plt.subplots(2)\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\n img = concat_images(pairs[1])\n ax1.get_yaxis().set_visible(False)\n ax1.get_xaxis().set_visible(False)\n ax2.matshow(img,cmap='gray')\n plt.xticks([])\n plt.yticks([])\... | [
"0.62449753",
"0.5956047",
"0.5905638",
"0.5834986",
"0.5807051",
"0.57767344",
"0.5769278",
"0.5720147",
"0.5714393",
"0.5708018",
"0.55924964",
"0.55918765",
"0.55361027",
"0.55186796",
"0.5489448",
"0.5472695",
"0.54674464",
"0.54264355",
"0.5421594",
"0.54154986",
"0.5411... | 0.80462617 | 0 |
Computes top principal component. | def pc1(d):
import numpy as np
from sklearn.decomposition import TruncatedSVD
# Normalize data
t1 = d.T
t1 = t1 - t1.mean(axis=0)
t1 = t1 / (np.sqrt((t1**2).mean(axis=0)) + 1E-200)
t0 = TruncatedSVD(n_components=1)
t1 = t0.fit_transform(t1).T.astype(d.dtype, copy=False).ravel()
assert t1.shape == (d.shape[1], )
return t1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_principal_component(X):\n guess = [1 for _ in X[0]]\n unscaled_maximizer = maximize_batch(\n partial(directional_variance, X),\n partial(directional_variance_gradient, X),\n guess)\n... | [
"0.6089231",
"0.5806278",
"0.5718602",
"0.5631194",
"0.555383",
"0.5522287",
"0.55130035",
"0.5443612",
"0.54245883",
"0.53624135",
"0.53293145",
"0.53293145",
"0.53293145",
"0.5287979",
"0.5231421",
"0.5225504",
"0.5204582",
"0.51921564",
"0.5179744",
"0.5143214",
"0.511822"... | 0.0 | -1 |
Converts a pandas series of string to numeric ratios. | def toratio(s):
from operator import truediv
return s.apply(lambda x: truediv(*[int(y) for y in x.split('/')])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_float(series):\n series = series.str[:-4].str.replace('.', '').str.replace(',', '.').astype(float)\n return series",
"def convert(srat):\n try:\n return float(srat)\n except ValueError:\n num, denom = srat.split('/')\n return float(num) / float(denom)",
"def conv... | [
"0.6325216",
"0.6113206",
"0.58220035",
"0.5687025",
"0.567426",
"0.56450087",
"0.5632027",
"0.5590445",
"0.5578296",
"0.5572146",
"0.5564546",
"0.5494868",
"0.54813343",
"0.5451129",
"0.54271585",
"0.5381694",
"0.5367929",
"0.5367361",
"0.5344174",
"0.5337416",
"0.5271317",
... | 0.48489207 | 58 |
Finds GO enrichment with goatools (0.7.11 tested). | def goe(
genelist,
go_file,
goa_file,
bg=None,
nmin=5,
conversion=None,
evidence_set={
'EXP', 'IDA', 'IPI', 'IMP', 'IGI', 'HTP', 'HDA', 'HMP', 'HGI', 'IBA',
'IBD', 'IKR', 'IRD', 'ISS', 'ISO', 'ISA', 'ISM'}):
from tempfile import NamedTemporaryFile
from os import linesep
from goatools.go_enrichment import GOEnrichmentStudy
from goatools.obo_parser import GODag
from goatools.associations import read_gaf
from collections import defaultdict
import itertools
from biothings_client import get_client
import pandas as pd
import logging
assert type(genelist) is list and len(genelist) > 0
if nmin < 1:
nmin = 1
bg0 = bg
# Convert gene names
if conversion is not None:
assert len(conversion) == 3
name_from, name_to, species = conversion
mg = get_client('gene')
ans = set(genelist)
if bg is not None:
t1 = set(bg)
assert len(ans - t1) == 0
ans |= t1
ans = list(ans)
ans = mg.querymany(ans, scopes=name_from, fields=name_to, species=species)
t1 = set(['query', '_score', name_to.split('.')[0]])
ans = list(filter(lambda x: len(t1 - set(x)) == 0, ans))
ans = sorted(ans, key=lambda x: x['_score'])
convert = {x['query']: x for x in ans}
for xi in name_to.split('.'):
convert = filter(lambda x: xi in x[1], convert.items())
convert = {x[0]: x[1][xi] for x in convert}
convert = {
x[0]: x[1] if type(x[1]) is str else x[1][0]
for x in convert.items()}
genelist2 = list(
set([convert[x] for x in filter(lambda x: x in convert, genelist)]))
if bg is not None:
bg = list(set([convert[x] for x in filter(lambda x: x in convert, bg)]))
t1 = set(genelist)
converti = list(filter(lambda x: x[0] in t1, convert.items()))
t1 = defaultdict(list)
for xi in converti:
t1[xi[1]].append(xi[0])
converti = dict(t1)
t1 = defaultdict(list)
for xi in convert.items():
t1[xi[1]].append(xi[0])
convertia = dict(t1)
else:
genelist2 = genelist
# Load GO DAG and association files
logging.debug('Reading GO DAG file ' + go_file)
godag = GODag(go_file)
logging.debug('Reading GO association file ' + goa_file)
goa = read_gaf(goa_file, evidence_set=evidence_set)
if bg is None:
bg = list(goa.keys())
# Compute enrichment
goe = GOEnrichmentStudy(bg, goa, godag)
ans = goe.run_study(genelist2)
# Format output
with NamedTemporaryFile() as f:
goe.wr_tsv(f.name, ans)
ans = f.read()
ans = ans.decode()
ans = [x.split('\t') for x in ans.split(linesep)]
if len(ans[-1]) < 2:
ans = ans[:-1]
if len(ans) == 0 or len(ans[0]) == 0:
raise ValueError('No enrichment found. Check your input ID type.')
ans[0][0] = ans[0][0].strip('# ')
ans = pd.DataFrame(ans[1:], columns=ans[0])
ans.drop(['NS', 'enrichment', 'study_count', 'p_sidak', 'p_holm'],
axis=1,
inplace=True)
for xj in ['p_uncorrected', 'p_bonferroni']:
ans[xj] = pd.to_numeric(ans[xj], errors='raise')
ans['depth'] = pd.to_numeric(ans['depth'],
errors='raise',
downcast='unsigned')
# Odds ratio column and sort column
ans['odds_ratio'] = toratio(ans['ratio_in_study']) / toratio(
ans['ratio_in_pop'])
ans = ans[[
'name', 'depth', 'p_uncorrected', 'p_bonferroni', 'odds_ratio',
'ratio_in_study', 'ratio_in_pop', 'GO', 'study_items']]
ans['study_items'] = ans['study_items'].apply(lambda x: x.replace(' ', ''))
# Convert back study_items
if conversion is not None:
ans['study_items'] = ans['study_items'].apply(lambda x: ','.join(
list(itertools.chain.from_iterable([converti[y] for y in x.split(',')])))
if len(x) > 0 else x)
ans.sort_values('p_uncorrected', inplace=True)
# Get top enriched GO by P-value
gotop = ans[
(ans['odds_ratio'] > 1)
& ans['ratio_in_study'].apply(lambda x: int(x.split('/')[0]) >= nmin)]
if len(gotop) == 0:
raise ValueError('No GO enrichment found for given criteria.')
gotop = str(gotop.iloc[0]['GO'])
if bg0 is not None:
# Children GOs
gos = set([gotop] + list(godag.query_term(gotop).get_all_children()))
# Look for genes
genes = list(
filter(lambda x: len(list(filter(lambda y: y in gos, goa[x]))) > 0, goa))
if conversion is not None:
genes = [convertia[x] for x in filter(lambda x: x in convertia, genes)]
genes = list(set(list(itertools.chain.from_iterable(genes))))
genes = set(genes)
genes = list(filter(lambda x: x in genes, bg0))
else:
genes = None
return (ans, gotop, genes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_functional_enrichment(enrichment_file, go, remove_parents=False, only_biological_processes=False, only_slim=False, logodds_cutoff=0):\n\n #from toolbox import OboParser\n #g=OboParser.getOboGraph(\"/home/emre/arastirma/celldiff/data/GO/gene_ontology.1_2.obo\")\n g=go\n\n go_terms = None\n na... | [
"0.62130064",
"0.5718101",
"0.53815275",
"0.53254366",
"0.5073769",
"0.50681895",
"0.49845618",
"0.49842817",
"0.4910564",
"0.48540446",
"0.4827082",
"0.47912404",
"0.47549713",
"0.47513545",
"0.47407323",
"0.47222322",
"0.47175512",
"0.47109953",
"0.47066993",
"0.47058165",
... | 0.4953663 | 8 |
Finds the top variable GO enrichment of top principal genes in the binary coexpression network. Principal genes are those with most coexpressed genes. They reflect the most variable pathways in the dataset. When the variable pathways are housekeeping related, they may conceal celltypespecific coexpression patterns from being observed and understood. This function identifies the most variable pathway with gene ontology enrichment study of the top principal genes. Background genes are all genes provided. | def gotop(net, namet, go_file, goa_file, n=100, **ka):
import numpy as np
nt = len(namet)
if net.shape != (nt, nt) or nt <= 1:
raise ValueError('Wrong shape for net or namet.')
if n <= 1 or n >= nt:
raise ValueError(
'Number of principal genes must be from 1 to the number of all genes (exclusive).'
)
# Find principal genes
t1 = net.sum(axis=1)
t2 = t1[t1.argsort()[::-1][n]]
if t2 == 0:
raise RuntimeError('Not enough principal genes that have co-expression')
t2 = np.nonzero(t1 >= t2)[0]
assert len(t2) >= n
assert len(t2) < nt
t1 = [str(x) for x in namet[t2]]
t2 = [str(x) for x in namet]
return tuple([t1] + list(goe(t1, go_file, goa_file, bg=t2, **ka))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetTopConfidenceNodes(g, dia, topn=20):\r\n conf_hf = {}\r\n for i in g.nodes(data=True):\r\n n, distr = i\r\n if (distr['class_distribution']['No Diagnosis'] != 0):\r\n conf_hf[n] = distr['class_distribution']['Diagnosis'] / (\r\n distr['class_distribution... | [
"0.5159819",
"0.5115306",
"0.504334",
"0.48993444",
"0.48605645",
"0.48025545",
"0.47738016",
"0.4770416",
"0.47697255",
"0.4766613",
"0.4763854",
"0.4754322",
"0.47231025",
"0.47138077",
"0.4684063",
"0.46748742",
"0.4669275",
"0.46637076",
"0.46562827",
"0.46556216",
"0.465... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.