List[Dict[str, str]]:\\n # split into paragraphs\\n lines = text.splitlines()\\n groups = common.group_list(lines, lambda a, _: a.strip() == '')\\n paras = ['\\\\n'.join(item) for empty_line, item in groups if not empty_line]\\n\\n def _fallback(p, type):\\n logging.warn(f'Wrong {type} format:\\\\n' + p)\\n cells.append({'type': 'text', 'source': p})\\n\\n cells = []\\n for p in paras:\\n lines = p.splitlines() + ['']\\n p += '\\\\n'\\n if p.startswith('#'):\\n # parse title\\n if not _is_mark(lines[1:]):\\n _fallback(p, 'title')\\n else:\\n m = re.match(r'#+ *', lines[0])\\n cells.append({\\n 'type': 'title',\\n 'prefix': m[0],\\n 'source': lines[0][m.span()[1]:],\\n 'mark': '\\\\n'.join(lines[1:])})\\n elif p.startswith('$$'):\\n # parse equations\\n m = re.findall(r'\\\\$\\\\$', p)\\n if len(m) != 2:\\n _fallback(p, 'equation')\\n else:\\n cells.append({'type': 'equation', 'source': p})\\n elif p.startswith('!['):\\n # parse images\\n if not lines[0].strip().endswith(')') or not _is_mark(lines[1:]):\\n _fallback(p, 'image')\\n else:\\n cells.append({'type': 'image', 'source': p})\\n elif p.startswith('|'):\\n # parse table\\n for i, l in enumerate(lines):\\n if not l.startswith('|'):\\n break\\n if not _is_mark(lines[i:]):\\n _fallback(p, 'equation')\\n else:\\n cells.append({'type': 'table', 'source': p})\\n else:\\n groups = common.group_list(lines, _list)\\n for prefix, item in groups:\\n if len(prefix.split('__')) == 2:\\n prefix = prefix.split('__')[0]\\n source = '\\\\n'.join(item)[len(prefix):]\\n if prefix == '':\\n cells.append({'type': 'text', 'source': source})\\n else:\\n cells.append({\\n 'type': 'list',\\n 'prefix': prefix,\\n 'source': source})\\n return cells\",\n \"def text_to_images(text):\\n top_keywords = text_to_keywords(text)\\n images = keyword_to_images(top_keywords)\\n return images\",\n \"def normalize_text(text):\\n text = re.sub(r'[ \\\\t]+', ' ', text)\\n text = re.sub(r'\\\\r', '', text)\\n\\n # Remove whitespace in the middle of text.\\n text = re.sub(r'[ \\\\t]+\\\\n', '\\\\n', text)\\n # Remove whitespace at the end of the text.\\n text = text.rstrip()\\n\\n return text\",\n \"def reach_process_text():\\n response = request.body.read().decode('utf-8')\\n body = json.loads(response)\\n text = body.get('text')\\n rp = reach.process_text(text)\\n if rp and rp.statements:\\n stmts = stmts_to_json(rp.statements)\\n res = {'statements': stmts}\\n return res\\n else:\\n res = {'statements': []}\\n return res\",\n \"def get_text_summarization_gensim(text, summary_ratio=0.4):\\n sentences = extract_sentences(text)\\n text = ' '.join(sentences)\\n summary = summarize(text, split=True, ratio=summary_ratio)\\n return summary\",\n \"def preprocess_text(text, tokenize=False, ner=False, stem=False, stopw=False, all_lower=False, strip_punct=True):\\n\\n # Clean the text\\n text = re.sub(r\\\"what's\\\", \\\"what is \\\", text)\\n text = re.sub(r\\\"\\\\'s\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\'ve\\\", \\\" have \\\", text)\\n text = re.sub(r\\\"can't\\\", \\\"cannot \\\", text)\\n text = re.sub(r\\\"n't\\\", \\\" not \\\", text)\\n text = re.sub(r\\\"i'm\\\", \\\"i am \\\", text)\\n text = re.sub(r\\\"\\\\'re\\\", \\\" are \\\", text)\\n text = re.sub(r\\\"\\\\'d\\\", \\\" would \\\", text)\\n text = re.sub(r\\\"\\\\'ll\\\", \\\" will \\\", text)\\n text = re.sub(r\\\"i\\\\.e\\\\.\\\", \\\"\\\", text)\\n text = re.sub(r\\\"\\\\.\\\", \\\" . \\\", text)\\n text = re.sub(r\\\"!\\\", \\\" ! \\\", text)\\n text = re.sub(r\\\"\\\\/\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\^\\\", \\\" ^ \\\", text)\\n text = re.sub(r\\\"\\\\+\\\", \\\" + \\\", text)\\n text = re.sub(r\\\"\\\\-\\\", \\\" - \\\", text)\\n text = re.sub(r\\\"\\\\=\\\", \\\" = \\\", text)\\n text = re.sub(r\\\"'\\\", \\\" \\\", text)\\n text = re.sub(r'\\\"', \\\" \\\", text)\\n text = re.sub(r\\\"(\\\\d+)(k)\\\", r\\\"\\\\g<1>000\\\", text)\\n text = re.sub(r\\\":\\\", \\\" : \\\", text)\\n text = re.sub(r\\\" e g \\\", \\\" eg \\\", text)\\n text = re.sub(r\\\"^e g \\\", \\\" eg \\\", text)\\n text = re.sub(r\\\" b g \\\", \\\" bg \\\", text)\\n text = re.sub(r\\\"^b g \\\", \\\" bg \\\", text)\\n text = re.sub(r\\\" u s \\\", \\\" american \\\", text)\\n text = re.sub(r\\\"^u s \\\", \\\" american \\\", text)\\n text = re.sub(r\\\"\\\\0s\\\", \\\"0\\\", text)\\n text = re.sub(r\\\" 9 11 \\\", \\\"911\\\", text)\\n text = re.sub(r\\\"e - mail\\\", \\\"email\\\", text)\\n text = re.sub(r\\\"j k\\\", \\\"jk\\\", text)\\n text = re.sub(r\\\"\\\\s{2,}\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\b[a-zA-Z]\\\\b\\\", \\\"\\\", text)\\n\\n if ner:\\n tokenized_text = word_tokenize(text)\\n tagged_text = pos_tag(tokenized_text)\\n chunked_text = ne_chunk(tagged_text, binary=True)\\n\\n named_entities = extract_entity_names(chunked_text)\\n for named_entity in named_entities:\\n entity = named_entity.replace(\\\".\\\", \\\"\\\")\\n entity = re.sub(r'\\\\s+', \\\"_\\\", entity)\\n text = text.replace(named_entity, entity)\\n\\n if all_lower:\\n text = text.lower()\\n\\n if stopw:\\n global stops\\n if stops is None:\\n try:\\n stops = set(stopwords.words(\\\"english\\\"))\\n except Exception as e:\\n print(\\\"%s - Please download english stopwords from NLTK\\\" % e)\\n exit()\\n text = [word.strip() for word in text.split() if word not in stops]\\n text = \\\" \\\".join(text)\\n\\n if tokenize:\\n text = word_tokenize(text)\\n text = \\\" \\\".join(text)\\n\\n # shorten words to their stems\\n if stem:\\n text = text.split()\\n stemmer = SnowballStemmer('english')\\n stemmed_words = [stemmer.stem(word) for word in text]\\n text = \\\" \\\".join(stemmed_words)\\n\\n if strip_punct:\\n text = text.translate(str.maketrans('', '', string.punctuation))\\n\\n text = text.strip()\\n\\n # Empty string\\n if text == '':\\n return EMPTY_TOKEN\\n\\n return text\",\n \"def from_text(text):\\n\\n return _from_text(text, _by_text)\",\n \"def pegasus_eval(text, params):\\n model, tokenizer, torch_device = params\\n batch = tokenizer.prepare_seq2seq_batch([text], truncation=True, padding='longest', return_tensors=\\\"pt\\\").to(torch_device)\\n translated = model.generate(**batch)\\n output = tokenizer.batch_decode(translated, skip_special_tokens=True)[0]\\n output = output.replace('<n>', ' ')\\n return output\",\n \"def parsingconvtext(retrievedtext,customtextlist):\\r\\n if not retrievedtext: #in case empty text \\r\\n retrievedtext=changenonetostr(retrievedtext)\\r\\n newtext=BeautifulSoup(retrievedtext).get_text() \\r\\n #newtext=changenonetostr(retrievedtext)\\r\\n #newtext=BeautifulSoup(newtext).get_text() \\r\\n #remove http links\\r\\n newtext=re.sub(r'http\\\\S+', '', newtext)\\r\\n newtext=re.sub(r'\\\\r\\\\r\\\\r\\\\n', ' ', newtext)\\r\\n #remove LL specific text\\r\\n if customtextlist:\\r\\n for i in customtextlist:\\r\\n newtext=re.sub(i, '', newtext)\\r\\n return newtext\",\n \"def preprocess_training_text_with_stops(text, convert=False):\\n return preprocess_training_text(text, accented_chars=True,\\n convert_num=False, extra_whitespace=True, \\n lemmatization=True, lowercase=True, punctuations=True,\\n remove_html=True, remove_num=True, special_chars=True, \\n stop_words=False)\",\n \"def process_text(text, stemmer=SnowballStemmer(\\\"english\\\"), min_length=3):\\n text = text.lower()\\n text = re.sub('dictated.*', '', text, flags=re.MULTILINE|re.DOTALL)\\n text = re.sub('.*:\\\\s+', '', text)\\n text = re.sub('\\\\n', ' ', text)\\n text = re.sub('\\\\[.*?\\\\]', '', text)\\n text = re.sub('\\\\s\\\\s+', ' ', text)\\n text = re.sub('[,.]', '', text)\\n text = re.sub('[/-]', ' ', text)\\n tokens = word_tokenize(text)\\n return \\\" \\\".join([stemmer.stem(t) for t in tokens if t not in stop_words\\n and len(t) >= min_length])\",\n \"def from_text(text):\\n return parse(text)\",\n \"def trans(monitext):\\n result = ''\\n last_line = 'empty'\\n\\n while monitext:\\n # newline character or empty line(s)\\n matched = re.match(r'\\\\n+', monitext, re.M)\\n\\n if matched:\\n result += matched.group()\\n if len(matched.group()) > 1:\\n last_line = 'empty'\\n elif last_line == 'title':\\n result += '\\\\n'\\n last_line = 'empty'\\n monitext = monitext[matched.end():]\\n continue\\n\\n # code block\\n matched = re.match(r'{{{.*?\\\\n((\\\\n|.)*?)\\\\n}}}', monitext, re.M)\\n\\n if matched:\\n body = matched.groups()[0]\\n result += '\\\\n\\\\t' + '\\\\n\\\\t'.join(body.split('\\\\n'))\\n monitext = monitext[matched.end():]\\n last_line = 'code'\\n continue\\n\\n # header\\n matched = re.match(r'^(=+) (.+) (=+)', monitext)\\n\\n if matched:\\n title = matched.groups()[1]\\n level = len(matched.groups()[0])\\n\\n if last_line != 'empty':\\n result += '\\\\n'\\n\\n if level < 4:\\n underscore = {2 : '=', 3 : '-'}[level] * mbstrlen(title)\\n result += title + os.linesep + underscore\\n else:\\n result += ('#' * level) + \\\" \\\" + title\\n monitext = monitext[matched.end():]\\n\\n last_line = 'title'\\n\\n continue\\n\\n # link\\n matched = re.match(r'(.*)\\\\[([^\\\\s]+[ \\\\t]+)?(.+)\\\\]', monitext)\\n\\n if matched:\\n pre = matched.groups()[0]\\n url = matched.groups()[1]\\n if url:\\n url = url.strip()\\n name = matched.groups()[2]\\n\\n if url:\\n replaced = \\\"%s[%s](%s)\\\" % (pre, name, url)\\n else:\\n replaced = \\\"%s[%s](%s)\\\" % (pre, name, name)\\n\\n monitext = monitext[:matched.start()] + replaced\\\\\\n + monitext[matched.end():]\\n\\n # important\\n monitext = re.sub(r'\\\\'\\\\'\\\\'(.*?)\\\\'\\\\'\\\\'', r'**\\\\1**', monitext)\\n\\n # italic\\n monitext = re.sub(r'\\\\'\\\\'(.*?)\\\\'\\\\'', r'_\\\\1_', monitext)\\n\\n # list\\n matched = re.match(r'^(\\\\s*)\\\\* (.*)', monitext)\\n\\n if matched:\\n depth = len(matched.groups()[0])\\n body = matched.groups()[1]\\n result += (depth - 1) * '\\\\t' + '* ' + body\\n monitext = monitext[matched.end():]\\n\\n last_line = 'others'\\n\\n try:\\n # Go to the next line\\n index = monitext.index('\\\\n')\\n result += monitext[:index]\\n monitext = monitext[index:]\\n except ValueError:\\n result += monitext\\n break\\n\\n return result\",\n \"def process_text(text):\\n doc = spacy_model(text.lower())\\n result = []\\n for token in doc:\\n if token.text in spacy_model.Defaults.stop_words:\\n continue\\n if token.is_punct:\\n continue\\n if token.lemma_ == '-PRON-':\\n continue\\n result.append(token.lemma_)\\n return \\\" \\\".join(result)\",\n \"def _from_text_to_crf(self, message, entities=None):\\n crf_format = []\\n tokens = self.nlp(message[\\\"text\\\"]) \\n for i, token in enumerate(tokens):\\n pattern = {}\\n entity = entities[i] if entities else \\\"N/A\\\"\\n tag = None\\n custom_ner_features = None\\n crf_format.append((token.text, tag, entity, pattern, custom_ner_features))\\n return crf_format\",\n \"def PigToEnglish(str):\\r\\n\\r\\n # TODO: Your code here\\r\\n\\r\\n\\r\\n # Change the return to return the converted string\\r\\n return(\\\"\\\")\",\n \"def _get_raw_annotations_for_text(text, ontologies='MESH', semantic_types=None):\\n\\n if semantic_types is None:\\n semantic_types = ()\\n\\n params = {}\\n params['text'] = text\\n params['ontologies'] = ontologies\\n params['semantic_types'] = ','.join(semantic_types)\\n response = _make_api_call('http://data.bioontology.org/annotator', params)\\n raw_annotations = response.json()\\n return raw_annotations\",\n \"def parse(self, text):\\n return self.dict.txt2vec(text)\",\n \"def _convert_speech_to_text(self, storage_uri):\\n\\n responses = self._convert_speech_to_text_by_api(storage_uri)\\n texts = [result.alternatives[0].transcript for result in responses.results]\\n self._texts = '\\\\n\\\\n'.join(texts)\",\n \"def preprocessing_a1(self, text):\\n # clean description\\n cleaned_text = self.text_cleaning(text)\\n # preprocess description\\n preprocessed_text = self.text_preprocessing_a1(cleaned_text)\\n\\n return preprocessed_text\",\n \"def detect_text(img):\\n \\n with io.open(img, 'rb') as image_file:\\n content = image_file.read()\\n\\n image = vision.types.Image(content=content)\\n response = client.text_detection(image=image) # returns TextAnnotation\\n df = pd.DataFrame(columns=['description'])\\n texts = response.text_annotations\\n for text in texts:\\n df = df.append(\\n dict(\\n \\n description= clean_text (text.description)\\n ),\\n ignore_index=True\\n )\\n \\n porter = PorterStemmer()\\n\\n try:\\n text= (df['description'][0])\\n text = porter.stem(text)\\n except IndexError:\\n text = 'i am neutral'\\n # print (analyze(text))\\n \\n \\n # print(df['description'])\\n print(text)\\n if len (text.split())<3:\\n text = 'i am neutral'\\n\\n sentiment_dict= analyze2(text) \\n if sentiment_dict >= 0.008: \\n Category.append('Positive') \\n return('Positive') \\n\\n elif (sentiment_dict > - 0.008) & (sentiment_dict < 0.008): \\n Category.append('Random')\\n return('Random')\\n\\n elif (sentiment_dict <= -0.008):\\n Category.append('Negative')\\n return('Negative')\",\n \"def _format_text(self, text) :\\n text_width = self.width - self.current_indent\\n indent = \\\" \\\"*self.current_indent\\n output_text = []\\n paragraphs = text.split('\\\\n')\\n for p in paragraphs :\\n output_text.append(textwrap.fill(p,\\n text_width,\\n initial_indent=indent,\\n subsequent_indent=indent))\\n return '\\\\n'.join(output_text)\",\n \"def save_annotated_text_to_txt(self):\\n #initialise file to write the output\\n outfile = open(('annotated_text_' + self.lang + '_' + self.method +\\n '.txt'), 'w')\\n #counter for the sentences\\n counter_sentence = 0\\n #counter for the paragrafhs\\n counter_paragraph = 0\\n #open txt file\\n with open(self.lang + '.txt') as file:\\n for paragraph in file:\\n sentences = tokenize.sent_tokenize(paragraph)\\n for sentence in sentences:\\n #build lists with the ends of the tokens with NE and the NEs\\n end_list = [0]\\n end_list += [i[2] for i in \\n self.named_entity_list_total[counter_sentence]]\\n ne_list = [i[3] for i in \\n self.named_entity_list_total[counter_sentence]]\\n counter_sentence += 1\\n #build new string\\n new_string = ''\\n for i in range(len(end_list)-1):\\n new_string += (sentence[end_list[i]:end_list[i+1]]+\\n '<annotation class=\\\"'+ne_list[i]+'\\\">')\\n new_string += sentence[end_list[-1]:len(sentence)]\\n #add new_string to outfile\\n outfile.write(new_string + '\\\\n')\\n #add additional space after abstract\\n if counter_paragraph == 2:\\n outfile.write('\\\\n') \\n counter_paragraph += 1\\n outfile.close()\\n return\",\n \"def textoutput(text):\\n\\n lines = text.split(\\\"\\\\n\\\")\\n result = []\\n\\n protocols = \\\"https?|ftp|sftp|file|afs|nfs\\\"\\n savane_tags = \\\"verbatim|nomarkup\\\"\\n\\n for line in lines:\\n # Handle named hyperlink.\\n line = re.sub(\\n # find the opening brace '['\\n\\t\\t '\\\\['\\n # followed by the protocol, either http:// or https://\\n\\t\\t + '((' + protocols + '):\\\\/\\\\/'\\n # match any character except whitespace or the closing\\n # brace ']' for the actual link\\n\\t\\t + '[^\\\\s\\\\]]+)'\\n # followed by at least one whitespace\\n\\t\\t + '\\\\s+'\\n # followed by any character (non-greedy) and the\\n # next closing brace ']'\\n\\t\\t + '(.+?)\\\\]', '\\\\\\\\3 <\\\\\\\\1>', line)\\n \\n # Remove savane-specific tags\\n line = re.sub('\\\\+(' + savane_tags + ')\\\\+', '', line)\\n line = re.sub('-(' + savane_tags + ')-', '', line)\\n result.append(line)\\n\\n return \\\"\\\\n\\\".join(result)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66363716","0.61474895","0.6118832","0.6097702","0.609217","0.60894656","0.6057062","0.60051125","0.6003964","0.59820795","0.59751576","0.5925597","0.5902075","0.5848546","0.5844513","0.5837306","0.58300614","0.58283144","0.5815858","0.5792594","0.5778242","0.57480145","0.57458895","0.5734289","0.569558","0.56917804","0.5674859","0.5668577","0.5655869","0.56327575","0.5625962","0.56073576","0.5605461","0.56039375","0.5598402","0.55878896","0.5587465","0.5586224","0.5583719","0.55676633","0.5565393","0.5540405","0.5539813","0.5529377","0.5525011","0.5519682","0.5515444","0.55116284","0.54856193","0.5476458","0.5467546","0.5463749","0.54634273","0.5457838","0.5454935","0.5454135","0.54462796","0.5443667","0.53999984","0.5387119","0.53853834","0.53594375","0.53575885","0.53568","0.5352479","0.53499365","0.53488964","0.53447264","0.534245","0.53357273","0.53298485","0.5319866","0.53089476","0.5304378","0.5303721","0.53023404","0.5299362","0.52991325","0.52976","0.529214","0.5287563","0.5285161","0.5278127","0.5275741","0.5275618","0.5273768","0.5272649","0.5270465","0.5268924","0.5266941","0.52648497","0.5258628","0.5250754","0.5246488","0.52442825","0.5236278","0.5233339","0.5229646","0.5227695","0.52225095"],"string":"[\n \"0.66363716\",\n \"0.61474895\",\n \"0.6118832\",\n \"0.6097702\",\n \"0.609217\",\n \"0.60894656\",\n \"0.6057062\",\n \"0.60051125\",\n \"0.6003964\",\n \"0.59820795\",\n \"0.59751576\",\n \"0.5925597\",\n \"0.5902075\",\n \"0.5848546\",\n \"0.5844513\",\n \"0.5837306\",\n \"0.58300614\",\n \"0.58283144\",\n \"0.5815858\",\n \"0.5792594\",\n \"0.5778242\",\n \"0.57480145\",\n \"0.57458895\",\n \"0.5734289\",\n \"0.569558\",\n \"0.56917804\",\n \"0.5674859\",\n \"0.5668577\",\n \"0.5655869\",\n \"0.56327575\",\n \"0.5625962\",\n \"0.56073576\",\n \"0.5605461\",\n \"0.56039375\",\n \"0.5598402\",\n \"0.55878896\",\n \"0.5587465\",\n \"0.5586224\",\n \"0.5583719\",\n \"0.55676633\",\n \"0.5565393\",\n \"0.5540405\",\n \"0.5539813\",\n \"0.5529377\",\n \"0.5525011\",\n \"0.5519682\",\n \"0.5515444\",\n \"0.55116284\",\n \"0.54856193\",\n \"0.5476458\",\n \"0.5467546\",\n \"0.5463749\",\n \"0.54634273\",\n \"0.5457838\",\n \"0.5454935\",\n \"0.5454135\",\n \"0.54462796\",\n \"0.5443667\",\n \"0.53999984\",\n \"0.5387119\",\n \"0.53853834\",\n \"0.53594375\",\n \"0.53575885\",\n \"0.53568\",\n \"0.5352479\",\n \"0.53499365\",\n \"0.53488964\",\n \"0.53447264\",\n \"0.534245\",\n \"0.53357273\",\n \"0.53298485\",\n \"0.5319866\",\n \"0.53089476\",\n \"0.5304378\",\n \"0.5303721\",\n \"0.53023404\",\n \"0.5299362\",\n \"0.52991325\",\n \"0.52976\",\n \"0.529214\",\n \"0.5287563\",\n \"0.5285161\",\n \"0.5278127\",\n \"0.5275741\",\n \"0.5275618\",\n \"0.5273768\",\n \"0.5272649\",\n \"0.5270465\",\n \"0.5268924\",\n \"0.5266941\",\n \"0.52648497\",\n \"0.5258628\",\n \"0.5250754\",\n \"0.5246488\",\n \"0.52442825\",\n \"0.5236278\",\n \"0.5233339\",\n \"0.5229646\",\n \"0.5227695\",\n \"0.52225095\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6489249"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3387,"cells":{"query":{"kind":"string","value":"Bin calculation for x and y Calculates the bin edges for the given data arrays x and y."},"document":{"kind":"string","value":"def get_2D_bins(x, y, bins, same_bins=False):\n \n # precalculated bins [np.ndarray, np.ndarray]: do nothing and return the same bins\n if isinstance(bins, list):\n if isinstance(bins[0], np.ndarray) and isinstance(bins[1], np.ndarray):\n pass\n elif 'uniform_counts' in bins:\n try:\n n = int(bins[1])\n\n bins_x = np.fromiter(\n (np.nanpercentile(x, (i / n) * 100) for i in range(1, n + 1)),\n dtype=float)\n bins_y = np.fromiter(\n (np.nanpercentile(y, (i / n) * 100) for i in range(1, n + 1)),\n dtype=float)\n bins = [bins_x, bins_y] \n except:\n raise ValueError(f\"Please define number of bins for binning method uniform_counts: bins = ['uniform_bins', n_bins]\")\n else:\n # calculate bins with np.histogram_bin_edges(), even_width option == int\n if bins in ['fd', 'doane', 'scott', 'stone', 'rice', 'sturges', 'sqrt'] or isinstance(bins, int):\n if same_bins:\n bins_xy = np.histogram_bin_edges([x, y], bins)\n bins = [bins_xy, bins_xy]\n else:\n bins_x = np.histogram_bin_edges(x, bins)\n bins_y = np.histogram_bin_edges(y, bins)\n bins = [bins_x, bins_y]\n elif bins == 'uniform_counts':\n raise ValueError(f\"Please define number of bins for binning method uniform_bins: bins = ['uniform_bins', n_bins]\") \n elif bins == 'unique_values':\n if same_bins:\n bins_xy = np.unique([x, y])\n bins = [bins_xy, bins_xy]\n else:\n bins_x = np.unique(x)\n bins_y = np.unique(y)\n bins = [bins_x, bins_y]\n else:\n raise ValueError(f\"Binning option {bins} not know.\")\n \n # always return bins as bin edges: [np.ndarray, np.ndarray] \n return bins"},"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 get2DBins(x, y, binSizeX, binSizeY):\n\n result = []\n xlength = len(x)\n ylength = len(y)\n\n i = 0\n xcount = 0\n for i1 in range(0, xlength, binSizeX):\n i2 = i1 + binSizeX\n if i2 >= xlength:\n i2 = xlength - 1\n xcount += 1\n ycount = 0\n for j1 in range(0, ylength, binSizeY):\n j2 = j1 + binSizeY\n if j2 >= ylength:\n j2 = ylength - 1\n result.append((i1, i2, j1, j2))\n ycount += 1\n return result, xcount, ycount","def bin_binarise(self):\n pass","def histogram2d(x, y, bins_x, bins_y):\n # x-range\n x_max, x_min = x.max(), x.min()\n delta_x = 1 / ((x_max - x_min) / bins_x)\n # y-range\n y_max, y_min = y.max(), y.min()\n delta_y = 1 / ((y_max - y_min) / bins_y)\n # compute histogram 2d\n xy_bin = np.zeros((np.int64(bins_x), np.int64(bins_y)), dtype=np.int64)\n for t in range(len(x)):\n i = (x[t] - x_min) * delta_x\n j = (y[t] - y_min) * delta_y\n if 0 <= i < bins_x and 0 <= j < bins_y:\n xy_bin[int(i), int(j)] += 1\n return xy_bin","def d2_bin(self, x, y):\n \n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\n KD.fit(np.column_stack((x,y)))\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\n mesh = np.meshgrid(grid1,grid2)\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\n samp = KD.score_samples(data)\n samp = samp.reshape(self.bins,self.bins)\n p = np.exp(samp)/np.sum(np.exp(samp))\n\n return p","def binvec(x):\n edge1 = x[0] - (x[1]-x[0])/2\n edge2 = x[-1] + (x[-1]-x[-2])/2\n return np.linspace(edge1, edge2, len(x)+1)","def _get_bin_edges(a, bins, range):\n # parse the overloaded bins argument\n n_equal_bins = None\n bin_edges = None\n\n if isinstance(bins, str):\n raise NotImplementedError(\n 'only integer and array bins are implemented')\n elif isinstance(bins, cupy.ndarray) or numpy.ndim(bins) == 1:\n # TODO(okuta): After #3060 is merged, `if cupy.ndim(bins) == 1:`.\n if isinstance(bins, cupy.ndarray):\n bin_edges = bins\n else:\n bin_edges = numpy.asarray(bins)\n\n if (bin_edges[:-1] > bin_edges[1:]).any(): # synchronize! when CuPy\n raise ValueError(\n '`bins` must increase monotonically, when an array')\n if isinstance(bin_edges, numpy.ndarray):\n bin_edges = cupy.asarray(bin_edges)\n elif numpy.ndim(bins) == 0:\n try:\n n_equal_bins = operator.index(bins)\n except TypeError:\n raise TypeError(\n '`bins` must be an integer, a string, or an array')\n if n_equal_bins < 1:\n raise ValueError('`bins` must be positive, when an integer')\n\n first_edge, last_edge = _get_outer_edges(a, range)\n else:\n raise ValueError('`bins` must be 1d, when an array')\n\n if n_equal_bins is not None:\n # numpy's gh-10322 means that type resolution rules are dependent on\n # array shapes. To avoid this causing problems, we pick a type now and\n # stick with it throughout.\n bin_type = cupy.result_type(first_edge, last_edge, a)\n if cupy.issubdtype(bin_type, cupy.integer):\n bin_type = cupy.result_type(bin_type, float)\n\n # bin edges must be computed\n bin_edges = cupy.linspace(\n first_edge, last_edge, n_equal_bins + 1,\n endpoint=True, dtype=bin_type)\n return bin_edges","def hbinavg(x,y,bins):\n\n binx = bins[:-1] + (bins[1:] - bins[:-1])/2.\n bsum = ( np.histogram(x,bins=bins,weights=y) )[0]\n bn = ( np.histogram(x,bins=bins) )[0]\n biny = bsum/bn\n\n return binx,biny","def bws(x, y, **kwargs):\n\tx.sort()\n\ty.sort()\n\tnpx = np.array(x)\n\tnpy = np.array(y)\n\n\txs = np.unique(npx)\n\tys = np.unique(npy)\n\txys = set(xs).union(set(ys))\n\taxy = np.array(list(xys))\n\taxy.sort()\n\n\tG = np.array([len(axy[np.where(axy <= xi)]) for xi in xs])\n\tH = np.array([len(axy[np.where(axy <= yi)]) for yi in ys])\n\n\tn = len(G)\n\tm = len(H)\n\tfn = float(n)\n\tfm = float(m)\n\n\tN = np.linspace(1,n,num=n)\n\tM = np.linspace(1,m,num=m)\n\n\txt1 = np.power(G - N*(fm + fn)/fn, 2.0)\n\txtt = N/(fn+1.0)\n\txt2 = xtt*(1 - xtt)*(fm * (fm+fn)/fn)\n\tBx = np.sum(xt1/xt2)/fn\n\t\n\tyt1 = np.power(H - M*(fm + fn)/fm, 2.0)\n\tytt = M/(fm+1.0)\n\tyt2 = ytt*(1 - ytt)*(fn * (fm+fn)/fm)\n\tBy = np.sum(yt1/yt2)/fm\n\n\tB = (Bx+By)/2.0\n\n\tprint \"B = \", B\n\t\n\tJ = 3\n\tif \"j\" in kwargs:\n\t\tJ = kwargs[\"j\"]\n\t\n\treturn compute_xi(B, J)","def bapply(x,y,bins,func):\n \n assert bins[0] <= min(x),'range'\n assert bins[-1] > max(x),'range'\n\n bid = np.digitize(x,bins) \n nbins = bins.size-1\n yapply = np.zeros(nbins)\n\n for id in range(1,nbins):\n yb = y[bid==id]\n yapply[id-1] = func(yb)\n\n return yapply","def find_bin(self, x):\n return (x - self.bin_edges[0]) // self.bin_width","def find_bin_edges(bin_centres):\n\n if not isinstance(bin_centres, np.ndarray):\n bin_centres = np.asarray(bin_centres)\n\n edges = bin_centres[:-1] + 0.5 * (bin_centres[1:] - bin_centres[:-1])\n bins = np.concatenate(([2 * bin_centres[0] - edges[0]], edges,\n [2 * bin_centres[-1] - edges[-1]]))\n\n return bins","def binning():\n def r(x):\n return 1 << (x & 7)\n\n def w(x):\n return 0x11 * (x >> 1)\n return r, w","def rebin2D(h, binsx, binsy):\n new_h = TH2D(\"%s_rebin_\"%(h.GetName()), \"%s_rebin_\"%(h.GetName()),\n len(binsx)-1, array.array('d', binsx), len(binsy)-1, array.array('d', binsy))\n new_h.Sumw2()\n for i in xrange(h.GetNbinsX()):\n bin_to_fill_x = new_h.GetXaxis().FindBin(h.GetXaxis().GetBinCenter(i+1))\n for j in xrange(h.GetNbinsY()):\n bin_to_fill_y = new_h.GetYaxis().FindBin(h.GetYaxis().GetBinCenter(j+1))\n new_h.SetBinContent(bin_to_fill_x, bin_to_fill_y, h.GetBinContent(i+1,j+1) + new_h.GetBinContent(bin_to_fill_x, bin_to_fill_y))\n new_h.SetBinError(bin_to_fill_x, bin_to_fill_y,\n TMath.Sqrt(h.GetBinError(i+1, j+1)*h.GetBinError(i+1,j+1) + new_h.GetBinError(bin_to_fill_x, bin_to_fill_y)*new_h.GetBinError(bin_to_fill_x, bin_to_fill_y) ) )\n return new_h","def test_bin_edges(self):\n with Pandas() as pd:\n if pd is None:\n return\n with Numpy() as np:\n if numpy is None:\n return\n sys.stderr.write(\"\\n\")\n\n df1 = pd.DataFrame({'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1]})\n df2 = pd.DataFrame({'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8]})\n\n # building test histograms\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\n\n # fill them\n hist2.fill.numpy(df1)\n hist3.fill.numpy(df2)\n hist4.fill.numpy(df1)\n hist5.fill.numpy(df2)\n\n import numpy as np\n np.testing.assert_array_equal(hist2.bin_edges(), [0., 1., 2., 3., 4., 5.])\n np.testing.assert_array_equal(hist3.bin_edges(), [2., 3., 4., 5., 6., 7., 8., 9.])\n np.testing.assert_array_equal(hist4.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n np.testing.assert_array_equal(hist5.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n\n np.testing.assert_array_equal(hist2.bin_edges(low=2.1, high=11.9), [\n 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])\n np.testing.assert_array_equal(hist3.bin_edges(low=1.1, high=6), [1., 2., 3., 4., 5., 6.])\n np.testing.assert_array_equal(hist4.bin_edges(low=2.1, high=11.9), [\n 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n np.testing.assert_array_equal(hist5.bin_edges(low=1.1, high=5.4), [1., 2., 3., 4., 5., 6.])\n\n assert len(hist6.bin_edges()) == 202\n assert len(hist6.bin_edges(low=0.2089, high=0.9333)) == 147\n assert len(hist6.bin_edges(low=0.205, high=0.935)) == 147","def felix_binning(xs, ys, delta=1):\n \n #bins = np.arange(start, end, delta)\n #occurance = np.zeros(start, end, delta)\n BIN_STEP = delta\n BIN_START = xs.min()\n BIN_STOP = xs.max()\n\n indices = xs.argsort()\n datax = xs[indices]\n datay = ys[indices]\n\n print(\"In total we have: \", len(datax), ' data points.')\n #do the binning of the data\n bins = np.arange(BIN_START, BIN_STOP, BIN_STEP)\n print(\"Binning starts: \", BIN_START, ' with step: ', BIN_STEP, ' ENDS: ', BIN_STOP)\n\n bin_i = np.digitize(datax, bins)\n bin_a = np.zeros(len(bins)+1)\n bin_occ = np.zeros(len(bins)+1)\n\n for i in range(datay.size):\n bin_a[bin_i[i]] += datay[i]\n bin_occ[bin_i[i]] += 1\n\n binsx, data_binned = [], []\n for i in range(bin_occ.size-1):\n if bin_occ[i] > 0:\n binsx.append(bins[i]-BIN_STEP/2)\n data_binned.append(bin_a[i]/bin_occ[i])\n\n #non_zero_i = bin_occ > 0\n #binsx = bins[non_zero_i] - BIN_STEP/2\n #data_binned = bin_a[non_zero_i]/bin_occ[non_zero_i]\n\n return binsx, data_binned","def extEucBin(x, y):\n g = 1\n while isEven(x) and isEven(y):\n x, y, g = x >> 1, y >> 1, g << 1\n u, v, A, B, C, D = x, y, 1, 0, 0, 1\n while True:\n while isEven(u):\n u >>= 1\n if isEven(A) and isEven(B):\n A, B = A >> 1, B >> 1\n else:\n A, B = (A + y) >> 1, (B - x) >> 1\n while isEven(v):\n v >>= 1\n if isEven(C) and isEven(D):\n C, D = C >> 1, D >> 1\n else:\n C, D = (C + y) >> 1, (D - x) >> 1\n if u >= v:\n u, A, B = u - v, A - C, B - D\n else:\n v, C, D = v - u, C - A, D - B\n if u == 0:\n return (C, D, g * v)","def _make_bins(start, stop, step):\n bin_edges = np.arange(start, stop + step, step)\n\n return bin_edges","def create_bin_boundaries(config, epoch_df, data_type, obs_per_bin, verbose=False):\n \n edges = create_edges_set(config, epoch_df, data_type)\n \n boundaries = []\n for edge in edges:\n start, end, freq = edge\n bin_size = freq * obs_per_bin\n boundaries.append(np.arange(start, end, bin_size))\n boundaries = np.concatenate(boundaries)\n \n return boundaries","def bin_stats(x,y,xbins,stat='average'):\n nbins=len(xbins)\n if stat=='average' or stat=='mean': func=mean\n elif stat=='median': func=median\n elif stat=='rms' or stat=='std' : func=std\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\n elif stat=='mean_robust': func=mean_robust\n elif stat=='median_robust': func=median_robust\n elif stat=='sum': func=sum\n results=[]\n for i in range(nbins):\n if i<nbins-1:\n good=(greater_equal(x,xbins[i])\n *less(x,xbins[i+1]))\n else: good=(greater_equal(x,xbins[-1]))\n if sum(good)>1.: results.append(func(compress(good,y)))\n else:\n results.append(0.)\n print('Bin starting at xbins[%i] has %i points' % (i,sum(good)))\n return array(results)","def crazy_histogram2d(x, y, bins=10, weights=None, reduce_w=None, NULL=None, reinterp=None):\n # define the bins (do anything you want here but needs edges and sizes of the 2d bins)\n try:\n nx, ny = bins\n except TypeError:\n nx = ny = bins\n\n # values you want to be reported\n if weights is None:\n weights = np.ones(x.size)\n\n if reduce_w is None:\n reduce_w = np.sum\n else:\n if not hasattr(reduce_w, '__call__'):\n raise TypeError('reduce function is not callable')\n\n # culling nans\n finite_inds = (np.isfinite(x) & np.isfinite(y) & np.isfinite(weights))\n _x = np.asarray(x)[finite_inds]\n _y = np.asarray(y)[finite_inds]\n _w = np.asarray(weights)[finite_inds]\n\n if not (len(_x) == len(_y)) & (len(_y) == len(_w)):\n raise ValueError('Shape mismatch between x, y, and weights: {}, {}, {}'.format(_x.shape, _y.shape, _w.shape))\n\n xmin, xmax = _x.min(), _x.max()\n ymin, ymax = _y.min(), _y.max()\n dx = (xmax - xmin) / (nx - 1.0)\n dy = (ymax - ymin) / (ny - 1.0)\n\n # Basically, this is just doing what np.digitize does with one less copy\n xyi = np.vstack((_x, _y)).T\n xyi -= [xmin, ymin]\n xyi /= [dx, dy]\n xyi = np.floor(xyi, xyi).T\n\n # xyi contains the bins of each point as a 2d array [(xi,yi)]\n\n d = {}\n for e, k in enumerate(xyi.T):\n key = (k[0], k[1])\n\n if key in d:\n d[key].append(_w[e])\n else:\n d[key] = [_w[e]]\n\n _xyi = np.array(d.keys()).T\n _w = np.array([ reduce_w(v) for v in d.values() ])\n\n # exploit a sparse coo_matrix to build the 2D histogram...\n _grid = sparse.coo_matrix((_w, _xyi), shape=(nx, ny))\n\n if reinterp is None:\n # convert sparse to array with filled value\n # grid.toarray() does not account for filled value\n # sparse.coo.coo_todense() does actually add the values to the existing ones, i.e. not what we want -> brute force\n if NULL is None:\n B = _grid.toarray()\n else: # Brute force only went needed\n B = np.zeros(_grid.shape, dtype=_grid.dtype)\n B.fill(NULL)\n for (x, y, v) in zip(_grid.col, _grid.row, _grid.data):\n B[y, x] = v\n else: # reinterp\n xi = np.arange(nx, dtype=float)\n yi = np.arange(ny, dtype=float)\n B = griddata(_grid.col.astype(float), _grid.row.astype(float), _grid.data, xi, yi, interp=reinterp)\n\n return B, (xmin, xmax, ymin, ymax), (dx, dy)","def crazy_histogram2d(x, y, bins=10, weights=None, reduce_w=None, NULL=None, reinterp=None):\n # define the bins (do anything you want here but needs edges and sizes of the 2d bins)\n try:\n nx, ny = bins\n except TypeError:\n nx = ny = bins\n\n #values you want to be reported\n if weights is None:\n weights = np.ones(x.size)\n\n if reduce_w is None:\n reduce_w = np.sum\n else:\n if not hasattr(reduce_w, '__call__'):\n raise TypeError('reduce function is not callable')\n\n # culling nans\n finite_inds = (np.isfinite(x) & np.isfinite(y) & np.isfinite(weights))\n _x = np.asarray(x)[finite_inds]\n _y = np.asarray(y)[finite_inds]\n _w = np.asarray(weights)[finite_inds]\n\n if not (len(_x) == len(_y)) & (len(_y) == len(_w)):\n raise ValueError('Shape mismatch between x, y, and weights: {}, {}, {}'.format(_x.shape, _y.shape, _w.shape))\n\n xmin, xmax = _x.min(), _x.max()\n ymin, ymax = _y.min(), _y.max()\n dx = (xmax - xmin) / (nx - 1.0)\n dy = (ymax - ymin) / (ny - 1.0)\n\n # Basically, this is just doing what np.digitize does with one less copy\n xyi = np.vstack((_x, _y)).T\n xyi -= [xmin, ymin]\n xyi /= [dx, dy]\n xyi = np.floor(xyi, xyi).T\n\n #xyi contains the bins of each point as a 2d array [(xi,yi)]\n\n d = {}\n for e, k in enumerate(xyi.T):\n key = (k[0], k[1])\n\n if key in d:\n d[key].append(_w[e])\n else:\n d[key] = [_w[e]]\n\n _xyi = np.array(d.keys()).T\n _w = np.array([ reduce_w(v) for v in d.values() ])\n\n # exploit a sparse coo_matrix to build the 2D histogram...\n _grid = sparse.coo_matrix((_w, _xyi), shape=(nx, ny))\n\n if reinterp is None:\n #convert sparse to array with filled value\n ## grid.toarray() does not account for filled value\n ## sparse.coo.coo_todense() does actually add the values to the existing ones, i.e. not what we want -> brute force\n if NULL is None:\n B = _grid.toarray()\n else: # Brute force only went needed\n B = np.zeros(_grid.shape, dtype=_grid.dtype)\n B.fill(NULL)\n for (x, y, v) in zip(_grid.col, _grid.row, _grid.data):\n B[y, x] = v\n else: # reinterp\n xi = np.arange(nx, dtype=float)\n yi = np.arange(ny, dtype=float)\n B = griddata(_grid.col.astype(float), _grid.row.astype(float), _grid.data, xi, yi, interp=reinterp)\n\n return B, (xmin, xmax, ymin, ymax), (dx, dy)","def _bin(self, X):\n H = np.linspace(0, 1, self.Nbin)\n return np.maximum(1 - (abs(X[..., None] - H)) / (H[1] - H[0]) , 0)","def bin_data(x, y, yerr, npts):\n mod, nbins = len(x) % npts, len(x) / npts\n if mod != 0:\n x, y, yerr = x[:-mod], y[:-mod], yerr[:-mod]\n xb, yb, yerrb = [np.zeros(nbins) for i in range(3)]\n for i in range(npts):\n xb += x[::npts]\n yb += y[::npts]\n yerrb += yerr[::npts]**2\n x, y, yerr = x[1:], y[1:], yerr[1:]\n return xb/npts, yb/npts, yerrb**.5/npts","def test_numpy_bins(self):\n # Load the data from the fixture\n data = load_occupancy(return_dataset=True)\n X, y = data.to_numpy()\n\n visualizer = BalancedBinningReference()\n visualizer.fit(y)\n visualizer.finalize()\n self.assert_images_similar(visualizer, tol=0.5)","def bin_data(x, N_bins=100, xmin=0.0, xmax=1.0, density=False):\n\n hist_y, hist_edges = np.histogram(x, bins=N_bins, range=(xmin, xmax), density=density)\n hist_x = 0.5 * (hist_edges[1:] + hist_edges[:-1])\n hist_sy = np.sqrt(hist_y)\n hist_mask = hist_y > 0\n\n return hist_x, hist_y, hist_sy, hist_mask","def histogram2d(x,y, bins=10, range=None, normed=False, weights=None):\r\n from numpy import histogramdd\r\n\r\n try:\r\n N = len(bins)\r\n except TypeError:\r\n N = 1\r\n\r\n if N != 1 and N != 2:\r\n xedges = yedges = asarray(bins, float)\r\n bins = [xedges, yedges]\r\n hist, edges = histogramdd([x,y], bins, range, normed, weights)\r\n return hist, edges[0], edges[1]","def mi_bin(x, y, bins_x, bins_y):\n if bins_y == 0:\n bins_y = len(np.unique(y))\n # compute probabilities\n p_x = histogram(x, bins_x)\n p_y = histogram(y, bins_y)\n p_xy = histogram2d(x, y, bins_x, bins_y)\n p_x = p_x / p_x.sum()\n p_y = p_y / p_y.sum()\n p_xy = p_xy / p_xy.sum()\n # compute entropy\n h_x = entropy(p_x.astype(np.float32))\n h_y = entropy(p_y.astype(np.float32))\n h_xy = entropy(p_xy.ravel().astype(np.float32))\n # compute mutual information\n i = h_x + h_y - h_xy\n\n return i","def _bin_numbers(col1, col2, bin_n):\n col1 = col1[~col1.map(lambda x: is_null_flag(x))].reset_index(drop=True)\n col2 = col2[~col2.map(lambda x: is_null_flag(x))].reset_index(drop=True)\n comb = pd.Series(pd.np.concatenate([col1, col2])).sort_values(inplace=False).reset_index(drop=True)\n bin_size = int(len(comb) / bin_n)\n bin_dict1, bin_dict2 = {}, {}\n for i in range(bin_n - 1): # last bin only needs bin_min\n bin_low = comb[i*bin_size]\n bin_high = comb[(i+1)*bin_size]\n bin_dict1[i] = sum((col1 >= bin_low) & (col1 < bin_high))\n bin_dict2[i] = sum((col2 >= bin_low) & (col2 < bin_high))\n # print bin_low, bin_high\n # Highest bin\n bin_dict1[i+1] = sum(col1 >= bin_high)\n bin_dict2[i+1] = sum(col2 >= bin_high)\n return bin_dict1, bin_dict2","def calculate_bin_edges(n_bins, geo):\n #Gefittete offsets: x,y,factor: factor*(x+x_off)\n #[6.19, 0.064, 1.0128]\n \n #print \"Reading detector geometry in order to calculate the detector dimensions from file \" + fname_geo_limits\n #geo = np.loadtxt(fname_geo_limits)\n\n # derive maximum and minimum x,y,z coordinates of the geometry input [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]\n geo_limits = np.nanmin(geo, axis = 0), np.nanmax(geo, axis = 0)\n #print ('Detector dimensions [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]: ' + str(geo_limits))\n\n x_bin_edges = np.linspace(geo_limits[0][1] - 9.95, geo_limits[1][1] + 9.95, num=n_bins[0] + 1) #try to get the lines in the bin center 9.95*2 = average x-separation of two lines\n y_bin_edges = np.linspace(geo_limits[0][2] - 9.75, geo_limits[1][2] + 9.75, num=n_bins[1] + 1) # Delta y = 19.483\n z_bin_edges = np.linspace(geo_limits[0][3] - 4.665, geo_limits[1][3] + 4.665, num=n_bins[2] + 1) # Delta z = 9.329\n\n #offset_x, offset_y, scale = [6.19, 0.064, 1.0128]\n #x_bin_edges = (x_bin_edges + offset_x )*scale\n #y_bin_edges = (y_bin_edges + offset_y )*scale\n\n #calculate_bin_edges_test(geo, y_bin_edges, z_bin_edges) # test disabled by default. Activate it, if you change the offsets in x/y/z-bin-edges\n\n return x_bin_edges, y_bin_edges, z_bin_edges","def bin(serie, bins):\n return serie.apply(lambda x: _bin(bins, x))","def binning(x, y, xmin=None, xmax=None, dx=1 / 12.,\r\n window=3 / 12., interp=False, median=False):\r\n if xmin is None:\r\n xmin = np.nanmin(x)\r\n if xmax is None:\r\n xmax = np.nanmax(x)\r\n\r\n steps = np.arange(xmin, xmax, dx) # time steps\r\n bins = [(ti, ti + window) for ti in steps] # bin limits\r\n\r\n N = len(bins)\r\n yb = np.full(N, np.nan)\r\n xb = np.full(N, np.nan)\r\n eb = np.full(N, np.nan)\r\n nb = np.full(N, np.nan)\r\n sb = np.full(N, np.nan)\r\n\r\n for i in range(N):\r\n\r\n t1, t2 = bins[i]\r\n idx, = np.where((x >= t1) & (x <= t2))\r\n\r\n if len(idx) == 0:\r\n xb[i] = 0.5 * (t1 + t2)\r\n continue\r\n\r\n ybv = y[idx]\r\n\r\n if median:\r\n yb[i] = np.nanmedian(ybv)\r\n else:\r\n yb[i] = np.nanmean(ybv)\r\n\r\n xb[i] = 0.5 * (t1 + t2)\r\n eb[i] = mad_std(ybv)\r\n nb[i] = np.sum(~np.isnan(ybv))\r\n sb[i] = np.sum(ybv)\r\n\r\n if interp:\r\n try:\r\n yb = np.interp(x, xb, yb)\r\n eb = np.interp(x, xb, eb)\r\n sb = np.interp(x, xb, sb)\r\n xb = x\r\n except:\r\n pass\r\n\r\n return xb, yb, eb, nb, sb","def conv_gauss_custom(x, y, fwhm, dwindow=2):\n # fwhm = sigma * 2 * np.sqrt(2 * np.log(2))\n\n # Check if fwhm is a number or a list\n if isinstance(fwhm, (int, float)):\n # If fwhm is a number, make an array with fwhm in each entry\n fwhm = np.ones_like(x) * fwhm\n else:\n # Check fwhm has same dimensions as x\n if len(fwhm) != len(x):\n sys.exit('Array `fwhm` has different length than `x`: len(fwhm)={}, len(x)={}'.format(len(fwhm), len(x)))\n\n # Number of total datapoints\n nx = len(x)\n\n # -----------------------\n\n # For each datapoint define a \"bin\" or \"pixel\"\n # E.g. for the datapoint x_3:\n # - Bin center: value of the datapoint: x_3\n # - Bin left edge: half the distance between the current datapoint and the previous one: x_3 - (x_3 - x_2) * 0.5\n # - Bin right edge: half the distance between the current datapoint and the next one: x_3 + (x_4 - x_3) * 0.5\n\n # Distances between center of each bin\n bin_distance = x[1:] - x[:-1] # length = len(x) - 1\n # Define left/right edge of each bin as half the distance to the bin previous/next to it\n bin_edgesmiddle = x[:-1] + 0.5 * bin_distance # middle points\n bin_edgesfirst = x[0] - 0.5 * bin_distance[0] # first point\n bin_edgeslast = x[-1] + 0.5 * bin_distance[-1] # last point\n edges = np.concatenate(([bin_edgesfirst], bin_edgesmiddle, [bin_edgeslast]), axis=0) # length = len(x) + 1\n\n # Width of each bin\n # If the input array x is equally spaced, `bin_width` will be equal to `bin_distance`\n bin_width = edges[1:] - edges[:-1] # length = len(x)\n\n # -----------------------\n\n # Convert FWHM from wavelength units to bins -> Number of bins per FWHM\n fwhm_bin = fwhm / bin_width\n # Round number of bins per FWHM\n nbins = np.ceil(fwhm_bin) #npixels\n\n ## Convert sigma from wavelength units to bins -> Number of bins per sigma\n #sigma_bin = sigma / bin_width\n ## Round number of bins per sigma\n #nbins = np.ceil(sigma_bin) #npixels\n\n # -----------------------\n\n yconv = np.zeros_like(x)\n for i, x_i in enumerate(x):\n\n # Slow method -> THIS IS WHAT MAKES THE OTHER FUNCTION SLOW!\n # # Select kernel window\n # dwindow = 2 * fwhm #2 * fwhm\n # x1 = (np.argmin(np.abs(x - (x_i - dwindow))))\n # x2 = (np.argmin(np.abs(x - (x_i + dwindow))))\n # irang = slice(x1, x2+1)\n\n # Number of pixels at each side of x_i:\n dx = dwindow * nbins[i] * 0.5\n i1 = int(max(0, i - dx))\n i2 = int(min(nx, i + dx + 1))\n irang = slice(i1, i2 + 1)\n\n # Gaussian kernel\n kernel = 1./(np.sqrt(2*np.pi)*fwhm[i]) * np.exp(- ((x[irang] - x_i)**2) / (2 * fwhm[i]**2))\n kernel = kernel / np.sum(kernel)\n\n # Convolve\n yconv[i] = np.sum(y[irang] * kernel)\n\n return yconv","def binarize(X, *, threshold=..., copy=...):\n ...","def asBinEdges(bins, data, scale='lin'):\n data = np.asarray(data)\n ndim = data.ndim\n edges = ndim * [None]\n\n try:\n M = len(bins)\n if M != ndim:\n flag_1d = really1d(bins)\n if flag_1d:\n bins = [np.asarray(bins, float)]\n\n if not flag_1d or len(bins) != ndim:\n raise ValueError('The dimension of bins must be equal '\n 'to the dimension of the sample x.')\n except TypeError:\n bins = ndim * [bins]\n\n # If `scale` is a single value for all dimensions\n if(np.ndim(scale) == 0):\n scale = ndim * [scale]\n # otherwise `scale` must be specified for each dimension\n elif(np.size(scale) != ndim):\n raise ValueError(\"`scale` must be a single value or a value for each dimension.\")\n\n # Find range for each dimension\n smin = np.atleast_1d(np.array(data.min(axis=0), float))\n smax = np.atleast_1d(np.array(data.max(axis=0), float))\n # Make sure the bins have a finite width.\n for i in range(len(smin)):\n if smin[i] == smax[i]:\n smin[i] = smin[i] - 0.5\n smax[i] = smax[i] + 0.5\n\n # Create arrays describing edges of bins\n for ii in range(ndim):\n if np.isscalar(bins[ii]):\n edges[ii] = spacing([smin[ii], smax[ii]], scale[ii], num=bins[ii] + 1)\n else:\n edges[ii] = np.asarray(bins[ii], float)\n\n if(ndim == 1):\n edges = edges[0]\n\n return edges","def binning ( self , axis , name = '' ) :\n assert isinstance ( axis , ROOT.TAxis ),\\\n 'Invalid axis %s/%s' % ( axis , type ( axis ) )\n\n ## uniform binning?\n if not axis.IsVariableBinSize() : \n return ROOT.RooFit.Binning ( axis.GetNbins() , axis.GetXmin() , axis.GetXmax() )\n ##\n xbins = axis.GetXbins().GetArray()\n rb = ROOT.RooBinning ( axis.GetNbins() , xbins , name )\n ##\n self.aux_keep.append ( rb )\n ##\n return ROOT.RooFit.Binning ( rb )","def bin_spec_y(self, start, end):\n #print(self.spec_x.tolist())\n start_spec_x = closest_value_index(start, self.spec_x.tolist())\n i = 0\n bin_sum = 0\n while(start_spec_x + i < len(self.spec_x) and self.spec_x[start_spec_x + i] <= end):\n bin_sum += self.spec_y[start_spec_x + i]\n i += 1\n average = bin_sum / (i+1)\n return average","def histogram2d(x, y, bins=10, range=None, weights=None, flow=False, cons_var=False):\n try:\n N = len(bins)\n except TypeError:\n N = 1\n\n x = np.asarray(x)\n y = np.asarray(y)\n if weights is not None:\n weights = np.asarray(weights)\n if N != 1 and N != 2:\n bins = np.asarray(bins)\n return var2d(x, y, bins, bins, weights=weights, flow=flow, cons_var=cons_var)\n\n elif N == 1:\n return fix2d(\n x,\n y,\n bins=bins,\n range=range,\n weights=weights,\n flow=flow,\n cons_var=cons_var,\n )\n\n elif N == 2:\n if isinstance(bins[0], int) and isinstance(bins[1], int):\n return fix2d(x, y, bins=bins, range=range, weights=weights, flow=flow)\n else:\n b1 = np.asarray(bins[0])\n b2 = np.asarray(bins[1])\n return var2d(x, y, b1, b2, weights=weights, flow=flow)\n\n else:\n raise ValueError(\"bins argument is not compatible\")","def histogram2d(x, y, bins=10, range=None, weights=None, density=None):\n try:\n n = len(bins)\n except TypeError:\n n = 1\n\n if n != 1 and n != 2:\n if isinstance(bins, cupy.ndarray):\n xedges = yedges = bins\n bins = [xedges, yedges]\n else:\n raise ValueError('array-like bins not supported in CuPy')\n\n hist, edges = histogramdd([x, y], bins, range, weights, density)\n return hist, edges[0], edges[1]","def bin_data(y, num_bins, std_away):\n mean = np.mean(y)\n std = np.std(y)\n pitch_shifts = np.arange(-num_bins, num_bins + 1)\n thresholds = (std * std_away) * pitch_shifts + mean\n\n result = []\n for point in y:\n if point < thresholds[0]:\n result.append(pitch_shifts[0] - 1)\n elif point > thresholds[-1]:\n result.append(pitch_shifts[-1] + 1)\n else:\n for i in range(len(thresholds) - 1):\n if point >= thresholds[i] and point < thresholds[i + 1]:\n result.append(i - num_bins)\n return np.array(result)","def _fast_hist_2d(data, bin_edges):\n # Yes, I've tested this against histogramdd().\n xassign = np.digitize(data[:,0], bin_edges[1:-1]) \n yassign = np.digitize(data[:,1], bin_edges[1:-1])\n nbins = len(bin_edges) - 1\n flatcount = np.bincount(xassign + yassign * nbins, minlength=nbins*nbins)\n return flatcount.reshape((nbins, nbins))","def createBin(image_object, num=8):\n image_array = sitk.GetArrayFromImage(image_object)\n _, bin_edges = np.histogram(image_array.flatten(), bins=num)\n bin_edges[-1] += 1\n for i in range(num):\n image_array[(image_array >= bin_edges[i]) & (image_array < bin_edges[i+1])] = i+1\n image_object_bin = sitk.GetImageFromArray(image_array)\n return image_object_bin","def getLinBins(nbins, low, high):\n x = float(low)\n dx = float(high-low)/nbins\n\n return np.array([x+i*dx for i in range(nbins+1)], dtype=float)","def xy_bin(xo, yo, n=100, mode='log', bins=None):\n \n assert(len(xo)==len(yo))\n \n if bins is None:\n if mode == 'log':\n x = np.logspace(np.log10(xo[xo>0].min()), np.log10(xo.max()), n+1)\n elif mode == 'lin':\n x = np.linspace(xo.min(), xo.max(), n+1)\n else:\n x = np.sort(bins)\n \n y = (np.histogram(xo, x, weights=yo)[0] /\n np.histogram(xo, x)[0])\n \n return x[:-1], y","def _bresenham_pairs(x0: int, y0: int, x1: int, y1: int) -> np.ndarray:\n dx = abs(x1 - x0)\n dy = abs(y1 - y0)\n dim = max(dx, dy)\n pairs = np.zeros((dim, 2), dtype=np.int64)\n x, y = x0, y0\n sx = -1 if x0 > x1 else 1\n sy = -1 if y0 > y1 else 1\n if dx > dy:\n err = dx // 2\n for i in range(dx):\n pairs[i, 0] = x\n pairs[i, 1] = y\n err -= dy\n if err < 0:\n y += sy\n err += dx\n x += sx\n else:\n err = dy // 2\n for i in range(dy):\n pairs[i, 0] = x\n pairs[i, 1] = y\n err -= dx\n if err < 0:\n x += sx\n err += dy\n y += sy\n return pairs","def binning_axis(self) -> int:\r\n return 0","def bin_discretize(self, variables=[], bins=3,\n min_const_samples_bin_size=1.0/3):\n self.edges=np.zeros((self.arity.size,bins+1))\n for i in variables:\n un_cnt=np.unique(self.data[:,i],return_counts=True)\n constvals=un_cnt[0][un_cnt[1]>self.data.shape[0]*min_const_samples_bin_size]\n mask=np.ones(self.data.shape[0],dtype=bool)\n if constvals.size>0:\n for j,cv in enumerate(constvals):\n mask*=(self.data[:,i]!=cv)\n self.data[self.data[:,i]==cv,i]=j\n\n size=np.sum(mask)/bins\n sorted_i=np.argsort(self.data[mask,i])\n edges=[self.data[mask,i][sorted_i[int(size*num)-1]] for num in range(1,bins)]\n self.edges[i]=[self.data[mask,i][sorted_i[0]]]+edges+[self.data[mask,i][sorted_i[-1]]]\n self.data[mask,i]=np.searchsorted(edges,self.data[mask,i])+constvals.size\n self.arity[i]=len(edges)+1+constvals.size","def rebin_2d(x_in, data, x_new, statistic='mean'):\n edges = binvec(x_new)\n datai = np.zeros((len(x_new), data.shape[1]))\n data = ma.masked_invalid(data) # data may contain nan-values\n for ind, values in enumerate(data.T):\n mask = ~values.mask\n if ma.any(values[mask]):\n datai[:, ind], _, _ = stats.binned_statistic(x_in[mask],\n values[mask],\n statistic=statistic,\n bins=edges)\n datai[~np.isfinite(datai)] = 0\n return ma.masked_equal(datai, 0)","def binnedAverage(x, y, bins=20):\n xbins, step = np.linspace(np.min(x), np.max(x), num=bins, retstep=True)\n xbins = (xbins + step/2)[:-1]\n emptyBins = []\n ymeans = []\n for xbi, xb in enumerate(xbins):\n ytotal = 0\n ycount = 0\n for y_i, y_ in enumerate(y):\n if xb - step/2 < x[y_i] < xb + step/2:\n ytotal += y_\n ycount += 1\n if ycount >= 1:\n ymeans.append(ytotal/ycount)\n else:\n emptyBins.append(xbi)\n xbins = np.delete(xbins, emptyBins)\n return xbins, np.array(ymeans)","def mapBinEdgesAndDataToXYZStandard(binEdgesArray, binDataArray):\n\t#TODO: Check that this is actually a 2-d array (need +1 since number of edges is +1 more than number of bins)\n\tdimX, dimY = len(binEdgesArray)+1, len(binEdgesArray[0])+1\n\n\t#We get a ValueError later anyway (at time of writing) but better to raise it here\n\tif len(binEdgesArray.shape)-2 != 2:\n\t\tnDims = len(binEdgesArray.shape)-2\n\t\traise ValueError(\"Input array seems to be {} dimensions; we need 2 dimensions\".format(nDims))\n\n\toutX = np.zeros( (dimX,dimY) )\n\toutY = np.zeros( (dimX,dimY) )\n\toutZ = copy.deepcopy(binDataArray)\n\n\tfor idxX in range(dimX):\n\t\tfor idxY in range(dimY):\n\t\t\t#Edge case where we take the upper edge of the previous bin (instead of lower edge of current)\n\t\t\tif (idxX==dimX-1) and (idxY==dimY-1):\n\t\t\t\toutX[idxX][idxY] = binEdgesArray[idxX-1][idxY-1][0][1] #Is this correct????\n\t\t\t\toutY[idxX][idxY] = binEdgesArray[idxX-1][idxY-1][1][1] \n\t\t\telif idxX==dimX-1:\n\t\t\t\toutX[idxX][idxY] = binEdgesArray[idxX-1][idxY][0][1]\n\t\t\t\toutY[idxX][idxY] = binEdgesArray[idxX-1][idxY][1][0]\n\t\t\telif idxY==dimY-1:\n\t\t\t\toutX[idxX][idxY] = binEdgesArray[idxX][idxY-1][0][0]\n\t\t\t\toutY[idxX][idxY] = binEdgesArray[idxX][idxY-1][1][1]\t\t\t\n\t\t\telse:\n\t\t\t\toutX[idxX][idxY] = binEdgesArray[idxX][idxY][0][0]\n\t\t\t\toutY[idxX][idxY] = binEdgesArray[idxX][idxY][1][0]\n\n\treturn outX, outY, outZ","def grid_to_bins(grid, start_bin_val, end_bin_val):\n bin_centers = (grid[1:] + grid[:-1])/2.0\n bins = np.concatenate([[start_bin_val], bin_centers, [end_bin_val]])\n return bins","def __call__(self, n_bins, segment, elements):\n\n # n_bins\n assert type(n_bins) is int\n assert n_bins > 0\n\n # segment\n assert type(segment) is list or type(segment) is tuple\n assert len(segment) == 2\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\n assert segment[0] < segment[1]\n\n # elements\n assert type(elements) is np.ndarray, f\"elements should be an np.ndarray, instead of {type(elements)}\"\n assert elements.dtype == np.number\n\n sorted_elements = np.sort(elements)\n\n bin_card = int(floor(elements.shape[0]/n_bins))\n\n bin_boundaries = [segment[0]]\n\n for i in range(1, n_bins):\n boundary_l = sorted_elements[i*bin_card - 1]\n boundary_r = sorted_elements[i * bin_card]\n boundary = (boundary_l+boundary_r)/2\n\n bin_boundaries.append(boundary)\n\n bin_boundaries.append(segment[1])\n\n return np.array(bin_boundaries)","def get_shape_bin_edges(shapes_path, datacard_bin):\n shapes_file = ROOT.TFile.Open(shapes_path)\n print 'tfile path is', shapes_path\n print 'list of keys'\n #ROOT.gDirectory.GetListOfKeys().ls()\n print 'gonnad cd', datacard_bin\n print shapes_file.cd(datacard_bin)\n shapes = ROOT.gDirectory.GetListOfKeys()\n #print 'list of Keys is', ROOT.gDirectory.GetListOfKeys().ls()\n # Since the nominal and varied shapes share the same binning,\n # take any of the histograms found in the shapes file.\n print 'debug0'\n shape = ROOT.gDirectory.Get(shapes[0].GetName())\n print 'debug'\n bin_edges = np.array(\n [shape.GetXaxis().GetBinLowEdge(i) for i in xrange(1, shape.GetNbinsX() + 1)],\n dtype=np.float64,\n )\n shapes_file.Close()\n print 'bin_edges for datacard_bin is', bin_edges\n #sys.exit()\n return bin_edges","def test_binops(self):","def mi_bin_conn_time(x, y, bins_x, bins_y):\n n_times, n_trials = x.shape\n mi = np.zeros((n_times), dtype=np.float32)\n for t in range(n_times):\n mi[t] = mi_bin(x[t, :], y[t, :], bins_x, bins_y)\n return mi","def bincalc(nbin=0.1,bmin=5,bmax=2000):\n\n logbmin=np.log10(bmin)\n logbmax=np.log10(bmax)\n\n logbins=np.arange(logbmin,logbmax,nbin)\n\n bins=10**logbins\n\n #bins=np.linspace(bmin,bmax,60)\n return (bins)","def getBinIndex(self, x):\n\t\tb = -1\n\t\tif x == self._max_val: # final bin is [low, high], where others are [low,high)\n\t\t\tb = len(self._bins)-1\n\t\telse:\n\t\t\tb = math.floor((x-self._min_val)/self._bin_width)\n\t\treturn int(b)","def binning(data, low, high):\n if len(data) == 0: return 1\n\n mask1 = (data >= low)\n mask2 = (data < high)\n mask3 = numpy.logical_and(mask1, mask2)\n data = data[mask3]\n\n if len(data) == 0: return 10\n\n data.sort()\n q1 = data[int(math.floor(0.25*len(data)))]\n q3 = data[int(math.floor(0.75*len(data)))]\n binwidth = 2. * (q3 - q1) / len(data)**(1./3.)\n if binwidth > 0.:\n return max(10, int(math.ceil((high - low)/binwidth)))\n else:\n return 10","def _calcBins(self, contribs, parValues, fraction, minReq):\n # single set of R for this calculation\n bins = np.zeros(self.binCount)\n binObs = np.zeros(self.binCount)\n for bi in range(self.binCount):\n val, obs = self._calcBin(\n self._binMask(bi, parValues),\n fraction, minReq)\n bins[bi] = val\n binObs[bi] = obs\n cdf = self._calcCDF(bins)\n return bins, binObs, cdf","def bins_match (a, b):\n return 0 == (\n np.sum ((a.xbins - b.xbins)**2)\n + np.sum ((a.ybins - b.ybins)**2) )","def mean_relationship_twoD(x, y, bins_values):\r\n sort_ind_x = np.argsort(x)\r\n x = x[sort_ind_x]\r\n y = y[:, sort_ind_x]\r\n hist, bin_edges = np.histogram(x, bins=bins_values)\r\n array_end = np.cumsum(hist)\r\n array_start = np.cumsum(hist) - hist\r\n y_x = np.zeros((len(y), len(array_start)))\r\n for i in np.arange(len(array_start)):\r\n y_x[:, i] = np.mean(y[:, array_start[i]:array_end[i]], axis=1)\r\n return y_x","def calculateMetallicityBinEdges(self):\n\n if self.binInLogSpace:\n logMetallicities = np.log10(self.metallicityGrid)\n b= logMetallicities[:-1] + (logMetallicities[1:] - logMetallicities[:-1])/2.\n b = 10.**b #the boundaries for integration are not in log space so\n #convert to \"normal\" numbers.\n else:\n b= (self.metallicityGrid[1:] - self.metallicityGrid[:-1])/2. \\\n + self.metallicityGrid[:-1] \n\n self.metallicityBinEdges = np.zeros(len(b)+2)\n\n #the lowest/highest metallicity bin edge are set in options\n #the calculated b edges are all in between\n\n self.metallicityBinEdges[0] = self.metallicityLowerLimit\n self.metallicityBinEdges[-1] = self.metallicityUpperLimit\n self.metallicityBinEdges[1:-1] = b","def binn_fft(self):\n bin_res = []\n for fft_bin in BINS:\n bin_res.append(self.bin_spec_y(fft_bin[0], fft_bin[1]))\n return bin_res","def bin_matrix(x, binning):\n\n N = len(x)\n B = []\n for i in range(len(binning) - 1):\n\n line = np.zeros(N)\n for j in range(N):\n\n if x[j] >= binning[i] and x[j] < binning[i+1]:\n\n size = binning[i + 1] - binning[i]\n line[j] = 1 / size\n\n B.append(line)\n\n B = np.array(B)\n\n return(B)","def binarize(self, image):\n\n [rows, columns] = np.shape(image)\n bin_img = np.zeros((rows, columns), dtype=int)\n print(\"############## Using to binarize an image ##############\")\n hist = self.compute_histogram(image)\n threshold = self.find_optimal_threshold(hist)\n for i in range(rows):\n for j in range(columns):\n if image[i, j] < threshold:\n bin_img[i, j] = 0\n else:\n bin_img[i, j] = 255\n # print(\"binary image: \\n\", bin_img)\n\n return bin_img","def to_bin(value, edges):\n\n previous = 0\n for v in edges:\n if previous <= value <= v:\n return (previous, v)\n previous = v\n return (previous, None)","def compute_histogram(samples, nbins=50, piecewise_constant=True):\n import sys\n if 'numpy' in sys.modules:\n y0, bin_edges = histogram(samples, bins=nbins, normed=True)\n h = bin_edges[1] - bin_edges[0] # bin width\n if piecewise_constant:\n x = zeros(2*len(bin_edges), type(bin_edges[0]))\n y = x.copy()\n x[0] = bin_edges[0]\n y[0] = 0\n for i in range(len(bin_edges)-1):\n x[2*i+1] = bin_edges[i]\n x[2*i+2] = bin_edges[i+1]\n y[2*i+1] = y0[i]\n y[2*i+2] = y0[i]\n x[-1] = bin_edges[-1]\n y[-1] = 0\n else:\n x = zeros(len(bin_edges)-1, type(bin_edges[0]))\n y = y0.copy()\n for i in range(len(x)):\n x[i] = (bin_edges[i] + bin_edges[i+1])/2.0\n return x, y","def bin_input(neu, bin_size, overlap = 0):\n win_d = bin_size - overlap\n n_bins = int(((neu.shape[0]-bin_size)/win_d)+1)\n FRmat = np.empty([n_bins, neu.shape[1]])\n for i in range(n_bins):\n FRmat[i,:] = np.sum(neu[i*win_d:i*win_d+bin_size,:], axis = 0)\n \n return FRmat","def getLogBins(nbins, low, high):\n\n x = float(low)\n dx = pow(high/low, 1.0/nbins);\n \n return np.array([x*pow(dx,i) for i in range(nbins+1)], dtype=float)","def binary_binned_metric(model=None, X=None, positive_scores=None, Y=None, bins_weights=None):\n\n return specific_class_binned_metric(model=model, X=X, specific_scores=positive_scores,\n Y=Y, bins_weights=bins_weights, class_index=1)","def compute_bin_indices(X_part, bin_limits=None, n_bins=20):\n if bin_limits is None:\n bin_limits = []\n for variable_data in range(X_part.shape[1]):\n bin_limits.append(numpy.linspace(numpy.min(variable_data), numpy.max(variable_data), n_bins + 1)[1: -1])\n\n bin_indices = numpy.zeros(len(X_part), dtype=numpy.int)\n for axis, bin_limits_axis in enumerate(bin_limits):\n bin_indices *= (len(bin_limits_axis) + 1)\n bin_indices += numpy.searchsorted(bin_limits_axis, X_part[:, axis])\n\n return bin_indices","def setup_bins(self):\n width = int((self.max - self.min) / self.bin_size)\n bins = {\n i * width + self.min: (idx, idx + self.bin_size)\n for i, idx in enumerate(range(0, len(self.nums), self.bin_size))\n }\n return bins","def tcbin(x, y=8):\n if x >= (2**(y - 1)) or x < -(2**(y - 1) or y < 1):\n raise Exception(\"Argument outside of range.\")\n if x >= 0:\n binstr = bin(x)\n # pad with leading zeros\n while len(binstr) < y + 2:\n binstr = \"0b0\" + binstr[2:]\n return binstr\n return bin((2**y) + x) # x is negative","def __init__(self, edges, yedges=None):\n if yedges is None:\n if len(edges) == 2:\n BinnedSet.__init__(self, edges)\n else:\n raise ValueError(\"'edges' does not contain exactly two bin \"\n \"edge arrays\")\n else:\n BinnedSet.__init__(self, (edges, yedges))","def matrix2bin(X, y, filename):\n if len(X.shape) == 3:\n Xy = []\n for dimX, dimy in zip(X, y):\n ym = np.array([dimy])\n Xy.append(np.append(dimX, ym.T, axis=1))\n Xy = np.array(Xy)\n else:\n ym = np.array([y])\n Xy = np.append(X, ym.T, axis=1)\n np.save(filename, Xy)","def bin_search(arr, x):\n \n low = 0\n hi = len(arr) - 1\n \n while(low <= hi): \n \n mid = int((low + hi) / 2) # find middle idx\n\n if( x >= arr[mid]): # if x on the right, change low idx and search right side\n low = mid + 1; \n else: # else search left side\n hi = mid - 1\n\n return hi","def label_values_to_bins(array_to_bin:object, bin_count:int):\n\t\t# Make 1D for qcut.\n\t\tarray_to_bin = array_to_bin.flatten()\n\t\t# For really unbalanced labels, I ran into errors where bin boundaries would be duplicates all the way down to 2 bins.\n\t\t# Setting `duplicates='drop'` to address this.\n\t\tbin_numbers = pd.qcut(x=array_to_bin, q=bin_count, labels=False, duplicates='drop')\n\t\t# Convert 1D array back to 2D for the rest of the program.\n\t\tbin_numbers = np.reshape(bin_numbers, (-1, 1))\n\t\treturn bin_numbers","def inner(x, y):\n\n return np.inner(x.ravel(), y.ravel())","def bin_absorbers(dat, bin_attr='z', binsize=None, bin_start=None,\n bin_end=None, bins=None):\n output = []\n if not bins: # if no custom bins specified, then take equallly spaced bins\n bins = np.arange(bin_start, bin_end, binsize)\n bins = list(zip(bins, bins + binsize))\n\n for b in bins:\n output.append(\n [item for item in dat if b[0] <= getattr(item, bin_attr) < b[1]]\n )\n return output","def binary_add(x, y):\n # Makes sure that the arrays have the same length.\n # Could be changed to padding on extra zeroes, if so desired.\n assert(len(x) == len(y))\n\n z = [0] * (len(x)+1)\n for a, (i, j) in enumerate(zip(x[::-1], y[::-1])):\n # Makes sure that the array is a binary array.\n # Strictly speaking, not necessary. But nice.\n if i not in [0, 1]: return False\n if j not in [0, 1]: return False\n\n # if i and j are both 1 \n if i and j:\n z[a] += 0\n z[a+1] += 1\n # if only one of them is 1\n elif i or j:\n z[a] += 1\n # if they're both 0\n else: pass\n\n if z[a] == 2:\n z[a+1] += 1\n z[a] -= 2\n \n return z[::-1]","def rebin(array, dimensions=None, scale=None):\n if dimensions is not None:\n if isinstance(dimensions, float):\n dimensions = [int(dimensions)] * len(array.shape)\n elif isinstance(dimensions, int):\n dimensions = [dimensions] * len(array.shape)\n elif len(dimensions) != len(array.shape):\n raise RuntimeError('')\n elif scale is not None:\n if isinstance(scale, float) or isinstance(scale, int):\n dimensions = map(int, map(round, map(lambda x: x * scale, array.shape)))\n elif len(scale) != len(array.shape):\n raise RuntimeError('')\n else:\n raise RuntimeError('Incorrect parameters to rebin.\\n\\trebin(array, dimensions=(x,y))\\n\\trebin(array, scale=a')\n import itertools\n # dY, dX = map(divmod, map(float, array.shape), dimensions)\n if np.shape(array) == dimensions: return array # no rebinning actually needed\n result = np.zeros(dimensions)\n for j, i in itertools.product(*map(xrange, array.shape)):\n (J, dj), (I, di) = divmod(j * dimensions[0], array.shape[0]), divmod(i * dimensions[1], array.shape[1])\n (J1, dj1), (I1, di1) = divmod(j + 1, array.shape[0] / float(dimensions[0])), divmod(i + 1,\n array.shape[1] / float(\n dimensions[1]))\n\n # Moving to new bin\n # Is this a discrete bin?\n dx, dy = 0, 0\n if (I1 - I == 0) | ((I1 - I == 1) & (di1 == 0)):\n dx = 1\n else:\n dx = 1 - di1\n if (J1 - J == 0) | ((J1 - J == 1) & (dj1 == 0)):\n dy = 1\n else:\n dy = 1 - dj1\n # Prevent it from allocating outide the array\n I_ = min(dimensions[1] - 1, I + 1)\n J_ = min(dimensions[0] - 1, J + 1)\n result[J, I] += array[j, i] * dx * dy\n result[J_, I] += array[j, i] * (1 - dy) * dx\n result[J, I_] += array[j, i] * dy * (1 - dx)\n result[J_, I_] += array[j, i] * (1 - dx) * (1 - dy)\n allowError = 0.1\n assert (array.sum() < result.sum() * (1 + allowError)) & (array.sum() > result.sum() * (1 - allowError))\n return result","def create_bins(start, end, n_bins):\n bins = np.linspace(start, end, n_bins)\n return bins","def bin_data(data, lat, lon, binsize=1, uv_data=False, pressure=None):\n\n # Create lats and lons based on binsize\n lonlen = 360\n latlen = 180\n\n lon_lowerlim = 0\n lon_upperlim = 360\n\n lat_lowerlim = -90\n lat_upperlim = 90\n\n if latlen % binsize == 0 and lonlen % binsize == 0:\n latbin = int(latlen/binsize)\n lonbin = int(lonlen/binsize)\n n_deg = binsize/2\n\n ll_lats = np.linspace(lat_lowerlim+(n_deg),\n lat_upperlim-(n_deg),\n latbin)\n\n ll_lons = np.linspace(lon_lowerlim+(n_deg),\n lon_upperlim-(n_deg),\n lonbin)\n\n else:\n print('ERROR: Binsize does not work for grid shape (180,360). Please use different binsize.')\n return\n\n paramlist = list(itertools.product(ll_lats, ll_lons))\n\n # Bin Data\n if uv_data == True:\n binned_u_data = np.full((latbin, lonbin), np.nan, dtype=object)\n binned_v_data = np.full((latbin, lonbin), np.nan, dtype=object)\n\n if pressure is not None:\n binned_pressure = np.full((latbin, lonbin), np.nan, dtype=object)\n\n for val in paramlist:\n # Get index of 1x1 grid lat and lon\n latidx = np.where(ll_lats == val[0])\n lonidx = np.where(ll_lons == val[1])\n # values of the 1x1 grid lat and lon\n binnedlons = val[1]\n binnedlats = val[0]\n\n # find instances where data is within 1x1 grid point of orginal data\n data_idx = np.where((lon >= binnedlons - n_deg) & (lon <= binnedlons + n_deg) &\n (lat >= binnedlats - n_deg) & (lat <= binnedlats + n_deg))\n\n latlon_idx = [latidx[0][0], lonidx[0][0]]\n\n # calculate stats if there is data at this grid point, else append np.nan\n if len(data_idx[0]) > 0:\n u = data['u'][data_idx]\n v = data['v'][data_idx]\n\n binned_u_data[latlon_idx[0], latlon_idx[1]] = u\n binned_v_data[latlon_idx[0], latlon_idx[1]] = v\n\n if pressure is not None:\n p = pressure[data_idx]\n binned_pressure[latlon_idx[0], latlon_idx[1]] = p\n\n if pressure is not None:\n return binned_u_data, binned_v_data, binned_pressure\n\n else:\n return binned_u_data, binned_v_data\n\n else:\n binned_data = np.full((latbin, lonbin), np.nan, dtype=object)\n if pressure is not None:\n binned_pressure = np.full((latbin, lonbin), np.nan, dtype=object)\n\n for val in paramlist:\n # Get index of grid lat and lon\n latidx = np.where(ll_lats == val[0])\n lonidx = np.where(ll_lons == val[1])\n # values of the 1x1 grid lat and lon\n binnedlons = val[1]\n binnedlats = val[0]\n\n # find instances where data is within 1x1 grid point of orginal data\n data_idx = np.where((lon >= binnedlons - n_deg) & (lon <= binnedlons + n_deg) &\n (lat >= binnedlats - n_deg) & (lat <= binnedlats + n_deg))\n\n latlon_idx = [latidx[0][0], lonidx[0][0]]\n\n # calculate stats if there is data at this grid point\n if len(data_idx[0]) > 0:\n d = data[data_idx]\n binned_data[latlon_idx[0], latlon_idx[1]] = d\n\n if pressure is not None:\n p = pressure[data_idx]\n binned_pressure[latlon_idx[0], latlon_idx[1]] = p\n\n if pressure is not None:\n return binned_data, binned_pressure\n\n else:\n return binned_data","def test_pandas_bins(self):\n # Load the data from the fixture\n data = load_occupancy(return_dataset=True)\n X, y = data.to_pandas()\n\n visualizer = BalancedBinningReference()\n visualizer.fit(y)\n visualizer.finalize()\n self.assert_images_similar(visualizer, tol=0.5)","def bin_center_to_edges(centers):\n edges = bin_edges_to_center(centers)\n edges = np.append(centers[0]-(edges[0]-centers[0]), edges)\n edges = np.append(edges, centers[-1]+(centers[-1]-edges[-1]))\n return edges","def bin_the_data(neuron_spikes, first, last, bin_size):\n neuron_activity = []\n timebins = range(first, int(last) + int(last) % bin_size, bin_size)\n for spike in neuron_spikes:\n activity = []\n spike_time = spike[0]\n i = 0\n for bin_size in timebins:\n k = 0\n while spike_time < bin_size:\n i += 1\n if i >= np.size(spike):\n break\n spike_time = spike[i]\n k += 1\n activity.append(k)\n neuron_activity.append(activity)\n return neuron_activity, timebins","def createBins():\n theBins = []\n startFreq = 60\n for a in range(32):\n endFreq = int(startFreq*1.12+12)\n theRange = (startFreq, endFreq)\n startFreq = endFreq\n theBins.append(theRange)\n return(theBins)","def get_bin_means(X,Y,bin_edges=None,mean='median',error='sem',minimum_n=25):\n \n assert(X.shape == Y.shape)\n \n # Flatten if not vectors\n if X.ndim > 1:\n X = X.flatten()\n Y = Y.flatten()\n \n if (bin_edges == None).all():\n X_min = np.nanmin(X)\n X_max = np.nanmax(X)\n bin_edges = np.linspace(X_min,X_max,num=10)\n \n \n which_bin = np.digitize(X,bin_edges)\n Nbins = len(bin_edges)-1\n means = np.zeros(Nbins)\n stds = np.zeros(Nbins)\n bin_centers = np.zeros(Nbins)\n for b in range(Nbins):\n y = Y[which_bin == b+1]\n bin_centers[b] = (bin_edges[b] + bin_edges[b+1]) / 2\n # Suppress noisy bins\n if len(y) < minimum_n:\n means[b] = np.nan\n stds[b] = np.nan\n else:\n # Mean or median\n if mean == 'mean':\n means[b] = np.nanmean(y)\n elif mean == 'median':\n means[b] = np.nanmedian(y)\n \n if error == 'sem':\n stds[b] = np.nanstd(y) / np.sqrt(len(y))\n elif error == 'std':\n stds[b] = np.nanstd(y)\n \n return means","def test_Bin(self):\n\n outcome_three = Outcome(\"00-0-1-2-3\", 6 )\n outcome_four = Outcome(\"D\", 2)\n outcome_five = Outcome(\"E\", 3)\n outcome_six = Outcome(\"F\", 4)\n\n bin_one = Bin(outcome_three, outcome_four)\n print 'what is bin one?: ', bin_one\n bin_two = Bin(outcome_five, outcome_six)\n print 'what is bin two?: ', bin_two","def _binoms(kernel_size):\n if kernel_size > 1:\n curr_kernel = BASE_KERNEL\n for i in range(2, kernel_size):\n curr_kernel = np.convolve(curr_kernel, BASE_KERNEL)\n return curr_kernel\n return np.array([1])","def to_bins(arr):\n result = np.zeros(len(arr)+1)\n result[1:-1] = 0.5 * (arr[1:] + arr[:-1])\n result[0] = arr[0] - 0.5*(arr[1] - arr[0])\n result[-1] = arr[-1] + 0.5*(arr[-1] - arr[-2])\n return result","def filter_binaries_beamprofile(bin_arr, beamprofile, cutoff=0.75, dilate=0):\r\n bp_bool = beamprofile < cutoff * beamprofile.max()\r\n out_binary = np.empty_like(bin_arr, dtype=int)\r\n total_cells = 0\r\n removed_cells = 0\r\n\r\n for i, img in enumerate(bin_arr):\r\n labeled, n = mh.labeled.label(img)\r\n total_cells += n\r\n for l in np.unique(labeled)[1:]:\r\n selected_binary = multi_dilate(labeled == l, dilate)\r\n if np.any(np.logical_and(selected_binary, bp_bool)): # Cell lies outside of\r\n labeled[labeled == l] = 0\r\n removed_cells += 1\r\n out_binary[i] = labeled\r\n print('Removed {} cells out of a total of {} cells.'.format(removed_cells, total_cells))\r\n return out_binary","def bin_statistics(data,bin_against,bin_edges,data_signal=[]):\n\n assert isinstance(data, pd.DataFrame), 'data must be of type pd.DataFram' \n try: bin_against = np.asarray(bin_against) \n except: 'bin_against must be of type np.ndarray'\n try: bin_edges = np.asarray(bin_edges)\n except: 'bin_edges must be of type np.ndarray' \n\n # Determine variables to analyze\n if len(data_signal)==0: # if not specified, bin all variables\n data_signal=data.columns.values\n else:\n assert isinstance(data_signal, list), 'must be of type list'\n\n # Pre-allocate list variables\n bin_stat_list = []\n bin_std_list = []\n\n # loop through data_signal and get binned means\n for signal_name in data_signal:\n # Bin data\n bin_stat = binned_statistic(bin_against,data[signal_name],\n statistic='mean',bins=bin_edges)\n # Calculate std of bins\n std = []\n stdev = pd.DataFrame(data[signal_name])\n stdev.set_index(bin_stat.binnumber,inplace=True)\n for i in range(1,len(bin_stat.bin_edges)):\n try:\n temp = stdev.loc[i].std(ddof=0)\n std.append(temp[0])\n except:\n std.append(np.nan)\n bin_stat_list.append(bin_stat.statistic)\n bin_std_list.append(std)\n \n # Convert to DataFrames\n bin_mean = pd.DataFrame(np.transpose(bin_stat_list),columns=data_signal)\n bin_std = pd.DataFrame(np.transpose(bin_std_list),columns=data_signal)\n\n # Check for nans \n if bin_mean.isna().any().any():\n print('Warning: some bins may be empty!')\n\n return bin_mean, bin_std","def bin_data(bins, data2bin, bindata, mode='mean', nbinned=False):\n assert mode in ['mean', 'median', 'std', 'max', 'min'], \"mode not recognized: {}\".format(mode)\n digitized = np.digitize(bindata, bins)\n binned = np.zeros(len(bins)) * np.nan\n if nbinned: \n numbinned = np.zeros(len(bins))\n\n if mode == 'mean':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmean(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'median':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmedian(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'std':\n for i, _ in enumerate(bins):\n binned[i] = np.nanstd(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'max':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmax(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n elif mode == 'min':\n for i, _ in enumerate(bins):\n binned[i] = np.nanmin(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\n if nbinned:\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\n else:\n raise ValueError('mode must be mean, median, std, max, or min')\n \n if nbinned:\n return np.array(binned), np.array(numbinned)\n else:\n return np.array(binned)","def get_bin_index(self, filter_bin):\n\n left_index = self.left_filter.get_bin_index(filter_bin[0])\n right_index = self.right_filter.get_bin_index(filter_bin[0])\n filter_index = left_index * self.right_filter.num_bins + right_index\n return filter_index","def get_bin_index(self, filter_bin):\n\n left_index = self.left_filter.get_bin_index(filter_bin[0])\n right_index = self.right_filter.get_bin_index(filter_bin[0])\n filter_index = left_index * self.right_filter.num_bins + right_index\n return filter_index","def compute_bb(self):\n all_shapes = list(self.parts.values()) + list(self.edges.values())\n bbox_vertices = cascaded_union(all_shapes).envelope.exterior.coords.xy\n min_x = min(bbox_vertices[0])\n max_x = max(bbox_vertices[0])\n min_y = min(bbox_vertices[1])\n max_y = max(bbox_vertices[1])\n return [min_x, max_x,min_y, max_y]","def createBinsByEntropy(self, data, structure, colName, numOfBins):\n splits = self.miningCalculator.getBestSplitsInDataByInfoGain(data, structure, colName, numOfBins-1)\n splits.sort()\n bins = {\"value<=\"+str(splits[0]): lambda x: x <= splits[0]}\n if len(splits) > 1:\n for i in range(1, numOfBins-1):\n bins[str(splits[i-1]) + '<value<=' + str(splits[i])] = (lambda x: splits[i-1] < x <= splits[i])\n bins[\"value>\" + str(splits[len(splits)-1])] = (lambda x: x > splits[len(splits)-1])\n return bins","def filter_binaries(bin_arr, remove_bordering=True, min_size=None, max_size=None, min_minor=None, max_minor=None,\r\n min_major=None, max_major=None):\r\n\r\n out = np.empty_like(bin_arr)\r\n for i, img in enumerate(bin_arr):\r\n if len(np.unique(img)) > 2: # Image is already labeled\r\n labeled = img\r\n else:\r\n labeled, n = mh.labeled.label(img)\r\n labeled, n = mh.labeled.filter_labeled(labeled, remove_bordering=remove_bordering, min_size=min_size, max_size=max_size)\r\n out[i] = (labeled > 0).astype(int) * labeled # Restore labels\r\n\r\n for j, img in enumerate(out):\r\n for i in np.unique(img)[1:]:\r\n selected_binary = (img == i).astype('int')\r\n min1, max1, min2, max2 = mh.bbox(selected_binary)\r\n selection = selected_binary[min1:max1, min2:max2]\r\n major, minor = mh.features.ellipse_axes(selection)\r\n\r\n if min_minor and minor < min_minor:\r\n img[img == i] = 0\r\n if max_minor and minor > max_minor:\r\n img[img == i] = 0\r\n if min_major and major < min_major:\r\n img[img == i] = 0\r\n if max_major and major > max_major:\r\n img[img == i] = 0\r\n\r\n return out","def test_bins(self):\n\n for filename in ['%s/population_padang_1.asc' % TESTDATA,\n '%s/test_grid.asc' % TESTDATA]:\n\n R = read_layer(filename)\n rmin, rmax = R.get_extrema()\n\n for N in [2, 3, 5, 7, 10, 16]:\n linear_intervals = R.get_bins(N=N, quantiles=False)\n\n assert linear_intervals[0] == rmin\n assert linear_intervals[-1] == rmax\n\n d = (rmax - rmin) / N\n for i in range(N):\n assert numpy.allclose(linear_intervals[i], rmin + i * d)\n\n quantiles = R.get_bins(N=N, quantiles=True)\n A = R.get_data(nan=True).flat[:]\n\n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\n l1 = len(A)\n A = A.compress(mask)\n l2 = len(A)\n\n if filename == '%s/test_grid.asc' % TESTDATA:\n # Check that NaN's were removed\n assert l1 == 35\n assert l2 == 30\n\n # Assert that there are no NaN's\n assert not numpy.alltrue(numpy.isnan(A))\n\n number_of_elements = len(A)\n average_elements_per_bin = number_of_elements / N\n\n # Count elements in each bin and check\n i0 = quantiles[0]\n for i1 in quantiles[1:]:\n count = numpy.sum((i0 < A) & (A < i1))\n if i0 == quantiles[0]:\n refcount = count\n\n if i1 < quantiles[-1]:\n # Number of elements in each bin must vary by no\n # more than 1\n assert abs(count - refcount) <= 1\n assert abs(count - average_elements_per_bin) <= 3\n else:\n # The last bin is allowed vary by more\n pass\n\n i0 = i1","def compute_bin_efficiencies(y_score, bin_indices, cut, sample_weight, minlength=None):\n y_score = column_or_1d(y_score)\n assert len(y_score) == len(sample_weight) == len(bin_indices), \"different size\"\n if minlength is None:\n minlength = numpy.max(bin_indices) + 1\n\n bin_total = numpy.bincount(bin_indices, weights=sample_weight, minlength=minlength)\n passed_cut = y_score > cut\n bin_passed_cut = numpy.bincount(bin_indices[passed_cut],\n weights=sample_weight[passed_cut], minlength=minlength)\n return bin_passed_cut / numpy.maximum(bin_total, 1)"],"string":"[\n \"def get2DBins(x, y, binSizeX, binSizeY):\\n\\n result = []\\n xlength = len(x)\\n ylength = len(y)\\n\\n i = 0\\n xcount = 0\\n for i1 in range(0, xlength, binSizeX):\\n i2 = i1 + binSizeX\\n if i2 >= xlength:\\n i2 = xlength - 1\\n xcount += 1\\n ycount = 0\\n for j1 in range(0, ylength, binSizeY):\\n j2 = j1 + binSizeY\\n if j2 >= ylength:\\n j2 = ylength - 1\\n result.append((i1, i2, j1, j2))\\n ycount += 1\\n return result, xcount, ycount\",\n \"def bin_binarise(self):\\n pass\",\n \"def histogram2d(x, y, bins_x, bins_y):\\n # x-range\\n x_max, x_min = x.max(), x.min()\\n delta_x = 1 / ((x_max - x_min) / bins_x)\\n # y-range\\n y_max, y_min = y.max(), y.min()\\n delta_y = 1 / ((y_max - y_min) / bins_y)\\n # compute histogram 2d\\n xy_bin = np.zeros((np.int64(bins_x), np.int64(bins_y)), dtype=np.int64)\\n for t in range(len(x)):\\n i = (x[t] - x_min) * delta_x\\n j = (y[t] - y_min) * delta_y\\n if 0 <= i < bins_x and 0 <= j < bins_y:\\n xy_bin[int(i), int(j)] += 1\\n return xy_bin\",\n \"def d2_bin(self, x, y):\\n \\n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\\n KD.fit(np.column_stack((x,y)))\\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\\n mesh = np.meshgrid(grid1,grid2)\\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\\n samp = KD.score_samples(data)\\n samp = samp.reshape(self.bins,self.bins)\\n p = np.exp(samp)/np.sum(np.exp(samp))\\n\\n return p\",\n \"def binvec(x):\\n edge1 = x[0] - (x[1]-x[0])/2\\n edge2 = x[-1] + (x[-1]-x[-2])/2\\n return np.linspace(edge1, edge2, len(x)+1)\",\n \"def _get_bin_edges(a, bins, range):\\n # parse the overloaded bins argument\\n n_equal_bins = None\\n bin_edges = None\\n\\n if isinstance(bins, str):\\n raise NotImplementedError(\\n 'only integer and array bins are implemented')\\n elif isinstance(bins, cupy.ndarray) or numpy.ndim(bins) == 1:\\n # TODO(okuta): After #3060 is merged, `if cupy.ndim(bins) == 1:`.\\n if isinstance(bins, cupy.ndarray):\\n bin_edges = bins\\n else:\\n bin_edges = numpy.asarray(bins)\\n\\n if (bin_edges[:-1] > bin_edges[1:]).any(): # synchronize! when CuPy\\n raise ValueError(\\n '`bins` must increase monotonically, when an array')\\n if isinstance(bin_edges, numpy.ndarray):\\n bin_edges = cupy.asarray(bin_edges)\\n elif numpy.ndim(bins) == 0:\\n try:\\n n_equal_bins = operator.index(bins)\\n except TypeError:\\n raise TypeError(\\n '`bins` must be an integer, a string, or an array')\\n if n_equal_bins < 1:\\n raise ValueError('`bins` must be positive, when an integer')\\n\\n first_edge, last_edge = _get_outer_edges(a, range)\\n else:\\n raise ValueError('`bins` must be 1d, when an array')\\n\\n if n_equal_bins is not None:\\n # numpy's gh-10322 means that type resolution rules are dependent on\\n # array shapes. To avoid this causing problems, we pick a type now and\\n # stick with it throughout.\\n bin_type = cupy.result_type(first_edge, last_edge, a)\\n if cupy.issubdtype(bin_type, cupy.integer):\\n bin_type = cupy.result_type(bin_type, float)\\n\\n # bin edges must be computed\\n bin_edges = cupy.linspace(\\n first_edge, last_edge, n_equal_bins + 1,\\n endpoint=True, dtype=bin_type)\\n return bin_edges\",\n \"def hbinavg(x,y,bins):\\n\\n binx = bins[:-1] + (bins[1:] - bins[:-1])/2.\\n bsum = ( np.histogram(x,bins=bins,weights=y) )[0]\\n bn = ( np.histogram(x,bins=bins) )[0]\\n biny = bsum/bn\\n\\n return binx,biny\",\n \"def bws(x, y, **kwargs):\\n\\tx.sort()\\n\\ty.sort()\\n\\tnpx = np.array(x)\\n\\tnpy = np.array(y)\\n\\n\\txs = np.unique(npx)\\n\\tys = np.unique(npy)\\n\\txys = set(xs).union(set(ys))\\n\\taxy = np.array(list(xys))\\n\\taxy.sort()\\n\\n\\tG = np.array([len(axy[np.where(axy <= xi)]) for xi in xs])\\n\\tH = np.array([len(axy[np.where(axy <= yi)]) for yi in ys])\\n\\n\\tn = len(G)\\n\\tm = len(H)\\n\\tfn = float(n)\\n\\tfm = float(m)\\n\\n\\tN = np.linspace(1,n,num=n)\\n\\tM = np.linspace(1,m,num=m)\\n\\n\\txt1 = np.power(G - N*(fm + fn)/fn, 2.0)\\n\\txtt = N/(fn+1.0)\\n\\txt2 = xtt*(1 - xtt)*(fm * (fm+fn)/fn)\\n\\tBx = np.sum(xt1/xt2)/fn\\n\\t\\n\\tyt1 = np.power(H - M*(fm + fn)/fm, 2.0)\\n\\tytt = M/(fm+1.0)\\n\\tyt2 = ytt*(1 - ytt)*(fn * (fm+fn)/fm)\\n\\tBy = np.sum(yt1/yt2)/fm\\n\\n\\tB = (Bx+By)/2.0\\n\\n\\tprint \\\"B = \\\", B\\n\\t\\n\\tJ = 3\\n\\tif \\\"j\\\" in kwargs:\\n\\t\\tJ = kwargs[\\\"j\\\"]\\n\\t\\n\\treturn compute_xi(B, J)\",\n \"def bapply(x,y,bins,func):\\n \\n assert bins[0] <= min(x),'range'\\n assert bins[-1] > max(x),'range'\\n\\n bid = np.digitize(x,bins) \\n nbins = bins.size-1\\n yapply = np.zeros(nbins)\\n\\n for id in range(1,nbins):\\n yb = y[bid==id]\\n yapply[id-1] = func(yb)\\n\\n return yapply\",\n \"def find_bin(self, x):\\n return (x - self.bin_edges[0]) // self.bin_width\",\n \"def find_bin_edges(bin_centres):\\n\\n if not isinstance(bin_centres, np.ndarray):\\n bin_centres = np.asarray(bin_centres)\\n\\n edges = bin_centres[:-1] + 0.5 * (bin_centres[1:] - bin_centres[:-1])\\n bins = np.concatenate(([2 * bin_centres[0] - edges[0]], edges,\\n [2 * bin_centres[-1] - edges[-1]]))\\n\\n return bins\",\n \"def binning():\\n def r(x):\\n return 1 << (x & 7)\\n\\n def w(x):\\n return 0x11 * (x >> 1)\\n return r, w\",\n \"def rebin2D(h, binsx, binsy):\\n new_h = TH2D(\\\"%s_rebin_\\\"%(h.GetName()), \\\"%s_rebin_\\\"%(h.GetName()),\\n len(binsx)-1, array.array('d', binsx), len(binsy)-1, array.array('d', binsy))\\n new_h.Sumw2()\\n for i in xrange(h.GetNbinsX()):\\n bin_to_fill_x = new_h.GetXaxis().FindBin(h.GetXaxis().GetBinCenter(i+1))\\n for j in xrange(h.GetNbinsY()):\\n bin_to_fill_y = new_h.GetYaxis().FindBin(h.GetYaxis().GetBinCenter(j+1))\\n new_h.SetBinContent(bin_to_fill_x, bin_to_fill_y, h.GetBinContent(i+1,j+1) + new_h.GetBinContent(bin_to_fill_x, bin_to_fill_y))\\n new_h.SetBinError(bin_to_fill_x, bin_to_fill_y,\\n TMath.Sqrt(h.GetBinError(i+1, j+1)*h.GetBinError(i+1,j+1) + new_h.GetBinError(bin_to_fill_x, bin_to_fill_y)*new_h.GetBinError(bin_to_fill_x, bin_to_fill_y) ) )\\n return new_h\",\n \"def test_bin_edges(self):\\n with Pandas() as pd:\\n if pd is None:\\n return\\n with Numpy() as np:\\n if numpy is None:\\n return\\n sys.stderr.write(\\\"\\\\n\\\")\\n\\n df1 = pd.DataFrame({'A': [0, 1, 2, 3, 4, 3, 2, 1, 1, 1]})\\n df2 = pd.DataFrame({'A': [2, 3, 4, 5, 7, 4, 6, 5, 7, 8]})\\n\\n # building test histograms\\n hist2 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist3 = hg.SparselyBin(origin=0.0, binWidth=1.0, quantity=unit('A'))\\n hist4 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n hist5 = hg.Bin(num=10, low=0.0, high=10., quantity=unit('A'))\\n hist6 = hg.Bin(num=201, low=0.0, high=1.005)\\n\\n # fill them\\n hist2.fill.numpy(df1)\\n hist3.fill.numpy(df2)\\n hist4.fill.numpy(df1)\\n hist5.fill.numpy(df2)\\n\\n import numpy as np\\n np.testing.assert_array_equal(hist2.bin_edges(), [0., 1., 2., 3., 4., 5.])\\n np.testing.assert_array_equal(hist3.bin_edges(), [2., 3., 4., 5., 6., 7., 8., 9.])\\n np.testing.assert_array_equal(hist4.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n np.testing.assert_array_equal(hist5.bin_edges(), [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n\\n np.testing.assert_array_equal(hist2.bin_edges(low=2.1, high=11.9), [\\n 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])\\n np.testing.assert_array_equal(hist3.bin_edges(low=1.1, high=6), [1., 2., 3., 4., 5., 6.])\\n np.testing.assert_array_equal(hist4.bin_edges(low=2.1, high=11.9), [\\n 2., 3., 4., 5., 6., 7., 8., 9., 10.])\\n np.testing.assert_array_equal(hist5.bin_edges(low=1.1, high=5.4), [1., 2., 3., 4., 5., 6.])\\n\\n assert len(hist6.bin_edges()) == 202\\n assert len(hist6.bin_edges(low=0.2089, high=0.9333)) == 147\\n assert len(hist6.bin_edges(low=0.205, high=0.935)) == 147\",\n \"def felix_binning(xs, ys, delta=1):\\n \\n #bins = np.arange(start, end, delta)\\n #occurance = np.zeros(start, end, delta)\\n BIN_STEP = delta\\n BIN_START = xs.min()\\n BIN_STOP = xs.max()\\n\\n indices = xs.argsort()\\n datax = xs[indices]\\n datay = ys[indices]\\n\\n print(\\\"In total we have: \\\", len(datax), ' data points.')\\n #do the binning of the data\\n bins = np.arange(BIN_START, BIN_STOP, BIN_STEP)\\n print(\\\"Binning starts: \\\", BIN_START, ' with step: ', BIN_STEP, ' ENDS: ', BIN_STOP)\\n\\n bin_i = np.digitize(datax, bins)\\n bin_a = np.zeros(len(bins)+1)\\n bin_occ = np.zeros(len(bins)+1)\\n\\n for i in range(datay.size):\\n bin_a[bin_i[i]] += datay[i]\\n bin_occ[bin_i[i]] += 1\\n\\n binsx, data_binned = [], []\\n for i in range(bin_occ.size-1):\\n if bin_occ[i] > 0:\\n binsx.append(bins[i]-BIN_STEP/2)\\n data_binned.append(bin_a[i]/bin_occ[i])\\n\\n #non_zero_i = bin_occ > 0\\n #binsx = bins[non_zero_i] - BIN_STEP/2\\n #data_binned = bin_a[non_zero_i]/bin_occ[non_zero_i]\\n\\n return binsx, data_binned\",\n \"def extEucBin(x, y):\\n g = 1\\n while isEven(x) and isEven(y):\\n x, y, g = x >> 1, y >> 1, g << 1\\n u, v, A, B, C, D = x, y, 1, 0, 0, 1\\n while True:\\n while isEven(u):\\n u >>= 1\\n if isEven(A) and isEven(B):\\n A, B = A >> 1, B >> 1\\n else:\\n A, B = (A + y) >> 1, (B - x) >> 1\\n while isEven(v):\\n v >>= 1\\n if isEven(C) and isEven(D):\\n C, D = C >> 1, D >> 1\\n else:\\n C, D = (C + y) >> 1, (D - x) >> 1\\n if u >= v:\\n u, A, B = u - v, A - C, B - D\\n else:\\n v, C, D = v - u, C - A, D - B\\n if u == 0:\\n return (C, D, g * v)\",\n \"def _make_bins(start, stop, step):\\n bin_edges = np.arange(start, stop + step, step)\\n\\n return bin_edges\",\n \"def create_bin_boundaries(config, epoch_df, data_type, obs_per_bin, verbose=False):\\n \\n edges = create_edges_set(config, epoch_df, data_type)\\n \\n boundaries = []\\n for edge in edges:\\n start, end, freq = edge\\n bin_size = freq * obs_per_bin\\n boundaries.append(np.arange(start, end, bin_size))\\n boundaries = np.concatenate(boundaries)\\n \\n return boundaries\",\n \"def bin_stats(x,y,xbins,stat='average'):\\n nbins=len(xbins)\\n if stat=='average' or stat=='mean': func=mean\\n elif stat=='median': func=median\\n elif stat=='rms' or stat=='std' : func=std\\n elif stat=='std_robust' or stat=='rms_robust': func=std_robust\\n elif stat=='mean_robust': func=mean_robust\\n elif stat=='median_robust': func=median_robust\\n elif stat=='sum': func=sum\\n results=[]\\n for i in range(nbins):\\n if i<nbins-1:\\n good=(greater_equal(x,xbins[i])\\n *less(x,xbins[i+1]))\\n else: good=(greater_equal(x,xbins[-1]))\\n if sum(good)>1.: results.append(func(compress(good,y)))\\n else:\\n results.append(0.)\\n print('Bin starting at xbins[%i] has %i points' % (i,sum(good)))\\n return array(results)\",\n \"def crazy_histogram2d(x, y, bins=10, weights=None, reduce_w=None, NULL=None, reinterp=None):\\n # define the bins (do anything you want here but needs edges and sizes of the 2d bins)\\n try:\\n nx, ny = bins\\n except TypeError:\\n nx = ny = bins\\n\\n # values you want to be reported\\n if weights is None:\\n weights = np.ones(x.size)\\n\\n if reduce_w is None:\\n reduce_w = np.sum\\n else:\\n if not hasattr(reduce_w, '__call__'):\\n raise TypeError('reduce function is not callable')\\n\\n # culling nans\\n finite_inds = (np.isfinite(x) & np.isfinite(y) & np.isfinite(weights))\\n _x = np.asarray(x)[finite_inds]\\n _y = np.asarray(y)[finite_inds]\\n _w = np.asarray(weights)[finite_inds]\\n\\n if not (len(_x) == len(_y)) & (len(_y) == len(_w)):\\n raise ValueError('Shape mismatch between x, y, and weights: {}, {}, {}'.format(_x.shape, _y.shape, _w.shape))\\n\\n xmin, xmax = _x.min(), _x.max()\\n ymin, ymax = _y.min(), _y.max()\\n dx = (xmax - xmin) / (nx - 1.0)\\n dy = (ymax - ymin) / (ny - 1.0)\\n\\n # Basically, this is just doing what np.digitize does with one less copy\\n xyi = np.vstack((_x, _y)).T\\n xyi -= [xmin, ymin]\\n xyi /= [dx, dy]\\n xyi = np.floor(xyi, xyi).T\\n\\n # xyi contains the bins of each point as a 2d array [(xi,yi)]\\n\\n d = {}\\n for e, k in enumerate(xyi.T):\\n key = (k[0], k[1])\\n\\n if key in d:\\n d[key].append(_w[e])\\n else:\\n d[key] = [_w[e]]\\n\\n _xyi = np.array(d.keys()).T\\n _w = np.array([ reduce_w(v) for v in d.values() ])\\n\\n # exploit a sparse coo_matrix to build the 2D histogram...\\n _grid = sparse.coo_matrix((_w, _xyi), shape=(nx, ny))\\n\\n if reinterp is None:\\n # convert sparse to array with filled value\\n # grid.toarray() does not account for filled value\\n # sparse.coo.coo_todense() does actually add the values to the existing ones, i.e. not what we want -> brute force\\n if NULL is None:\\n B = _grid.toarray()\\n else: # Brute force only went needed\\n B = np.zeros(_grid.shape, dtype=_grid.dtype)\\n B.fill(NULL)\\n for (x, y, v) in zip(_grid.col, _grid.row, _grid.data):\\n B[y, x] = v\\n else: # reinterp\\n xi = np.arange(nx, dtype=float)\\n yi = np.arange(ny, dtype=float)\\n B = griddata(_grid.col.astype(float), _grid.row.astype(float), _grid.data, xi, yi, interp=reinterp)\\n\\n return B, (xmin, xmax, ymin, ymax), (dx, dy)\",\n \"def crazy_histogram2d(x, y, bins=10, weights=None, reduce_w=None, NULL=None, reinterp=None):\\n # define the bins (do anything you want here but needs edges and sizes of the 2d bins)\\n try:\\n nx, ny = bins\\n except TypeError:\\n nx = ny = bins\\n\\n #values you want to be reported\\n if weights is None:\\n weights = np.ones(x.size)\\n\\n if reduce_w is None:\\n reduce_w = np.sum\\n else:\\n if not hasattr(reduce_w, '__call__'):\\n raise TypeError('reduce function is not callable')\\n\\n # culling nans\\n finite_inds = (np.isfinite(x) & np.isfinite(y) & np.isfinite(weights))\\n _x = np.asarray(x)[finite_inds]\\n _y = np.asarray(y)[finite_inds]\\n _w = np.asarray(weights)[finite_inds]\\n\\n if not (len(_x) == len(_y)) & (len(_y) == len(_w)):\\n raise ValueError('Shape mismatch between x, y, and weights: {}, {}, {}'.format(_x.shape, _y.shape, _w.shape))\\n\\n xmin, xmax = _x.min(), _x.max()\\n ymin, ymax = _y.min(), _y.max()\\n dx = (xmax - xmin) / (nx - 1.0)\\n dy = (ymax - ymin) / (ny - 1.0)\\n\\n # Basically, this is just doing what np.digitize does with one less copy\\n xyi = np.vstack((_x, _y)).T\\n xyi -= [xmin, ymin]\\n xyi /= [dx, dy]\\n xyi = np.floor(xyi, xyi).T\\n\\n #xyi contains the bins of each point as a 2d array [(xi,yi)]\\n\\n d = {}\\n for e, k in enumerate(xyi.T):\\n key = (k[0], k[1])\\n\\n if key in d:\\n d[key].append(_w[e])\\n else:\\n d[key] = [_w[e]]\\n\\n _xyi = np.array(d.keys()).T\\n _w = np.array([ reduce_w(v) for v in d.values() ])\\n\\n # exploit a sparse coo_matrix to build the 2D histogram...\\n _grid = sparse.coo_matrix((_w, _xyi), shape=(nx, ny))\\n\\n if reinterp is None:\\n #convert sparse to array with filled value\\n ## grid.toarray() does not account for filled value\\n ## sparse.coo.coo_todense() does actually add the values to the existing ones, i.e. not what we want -> brute force\\n if NULL is None:\\n B = _grid.toarray()\\n else: # Brute force only went needed\\n B = np.zeros(_grid.shape, dtype=_grid.dtype)\\n B.fill(NULL)\\n for (x, y, v) in zip(_grid.col, _grid.row, _grid.data):\\n B[y, x] = v\\n else: # reinterp\\n xi = np.arange(nx, dtype=float)\\n yi = np.arange(ny, dtype=float)\\n B = griddata(_grid.col.astype(float), _grid.row.astype(float), _grid.data, xi, yi, interp=reinterp)\\n\\n return B, (xmin, xmax, ymin, ymax), (dx, dy)\",\n \"def _bin(self, X):\\n H = np.linspace(0, 1, self.Nbin)\\n return np.maximum(1 - (abs(X[..., None] - H)) / (H[1] - H[0]) , 0)\",\n \"def bin_data(x, y, yerr, npts):\\n mod, nbins = len(x) % npts, len(x) / npts\\n if mod != 0:\\n x, y, yerr = x[:-mod], y[:-mod], yerr[:-mod]\\n xb, yb, yerrb = [np.zeros(nbins) for i in range(3)]\\n for i in range(npts):\\n xb += x[::npts]\\n yb += y[::npts]\\n yerrb += yerr[::npts]**2\\n x, y, yerr = x[1:], y[1:], yerr[1:]\\n return xb/npts, yb/npts, yerrb**.5/npts\",\n \"def test_numpy_bins(self):\\n # Load the data from the fixture\\n data = load_occupancy(return_dataset=True)\\n X, y = data.to_numpy()\\n\\n visualizer = BalancedBinningReference()\\n visualizer.fit(y)\\n visualizer.finalize()\\n self.assert_images_similar(visualizer, tol=0.5)\",\n \"def bin_data(x, N_bins=100, xmin=0.0, xmax=1.0, density=False):\\n\\n hist_y, hist_edges = np.histogram(x, bins=N_bins, range=(xmin, xmax), density=density)\\n hist_x = 0.5 * (hist_edges[1:] + hist_edges[:-1])\\n hist_sy = np.sqrt(hist_y)\\n hist_mask = hist_y > 0\\n\\n return hist_x, hist_y, hist_sy, hist_mask\",\n \"def histogram2d(x,y, bins=10, range=None, normed=False, weights=None):\\r\\n from numpy import histogramdd\\r\\n\\r\\n try:\\r\\n N = len(bins)\\r\\n except TypeError:\\r\\n N = 1\\r\\n\\r\\n if N != 1 and N != 2:\\r\\n xedges = yedges = asarray(bins, float)\\r\\n bins = [xedges, yedges]\\r\\n hist, edges = histogramdd([x,y], bins, range, normed, weights)\\r\\n return hist, edges[0], edges[1]\",\n \"def mi_bin(x, y, bins_x, bins_y):\\n if bins_y == 0:\\n bins_y = len(np.unique(y))\\n # compute probabilities\\n p_x = histogram(x, bins_x)\\n p_y = histogram(y, bins_y)\\n p_xy = histogram2d(x, y, bins_x, bins_y)\\n p_x = p_x / p_x.sum()\\n p_y = p_y / p_y.sum()\\n p_xy = p_xy / p_xy.sum()\\n # compute entropy\\n h_x = entropy(p_x.astype(np.float32))\\n h_y = entropy(p_y.astype(np.float32))\\n h_xy = entropy(p_xy.ravel().astype(np.float32))\\n # compute mutual information\\n i = h_x + h_y - h_xy\\n\\n return i\",\n \"def _bin_numbers(col1, col2, bin_n):\\n col1 = col1[~col1.map(lambda x: is_null_flag(x))].reset_index(drop=True)\\n col2 = col2[~col2.map(lambda x: is_null_flag(x))].reset_index(drop=True)\\n comb = pd.Series(pd.np.concatenate([col1, col2])).sort_values(inplace=False).reset_index(drop=True)\\n bin_size = int(len(comb) / bin_n)\\n bin_dict1, bin_dict2 = {}, {}\\n for i in range(bin_n - 1): # last bin only needs bin_min\\n bin_low = comb[i*bin_size]\\n bin_high = comb[(i+1)*bin_size]\\n bin_dict1[i] = sum((col1 >= bin_low) & (col1 < bin_high))\\n bin_dict2[i] = sum((col2 >= bin_low) & (col2 < bin_high))\\n # print bin_low, bin_high\\n # Highest bin\\n bin_dict1[i+1] = sum(col1 >= bin_high)\\n bin_dict2[i+1] = sum(col2 >= bin_high)\\n return bin_dict1, bin_dict2\",\n \"def calculate_bin_edges(n_bins, geo):\\n #Gefittete offsets: x,y,factor: factor*(x+x_off)\\n #[6.19, 0.064, 1.0128]\\n \\n #print \\\"Reading detector geometry in order to calculate the detector dimensions from file \\\" + fname_geo_limits\\n #geo = np.loadtxt(fname_geo_limits)\\n\\n # derive maximum and minimum x,y,z coordinates of the geometry input [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]\\n geo_limits = np.nanmin(geo, axis = 0), np.nanmax(geo, axis = 0)\\n #print ('Detector dimensions [[first_OM_id, xmin, ymin, zmin], [last_OM_id, xmax, ymax, zmax]]: ' + str(geo_limits))\\n\\n x_bin_edges = np.linspace(geo_limits[0][1] - 9.95, geo_limits[1][1] + 9.95, num=n_bins[0] + 1) #try to get the lines in the bin center 9.95*2 = average x-separation of two lines\\n y_bin_edges = np.linspace(geo_limits[0][2] - 9.75, geo_limits[1][2] + 9.75, num=n_bins[1] + 1) # Delta y = 19.483\\n z_bin_edges = np.linspace(geo_limits[0][3] - 4.665, geo_limits[1][3] + 4.665, num=n_bins[2] + 1) # Delta z = 9.329\\n\\n #offset_x, offset_y, scale = [6.19, 0.064, 1.0128]\\n #x_bin_edges = (x_bin_edges + offset_x )*scale\\n #y_bin_edges = (y_bin_edges + offset_y )*scale\\n\\n #calculate_bin_edges_test(geo, y_bin_edges, z_bin_edges) # test disabled by default. Activate it, if you change the offsets in x/y/z-bin-edges\\n\\n return x_bin_edges, y_bin_edges, z_bin_edges\",\n \"def bin(serie, bins):\\n return serie.apply(lambda x: _bin(bins, x))\",\n \"def binning(x, y, xmin=None, xmax=None, dx=1 / 12.,\\r\\n window=3 / 12., interp=False, median=False):\\r\\n if xmin is None:\\r\\n xmin = np.nanmin(x)\\r\\n if xmax is None:\\r\\n xmax = np.nanmax(x)\\r\\n\\r\\n steps = np.arange(xmin, xmax, dx) # time steps\\r\\n bins = [(ti, ti + window) for ti in steps] # bin limits\\r\\n\\r\\n N = len(bins)\\r\\n yb = np.full(N, np.nan)\\r\\n xb = np.full(N, np.nan)\\r\\n eb = np.full(N, np.nan)\\r\\n nb = np.full(N, np.nan)\\r\\n sb = np.full(N, np.nan)\\r\\n\\r\\n for i in range(N):\\r\\n\\r\\n t1, t2 = bins[i]\\r\\n idx, = np.where((x >= t1) & (x <= t2))\\r\\n\\r\\n if len(idx) == 0:\\r\\n xb[i] = 0.5 * (t1 + t2)\\r\\n continue\\r\\n\\r\\n ybv = y[idx]\\r\\n\\r\\n if median:\\r\\n yb[i] = np.nanmedian(ybv)\\r\\n else:\\r\\n yb[i] = np.nanmean(ybv)\\r\\n\\r\\n xb[i] = 0.5 * (t1 + t2)\\r\\n eb[i] = mad_std(ybv)\\r\\n nb[i] = np.sum(~np.isnan(ybv))\\r\\n sb[i] = np.sum(ybv)\\r\\n\\r\\n if interp:\\r\\n try:\\r\\n yb = np.interp(x, xb, yb)\\r\\n eb = np.interp(x, xb, eb)\\r\\n sb = np.interp(x, xb, sb)\\r\\n xb = x\\r\\n except:\\r\\n pass\\r\\n\\r\\n return xb, yb, eb, nb, sb\",\n \"def conv_gauss_custom(x, y, fwhm, dwindow=2):\\n # fwhm = sigma * 2 * np.sqrt(2 * np.log(2))\\n\\n # Check if fwhm is a number or a list\\n if isinstance(fwhm, (int, float)):\\n # If fwhm is a number, make an array with fwhm in each entry\\n fwhm = np.ones_like(x) * fwhm\\n else:\\n # Check fwhm has same dimensions as x\\n if len(fwhm) != len(x):\\n sys.exit('Array `fwhm` has different length than `x`: len(fwhm)={}, len(x)={}'.format(len(fwhm), len(x)))\\n\\n # Number of total datapoints\\n nx = len(x)\\n\\n # -----------------------\\n\\n # For each datapoint define a \\\"bin\\\" or \\\"pixel\\\"\\n # E.g. for the datapoint x_3:\\n # - Bin center: value of the datapoint: x_3\\n # - Bin left edge: half the distance between the current datapoint and the previous one: x_3 - (x_3 - x_2) * 0.5\\n # - Bin right edge: half the distance between the current datapoint and the next one: x_3 + (x_4 - x_3) * 0.5\\n\\n # Distances between center of each bin\\n bin_distance = x[1:] - x[:-1] # length = len(x) - 1\\n # Define left/right edge of each bin as half the distance to the bin previous/next to it\\n bin_edgesmiddle = x[:-1] + 0.5 * bin_distance # middle points\\n bin_edgesfirst = x[0] - 0.5 * bin_distance[0] # first point\\n bin_edgeslast = x[-1] + 0.5 * bin_distance[-1] # last point\\n edges = np.concatenate(([bin_edgesfirst], bin_edgesmiddle, [bin_edgeslast]), axis=0) # length = len(x) + 1\\n\\n # Width of each bin\\n # If the input array x is equally spaced, `bin_width` will be equal to `bin_distance`\\n bin_width = edges[1:] - edges[:-1] # length = len(x)\\n\\n # -----------------------\\n\\n # Convert FWHM from wavelength units to bins -> Number of bins per FWHM\\n fwhm_bin = fwhm / bin_width\\n # Round number of bins per FWHM\\n nbins = np.ceil(fwhm_bin) #npixels\\n\\n ## Convert sigma from wavelength units to bins -> Number of bins per sigma\\n #sigma_bin = sigma / bin_width\\n ## Round number of bins per sigma\\n #nbins = np.ceil(sigma_bin) #npixels\\n\\n # -----------------------\\n\\n yconv = np.zeros_like(x)\\n for i, x_i in enumerate(x):\\n\\n # Slow method -> THIS IS WHAT MAKES THE OTHER FUNCTION SLOW!\\n # # Select kernel window\\n # dwindow = 2 * fwhm #2 * fwhm\\n # x1 = (np.argmin(np.abs(x - (x_i - dwindow))))\\n # x2 = (np.argmin(np.abs(x - (x_i + dwindow))))\\n # irang = slice(x1, x2+1)\\n\\n # Number of pixels at each side of x_i:\\n dx = dwindow * nbins[i] * 0.5\\n i1 = int(max(0, i - dx))\\n i2 = int(min(nx, i + dx + 1))\\n irang = slice(i1, i2 + 1)\\n\\n # Gaussian kernel\\n kernel = 1./(np.sqrt(2*np.pi)*fwhm[i]) * np.exp(- ((x[irang] - x_i)**2) / (2 * fwhm[i]**2))\\n kernel = kernel / np.sum(kernel)\\n\\n # Convolve\\n yconv[i] = np.sum(y[irang] * kernel)\\n\\n return yconv\",\n \"def binarize(X, *, threshold=..., copy=...):\\n ...\",\n \"def asBinEdges(bins, data, scale='lin'):\\n data = np.asarray(data)\\n ndim = data.ndim\\n edges = ndim * [None]\\n\\n try:\\n M = len(bins)\\n if M != ndim:\\n flag_1d = really1d(bins)\\n if flag_1d:\\n bins = [np.asarray(bins, float)]\\n\\n if not flag_1d or len(bins) != ndim:\\n raise ValueError('The dimension of bins must be equal '\\n 'to the dimension of the sample x.')\\n except TypeError:\\n bins = ndim * [bins]\\n\\n # If `scale` is a single value for all dimensions\\n if(np.ndim(scale) == 0):\\n scale = ndim * [scale]\\n # otherwise `scale` must be specified for each dimension\\n elif(np.size(scale) != ndim):\\n raise ValueError(\\\"`scale` must be a single value or a value for each dimension.\\\")\\n\\n # Find range for each dimension\\n smin = np.atleast_1d(np.array(data.min(axis=0), float))\\n smax = np.atleast_1d(np.array(data.max(axis=0), float))\\n # Make sure the bins have a finite width.\\n for i in range(len(smin)):\\n if smin[i] == smax[i]:\\n smin[i] = smin[i] - 0.5\\n smax[i] = smax[i] + 0.5\\n\\n # Create arrays describing edges of bins\\n for ii in range(ndim):\\n if np.isscalar(bins[ii]):\\n edges[ii] = spacing([smin[ii], smax[ii]], scale[ii], num=bins[ii] + 1)\\n else:\\n edges[ii] = np.asarray(bins[ii], float)\\n\\n if(ndim == 1):\\n edges = edges[0]\\n\\n return edges\",\n \"def binning ( self , axis , name = '' ) :\\n assert isinstance ( axis , ROOT.TAxis ),\\\\\\n 'Invalid axis %s/%s' % ( axis , type ( axis ) )\\n\\n ## uniform binning?\\n if not axis.IsVariableBinSize() : \\n return ROOT.RooFit.Binning ( axis.GetNbins() , axis.GetXmin() , axis.GetXmax() )\\n ##\\n xbins = axis.GetXbins().GetArray()\\n rb = ROOT.RooBinning ( axis.GetNbins() , xbins , name )\\n ##\\n self.aux_keep.append ( rb )\\n ##\\n return ROOT.RooFit.Binning ( rb )\",\n \"def bin_spec_y(self, start, end):\\n #print(self.spec_x.tolist())\\n start_spec_x = closest_value_index(start, self.spec_x.tolist())\\n i = 0\\n bin_sum = 0\\n while(start_spec_x + i < len(self.spec_x) and self.spec_x[start_spec_x + i] <= end):\\n bin_sum += self.spec_y[start_spec_x + i]\\n i += 1\\n average = bin_sum / (i+1)\\n return average\",\n \"def histogram2d(x, y, bins=10, range=None, weights=None, flow=False, cons_var=False):\\n try:\\n N = len(bins)\\n except TypeError:\\n N = 1\\n\\n x = np.asarray(x)\\n y = np.asarray(y)\\n if weights is not None:\\n weights = np.asarray(weights)\\n if N != 1 and N != 2:\\n bins = np.asarray(bins)\\n return var2d(x, y, bins, bins, weights=weights, flow=flow, cons_var=cons_var)\\n\\n elif N == 1:\\n return fix2d(\\n x,\\n y,\\n bins=bins,\\n range=range,\\n weights=weights,\\n flow=flow,\\n cons_var=cons_var,\\n )\\n\\n elif N == 2:\\n if isinstance(bins[0], int) and isinstance(bins[1], int):\\n return fix2d(x, y, bins=bins, range=range, weights=weights, flow=flow)\\n else:\\n b1 = np.asarray(bins[0])\\n b2 = np.asarray(bins[1])\\n return var2d(x, y, b1, b2, weights=weights, flow=flow)\\n\\n else:\\n raise ValueError(\\\"bins argument is not compatible\\\")\",\n \"def histogram2d(x, y, bins=10, range=None, weights=None, density=None):\\n try:\\n n = len(bins)\\n except TypeError:\\n n = 1\\n\\n if n != 1 and n != 2:\\n if isinstance(bins, cupy.ndarray):\\n xedges = yedges = bins\\n bins = [xedges, yedges]\\n else:\\n raise ValueError('array-like bins not supported in CuPy')\\n\\n hist, edges = histogramdd([x, y], bins, range, weights, density)\\n return hist, edges[0], edges[1]\",\n \"def bin_data(y, num_bins, std_away):\\n mean = np.mean(y)\\n std = np.std(y)\\n pitch_shifts = np.arange(-num_bins, num_bins + 1)\\n thresholds = (std * std_away) * pitch_shifts + mean\\n\\n result = []\\n for point in y:\\n if point < thresholds[0]:\\n result.append(pitch_shifts[0] - 1)\\n elif point > thresholds[-1]:\\n result.append(pitch_shifts[-1] + 1)\\n else:\\n for i in range(len(thresholds) - 1):\\n if point >= thresholds[i] and point < thresholds[i + 1]:\\n result.append(i - num_bins)\\n return np.array(result)\",\n \"def _fast_hist_2d(data, bin_edges):\\n # Yes, I've tested this against histogramdd().\\n xassign = np.digitize(data[:,0], bin_edges[1:-1]) \\n yassign = np.digitize(data[:,1], bin_edges[1:-1])\\n nbins = len(bin_edges) - 1\\n flatcount = np.bincount(xassign + yassign * nbins, minlength=nbins*nbins)\\n return flatcount.reshape((nbins, nbins))\",\n \"def createBin(image_object, num=8):\\n image_array = sitk.GetArrayFromImage(image_object)\\n _, bin_edges = np.histogram(image_array.flatten(), bins=num)\\n bin_edges[-1] += 1\\n for i in range(num):\\n image_array[(image_array >= bin_edges[i]) & (image_array < bin_edges[i+1])] = i+1\\n image_object_bin = sitk.GetImageFromArray(image_array)\\n return image_object_bin\",\n \"def getLinBins(nbins, low, high):\\n x = float(low)\\n dx = float(high-low)/nbins\\n\\n return np.array([x+i*dx for i in range(nbins+1)], dtype=float)\",\n \"def xy_bin(xo, yo, n=100, mode='log', bins=None):\\n \\n assert(len(xo)==len(yo))\\n \\n if bins is None:\\n if mode == 'log':\\n x = np.logspace(np.log10(xo[xo>0].min()), np.log10(xo.max()), n+1)\\n elif mode == 'lin':\\n x = np.linspace(xo.min(), xo.max(), n+1)\\n else:\\n x = np.sort(bins)\\n \\n y = (np.histogram(xo, x, weights=yo)[0] /\\n np.histogram(xo, x)[0])\\n \\n return x[:-1], y\",\n \"def _bresenham_pairs(x0: int, y0: int, x1: int, y1: int) -> np.ndarray:\\n dx = abs(x1 - x0)\\n dy = abs(y1 - y0)\\n dim = max(dx, dy)\\n pairs = np.zeros((dim, 2), dtype=np.int64)\\n x, y = x0, y0\\n sx = -1 if x0 > x1 else 1\\n sy = -1 if y0 > y1 else 1\\n if dx > dy:\\n err = dx // 2\\n for i in range(dx):\\n pairs[i, 0] = x\\n pairs[i, 1] = y\\n err -= dy\\n if err < 0:\\n y += sy\\n err += dx\\n x += sx\\n else:\\n err = dy // 2\\n for i in range(dy):\\n pairs[i, 0] = x\\n pairs[i, 1] = y\\n err -= dx\\n if err < 0:\\n x += sx\\n err += dy\\n y += sy\\n return pairs\",\n \"def binning_axis(self) -> int:\\r\\n return 0\",\n \"def bin_discretize(self, variables=[], bins=3,\\n min_const_samples_bin_size=1.0/3):\\n self.edges=np.zeros((self.arity.size,bins+1))\\n for i in variables:\\n un_cnt=np.unique(self.data[:,i],return_counts=True)\\n constvals=un_cnt[0][un_cnt[1]>self.data.shape[0]*min_const_samples_bin_size]\\n mask=np.ones(self.data.shape[0],dtype=bool)\\n if constvals.size>0:\\n for j,cv in enumerate(constvals):\\n mask*=(self.data[:,i]!=cv)\\n self.data[self.data[:,i]==cv,i]=j\\n\\n size=np.sum(mask)/bins\\n sorted_i=np.argsort(self.data[mask,i])\\n edges=[self.data[mask,i][sorted_i[int(size*num)-1]] for num in range(1,bins)]\\n self.edges[i]=[self.data[mask,i][sorted_i[0]]]+edges+[self.data[mask,i][sorted_i[-1]]]\\n self.data[mask,i]=np.searchsorted(edges,self.data[mask,i])+constvals.size\\n self.arity[i]=len(edges)+1+constvals.size\",\n \"def rebin_2d(x_in, data, x_new, statistic='mean'):\\n edges = binvec(x_new)\\n datai = np.zeros((len(x_new), data.shape[1]))\\n data = ma.masked_invalid(data) # data may contain nan-values\\n for ind, values in enumerate(data.T):\\n mask = ~values.mask\\n if ma.any(values[mask]):\\n datai[:, ind], _, _ = stats.binned_statistic(x_in[mask],\\n values[mask],\\n statistic=statistic,\\n bins=edges)\\n datai[~np.isfinite(datai)] = 0\\n return ma.masked_equal(datai, 0)\",\n \"def binnedAverage(x, y, bins=20):\\n xbins, step = np.linspace(np.min(x), np.max(x), num=bins, retstep=True)\\n xbins = (xbins + step/2)[:-1]\\n emptyBins = []\\n ymeans = []\\n for xbi, xb in enumerate(xbins):\\n ytotal = 0\\n ycount = 0\\n for y_i, y_ in enumerate(y):\\n if xb - step/2 < x[y_i] < xb + step/2:\\n ytotal += y_\\n ycount += 1\\n if ycount >= 1:\\n ymeans.append(ytotal/ycount)\\n else:\\n emptyBins.append(xbi)\\n xbins = np.delete(xbins, emptyBins)\\n return xbins, np.array(ymeans)\",\n \"def mapBinEdgesAndDataToXYZStandard(binEdgesArray, binDataArray):\\n\\t#TODO: Check that this is actually a 2-d array (need +1 since number of edges is +1 more than number of bins)\\n\\tdimX, dimY = len(binEdgesArray)+1, len(binEdgesArray[0])+1\\n\\n\\t#We get a ValueError later anyway (at time of writing) but better to raise it here\\n\\tif len(binEdgesArray.shape)-2 != 2:\\n\\t\\tnDims = len(binEdgesArray.shape)-2\\n\\t\\traise ValueError(\\\"Input array seems to be {} dimensions; we need 2 dimensions\\\".format(nDims))\\n\\n\\toutX = np.zeros( (dimX,dimY) )\\n\\toutY = np.zeros( (dimX,dimY) )\\n\\toutZ = copy.deepcopy(binDataArray)\\n\\n\\tfor idxX in range(dimX):\\n\\t\\tfor idxY in range(dimY):\\n\\t\\t\\t#Edge case where we take the upper edge of the previous bin (instead of lower edge of current)\\n\\t\\t\\tif (idxX==dimX-1) and (idxY==dimY-1):\\n\\t\\t\\t\\toutX[idxX][idxY] = binEdgesArray[idxX-1][idxY-1][0][1] #Is this correct????\\n\\t\\t\\t\\toutY[idxX][idxY] = binEdgesArray[idxX-1][idxY-1][1][1] \\n\\t\\t\\telif idxX==dimX-1:\\n\\t\\t\\t\\toutX[idxX][idxY] = binEdgesArray[idxX-1][idxY][0][1]\\n\\t\\t\\t\\toutY[idxX][idxY] = binEdgesArray[idxX-1][idxY][1][0]\\n\\t\\t\\telif idxY==dimY-1:\\n\\t\\t\\t\\toutX[idxX][idxY] = binEdgesArray[idxX][idxY-1][0][0]\\n\\t\\t\\t\\toutY[idxX][idxY] = binEdgesArray[idxX][idxY-1][1][1]\\t\\t\\t\\n\\t\\t\\telse:\\n\\t\\t\\t\\toutX[idxX][idxY] = binEdgesArray[idxX][idxY][0][0]\\n\\t\\t\\t\\toutY[idxX][idxY] = binEdgesArray[idxX][idxY][1][0]\\n\\n\\treturn outX, outY, outZ\",\n \"def grid_to_bins(grid, start_bin_val, end_bin_val):\\n bin_centers = (grid[1:] + grid[:-1])/2.0\\n bins = np.concatenate([[start_bin_val], bin_centers, [end_bin_val]])\\n return bins\",\n \"def __call__(self, n_bins, segment, elements):\\n\\n # n_bins\\n assert type(n_bins) is int\\n assert n_bins > 0\\n\\n # segment\\n assert type(segment) is list or type(segment) is tuple\\n assert len(segment) == 2\\n assert np.isscalar(segment[0]) and np.isscalar(segment[1])\\n assert segment[0] < segment[1]\\n\\n # elements\\n assert type(elements) is np.ndarray, f\\\"elements should be an np.ndarray, instead of {type(elements)}\\\"\\n assert elements.dtype == np.number\\n\\n sorted_elements = np.sort(elements)\\n\\n bin_card = int(floor(elements.shape[0]/n_bins))\\n\\n bin_boundaries = [segment[0]]\\n\\n for i in range(1, n_bins):\\n boundary_l = sorted_elements[i*bin_card - 1]\\n boundary_r = sorted_elements[i * bin_card]\\n boundary = (boundary_l+boundary_r)/2\\n\\n bin_boundaries.append(boundary)\\n\\n bin_boundaries.append(segment[1])\\n\\n return np.array(bin_boundaries)\",\n \"def get_shape_bin_edges(shapes_path, datacard_bin):\\n shapes_file = ROOT.TFile.Open(shapes_path)\\n print 'tfile path is', shapes_path\\n print 'list of keys'\\n #ROOT.gDirectory.GetListOfKeys().ls()\\n print 'gonnad cd', datacard_bin\\n print shapes_file.cd(datacard_bin)\\n shapes = ROOT.gDirectory.GetListOfKeys()\\n #print 'list of Keys is', ROOT.gDirectory.GetListOfKeys().ls()\\n # Since the nominal and varied shapes share the same binning,\\n # take any of the histograms found in the shapes file.\\n print 'debug0'\\n shape = ROOT.gDirectory.Get(shapes[0].GetName())\\n print 'debug'\\n bin_edges = np.array(\\n [shape.GetXaxis().GetBinLowEdge(i) for i in xrange(1, shape.GetNbinsX() + 1)],\\n dtype=np.float64,\\n )\\n shapes_file.Close()\\n print 'bin_edges for datacard_bin is', bin_edges\\n #sys.exit()\\n return bin_edges\",\n \"def test_binops(self):\",\n \"def mi_bin_conn_time(x, y, bins_x, bins_y):\\n n_times, n_trials = x.shape\\n mi = np.zeros((n_times), dtype=np.float32)\\n for t in range(n_times):\\n mi[t] = mi_bin(x[t, :], y[t, :], bins_x, bins_y)\\n return mi\",\n \"def bincalc(nbin=0.1,bmin=5,bmax=2000):\\n\\n logbmin=np.log10(bmin)\\n logbmax=np.log10(bmax)\\n\\n logbins=np.arange(logbmin,logbmax,nbin)\\n\\n bins=10**logbins\\n\\n #bins=np.linspace(bmin,bmax,60)\\n return (bins)\",\n \"def getBinIndex(self, x):\\n\\t\\tb = -1\\n\\t\\tif x == self._max_val: # final bin is [low, high], where others are [low,high)\\n\\t\\t\\tb = len(self._bins)-1\\n\\t\\telse:\\n\\t\\t\\tb = math.floor((x-self._min_val)/self._bin_width)\\n\\t\\treturn int(b)\",\n \"def binning(data, low, high):\\n if len(data) == 0: return 1\\n\\n mask1 = (data >= low)\\n mask2 = (data < high)\\n mask3 = numpy.logical_and(mask1, mask2)\\n data = data[mask3]\\n\\n if len(data) == 0: return 10\\n\\n data.sort()\\n q1 = data[int(math.floor(0.25*len(data)))]\\n q3 = data[int(math.floor(0.75*len(data)))]\\n binwidth = 2. * (q3 - q1) / len(data)**(1./3.)\\n if binwidth > 0.:\\n return max(10, int(math.ceil((high - low)/binwidth)))\\n else:\\n return 10\",\n \"def _calcBins(self, contribs, parValues, fraction, minReq):\\n # single set of R for this calculation\\n bins = np.zeros(self.binCount)\\n binObs = np.zeros(self.binCount)\\n for bi in range(self.binCount):\\n val, obs = self._calcBin(\\n self._binMask(bi, parValues),\\n fraction, minReq)\\n bins[bi] = val\\n binObs[bi] = obs\\n cdf = self._calcCDF(bins)\\n return bins, binObs, cdf\",\n \"def bins_match (a, b):\\n return 0 == (\\n np.sum ((a.xbins - b.xbins)**2)\\n + np.sum ((a.ybins - b.ybins)**2) )\",\n \"def mean_relationship_twoD(x, y, bins_values):\\r\\n sort_ind_x = np.argsort(x)\\r\\n x = x[sort_ind_x]\\r\\n y = y[:, sort_ind_x]\\r\\n hist, bin_edges = np.histogram(x, bins=bins_values)\\r\\n array_end = np.cumsum(hist)\\r\\n array_start = np.cumsum(hist) - hist\\r\\n y_x = np.zeros((len(y), len(array_start)))\\r\\n for i in np.arange(len(array_start)):\\r\\n y_x[:, i] = np.mean(y[:, array_start[i]:array_end[i]], axis=1)\\r\\n return y_x\",\n \"def calculateMetallicityBinEdges(self):\\n\\n if self.binInLogSpace:\\n logMetallicities = np.log10(self.metallicityGrid)\\n b= logMetallicities[:-1] + (logMetallicities[1:] - logMetallicities[:-1])/2.\\n b = 10.**b #the boundaries for integration are not in log space so\\n #convert to \\\"normal\\\" numbers.\\n else:\\n b= (self.metallicityGrid[1:] - self.metallicityGrid[:-1])/2. \\\\\\n + self.metallicityGrid[:-1] \\n\\n self.metallicityBinEdges = np.zeros(len(b)+2)\\n\\n #the lowest/highest metallicity bin edge are set in options\\n #the calculated b edges are all in between\\n\\n self.metallicityBinEdges[0] = self.metallicityLowerLimit\\n self.metallicityBinEdges[-1] = self.metallicityUpperLimit\\n self.metallicityBinEdges[1:-1] = b\",\n \"def binn_fft(self):\\n bin_res = []\\n for fft_bin in BINS:\\n bin_res.append(self.bin_spec_y(fft_bin[0], fft_bin[1]))\\n return bin_res\",\n \"def bin_matrix(x, binning):\\n\\n N = len(x)\\n B = []\\n for i in range(len(binning) - 1):\\n\\n line = np.zeros(N)\\n for j in range(N):\\n\\n if x[j] >= binning[i] and x[j] < binning[i+1]:\\n\\n size = binning[i + 1] - binning[i]\\n line[j] = 1 / size\\n\\n B.append(line)\\n\\n B = np.array(B)\\n\\n return(B)\",\n \"def binarize(self, image):\\n\\n [rows, columns] = np.shape(image)\\n bin_img = np.zeros((rows, columns), dtype=int)\\n print(\\\"############## Using to binarize an image ##############\\\")\\n hist = self.compute_histogram(image)\\n threshold = self.find_optimal_threshold(hist)\\n for i in range(rows):\\n for j in range(columns):\\n if image[i, j] < threshold:\\n bin_img[i, j] = 0\\n else:\\n bin_img[i, j] = 255\\n # print(\\\"binary image: \\\\n\\\", bin_img)\\n\\n return bin_img\",\n \"def to_bin(value, edges):\\n\\n previous = 0\\n for v in edges:\\n if previous <= value <= v:\\n return (previous, v)\\n previous = v\\n return (previous, None)\",\n \"def compute_histogram(samples, nbins=50, piecewise_constant=True):\\n import sys\\n if 'numpy' in sys.modules:\\n y0, bin_edges = histogram(samples, bins=nbins, normed=True)\\n h = bin_edges[1] - bin_edges[0] # bin width\\n if piecewise_constant:\\n x = zeros(2*len(bin_edges), type(bin_edges[0]))\\n y = x.copy()\\n x[0] = bin_edges[0]\\n y[0] = 0\\n for i in range(len(bin_edges)-1):\\n x[2*i+1] = bin_edges[i]\\n x[2*i+2] = bin_edges[i+1]\\n y[2*i+1] = y0[i]\\n y[2*i+2] = y0[i]\\n x[-1] = bin_edges[-1]\\n y[-1] = 0\\n else:\\n x = zeros(len(bin_edges)-1, type(bin_edges[0]))\\n y = y0.copy()\\n for i in range(len(x)):\\n x[i] = (bin_edges[i] + bin_edges[i+1])/2.0\\n return x, y\",\n \"def bin_input(neu, bin_size, overlap = 0):\\n win_d = bin_size - overlap\\n n_bins = int(((neu.shape[0]-bin_size)/win_d)+1)\\n FRmat = np.empty([n_bins, neu.shape[1]])\\n for i in range(n_bins):\\n FRmat[i,:] = np.sum(neu[i*win_d:i*win_d+bin_size,:], axis = 0)\\n \\n return FRmat\",\n \"def getLogBins(nbins, low, high):\\n\\n x = float(low)\\n dx = pow(high/low, 1.0/nbins);\\n \\n return np.array([x*pow(dx,i) for i in range(nbins+1)], dtype=float)\",\n \"def binary_binned_metric(model=None, X=None, positive_scores=None, Y=None, bins_weights=None):\\n\\n return specific_class_binned_metric(model=model, X=X, specific_scores=positive_scores,\\n Y=Y, bins_weights=bins_weights, class_index=1)\",\n \"def compute_bin_indices(X_part, bin_limits=None, n_bins=20):\\n if bin_limits is None:\\n bin_limits = []\\n for variable_data in range(X_part.shape[1]):\\n bin_limits.append(numpy.linspace(numpy.min(variable_data), numpy.max(variable_data), n_bins + 1)[1: -1])\\n\\n bin_indices = numpy.zeros(len(X_part), dtype=numpy.int)\\n for axis, bin_limits_axis in enumerate(bin_limits):\\n bin_indices *= (len(bin_limits_axis) + 1)\\n bin_indices += numpy.searchsorted(bin_limits_axis, X_part[:, axis])\\n\\n return bin_indices\",\n \"def setup_bins(self):\\n width = int((self.max - self.min) / self.bin_size)\\n bins = {\\n i * width + self.min: (idx, idx + self.bin_size)\\n for i, idx in enumerate(range(0, len(self.nums), self.bin_size))\\n }\\n return bins\",\n \"def tcbin(x, y=8):\\n if x >= (2**(y - 1)) or x < -(2**(y - 1) or y < 1):\\n raise Exception(\\\"Argument outside of range.\\\")\\n if x >= 0:\\n binstr = bin(x)\\n # pad with leading zeros\\n while len(binstr) < y + 2:\\n binstr = \\\"0b0\\\" + binstr[2:]\\n return binstr\\n return bin((2**y) + x) # x is negative\",\n \"def __init__(self, edges, yedges=None):\\n if yedges is None:\\n if len(edges) == 2:\\n BinnedSet.__init__(self, edges)\\n else:\\n raise ValueError(\\\"'edges' does not contain exactly two bin \\\"\\n \\\"edge arrays\\\")\\n else:\\n BinnedSet.__init__(self, (edges, yedges))\",\n \"def matrix2bin(X, y, filename):\\n if len(X.shape) == 3:\\n Xy = []\\n for dimX, dimy in zip(X, y):\\n ym = np.array([dimy])\\n Xy.append(np.append(dimX, ym.T, axis=1))\\n Xy = np.array(Xy)\\n else:\\n ym = np.array([y])\\n Xy = np.append(X, ym.T, axis=1)\\n np.save(filename, Xy)\",\n \"def bin_search(arr, x):\\n \\n low = 0\\n hi = len(arr) - 1\\n \\n while(low <= hi): \\n \\n mid = int((low + hi) / 2) # find middle idx\\n\\n if( x >= arr[mid]): # if x on the right, change low idx and search right side\\n low = mid + 1; \\n else: # else search left side\\n hi = mid - 1\\n\\n return hi\",\n \"def label_values_to_bins(array_to_bin:object, bin_count:int):\\n\\t\\t# Make 1D for qcut.\\n\\t\\tarray_to_bin = array_to_bin.flatten()\\n\\t\\t# For really unbalanced labels, I ran into errors where bin boundaries would be duplicates all the way down to 2 bins.\\n\\t\\t# Setting `duplicates='drop'` to address this.\\n\\t\\tbin_numbers = pd.qcut(x=array_to_bin, q=bin_count, labels=False, duplicates='drop')\\n\\t\\t# Convert 1D array back to 2D for the rest of the program.\\n\\t\\tbin_numbers = np.reshape(bin_numbers, (-1, 1))\\n\\t\\treturn bin_numbers\",\n \"def inner(x, y):\\n\\n return np.inner(x.ravel(), y.ravel())\",\n \"def bin_absorbers(dat, bin_attr='z', binsize=None, bin_start=None,\\n bin_end=None, bins=None):\\n output = []\\n if not bins: # if no custom bins specified, then take equallly spaced bins\\n bins = np.arange(bin_start, bin_end, binsize)\\n bins = list(zip(bins, bins + binsize))\\n\\n for b in bins:\\n output.append(\\n [item for item in dat if b[0] <= getattr(item, bin_attr) < b[1]]\\n )\\n return output\",\n \"def binary_add(x, y):\\n # Makes sure that the arrays have the same length.\\n # Could be changed to padding on extra zeroes, if so desired.\\n assert(len(x) == len(y))\\n\\n z = [0] * (len(x)+1)\\n for a, (i, j) in enumerate(zip(x[::-1], y[::-1])):\\n # Makes sure that the array is a binary array.\\n # Strictly speaking, not necessary. But nice.\\n if i not in [0, 1]: return False\\n if j not in [0, 1]: return False\\n\\n # if i and j are both 1 \\n if i and j:\\n z[a] += 0\\n z[a+1] += 1\\n # if only one of them is 1\\n elif i or j:\\n z[a] += 1\\n # if they're both 0\\n else: pass\\n\\n if z[a] == 2:\\n z[a+1] += 1\\n z[a] -= 2\\n \\n return z[::-1]\",\n \"def rebin(array, dimensions=None, scale=None):\\n if dimensions is not None:\\n if isinstance(dimensions, float):\\n dimensions = [int(dimensions)] * len(array.shape)\\n elif isinstance(dimensions, int):\\n dimensions = [dimensions] * len(array.shape)\\n elif len(dimensions) != len(array.shape):\\n raise RuntimeError('')\\n elif scale is not None:\\n if isinstance(scale, float) or isinstance(scale, int):\\n dimensions = map(int, map(round, map(lambda x: x * scale, array.shape)))\\n elif len(scale) != len(array.shape):\\n raise RuntimeError('')\\n else:\\n raise RuntimeError('Incorrect parameters to rebin.\\\\n\\\\trebin(array, dimensions=(x,y))\\\\n\\\\trebin(array, scale=a')\\n import itertools\\n # dY, dX = map(divmod, map(float, array.shape), dimensions)\\n if np.shape(array) == dimensions: return array # no rebinning actually needed\\n result = np.zeros(dimensions)\\n for j, i in itertools.product(*map(xrange, array.shape)):\\n (J, dj), (I, di) = divmod(j * dimensions[0], array.shape[0]), divmod(i * dimensions[1], array.shape[1])\\n (J1, dj1), (I1, di1) = divmod(j + 1, array.shape[0] / float(dimensions[0])), divmod(i + 1,\\n array.shape[1] / float(\\n dimensions[1]))\\n\\n # Moving to new bin\\n # Is this a discrete bin?\\n dx, dy = 0, 0\\n if (I1 - I == 0) | ((I1 - I == 1) & (di1 == 0)):\\n dx = 1\\n else:\\n dx = 1 - di1\\n if (J1 - J == 0) | ((J1 - J == 1) & (dj1 == 0)):\\n dy = 1\\n else:\\n dy = 1 - dj1\\n # Prevent it from allocating outide the array\\n I_ = min(dimensions[1] - 1, I + 1)\\n J_ = min(dimensions[0] - 1, J + 1)\\n result[J, I] += array[j, i] * dx * dy\\n result[J_, I] += array[j, i] * (1 - dy) * dx\\n result[J, I_] += array[j, i] * dy * (1 - dx)\\n result[J_, I_] += array[j, i] * (1 - dx) * (1 - dy)\\n allowError = 0.1\\n assert (array.sum() < result.sum() * (1 + allowError)) & (array.sum() > result.sum() * (1 - allowError))\\n return result\",\n \"def create_bins(start, end, n_bins):\\n bins = np.linspace(start, end, n_bins)\\n return bins\",\n \"def bin_data(data, lat, lon, binsize=1, uv_data=False, pressure=None):\\n\\n # Create lats and lons based on binsize\\n lonlen = 360\\n latlen = 180\\n\\n lon_lowerlim = 0\\n lon_upperlim = 360\\n\\n lat_lowerlim = -90\\n lat_upperlim = 90\\n\\n if latlen % binsize == 0 and lonlen % binsize == 0:\\n latbin = int(latlen/binsize)\\n lonbin = int(lonlen/binsize)\\n n_deg = binsize/2\\n\\n ll_lats = np.linspace(lat_lowerlim+(n_deg),\\n lat_upperlim-(n_deg),\\n latbin)\\n\\n ll_lons = np.linspace(lon_lowerlim+(n_deg),\\n lon_upperlim-(n_deg),\\n lonbin)\\n\\n else:\\n print('ERROR: Binsize does not work for grid shape (180,360). Please use different binsize.')\\n return\\n\\n paramlist = list(itertools.product(ll_lats, ll_lons))\\n\\n # Bin Data\\n if uv_data == True:\\n binned_u_data = np.full((latbin, lonbin), np.nan, dtype=object)\\n binned_v_data = np.full((latbin, lonbin), np.nan, dtype=object)\\n\\n if pressure is not None:\\n binned_pressure = np.full((latbin, lonbin), np.nan, dtype=object)\\n\\n for val in paramlist:\\n # Get index of 1x1 grid lat and lon\\n latidx = np.where(ll_lats == val[0])\\n lonidx = np.where(ll_lons == val[1])\\n # values of the 1x1 grid lat and lon\\n binnedlons = val[1]\\n binnedlats = val[0]\\n\\n # find instances where data is within 1x1 grid point of orginal data\\n data_idx = np.where((lon >= binnedlons - n_deg) & (lon <= binnedlons + n_deg) &\\n (lat >= binnedlats - n_deg) & (lat <= binnedlats + n_deg))\\n\\n latlon_idx = [latidx[0][0], lonidx[0][0]]\\n\\n # calculate stats if there is data at this grid point, else append np.nan\\n if len(data_idx[0]) > 0:\\n u = data['u'][data_idx]\\n v = data['v'][data_idx]\\n\\n binned_u_data[latlon_idx[0], latlon_idx[1]] = u\\n binned_v_data[latlon_idx[0], latlon_idx[1]] = v\\n\\n if pressure is not None:\\n p = pressure[data_idx]\\n binned_pressure[latlon_idx[0], latlon_idx[1]] = p\\n\\n if pressure is not None:\\n return binned_u_data, binned_v_data, binned_pressure\\n\\n else:\\n return binned_u_data, binned_v_data\\n\\n else:\\n binned_data = np.full((latbin, lonbin), np.nan, dtype=object)\\n if pressure is not None:\\n binned_pressure = np.full((latbin, lonbin), np.nan, dtype=object)\\n\\n for val in paramlist:\\n # Get index of grid lat and lon\\n latidx = np.where(ll_lats == val[0])\\n lonidx = np.where(ll_lons == val[1])\\n # values of the 1x1 grid lat and lon\\n binnedlons = val[1]\\n binnedlats = val[0]\\n\\n # find instances where data is within 1x1 grid point of orginal data\\n data_idx = np.where((lon >= binnedlons - n_deg) & (lon <= binnedlons + n_deg) &\\n (lat >= binnedlats - n_deg) & (lat <= binnedlats + n_deg))\\n\\n latlon_idx = [latidx[0][0], lonidx[0][0]]\\n\\n # calculate stats if there is data at this grid point\\n if len(data_idx[0]) > 0:\\n d = data[data_idx]\\n binned_data[latlon_idx[0], latlon_idx[1]] = d\\n\\n if pressure is not None:\\n p = pressure[data_idx]\\n binned_pressure[latlon_idx[0], latlon_idx[1]] = p\\n\\n if pressure is not None:\\n return binned_data, binned_pressure\\n\\n else:\\n return binned_data\",\n \"def test_pandas_bins(self):\\n # Load the data from the fixture\\n data = load_occupancy(return_dataset=True)\\n X, y = data.to_pandas()\\n\\n visualizer = BalancedBinningReference()\\n visualizer.fit(y)\\n visualizer.finalize()\\n self.assert_images_similar(visualizer, tol=0.5)\",\n \"def bin_center_to_edges(centers):\\n edges = bin_edges_to_center(centers)\\n edges = np.append(centers[0]-(edges[0]-centers[0]), edges)\\n edges = np.append(edges, centers[-1]+(centers[-1]-edges[-1]))\\n return edges\",\n \"def bin_the_data(neuron_spikes, first, last, bin_size):\\n neuron_activity = []\\n timebins = range(first, int(last) + int(last) % bin_size, bin_size)\\n for spike in neuron_spikes:\\n activity = []\\n spike_time = spike[0]\\n i = 0\\n for bin_size in timebins:\\n k = 0\\n while spike_time < bin_size:\\n i += 1\\n if i >= np.size(spike):\\n break\\n spike_time = spike[i]\\n k += 1\\n activity.append(k)\\n neuron_activity.append(activity)\\n return neuron_activity, timebins\",\n \"def createBins():\\n theBins = []\\n startFreq = 60\\n for a in range(32):\\n endFreq = int(startFreq*1.12+12)\\n theRange = (startFreq, endFreq)\\n startFreq = endFreq\\n theBins.append(theRange)\\n return(theBins)\",\n \"def get_bin_means(X,Y,bin_edges=None,mean='median',error='sem',minimum_n=25):\\n \\n assert(X.shape == Y.shape)\\n \\n # Flatten if not vectors\\n if X.ndim > 1:\\n X = X.flatten()\\n Y = Y.flatten()\\n \\n if (bin_edges == None).all():\\n X_min = np.nanmin(X)\\n X_max = np.nanmax(X)\\n bin_edges = np.linspace(X_min,X_max,num=10)\\n \\n \\n which_bin = np.digitize(X,bin_edges)\\n Nbins = len(bin_edges)-1\\n means = np.zeros(Nbins)\\n stds = np.zeros(Nbins)\\n bin_centers = np.zeros(Nbins)\\n for b in range(Nbins):\\n y = Y[which_bin == b+1]\\n bin_centers[b] = (bin_edges[b] + bin_edges[b+1]) / 2\\n # Suppress noisy bins\\n if len(y) < minimum_n:\\n means[b] = np.nan\\n stds[b] = np.nan\\n else:\\n # Mean or median\\n if mean == 'mean':\\n means[b] = np.nanmean(y)\\n elif mean == 'median':\\n means[b] = np.nanmedian(y)\\n \\n if error == 'sem':\\n stds[b] = np.nanstd(y) / np.sqrt(len(y))\\n elif error == 'std':\\n stds[b] = np.nanstd(y)\\n \\n return means\",\n \"def test_Bin(self):\\n\\n outcome_three = Outcome(\\\"00-0-1-2-3\\\", 6 )\\n outcome_four = Outcome(\\\"D\\\", 2)\\n outcome_five = Outcome(\\\"E\\\", 3)\\n outcome_six = Outcome(\\\"F\\\", 4)\\n\\n bin_one = Bin(outcome_three, outcome_four)\\n print 'what is bin one?: ', bin_one\\n bin_two = Bin(outcome_five, outcome_six)\\n print 'what is bin two?: ', bin_two\",\n \"def _binoms(kernel_size):\\n if kernel_size > 1:\\n curr_kernel = BASE_KERNEL\\n for i in range(2, kernel_size):\\n curr_kernel = np.convolve(curr_kernel, BASE_KERNEL)\\n return curr_kernel\\n return np.array([1])\",\n \"def to_bins(arr):\\n result = np.zeros(len(arr)+1)\\n result[1:-1] = 0.5 * (arr[1:] + arr[:-1])\\n result[0] = arr[0] - 0.5*(arr[1] - arr[0])\\n result[-1] = arr[-1] + 0.5*(arr[-1] - arr[-2])\\n return result\",\n \"def filter_binaries_beamprofile(bin_arr, beamprofile, cutoff=0.75, dilate=0):\\r\\n bp_bool = beamprofile < cutoff * beamprofile.max()\\r\\n out_binary = np.empty_like(bin_arr, dtype=int)\\r\\n total_cells = 0\\r\\n removed_cells = 0\\r\\n\\r\\n for i, img in enumerate(bin_arr):\\r\\n labeled, n = mh.labeled.label(img)\\r\\n total_cells += n\\r\\n for l in np.unique(labeled)[1:]:\\r\\n selected_binary = multi_dilate(labeled == l, dilate)\\r\\n if np.any(np.logical_and(selected_binary, bp_bool)): # Cell lies outside of\\r\\n labeled[labeled == l] = 0\\r\\n removed_cells += 1\\r\\n out_binary[i] = labeled\\r\\n print('Removed {} cells out of a total of {} cells.'.format(removed_cells, total_cells))\\r\\n return out_binary\",\n \"def bin_statistics(data,bin_against,bin_edges,data_signal=[]):\\n\\n assert isinstance(data, pd.DataFrame), 'data must be of type pd.DataFram' \\n try: bin_against = np.asarray(bin_against) \\n except: 'bin_against must be of type np.ndarray'\\n try: bin_edges = np.asarray(bin_edges)\\n except: 'bin_edges must be of type np.ndarray' \\n\\n # Determine variables to analyze\\n if len(data_signal)==0: # if not specified, bin all variables\\n data_signal=data.columns.values\\n else:\\n assert isinstance(data_signal, list), 'must be of type list'\\n\\n # Pre-allocate list variables\\n bin_stat_list = []\\n bin_std_list = []\\n\\n # loop through data_signal and get binned means\\n for signal_name in data_signal:\\n # Bin data\\n bin_stat = binned_statistic(bin_against,data[signal_name],\\n statistic='mean',bins=bin_edges)\\n # Calculate std of bins\\n std = []\\n stdev = pd.DataFrame(data[signal_name])\\n stdev.set_index(bin_stat.binnumber,inplace=True)\\n for i in range(1,len(bin_stat.bin_edges)):\\n try:\\n temp = stdev.loc[i].std(ddof=0)\\n std.append(temp[0])\\n except:\\n std.append(np.nan)\\n bin_stat_list.append(bin_stat.statistic)\\n bin_std_list.append(std)\\n \\n # Convert to DataFrames\\n bin_mean = pd.DataFrame(np.transpose(bin_stat_list),columns=data_signal)\\n bin_std = pd.DataFrame(np.transpose(bin_std_list),columns=data_signal)\\n\\n # Check for nans \\n if bin_mean.isna().any().any():\\n print('Warning: some bins may be empty!')\\n\\n return bin_mean, bin_std\",\n \"def bin_data(bins, data2bin, bindata, mode='mean', nbinned=False):\\n assert mode in ['mean', 'median', 'std', 'max', 'min'], \\\"mode not recognized: {}\\\".format(mode)\\n digitized = np.digitize(bindata, bins)\\n binned = np.zeros(len(bins)) * np.nan\\n if nbinned: \\n numbinned = np.zeros(len(bins))\\n\\n if mode == 'mean':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmean(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'median':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmedian(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'std':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanstd(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'max':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmax(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n elif mode == 'min':\\n for i, _ in enumerate(bins):\\n binned[i] = np.nanmin(data2bin[np.logical_and(np.isfinite(bindata), digitized == i+1)])\\n if nbinned:\\n numbinned[i] = np.count_nonzero(np.logical_and(np.isfinite(data2bin), digitized == i+1))\\n else:\\n raise ValueError('mode must be mean, median, std, max, or min')\\n \\n if nbinned:\\n return np.array(binned), np.array(numbinned)\\n else:\\n return np.array(binned)\",\n \"def get_bin_index(self, filter_bin):\\n\\n left_index = self.left_filter.get_bin_index(filter_bin[0])\\n right_index = self.right_filter.get_bin_index(filter_bin[0])\\n filter_index = left_index * self.right_filter.num_bins + right_index\\n return filter_index\",\n \"def get_bin_index(self, filter_bin):\\n\\n left_index = self.left_filter.get_bin_index(filter_bin[0])\\n right_index = self.right_filter.get_bin_index(filter_bin[0])\\n filter_index = left_index * self.right_filter.num_bins + right_index\\n return filter_index\",\n \"def compute_bb(self):\\n all_shapes = list(self.parts.values()) + list(self.edges.values())\\n bbox_vertices = cascaded_union(all_shapes).envelope.exterior.coords.xy\\n min_x = min(bbox_vertices[0])\\n max_x = max(bbox_vertices[0])\\n min_y = min(bbox_vertices[1])\\n max_y = max(bbox_vertices[1])\\n return [min_x, max_x,min_y, max_y]\",\n \"def createBinsByEntropy(self, data, structure, colName, numOfBins):\\n splits = self.miningCalculator.getBestSplitsInDataByInfoGain(data, structure, colName, numOfBins-1)\\n splits.sort()\\n bins = {\\\"value<=\\\"+str(splits[0]): lambda x: x <= splits[0]}\\n if len(splits) > 1:\\n for i in range(1, numOfBins-1):\\n bins[str(splits[i-1]) + '<value<=' + str(splits[i])] = (lambda x: splits[i-1] < x <= splits[i])\\n bins[\\\"value>\\\" + str(splits[len(splits)-1])] = (lambda x: x > splits[len(splits)-1])\\n return bins\",\n \"def filter_binaries(bin_arr, remove_bordering=True, min_size=None, max_size=None, min_minor=None, max_minor=None,\\r\\n min_major=None, max_major=None):\\r\\n\\r\\n out = np.empty_like(bin_arr)\\r\\n for i, img in enumerate(bin_arr):\\r\\n if len(np.unique(img)) > 2: # Image is already labeled\\r\\n labeled = img\\r\\n else:\\r\\n labeled, n = mh.labeled.label(img)\\r\\n labeled, n = mh.labeled.filter_labeled(labeled, remove_bordering=remove_bordering, min_size=min_size, max_size=max_size)\\r\\n out[i] = (labeled > 0).astype(int) * labeled # Restore labels\\r\\n\\r\\n for j, img in enumerate(out):\\r\\n for i in np.unique(img)[1:]:\\r\\n selected_binary = (img == i).astype('int')\\r\\n min1, max1, min2, max2 = mh.bbox(selected_binary)\\r\\n selection = selected_binary[min1:max1, min2:max2]\\r\\n major, minor = mh.features.ellipse_axes(selection)\\r\\n\\r\\n if min_minor and minor < min_minor:\\r\\n img[img == i] = 0\\r\\n if max_minor and minor > max_minor:\\r\\n img[img == i] = 0\\r\\n if min_major and major < min_major:\\r\\n img[img == i] = 0\\r\\n if max_major and major > max_major:\\r\\n img[img == i] = 0\\r\\n\\r\\n return out\",\n \"def test_bins(self):\\n\\n for filename in ['%s/population_padang_1.asc' % TESTDATA,\\n '%s/test_grid.asc' % TESTDATA]:\\n\\n R = read_layer(filename)\\n rmin, rmax = R.get_extrema()\\n\\n for N in [2, 3, 5, 7, 10, 16]:\\n linear_intervals = R.get_bins(N=N, quantiles=False)\\n\\n assert linear_intervals[0] == rmin\\n assert linear_intervals[-1] == rmax\\n\\n d = (rmax - rmin) / N\\n for i in range(N):\\n assert numpy.allclose(linear_intervals[i], rmin + i * d)\\n\\n quantiles = R.get_bins(N=N, quantiles=True)\\n A = R.get_data(nan=True).flat[:]\\n\\n mask = numpy.logical_not(numpy.isnan(A)) # Omit NaN's\\n l1 = len(A)\\n A = A.compress(mask)\\n l2 = len(A)\\n\\n if filename == '%s/test_grid.asc' % TESTDATA:\\n # Check that NaN's were removed\\n assert l1 == 35\\n assert l2 == 30\\n\\n # Assert that there are no NaN's\\n assert not numpy.alltrue(numpy.isnan(A))\\n\\n number_of_elements = len(A)\\n average_elements_per_bin = number_of_elements / N\\n\\n # Count elements in each bin and check\\n i0 = quantiles[0]\\n for i1 in quantiles[1:]:\\n count = numpy.sum((i0 < A) & (A < i1))\\n if i0 == quantiles[0]:\\n refcount = count\\n\\n if i1 < quantiles[-1]:\\n # Number of elements in each bin must vary by no\\n # more than 1\\n assert abs(count - refcount) <= 1\\n assert abs(count - average_elements_per_bin) <= 3\\n else:\\n # The last bin is allowed vary by more\\n pass\\n\\n i0 = i1\",\n \"def compute_bin_efficiencies(y_score, bin_indices, cut, sample_weight, minlength=None):\\n y_score = column_or_1d(y_score)\\n assert len(y_score) == len(sample_weight) == len(bin_indices), \\\"different size\\\"\\n if minlength is None:\\n minlength = numpy.max(bin_indices) + 1\\n\\n bin_total = numpy.bincount(bin_indices, weights=sample_weight, minlength=minlength)\\n passed_cut = y_score > cut\\n bin_passed_cut = numpy.bincount(bin_indices[passed_cut],\\n weights=sample_weight[passed_cut], minlength=minlength)\\n return bin_passed_cut / numpy.maximum(bin_total, 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7028389","0.69049263","0.68282115","0.6756274","0.65525955","0.6534234","0.6517673","0.65156","0.6511489","0.6493547","0.6453416","0.63842267","0.630369","0.6285076","0.62552357","0.62531275","0.6207189","0.6184054","0.6180757","0.61535704","0.61472905","0.61317474","0.6117792","0.6092234","0.60255945","0.59861904","0.5981901","0.59649616","0.59354675","0.5932195","0.5905469","0.5842088","0.5828209","0.5804458","0.5792083","0.5789896","0.575374","0.5748606","0.5740341","0.57381374","0.5737257","0.5735844","0.57312286","0.57095677","0.57010794","0.56960064","0.5691151","0.5687027","0.5680992","0.56681645","0.56649","0.56646186","0.5659573","0.56416947","0.56416684","0.5633486","0.5629551","0.56012934","0.55789465","0.55645484","0.5564454","0.55463433","0.55198586","0.55178976","0.5495198","0.5492061","0.5470556","0.54694444","0.54563844","0.54544556","0.5444149","0.5438115","0.541533","0.5405104","0.54009694","0.5398532","0.53853047","0.5380422","0.537311","0.53667367","0.53572166","0.5345539","0.53425616","0.5341545","0.534109","0.5329469","0.5325073","0.53208125","0.53199625","0.5319453","0.52922046","0.5286837","0.52820027","0.5279666","0.5279666","0.52767116","0.52578336","0.5249415","0.524326","0.5242155"],"string":"[\n \"0.7028389\",\n \"0.69049263\",\n \"0.68282115\",\n \"0.6756274\",\n \"0.65525955\",\n \"0.6534234\",\n \"0.6517673\",\n \"0.65156\",\n \"0.6511489\",\n \"0.6493547\",\n \"0.6453416\",\n \"0.63842267\",\n \"0.630369\",\n \"0.6285076\",\n \"0.62552357\",\n \"0.62531275\",\n \"0.6207189\",\n \"0.6184054\",\n \"0.6180757\",\n \"0.61535704\",\n \"0.61472905\",\n \"0.61317474\",\n \"0.6117792\",\n \"0.6092234\",\n \"0.60255945\",\n \"0.59861904\",\n \"0.5981901\",\n \"0.59649616\",\n \"0.59354675\",\n \"0.5932195\",\n \"0.5905469\",\n \"0.5842088\",\n \"0.5828209\",\n \"0.5804458\",\n \"0.5792083\",\n \"0.5789896\",\n \"0.575374\",\n \"0.5748606\",\n \"0.5740341\",\n \"0.57381374\",\n \"0.5737257\",\n \"0.5735844\",\n \"0.57312286\",\n \"0.57095677\",\n \"0.57010794\",\n \"0.56960064\",\n \"0.5691151\",\n \"0.5687027\",\n \"0.5680992\",\n \"0.56681645\",\n \"0.56649\",\n \"0.56646186\",\n \"0.5659573\",\n \"0.56416947\",\n \"0.56416684\",\n \"0.5633486\",\n \"0.5629551\",\n \"0.56012934\",\n \"0.55789465\",\n \"0.55645484\",\n \"0.5564454\",\n \"0.55463433\",\n \"0.55198586\",\n \"0.55178976\",\n \"0.5495198\",\n \"0.5492061\",\n \"0.5470556\",\n \"0.54694444\",\n \"0.54563844\",\n \"0.54544556\",\n \"0.5444149\",\n \"0.5438115\",\n \"0.541533\",\n \"0.5405104\",\n \"0.54009694\",\n \"0.5398532\",\n \"0.53853047\",\n \"0.5380422\",\n \"0.537311\",\n \"0.53667367\",\n \"0.53572166\",\n \"0.5345539\",\n \"0.53425616\",\n \"0.5341545\",\n \"0.534109\",\n \"0.5329469\",\n \"0.5325073\",\n \"0.53208125\",\n \"0.53199625\",\n \"0.5319453\",\n \"0.52922046\",\n \"0.5286837\",\n \"0.52820027\",\n \"0.5279666\",\n \"0.5279666\",\n \"0.52767116\",\n \"0.52578336\",\n \"0.5249415\",\n \"0.524326\",\n \"0.5242155\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6405554"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":3388,"cells":{"query":{"kind":"string","value":"Shannon Entropy Calculates the Shannon Entropy for the given data array x."},"document":{"kind":"string","value":"def entropy(x, bins, normalize=False, xy_probabilities=False):\n # calculate probabilities if xy_probabilities == False\n if xy_probabilities:\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n \n # add a small number to all probabilities if zero occurs\n if x.any(0):\n p = x + 1e-15\n else:\n p = x\n else:\n # get the bins\n bins = np.histogram_bin_edges(x, bins)\n\n # calculate the empirical probabilities\n count = np.histogram(x, bins=bins)[0]\n\n # if counts should be None, raise an error\n if np.sum(count) == 0:\n raise ValueError('The histogram cannot be empty. Adjust the bins to ' +\n 'fit the data')\n # calculate the probabilities\n p = (count / np.sum(count)) + 1e-15\n\n\n # calculate the Shannon Entropy\n if normalize:\n # get number of bins\n nbins = len(p)\n # maximal entropy: uniform distribution\n normalizer = np.log2(nbins) \n\n return - p.dot(np.log2(p)) / normalizer\n else:\n return - p.dot(np.log2(p))"},"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 ShannonEntropy(self,s):\n e = s[np.nonzero(s)]**2 * np.log(s[np.nonzero(s)]**2)\n return np.sum(e)","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def H(self, data):\n entropy = 0\n\n if not data:\n return entropy\n\n for x in range(256):\n p_x = float(data.count(chr(x))) / len(data)\n if p_x > 0:\n entropy -= p_x * math.log(p_x, 2)\n\n return entropy","def salomonfcn(x: np.ndarray) -> np.ndarray:\n x2 = x**2\n sumx2 = np.sum(x2, axis=1)\n sqrtsx2 = np.sqrt(sumx2)\n\n scores = 1 - np.cos(2 * np.pi * sqrtsx2) + (0.1 * sqrtsx2)\n\n return scores","def shannon_entropy(ps: np.ndarray, base: int = 2) -> float:\n\n return -np.sum(ps * np.log(ps) / np.log(base))","def shannon_entropy(c):\n\n c_normalized = c / float(np.sum(c))\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\n return entropy","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def shannon_entropy(counts):\n freq = np.array(counts) * 1.0 / np.sum(counts)\n return -np.sum([f * np.log2(f) for f in freq if f != 0])","def shannon_entropy(probs):\n return -(\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\n )","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def entropy(data):\n n, m = np.shape(data)\n data = np.tanh(data)\n data = data / np.sum(data, axis=0)\n a = data * 1.0\n a[np.where(data == 0)] = 0.000001\n\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\n w = (1 - e) / np.sum(1 - e)\n return w","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def shannon(counts, base=2):\n freqs = counts/float(counts.sum())\n nonzero_freqs = freqs[freqs.nonzero()]\n return -sum(nonzero_freqs*log(nonzero_freqs))/log(base)","def entropy(self, X):\n if isinstance(X, np.ndarray):\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\n K = self._posterior_covariance(X)\n L = np.linalg.cholesky(K)\n D = len(X)\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))","def hx(self, x):\n yp = np.sqrt(x[0] ** 2 + x[2] ** 2)\n return yp","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def xinsheyangn1fcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n scores = np.zeros((x.shape[0], 1))\n for i in range(n):\n scores += np.random.rand() * np.abs(x[:, i]) ** i\n return scores","def xinsheyangn4fcn(x: np.ndarray) -> np.ndarray:\n scores = (\n np.sum(np.sin(x) ** 2, axis=1) - np.exp(-np.sum(x**2, axis=1))\n ) * np.exp(-np.sum(np.sin(np.sqrt(np.abs(x))) ** 2, axis=1))\n return scores","def xinsheyangn2fcn(x: np.ndarray) -> np.ndarray:\n scores = np.sum(np.abs(x), axis=1) * np.exp(-np.sum(np.sin(x**2), axis=1))\n return scores","def shubertfcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n scores = np.ones((x.shape[0], 1))\n\n for i in range(n):\n inner_sum = 0\n for j in range(1, 6):\n inner_sum += j * np.cos((j + 1) * x[:, i] + j)\n scores *= inner_sum.reshape(-1, 1)\n\n return scores","def arcosh(x):\n return torch.log(x+torch.sqrt(x*x - 1))","def acosh(x):\n return math.log(x+math.sqrt(x*x-1))","def test_shannon(self):\n c = array([5])\n self.assertFloatEqual(shannon(c), 0)\n c = array([5,5])\n self.assertFloatEqual(shannon(c), 1)\n c = array([1,1,1,1,0])\n self.assertEqual(shannon(c), 2)","def entropy(self, base: int = None):\n\n # shannon entropy in nats\n fdist_ = self.fdist\n fdist_[\"prob\"] = fdist_[\"freq\"] / fdist_[\"freq\"].sum()\n fdist_[\"logp\"] = np.log(fdist_[\"prob\"])\n fdist_[\"nats\"] = -fdist_[\"prob\"] * fdist_[\"logp\"]\n entropy_ = fdist_[\"nats\"].sum()\n\n # convert base\n if base:\n entropy_ = entropy_ / np.log(base)\n\n # return\n return entropy_","def computeJensenShanon(sequence, frames_first):\n \n sequence = np.asarray(sequence)\n \n assert sequence.ndim == 3 or sequence.ndim == 2\n \n \n JS = JensenShanon_()\n \n overlay, _ = fromSequenceToOverlay(sequence,\n frames_first=frames_first,\n apply_standardization=True)\n \n return JS.fit(overlay).entropy","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def H_complicated(x):\n _ = x**2\n _[0] += np.sin(2*x[1]*x[0])\n _[1] += -3*x[0]**3 + np.log(np.abs(x[0]))\n return _","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def logistic(mu, hw, x): \n n = np.exp(- ((x-mu)/(.477*hw))**2)\n return (2. * n)/( 1 + n)","def schaffer(self, x):\r\n N = len(x);\r\n s = x[0:N-1]**2 + x[1:N]**2;\r\n return sum(s**0.25 * (np.sin(50*s**0.1)**2 + 1))","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def spherew(self, x):\r\n # return np.random.rand(1)[0]**0 * sum(x**2) + 1 * np.random.rand(1)[0]\r\n # s = sum(abs(x))\r\n # return sum((x/s+0)**2) - 1/len(x)\r\n # return sum((x/s)**2) - 1/len(x)\r\n return -0.01*x[0] + abs(x[0])**-2 * sum(x[1:]**2)","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def get_hess(self, x: np.ndarray) -> np.ndarray:\n hess = self(x, (2,), MODE_FUN)\n return hess","def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def entropy(s):\n p, lns = Counter(s), float(len(s))\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())","def shannon(state_space):\n if isinstance(state_space, int) or len(state_space) == 1:\n return 0\n ws = sum(state_space.values())\n if ws == 0:\n print(state_space)\n return math.log(ws) - sum(map(lambda x: x * math.log(x), state_space.values())) / ws","def schwefelfcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n scores = 418.9829 * n - np.sum(x * np.sin(np.sqrt(np.abs(x))), axis=1)\n return scores","def hessian(self, x):\n h = self._hess(\n time_series=self.observed_data,\n a=x[0],\n b=x[1],\n c=x[2],\n sigma=self.sigma\n )\n return h","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def shubert4fcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n\n scores = np.zeros((x.shape[0], 1))\n for i in range(n):\n for j in range(5):\n scores += np.cos(((j + 1) * x[:, i]) + j)\n\n return scores","def entropy(self, params):\n log_std = params[:, :, 1]\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)","def h(x):\n return torch.sin(3 * x) + 4.","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def vectorized_hessp(self, x, p):\n primals = self.vectorizer.unpack(x)\n tangents = self.vectorizer.unpack(p)\n hp_arrays = self.handler.hessp(primals, tangents)\n self._n += 1\n self.losses.append(self.loss)\n self._maybe_update_pbar()\n return self.vectorizer.pack(hp_arrays, \"hp\")","def stoch(x):\n return x/np.sum(x)","def entropy(self):\n Z = self.sum()\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\n H = 0.0\n for x in np.nditer(self.t, op_flags=['readonly']):\n p = x/Z\n H += 0.0 if p==0 else -p*np.log(p)\n return H","def exploitEntropy(self, position):\n pass","def cosh(x):\n raise NotImplementedError","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def h(x):\n\n hasher = hashlib.sha256()\n hasher.update(x)\n return hasher.digest()","def easomfcn(x: np.ndarray) -> np.ndarray:\n\n n = x.shape[1]\n assert n == 2, \"The Easom's function is only defined on a 2D space.\"\n X = x[:, 0]\n Y = x[:, 1]\n\n scores = (\n -np.cos(X) * np.cos(Y) * np.exp(-((X - np.pi) ** 2 + (Y - np.pi) ** 2))\n )\n return scores","def hann(self, _x):\n N = self.N\n return (1 - np.cos(2 * np.pi * _x / (N - 1))) / 2","def Hamming(data):\r\n N=float(data.shape[0])\r\n temp=np.zeros(data.shape[0])\r\n for u, i in enumerate(data):\r\n temp[u]=(0.54-0.46*np.cos(2*np.pi*(u/N)))*i\r\n return temp","def h(x):\n h = -x*np.math.log(x, 2) - (1 - x)*np.math.log(1 - x, 2)\n return h","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def hessian(f, x, s=_DEFAULT_STEP):\n x = np.asarray(x)\n n = len(x)\n e = s * np.eye(n)\n\n forw1 = np.zeros(n)\n forw2 = np.zeros((n, n))\n for i in range(n):\n forw1[i] = f(x + e[i])\n for j in range(i, n):\n forw2[i, j] = forw2[j, i] = f(x + e[i] + e[j])\n\n H = (forw2 - _colvec(forw1) - _rowvec(forw1) + f(x)) / s**2\n return H","def heavi(x):\n return 0.5 * (np.sign(x) + 1)","def div(self):\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\n entropies = [i * math.log(i, 2) for i in freqList]\n entropy = -sum(entropies)\n return entropy","def entropy(data, idxList):\n df = data.loc[idxList]\n counts = df.value_counts().to_numpy()\n counts = counts.reshape(1, -1).astype(np.float32)\n counts /= np.sum(counts)\n log_sum = counts @ np.log2(counts.T)\n return -log_sum[0, 0]","def f(self, x: np.array) -> np.array:\n return (1/np.sqrt(2*np.pi*self.sig**2))*np.exp(-1*((x - self.mu)**2/(2*self.sig**2)))","def shubert3fcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n scores = np.zeros((x.shape[0], 1))\n for i in range(n):\n for j in range(1, 6):\n scores += j * np.sin(((j + 1) * x[:, i]) + j)\n return scores","def entropycell(self):\n cells = [0] * self.k\n for i in range(self.width):\n cells[int(self.config[self.t, i])] += 1\n\n \"\"\"Calculates the Shannon entropy and the the average entropy so far.\"\"\"\n shannon = 0\n for i in range(self.k):\n if(cells[i] != 0):\n probability = cells[i] / self.width\n shannon -= probability * np.log2(probability)\n self.average_cell = (self.average_cell * self.t + shannon) / (self.t + 1)","def entropy ( target_array ):\n return -1 * sum (\n [\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\n for value in set ( target_array )\n ]\n ) # End entropy()","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def var(x):\n length = len(x)\n\n if length == 0:\n return None\n result = 0.0\n m = TinyStatistician.mean(x)\n for i in x:\n result += (i - m) ** 2\n\n return result / length","def gen_psi(self, x):\n\n if isinstance(x, jnp.ndarray):\n x = x[:, None]\n return jnp.exp(-self.h * (x - self.c) ** 2)","def test_heip_e(self):\n c = array([1,2,3,1])\n h = shannon(c, base=e)\n expected = exp(h-1)/3\n self.assertEqual(heip_e(c), expected)","def r_soft_hash(x):\n if abs(x) < 1e-9:return 0\n # round it to some number of bits\n b = ns.round(ns.log(abs(x)) / ns.log(2))\n gran = 2**(b-30)\n return ns.round(x / gran) * gran","def _ss(data):\n c = sum(data)/len(data)\n ss = sum((x-c)**2 for x in data)\n return ss","def hx(self, xhat):\n zp = np.sqrt(xhat[0] ** 2 + xhat[2] ** 2)\n return zp","def psi(n, x):\n H = h(n, x, orthonormal=True)\n weight = np.exp(-(x ** 2) / 2)\n psi = H * weight\n return psi","def f(x):\n res = np.real(np.exp(-1j*x[1])*sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1))) \n res = -res/np.sqrt(2*sample_size+1) \n return res","def species_irreplaceability(x):\n x = x*100\n\n def h(x):\n # h(x) as specified\n miu = 39\n s = 9.5\n tmp = -(x - miu)/ s\n denominator = 1 + np.exp(tmp)\n return 1/denominator\n \n\n return (h(x) - h(0))/(h(100) - h(0))","def sinh(x):\n raise NotImplementedError","def equitability(counts, base=2):\n return shannon(counts, base)/(log((counts!=0).sum())/log(base))","def entropy(self, priors=None):\n def entropy_f(x):\n x[x != 0] *= np.log(x[x != 0])\n return -x.sum(axis=0)\n return self.utility(entropy_f, priors)","def chi(self, theta):\n yf = self.predict(self.t, theta)\n sse = np.sum(np.square((yf - self.y) / self.dy))\n return sse","def __value(t,N):\n _,hist=np.unique(t, return_counts=True)\n hist=list(hist)\n hist.append(N-np.sum(hist))\n return EntropyD(np.array(hist))","def acosh(x):\n return 0.0","def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])","def entropy(self):\n ent = 0.0\n for f in self.byte_freq:\n if f > 0:\n freq = float(f) / self.byte_total\n ent = ent + freq * math.log(freq, 2)\n return -ent","def manual_log_like_normal(x, data):\n return np.sum(-np.log(x[1] * np.sqrt(2 * np.pi))-((data-x[0])**2) / (2*x[1]**2))","def compute_energy(x, input_HP_sequence):\n # add code here, feel free to change the argument list\n # Given a input HP sequence, we already which points are H's.\n return U","def h(self, X):\n if isinstance(X, int) or isinstance(X, float):\n if X < 1:\n x = max(0.001, X)\n a = np.log(x/2.)**2 - np.arccosh(1./x)**2\n elif X >= 1:\n a = np.log(X/2.)**2 + np.arccos(1./X)**2\n else:\n a=np.empty_like(X)\n X[X==0] = 0.001\n x = X[(X<1) & (X>0)]\n a[(X<1) & (X>0)] = np.log(x/2.)**2 - np.arccosh(1./x)**2\n x = X[X >= 1]\n a[X >= 1] = np.log(x/2.)**2 + np.arccos(1./x)**2\n return a","def h_function(self, x, xsquare):\n return invert(self.l_function(powmod(self.public_key.g, x - 1, xsquare),x), x)","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def toy_hamiltonian(x):\n q,p = extract_q_p(x)\n pSqr = tf.square(p)\n return 1/2 * tf.square(q - 1/4 * pSqr) + 1/32 * pSqr","def shannons(data):\n \n from math import log as ln\n\n # from IPython.core.debugger import Tracer\n # Tracer()()\n \n def p(n, N):\n \"\"\" Relative abundance \"\"\"\n if n is 0:\n return 0\n else:\n return (float(n)/N) * ln(float(n)/N)\n \n N = sum(data)\n \n return -sum(p(n, N) for n in data if not n == 0)","def density(self, x):\n\t\tN = len(self.train_data)\n\t\tpoints = list(self.train_data)\n\t\tdists = [np.linalg.norm(x-point)**2 for point in points]\n\t\texps = [np.exp(-dist / (2 * (self.bandwidth ** 2))) for dist in dists]\n\t\tunnormalized_sum = sum(exps)\n\t\tprobability = (1 / N) * self.normalizing_constant() * unnormalized_sum\n\t\treturn probability","def hash_numpy(x: numpy.ndarray) -> int:\n x = x.astype(\"|S576\") if x.dtype == \"O\" else x\n return xxhash.xxh64_hexdigest(x.tobytes())","def entropy(a):\n a = a.upper()\n\n freq = collections.defaultdict(int) # int() is the default constructor for non existent item, and returns 0\n for c in a:\n freq[c] = freq[c] + 1\n\n e = 0.0\n for f in freq.values():\n if f:\n p = f / len(a)\n e += p * math.log(p)\n\n return -e","def f(x):\n res = np.real(np.exp(-1j*x[1])*\\\n sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1))) \n res = -res/np.sqrt(2*sample_size+1) \n return res","def hash_function(self, x):\n if not x:\n return -1\n hashed_value = 0\n\n for char in x:\n hashed_value = 181 * hashed_value + ord(char)\n\n return hashed_value % self.capacity","def jensen_shannon(x, y, bins, calc_distance=False, xy_probabilities=False):\n # assert array length\n assert len(x) == len(y)\n\n if xy_probabilities:\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x), 1 ,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y), 1, atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n \n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n # calculate probabilities\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n # calculate m\n pm = 0.5 * (px + py)\n\n # calculate kullback-leibler divergence between px and pm & py and pm\n kl_xm = kullback_leibler(px, pm, bins=bins, xy_probabilities=True)\n kl_ym = kullback_leibler(py, pm, bins=bins, xy_probabilities=True)\n \n if calc_distance:\n return (0.5 * kl_xm + 0.5 * kl_ym)**0.5\n else:\n return (0.5 * kl_xm + 0.5 * kl_ym)","def evenness(df):\n obs = shannon(df)\n count = df.shape[0]\n max_freq = 1.0 / count\n max_vector = np.repeat(max_freq,count)\n pre = -(sum(max_vector * np.log(max_vector)))\n return obs / pre","def jeffreys(self, x):\n return np.sqrt(1. / x)","def entropy(message):\n n = len(message)\n message = letter_freq(message)\n h = 0\n for n_i in message.values():\n p_i = n_i/n\n h += -p_i*(log2(p_i))\n return h"],"string":"[\n \"def ShannonEntropy(self,s):\\n e = s[np.nonzero(s)]**2 * np.log(s[np.nonzero(s)]**2)\\n return np.sum(e)\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def H(self, data):\\n entropy = 0\\n\\n if not data:\\n return entropy\\n\\n for x in range(256):\\n p_x = float(data.count(chr(x))) / len(data)\\n if p_x > 0:\\n entropy -= p_x * math.log(p_x, 2)\\n\\n return entropy\",\n \"def salomonfcn(x: np.ndarray) -> np.ndarray:\\n x2 = x**2\\n sumx2 = np.sum(x2, axis=1)\\n sqrtsx2 = np.sqrt(sumx2)\\n\\n scores = 1 - np.cos(2 * np.pi * sqrtsx2) + (0.1 * sqrtsx2)\\n\\n return scores\",\n \"def shannon_entropy(ps: np.ndarray, base: int = 2) -> float:\\n\\n return -np.sum(ps * np.log(ps) / np.log(base))\",\n \"def shannon_entropy(c):\\n\\n c_normalized = c / float(np.sum(c))\\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\\n return entropy\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def shannon_entropy(counts):\\n freq = np.array(counts) * 1.0 / np.sum(counts)\\n return -np.sum([f * np.log2(f) for f in freq if f != 0])\",\n \"def shannon_entropy(probs):\\n return -(\\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\\n )\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def entropy(data):\\n n, m = np.shape(data)\\n data = np.tanh(data)\\n data = data / np.sum(data, axis=0)\\n a = data * 1.0\\n a[np.where(data == 0)] = 0.000001\\n\\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\\n w = (1 - e) / np.sum(1 - e)\\n return w\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def shannon(counts, base=2):\\n freqs = counts/float(counts.sum())\\n nonzero_freqs = freqs[freqs.nonzero()]\\n return -sum(nonzero_freqs*log(nonzero_freqs))/log(base)\",\n \"def entropy(self, X):\\n if isinstance(X, np.ndarray):\\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\\n K = self._posterior_covariance(X)\\n L = np.linalg.cholesky(K)\\n D = len(X)\\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))\",\n \"def hx(self, x):\\n yp = np.sqrt(x[0] ** 2 + x[2] ** 2)\\n return yp\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def xinsheyangn1fcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n scores = np.zeros((x.shape[0], 1))\\n for i in range(n):\\n scores += np.random.rand() * np.abs(x[:, i]) ** i\\n return scores\",\n \"def xinsheyangn4fcn(x: np.ndarray) -> np.ndarray:\\n scores = (\\n np.sum(np.sin(x) ** 2, axis=1) - np.exp(-np.sum(x**2, axis=1))\\n ) * np.exp(-np.sum(np.sin(np.sqrt(np.abs(x))) ** 2, axis=1))\\n return scores\",\n \"def xinsheyangn2fcn(x: np.ndarray) -> np.ndarray:\\n scores = np.sum(np.abs(x), axis=1) * np.exp(-np.sum(np.sin(x**2), axis=1))\\n return scores\",\n \"def shubertfcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n scores = np.ones((x.shape[0], 1))\\n\\n for i in range(n):\\n inner_sum = 0\\n for j in range(1, 6):\\n inner_sum += j * np.cos((j + 1) * x[:, i] + j)\\n scores *= inner_sum.reshape(-1, 1)\\n\\n return scores\",\n \"def arcosh(x):\\n return torch.log(x+torch.sqrt(x*x - 1))\",\n \"def acosh(x):\\n return math.log(x+math.sqrt(x*x-1))\",\n \"def test_shannon(self):\\n c = array([5])\\n self.assertFloatEqual(shannon(c), 0)\\n c = array([5,5])\\n self.assertFloatEqual(shannon(c), 1)\\n c = array([1,1,1,1,0])\\n self.assertEqual(shannon(c), 2)\",\n \"def entropy(self, base: int = None):\\n\\n # shannon entropy in nats\\n fdist_ = self.fdist\\n fdist_[\\\"prob\\\"] = fdist_[\\\"freq\\\"] / fdist_[\\\"freq\\\"].sum()\\n fdist_[\\\"logp\\\"] = np.log(fdist_[\\\"prob\\\"])\\n fdist_[\\\"nats\\\"] = -fdist_[\\\"prob\\\"] * fdist_[\\\"logp\\\"]\\n entropy_ = fdist_[\\\"nats\\\"].sum()\\n\\n # convert base\\n if base:\\n entropy_ = entropy_ / np.log(base)\\n\\n # return\\n return entropy_\",\n \"def computeJensenShanon(sequence, frames_first):\\n \\n sequence = np.asarray(sequence)\\n \\n assert sequence.ndim == 3 or sequence.ndim == 2\\n \\n \\n JS = JensenShanon_()\\n \\n overlay, _ = fromSequenceToOverlay(sequence,\\n frames_first=frames_first,\\n apply_standardization=True)\\n \\n return JS.fit(overlay).entropy\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def H_complicated(x):\\n _ = x**2\\n _[0] += np.sin(2*x[1]*x[0])\\n _[1] += -3*x[0]**3 + np.log(np.abs(x[0]))\\n return _\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def logistic(mu, hw, x): \\n n = np.exp(- ((x-mu)/(.477*hw))**2)\\n return (2. * n)/( 1 + n)\",\n \"def schaffer(self, x):\\r\\n N = len(x);\\r\\n s = x[0:N-1]**2 + x[1:N]**2;\\r\\n return sum(s**0.25 * (np.sin(50*s**0.1)**2 + 1))\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def spherew(self, x):\\r\\n # return np.random.rand(1)[0]**0 * sum(x**2) + 1 * np.random.rand(1)[0]\\r\\n # s = sum(abs(x))\\r\\n # return sum((x/s+0)**2) - 1/len(x)\\r\\n # return sum((x/s)**2) - 1/len(x)\\r\\n return -0.01*x[0] + abs(x[0])**-2 * sum(x[1:]**2)\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def get_hess(self, x: np.ndarray) -> np.ndarray:\\n hess = self(x, (2,), MODE_FUN)\\n return hess\",\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(s):\\n p, lns = Counter(s), float(len(s))\\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def shannon(state_space):\\n if isinstance(state_space, int) or len(state_space) == 1:\\n return 0\\n ws = sum(state_space.values())\\n if ws == 0:\\n print(state_space)\\n return math.log(ws) - sum(map(lambda x: x * math.log(x), state_space.values())) / ws\",\n \"def schwefelfcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n scores = 418.9829 * n - np.sum(x * np.sin(np.sqrt(np.abs(x))), axis=1)\\n return scores\",\n \"def hessian(self, x):\\n h = self._hess(\\n time_series=self.observed_data,\\n a=x[0],\\n b=x[1],\\n c=x[2],\\n sigma=self.sigma\\n )\\n return h\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def shubert4fcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n\\n scores = np.zeros((x.shape[0], 1))\\n for i in range(n):\\n for j in range(5):\\n scores += np.cos(((j + 1) * x[:, i]) + j)\\n\\n return scores\",\n \"def entropy(self, params):\\n log_std = params[:, :, 1]\\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)\",\n \"def h(x):\\n return torch.sin(3 * x) + 4.\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def vectorized_hessp(self, x, p):\\n primals = self.vectorizer.unpack(x)\\n tangents = self.vectorizer.unpack(p)\\n hp_arrays = self.handler.hessp(primals, tangents)\\n self._n += 1\\n self.losses.append(self.loss)\\n self._maybe_update_pbar()\\n return self.vectorizer.pack(hp_arrays, \\\"hp\\\")\",\n \"def stoch(x):\\n return x/np.sum(x)\",\n \"def entropy(self):\\n Z = self.sum()\\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\\n H = 0.0\\n for x in np.nditer(self.t, op_flags=['readonly']):\\n p = x/Z\\n H += 0.0 if p==0 else -p*np.log(p)\\n return H\",\n \"def exploitEntropy(self, position):\\n pass\",\n \"def cosh(x):\\n raise NotImplementedError\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def h(x):\\n\\n hasher = hashlib.sha256()\\n hasher.update(x)\\n return hasher.digest()\",\n \"def easomfcn(x: np.ndarray) -> np.ndarray:\\n\\n n = x.shape[1]\\n assert n == 2, \\\"The Easom's function is only defined on a 2D space.\\\"\\n X = x[:, 0]\\n Y = x[:, 1]\\n\\n scores = (\\n -np.cos(X) * np.cos(Y) * np.exp(-((X - np.pi) ** 2 + (Y - np.pi) ** 2))\\n )\\n return scores\",\n \"def hann(self, _x):\\n N = self.N\\n return (1 - np.cos(2 * np.pi * _x / (N - 1))) / 2\",\n \"def Hamming(data):\\r\\n N=float(data.shape[0])\\r\\n temp=np.zeros(data.shape[0])\\r\\n for u, i in enumerate(data):\\r\\n temp[u]=(0.54-0.46*np.cos(2*np.pi*(u/N)))*i\\r\\n return temp\",\n \"def h(x):\\n h = -x*np.math.log(x, 2) - (1 - x)*np.math.log(1 - x, 2)\\n return h\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def hessian(f, x, s=_DEFAULT_STEP):\\n x = np.asarray(x)\\n n = len(x)\\n e = s * np.eye(n)\\n\\n forw1 = np.zeros(n)\\n forw2 = np.zeros((n, n))\\n for i in range(n):\\n forw1[i] = f(x + e[i])\\n for j in range(i, n):\\n forw2[i, j] = forw2[j, i] = f(x + e[i] + e[j])\\n\\n H = (forw2 - _colvec(forw1) - _rowvec(forw1) + f(x)) / s**2\\n return H\",\n \"def heavi(x):\\n return 0.5 * (np.sign(x) + 1)\",\n \"def div(self):\\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\\n entropies = [i * math.log(i, 2) for i in freqList]\\n entropy = -sum(entropies)\\n return entropy\",\n \"def entropy(data, idxList):\\n df = data.loc[idxList]\\n counts = df.value_counts().to_numpy()\\n counts = counts.reshape(1, -1).astype(np.float32)\\n counts /= np.sum(counts)\\n log_sum = counts @ np.log2(counts.T)\\n return -log_sum[0, 0]\",\n \"def f(self, x: np.array) -> np.array:\\n return (1/np.sqrt(2*np.pi*self.sig**2))*np.exp(-1*((x - self.mu)**2/(2*self.sig**2)))\",\n \"def shubert3fcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n scores = np.zeros((x.shape[0], 1))\\n for i in range(n):\\n for j in range(1, 6):\\n scores += j * np.sin(((j + 1) * x[:, i]) + j)\\n return scores\",\n \"def entropycell(self):\\n cells = [0] * self.k\\n for i in range(self.width):\\n cells[int(self.config[self.t, i])] += 1\\n\\n \\\"\\\"\\\"Calculates the Shannon entropy and the the average entropy so far.\\\"\\\"\\\"\\n shannon = 0\\n for i in range(self.k):\\n if(cells[i] != 0):\\n probability = cells[i] / self.width\\n shannon -= probability * np.log2(probability)\\n self.average_cell = (self.average_cell * self.t + shannon) / (self.t + 1)\",\n \"def entropy ( target_array ):\\n return -1 * sum (\\n [\\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\\n for value in set ( target_array )\\n ]\\n ) # End entropy()\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def var(x):\\n length = len(x)\\n\\n if length == 0:\\n return None\\n result = 0.0\\n m = TinyStatistician.mean(x)\\n for i in x:\\n result += (i - m) ** 2\\n\\n return result / length\",\n \"def gen_psi(self, x):\\n\\n if isinstance(x, jnp.ndarray):\\n x = x[:, None]\\n return jnp.exp(-self.h * (x - self.c) ** 2)\",\n \"def test_heip_e(self):\\n c = array([1,2,3,1])\\n h = shannon(c, base=e)\\n expected = exp(h-1)/3\\n self.assertEqual(heip_e(c), expected)\",\n \"def r_soft_hash(x):\\n if abs(x) < 1e-9:return 0\\n # round it to some number of bits\\n b = ns.round(ns.log(abs(x)) / ns.log(2))\\n gran = 2**(b-30)\\n return ns.round(x / gran) * gran\",\n \"def _ss(data):\\n c = sum(data)/len(data)\\n ss = sum((x-c)**2 for x in data)\\n return ss\",\n \"def hx(self, xhat):\\n zp = np.sqrt(xhat[0] ** 2 + xhat[2] ** 2)\\n return zp\",\n \"def psi(n, x):\\n H = h(n, x, orthonormal=True)\\n weight = np.exp(-(x ** 2) / 2)\\n psi = H * weight\\n return psi\",\n \"def f(x):\\n res = np.real(np.exp(-1j*x[1])*sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\\\\n for k in range(-sample_size,sample_size+1))) \\n res = -res/np.sqrt(2*sample_size+1) \\n return res\",\n \"def species_irreplaceability(x):\\n x = x*100\\n\\n def h(x):\\n # h(x) as specified\\n miu = 39\\n s = 9.5\\n tmp = -(x - miu)/ s\\n denominator = 1 + np.exp(tmp)\\n return 1/denominator\\n \\n\\n return (h(x) - h(0))/(h(100) - h(0))\",\n \"def sinh(x):\\n raise NotImplementedError\",\n \"def equitability(counts, base=2):\\n return shannon(counts, base)/(log((counts!=0).sum())/log(base))\",\n \"def entropy(self, priors=None):\\n def entropy_f(x):\\n x[x != 0] *= np.log(x[x != 0])\\n return -x.sum(axis=0)\\n return self.utility(entropy_f, priors)\",\n \"def chi(self, theta):\\n yf = self.predict(self.t, theta)\\n sse = np.sum(np.square((yf - self.y) / self.dy))\\n return sse\",\n \"def __value(t,N):\\n _,hist=np.unique(t, return_counts=True)\\n hist=list(hist)\\n hist.append(N-np.sum(hist))\\n return EntropyD(np.array(hist))\",\n \"def acosh(x):\\n return 0.0\",\n \"def entropy(img):\\n # by calculating\\n histogram = img.histogram()\\n histogram_size = sum(histogram)\\n histogram = [float(h) / histogram_size for h in histogram]\\n\\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])\",\n \"def entropy(self):\\n ent = 0.0\\n for f in self.byte_freq:\\n if f > 0:\\n freq = float(f) / self.byte_total\\n ent = ent + freq * math.log(freq, 2)\\n return -ent\",\n \"def manual_log_like_normal(x, data):\\n return np.sum(-np.log(x[1] * np.sqrt(2 * np.pi))-((data-x[0])**2) / (2*x[1]**2))\",\n \"def compute_energy(x, input_HP_sequence):\\n # add code here, feel free to change the argument list\\n # Given a input HP sequence, we already which points are H's.\\n return U\",\n \"def h(self, X):\\n if isinstance(X, int) or isinstance(X, float):\\n if X < 1:\\n x = max(0.001, X)\\n a = np.log(x/2.)**2 - np.arccosh(1./x)**2\\n elif X >= 1:\\n a = np.log(X/2.)**2 + np.arccos(1./X)**2\\n else:\\n a=np.empty_like(X)\\n X[X==0] = 0.001\\n x = X[(X<1) & (X>0)]\\n a[(X<1) & (X>0)] = np.log(x/2.)**2 - np.arccosh(1./x)**2\\n x = X[X >= 1]\\n a[X >= 1] = np.log(x/2.)**2 + np.arccos(1./x)**2\\n return a\",\n \"def h_function(self, x, xsquare):\\n return invert(self.l_function(powmod(self.public_key.g, x - 1, xsquare),x), x)\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def toy_hamiltonian(x):\\n q,p = extract_q_p(x)\\n pSqr = tf.square(p)\\n return 1/2 * tf.square(q - 1/4 * pSqr) + 1/32 * pSqr\",\n \"def shannons(data):\\n \\n from math import log as ln\\n\\n # from IPython.core.debugger import Tracer\\n # Tracer()()\\n \\n def p(n, N):\\n \\\"\\\"\\\" Relative abundance \\\"\\\"\\\"\\n if n is 0:\\n return 0\\n else:\\n return (float(n)/N) * ln(float(n)/N)\\n \\n N = sum(data)\\n \\n return -sum(p(n, N) for n in data if not n == 0)\",\n \"def density(self, x):\\n\\t\\tN = len(self.train_data)\\n\\t\\tpoints = list(self.train_data)\\n\\t\\tdists = [np.linalg.norm(x-point)**2 for point in points]\\n\\t\\texps = [np.exp(-dist / (2 * (self.bandwidth ** 2))) for dist in dists]\\n\\t\\tunnormalized_sum = sum(exps)\\n\\t\\tprobability = (1 / N) * self.normalizing_constant() * unnormalized_sum\\n\\t\\treturn probability\",\n \"def hash_numpy(x: numpy.ndarray) -> int:\\n x = x.astype(\\\"|S576\\\") if x.dtype == \\\"O\\\" else x\\n return xxhash.xxh64_hexdigest(x.tobytes())\",\n \"def entropy(a):\\n a = a.upper()\\n\\n freq = collections.defaultdict(int) # int() is the default constructor for non existent item, and returns 0\\n for c in a:\\n freq[c] = freq[c] + 1\\n\\n e = 0.0\\n for f in freq.values():\\n if f:\\n p = f / len(a)\\n e += p * math.log(p)\\n\\n return -e\",\n \"def f(x):\\n res = np.real(np.exp(-1j*x[1])*\\\\\\n sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\\\\n for k in range(-sample_size,sample_size+1))) \\n res = -res/np.sqrt(2*sample_size+1) \\n return res\",\n \"def hash_function(self, x):\\n if not x:\\n return -1\\n hashed_value = 0\\n\\n for char in x:\\n hashed_value = 181 * hashed_value + ord(char)\\n\\n return hashed_value % self.capacity\",\n \"def jensen_shannon(x, y, bins, calc_distance=False, xy_probabilities=False):\\n # assert array length\\n assert len(x) == len(y)\\n\\n if xy_probabilities:\\n # if x does not sum up to 1, raise an error\\n if not np.isclose(sum(x), 1 ,atol=0.0001):\\n raise ValueError('Probabilities in vector x do not sum up to 1.')\\n # if y does not sum up to 1, raise an error\\n if not np.isclose(sum(y), 1, atol=0.0001):\\n raise ValueError('Probabilities in vector y do not sum up to 1.')\\n \\n # add a small number to all probabilities if zero occurs\\n if x.any(0):\\n px = x + 1e-15\\n py = y + 1e-15\\n else:\\n px = x\\n py = y\\n else:\\n # get the bins, joint bins for x and y (same_bins=True)\\n bins = get_2D_bins(x, y, bins, same_bins=True)\\n\\n # calculate unconditioned histograms\\n hist_x = np.histogram(x, bins=bins[0])[0]\\n hist_y = np.histogram(y, bins=bins[1])[0]\\n\\n # calculate probabilities\\n px = (hist_x / np.sum(hist_x)) + 1e-15\\n py = (hist_y / np.sum(hist_y)) + 1e-15\\n\\n # calculate m\\n pm = 0.5 * (px + py)\\n\\n # calculate kullback-leibler divergence between px and pm & py and pm\\n kl_xm = kullback_leibler(px, pm, bins=bins, xy_probabilities=True)\\n kl_ym = kullback_leibler(py, pm, bins=bins, xy_probabilities=True)\\n \\n if calc_distance:\\n return (0.5 * kl_xm + 0.5 * kl_ym)**0.5\\n else:\\n return (0.5 * kl_xm + 0.5 * kl_ym)\",\n \"def evenness(df):\\n obs = shannon(df)\\n count = df.shape[0]\\n max_freq = 1.0 / count\\n max_vector = np.repeat(max_freq,count)\\n pre = -(sum(max_vector * np.log(max_vector)))\\n return obs / pre\",\n \"def jeffreys(self, x):\\n return np.sqrt(1. / x)\",\n \"def entropy(message):\\n n = len(message)\\n message = letter_freq(message)\\n h = 0\\n for n_i in message.values():\\n p_i = n_i/n\\n h += -p_i*(log2(p_i))\\n return h\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7339232","0.6906172","0.67469835","0.66126776","0.6580351","0.6566007","0.65266234","0.646055","0.6361494","0.6340554","0.62182045","0.6194352","0.6190961","0.6157335","0.6148306","0.61020863","0.6101131","0.60966253","0.6066495","0.60436225","0.6029721","0.59834","0.5931555","0.5925839","0.59182525","0.58996916","0.5898303","0.5887441","0.5859824","0.58569765","0.58440596","0.5839691","0.58200365","0.5810351","0.5798393","0.578523","0.57807714","0.57777876","0.5770964","0.5757985","0.5704455","0.5683404","0.56801724","0.5656068","0.56245786","0.56197053","0.5606164","0.5585159","0.5557278","0.5542862","0.553604","0.55303204","0.5519091","0.55129105","0.5510744","0.5506213","0.549372","0.5491815","0.54911304","0.5472284","0.5465591","0.54650146","0.54544616","0.5443581","0.544332","0.5432493","0.54295903","0.54291785","0.5420431","0.541597","0.5412896","0.5412091","0.5411842","0.53992075","0.53878903","0.5385198","0.53848237","0.5371965","0.5369404","0.5368891","0.53561705","0.53470343","0.534513","0.5339327","0.5335368","0.5326147","0.5315033","0.5311857","0.53029484","0.5299311","0.5294926","0.5291466","0.52912486","0.52791643","0.52769536","0.5272159","0.52682436","0.52594215","0.5257753","0.52562857"],"string":"[\n \"0.7339232\",\n \"0.6906172\",\n \"0.67469835\",\n \"0.66126776\",\n \"0.6580351\",\n \"0.6566007\",\n \"0.65266234\",\n \"0.646055\",\n \"0.6361494\",\n \"0.6340554\",\n \"0.62182045\",\n \"0.6194352\",\n \"0.6190961\",\n \"0.6157335\",\n \"0.6148306\",\n \"0.61020863\",\n \"0.6101131\",\n \"0.60966253\",\n \"0.6066495\",\n \"0.60436225\",\n \"0.6029721\",\n \"0.59834\",\n \"0.5931555\",\n \"0.5925839\",\n \"0.59182525\",\n \"0.58996916\",\n \"0.5898303\",\n \"0.5887441\",\n \"0.5859824\",\n \"0.58569765\",\n \"0.58440596\",\n \"0.5839691\",\n \"0.58200365\",\n \"0.5810351\",\n \"0.5798393\",\n \"0.578523\",\n \"0.57807714\",\n \"0.57777876\",\n \"0.5770964\",\n \"0.5757985\",\n \"0.5704455\",\n \"0.5683404\",\n \"0.56801724\",\n \"0.5656068\",\n \"0.56245786\",\n \"0.56197053\",\n \"0.5606164\",\n \"0.5585159\",\n \"0.5557278\",\n \"0.5542862\",\n \"0.553604\",\n \"0.55303204\",\n \"0.5519091\",\n \"0.55129105\",\n \"0.5510744\",\n \"0.5506213\",\n \"0.549372\",\n \"0.5491815\",\n \"0.54911304\",\n \"0.5472284\",\n \"0.5465591\",\n \"0.54650146\",\n \"0.54544616\",\n \"0.5443581\",\n \"0.544332\",\n \"0.5432493\",\n \"0.54295903\",\n \"0.54291785\",\n \"0.5420431\",\n \"0.541597\",\n \"0.5412896\",\n \"0.5412091\",\n \"0.5411842\",\n \"0.53992075\",\n \"0.53878903\",\n \"0.5385198\",\n \"0.53848237\",\n \"0.5371965\",\n \"0.5369404\",\n \"0.5368891\",\n \"0.53561705\",\n \"0.53470343\",\n \"0.534513\",\n \"0.5339327\",\n \"0.5335368\",\n \"0.5326147\",\n \"0.5315033\",\n \"0.5311857\",\n \"0.53029484\",\n \"0.5299311\",\n \"0.5294926\",\n \"0.5291466\",\n \"0.52912486\",\n \"0.52791643\",\n \"0.52769536\",\n \"0.5272159\",\n \"0.52682436\",\n \"0.52594215\",\n \"0.5257753\",\n \"0.52562857\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6537447"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":3389,"cells":{"query":{"kind":"string","value":"Conditional Entropy Calculates the conditional Shannon Entropy for two discrete distributions. This metric gives the entropy of the distribution of x in case the distribution of y is known."},"document":{"kind":"string","value":"def conditional_entropy(x, y, bins, normalize=False):\n \n # get the bins\n bins = get_2D_bins(x, y, bins)\n \n # calculate H(x,y) and H(y)\n hjoint = joint_entropy(x,y,bins)\n hy = entropy(y, bins[1])\n\n if normalize:\n normalizer = entropy(x, bins[0])\n conditional_entropy = hjoint - hy\n\n # check if conditional entropy and normalizer are very small\n if conditional_entropy < 1e-4 and normalizer < 1e-4:\n # return zero to prevent very high values of normalized conditional entropy\n # e.g. conditional entropy = -1.3e-12, normalizer = -1.6e-12 \n # -> normalized conditional entropy = 812.5\n return 0\n else:\n return conditional_entropy / normalizer\n else:\n return hjoint - hy"},"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 conditional_entropy(f1, f2):\n\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\n return ce","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def conditional_entropy(self) -> float:\n pass","def entropy(a, b):\n with mp.extradps(5):\n a, b = _validate_a_b(a, b)\n return (_fun.logbeta(a, b)\n - (a - 1)*mp.psi(0, a)\n - (b - 1)*mp.psi(0, b)\n + (a + b - 2)*mp.psi(0, a + b))","def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def conditional_entropy_hyper(self) -> float:\n pass","def cross_entropy(x, y, bins, xy_probabilities=False):\n # calculate probabilities if probabilities == False\n if xy_probabilities:\n # same bins for x and y -> same length of x and y if xy_probabilities == True\n assert len(x) == len(y)\n\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y),1,atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n\n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n return - px.dot(np.log2(py))","def _cal_igr(x, y):\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\n confmat = _drop_empty_rows_and_cols(confmat)\n total_occurrences = confmat.sum()\n p_xy_m = confmat / total_occurrences\n p_y = confmat.sum(1) / total_occurrences\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))","def js_divergence(dist1, dist2):\n mean_dist = (dist1 + dist2) / 2.0\n js = (\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\n ) / 2.0\n return js","def _entropy_filter(self, prob1, prob2):\n\n\n # calculate merged prob.\n prob_merged = (prob1 + prob2)/2\n # Compute entropy for each prob.\n H1 = -prob1 * math.log(prob1) - (1-prob1) * math.log(1-prob1)\n H2 = -prob2 * math.log(prob2) - (1-prob2) * math.log(1-prob2)\n Hm = -prob_merged * math.log(prob_merged) - (1-prob_merged) * math.log(1-prob_merged)\n\n H_min = min(H1, H2, Hm)\n\n if H_min == H1:\n return prob1\n elif H_min == H2:\n return prob2\n else:\n return prob_merged","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def calc_conditional_entropy(map,data_stat,attribute):\n #acquire the data info of the attribute stored in data_stat\n data_info = data_stat[attribute]\n #acquire the label info\n # label_col = len(data_stat)-1\n label_col = data_stat.keys()[-1]\n # print(data_stat.keys())\n label_info = data_stat[label_col]\n #acquire the data \n data = map[attribute]\n labels = map[label_col]\n conditional_entropy =0\n for data_type in data_info:\n specific_entropy = 0\n for label_type in label_info: \n #attribute data indices where all data entries are equal to a speicifc value\n data_with_spec_val_idx = data_info[data_type]\n #label indices where all labels are of same value\n spec_label_idx = label_info[label_type]\n #the intersection of the two indices above\n intersect_idx = np.intersect1d(data_with_spec_val_idx,spec_label_idx)\n #conditional probability of label being of specific value given speicific data value\n temp_prob = len(intersect_idx)/float(len(data_with_spec_val_idx))\n if temp_prob!=0:\n specific_entropy += temp_prob*math.log(temp_prob,2)\n specific_entropy = -specific_entropy\n prob = len(data_with_spec_val_idx)/float(len(data))\n conditional_entropy += prob * specific_entropy\n return conditional_entropy","def joint_entropy(x, y, bins):\n # assert array length\n assert len(x) == len(y)\n\n # get the bins, x and y get their own bins in case of joint entropy\n bins = get_2D_bins(x, y, bins)\n\n # get the joint histogram\n joint_hist = np.histogram2d(x, y, bins)[0]\n\n # calculate the joint probability and add a small number\n joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15\n\n # calculate and return the joint entropy\n return - np.sum(joint_p * np.log2(joint_p))","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def entropy(y,w):\r\n\r\n\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\r\n\r\n # y_partition = partition(y)\r\n # elements,counts = np.unique(y,return_counts = True)\r\n # entropy=0\r\n\r\n # for i in range(len(elements)):\r\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\r\n # return entropy\r\n\r\n entropy = 0\r\n # two hypothesis cases 0,1\r\n h = {0: 0, 1: 0}\r\n leny = len(y)\r\n for i in range(leny):\r\n # if y is 0 add 0 to the weight\r\n if y[i] == 0:\r\n h[0] += w[i]\r\n # if y is 1 add 1 to the weight\r\n elif y[i] == 1:\r\n h[1] += + w[i]\r\n # summing all the weighted values \r\n val_sum = h[0] + h[1]\r\n\r\n # entropy calculation\r\n for j in range(len(h)):\r\n h[j] = h[j]/val_sum\r\n # to prevent divide by zero\r\n if h[j] != 0:\r\n entropy += h[j] * np.log2(h[j])\r\n entropy = -(entropy)\r\n return entropy","def transfer_entropy(X, Y):\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\n\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\n for y_f, x_p, y_p in coords.keys():\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\n\n p_yp = p_dist.sum(axis=2).sum(axis=1)\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\n\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\n denominator[denominator == 0] = np.nan\n\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\n division[division == 0] = np.nan\n\n log = np.log2(division)\n\n return np.nansum(np.multiply(p_dist, log))","def entropy_coefficient(filter1, filter2, base=2):\n\n if (type(filter1) is NullField) or (type(filter2) is NullField):\n return 0\n\n total_count = int(filter1.bit_size)\n\n f1_element_count = filter1.filter.count(True)\n f2_element_count = filter2.filter.count(True)\n\n prob_f1 = f1_element_count / total_count\n prob_f2 = f1_element_count / total_count\n\n e_f1 = -1.0 * total_count * prob_f1 * math.log(prob_f1) / math.log(base)\n e_f2 = -1.0 * total_count * prob_f2 * math.log(prob_f2) / math.log(base)\n\n entropy = abs(e_f1 - e_f2)\n\n # for element_count in Counter(data).values():\n # p = element_count / total_count\n # entropy -= p * math.log(p, self.base)\n\n assert entropy >= 0\n\n return 1 - entropy","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def shannon_entropy(probs):\n return -(\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\n )","def compute_empirical_conditional_distribution(var1_values, var2_values):\n conditional_distributions = {x2: {} for x2 in set(var2_values)}\n\n # -------------------------------------------------------------------------\n # YOUR CODE HERE\n #\n \n # Compute the empirical distribution of var2_values\n x2_prob = compute_empirical_distribution(var2_values)\n \n # Compute the empirical joint distribution of var1_values and var2_values\n joint_prob_x1_x2 = compute_empirical_distribution(list(zip(var1_values, var2_values)))\n \n for x2 in var2_values:\n for x1 in var1_values:\n conditional_distributions[x2][x1] = joint_prob_x1_x2[x1, x2]/x2_prob[x2]\n\n #\n # END OF YOUR CODE\n # -------------------------------------------------------------------------\n\n return conditional_distributions","def calculate_entropy(y):\n\tlog2 = lambda x: math.log(x) / math.log(2)\n\tunique_labels = np.unique(y)\n\tentropy = 0\n\tfor label in unique_labels:\n\t\tcount = len(y[y == label])\n\t\tp = count / len(y)\n\t\tentropy += -p * log2(p)\n\treturn entropy","def information_gain(f1, f2):\n\n ig = ee.entropyd(f1) - conditional_entropy(f1, f2)\n return ig","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def dist_calc(self, x, y):\n p_xy = self.d2_bin(x, y)\n p_x = np.sum(p_xy, axis=1)\n p_y = np.sum(p_xy, axis=0)\n\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\n\n output = max(0.0, (1 - (info / entropy)))\n return output","def chl_entropy(y, base=2):\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\n p = p[p!=0]/float(len(y))\n S = -1.0*sum(p*log(p))/log(base)\n return S","def entropy(x, bins, normalize=False, xy_probabilities=False):\n # calculate probabilities if xy_probabilities == False\n if xy_probabilities:\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n \n # add a small number to all probabilities if zero occurs\n if x.any(0):\n p = x + 1e-15\n else:\n p = x\n else:\n # get the bins\n bins = np.histogram_bin_edges(x, bins)\n\n # calculate the empirical probabilities\n count = np.histogram(x, bins=bins)[0]\n\n # if counts should be None, raise an error\n if np.sum(count) == 0:\n raise ValueError('The histogram cannot be empty. Adjust the bins to ' +\n 'fit the data')\n # calculate the probabilities\n p = (count / np.sum(count)) + 1e-15\n\n\n # calculate the Shannon Entropy\n if normalize:\n # get number of bins\n nbins = len(p)\n # maximal entropy: uniform distribution\n normalizer = np.log2(nbins) \n\n return - p.dot(np.log2(p)) / normalizer\n else:\n return - p.dot(np.log2(p))","def alt_cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\n np.std(y_arr, ddof=1) ** 2) / 2.0)\n return delta / pooled_std","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def cond_entropy(joint_prob, cond_prob):\n # Computing log2(P cond)\n log2_p = (np.ma.log2(cond_prob)).filled(0)\n # Multipling element wise the arrays\n prod_entropy = np.multiply(joint_prob, log2_p)\n # Getting the - sum of the resulting array.\n H = -( np.sum(prod_entropy))\n return H","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def div(self):\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\n entropies = [i * math.log(i, 2) for i in freqList]\n entropy = -sum(entropies)\n return entropy","def symbolic_transfer_entropy(symX, symY):\n\n if len(symX) != len(symY):\n raise ValueError('All arrays must have same length')\n \n symX = np.array(symX)\n symY = np.array(symY)\n \n cp = symbolic_conditional_probabilities_consecutive(symX)\n cp2 = symbolic_conditional_probabilities_consecutive_external(symX, symY)\n jp = symbolic_joint_probabilities_consecutive_external(symX, symY)\n \n TE = 0\n \n for yi, xi, xii in list(jp.keys()):\n try:\n a = cp[xi,xii]\n b = cp2[yi,xi,xii]\n c = jp[yi,xi,xii]\n TE += c * np.log(b / a) / np.log(2.)\n except KeyError:\n continue\n except:\n print(\"Unexpected Error\")\n raise\n del cp\n del cp2\n del jp\n \n return TE","def entropyCategorical(attr, X, y):\n uniques = X[attr].unique().tolist()\n idxLists = []\n entropies = []\n weights = []\n for u in uniques:\n idxLists.append(X.index[X[attr] == u].tolist())\n entropies.append(entropy(y, idxLists[-1]))\n weights.append(len(idxLists[-1]))\n\n entropies = np.array(entropies).reshape(1, -1)\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\n weights /= np.sum(weights)\n\n return (uniques, idxLists, (entropies @ weights)[0, 0])","def entropy(self):\n raise NotImplementedError","def entropy(self):\r\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)","def _calculate_probs_and_entropy_y(self):\n #calculate y probabilities and H(Y)\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\n self.lab_entropy = 0\n s = sum(self.lab_counts.values())\n for label, count in self.lab_counts.items():\n self.lab_probs[label] = count / s\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])","def shannon_entropy(c):\n\n c_normalized = c / float(np.sum(c))\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\n return entropy","def entropy ( target_array ):\n return -1 * sum (\n [\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\n for value in set ( target_array )\n ]\n ) # End entropy()","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def condentropy(truelabels, labels):\n labels=array(labels)\n truelabels=array(truelabels)\n \n condent=0.\n for l in xrange(min(labels),max(labels)+1):\n sublabels = truelabels[ labels==l ]\n condent += len(sublabels)*chl_entropy( sublabels )\n return condent/float(len(labels))","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def _entropies(self):\n H_C = fentropy(self.row_totals)\n H_K = fentropy(self.col_totals)\n H_actual = fentropy(self.itervalues())\n H_expected = H_C + H_K\n I_CK = H_expected - H_actual\n return H_C, H_K, I_CK","def entropy(probabilities):\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))","def mutual_info(l1, l2):\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def conditional_entropy(df, var, var_t):\n row_list = df \\\n .groupBy(var) \\\n .agg(count(\"*\").alias('num_entries')) \\\n .withColumn('all', lit('all')) \\\n .withColumn('total_num_entries', sql_sum('num_entries').over(Window.partitionBy('all'))) \\\n .withColumn('pcg', col('num_entries') / col('total_num_entries')) \\\n .select(var, 'pcg').collect()\n\n cat_and_weight = [(r[var], r['pcg']) for r in row_list]\n\n return sum([w * single_entropy(df=df.filter(col(var) == c), var=var_t) for (c, w) in cat_and_weight])","def conditional_pdf(self, x1, x2 = None):\n return np.exp(self.conditional_logpdf(x1, x2))","def shannon_entropy(counts):\n freq = np.array(counts) * 1.0 / np.sum(counts)\n return -np.sum([f * np.log2(f) for f in freq if f != 0])","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def entropy_function(c, n):\n return -(c*1.0/n)*math.log(c*1.0/n,2)","def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])","def get_entropy(distribution, samples):\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\n return entropy","def mutual_information(x, y, w):\r\n \r\n\r\n total_entropy = entropy(y,w)\r\n\r\n partitioned_x = partition(x)\r\n weighted_entropy = 0\r\n # calculate the weighted entropy over the partition of x\r\n vals,counts= np.unique(x,return_counts=True)\r\n for key in partitioned_x:\r\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\r\n\r\n information_gain = total_entropy - weighted_entropy\r\n return information_gain","def entropy(self, X):\n if isinstance(X, np.ndarray):\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\n K = self._posterior_covariance(X)\n L = np.linalg.cholesky(K)\n D = len(X)\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))","def entropy(self, args):\n mean, stddev = args\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\n entropy = dist.entropy()\n return entropy","def entropy(counts):\n assert (counts >= 0).all()\n probs = counts / counts.sum()\n probs = probs[probs > 0] # Avoid log(0)\n return - np.sum(probs * np.log2(probs))","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def get_entropy(*labels):\n entropies = [] #list of entropy values from each subset\n total = 0 #total number of datapoints\n for subset in labels:\n n = len(subset)\n total += n\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\n entropies.append((entropy, n))\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])","def cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt(\n (\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\n ) / (len(x_arr) + len(y_arr))\n )\n return delta / pooled_std","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def cohens_d(x, y):\n nx, ny = len(x), len(y)\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\n ((nx - 1) + (ny - 1))\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)","def conditional_entropy(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n\n marginals = np.nansum(P_nan, axis=1)\n P_cond = P_nan / marginals[:, None]\n\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_cond)))","def prob_larger_continuous(distr1, distr2):\n\n return distr1.expect(distr2.cdf)","def _entropy2(labels, base=None):\n\n n_labels = len(labels)\n\n if n_labels <= 1:\n return 0\n\n value,counts = np.unique(labels, return_counts=True)\n probs = counts / n_labels\n n_classes = np.count_nonzero(probs)\n\n if n_classes <= 1:\n return 0\n\n ent = 0.\n\n # Compute entropy\n base = e if base is None else base\n for i in probs:\n ent -= i * log(i, base)\n\n # quick observation shows ent between 0.0 and 4.0.\n return ent","def _calculate_probs_and_entropy_x(self, columns):\n #calculate x probabilities and H(Xi)\n #H(Xi) = Sum(x € Xi)(-P(Xi=x) * log(P(Xi=x)))\n for col in columns:\n self.cat_entropies[col] = 0\n xsum = 0\n for val in self.categories[col]:\n self.cat_probs[col][val] = 0\n for label in self.labels:\n self.cat_probs[col][val] += self.cat_counts[col][label][val]\n xsum += self.cat_probs[col][val]\n for val in self.categories[col]:\n self.cat_probs[col][val] /= xsum\n self.cat_entropies[col] -= self.cat_probs[col][val] * self.log(self.cat_probs[col][val])","def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\n def entropy(freqDict):\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\n freqx = objhist(x)\n freqy = objhist(y)\n \n Hx = freqx.entropy()\n Hy = freqy.entropy()\n Hxy = objhist(zip(x,y)).entropy()\n M = Hx + Hy - Hxy\n Mstar = 2*M / (Hx+Hy)\n\n if len(freqx)==1 or len(freqy)==1:\n p = 1\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\n p = 0\n else:\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\n p = (Mperms >= M).sum() / nperms\n\n return M, Mstar, p, Hx, Hy, Hxy","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def entropy(self):\n Z = self.sum()\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\n H = 0.0\n for x in np.nditer(self.t, op_flags=['readonly']):\n p = x/Z\n H += 0.0 if p==0 else -p*np.log(p)\n return H","def H(self, data):\n entropy = 0\n\n if not data:\n return entropy\n\n for x in range(256):\n p_x = float(data.count(chr(x))) / len(data)\n if p_x > 0:\n entropy -= p_x * math.log(p_x, 2)\n\n return entropy","def entropy_obj(self, x, h, num_samples_posterior=20, return_score=False, learn_post_sigma=True):\n inf_dist = distributions.Normal(h, self.post_logsigma.detach().exp())\n h_given_x = inf_dist.sample((num_samples_posterior,))\n if len(x.size()) == 4:\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\n xr = x[None].repeat(num_samples_posterior, 1, 1, 1, 1)\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1), x.size(2), x.size(3))\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1), x.size(2), x.size(3))\n logq = logq.view(num_samples_posterior, x.size(0))\n w = (logq - inf_logprob).softmax(dim=0)\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\n weighted_fvals = (fvals * w[:, :, None, None, None]).sum(0).detach()\n c = weighted_fvals\n else:\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\n xr = x[None].repeat(num_samples_posterior, 1, 1)\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1))\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1))\n logq = logq.view(num_samples_posterior, x.size(0))\n w = (logq - inf_logprob).softmax(dim=0)\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\n weighted_fvals = (fvals * w[:, :, None]).sum(0).detach()\n c = weighted_fvals\n\n mgn = c.norm(2, 1).mean()\n g_error_entropy = torch.mul(c, x).mean(0).sum()\n\n post = distributions.Normal(h.detach(), self.post_logsigma.exp())\n h_g_post = post.rsample()\n joint = self.logq_joint(x.detach(), h_g_post)\n post_ent = post.entropy().sum(1)\n\n elbo = joint + post_ent\n post_loss = -elbo.mean()\n\n if learn_post_sigma:\n self.post_optimizer.zero_grad()\n post_loss.backward()\n self.post_optimizer.step()\n\n if return_score:\n return g_error_entropy, mgn, c\n else:\n return g_error_entropy, mgn","def compute_dists(x, y):\r\n \r\n return (x - y.permute(0, 2, 1)) ** 2","def entropy(d, total, word_count):\n\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\n\t# p(morf) = c(morf) / c(all)\n\te = 0\n\tfor count in d.values():\n\t\tp = count/total\n\t\ttype_e = - p * log2(p)\n\t\te += type_e * count\n\treturn e / word_count","def entropy(self, priors=None):\n def entropy_f(x):\n x[x != 0] *= np.log(x[x != 0])\n return -x.sum(axis=0)\n return self.utility(entropy_f, priors)","def entropy(class_probabilities):\n return sum(-p * math.log(p, 2)\n for p in class_probabilities\n if p) #ignore 0's","def entropy(data, idxList):\n df = data.loc[idxList]\n counts = df.value_counts().to_numpy()\n counts = counts.reshape(1, -1).astype(np.float32)\n counts /= np.sum(counts)\n log_sum = counts @ np.log2(counts.T)\n return -log_sum[0, 0]","def print_entropies(independent_joint_probabilities, conditional_joint_probabilities):\n indepndent_entropy = entropy_from_probability_matrix(independent_joint_probabilities)\n conditional_entropy = entropy_from_probability_matrix(conditional_joint_probabilities)\n\n print 'Independent H(X,Y) = {h}'.format(h=indepndent_entropy)\n print 'Conditional H(X,Y) = {h}'.format(h=conditional_entropy)\n print 'D_KL(Independent, Conditional) = {d_kl}' \\\n .format(d_kl=kullback_leibler_divergence(independent_joint_probabilities, conditional_joint_probabilities))\n print 'D_KL(Conditional, Independent) = {d_kl}' \\\n .format(d_kl=kullback_leibler_divergence(conditional_joint_probabilities, independent_joint_probabilities))\n\n return indepndent_entropy, conditional_entropy","def entropy_computations(\n self,\n between_labels=True,\n between_images=True,\n between_all_images=False,\n symmetrized=True,\n ):\n jzazbz_dist_dict = self.jzazbz_dist_dict\n\n if between_labels:\n words = self.labels_list\n labels_entropy_dict = {}\n labels_entropy_dict_js = {}\n color_sym_matrix = []\n color_sym_matrix_js = []\n\n for word1 in words:\n row = []\n row_js = []\n for word2 in words:\n entropy_js = js_divergence(\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n np.mean(np.array(jzazbz_dist_dict[word2]), axis=0),\n )\n entropy = kl_divergence(\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n symmetrized,\n )\n row.append(entropy)\n row_js.append(entropy_js)\n # these lines are for convenience; if strings are correctly synced across all data they are not needed\n if word1 == \"computer science\":\n labels_entropy_dict[\"computer_science\" + \"_\" + word2] = entropy\n labels_entropy_dict_js[\n \"computer_science\" + \"_\" + word2\n ] = entropy_js\n elif word2 == \"computer science\":\n labels_entropy_dict[word1 + \"_\" + \"computer_science\"] = entropy\n labels_entropy_dict_js[\n word1 + \"_\" + \"computer_science\"\n ] = entropy_js\n else:\n labels_entropy_dict[word1 + \"_\" + word2] = entropy\n labels_entropy_dict_js[word1 + \"_\" + word2] = entropy_js\n color_sym_matrix.append(row)\n color_sym_matrix_js.append(row_js)\n\n self.cross_entropy_between_labels_dict = labels_entropy_dict\n self.cross_entropy_between_labels_matrix = color_sym_matrix\n self.cross_entropy_between_labels_dict_js = labels_entropy_dict_js\n self.cross_entropy_between_labels_matrix_js = color_sym_matrix_js\n\n if between_images:\n entropy_dict = {}\n entropy_dict_js = {}\n for key in jzazbz_dist_dict:\n entropy_array = []\n entropy_array_js = []\n for i in range(len(jzazbz_dist_dict[key])):\n for j in range(len(jzazbz_dist_dict[key])):\n entropy_array_js.append(\n js_divergence(\n jzazbz_dist_dict[key][i], jzazbz_dist_dict[key][j]\n )\n )\n entropy_array.append(\n kl_divergence(\n jzazbz_dist_dict[key][i],\n jzazbz_dist_dict[key][j],\n symmetrized,\n )\n )\n entropy_dict[key] = entropy_array\n entropy_dict_js[key] = entropy_array_js\n\n self.cross_entropy_between_images_dict = entropy_dict\n self.cross_entropy_between_images_dict_js = entropy_dict_js\n\n if between_all_images:\n entropy_dict_all = {}\n color_sym_matrix_js_all = []\n\n for word1 in words:\n row_js_all = []\n for word2 in words:\n entropy_js_all = []\n for i in range(len(jzazbz_dist_dict[word1])):\n for j in range(len(jzazbz_dist_dict[word2])):\n try:\n entropy_js_all.append(\n js_divergence(\n jzazbz_dist_dict[word1][i],\n jzazbz_dist_dict[word2][j],\n )\n )\n except Exception as exc:\n self.log.error(exc)\n entropy_js_all.append(np.mean(entropy_js))\n entropy_dict_all[word1 + \"_\" + word2] = entropy_js_all\n row_js_all.append(np.mean(entropy_js_all))\n color_sym_matrix_js_all.append(row_js_all)\n\n self.cross_entropy_between_all_images_dict = entropy_dict_all\n self.cross_entropy_between_all_images_matrix = color_sym_matrix_js_all","def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))","def entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))","def entropy(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))","def entropy(self, base: int = None):\n\n # shannon entropy in nats\n fdist_ = self.fdist\n fdist_[\"prob\"] = fdist_[\"freq\"] / fdist_[\"freq\"].sum()\n fdist_[\"logp\"] = np.log(fdist_[\"prob\"])\n fdist_[\"nats\"] = -fdist_[\"prob\"] * fdist_[\"logp\"]\n entropy_ = fdist_[\"nats\"].sum()\n\n # convert base\n if base:\n entropy_ = entropy_ / np.log(base)\n\n # return\n return entropy_","def entropy(distribution, unit=2):\n frequencies = distribution.frequencies(normalised=True)\n # check to see if it is a deterministic case (all but one are zero)\n zeros_size = frequencies[frequencies == 0].size\n if zeros_size + 1 == frequencies.size:\n return 0\n else:\n return np.sum(-frequencies * np.log2(frequencies) / np.log2(unit))","def mutual_information(x, y, bins, normalize=False):\n # assert array length\n assert len(x) == len(y)\n\n # get the bins\n bins = get_2D_bins(x, y, bins)\n\n # calculate entropy(x) and conditional_entropy(x,y)\n hx = entropy(x, bins[0])\n hcon = conditional_entropy(x, y, bins)\n\n if normalize:\n normalizer = np.min([entropy(x, bins[0]), entropy(y, bins[1])])\n mutual_info = hx - hcon\n\n # check if mutual info and normalizer are very small\n if mutual_info < 1e-4 and normalizer < 1e-4:\n # return zero to prevent very high values of normalized mutual information\n # e.g. mutual information = -1.3e-12, normalizer = -1.6e-12 \n # -> normalized conditional entropy = 812.5\n return 0\n else:\n return mutual_info / normalizer\n else:\n return hx - hcon","def entropy(class_probabilities):\n return sum(-p * math.log(p,2)\n for p in class_probabilities\n if p)","def EntropyD(dist): \n if np.any(dist>0):\n dist2 = dist/np.sum(dist)\n return -np.sum(dist2[dist2>0]*np.log2(dist2[dist2>0]))\n else:\n return 0","def compute_entropy(bincounts, include_zeros):\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\n if not include_zeros:\n bincounts = bincounts[1:]\n mask = tf.greater(bincounts, 0)\n nonzero_bincounts = tf.cast(\n tf.boolean_mask(bincounts, mask), tf.float64)\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\n log_nonzero_bincounts)\n entropy = tf.math.reduce_sum(\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\n return entropy * num_nonzero / num_total"],"string":"[\n \"def conditional_entropy(f1, f2):\\n\\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\\n return ce\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def conditional_entropy(self) -> float:\\n pass\",\n \"def entropy(a, b):\\n with mp.extradps(5):\\n a, b = _validate_a_b(a, b)\\n return (_fun.logbeta(a, b)\\n - (a - 1)*mp.psi(0, a)\\n - (b - 1)*mp.psi(0, b)\\n + (a + b - 2)*mp.psi(0, a + b))\",\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def cross_entropy(x, y, bins, xy_probabilities=False):\\n # calculate probabilities if probabilities == False\\n if xy_probabilities:\\n # same bins for x and y -> same length of x and y if xy_probabilities == True\\n assert len(x) == len(y)\\n\\n # if x does not sum up to 1, raise an error\\n if not np.isclose(sum(x),1,atol=0.0001):\\n raise ValueError('Probabilities in vector x do not sum up to 1.')\\n # if y does not sum up to 1, raise an error\\n if not np.isclose(sum(y),1,atol=0.0001):\\n raise ValueError('Probabilities in vector y do not sum up to 1.')\\n\\n # add a small number to all probabilities if zero occurs\\n if x.any(0):\\n px = x + 1e-15\\n py = y + 1e-15\\n else:\\n px = x\\n py = y\\n else:\\n # get the bins, joint bins for x and y (same_bins=True)\\n bins = get_2D_bins(x, y, bins, same_bins=True)\\n\\n # calculate unconditioned histograms\\n hist_x = np.histogram(x, bins=bins[0])[0]\\n hist_y = np.histogram(y, bins=bins[1])[0]\\n\\n px = (hist_x / np.sum(hist_x)) + 1e-15\\n py = (hist_y / np.sum(hist_y)) + 1e-15\\n\\n return - px.dot(np.log2(py))\",\n \"def _cal_igr(x, y):\\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\\n confmat = _drop_empty_rows_and_cols(confmat)\\n total_occurrences = confmat.sum()\\n p_xy_m = confmat / total_occurrences\\n p_y = confmat.sum(1) / total_occurrences\\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))\",\n \"def js_divergence(dist1, dist2):\\n mean_dist = (dist1 + dist2) / 2.0\\n js = (\\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\\n ) / 2.0\\n return js\",\n \"def _entropy_filter(self, prob1, prob2):\\n\\n\\n # calculate merged prob.\\n prob_merged = (prob1 + prob2)/2\\n # Compute entropy for each prob.\\n H1 = -prob1 * math.log(prob1) - (1-prob1) * math.log(1-prob1)\\n H2 = -prob2 * math.log(prob2) - (1-prob2) * math.log(1-prob2)\\n Hm = -prob_merged * math.log(prob_merged) - (1-prob_merged) * math.log(1-prob_merged)\\n\\n H_min = min(H1, H2, Hm)\\n\\n if H_min == H1:\\n return prob1\\n elif H_min == H2:\\n return prob2\\n else:\\n return prob_merged\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def calc_conditional_entropy(map,data_stat,attribute):\\n #acquire the data info of the attribute stored in data_stat\\n data_info = data_stat[attribute]\\n #acquire the label info\\n # label_col = len(data_stat)-1\\n label_col = data_stat.keys()[-1]\\n # print(data_stat.keys())\\n label_info = data_stat[label_col]\\n #acquire the data \\n data = map[attribute]\\n labels = map[label_col]\\n conditional_entropy =0\\n for data_type in data_info:\\n specific_entropy = 0\\n for label_type in label_info: \\n #attribute data indices where all data entries are equal to a speicifc value\\n data_with_spec_val_idx = data_info[data_type]\\n #label indices where all labels are of same value\\n spec_label_idx = label_info[label_type]\\n #the intersection of the two indices above\\n intersect_idx = np.intersect1d(data_with_spec_val_idx,spec_label_idx)\\n #conditional probability of label being of specific value given speicific data value\\n temp_prob = len(intersect_idx)/float(len(data_with_spec_val_idx))\\n if temp_prob!=0:\\n specific_entropy += temp_prob*math.log(temp_prob,2)\\n specific_entropy = -specific_entropy\\n prob = len(data_with_spec_val_idx)/float(len(data))\\n conditional_entropy += prob * specific_entropy\\n return conditional_entropy\",\n \"def joint_entropy(x, y, bins):\\n # assert array length\\n assert len(x) == len(y)\\n\\n # get the bins, x and y get their own bins in case of joint entropy\\n bins = get_2D_bins(x, y, bins)\\n\\n # get the joint histogram\\n joint_hist = np.histogram2d(x, y, bins)[0]\\n\\n # calculate the joint probability and add a small number\\n joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15\\n\\n # calculate and return the joint entropy\\n return - np.sum(joint_p * np.log2(joint_p))\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def entropy(y,w):\\r\\n\\r\\n\\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\\r\\n\\r\\n # y_partition = partition(y)\\r\\n # elements,counts = np.unique(y,return_counts = True)\\r\\n # entropy=0\\r\\n\\r\\n # for i in range(len(elements)):\\r\\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\\r\\n # return entropy\\r\\n\\r\\n entropy = 0\\r\\n # two hypothesis cases 0,1\\r\\n h = {0: 0, 1: 0}\\r\\n leny = len(y)\\r\\n for i in range(leny):\\r\\n # if y is 0 add 0 to the weight\\r\\n if y[i] == 0:\\r\\n h[0] += w[i]\\r\\n # if y is 1 add 1 to the weight\\r\\n elif y[i] == 1:\\r\\n h[1] += + w[i]\\r\\n # summing all the weighted values \\r\\n val_sum = h[0] + h[1]\\r\\n\\r\\n # entropy calculation\\r\\n for j in range(len(h)):\\r\\n h[j] = h[j]/val_sum\\r\\n # to prevent divide by zero\\r\\n if h[j] != 0:\\r\\n entropy += h[j] * np.log2(h[j])\\r\\n entropy = -(entropy)\\r\\n return entropy\",\n \"def transfer_entropy(X, Y):\\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\\n\\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\\n for y_f, x_p, y_p in coords.keys():\\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\\n\\n p_yp = p_dist.sum(axis=2).sum(axis=1)\\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\\n\\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\\n denominator[denominator == 0] = np.nan\\n\\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\\n division[division == 0] = np.nan\\n\\n log = np.log2(division)\\n\\n return np.nansum(np.multiply(p_dist, log))\",\n \"def entropy_coefficient(filter1, filter2, base=2):\\n\\n if (type(filter1) is NullField) or (type(filter2) is NullField):\\n return 0\\n\\n total_count = int(filter1.bit_size)\\n\\n f1_element_count = filter1.filter.count(True)\\n f2_element_count = filter2.filter.count(True)\\n\\n prob_f1 = f1_element_count / total_count\\n prob_f2 = f1_element_count / total_count\\n\\n e_f1 = -1.0 * total_count * prob_f1 * math.log(prob_f1) / math.log(base)\\n e_f2 = -1.0 * total_count * prob_f2 * math.log(prob_f2) / math.log(base)\\n\\n entropy = abs(e_f1 - e_f2)\\n\\n # for element_count in Counter(data).values():\\n # p = element_count / total_count\\n # entropy -= p * math.log(p, self.base)\\n\\n assert entropy >= 0\\n\\n return 1 - entropy\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def shannon_entropy(probs):\\n return -(\\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\\n )\",\n \"def compute_empirical_conditional_distribution(var1_values, var2_values):\\n conditional_distributions = {x2: {} for x2 in set(var2_values)}\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE HERE\\n #\\n \\n # Compute the empirical distribution of var2_values\\n x2_prob = compute_empirical_distribution(var2_values)\\n \\n # Compute the empirical joint distribution of var1_values and var2_values\\n joint_prob_x1_x2 = compute_empirical_distribution(list(zip(var1_values, var2_values)))\\n \\n for x2 in var2_values:\\n for x1 in var1_values:\\n conditional_distributions[x2][x1] = joint_prob_x1_x2[x1, x2]/x2_prob[x2]\\n\\n #\\n # END OF YOUR CODE\\n # -------------------------------------------------------------------------\\n\\n return conditional_distributions\",\n \"def calculate_entropy(y):\\n\\tlog2 = lambda x: math.log(x) / math.log(2)\\n\\tunique_labels = np.unique(y)\\n\\tentropy = 0\\n\\tfor label in unique_labels:\\n\\t\\tcount = len(y[y == label])\\n\\t\\tp = count / len(y)\\n\\t\\tentropy += -p * log2(p)\\n\\treturn entropy\",\n \"def information_gain(f1, f2):\\n\\n ig = ee.entropyd(f1) - conditional_entropy(f1, f2)\\n return ig\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def dist_calc(self, x, y):\\n p_xy = self.d2_bin(x, y)\\n p_x = np.sum(p_xy, axis=1)\\n p_y = np.sum(p_xy, axis=0)\\n\\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\\n\\n output = max(0.0, (1 - (info / entropy)))\\n return output\",\n \"def chl_entropy(y, base=2):\\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\\n p = p[p!=0]/float(len(y))\\n S = -1.0*sum(p*log(p))/log(base)\\n return S\",\n \"def entropy(x, bins, normalize=False, xy_probabilities=False):\\n # calculate probabilities if xy_probabilities == False\\n if xy_probabilities:\\n # if x does not sum up to 1, raise an error\\n if not np.isclose(sum(x),1,atol=0.0001):\\n raise ValueError('Probabilities in vector x do not sum up to 1.')\\n \\n # add a small number to all probabilities if zero occurs\\n if x.any(0):\\n p = x + 1e-15\\n else:\\n p = x\\n else:\\n # get the bins\\n bins = np.histogram_bin_edges(x, bins)\\n\\n # calculate the empirical probabilities\\n count = np.histogram(x, bins=bins)[0]\\n\\n # if counts should be None, raise an error\\n if np.sum(count) == 0:\\n raise ValueError('The histogram cannot be empty. Adjust the bins to ' +\\n 'fit the data')\\n # calculate the probabilities\\n p = (count / np.sum(count)) + 1e-15\\n\\n\\n # calculate the Shannon Entropy\\n if normalize:\\n # get number of bins\\n nbins = len(p)\\n # maximal entropy: uniform distribution\\n normalizer = np.log2(nbins) \\n\\n return - p.dot(np.log2(p)) / normalizer\\n else:\\n return - p.dot(np.log2(p))\",\n \"def alt_cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\\n np.std(y_arr, ddof=1) ** 2) / 2.0)\\n return delta / pooled_std\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def cond_entropy(joint_prob, cond_prob):\\n # Computing log2(P cond)\\n log2_p = (np.ma.log2(cond_prob)).filled(0)\\n # Multipling element wise the arrays\\n prod_entropy = np.multiply(joint_prob, log2_p)\\n # Getting the - sum of the resulting array.\\n H = -( np.sum(prod_entropy))\\n return H\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def div(self):\\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\\n entropies = [i * math.log(i, 2) for i in freqList]\\n entropy = -sum(entropies)\\n return entropy\",\n \"def symbolic_transfer_entropy(symX, symY):\\n\\n if len(symX) != len(symY):\\n raise ValueError('All arrays must have same length')\\n \\n symX = np.array(symX)\\n symY = np.array(symY)\\n \\n cp = symbolic_conditional_probabilities_consecutive(symX)\\n cp2 = symbolic_conditional_probabilities_consecutive_external(symX, symY)\\n jp = symbolic_joint_probabilities_consecutive_external(symX, symY)\\n \\n TE = 0\\n \\n for yi, xi, xii in list(jp.keys()):\\n try:\\n a = cp[xi,xii]\\n b = cp2[yi,xi,xii]\\n c = jp[yi,xi,xii]\\n TE += c * np.log(b / a) / np.log(2.)\\n except KeyError:\\n continue\\n except:\\n print(\\\"Unexpected Error\\\")\\n raise\\n del cp\\n del cp2\\n del jp\\n \\n return TE\",\n \"def entropyCategorical(attr, X, y):\\n uniques = X[attr].unique().tolist()\\n idxLists = []\\n entropies = []\\n weights = []\\n for u in uniques:\\n idxLists.append(X.index[X[attr] == u].tolist())\\n entropies.append(entropy(y, idxLists[-1]))\\n weights.append(len(idxLists[-1]))\\n\\n entropies = np.array(entropies).reshape(1, -1)\\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\\n weights /= np.sum(weights)\\n\\n return (uniques, idxLists, (entropies @ weights)[0, 0])\",\n \"def entropy(self):\\n raise NotImplementedError\",\n \"def entropy(self):\\r\\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)\",\n \"def _calculate_probs_and_entropy_y(self):\\n #calculate y probabilities and H(Y)\\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\\n self.lab_entropy = 0\\n s = sum(self.lab_counts.values())\\n for label, count in self.lab_counts.items():\\n self.lab_probs[label] = count / s\\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])\",\n \"def shannon_entropy(c):\\n\\n c_normalized = c / float(np.sum(c))\\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\\n return entropy\",\n \"def entropy ( target_array ):\\n return -1 * sum (\\n [\\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\\n for value in set ( target_array )\\n ]\\n ) # End entropy()\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def condentropy(truelabels, labels):\\n labels=array(labels)\\n truelabels=array(truelabels)\\n \\n condent=0.\\n for l in xrange(min(labels),max(labels)+1):\\n sublabels = truelabels[ labels==l ]\\n condent += len(sublabels)*chl_entropy( sublabels )\\n return condent/float(len(labels))\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def _entropies(self):\\n H_C = fentropy(self.row_totals)\\n H_K = fentropy(self.col_totals)\\n H_actual = fentropy(self.itervalues())\\n H_expected = H_C + H_K\\n I_CK = H_expected - H_actual\\n return H_C, H_K, I_CK\",\n \"def entropy(probabilities):\\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))\",\n \"def mutual_info(l1, l2):\\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def conditional_entropy(df, var, var_t):\\n row_list = df \\\\\\n .groupBy(var) \\\\\\n .agg(count(\\\"*\\\").alias('num_entries')) \\\\\\n .withColumn('all', lit('all')) \\\\\\n .withColumn('total_num_entries', sql_sum('num_entries').over(Window.partitionBy('all'))) \\\\\\n .withColumn('pcg', col('num_entries') / col('total_num_entries')) \\\\\\n .select(var, 'pcg').collect()\\n\\n cat_and_weight = [(r[var], r['pcg']) for r in row_list]\\n\\n return sum([w * single_entropy(df=df.filter(col(var) == c), var=var_t) for (c, w) in cat_and_weight])\",\n \"def conditional_pdf(self, x1, x2 = None):\\n return np.exp(self.conditional_logpdf(x1, x2))\",\n \"def shannon_entropy(counts):\\n freq = np.array(counts) * 1.0 / np.sum(counts)\\n return -np.sum([f * np.log2(f) for f in freq if f != 0])\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def entropy_function(c, n):\\n return -(c*1.0/n)*math.log(c*1.0/n,2)\",\n \"def entropy(img):\\n # by calculating\\n histogram = img.histogram()\\n histogram_size = sum(histogram)\\n histogram = [float(h) / histogram_size for h in histogram]\\n\\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])\",\n \"def get_entropy(distribution, samples):\\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\\n return entropy\",\n \"def mutual_information(x, y, w):\\r\\n \\r\\n\\r\\n total_entropy = entropy(y,w)\\r\\n\\r\\n partitioned_x = partition(x)\\r\\n weighted_entropy = 0\\r\\n # calculate the weighted entropy over the partition of x\\r\\n vals,counts= np.unique(x,return_counts=True)\\r\\n for key in partitioned_x:\\r\\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\\r\\n\\r\\n information_gain = total_entropy - weighted_entropy\\r\\n return information_gain\",\n \"def entropy(self, X):\\n if isinstance(X, np.ndarray):\\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\\n K = self._posterior_covariance(X)\\n L = np.linalg.cholesky(K)\\n D = len(X)\\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))\",\n \"def entropy(self, args):\\n mean, stddev = args\\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\\n entropy = dist.entropy()\\n return entropy\",\n \"def entropy(counts):\\n assert (counts >= 0).all()\\n probs = counts / counts.sum()\\n probs = probs[probs > 0] # Avoid log(0)\\n return - np.sum(probs * np.log2(probs))\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def get_entropy(*labels):\\n entropies = [] #list of entropy values from each subset\\n total = 0 #total number of datapoints\\n for subset in labels:\\n n = len(subset)\\n total += n\\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\\n entropies.append((entropy, n))\\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])\",\n \"def cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt(\\n (\\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\\n ) / (len(x_arr) + len(y_arr))\\n )\\n return delta / pooled_std\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def cohens_d(x, y):\\n nx, ny = len(x), len(y)\\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\\\\n ((nx - 1) + (ny - 1))\\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)\",\n \"def conditional_entropy(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n\\n marginals = np.nansum(P_nan, axis=1)\\n P_cond = P_nan / marginals[:, None]\\n\\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_cond)))\",\n \"def prob_larger_continuous(distr1, distr2):\\n\\n return distr1.expect(distr2.cdf)\",\n \"def _entropy2(labels, base=None):\\n\\n n_labels = len(labels)\\n\\n if n_labels <= 1:\\n return 0\\n\\n value,counts = np.unique(labels, return_counts=True)\\n probs = counts / n_labels\\n n_classes = np.count_nonzero(probs)\\n\\n if n_classes <= 1:\\n return 0\\n\\n ent = 0.\\n\\n # Compute entropy\\n base = e if base is None else base\\n for i in probs:\\n ent -= i * log(i, base)\\n\\n # quick observation shows ent between 0.0 and 4.0.\\n return ent\",\n \"def _calculate_probs_and_entropy_x(self, columns):\\n #calculate x probabilities and H(Xi)\\n #H(Xi) = Sum(x € Xi)(-P(Xi=x) * log(P(Xi=x)))\\n for col in columns:\\n self.cat_entropies[col] = 0\\n xsum = 0\\n for val in self.categories[col]:\\n self.cat_probs[col][val] = 0\\n for label in self.labels:\\n self.cat_probs[col][val] += self.cat_counts[col][label][val]\\n xsum += self.cat_probs[col][val]\\n for val in self.categories[col]:\\n self.cat_probs[col][val] /= xsum\\n self.cat_entropies[col] -= self.cat_probs[col][val] * self.log(self.cat_probs[col][val])\",\n \"def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\\n def entropy(freqDict):\\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\\n freqx = objhist(x)\\n freqy = objhist(y)\\n \\n Hx = freqx.entropy()\\n Hy = freqy.entropy()\\n Hxy = objhist(zip(x,y)).entropy()\\n M = Hx + Hy - Hxy\\n Mstar = 2*M / (Hx+Hy)\\n\\n if len(freqx)==1 or len(freqy)==1:\\n p = 1\\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\\n p = 0\\n else:\\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\\n p = (Mperms >= M).sum() / nperms\\n\\n return M, Mstar, p, Hx, Hy, Hxy\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def entropy(self):\\n Z = self.sum()\\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\\n H = 0.0\\n for x in np.nditer(self.t, op_flags=['readonly']):\\n p = x/Z\\n H += 0.0 if p==0 else -p*np.log(p)\\n return H\",\n \"def H(self, data):\\n entropy = 0\\n\\n if not data:\\n return entropy\\n\\n for x in range(256):\\n p_x = float(data.count(chr(x))) / len(data)\\n if p_x > 0:\\n entropy -= p_x * math.log(p_x, 2)\\n\\n return entropy\",\n \"def entropy_obj(self, x, h, num_samples_posterior=20, return_score=False, learn_post_sigma=True):\\n inf_dist = distributions.Normal(h, self.post_logsigma.detach().exp())\\n h_given_x = inf_dist.sample((num_samples_posterior,))\\n if len(x.size()) == 4:\\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\\n xr = x[None].repeat(num_samples_posterior, 1, 1, 1, 1)\\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1), x.size(2), x.size(3))\\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1), x.size(2), x.size(3))\\n logq = logq.view(num_samples_posterior, x.size(0))\\n w = (logq - inf_logprob).softmax(dim=0)\\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\\n weighted_fvals = (fvals * w[:, :, None, None, None]).sum(0).detach()\\n c = weighted_fvals\\n else:\\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\\n xr = x[None].repeat(num_samples_posterior, 1, 1)\\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1))\\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1))\\n logq = logq.view(num_samples_posterior, x.size(0))\\n w = (logq - inf_logprob).softmax(dim=0)\\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\\n weighted_fvals = (fvals * w[:, :, None]).sum(0).detach()\\n c = weighted_fvals\\n\\n mgn = c.norm(2, 1).mean()\\n g_error_entropy = torch.mul(c, x).mean(0).sum()\\n\\n post = distributions.Normal(h.detach(), self.post_logsigma.exp())\\n h_g_post = post.rsample()\\n joint = self.logq_joint(x.detach(), h_g_post)\\n post_ent = post.entropy().sum(1)\\n\\n elbo = joint + post_ent\\n post_loss = -elbo.mean()\\n\\n if learn_post_sigma:\\n self.post_optimizer.zero_grad()\\n post_loss.backward()\\n self.post_optimizer.step()\\n\\n if return_score:\\n return g_error_entropy, mgn, c\\n else:\\n return g_error_entropy, mgn\",\n \"def compute_dists(x, y):\\r\\n \\r\\n return (x - y.permute(0, 2, 1)) ** 2\",\n \"def entropy(d, total, word_count):\\n\\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\\n\\t# p(morf) = c(morf) / c(all)\\n\\te = 0\\n\\tfor count in d.values():\\n\\t\\tp = count/total\\n\\t\\ttype_e = - p * log2(p)\\n\\t\\te += type_e * count\\n\\treturn e / word_count\",\n \"def entropy(self, priors=None):\\n def entropy_f(x):\\n x[x != 0] *= np.log(x[x != 0])\\n return -x.sum(axis=0)\\n return self.utility(entropy_f, priors)\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p, 2)\\n for p in class_probabilities\\n if p) #ignore 0's\",\n \"def entropy(data, idxList):\\n df = data.loc[idxList]\\n counts = df.value_counts().to_numpy()\\n counts = counts.reshape(1, -1).astype(np.float32)\\n counts /= np.sum(counts)\\n log_sum = counts @ np.log2(counts.T)\\n return -log_sum[0, 0]\",\n \"def print_entropies(independent_joint_probabilities, conditional_joint_probabilities):\\n indepndent_entropy = entropy_from_probability_matrix(independent_joint_probabilities)\\n conditional_entropy = entropy_from_probability_matrix(conditional_joint_probabilities)\\n\\n print 'Independent H(X,Y) = {h}'.format(h=indepndent_entropy)\\n print 'Conditional H(X,Y) = {h}'.format(h=conditional_entropy)\\n print 'D_KL(Independent, Conditional) = {d_kl}' \\\\\\n .format(d_kl=kullback_leibler_divergence(independent_joint_probabilities, conditional_joint_probabilities))\\n print 'D_KL(Conditional, Independent) = {d_kl}' \\\\\\n .format(d_kl=kullback_leibler_divergence(conditional_joint_probabilities, independent_joint_probabilities))\\n\\n return indepndent_entropy, conditional_entropy\",\n \"def entropy_computations(\\n self,\\n between_labels=True,\\n between_images=True,\\n between_all_images=False,\\n symmetrized=True,\\n ):\\n jzazbz_dist_dict = self.jzazbz_dist_dict\\n\\n if between_labels:\\n words = self.labels_list\\n labels_entropy_dict = {}\\n labels_entropy_dict_js = {}\\n color_sym_matrix = []\\n color_sym_matrix_js = []\\n\\n for word1 in words:\\n row = []\\n row_js = []\\n for word2 in words:\\n entropy_js = js_divergence(\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n np.mean(np.array(jzazbz_dist_dict[word2]), axis=0),\\n )\\n entropy = kl_divergence(\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n symmetrized,\\n )\\n row.append(entropy)\\n row_js.append(entropy_js)\\n # these lines are for convenience; if strings are correctly synced across all data they are not needed\\n if word1 == \\\"computer science\\\":\\n labels_entropy_dict[\\\"computer_science\\\" + \\\"_\\\" + word2] = entropy\\n labels_entropy_dict_js[\\n \\\"computer_science\\\" + \\\"_\\\" + word2\\n ] = entropy_js\\n elif word2 == \\\"computer science\\\":\\n labels_entropy_dict[word1 + \\\"_\\\" + \\\"computer_science\\\"] = entropy\\n labels_entropy_dict_js[\\n word1 + \\\"_\\\" + \\\"computer_science\\\"\\n ] = entropy_js\\n else:\\n labels_entropy_dict[word1 + \\\"_\\\" + word2] = entropy\\n labels_entropy_dict_js[word1 + \\\"_\\\" + word2] = entropy_js\\n color_sym_matrix.append(row)\\n color_sym_matrix_js.append(row_js)\\n\\n self.cross_entropy_between_labels_dict = labels_entropy_dict\\n self.cross_entropy_between_labels_matrix = color_sym_matrix\\n self.cross_entropy_between_labels_dict_js = labels_entropy_dict_js\\n self.cross_entropy_between_labels_matrix_js = color_sym_matrix_js\\n\\n if between_images:\\n entropy_dict = {}\\n entropy_dict_js = {}\\n for key in jzazbz_dist_dict:\\n entropy_array = []\\n entropy_array_js = []\\n for i in range(len(jzazbz_dist_dict[key])):\\n for j in range(len(jzazbz_dist_dict[key])):\\n entropy_array_js.append(\\n js_divergence(\\n jzazbz_dist_dict[key][i], jzazbz_dist_dict[key][j]\\n )\\n )\\n entropy_array.append(\\n kl_divergence(\\n jzazbz_dist_dict[key][i],\\n jzazbz_dist_dict[key][j],\\n symmetrized,\\n )\\n )\\n entropy_dict[key] = entropy_array\\n entropy_dict_js[key] = entropy_array_js\\n\\n self.cross_entropy_between_images_dict = entropy_dict\\n self.cross_entropy_between_images_dict_js = entropy_dict_js\\n\\n if between_all_images:\\n entropy_dict_all = {}\\n color_sym_matrix_js_all = []\\n\\n for word1 in words:\\n row_js_all = []\\n for word2 in words:\\n entropy_js_all = []\\n for i in range(len(jzazbz_dist_dict[word1])):\\n for j in range(len(jzazbz_dist_dict[word2])):\\n try:\\n entropy_js_all.append(\\n js_divergence(\\n jzazbz_dist_dict[word1][i],\\n jzazbz_dist_dict[word2][j],\\n )\\n )\\n except Exception as exc:\\n self.log.error(exc)\\n entropy_js_all.append(np.mean(entropy_js))\\n entropy_dict_all[word1 + \\\"_\\\" + word2] = entropy_js_all\\n row_js_all.append(np.mean(entropy_js_all))\\n color_sym_matrix_js_all.append(row_js_all)\\n\\n self.cross_entropy_between_all_images_dict = entropy_dict_all\\n self.cross_entropy_between_all_images_matrix = color_sym_matrix_js_all\",\n \"def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))\",\n \"def entropy(self):\\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))\",\n \"def entropy(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))\",\n \"def entropy(self, base: int = None):\\n\\n # shannon entropy in nats\\n fdist_ = self.fdist\\n fdist_[\\\"prob\\\"] = fdist_[\\\"freq\\\"] / fdist_[\\\"freq\\\"].sum()\\n fdist_[\\\"logp\\\"] = np.log(fdist_[\\\"prob\\\"])\\n fdist_[\\\"nats\\\"] = -fdist_[\\\"prob\\\"] * fdist_[\\\"logp\\\"]\\n entropy_ = fdist_[\\\"nats\\\"].sum()\\n\\n # convert base\\n if base:\\n entropy_ = entropy_ / np.log(base)\\n\\n # return\\n return entropy_\",\n \"def entropy(distribution, unit=2):\\n frequencies = distribution.frequencies(normalised=True)\\n # check to see if it is a deterministic case (all but one are zero)\\n zeros_size = frequencies[frequencies == 0].size\\n if zeros_size + 1 == frequencies.size:\\n return 0\\n else:\\n return np.sum(-frequencies * np.log2(frequencies) / np.log2(unit))\",\n \"def mutual_information(x, y, bins, normalize=False):\\n # assert array length\\n assert len(x) == len(y)\\n\\n # get the bins\\n bins = get_2D_bins(x, y, bins)\\n\\n # calculate entropy(x) and conditional_entropy(x,y)\\n hx = entropy(x, bins[0])\\n hcon = conditional_entropy(x, y, bins)\\n\\n if normalize:\\n normalizer = np.min([entropy(x, bins[0]), entropy(y, bins[1])])\\n mutual_info = hx - hcon\\n\\n # check if mutual info and normalizer are very small\\n if mutual_info < 1e-4 and normalizer < 1e-4:\\n # return zero to prevent very high values of normalized mutual information\\n # e.g. mutual information = -1.3e-12, normalizer = -1.6e-12 \\n # -> normalized conditional entropy = 812.5\\n return 0\\n else:\\n return mutual_info / normalizer\\n else:\\n return hx - hcon\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p,2)\\n for p in class_probabilities\\n if p)\",\n \"def EntropyD(dist): \\n if np.any(dist>0):\\n dist2 = dist/np.sum(dist)\\n return -np.sum(dist2[dist2>0]*np.log2(dist2[dist2>0]))\\n else:\\n return 0\",\n \"def compute_entropy(bincounts, include_zeros):\\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\\n if not include_zeros:\\n bincounts = bincounts[1:]\\n mask = tf.greater(bincounts, 0)\\n nonzero_bincounts = tf.cast(\\n tf.boolean_mask(bincounts, mask), tf.float64)\\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\\n log_nonzero_bincounts)\\n entropy = tf.math.reduce_sum(\\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\\n return entropy * num_nonzero / num_total\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7481201","0.6875717","0.6782211","0.6750487","0.6720426","0.6655979","0.6648373","0.6570259","0.6566688","0.64887154","0.64597607","0.64407265","0.63953054","0.6383221","0.63512045","0.63497704","0.63459283","0.63403004","0.6330119","0.6322664","0.6289737","0.6262488","0.62549144","0.6251724","0.6230731","0.6217289","0.61961704","0.6191671","0.61783874","0.61604345","0.6134164","0.61279017","0.61182636","0.6096975","0.60740614","0.60637957","0.6060501","0.6000772","0.5995078","0.59780097","0.5965804","0.5962275","0.5938181","0.5931029","0.59214073","0.58948284","0.5884102","0.58662707","0.58644086","0.5844605","0.5844605","0.5831491","0.5826183","0.58253723","0.5824066","0.5819012","0.58132887","0.5806917","0.57983744","0.57874715","0.57716763","0.5768342","0.5764843","0.5764293","0.5762632","0.57526463","0.5746962","0.57385045","0.57261175","0.57250965","0.5715183","0.5712746","0.57112396","0.57057035","0.5703124","0.5693805","0.5688762","0.56652105","0.5663189","0.56622654","0.5652942","0.56420094","0.5633418","0.5633384","0.5622846","0.5621945","0.5621546","0.5619045","0.56153","0.5594045","0.55938196","0.5593046","0.55873567","0.55843854","0.5583587","0.5580749","0.55726624","0.55649835","0.55515546","0.55513716"],"string":"[\n \"0.7481201\",\n \"0.6875717\",\n \"0.6782211\",\n \"0.6750487\",\n \"0.6720426\",\n \"0.6655979\",\n \"0.6648373\",\n \"0.6570259\",\n \"0.6566688\",\n \"0.64887154\",\n \"0.64597607\",\n \"0.64407265\",\n \"0.63953054\",\n \"0.6383221\",\n \"0.63512045\",\n \"0.63497704\",\n \"0.63459283\",\n \"0.63403004\",\n \"0.6330119\",\n \"0.6322664\",\n \"0.6289737\",\n \"0.6262488\",\n \"0.62549144\",\n \"0.6251724\",\n \"0.6230731\",\n \"0.6217289\",\n \"0.61961704\",\n \"0.6191671\",\n \"0.61783874\",\n \"0.61604345\",\n \"0.6134164\",\n \"0.61279017\",\n \"0.61182636\",\n \"0.6096975\",\n \"0.60740614\",\n \"0.60637957\",\n \"0.6060501\",\n \"0.6000772\",\n \"0.5995078\",\n \"0.59780097\",\n \"0.5965804\",\n \"0.5962275\",\n \"0.5938181\",\n \"0.5931029\",\n \"0.59214073\",\n \"0.58948284\",\n \"0.5884102\",\n \"0.58662707\",\n \"0.58644086\",\n \"0.5844605\",\n \"0.5844605\",\n \"0.5831491\",\n \"0.5826183\",\n \"0.58253723\",\n \"0.5824066\",\n \"0.5819012\",\n \"0.58132887\",\n \"0.5806917\",\n \"0.57983744\",\n \"0.57874715\",\n \"0.57716763\",\n \"0.5768342\",\n \"0.5764843\",\n \"0.5764293\",\n \"0.5762632\",\n \"0.57526463\",\n \"0.5746962\",\n \"0.57385045\",\n \"0.57261175\",\n \"0.57250965\",\n \"0.5715183\",\n \"0.5712746\",\n \"0.57112396\",\n \"0.57057035\",\n \"0.5703124\",\n \"0.5693805\",\n \"0.5688762\",\n \"0.56652105\",\n \"0.5663189\",\n \"0.56622654\",\n \"0.5652942\",\n \"0.56420094\",\n \"0.5633418\",\n \"0.5633384\",\n \"0.5622846\",\n \"0.5621945\",\n \"0.5621546\",\n \"0.5619045\",\n \"0.56153\",\n \"0.5594045\",\n \"0.55938196\",\n \"0.5593046\",\n \"0.55873567\",\n \"0.55843854\",\n \"0.5583587\",\n \"0.5580749\",\n \"0.55726624\",\n \"0.55649835\",\n \"0.55515546\",\n \"0.55513716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71850336"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3390,"cells":{"query":{"kind":"string","value":"Mutual information Calculates the mutual information of a discrete distribution x given a known discrete distribution y. The mutual information is the amount of information that two distributions share."},"document":{"kind":"string","value":"def mutual_information(x, y, bins, normalize=False):\n # assert array length\n assert len(x) == len(y)\n\n # get the bins\n bins = get_2D_bins(x, y, bins)\n\n # calculate entropy(x) and conditional_entropy(x,y)\n hx = entropy(x, bins[0])\n hcon = conditional_entropy(x, y, bins)\n\n if normalize:\n normalizer = np.min([entropy(x, bins[0]), entropy(y, bins[1])])\n mutual_info = hx - hcon\n\n # check if mutual info and normalizer are very small\n if mutual_info < 1e-4 and normalizer < 1e-4:\n # return zero to prevent very high values of normalized mutual information\n # e.g. mutual information = -1.3e-12, normalizer = -1.6e-12 \n # -> normalized conditional entropy = 812.5\n return 0\n else:\n return mutual_info / normalizer\n else:\n return hx - hcon"},"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 mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\n def entropy(freqDict):\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\n freqx = objhist(x)\n freqy = objhist(y)\n \n Hx = freqx.entropy()\n Hy = freqy.entropy()\n Hxy = objhist(zip(x,y)).entropy()\n M = Hx + Hy - Hxy\n Mstar = 2*M / (Hx+Hy)\n\n if len(freqx)==1 or len(freqy)==1:\n p = 1\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\n p = 0\n else:\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\n p = (Mperms >= M).sum() / nperms\n\n return M, Mstar, p, Hx, Hy, Hxy","def mutual_information(x, y, w):\r\n \r\n\r\n total_entropy = entropy(y,w)\r\n\r\n partitioned_x = partition(x)\r\n weighted_entropy = 0\r\n # calculate the weighted entropy over the partition of x\r\n vals,counts= np.unique(x,return_counts=True)\r\n for key in partitioned_x:\r\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\r\n\r\n information_gain = total_entropy - weighted_entropy\r\n return information_gain","def MutualInformation(x, y, bins):\n hist_xy, x_edges, y_edges = np.histogram2d(x, y, bins)\n return sklearn.metrics.mutual_info_score(None, None, hist_xy)","def mutual_information_2d(x, y, sigma=1, normalized=False):\n \n bins = (256, 256)\n \n jh = np.histogram2d(x, y, bins=bins)[0]\n \n # smooth the jh with a gaussian filter of given sigma\n ndimage.gaussian_filter(jh, sigma=sigma, mode='constant',\n output=jh)\n \n # compute marginal histograms\n jh = jh + EPS\n sh = np.sum(jh)\n jh = jh / sh\n s1 = np.sum(jh, axis=0).reshape((-1, jh.shape[0]))\n s2 = np.sum(jh, axis=1).reshape((jh.shape[1], -1))\n \n # Normalised Mutual Information of:\n # Studholme, jhill & jhawkes (1998).\n # \"A normalized entropy measure of 3-D medical image alignment\".\n # in Proc. Medical Imaging 1998, vol. 3338, San Diego, CA, pp. 132-143.\n if normalized:\n mi = ((np.sum(s1 * np.log(s1)) + np.sum(s2 * np.log(s2)))\n / np.sum(jh * np.log(jh))) - 1\n else:\n mi = ( np.sum(jh * np.log(jh)) - np.sum(s1 * np.log(s1))\n - np.sum(s2 * np.log(s2)))\n \n return mi","def mutual_info(l1, l2):\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))","def mutual_information_from_data(X, Y, num_bins):\n N = X.size\n delta = 10e-10\n\n x_min, x_max = (X.min() - delta, X.max() + delta)\n y_min, y_max = (Y.min() - delta, Y.max() + delta)\n\n X_hist, X_bin = np.histogram(X, bins=num_bins, range=(x_min, x_max))\n Y_hist, Y_bin = np.histogram(Y, bins=num_bins, range=(y_min, y_max))\n\n X_states = np.digitize(X, X_bin)\n Y_states = np.digitize(Y, Y_bin)\n coords = Counter(zip(X_states, Y_states))\n\n joint_linear = np.zeros((config.NUM_STATES, config.NUM_STATES))\n for x, y in coords.keys():\n joint_linear[x - 1, y - 1] = coords[(x, y)] / N\n\n p_X = X_hist / N\n p_Y = Y_hist / N\n prod_XY = np.tensordot(p_X.T, p_Y, axes=0)\n\n div_XY = joint_linear / prod_XY\n div_XY[div_XY == 0] = np.nan\n\n return np.nansum(np.multiply(joint_linear, np.log2(div_XY)))","def compute_empirical_mutual_info_nats(var1_values, var2_values):\n\n # -------------------------------------------------------------------------\n # YOUR CODE HERE\n #\n\n empirical_mutual_info_nats = 0.0\n \n var1_distribution = compute_empirical_distribution(var1_values)\n var2_distribution = compute_empirical_distribution(var2_values)\n joint_distribution = compute_empirical_distribution(list(zip(var1_values,var2_values)))\n \n empirical_mutual_info_nats = 0\n for var1 in var1_distribution:\n for var2 in var2_distribution:\n empirical_mutual_info_nats += joint_distribution[(var1, var2)] \\\n * np.log(joint_distribution[(var1,var2)]/(var1_distribution[var1]*var2_distribution[var2]))\n \n #\n # END OF YOUR CODE\n # -------------------------------------------------------------------------\n\n return empirical_mutual_info_nats","def pairwiseMutualInformation(align, nperms=1e4):\n L=len(align[align.index[0]])\n columns = [align.map(lambda s: s[i]) for i in np.arange(L)]\n M = np.nan*np.zeros((L, L))\n p = np.nan*np.zeros((L, L))\n Mstar = np.nan*np.zeros((L, L))\n for xi, yi in itertools.combinations(np.arange(L), 2):\n freqx = objhist(columns[xi])\n freqy = objhist(columns[yi])\n\n tmpM, tmpMstar, tmpp, Hx, Hy, Hxy= mutual_information(columns[xi],\n columns[yi],\n logfunc=np.log2,\n nperms=nperms)\n \n \"\"\"We wouldn't need to test invariant sites or a site with itself\"\"\"\n if len(freqx) == 1 or len(freqy) == 1:\n tmpp = np.nan\n elif xi == yi:\n tmpp = np.np.nan\n\n M[xi, yi] = tmpM\n p[xi, yi] = tmpp\n Mstar[xi, yi] = tmpMstar\n q = adjustnonnan(p)\n\n return M, Mstar, p, q","def compute_dists(x, y):\r\n \r\n return (x - y.permute(0, 2, 1)) ** 2","def mi_bin(x, y, bins_x, bins_y):\n if bins_y == 0:\n bins_y = len(np.unique(y))\n # compute probabilities\n p_x = histogram(x, bins_x)\n p_y = histogram(y, bins_y)\n p_xy = histogram2d(x, y, bins_x, bins_y)\n p_x = p_x / p_x.sum()\n p_y = p_y / p_y.sum()\n p_xy = p_xy / p_xy.sum()\n # compute entropy\n h_x = entropy(p_x.astype(np.float32))\n h_y = entropy(p_y.astype(np.float32))\n h_xy = entropy(p_xy.ravel().astype(np.float32))\n # compute mutual information\n i = h_x + h_y - h_xy\n\n return i","def mutual_information(co_freq, s_freq, t_freq, total_instances, mitype=None):\n if co_freq > 0:\n if mitype is not None:\n if mitype == \"expected\":\n mi = math.log2(\n (total_instances * co_freq) / (s_freq * t_freq)\n ) * (co_freq / total_instances)\n elif mitype == \"normalized\":\n alpha = - math.log2(co_freq / total_instances)\n mi = (\n (math.log2(\n (total_instances * co_freq) / (s_freq * t_freq)) / alpha)\n if alpha != 0 else 0\n )\n elif mitype == \"pmi2\":\n mi = math.log2((co_freq ** 2) / (s_freq * t_freq))\n elif mitype == \"pmi3\":\n mi = math.log2(\n (co_freq ** 3) / (s_freq * t_freq * total_instances))\n else:\n raise ValueError(\n \"Provided Mutual information score type (mitype) is not \"\n \"supported. Provide one value from the following list \"\n \"['expected', 'normalized','pmi2', 'pmi3'] \")\n else:\n mi = math.log2((total_instances * co_freq) / (s_freq * t_freq))\n else:\n mi = 0\n return mi if mi > 0 else 0","def mutual_information(transposed, transposed_2 = False):\n\tmi = []\n\tlength = range(len(transposed))\n\tfor i in length:\n\t\tentropy_i = entropy(transposed[i])\n\t\tmi_list = []\n\t\tif transposed_2 == False:\n\t\t\tfor j in length:\n\t\t\t\tentropy_j = entropy(transposed[j])\n\t\t\t\tjoint = joint_entropy(transposed[i], transposed[j])\n\t\t\t\tmi_calc = entropy_i + entropy_j - joint\n\t\t\t\tmi_list.append(mi_calc)\n\t\t\tmi.append(mi_list)\n\n\t\telse:\n\t\t\tlength_2 = range(len(transposed_2))\n\t\t\tfor j in length_2:\n\t\t\t\tentropy_j = entropy(transposed_2[j])\n\t\t\t\tjoint = joint_entropy(transposed[i], transposed_2[j])\n\t\t\t\tmi_calc = entropy_i + entropy_j - joint\n\t\t\t\tmi_list.append(mi_calc)\n\t\t\tmi.append(mi_list)\n\treturn mi","def mutual_information(transposed, transposed_2 = False):\n\tmi = []\n\tlength = range(len(transposed))\n\tfor i in length:\n\t\tentropy_i = entropy(transposed[i])\n\t\tmi_list = []\n\t\tif transposed_2 == False:\n\t\t\tfor j in length:\n\t\t\t\tentropy_j = entropy(transposed[j])\n\t\t\t\tjoint = joint_entropy(transposed[i], transposed[j])\n\t\t\t\tmi_calc = entropy_i + entropy_j - joint\n\t\t\t\tmi_list.append(mi_calc)\n\t\t\tmi.append(mi_list)\n\n\t\telse:\n\t\t\tlength_2 = range(len(transposed_2))\n\t\t\tfor j in length_2:\n\t\t\t\tentropy_j = entropy(transposed_2[j])\n\t\t\t\tjoint = joint_entropy(transposed[i], transposed_2[j])\n\t\t\t\tmi_calc = entropy_i + entropy_j - joint\n\t\t\t\tmi_list.append(mi_calc)\n\t\t\tmi.append(mi_list)\n\treturn mi","def mutual_information_brute_force(self, ret_prob_activity=False):\n base = 2 ** np.arange(0, self.Nr)\n\n # prob_a contains the probability of finding activity a as an output.\n prob_a = np.zeros(2**self.Nr)\n for c, prob_c in self._iterate_mixtures():\n # get the associated output ...\n a = np.dot(self.sens_mat, c).astype(np.bool)\n # ... and represent it as a single integer\n a = np.dot(base, a)\n\n prob_a[a] += prob_c\n \n # normalize the output to make it a probability distribution\n prob_a /= prob_a.sum()\n \n # calculate the mutual information\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\n \n if ret_prob_activity:\n return MI, prob_a\n else:\n return MI","def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))","def dist_calc(self, x, y):\n p_xy = self.d2_bin(x, y)\n p_x = np.sum(p_xy, axis=1)\n p_y = np.sum(p_xy, axis=0)\n\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\n\n output = max(0.0, (1 - (info / entropy)))\n return output","def get_information_y_hat(x_pub, x_priv, x_joint, y_hat, num_of_bins_y):\n\tprint('Start calculating the information for y_hat...')\n\ty_hat = np.array(y_hat).astype(np.float)\n\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\n\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(y_hat, x_pub)\n\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\n\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(y_hat, x_joint)\n\t# Shannon Entropy over label\n\tH2Y_hat = -np.sum(pys_hat * np.log2(pys_hat))\n\t# mutual Information between secret layer and label\n\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\n\t# mutual Information between secret layer and label\n\tMI_pub_y_hat = calc_information_for_inp_out(pxs_pub,pys_hat,y_hat,unique_inverse_x_pub)\n\treturn H2Y_hat, MI_pri_y_hat, MI_pub_y_hat","def get_mi_mvn(x, y):\n\n d = x.shape[1]\n\n # hx = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(x.T)))\n # hy = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(y.T)))\n # hxy = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=y.T)))\n # mi = hx + hy - hxy\n\n # hx = 0.5 * log(det(2*np.pi*np.e*np.cov(x.T)))\n # hy = 0.5 * log(det(2*np.pi*np.e*np.cov(y.T)))\n # hxy = 0.5 * log(det(2*np.pi*np.e*np.cov(np.c_[x,y].T)))\n hx = get_h_mvn(x)\n hy = get_h_mvn(y)\n hxy = get_h_mvn(np.c_[x,y])\n mi = hx + hy - hxy\n\n # mi = 0.5 * (log(det(np.cov(x.T))) + log(det(np.cov(y.T))) - log(det(np.cov(np.c_[x,y].T))))\n\n return mi","def symbolic_mutual_information(symX, symY):\n\n if len(symX) != len(symY):\n raise ValueError('All arrays must have same length')\n \n symX = np.array(symX)\n symY = np.array(symY)\n \n symbols = np.unique(np.concatenate((symX,symY))).tolist()\n \n jp = symbolic_joint_probabilities(symX, symY)\n pX = symbolic_probabilities(symX)\n pY = symbolic_probabilities(symY)\n \n MI = 0\n\n for yi, b in pY.items():\n for xi, a in pX.items():\n try:\n c = jp[yi,xi]\n MI += c * np.log(c /(a * b)) / np.log(len(symbols))\n except KeyError:\n continue\n except:\n print(\"Unexpected Error\")\n raise\n \n return MI","def mutual_information(mc_preds):\n mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),\n axis=0)\n return mutual_info","def metric(x, y):\n d = 2\n summ = []\n i = 0\n while i < len(x):\n # in this case use euclidean distance\n summ.append((x[i] - y[i])**d)\n i = i + 1\n return sum(summ) ** (1 / float(d))","def get_information_priv_y_hat(x_priv, y_hat, num_of_bins_y):\n\tprint('Start calculating the information for y_hat...')\n\ty_hat = np.array(y_hat).astype(np.float)\n\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\n\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\n\t# mutual Information between secret layer and label\n\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\n\treturn MI_pri_y_hat.astype(np.float32)","def synergy(g1, g2, c):\n return mutual_info(joint_dataset(g1, g2), c) -\\\n mutual_info(g1, c) - mutual_info(g2, c)","def mutual_information_estimate(self, approx_prob=False):\n \n # this might be not the right approach\n q_n = self.receptor_activity_estimate(approx_prob=approx_prob)\n q_nm = self.receptor_crosstalk_estimate(approx_prob=approx_prob)\n \n # calculate the approximate mutual information\n return self._estimate_MI_from_q_values(q_n, q_nm)","def get_dists_2():\n d1 = Distribution(['0', '1'], [1 / 2, 1 / 2])\n d2 = Distribution(['0', '1'], [1 / 3, 2 / 3])\n d3 = Distribution(['0', '1'], [2 / 5, 3 / 5])\n return d1, d2, d3","def normalized_mutual_information(cl: np.ndarray, org: np.ndarray):\n assert cl.shape == org.shape\n\n return mutual_info_score(org, cl) / (abs(entropy(cl) + entropy(org)) / 2)","def mutual_information(self, excitation_method='auto', **kwargs):\n if excitation_method == 'auto':\n if self.Ns <= self.parameters['brute_force_threshold_Ns']:\n excitation_method = 'brute_force'\n else:\n excitation_method = 'monte_carlo'\n \n if excitation_method == 'brute_force' or excitation_method == 'brute-force':\n return self.mutual_information_brute_force(**kwargs)\n elif excitation_method == 'monte_carlo' or excitation_method == 'monte-carlo':\n return self.mutual_information_monte_carlo(**kwargs)\n elif excitation_method == 'estimate':\n return self.mutual_information_estimate(**kwargs)\n else:\n raise ValueError('Unknown excitation_method `%s`.' % excitation_method)","def mutual_information(pi, pj, pij):\n p_i = 1 - pi\n p_j = 1 - pj\n p_ij = pj - pij\n pi_j = pi - pij\n p_i_j = 1 - pi - pj + pij\n \n log_pi = log(pi)\n log_pj = log(pj)\n log_p_i = log(p_i)\n log_p_j = log(p_j)\n \n mi = pij * (log(pij) - log_pi - log_pj) + \\\n pi_j * (log(pi_j) - log_pi - log_p_j) + \\\n p_i_j * (log(p_i_j) - log_p_i - log_p_j)\n if p_ij != 0: # For language groups and features, this is the only probability that could be zero, and lim_x->0[x*log(x)] = 0 \n mi += p_ij * (log(p_ij) - log_p_i - log_pj)\n \n return mi","def mattes_mutual_information(fixed, moving, bins_count=24, pixels_fraction=None, **kwargs) :\n \n pixels_count = 0\n if isinstance(fixed, medipy.base.Image) :\n pixels_count = numpy.prod(fixed.shape)\n FixedImageType = medipy.itk.itk_image_type(fixed)\n else :\n pixels_count = numpy.prod(fixed.GetLargestPossibleRegion().GetSize())\n FixedImageType = fixed\n \n if isinstance(moving, medipy.base.Image) :\n pixels_count = max(pixels_count, numpy.prod(moving.shape))\n MovingImageType = medipy.itk.itk_image_type(moving)\n else :\n pixels_count = max(pixels_count, numpy.prod(moving.GetLargestPossibleRegion().GetSize()))\n MovingImageType = moving\n\n arguments = {}\n \n # Medimax : recalage/imx_mtch.c:erreur_IM : histograms have 250 bins. We use\n # ITK suggested value\n arguments[\"NumberOfHistogramBins\"] = int(bins_count)\n arguments[\"UseAllPixels\"] = True\n\n if pixels_fraction is not None :\n arguments[\"NumberOfSpatialSamples\"] = int(pixels_fraction*pixels_count)\n\n #if pixels_fraction is None :\n # if kwargs == {} :\n # arguments[\"UseAllPixels\"] = False\n # arguments[\"NumberOfSpatialSamples\"] = int(0.1*pixels_count)\n # elif kwargs.get(\"all_pixels\", False) :\n # arguments[\"UseAllPixels\"] = True\n # elif \"spatial_samples_count\" in kwargs :\n # arguments[\"UseAllPixels\"] = False\n # arguments[\"NumberOfSpatialSamples\"] = kwargs[\"spatial_samples_count\"]\n # else :\n # raise Exception(\"Incorrect arguments\")\n #else :\n # arguments[\"UseAllPixels\"] = False\n # arguments[\"NumberOfSpatialSamples\"] = int(pixels_fraction*pixels_count)\n \n metric = itk.MattesMutualInformationImageToImageMetric[\n FixedImageType, MovingImageType].New(**arguments)\n\n return metric","def make_likelihood_table(x, y):\n\n Y = np.unique(y)\n X = np.unique(x)\n\n likelihood = [[0 for i in range(len(Y))] for j in range(len(X))]\n\n freq = make_frequency_table(x, y, X, Y)\n\n for j in range(len(Y)):\n Sum = (y == Y[j]).sum()\n for i in range(len(X)):\n likelihood[i][j] = freq[X[i]][j] / Sum\n\n return likelihood","def mutual_information(self,max_lag):\n\n digi = utilities.mi_digitize(self.X)\n\n mi = np.empty(max_lag)\n\n for i in range(max_lag):\n\n ind = i+1\n unshift = digi[ind:]\n shift = digi[0:-ind]\n\n mi[i] = skmetrics.mutual_info_score(unshift,shift)\n\n return mi","def get_mutual_information(c_wic, c_wioc, c_owic, c_owioc):\n # total word count\n c_total = c_wic + c_wioc + c_owic + c_owioc\n\n mi_1 = (c_wic / float(c_total)) * log10((c_total * c_wic) /\n float((c_wic + c_wioc) * (c_wic + c_owic)))\n mi_2 = (c_owic / float(c_total)) * log10((c_total * c_owic) /\n float((c_owic + c_owioc) * (c_wic + c_owic)))\n mi_3 = (c_wioc / float(c_total)) * log10((c_total * c_wioc) /\n float((c_wic + c_wioc) * (c_wioc + c_owioc)))\n mi_4 = (c_owioc / float(c_total)) * log10((c_total * c_owioc) /\n float((c_owic + c_owioc) * (c_wioc + c_owioc)))\n\n return mi_1 + mi_2 + mi_3 + mi_4","def mass_based_dissimilarity(self, x1, x2):\n # In each i-tree, find lowest nodes containing both x and y\n # TODO: parallelize\n sum_masses = 0\n for itree in self.random_itrees:\n # Divide each sum by size of subset used to construct the trees.\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.","def compute_information_gain(Y, xi):\r\n H_Y = H(Y)\r\n\r\n TrainSet = np.delete(AllSets[2], -1, axis=1)\r\n ColumnInd = AllSets[3].index(xi) # extract from dictionary\r\n\r\n NumHeadlines = AllSets[2].shape[0]\r\n AllOccurences, Count = np.unique(AllSets[2][:, ColumnInd], return_counts=True)\r\n\r\n TotalH_YGivenX = 0\r\n for i, count in zip(AllOccurences, Count):\r\n NewY = Y[TrainSet[:, ColumnInd] == i]\r\n\r\n TotalH_YGivenX += H(NewY) * float(count) / NumHeadlines\r\n\r\n return H_Y - TotalH_YGivenX","def mutual_information_union(p1, p2, measure=normalized_mutual_info_score):\n nodes = sorted(set(p1.keys()) | set(p2.keys()))\n if nodes == []: return 0\n return measure(\n [p1[n] if n in p1 else np.random.randint(1e12) for n in nodes],\n [p2[n] if n in p2 else np.random.randint(1e12) for n in nodes]\n )","def calc_mutual_information(probability_mat):\n\n marginals = sp.outer(\n sp.sum(probability_mat, axis=1), sp.sum(probability_mat, axis=0))\n p = probability_mat[probability_mat != 0.0]\n m = marginals[probability_mat != 0.0]\n return sp.sum(p * sp.log(p / m))","def mi(x,y,k=3,base=2):\n x = [[entry] for entry in x]\n y = [[entry] for entry in y]\n assert len(x)==len(y), \"Lists should have same length\"\n assert k <= len(x) - 1, \"Set k smaller than num. samples - 1\"\n intens = 1e-10 #small noise to break degeneracy, see doc.\n x = [list(p + intens*nr.rand(len(x[0]))) for p in x]\n y = [list(p + intens*nr.rand(len(y[0]))) for p in y]\n points = zip2(x,y)\n #Find nearest neighbors in joint space, p=inf means max-norm\n tree = ss.cKDTree(points)\n dvec = [tree.query(point,k+1,p=float('inf'))[0][k] for point in points]\n a,b,c,d = avgdigamma(x,dvec), avgdigamma(y,dvec), digamma(k), digamma(len(x)) \n return (-a-b+c+d)/log(base)","def get_mutual_information_table(self, dims_to_use=None, ignore_negative_values=True, use_correlation=False):\n from mlabwrap import mlab\n bad_dims = self.get_markers('surface_ignore')\n bad_dims.append('Cell Length')\n bad_dims.append('Time')\n bad_dims.append('191-DNA')\n bad_dims.append('193-DNA')\n bad_dims.append('103-Viability')\n bad_dims.append('cluster_name')\n bad_dims.append('stim')\n bad_dims.append('cluster_num')\n if not dims_to_use:\n dims_to_use = self.dims[:]\n dims_to_use = [d for d in dims_to_use if not d in bad_dims] \n num_dims = len(dims_to_use)\n res = np.zeros((num_dims, num_dims))\n logging.info(\n 'Calculating mutual information for %d pairs...' % ((num_dims ** 2 - num_dims) / 2))\n timer = MultiTimer((num_dims ** 2 - num_dims) / 2)\n for i in xrange(num_dims):\n for j in xrange(i):\n arr = self.get_points(dims_to_use[i], dims_to_use[j])\n if ignore_negative_values:\n arr = arr[np.all(arr > 0, axis=1)]\n if arr.shape[0] < 100:\n logging.warning('Less than 100 cells in MI calculation for (%s, %s)' % (dims_to_use[i], dims_to_use[j]))\n res[j,i] = 0\n res[i,j] = 0\n continue\n if use_correlation:\n res[i,j] = np.corrcoef(arr.T[0], arr.T[1])[0,1]\n else:\n res[i,j] = mlab.mutualinfo_ap(arr, nout=1)\n res[j,i] = res[i,j]\n timer.complete_task('%s, %s' % (dims_to_use[i], dims_to_use[j]))\n return DataTable(res, dims_to_use)","def nmi(ypred, y):\n# print (ypred)\n# print (y)\n return normalized_mutual_info_score(y,ypred)","def associate_comp(x, y):\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])","def adjusted_mutual_info(self):\n # Prepare row totals and check for special cases\n row_totals = np.fromiter(self.iter_row_totals(), dtype=np.int64)\n col_totals = np.fromiter(self.iter_col_totals(), dtype=np.int64)\n R = len(row_totals)\n C = len(col_totals)\n if R == C == 1 or R == C == 0:\n # No clustering since the data is not split. This is a perfect match\n # hence return 1.0.\n return 1.0\n\n # In one step, calculate entropy for each labeling and mutual\n # information\n h_true, h_pred, mi = self._entropies()\n mi_max = max(h_true, h_pred)\n\n # Calculate the expected value for the MI\n emi = emi_from_margins(row_totals, col_totals)\n\n # Calculate the adjusted MI score\n ami = (mi - emi) / (mi_max - emi)\n return ami","def d_mse(x, y):\n\n return 2 * (x - y) / x.size(0) / x.size(1)","def mutual_info_score(self):\n _, _, I_CK = self._entropies()\n return I_CK / self.grand_total","def __mul__(self, y):\n sum = 0\n x = self\n if len(x) > len(y):\n x, y = y, x\n for key in x:\n if key not in y:\n continue\n sum += x[key] * y[key]\n return sum","def __mul__(self, y):\n sum = 0\n x = self\n if len(x) > len(y):\n x, y = y, x\n for key in x:\n if key not in y:\n continue\n sum += x[key] * y[key]\n return sum","def _information_gain(self, y, subsets):\n n = y.shape[0]\n child_entropy = 0\n\n for y_i in subsets:\n child_entropy += self._entropy(y_i) * y_i.shape[0] / float(n)\n\n return self._entropy(y) - child_entropy","def mutual_information_intersection(p1, p2, measure=normalized_mutual_info_score):\n nodes = sorted(set(p1.keys()) & set(p2.keys()))\n if nodes == []: return 0\n return measure(\n [p1[n] for n in nodes],\n [p2[n] for n in nodes]\n )","def marginalDistribution(self, x, variable):\n return self._distribution.marginal(x, variable)","def mutual_info_score(labels_true, labels_pred):\n ct = ContingencyTable.from_labels(labels_true, labels_pred)\n return ct.mutual_info_score()","def rmsd(x, y):\n\n # get the length of the dataset\n n, = x.shape\n\n return np.sqrt(np.sum((x-y)**2)/n)","def manhattan(x, y):\n md = np.sum(abs(x-y))\n # print md\n return md","def mutual_info_matrix(time_series, num_of_bins):\n num_of_rafts, interval_width = time_series.shape\n mi_matrix = np.zeros((num_of_rafts, num_of_rafts))\n\n for i in range(num_of_rafts):\n for j in range(i + 1):\n i0 = time_series[i, :].copy()\n j0 = time_series[j, :].copy()\n c_xy = np.histogram2d(i0, j0, num_of_bins)[0]\n mi = mutual_info_score(None, None, contingency=c_xy) * np.log2(np.e)\n # in unit of bits, * np.log2(np.e) to convert nats to bits\n mi_matrix[i, j] = mi\n mi_matrix[j, i] = mi\n\n return mi_matrix","def probabilities(self, x, y):\n return self.feed_and_return(x, y, self.network.a)","def mutual_info(a,b,c,n):\r\n if a == 0: \r\n return 0\r\n print(a,b,c,n) \r\n return log10((a * n) / ((a + c) * (a + b)))","def Pdist2(x, y):\r\n x_norm = (x ** 2).sum(1).view(-1, 1)\r\n if y is not None:\r\n y_norm = (y ** 2).sum(1).view(1, -1)\r\n else:\r\n y = x\r\n y_norm = x_norm.view(1, -1)\r\n Pdist = x_norm + y_norm - 2.0 * torch.mm(x, torch.transpose(y, 0, 1))\r\n Pdist[Pdist<0]=0\r\n return Pdist","def mutual_information_spatial(self,max_lag,percent_calc=.5,digitize=True):\n if digitize:\n M = utilities.mi_digitize(self.X)\n else:\n M = self.X\n\n rs, cs = np.shape(M)\n\n rs_iters = int(rs*percent_calc)\n cs_iters = int(cs*percent_calc)\n\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\n\n\n # The r_picks are used to calculate the MI in the columns\n # and the c_picks are used to calculate the MI in the rows\n\n c_mi = np.zeros((rs_iters,max_lag))\n r_mi = np.zeros((cs_iters,max_lag))\n\n for i in range(rs_iters):\n for j in range(max_lag):\n\n ind = j+1\n unshift = M[r_picks[i],ind:]\n shift = M[r_picks[i],:-ind]\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n for i in range(cs_iters):\n for j in range(max_lag):\n\n ind=j+1\n unshift = M[ind:, c_picks[i]]\n shift = M[:-ind, c_picks[i]]\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\n\n r_mut = np.mean(r_mi,axis=0)\n c_mut = np.mean(c_mi,axis=0)\n\n return r_mut, c_mut, r_mi, c_mi","def __mul__(self, other):\n\n\t\tassert set(self.keys()) == set(other.keys())\n\t\tdistribution, total = {}, 0.0\n\n\t\tfor key in self.keys():\n\t\t\tx, y = self.probability(key), other.probability(key)\n\t\t\tdistribution[key] = (x + eps) * (y + eps)\n\t\t\ttotal += distribution[key]\n\n\t\tfor key in self.keys():\n\t\t\tdistribution[key] /= total\n\n\t\t\tif distribution[key] <= eps / total:\n\t\t\t\tdistribution[key] = 0.0\n\t\t\telif distribution[key] >= 1 - eps / total:\n\t\t\t\tdistribution[key] = 1.0\n\n\t\treturn DiscreteDistribution(distribution)","def Dist(p1,p2):\n x1, y1 = p1\n x2, y2 = p2\n return (((x1-x2)*(x1-x2)) + ((y1-y2)*(y1-y2)))**0.5","def get_information(ws_pub, ws_priv, ws_joint, x_pub, x_priv, x_joint, y, num_of_bins, num_of_bins_y,\n\t\t\t\t\tinterval_information_display, calc_parallel=True, py_hats=0):\n\tprint('Start calculating the information...')\n\tbins = np.linspace(-1, 1, num_of_bins)\n\ty = np.array(y).astype(np.float)\n\tpys1, unique_inverse_y,label = extract_probs_label(y,num_of_bins_y)\n\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(label, x_pub)\n\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(label, x_priv)\n\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(label, x_joint)\n\t# Shannon Entropy over label\n\tH2Label = -np.sum(pys1 * np.log2(pys1))\n\t# mutual Information between secret layer and label\n\tMI_pri_label = calc_information_for_inp_out(pxs_priv,pys1,label,unique_inverse_x_priv)\n\t# mutual Information between secret layer and label\n\tMI_pub_label = calc_information_for_inp_out(pxs_pub,pys1,label,unique_inverse_x_pub)\n\n\tif calc_parallel:\n\t\tprint('calculating the information for public layer...')\n\t\tparams_pub = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\n\t\t (i, interval_information_display, ws_pub[i], bins, unique_inverse_x_pub,\n\t\t\t\t\t\t\t\t\tunique_inverse_y, label, b_pub, b1_pub, len(unique_a_pub),\n\t\t \t\t\t\t\tpxs_pub, p_y_given_x_pub, pys1)\n\t\t for i in range(len(ws_pub))))\n\t\tprint('calculating the information for secret layer...')\n\t\tparams_priv = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\n\t\t (i, interval_information_display, ws_priv[i], bins, unique_inverse_x_priv,\n\t\t\t\t\t\t\t\t\tunique_inverse_y, label, b_priv, b1_priv, len(unique_a_priv),\n\t\t \t\t\t\t\tpxs_priv, p_y_given_x_priv, pys1)\n\t\t for i in range(len(ws_priv))))\n\t\tprint('calculating the information for joint layer...')\n\t\tparams_joint = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\n\t\t (i, interval_information_display, ws_joint[i], bins, unique_inverse_x_joint,\n\t\t\t\t\t\t\t\t\tunique_inverse_y, label, b_joint, b1_joint, len(unique_a_joint),\n\t\t \t\t\t\t\tpxs_joint, p_y_given_x_joint, pys1)\n\t\t for i in range(len(ws_joint))))\n\n\telse:\n\t\tparams_pub = np.array([calc_information_for_epoch\n\t\t\t\t\t\t\t\t(i, interval_information_display, ws_pub[i], bins, unique_inverse_x_pub,\n\t\t\t\t\t\t\t\tunique_inverse_y, label, b_pub, b1_pub, len(unique_a_pub),\n\t\t\t\t\t\t\t\tpxs_pub, p_y_given_x_pub, pys1)\n\t\t \t\tfor i in range(len(ws_pub))])\n\t\tparams_priv = np.array([calc_information_for_epoch\n\t\t (i, interval_information_display, ws_priv[i], bins, unique_inverse_x_priv,\n\t\t\t\t\t\t\t\t\tunique_inverse_y, label, b_priv, b1_priv, len(unique_a_priv),\n\t\t \t\t\t\t\tpxs_priv, p_y_given_x_priv, pys1)\n\t\t for i in range(len(ws_priv))])\n\t\tparams_joint = np.array([calc_information_for_epoch\n\t\t (i, interval_information_display, ws_joint[i], bins, unique_inverse_x_joint,\n\t\t\t\t\t\t\t\t\tunique_inverse_y, label, b_joint, b1_joint, len(unique_a_joint),\n\t\t \t\t\t\t\tpxs_joint, p_y_given_x_joint, pys1)\n\t\t for i in range(len(ws_joint))])\n\treturn params_pub, params_priv, params_joint, H2Label, MI_pri_label, MI_pub_label","def calculateDist(kSet1, kSet2, x, y, group, iteration):\n\tkSet1Dist = 0\n\tkSet2Dist = 0\n\t\n\tfor j in range(len(x)):\n\t\tk1Dist = math.sqrt((x[j] - kSet1[0])**2 + (y[j] - kSet1[1])**2)\n\t\tk2Dist = math.sqrt((x[j] - kSet2[0])**2 + (y[j] - kSet2[1])**2)\n\n\t\tif(k1Dist < k2Dist):\n\t\t\tgroup[iteration].append(1)\n\t\t\tkSet1Dist += k1Dist\n\t\telse:\n\t\t\tgroup[iteration].append(2)\n\t\t\tkSet2Dist += k2Dist\n\n\treturn group","def hammingDist(x, y):\n hd = 0\n for ch1, ch2 in zip(x, y):\n if ch1 != ch2:\n hd += 1\n return hd","def _compute_x2_statistic(self, expected, actual):\n rng = expected.keys()\n if actual.keys() != rng:\n raise Exception(\"Ranges of two frequencies are not equal.\")\n num_observations = sum([actual[r] for r in rng])\n if abs(num_observations - sum([expected[r] for r in rng])) > _FLOAT_EQ_DELTA:\n raise Exception(\"Frequencies must sum to the same value.\")\n chi_squared_stat = sum([(actual[r] - expected[r])**2 / max(float(expected[r]), 1.0)\n for r in rng])\n p_value = 1 - stats.chi2.cdf(x=chi_squared_stat, # Find the p-value\n df=len(rng))\n return chi_squared_stat, p_value","def example_A():\n d = dit.example_dists.Xor()\n\n # Calculate marginal maximum entropy distributions up to order 3.\n maxent_dists = dit.algorithms.marginal_maxent_dists(d, 3)\n\n print_output(d, maxent_dists)\n\n return maxent_dists","def nmi(y_pred, y_true, average_method='geometric'):\n return metrics.normalized_mutual_info_score(y_true, y_pred, average_method=average_method)","def mcd(x, y):\n r = x % y\n if r == 0:\n return y\n else:\n return mcd(y, r)","def _densityctr(self, rangex, rangey, dim = misc.DEF_VIS_DIM):\n gr = N.meshgrid(rangex, rangey)\n x = gr[0].flatten()\n y = gr[1].flatten()\n xdata = N.concatenate((x[:, N.newaxis], y[:, N.newaxis]), axis = 1)\n dmu = self.mu[:, dim]\n dva = self._get_va(dim)\n den = GM.fromvalues(self.w, dmu, dva).pdf(xdata, log = True)\n den = den.reshape(len(rangey), len(rangex))\n\n return gr[0], gr[1], den","def _compute_prob_y_given_x(self, _x, _y):\n normalisation_constant = sum([\n math.exp(sum([self.weights[_feature] *\n self.feature_funcs[_feature, cls](_feature, cls)\n for _feature in _x]))\n for cls in self.classes])\n\n return math.exp(sum([\n self.weights[_feature] *\n self.feature_funcs[_feature, _y](_feature, _y)\n for _feature in _x])) / normalisation_constant","def L2_dists(x, y):\n #print(x.shape)\n #print(y.shape)\n dists = -2 * np.matmul(x, y.T)\n dists += np.sum(x**2)[np.newaxis]\n dists += np.sum(y**2)\n return np.sqrt(dists)","def cid(x, y):\n assert(len(x.shape) == 2 and x.shape == y.shape) # time series must have same length and dimensionality\n ce_x = np.sqrt(np.sum(np.square(np.diff(x, axis=0)), axis=0) + 1e-9)\n ce_y = np.sqrt(np.sum(np.square(np.diff(y, axis=0)), axis=0) + 1e-9)\n d = np.sqrt(np.sum(np.square(x - y), axis=0)) * np.divide(np.maximum(ce_x, ce_y), np.minimum(ce_x, ce_y))\n return np.sum(d)","def occupation_distribution(data):","def mutual_information_monte_carlo_extrapolate(self, ret_prob_activity=False):\n if self.is_correlated_mixture:\n raise NotImplementedError('Not implemented for correlated mixtures')\n \n base = 2 ** np.arange(0, self.Nr)\n prob_s = self.substrate_probabilities\n\n max_steps = self._sample_steps\n steps, MIs = [], []\n\n # sample mixtures according to the probabilities of finding\n # substrates\n count_a = np.zeros(2**self.Nr)\n step_check = 10000\n for step in range(max_steps):\n # choose a mixture vector according to substrate probabilities\n m = (np.random.random(self.Ns) < prob_s)\n \n # get the associated output ...\n a = np.dot(self.sens_mat, m).astype(np.bool)\n # ... and represent it as a single integer\n a = np.dot(base, a)\n # increment counter for this output\n count_a[a] += 1\n\n if step == step_check - 1:\n # do an extrapolation step\n # calculate the mutual information from the result pattern\n prob_a = count_a / step\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\n \n # save the data \n steps.append(step)\n MIs.append(MI)\n \n # do the extrapolation\n if len(steps) >= 3:\n a2, a1, a0 = MIs[-3:]\n MI_ext = (a0*a2 - a1*a1)/(a0 - 2*a1 + a2)\n# MI_ext = self._get_extrapolated_mutual_information(steps, MIs)\n print((step, MIs[-1], MI_ext))\n \n step_check += 10000\n \n else:\n # count_a contains the number of times output pattern a was observed.\n # We can thus construct P_a(a) from count_a. \n \n # calculate the mutual information from the result pattern\n prob_a = count_a / step\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\n\n if ret_prob_activity:\n return MI, prob_a\n else:\n return MI","def get_trans_pmi(x2ys, x2cnt, y2cnt, Nxy, Nx, Ny, width, n_trans):\n x2ys_pmi = dict()\n pmi_diff = -np.log2(Nxy) + np.log2(Nx) + np.log2(Ny)\n for x, ys in tqdm(x2ys.items()):\n l_scores = []\n for y, cnt in sorted(ys.items(), key=operator.itemgetter(1),\n reverse=True)[:width]:\n pmi = np.log2(cnt) - np.log2(x2cnt[x]) - np.log2(y2cnt[y])\n pmi += pmi_diff\n l_scores.append((y, pmi))\n trans = sorted(l_scores, key=operator.itemgetter(1, 0), reverse=True)[:n_trans]\n trans = [each[0] for each in trans]\n x2ys_pmi[x] = trans\n\n return x2ys_pmi","def dist(self, X, Y):\n raise NotImplementedError","def conditional_MI(data=None, x=None, y=None, z=None):\n X = data[list(x)].astype(int)\n Y = data[list(y)].astype(int)\n t = list(z)\n Z = data[t].astype(int)\n Z = Z.values.tolist()\n Z = list(data[t].itertuples(index=False, name=None))\n Hxz = entropy(map(lambda x: \"%s/%s\" % x, zip(X, Z))) # Finding Joint entropy of X and Z\n Hyz = entropy(map(lambda x: \"%s/%s\" % x, zip(Y, Z))) # Finding Joint entropy of Y and Z\n Hz = entropy(Z) # Finding Entropy of Z\n Hxyz = entropy(map(lambda x: \"%s/%s/%s\" % x, zip(X, Y, Z))) # Finding Joint Entropy of X, Y and Z\n return Hxz + Hyz - Hxyz - Hz","def mutual_information_from_table(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n\n marginals_p1 = np.nansum(P_nan, axis=1)\n marginals_p2 = np.nansum(P_nan, axis=0)\n\n return np.nansum(np.multiply(P_nan, np.log2(P_nan / (np.tensordot(marginals_p1, marginals_p2, axes=0)))))","def information_gain(Y, attr):\n initial_gain = entropy(Y)\n\n temp_Y = Y.tolist()\n temp_attr = attr.tolist()\n\n temp_attr = list(np.unique(attr))\n\n for a in temp_attr:\n l = []\n count = 0\n for j in attr:\n if (j == a):\n l.append(temp_Y[count])\n count+=1\n initial_gain -= ((len(l) / len(temp_Y)) * entropy(pd.Series(l)))\n return initial_gain","def calc_euclidian_dists(x, y):\n n = x.shape[0]\n m = y.shape[0]\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)","def informationGain2(data, attribute):\n \n split_data = splitBy(data, attribute) \n weighted_entropies = 0\n \n for set in split_data:\n weighted_entropies += len(set) / len(data) * entropy2(set) \n \n columnIG = entropy2(data) - weighted_entropies\n \n return columnIG","def get_mi(x, y, k=1, normalize=None, norm=np.inf, estimator='ksg'):\n\n if normalize:\n x = normalize(x)\n y = normalize(y)\n\n # construct state array for the joint process:\n xy = np.c_[x,y]\n\n if estimator == 'naive':\n # compute individual entropies\n hx = get_h(x, k=k, norm=norm)\n hy = get_h(y, k=k, norm=norm)\n hxy = get_h(xy, k=k, norm=norm)\n\n # compute mi\n mi = hx + hy - hxy\n\n elif estimator == 'ksg':\n\n # store data pts in kd-trees for efficient nearest neighbour computations\n # TODO: choose a better leaf size\n x_tree = cKDTree(x)\n y_tree = cKDTree(y)\n xy_tree = cKDTree(xy)\n\n # kth nearest neighbour distances for every state\n # query with k=k+1 to return the nearest neighbour, not counting the data point itself\n # dist, idx = xy_tree.query(xy, k=k+1, p=norm)\n dist, idx = xy_tree.query(xy, k=k+1, p=np.inf)\n epsilon = dist[:, -1]\n\n # for each point, count the number of neighbours\n # whose distance in the x-subspace is strictly < epsilon\n # repeat for the y subspace\n n = len(x)\n nx = np.empty(n, dtype=np.int)\n ny = np.empty(n, dtype=np.int)\n for ii in range(n):\n # nx[ii] = len(x_tree.query_ball_point(x_tree.data[ii], r=epsilon[ii], p=norm)) - 1\n # ny[ii] = len(y_tree.query_ball_point(y_tree.data[ii], r=epsilon[ii], p=norm)) - 1\n nx[ii] = len(x_tree.query_ball_point(x_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\n ny[ii] = len(y_tree.query_ball_point(y_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\n\n mi = digamma(k) - np.mean(digamma(nx+1) + digamma(ny+1)) + digamma(n) # version (1)\n # mi = digamma(k) -1./k -np.mean(digamma(nx) + digamma(ny)) + digamma(n) # version (2)\n\n elif estimator == 'lnc':\n # TODO: (only if you can find some decent explanation on how to set alpha!)\n raise NotImplementedError(\"Estimator is one of 'naive', 'ksg'; currently: {}\".format(estimator))\n\n else:\n raise NotImplementedError(\"Estimator is one of 'naive', 'ksg'; currently: {}\".format(estimator))\n\n return mi","def _basic_data_info(X, y):\n num_samples, num_feats = X.shape # start with X properties\n\n # Compute distribution\n classes, counts, percs = _class_distribution(y)\n num_classes = classes.size\n\n # Return data info dictionary\n output_dic = {\n \"Num_samples\": num_samples,\n \"Num_feats\": num_feats,\n \"Num_classes\": num_classes,\n \"classes\": classes,\n \"counts\": counts,\n \"percs\": percs\n }\n\n return output_dic","def cofactors(self,x,y):\r\n return self.factorset(x) & self.factorset(y)","def mutual_information(pred, true):\n \n #for now , only for univariate forecasting. So reshapes entire batch of K timesteps into vector as if single feature\n MI = mutual_info_regression(true.detach().numpy().flatten().reshape(-1,1), pred.detach().numpy().flatten())[0]\n return torch.tensor(MI)","def marginalize(self, axis):\n \n dist = {}\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE\n #\n \n # get relevant data based on the given random variable\n for i in self._table:\n if axis == 0:\n if i[0] in dist:\n dist[i[0]] += self._table[i]\n else:\n dist[i[0]] = self._table[i]\n else:\n if i[1] in dist:\n dist[i[1]] += self._table[i]\n else:\n dist[i[1]] = self._table[i]\n\n\n #\n # END OF YOUR CODE\n # ------------------------------------------------------------------------- \n\n return dist","def mmd2(K_xx, K_yy, K_xy, w_x=None, w_y=None):\n n, m = K_xy.shape\n\n assert n == K_xx.shape[0], \"Shapes must conform between K_xx and K_xy, K_xx.shape == {}, K_xy.shape == {}\".format(\n K_xx.shape, K_xy.shape)\n assert m == K_yy.shape[0], \"Shapes must conform between K_yy and K_xy, K_yy.shape == {}, K_xy.shape == {}\".format(\n K_yy.shape, K_xy.shape)\n\n if isinstance(w_x, np.ndarray) and isinstance(w_y, np.ndarray):\n assert np.isclose(w_x.sum(), 1) and np.isclose(\n w_y.sum(), 1), \"w_x and w_y must sum to 1\"\n assert w_x.shape == (n, 1) and w_y.shape == (\n m, 1), \"w_x and w_y must conform to K_xx and K_yy, have w_x.shape == {}, w_y.shape == {} and K_xx.shape == {}, K_yy == {}\".format(w_x.shape, w_y.shape, K_xx.shape, K_yy.shape)\n assert (w_x >= 0).all(), \"All entries of w_x should be greater than zero\"\n assert (w_y >= 0).all(), \"All entries of w_y should be greater than zero\"\n mmd2 = w_x.T @ K_xx @ w_x - 2 * w_x.T @ K_xy @ w_y + w_y.T @ K_yy @ w_y\n else:\n mmd2 = (K_xx.sum() / (n**2)) + (K_yy.sum() / (m**2)) - \\\n 2 * (K_xy.sum() / (m*n))\n\n # Had problem with negative values on order of machine epsilon\n mmd2 += 2 * np.finfo(float).eps\n assert mmd2 > 0.0, \"mmd2 should be non-negative, is {}\".format(mmd2)\n\n return mmd2","def prob(self, x, y):\n p = self.tag_prob(y)\n for i in range(len(y)):\n p *= self.out_prob(x[i], y[i])\n\n return p","def marginal_2D(self, wrt_x, wrt_y, figure_name=None):\n res = self.marginalize_wrt_x_y(wrt_x, wrt_y)\n tagx= np.array([tup[0] for tup in res], dtype=np.int16)\n tagy= np.array([tup[1] for tup in res], dtype=np.int16)\n z = np.array([tup[2] for tup in res], dtype=np.float32)\n\n if wrt_x == 'logD':\n x = tagx[:]\n else:\n x = self.convert_tags_to_features(tagx, wrt_x)\n if wrt_y == 'logD':\n y = tagy[:]\n else:\n y = self.convert_tags_to_features(tagy, wrt_y)\n\n nx = ny = 101\n xi = np.linspace(min(x), max(x), nx)\n yi = np.linspace(min(y), max(y), ny)\n xi_ = xi[None,:]\n yi_ = yi[:,None]\n # zi0 = mlab.griddata(x, y, z, xi, yi, interp='linear')\n zi = interpolate.griddata((x, y), z, (xi_, yi_), method='cubic')\n zi[np.isnan(zi)] = 0.0\n max_zi = np.max(zi)\n zi_low = max_zi / 100.0\n ind_zero = zi <= zi_low\n zi[zi <= ind_zero] = 0\n\n if figure_name is None: return (x, y, xi, yi, zi)\n\n # Continue making the figure\n fig, ax = plt.subplots(1, figsize=(4,4), dpi=100, tight_layout=True)\n\n lev = marg_contour_levels\n # c = ax.contour(xi, yi, zi, lev, linestyle='dotted', linewidth=0.5, color='k')\n cf = ax.contourf(xi, yi, zi, lev, zorder=1, cmap=plt.get_cmap('Greys'),\n norm=plt.Normalize(vmin=0, vmax=abs(zi).max())) \n ax.scatter(x, y, marker=',', facecolor='grey', edgecolor='grey', s=1, zorder=2)\n cb = fig.colorbar(cf, ax=ax, shrink=1.00)\n\n ax.set_xlabel(utils.feature_name_in_latex(wrt_x))\n ax.set_ylabel(utils.feature_name_in_latex(wrt_y))\n\n if wrt_x == 'logD': \n ax.xaxis.set_ticks(range(5))\n ax.set_xticklabels(logD_ticks, rotation=45, fontsize='small')\n\n if wrt_y == 'logD': \n ax.yaxis.set_ticks(range(5))\n ax.set_yticklabels(logD_ticks, rotation=45, fontsize='small')\n\n if figure_name is not None:\n plt.savefig(figure_name)\n logger.info('marginal_2D: saved {0}'.format(figure_name))\n plt.close()\n\n return (x, y, xi, yi, zi)","def get_pmi_mvn(x, y, z):\n\n d = x.shape[1]\n hz = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(z.T)))\n hxz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=z.T)))\n hyz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(y.T, y=z.T)))\n hxyz = 0.5 * log((2 * np.pi * np.e)**(3*d) * det(np.cov(np.c_[x,y,z].T)))\n\n pmi = hxz + hyz - hxyz - hz\n return pmi","def _mutual_info(self, object_focus, premise_focus, object_cp):\n\n # match up change points with known object's\n assert object_focus.shape[0] == premise_focus.shape[0]\n n_focus = object_focus.shape[0]\n object_cp_mask = util.list_to_mask(object_cp, n_focus)\n\n # filter out those timestamp when object's far from premise\n prox_mask = self._get_prox_mask(object_focus, premise_focus)\n match_mask = object_cp_mask & prox_mask\n diffs_mask = object_cp_mask ^ prox_mask\n if self.verbose:\n logger.info('prox filter valid= %d: match= %3d, diff= %3d'%(\n np.sum(prox_mask), np.sum(match_mask), np.sum(diffs_mask)))\n\n # probability of proximal conditioned on changepoint\n frame_shape = self.frame_source.get_shape()[-2:]\n frame_shape = (frame_shape[0] // 8, frame_shape[1] // 8)\n is_object_cp = set(object_cp)\n tp, fp, fn, tn = 1e-10, 1e-10, 1e-10, 1e-10\n cp_cnt = np.zeros(frame_shape)\n prox_cnt = np.zeros(frame_shape)\n cp_prox_cnt = np.zeros(frame_shape)\n total_cnt = np.zeros(frame_shape)\n for i, obj_fx in enumerate(object_focus):\n obj_x = (obj_fx * frame_shape).astype(int)\n total_cnt[obj_x[0], obj_x[1]] += 1\n if prox_mask[i]:\n prox_cnt[obj_x[0], obj_x[1]] += 1\n if i in is_object_cp:\n tp += 1\n else:\n fp += 1\n else:\n if i in is_object_cp:\n fn += 1\n else:\n tn += 1\n for cpi in object_cp:\n obj_x = (object_focus[cpi] * frame_shape).astype(int)\n premise_x = (premise_focus[cpi] * frame_shape).astype(int)\n cp_cnt[obj_x[0], obj_x[1]] += 1\n if prox_mask[cpi]:\n cp_prox_cnt[obj_x[0], obj_x[1]] += 1\n none_cnt = total_cnt - cp_cnt - prox_cnt + cp_prox_cnt\n cnt_valid = np.logical_and(cp_prox_cnt > 0.0, \n prox_cnt - cp_prox_cnt > 0.0)\n cndcp_score = np.mean(2 * cp_prox_cnt[cnt_valid]\n / (cp_cnt[cnt_valid] + prox_cnt[cnt_valid])) \\\n if np.sum(cnt_valid) > 0.0 else 0.0\n # util.confuse_metrics(cp_prox_cnt, prox_cnt-cp_prox_cnt, \n # cp_cnt-cp_prox_cnt, none_cnt)\n \n # print('tp', int(tp), 'fp', int(fp), 'fn', int(fn), 'tn', int(tn))\n # util.confuse_metrics(tp, fp, fn, tn)\n\n return np.sum(match_mask)/n_focus, \\\n np.sum(diffs_mask)/n_focus, \\\n np.sum(prox_mask)/n_focus, \\\n cndcp_score","def _mutual_info(self, focus, object_cp, premise_cp):\n\n # match up change points with known object's\n n_focus = focus.shape[0]\n match_mask, diffs_mask = util.match_diffs(object_cp, premise_cp, n_focus)\n\n return np.sum(match_mask)/n_focus, np.sum(diffs_mask)/n_focus, n_focus","def posteriorDistribution(x,z,beta,sigma2):\r\n ### TODO: Write your code here\r\n mu = 0\r\n Cov = 0\r\n\r\n x_s = []\r\n for i in np.linspace(-1 , 1 , 150):\r\n for j in np.linspace(-1 , 1 , 150):\r\n x_s.append([i,j])\r\n x_s = np.array(x_s)\r\n\r\n X = []\r\n for i in x:\r\n j = [1,i[0]]\r\n X.append(j)\r\n X = np.array(X)\r\n\r\n common = np.matmul( X.T , X) + np.identity(2) * sigma2/beta\r\n common = np.linalg.inv(common)\r\n Cov = common * sigma2\r\n mu = np.matmul(common , np.matmul (X.T , z) )\r\n mu = mu.flatten()\r\n print(\"X.shape: \" , X.shape)\r\n print(\"z.shape: \",z.shape)\r\n print(\"Cov.shape\" , Cov.shape)\r\n print(\"mu.shape: \",mu.shape)\r\n density = util.density_Gaussian(mu , Cov , x_s).reshape(150 , 150 ).T\r\n print(\"density.shape\",density.shape)\r\n X,Y = np.meshgrid( np.linspace(-1,1,150) , np.linspace(-1,1,150) )\r\n\r\n \r\n\r\n plt.contour( X , Y , np.reshape(density , (150, 150 )))\r\n plt.plot(-0.1 , -0.5 , marker = 'o' , MarkerSize = 10 , label = 'point a')\r\n plt.xlabel('a0 ')\r\n plt.ylabel(' a1 ')\r\n plt.legend()\r\n plt.xlim = (-1,1)\r\n plt.ylim = (-1,1)\r\n plt.title('p(a|x1,z1....xn,zn) for '+ str(len(x)) +' samples')\r\n plt.show() \r\n print('-x-x-x-x-x-x-x-x-x')\r\n\r\n return (mu,Cov)","def cross_entropy(x, y, bins, xy_probabilities=False):\n # calculate probabilities if probabilities == False\n if xy_probabilities:\n # same bins for x and y -> same length of x and y if xy_probabilities == True\n assert len(x) == len(y)\n\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y),1,atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n\n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n return - px.dot(np.log2(py))","def obtain_consistent_marginals(self, priv_marginal_config, priv_split_method) -> Marginals:\n\n # generate_all_pub_marginals() generates all the one and two way marginals of the public set which is implemented in DataLoader.py\n if self.data.pub_ref:\n pub_marginals = self.data.generate_all_pub_marginals()\n \n # get_noisy_marginals() is in synthesizer.py\n # which first calls generate_..._by_config(), and computes on priv_data to return marginal_sets, epss\n # (note that 'marginal_key' could be 'priv_all_one_way' or 'priv_all_two_way')\n # later it calls anonymize() which add noises to marginals\n # (what decides noises is 'priv_split_method') \n # priv_split_method[set_key]='lap' or....\n # Step 1: generate noisy marginals\n noisy_marginals = self.get_noisy_marginals(priv_marginal_config, priv_split_method)\n\n # since calculated on noisy marginals\n # we use mean function to estimate the number of synthesized records\n num_synthesize_records = np.mean([np.sum(x.values) for _, x in noisy_marginals.items()]).round().astype(np.int)\n print(\"------------------------> now we get the estimate of records' num by averaging from nosiy marginals:\", num_synthesize_records)\n \n \n \n # the list of all attributes' name(str) except the identifier attribute\n self.attr_list = self.data.obtain_attrs()\n # domain_list is an array recording the count of each attribute's candidate values\n self.domain_list = np.array([len(self.data.encode_schema[att]) for att in self.attr_list])\n \n # map the attribute str to its index in attr_list, for possible use\n # use enumerate to return Tuple(index, element) \n self.attr_index_map = {att: att_i for att_i, att in enumerate(self.attr_list)}\n\n\n # views are wrappers of marginals with additional functions for consistency\n # if there exist public dataset to refer to\n if self.data.pub_ref:\n pub_onehot_view_dict, pub_attr_view_dict = self.construct_views(pub_marginals)\n # Step 2: create some data structures\n noisy_onehot_view_dict, noisy_attr_view_dict = self.construct_views(noisy_marginals)\n \n # all_views is one-hot to view dict, views_dict is attribute to view dict\n # they have different format to satisfy the needs of consistenter and synthesiser\n # to fit in code when we do not have public things to utilize \n if not self.data.pub_ref:\n pub_onehot_view_dict = noisy_onehot_view_dict\n pub_attr_view_dict = noisy_attr_view_dict\n\n self.onehot_view_dict, self.attrs_view_dict = self.normalize_views(\n pub_onehot_view_dict,\n pub_attr_view_dict,\n noisy_attr_view_dict,\n self.attr_index_map,\n num_synthesize_records)\n\n # consist the noisy marginals to submit to some rules\n consistenter = Consistenter(self.onehot_view_dict, self.domain_list)\n consistenter.consist_views()\n\n # consistenter uses unnormalized counts;\n # after consistency, synthesizer uses normalized counts\n for _, view in self.onehot_view_dict.items():\n view.count /= sum(view.count)\n\n return noisy_marginals, num_synthesize_records","def make_frequency_table(x, y, X, Y):\n freq = dict()\n\n for i in range(len(X)):\n freq[X[i]] = [0, 0]\n\n # merging the two to get a matrix\n\n M = np.array([[x[i], y[i]] for i in range(len(x))])\n\n for i in range(len(M)):\n if M[i][1] == Y[0]:\n freq[M[i][0]][0] += 1\n else:\n freq[M[i][0]][1] += 1\n\n return freq","def _update_info_and_n(self, y_i, h_tilde, phi_p, msr_cov):\n h_i = np.matmul(h_tilde, phi_p)\n # update fisher_info\n L = np.matmul(np.transpose(h_i), np.matmul(msr_cov, h_i)) # placeholder matrix for computations\n self.fisher_info.append(np.add(self.fisher_info[-1], L))\n # update N\n M = np.matmul(np.transpose(h_i), np.matmul(msr_cov, np.transpose(y_i))) #placeholder matrix for computations\n self.N.append(np.add(self.N[-1], M))","def _impurity(y, y1, y2, sample_weights=None):\n # YOUR CODE HERE\n # begin answer\n weight_1=len(y1)\n weight_2=len(y2)\n meal_1=np.sum(y1)/float(weight_1)\n meal_2=np.sum(y2)/float(weight_2)\n diff=meal_1-meal_2\n sum_var=weight_1*weight_2*diff*diff/(weight_1+weight_2)\n # end answer\n return sum_var","def get_mutual_information(filename):\n categories = {} #{category: speakers of this category}\n features = {} #{feat: speakers who use this feature}\n pos_categories_features = {} #{category: {feat: speakers of category who use this feat}}\n neg_categories_features = {} #{category: {feat: speakers of category who do not use this feat}}\n users = set() #set of all users in data\n \n for line in open(filename):\n userid, c, date, statusid, rawtweet, toktweet, tagtweet = line.split('\\t')\n users.add(userid)\n \n if c not in categories:\n categories[c] = set()\n pos_categories_features[c] = {}\n categories[c].add(userid)\n \n feats = set(toktweet.lower().split()) #lowercase tweet and split into words\n\n for feat in feats:\n if feat not in pos_categories_features[c]:\n pos_categories_features[c][feat] = set()\n pos_categories_features[c][feat].add(userid)\n \n if feat not in features:\n features[feat] = set()\n features[feat].add(userid)\n\n print \"Parsed data\"\n\n numfeats = len(features) #num of features\n print numfeats, \"features\"\n numusers = len(users) #num of users \n print numusers, \"users\"\n\n #keep sizes of sets, not sets themselves\n for feat in features:\n features[feat] = len(features[feat])\n for c in categories:\n categories[c] = len(categories[c])\n for c in pos_categories_features:\n for feat in features:\n if feat in pos_categories_features[c]:\n pos_categories_features[c][feat] = len(pos_categories_features[c][feat])\n else:\n pos_categories_features[c][feat] = 0\n\n for c in categories:\n print c, categories[c], \"users\"\n\n print \"Computed counts\"\n \n mi = {}\n for feat in features:\n mi[feat] = 0.0\n for c in categories:\n #print c, feat, features[feat], pos_categories_features[c][feat]\n \n catprob = categories[c]/numusers\n\n #prob of speakers of category c using feat\n featprob = features[feat]/numusers\n jointprob = pos_categories_features[c][feat]/numusers\n if jointprob > 0 and featprob > 0:\n mi[feat] += jointprob * log2(jointprob/(catprob * featprob))\n \n #prob of speakers of category c NOT using feat\n featprob = 1 - featprob\n jointprob = (categories[c] - pos_categories_features[c][feat])/numusers\n if jointprob > 0 and featprob > 0:\n mi[feat] += jointprob * log2(jointprob/(catprob * featprob))\n\n print \"Computed mutual information\"\n\n feature_scores = sorted(mi.items(), key=lambda x:x[1], reverse=True)\n refcat = categories.keys()[0] #pick one of the categories\n print 'Feature\\tMI\\tP({0}|Feature)\\tNum. users'.format(refcat)\n for feat, score in feature_scores[:200]:\n prob = pos_categories_features[refcat][feat]/features[feat]\n print '{0}\\t{1:.3f}\\t{2:.3f}\\t{3}'.format(feat, score, prob, features[feat])","def C(self, y, x):\n return self.minor(y,x).det()*(-1.0)**(y+x+2.0)","def mmi_norm(self, x, y, tuples):\r\n P_ = {x: self.P(x, tuples), y: self.P(y, tuples)}\r\n P_xy = self.condP(x, y, tuples)\r\n return - P_[x] * log2(P_[x]) - P_[y] * (-P_xy * log2(P_xy))","def information_reduction(\n X: np.ndarray, Y: np.ndarray, uni_entropy: Callable, tol_dims: int, p: float = 0.25,\n) -> float:\n # calculate the marginal entropy\n hx = jax.vmap(uni_entropy)(X.T)\n hy = jax.vmap(uni_entropy)(Y.T)\n\n # Information content\n delta_info = np.sum(hy) - np.sum(hx)\n tol_info = np.sqrt(np.sum((hy - hx) ** 2))\n\n # get tolerance\n n_dimensions = X.shape[1]\n\n # conditional\n cond = np.logical_or(\n tol_info < np.sqrt(n_dimensions * p * tol_dims ** 2), delta_info < 0\n )\n return np.array(np.where(cond, 0.0, delta_info))"],"string":"[\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\\n def entropy(freqDict):\\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\\n freqx = objhist(x)\\n freqy = objhist(y)\\n \\n Hx = freqx.entropy()\\n Hy = freqy.entropy()\\n Hxy = objhist(zip(x,y)).entropy()\\n M = Hx + Hy - Hxy\\n Mstar = 2*M / (Hx+Hy)\\n\\n if len(freqx)==1 or len(freqy)==1:\\n p = 1\\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\\n p = 0\\n else:\\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\\n p = (Mperms >= M).sum() / nperms\\n\\n return M, Mstar, p, Hx, Hy, Hxy\",\n \"def mutual_information(x, y, w):\\r\\n \\r\\n\\r\\n total_entropy = entropy(y,w)\\r\\n\\r\\n partitioned_x = partition(x)\\r\\n weighted_entropy = 0\\r\\n # calculate the weighted entropy over the partition of x\\r\\n vals,counts= np.unique(x,return_counts=True)\\r\\n for key in partitioned_x:\\r\\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\\r\\n\\r\\n information_gain = total_entropy - weighted_entropy\\r\\n return information_gain\",\n \"def MutualInformation(x, y, bins):\\n hist_xy, x_edges, y_edges = np.histogram2d(x, y, bins)\\n return sklearn.metrics.mutual_info_score(None, None, hist_xy)\",\n \"def mutual_information_2d(x, y, sigma=1, normalized=False):\\n \\n bins = (256, 256)\\n \\n jh = np.histogram2d(x, y, bins=bins)[0]\\n \\n # smooth the jh with a gaussian filter of given sigma\\n ndimage.gaussian_filter(jh, sigma=sigma, mode='constant',\\n output=jh)\\n \\n # compute marginal histograms\\n jh = jh + EPS\\n sh = np.sum(jh)\\n jh = jh / sh\\n s1 = np.sum(jh, axis=0).reshape((-1, jh.shape[0]))\\n s2 = np.sum(jh, axis=1).reshape((jh.shape[1], -1))\\n \\n # Normalised Mutual Information of:\\n # Studholme, jhill & jhawkes (1998).\\n # \\\"A normalized entropy measure of 3-D medical image alignment\\\".\\n # in Proc. Medical Imaging 1998, vol. 3338, San Diego, CA, pp. 132-143.\\n if normalized:\\n mi = ((np.sum(s1 * np.log(s1)) + np.sum(s2 * np.log(s2)))\\n / np.sum(jh * np.log(jh))) - 1\\n else:\\n mi = ( np.sum(jh * np.log(jh)) - np.sum(s1 * np.log(s1))\\n - np.sum(s2 * np.log(s2)))\\n \\n return mi\",\n \"def mutual_info(l1, l2):\\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))\",\n \"def mutual_information_from_data(X, Y, num_bins):\\n N = X.size\\n delta = 10e-10\\n\\n x_min, x_max = (X.min() - delta, X.max() + delta)\\n y_min, y_max = (Y.min() - delta, Y.max() + delta)\\n\\n X_hist, X_bin = np.histogram(X, bins=num_bins, range=(x_min, x_max))\\n Y_hist, Y_bin = np.histogram(Y, bins=num_bins, range=(y_min, y_max))\\n\\n X_states = np.digitize(X, X_bin)\\n Y_states = np.digitize(Y, Y_bin)\\n coords = Counter(zip(X_states, Y_states))\\n\\n joint_linear = np.zeros((config.NUM_STATES, config.NUM_STATES))\\n for x, y in coords.keys():\\n joint_linear[x - 1, y - 1] = coords[(x, y)] / N\\n\\n p_X = X_hist / N\\n p_Y = Y_hist / N\\n prod_XY = np.tensordot(p_X.T, p_Y, axes=0)\\n\\n div_XY = joint_linear / prod_XY\\n div_XY[div_XY == 0] = np.nan\\n\\n return np.nansum(np.multiply(joint_linear, np.log2(div_XY)))\",\n \"def compute_empirical_mutual_info_nats(var1_values, var2_values):\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE HERE\\n #\\n\\n empirical_mutual_info_nats = 0.0\\n \\n var1_distribution = compute_empirical_distribution(var1_values)\\n var2_distribution = compute_empirical_distribution(var2_values)\\n joint_distribution = compute_empirical_distribution(list(zip(var1_values,var2_values)))\\n \\n empirical_mutual_info_nats = 0\\n for var1 in var1_distribution:\\n for var2 in var2_distribution:\\n empirical_mutual_info_nats += joint_distribution[(var1, var2)] \\\\\\n * np.log(joint_distribution[(var1,var2)]/(var1_distribution[var1]*var2_distribution[var2]))\\n \\n #\\n # END OF YOUR CODE\\n # -------------------------------------------------------------------------\\n\\n return empirical_mutual_info_nats\",\n \"def pairwiseMutualInformation(align, nperms=1e4):\\n L=len(align[align.index[0]])\\n columns = [align.map(lambda s: s[i]) for i in np.arange(L)]\\n M = np.nan*np.zeros((L, L))\\n p = np.nan*np.zeros((L, L))\\n Mstar = np.nan*np.zeros((L, L))\\n for xi, yi in itertools.combinations(np.arange(L), 2):\\n freqx = objhist(columns[xi])\\n freqy = objhist(columns[yi])\\n\\n tmpM, tmpMstar, tmpp, Hx, Hy, Hxy= mutual_information(columns[xi],\\n columns[yi],\\n logfunc=np.log2,\\n nperms=nperms)\\n \\n \\\"\\\"\\\"We wouldn't need to test invariant sites or a site with itself\\\"\\\"\\\"\\n if len(freqx) == 1 or len(freqy) == 1:\\n tmpp = np.nan\\n elif xi == yi:\\n tmpp = np.np.nan\\n\\n M[xi, yi] = tmpM\\n p[xi, yi] = tmpp\\n Mstar[xi, yi] = tmpMstar\\n q = adjustnonnan(p)\\n\\n return M, Mstar, p, q\",\n \"def compute_dists(x, y):\\r\\n \\r\\n return (x - y.permute(0, 2, 1)) ** 2\",\n \"def mi_bin(x, y, bins_x, bins_y):\\n if bins_y == 0:\\n bins_y = len(np.unique(y))\\n # compute probabilities\\n p_x = histogram(x, bins_x)\\n p_y = histogram(y, bins_y)\\n p_xy = histogram2d(x, y, bins_x, bins_y)\\n p_x = p_x / p_x.sum()\\n p_y = p_y / p_y.sum()\\n p_xy = p_xy / p_xy.sum()\\n # compute entropy\\n h_x = entropy(p_x.astype(np.float32))\\n h_y = entropy(p_y.astype(np.float32))\\n h_xy = entropy(p_xy.ravel().astype(np.float32))\\n # compute mutual information\\n i = h_x + h_y - h_xy\\n\\n return i\",\n \"def mutual_information(co_freq, s_freq, t_freq, total_instances, mitype=None):\\n if co_freq > 0:\\n if mitype is not None:\\n if mitype == \\\"expected\\\":\\n mi = math.log2(\\n (total_instances * co_freq) / (s_freq * t_freq)\\n ) * (co_freq / total_instances)\\n elif mitype == \\\"normalized\\\":\\n alpha = - math.log2(co_freq / total_instances)\\n mi = (\\n (math.log2(\\n (total_instances * co_freq) / (s_freq * t_freq)) / alpha)\\n if alpha != 0 else 0\\n )\\n elif mitype == \\\"pmi2\\\":\\n mi = math.log2((co_freq ** 2) / (s_freq * t_freq))\\n elif mitype == \\\"pmi3\\\":\\n mi = math.log2(\\n (co_freq ** 3) / (s_freq * t_freq * total_instances))\\n else:\\n raise ValueError(\\n \\\"Provided Mutual information score type (mitype) is not \\\"\\n \\\"supported. Provide one value from the following list \\\"\\n \\\"['expected', 'normalized','pmi2', 'pmi3'] \\\")\\n else:\\n mi = math.log2((total_instances * co_freq) / (s_freq * t_freq))\\n else:\\n mi = 0\\n return mi if mi > 0 else 0\",\n \"def mutual_information(transposed, transposed_2 = False):\\n\\tmi = []\\n\\tlength = range(len(transposed))\\n\\tfor i in length:\\n\\t\\tentropy_i = entropy(transposed[i])\\n\\t\\tmi_list = []\\n\\t\\tif transposed_2 == False:\\n\\t\\t\\tfor j in length:\\n\\t\\t\\t\\tentropy_j = entropy(transposed[j])\\n\\t\\t\\t\\tjoint = joint_entropy(transposed[i], transposed[j])\\n\\t\\t\\t\\tmi_calc = entropy_i + entropy_j - joint\\n\\t\\t\\t\\tmi_list.append(mi_calc)\\n\\t\\t\\tmi.append(mi_list)\\n\\n\\t\\telse:\\n\\t\\t\\tlength_2 = range(len(transposed_2))\\n\\t\\t\\tfor j in length_2:\\n\\t\\t\\t\\tentropy_j = entropy(transposed_2[j])\\n\\t\\t\\t\\tjoint = joint_entropy(transposed[i], transposed_2[j])\\n\\t\\t\\t\\tmi_calc = entropy_i + entropy_j - joint\\n\\t\\t\\t\\tmi_list.append(mi_calc)\\n\\t\\t\\tmi.append(mi_list)\\n\\treturn mi\",\n \"def mutual_information(transposed, transposed_2 = False):\\n\\tmi = []\\n\\tlength = range(len(transposed))\\n\\tfor i in length:\\n\\t\\tentropy_i = entropy(transposed[i])\\n\\t\\tmi_list = []\\n\\t\\tif transposed_2 == False:\\n\\t\\t\\tfor j in length:\\n\\t\\t\\t\\tentropy_j = entropy(transposed[j])\\n\\t\\t\\t\\tjoint = joint_entropy(transposed[i], transposed[j])\\n\\t\\t\\t\\tmi_calc = entropy_i + entropy_j - joint\\n\\t\\t\\t\\tmi_list.append(mi_calc)\\n\\t\\t\\tmi.append(mi_list)\\n\\n\\t\\telse:\\n\\t\\t\\tlength_2 = range(len(transposed_2))\\n\\t\\t\\tfor j in length_2:\\n\\t\\t\\t\\tentropy_j = entropy(transposed_2[j])\\n\\t\\t\\t\\tjoint = joint_entropy(transposed[i], transposed_2[j])\\n\\t\\t\\t\\tmi_calc = entropy_i + entropy_j - joint\\n\\t\\t\\t\\tmi_list.append(mi_calc)\\n\\t\\t\\tmi.append(mi_list)\\n\\treturn mi\",\n \"def mutual_information_brute_force(self, ret_prob_activity=False):\\n base = 2 ** np.arange(0, self.Nr)\\n\\n # prob_a contains the probability of finding activity a as an output.\\n prob_a = np.zeros(2**self.Nr)\\n for c, prob_c in self._iterate_mixtures():\\n # get the associated output ...\\n a = np.dot(self.sens_mat, c).astype(np.bool)\\n # ... and represent it as a single integer\\n a = np.dot(base, a)\\n\\n prob_a[a] += prob_c\\n \\n # normalize the output to make it a probability distribution\\n prob_a /= prob_a.sum()\\n \\n # calculate the mutual information\\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\\n \\n if ret_prob_activity:\\n return MI, prob_a\\n else:\\n return MI\",\n \"def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))\",\n \"def dist_calc(self, x, y):\\n p_xy = self.d2_bin(x, y)\\n p_x = np.sum(p_xy, axis=1)\\n p_y = np.sum(p_xy, axis=0)\\n\\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\\n\\n output = max(0.0, (1 - (info / entropy)))\\n return output\",\n \"def get_information_y_hat(x_pub, x_priv, x_joint, y_hat, num_of_bins_y):\\n\\tprint('Start calculating the information for y_hat...')\\n\\ty_hat = np.array(y_hat).astype(np.float)\\n\\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\\n\\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(y_hat, x_pub)\\n\\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\\n\\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(y_hat, x_joint)\\n\\t# Shannon Entropy over label\\n\\tH2Y_hat = -np.sum(pys_hat * np.log2(pys_hat))\\n\\t# mutual Information between secret layer and label\\n\\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\\n\\t# mutual Information between secret layer and label\\n\\tMI_pub_y_hat = calc_information_for_inp_out(pxs_pub,pys_hat,y_hat,unique_inverse_x_pub)\\n\\treturn H2Y_hat, MI_pri_y_hat, MI_pub_y_hat\",\n \"def get_mi_mvn(x, y):\\n\\n d = x.shape[1]\\n\\n # hx = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(x.T)))\\n # hy = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(y.T)))\\n # hxy = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=y.T)))\\n # mi = hx + hy - hxy\\n\\n # hx = 0.5 * log(det(2*np.pi*np.e*np.cov(x.T)))\\n # hy = 0.5 * log(det(2*np.pi*np.e*np.cov(y.T)))\\n # hxy = 0.5 * log(det(2*np.pi*np.e*np.cov(np.c_[x,y].T)))\\n hx = get_h_mvn(x)\\n hy = get_h_mvn(y)\\n hxy = get_h_mvn(np.c_[x,y])\\n mi = hx + hy - hxy\\n\\n # mi = 0.5 * (log(det(np.cov(x.T))) + log(det(np.cov(y.T))) - log(det(np.cov(np.c_[x,y].T))))\\n\\n return mi\",\n \"def symbolic_mutual_information(symX, symY):\\n\\n if len(symX) != len(symY):\\n raise ValueError('All arrays must have same length')\\n \\n symX = np.array(symX)\\n symY = np.array(symY)\\n \\n symbols = np.unique(np.concatenate((symX,symY))).tolist()\\n \\n jp = symbolic_joint_probabilities(symX, symY)\\n pX = symbolic_probabilities(symX)\\n pY = symbolic_probabilities(symY)\\n \\n MI = 0\\n\\n for yi, b in pY.items():\\n for xi, a in pX.items():\\n try:\\n c = jp[yi,xi]\\n MI += c * np.log(c /(a * b)) / np.log(len(symbols))\\n except KeyError:\\n continue\\n except:\\n print(\\\"Unexpected Error\\\")\\n raise\\n \\n return MI\",\n \"def mutual_information(mc_preds):\\n mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),\\n axis=0)\\n return mutual_info\",\n \"def metric(x, y):\\n d = 2\\n summ = []\\n i = 0\\n while i < len(x):\\n # in this case use euclidean distance\\n summ.append((x[i] - y[i])**d)\\n i = i + 1\\n return sum(summ) ** (1 / float(d))\",\n \"def get_information_priv_y_hat(x_priv, y_hat, num_of_bins_y):\\n\\tprint('Start calculating the information for y_hat...')\\n\\ty_hat = np.array(y_hat).astype(np.float)\\n\\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\\n\\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\\n\\t# mutual Information between secret layer and label\\n\\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\\n\\treturn MI_pri_y_hat.astype(np.float32)\",\n \"def synergy(g1, g2, c):\\n return mutual_info(joint_dataset(g1, g2), c) -\\\\\\n mutual_info(g1, c) - mutual_info(g2, c)\",\n \"def mutual_information_estimate(self, approx_prob=False):\\n \\n # this might be not the right approach\\n q_n = self.receptor_activity_estimate(approx_prob=approx_prob)\\n q_nm = self.receptor_crosstalk_estimate(approx_prob=approx_prob)\\n \\n # calculate the approximate mutual information\\n return self._estimate_MI_from_q_values(q_n, q_nm)\",\n \"def get_dists_2():\\n d1 = Distribution(['0', '1'], [1 / 2, 1 / 2])\\n d2 = Distribution(['0', '1'], [1 / 3, 2 / 3])\\n d3 = Distribution(['0', '1'], [2 / 5, 3 / 5])\\n return d1, d2, d3\",\n \"def normalized_mutual_information(cl: np.ndarray, org: np.ndarray):\\n assert cl.shape == org.shape\\n\\n return mutual_info_score(org, cl) / (abs(entropy(cl) + entropy(org)) / 2)\",\n \"def mutual_information(self, excitation_method='auto', **kwargs):\\n if excitation_method == 'auto':\\n if self.Ns <= self.parameters['brute_force_threshold_Ns']:\\n excitation_method = 'brute_force'\\n else:\\n excitation_method = 'monte_carlo'\\n \\n if excitation_method == 'brute_force' or excitation_method == 'brute-force':\\n return self.mutual_information_brute_force(**kwargs)\\n elif excitation_method == 'monte_carlo' or excitation_method == 'monte-carlo':\\n return self.mutual_information_monte_carlo(**kwargs)\\n elif excitation_method == 'estimate':\\n return self.mutual_information_estimate(**kwargs)\\n else:\\n raise ValueError('Unknown excitation_method `%s`.' % excitation_method)\",\n \"def mutual_information(pi, pj, pij):\\n p_i = 1 - pi\\n p_j = 1 - pj\\n p_ij = pj - pij\\n pi_j = pi - pij\\n p_i_j = 1 - pi - pj + pij\\n \\n log_pi = log(pi)\\n log_pj = log(pj)\\n log_p_i = log(p_i)\\n log_p_j = log(p_j)\\n \\n mi = pij * (log(pij) - log_pi - log_pj) + \\\\\\n pi_j * (log(pi_j) - log_pi - log_p_j) + \\\\\\n p_i_j * (log(p_i_j) - log_p_i - log_p_j)\\n if p_ij != 0: # For language groups and features, this is the only probability that could be zero, and lim_x->0[x*log(x)] = 0 \\n mi += p_ij * (log(p_ij) - log_p_i - log_pj)\\n \\n return mi\",\n \"def mattes_mutual_information(fixed, moving, bins_count=24, pixels_fraction=None, **kwargs) :\\n \\n pixels_count = 0\\n if isinstance(fixed, medipy.base.Image) :\\n pixels_count = numpy.prod(fixed.shape)\\n FixedImageType = medipy.itk.itk_image_type(fixed)\\n else :\\n pixels_count = numpy.prod(fixed.GetLargestPossibleRegion().GetSize())\\n FixedImageType = fixed\\n \\n if isinstance(moving, medipy.base.Image) :\\n pixels_count = max(pixels_count, numpy.prod(moving.shape))\\n MovingImageType = medipy.itk.itk_image_type(moving)\\n else :\\n pixels_count = max(pixels_count, numpy.prod(moving.GetLargestPossibleRegion().GetSize()))\\n MovingImageType = moving\\n\\n arguments = {}\\n \\n # Medimax : recalage/imx_mtch.c:erreur_IM : histograms have 250 bins. We use\\n # ITK suggested value\\n arguments[\\\"NumberOfHistogramBins\\\"] = int(bins_count)\\n arguments[\\\"UseAllPixels\\\"] = True\\n\\n if pixels_fraction is not None :\\n arguments[\\\"NumberOfSpatialSamples\\\"] = int(pixels_fraction*pixels_count)\\n\\n #if pixels_fraction is None :\\n # if kwargs == {} :\\n # arguments[\\\"UseAllPixels\\\"] = False\\n # arguments[\\\"NumberOfSpatialSamples\\\"] = int(0.1*pixels_count)\\n # elif kwargs.get(\\\"all_pixels\\\", False) :\\n # arguments[\\\"UseAllPixels\\\"] = True\\n # elif \\\"spatial_samples_count\\\" in kwargs :\\n # arguments[\\\"UseAllPixels\\\"] = False\\n # arguments[\\\"NumberOfSpatialSamples\\\"] = kwargs[\\\"spatial_samples_count\\\"]\\n # else :\\n # raise Exception(\\\"Incorrect arguments\\\")\\n #else :\\n # arguments[\\\"UseAllPixels\\\"] = False\\n # arguments[\\\"NumberOfSpatialSamples\\\"] = int(pixels_fraction*pixels_count)\\n \\n metric = itk.MattesMutualInformationImageToImageMetric[\\n FixedImageType, MovingImageType].New(**arguments)\\n\\n return metric\",\n \"def make_likelihood_table(x, y):\\n\\n Y = np.unique(y)\\n X = np.unique(x)\\n\\n likelihood = [[0 for i in range(len(Y))] for j in range(len(X))]\\n\\n freq = make_frequency_table(x, y, X, Y)\\n\\n for j in range(len(Y)):\\n Sum = (y == Y[j]).sum()\\n for i in range(len(X)):\\n likelihood[i][j] = freq[X[i]][j] / Sum\\n\\n return likelihood\",\n \"def mutual_information(self,max_lag):\\n\\n digi = utilities.mi_digitize(self.X)\\n\\n mi = np.empty(max_lag)\\n\\n for i in range(max_lag):\\n\\n ind = i+1\\n unshift = digi[ind:]\\n shift = digi[0:-ind]\\n\\n mi[i] = skmetrics.mutual_info_score(unshift,shift)\\n\\n return mi\",\n \"def get_mutual_information(c_wic, c_wioc, c_owic, c_owioc):\\n # total word count\\n c_total = c_wic + c_wioc + c_owic + c_owioc\\n\\n mi_1 = (c_wic / float(c_total)) * log10((c_total * c_wic) /\\n float((c_wic + c_wioc) * (c_wic + c_owic)))\\n mi_2 = (c_owic / float(c_total)) * log10((c_total * c_owic) /\\n float((c_owic + c_owioc) * (c_wic + c_owic)))\\n mi_3 = (c_wioc / float(c_total)) * log10((c_total * c_wioc) /\\n float((c_wic + c_wioc) * (c_wioc + c_owioc)))\\n mi_4 = (c_owioc / float(c_total)) * log10((c_total * c_owioc) /\\n float((c_owic + c_owioc) * (c_wioc + c_owioc)))\\n\\n return mi_1 + mi_2 + mi_3 + mi_4\",\n \"def mass_based_dissimilarity(self, x1, x2):\\n # In each i-tree, find lowest nodes containing both x and y\\n # TODO: parallelize\\n sum_masses = 0\\n for itree in self.random_itrees:\\n # Divide each sum by size of subset used to construct the trees.\\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.\",\n \"def compute_information_gain(Y, xi):\\r\\n H_Y = H(Y)\\r\\n\\r\\n TrainSet = np.delete(AllSets[2], -1, axis=1)\\r\\n ColumnInd = AllSets[3].index(xi) # extract from dictionary\\r\\n\\r\\n NumHeadlines = AllSets[2].shape[0]\\r\\n AllOccurences, Count = np.unique(AllSets[2][:, ColumnInd], return_counts=True)\\r\\n\\r\\n TotalH_YGivenX = 0\\r\\n for i, count in zip(AllOccurences, Count):\\r\\n NewY = Y[TrainSet[:, ColumnInd] == i]\\r\\n\\r\\n TotalH_YGivenX += H(NewY) * float(count) / NumHeadlines\\r\\n\\r\\n return H_Y - TotalH_YGivenX\",\n \"def mutual_information_union(p1, p2, measure=normalized_mutual_info_score):\\n nodes = sorted(set(p1.keys()) | set(p2.keys()))\\n if nodes == []: return 0\\n return measure(\\n [p1[n] if n in p1 else np.random.randint(1e12) for n in nodes],\\n [p2[n] if n in p2 else np.random.randint(1e12) for n in nodes]\\n )\",\n \"def calc_mutual_information(probability_mat):\\n\\n marginals = sp.outer(\\n sp.sum(probability_mat, axis=1), sp.sum(probability_mat, axis=0))\\n p = probability_mat[probability_mat != 0.0]\\n m = marginals[probability_mat != 0.0]\\n return sp.sum(p * sp.log(p / m))\",\n \"def mi(x,y,k=3,base=2):\\n x = [[entry] for entry in x]\\n y = [[entry] for entry in y]\\n assert len(x)==len(y), \\\"Lists should have same length\\\"\\n assert k <= len(x) - 1, \\\"Set k smaller than num. samples - 1\\\"\\n intens = 1e-10 #small noise to break degeneracy, see doc.\\n x = [list(p + intens*nr.rand(len(x[0]))) for p in x]\\n y = [list(p + intens*nr.rand(len(y[0]))) for p in y]\\n points = zip2(x,y)\\n #Find nearest neighbors in joint space, p=inf means max-norm\\n tree = ss.cKDTree(points)\\n dvec = [tree.query(point,k+1,p=float('inf'))[0][k] for point in points]\\n a,b,c,d = avgdigamma(x,dvec), avgdigamma(y,dvec), digamma(k), digamma(len(x)) \\n return (-a-b+c+d)/log(base)\",\n \"def get_mutual_information_table(self, dims_to_use=None, ignore_negative_values=True, use_correlation=False):\\n from mlabwrap import mlab\\n bad_dims = self.get_markers('surface_ignore')\\n bad_dims.append('Cell Length')\\n bad_dims.append('Time')\\n bad_dims.append('191-DNA')\\n bad_dims.append('193-DNA')\\n bad_dims.append('103-Viability')\\n bad_dims.append('cluster_name')\\n bad_dims.append('stim')\\n bad_dims.append('cluster_num')\\n if not dims_to_use:\\n dims_to_use = self.dims[:]\\n dims_to_use = [d for d in dims_to_use if not d in bad_dims] \\n num_dims = len(dims_to_use)\\n res = np.zeros((num_dims, num_dims))\\n logging.info(\\n 'Calculating mutual information for %d pairs...' % ((num_dims ** 2 - num_dims) / 2))\\n timer = MultiTimer((num_dims ** 2 - num_dims) / 2)\\n for i in xrange(num_dims):\\n for j in xrange(i):\\n arr = self.get_points(dims_to_use[i], dims_to_use[j])\\n if ignore_negative_values:\\n arr = arr[np.all(arr > 0, axis=1)]\\n if arr.shape[0] < 100:\\n logging.warning('Less than 100 cells in MI calculation for (%s, %s)' % (dims_to_use[i], dims_to_use[j]))\\n res[j,i] = 0\\n res[i,j] = 0\\n continue\\n if use_correlation:\\n res[i,j] = np.corrcoef(arr.T[0], arr.T[1])[0,1]\\n else:\\n res[i,j] = mlab.mutualinfo_ap(arr, nout=1)\\n res[j,i] = res[i,j]\\n timer.complete_task('%s, %s' % (dims_to_use[i], dims_to_use[j]))\\n return DataTable(res, dims_to_use)\",\n \"def nmi(ypred, y):\\n# print (ypred)\\n# print (y)\\n return normalized_mutual_info_score(y,ypred)\",\n \"def associate_comp(x, y):\\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])\",\n \"def adjusted_mutual_info(self):\\n # Prepare row totals and check for special cases\\n row_totals = np.fromiter(self.iter_row_totals(), dtype=np.int64)\\n col_totals = np.fromiter(self.iter_col_totals(), dtype=np.int64)\\n R = len(row_totals)\\n C = len(col_totals)\\n if R == C == 1 or R == C == 0:\\n # No clustering since the data is not split. This is a perfect match\\n # hence return 1.0.\\n return 1.0\\n\\n # In one step, calculate entropy for each labeling and mutual\\n # information\\n h_true, h_pred, mi = self._entropies()\\n mi_max = max(h_true, h_pred)\\n\\n # Calculate the expected value for the MI\\n emi = emi_from_margins(row_totals, col_totals)\\n\\n # Calculate the adjusted MI score\\n ami = (mi - emi) / (mi_max - emi)\\n return ami\",\n \"def d_mse(x, y):\\n\\n return 2 * (x - y) / x.size(0) / x.size(1)\",\n \"def mutual_info_score(self):\\n _, _, I_CK = self._entropies()\\n return I_CK / self.grand_total\",\n \"def __mul__(self, y):\\n sum = 0\\n x = self\\n if len(x) > len(y):\\n x, y = y, x\\n for key in x:\\n if key not in y:\\n continue\\n sum += x[key] * y[key]\\n return sum\",\n \"def __mul__(self, y):\\n sum = 0\\n x = self\\n if len(x) > len(y):\\n x, y = y, x\\n for key in x:\\n if key not in y:\\n continue\\n sum += x[key] * y[key]\\n return sum\",\n \"def _information_gain(self, y, subsets):\\n n = y.shape[0]\\n child_entropy = 0\\n\\n for y_i in subsets:\\n child_entropy += self._entropy(y_i) * y_i.shape[0] / float(n)\\n\\n return self._entropy(y) - child_entropy\",\n \"def mutual_information_intersection(p1, p2, measure=normalized_mutual_info_score):\\n nodes = sorted(set(p1.keys()) & set(p2.keys()))\\n if nodes == []: return 0\\n return measure(\\n [p1[n] for n in nodes],\\n [p2[n] for n in nodes]\\n )\",\n \"def marginalDistribution(self, x, variable):\\n return self._distribution.marginal(x, variable)\",\n \"def mutual_info_score(labels_true, labels_pred):\\n ct = ContingencyTable.from_labels(labels_true, labels_pred)\\n return ct.mutual_info_score()\",\n \"def rmsd(x, y):\\n\\n # get the length of the dataset\\n n, = x.shape\\n\\n return np.sqrt(np.sum((x-y)**2)/n)\",\n \"def manhattan(x, y):\\n md = np.sum(abs(x-y))\\n # print md\\n return md\",\n \"def mutual_info_matrix(time_series, num_of_bins):\\n num_of_rafts, interval_width = time_series.shape\\n mi_matrix = np.zeros((num_of_rafts, num_of_rafts))\\n\\n for i in range(num_of_rafts):\\n for j in range(i + 1):\\n i0 = time_series[i, :].copy()\\n j0 = time_series[j, :].copy()\\n c_xy = np.histogram2d(i0, j0, num_of_bins)[0]\\n mi = mutual_info_score(None, None, contingency=c_xy) * np.log2(np.e)\\n # in unit of bits, * np.log2(np.e) to convert nats to bits\\n mi_matrix[i, j] = mi\\n mi_matrix[j, i] = mi\\n\\n return mi_matrix\",\n \"def probabilities(self, x, y):\\n return self.feed_and_return(x, y, self.network.a)\",\n \"def mutual_info(a,b,c,n):\\r\\n if a == 0: \\r\\n return 0\\r\\n print(a,b,c,n) \\r\\n return log10((a * n) / ((a + c) * (a + b)))\",\n \"def Pdist2(x, y):\\r\\n x_norm = (x ** 2).sum(1).view(-1, 1)\\r\\n if y is not None:\\r\\n y_norm = (y ** 2).sum(1).view(1, -1)\\r\\n else:\\r\\n y = x\\r\\n y_norm = x_norm.view(1, -1)\\r\\n Pdist = x_norm + y_norm - 2.0 * torch.mm(x, torch.transpose(y, 0, 1))\\r\\n Pdist[Pdist<0]=0\\r\\n return Pdist\",\n \"def mutual_information_spatial(self,max_lag,percent_calc=.5,digitize=True):\\n if digitize:\\n M = utilities.mi_digitize(self.X)\\n else:\\n M = self.X\\n\\n rs, cs = np.shape(M)\\n\\n rs_iters = int(rs*percent_calc)\\n cs_iters = int(cs*percent_calc)\\n\\n r_picks = np.random.choice(np.arange(rs),size=rs_iters,replace=False)\\n c_picks = np.random.choice(np.arange(cs),size=cs_iters,replace=False)\\n\\n\\n # The r_picks are used to calculate the MI in the columns\\n # and the c_picks are used to calculate the MI in the rows\\n\\n c_mi = np.zeros((rs_iters,max_lag))\\n r_mi = np.zeros((cs_iters,max_lag))\\n\\n for i in range(rs_iters):\\n for j in range(max_lag):\\n\\n ind = j+1\\n unshift = M[r_picks[i],ind:]\\n shift = M[r_picks[i],:-ind]\\n c_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n for i in range(cs_iters):\\n for j in range(max_lag):\\n\\n ind=j+1\\n unshift = M[ind:, c_picks[i]]\\n shift = M[:-ind, c_picks[i]]\\n r_mi[i,j] = skmetrics.mutual_info_score(unshift,shift)\\n\\n r_mut = np.mean(r_mi,axis=0)\\n c_mut = np.mean(c_mi,axis=0)\\n\\n return r_mut, c_mut, r_mi, c_mi\",\n \"def __mul__(self, other):\\n\\n\\t\\tassert set(self.keys()) == set(other.keys())\\n\\t\\tdistribution, total = {}, 0.0\\n\\n\\t\\tfor key in self.keys():\\n\\t\\t\\tx, y = self.probability(key), other.probability(key)\\n\\t\\t\\tdistribution[key] = (x + eps) * (y + eps)\\n\\t\\t\\ttotal += distribution[key]\\n\\n\\t\\tfor key in self.keys():\\n\\t\\t\\tdistribution[key] /= total\\n\\n\\t\\t\\tif distribution[key] <= eps / total:\\n\\t\\t\\t\\tdistribution[key] = 0.0\\n\\t\\t\\telif distribution[key] >= 1 - eps / total:\\n\\t\\t\\t\\tdistribution[key] = 1.0\\n\\n\\t\\treturn DiscreteDistribution(distribution)\",\n \"def Dist(p1,p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n return (((x1-x2)*(x1-x2)) + ((y1-y2)*(y1-y2)))**0.5\",\n \"def get_information(ws_pub, ws_priv, ws_joint, x_pub, x_priv, x_joint, y, num_of_bins, num_of_bins_y,\\n\\t\\t\\t\\t\\tinterval_information_display, calc_parallel=True, py_hats=0):\\n\\tprint('Start calculating the information...')\\n\\tbins = np.linspace(-1, 1, num_of_bins)\\n\\ty = np.array(y).astype(np.float)\\n\\tpys1, unique_inverse_y,label = extract_probs_label(y,num_of_bins_y)\\n\\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(label, x_pub)\\n\\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(label, x_priv)\\n\\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(label, x_joint)\\n\\t# Shannon Entropy over label\\n\\tH2Label = -np.sum(pys1 * np.log2(pys1))\\n\\t# mutual Information between secret layer and label\\n\\tMI_pri_label = calc_information_for_inp_out(pxs_priv,pys1,label,unique_inverse_x_priv)\\n\\t# mutual Information between secret layer and label\\n\\tMI_pub_label = calc_information_for_inp_out(pxs_pub,pys1,label,unique_inverse_x_pub)\\n\\n\\tif calc_parallel:\\n\\t\\tprint('calculating the information for public layer...')\\n\\t\\tparams_pub = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\\n\\t\\t (i, interval_information_display, ws_pub[i], bins, unique_inverse_x_pub,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_pub, b1_pub, len(unique_a_pub),\\n\\t\\t \\t\\t\\t\\t\\tpxs_pub, p_y_given_x_pub, pys1)\\n\\t\\t for i in range(len(ws_pub))))\\n\\t\\tprint('calculating the information for secret layer...')\\n\\t\\tparams_priv = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\\n\\t\\t (i, interval_information_display, ws_priv[i], bins, unique_inverse_x_priv,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_priv, b1_priv, len(unique_a_priv),\\n\\t\\t \\t\\t\\t\\t\\tpxs_priv, p_y_given_x_priv, pys1)\\n\\t\\t for i in range(len(ws_priv))))\\n\\t\\tprint('calculating the information for joint layer...')\\n\\t\\tparams_joint = np.array(Parallel(n_jobs=NUM_CORES)(delayed(calc_information_for_epoch)\\n\\t\\t (i, interval_information_display, ws_joint[i], bins, unique_inverse_x_joint,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_joint, b1_joint, len(unique_a_joint),\\n\\t\\t \\t\\t\\t\\t\\tpxs_joint, p_y_given_x_joint, pys1)\\n\\t\\t for i in range(len(ws_joint))))\\n\\n\\telse:\\n\\t\\tparams_pub = np.array([calc_information_for_epoch\\n\\t\\t\\t\\t\\t\\t\\t\\t(i, interval_information_display, ws_pub[i], bins, unique_inverse_x_pub,\\n\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_pub, b1_pub, len(unique_a_pub),\\n\\t\\t\\t\\t\\t\\t\\t\\tpxs_pub, p_y_given_x_pub, pys1)\\n\\t\\t \\t\\tfor i in range(len(ws_pub))])\\n\\t\\tparams_priv = np.array([calc_information_for_epoch\\n\\t\\t (i, interval_information_display, ws_priv[i], bins, unique_inverse_x_priv,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_priv, b1_priv, len(unique_a_priv),\\n\\t\\t \\t\\t\\t\\t\\tpxs_priv, p_y_given_x_priv, pys1)\\n\\t\\t for i in range(len(ws_priv))])\\n\\t\\tparams_joint = np.array([calc_information_for_epoch\\n\\t\\t (i, interval_information_display, ws_joint[i], bins, unique_inverse_x_joint,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tunique_inverse_y, label, b_joint, b1_joint, len(unique_a_joint),\\n\\t\\t \\t\\t\\t\\t\\tpxs_joint, p_y_given_x_joint, pys1)\\n\\t\\t for i in range(len(ws_joint))])\\n\\treturn params_pub, params_priv, params_joint, H2Label, MI_pri_label, MI_pub_label\",\n \"def calculateDist(kSet1, kSet2, x, y, group, iteration):\\n\\tkSet1Dist = 0\\n\\tkSet2Dist = 0\\n\\t\\n\\tfor j in range(len(x)):\\n\\t\\tk1Dist = math.sqrt((x[j] - kSet1[0])**2 + (y[j] - kSet1[1])**2)\\n\\t\\tk2Dist = math.sqrt((x[j] - kSet2[0])**2 + (y[j] - kSet2[1])**2)\\n\\n\\t\\tif(k1Dist < k2Dist):\\n\\t\\t\\tgroup[iteration].append(1)\\n\\t\\t\\tkSet1Dist += k1Dist\\n\\t\\telse:\\n\\t\\t\\tgroup[iteration].append(2)\\n\\t\\t\\tkSet2Dist += k2Dist\\n\\n\\treturn group\",\n \"def hammingDist(x, y):\\n hd = 0\\n for ch1, ch2 in zip(x, y):\\n if ch1 != ch2:\\n hd += 1\\n return hd\",\n \"def _compute_x2_statistic(self, expected, actual):\\n rng = expected.keys()\\n if actual.keys() != rng:\\n raise Exception(\\\"Ranges of two frequencies are not equal.\\\")\\n num_observations = sum([actual[r] for r in rng])\\n if abs(num_observations - sum([expected[r] for r in rng])) > _FLOAT_EQ_DELTA:\\n raise Exception(\\\"Frequencies must sum to the same value.\\\")\\n chi_squared_stat = sum([(actual[r] - expected[r])**2 / max(float(expected[r]), 1.0)\\n for r in rng])\\n p_value = 1 - stats.chi2.cdf(x=chi_squared_stat, # Find the p-value\\n df=len(rng))\\n return chi_squared_stat, p_value\",\n \"def example_A():\\n d = dit.example_dists.Xor()\\n\\n # Calculate marginal maximum entropy distributions up to order 3.\\n maxent_dists = dit.algorithms.marginal_maxent_dists(d, 3)\\n\\n print_output(d, maxent_dists)\\n\\n return maxent_dists\",\n \"def nmi(y_pred, y_true, average_method='geometric'):\\n return metrics.normalized_mutual_info_score(y_true, y_pred, average_method=average_method)\",\n \"def mcd(x, y):\\n r = x % y\\n if r == 0:\\n return y\\n else:\\n return mcd(y, r)\",\n \"def _densityctr(self, rangex, rangey, dim = misc.DEF_VIS_DIM):\\n gr = N.meshgrid(rangex, rangey)\\n x = gr[0].flatten()\\n y = gr[1].flatten()\\n xdata = N.concatenate((x[:, N.newaxis], y[:, N.newaxis]), axis = 1)\\n dmu = self.mu[:, dim]\\n dva = self._get_va(dim)\\n den = GM.fromvalues(self.w, dmu, dva).pdf(xdata, log = True)\\n den = den.reshape(len(rangey), len(rangex))\\n\\n return gr[0], gr[1], den\",\n \"def _compute_prob_y_given_x(self, _x, _y):\\n normalisation_constant = sum([\\n math.exp(sum([self.weights[_feature] *\\n self.feature_funcs[_feature, cls](_feature, cls)\\n for _feature in _x]))\\n for cls in self.classes])\\n\\n return math.exp(sum([\\n self.weights[_feature] *\\n self.feature_funcs[_feature, _y](_feature, _y)\\n for _feature in _x])) / normalisation_constant\",\n \"def L2_dists(x, y):\\n #print(x.shape)\\n #print(y.shape)\\n dists = -2 * np.matmul(x, y.T)\\n dists += np.sum(x**2)[np.newaxis]\\n dists += np.sum(y**2)\\n return np.sqrt(dists)\",\n \"def cid(x, y):\\n assert(len(x.shape) == 2 and x.shape == y.shape) # time series must have same length and dimensionality\\n ce_x = np.sqrt(np.sum(np.square(np.diff(x, axis=0)), axis=0) + 1e-9)\\n ce_y = np.sqrt(np.sum(np.square(np.diff(y, axis=0)), axis=0) + 1e-9)\\n d = np.sqrt(np.sum(np.square(x - y), axis=0)) * np.divide(np.maximum(ce_x, ce_y), np.minimum(ce_x, ce_y))\\n return np.sum(d)\",\n \"def occupation_distribution(data):\",\n \"def mutual_information_monte_carlo_extrapolate(self, ret_prob_activity=False):\\n if self.is_correlated_mixture:\\n raise NotImplementedError('Not implemented for correlated mixtures')\\n \\n base = 2 ** np.arange(0, self.Nr)\\n prob_s = self.substrate_probabilities\\n\\n max_steps = self._sample_steps\\n steps, MIs = [], []\\n\\n # sample mixtures according to the probabilities of finding\\n # substrates\\n count_a = np.zeros(2**self.Nr)\\n step_check = 10000\\n for step in range(max_steps):\\n # choose a mixture vector according to substrate probabilities\\n m = (np.random.random(self.Ns) < prob_s)\\n \\n # get the associated output ...\\n a = np.dot(self.sens_mat, m).astype(np.bool)\\n # ... and represent it as a single integer\\n a = np.dot(base, a)\\n # increment counter for this output\\n count_a[a] += 1\\n\\n if step == step_check - 1:\\n # do an extrapolation step\\n # calculate the mutual information from the result pattern\\n prob_a = count_a / step\\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\\n \\n # save the data \\n steps.append(step)\\n MIs.append(MI)\\n \\n # do the extrapolation\\n if len(steps) >= 3:\\n a2, a1, a0 = MIs[-3:]\\n MI_ext = (a0*a2 - a1*a1)/(a0 - 2*a1 + a2)\\n# MI_ext = self._get_extrapolated_mutual_information(steps, MIs)\\n print((step, MIs[-1], MI_ext))\\n \\n step_check += 10000\\n \\n else:\\n # count_a contains the number of times output pattern a was observed.\\n # We can thus construct P_a(a) from count_a. \\n \\n # calculate the mutual information from the result pattern\\n prob_a = count_a / step\\n MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)\\n\\n if ret_prob_activity:\\n return MI, prob_a\\n else:\\n return MI\",\n \"def get_trans_pmi(x2ys, x2cnt, y2cnt, Nxy, Nx, Ny, width, n_trans):\\n x2ys_pmi = dict()\\n pmi_diff = -np.log2(Nxy) + np.log2(Nx) + np.log2(Ny)\\n for x, ys in tqdm(x2ys.items()):\\n l_scores = []\\n for y, cnt in sorted(ys.items(), key=operator.itemgetter(1),\\n reverse=True)[:width]:\\n pmi = np.log2(cnt) - np.log2(x2cnt[x]) - np.log2(y2cnt[y])\\n pmi += pmi_diff\\n l_scores.append((y, pmi))\\n trans = sorted(l_scores, key=operator.itemgetter(1, 0), reverse=True)[:n_trans]\\n trans = [each[0] for each in trans]\\n x2ys_pmi[x] = trans\\n\\n return x2ys_pmi\",\n \"def dist(self, X, Y):\\n raise NotImplementedError\",\n \"def conditional_MI(data=None, x=None, y=None, z=None):\\n X = data[list(x)].astype(int)\\n Y = data[list(y)].astype(int)\\n t = list(z)\\n Z = data[t].astype(int)\\n Z = Z.values.tolist()\\n Z = list(data[t].itertuples(index=False, name=None))\\n Hxz = entropy(map(lambda x: \\\"%s/%s\\\" % x, zip(X, Z))) # Finding Joint entropy of X and Z\\n Hyz = entropy(map(lambda x: \\\"%s/%s\\\" % x, zip(Y, Z))) # Finding Joint entropy of Y and Z\\n Hz = entropy(Z) # Finding Entropy of Z\\n Hxyz = entropy(map(lambda x: \\\"%s/%s/%s\\\" % x, zip(X, Y, Z))) # Finding Joint Entropy of X, Y and Z\\n return Hxz + Hyz - Hxyz - Hz\",\n \"def mutual_information_from_table(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n\\n marginals_p1 = np.nansum(P_nan, axis=1)\\n marginals_p2 = np.nansum(P_nan, axis=0)\\n\\n return np.nansum(np.multiply(P_nan, np.log2(P_nan / (np.tensordot(marginals_p1, marginals_p2, axes=0)))))\",\n \"def information_gain(Y, attr):\\n initial_gain = entropy(Y)\\n\\n temp_Y = Y.tolist()\\n temp_attr = attr.tolist()\\n\\n temp_attr = list(np.unique(attr))\\n\\n for a in temp_attr:\\n l = []\\n count = 0\\n for j in attr:\\n if (j == a):\\n l.append(temp_Y[count])\\n count+=1\\n initial_gain -= ((len(l) / len(temp_Y)) * entropy(pd.Series(l)))\\n return initial_gain\",\n \"def calc_euclidian_dists(x, y):\\n n = x.shape[0]\\n m = y.shape[0]\\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)\",\n \"def informationGain2(data, attribute):\\n \\n split_data = splitBy(data, attribute) \\n weighted_entropies = 0\\n \\n for set in split_data:\\n weighted_entropies += len(set) / len(data) * entropy2(set) \\n \\n columnIG = entropy2(data) - weighted_entropies\\n \\n return columnIG\",\n \"def get_mi(x, y, k=1, normalize=None, norm=np.inf, estimator='ksg'):\\n\\n if normalize:\\n x = normalize(x)\\n y = normalize(y)\\n\\n # construct state array for the joint process:\\n xy = np.c_[x,y]\\n\\n if estimator == 'naive':\\n # compute individual entropies\\n hx = get_h(x, k=k, norm=norm)\\n hy = get_h(y, k=k, norm=norm)\\n hxy = get_h(xy, k=k, norm=norm)\\n\\n # compute mi\\n mi = hx + hy - hxy\\n\\n elif estimator == 'ksg':\\n\\n # store data pts in kd-trees for efficient nearest neighbour computations\\n # TODO: choose a better leaf size\\n x_tree = cKDTree(x)\\n y_tree = cKDTree(y)\\n xy_tree = cKDTree(xy)\\n\\n # kth nearest neighbour distances for every state\\n # query with k=k+1 to return the nearest neighbour, not counting the data point itself\\n # dist, idx = xy_tree.query(xy, k=k+1, p=norm)\\n dist, idx = xy_tree.query(xy, k=k+1, p=np.inf)\\n epsilon = dist[:, -1]\\n\\n # for each point, count the number of neighbours\\n # whose distance in the x-subspace is strictly < epsilon\\n # repeat for the y subspace\\n n = len(x)\\n nx = np.empty(n, dtype=np.int)\\n ny = np.empty(n, dtype=np.int)\\n for ii in range(n):\\n # nx[ii] = len(x_tree.query_ball_point(x_tree.data[ii], r=epsilon[ii], p=norm)) - 1\\n # ny[ii] = len(y_tree.query_ball_point(y_tree.data[ii], r=epsilon[ii], p=norm)) - 1\\n nx[ii] = len(x_tree.query_ball_point(x_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\\n ny[ii] = len(y_tree.query_ball_point(y_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\\n\\n mi = digamma(k) - np.mean(digamma(nx+1) + digamma(ny+1)) + digamma(n) # version (1)\\n # mi = digamma(k) -1./k -np.mean(digamma(nx) + digamma(ny)) + digamma(n) # version (2)\\n\\n elif estimator == 'lnc':\\n # TODO: (only if you can find some decent explanation on how to set alpha!)\\n raise NotImplementedError(\\\"Estimator is one of 'naive', 'ksg'; currently: {}\\\".format(estimator))\\n\\n else:\\n raise NotImplementedError(\\\"Estimator is one of 'naive', 'ksg'; currently: {}\\\".format(estimator))\\n\\n return mi\",\n \"def _basic_data_info(X, y):\\n num_samples, num_feats = X.shape # start with X properties\\n\\n # Compute distribution\\n classes, counts, percs = _class_distribution(y)\\n num_classes = classes.size\\n\\n # Return data info dictionary\\n output_dic = {\\n \\\"Num_samples\\\": num_samples,\\n \\\"Num_feats\\\": num_feats,\\n \\\"Num_classes\\\": num_classes,\\n \\\"classes\\\": classes,\\n \\\"counts\\\": counts,\\n \\\"percs\\\": percs\\n }\\n\\n return output_dic\",\n \"def cofactors(self,x,y):\\r\\n return self.factorset(x) & self.factorset(y)\",\n \"def mutual_information(pred, true):\\n \\n #for now , only for univariate forecasting. So reshapes entire batch of K timesteps into vector as if single feature\\n MI = mutual_info_regression(true.detach().numpy().flatten().reshape(-1,1), pred.detach().numpy().flatten())[0]\\n return torch.tensor(MI)\",\n \"def marginalize(self, axis):\\n \\n dist = {}\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE\\n #\\n \\n # get relevant data based on the given random variable\\n for i in self._table:\\n if axis == 0:\\n if i[0] in dist:\\n dist[i[0]] += self._table[i]\\n else:\\n dist[i[0]] = self._table[i]\\n else:\\n if i[1] in dist:\\n dist[i[1]] += self._table[i]\\n else:\\n dist[i[1]] = self._table[i]\\n\\n\\n #\\n # END OF YOUR CODE\\n # ------------------------------------------------------------------------- \\n\\n return dist\",\n \"def mmd2(K_xx, K_yy, K_xy, w_x=None, w_y=None):\\n n, m = K_xy.shape\\n\\n assert n == K_xx.shape[0], \\\"Shapes must conform between K_xx and K_xy, K_xx.shape == {}, K_xy.shape == {}\\\".format(\\n K_xx.shape, K_xy.shape)\\n assert m == K_yy.shape[0], \\\"Shapes must conform between K_yy and K_xy, K_yy.shape == {}, K_xy.shape == {}\\\".format(\\n K_yy.shape, K_xy.shape)\\n\\n if isinstance(w_x, np.ndarray) and isinstance(w_y, np.ndarray):\\n assert np.isclose(w_x.sum(), 1) and np.isclose(\\n w_y.sum(), 1), \\\"w_x and w_y must sum to 1\\\"\\n assert w_x.shape == (n, 1) and w_y.shape == (\\n m, 1), \\\"w_x and w_y must conform to K_xx and K_yy, have w_x.shape == {}, w_y.shape == {} and K_xx.shape == {}, K_yy == {}\\\".format(w_x.shape, w_y.shape, K_xx.shape, K_yy.shape)\\n assert (w_x >= 0).all(), \\\"All entries of w_x should be greater than zero\\\"\\n assert (w_y >= 0).all(), \\\"All entries of w_y should be greater than zero\\\"\\n mmd2 = w_x.T @ K_xx @ w_x - 2 * w_x.T @ K_xy @ w_y + w_y.T @ K_yy @ w_y\\n else:\\n mmd2 = (K_xx.sum() / (n**2)) + (K_yy.sum() / (m**2)) - \\\\\\n 2 * (K_xy.sum() / (m*n))\\n\\n # Had problem with negative values on order of machine epsilon\\n mmd2 += 2 * np.finfo(float).eps\\n assert mmd2 > 0.0, \\\"mmd2 should be non-negative, is {}\\\".format(mmd2)\\n\\n return mmd2\",\n \"def prob(self, x, y):\\n p = self.tag_prob(y)\\n for i in range(len(y)):\\n p *= self.out_prob(x[i], y[i])\\n\\n return p\",\n \"def marginal_2D(self, wrt_x, wrt_y, figure_name=None):\\n res = self.marginalize_wrt_x_y(wrt_x, wrt_y)\\n tagx= np.array([tup[0] for tup in res], dtype=np.int16)\\n tagy= np.array([tup[1] for tup in res], dtype=np.int16)\\n z = np.array([tup[2] for tup in res], dtype=np.float32)\\n\\n if wrt_x == 'logD':\\n x = tagx[:]\\n else:\\n x = self.convert_tags_to_features(tagx, wrt_x)\\n if wrt_y == 'logD':\\n y = tagy[:]\\n else:\\n y = self.convert_tags_to_features(tagy, wrt_y)\\n\\n nx = ny = 101\\n xi = np.linspace(min(x), max(x), nx)\\n yi = np.linspace(min(y), max(y), ny)\\n xi_ = xi[None,:]\\n yi_ = yi[:,None]\\n # zi0 = mlab.griddata(x, y, z, xi, yi, interp='linear')\\n zi = interpolate.griddata((x, y), z, (xi_, yi_), method='cubic')\\n zi[np.isnan(zi)] = 0.0\\n max_zi = np.max(zi)\\n zi_low = max_zi / 100.0\\n ind_zero = zi <= zi_low\\n zi[zi <= ind_zero] = 0\\n\\n if figure_name is None: return (x, y, xi, yi, zi)\\n\\n # Continue making the figure\\n fig, ax = plt.subplots(1, figsize=(4,4), dpi=100, tight_layout=True)\\n\\n lev = marg_contour_levels\\n # c = ax.contour(xi, yi, zi, lev, linestyle='dotted', linewidth=0.5, color='k')\\n cf = ax.contourf(xi, yi, zi, lev, zorder=1, cmap=plt.get_cmap('Greys'),\\n norm=plt.Normalize(vmin=0, vmax=abs(zi).max())) \\n ax.scatter(x, y, marker=',', facecolor='grey', edgecolor='grey', s=1, zorder=2)\\n cb = fig.colorbar(cf, ax=ax, shrink=1.00)\\n\\n ax.set_xlabel(utils.feature_name_in_latex(wrt_x))\\n ax.set_ylabel(utils.feature_name_in_latex(wrt_y))\\n\\n if wrt_x == 'logD': \\n ax.xaxis.set_ticks(range(5))\\n ax.set_xticklabels(logD_ticks, rotation=45, fontsize='small')\\n\\n if wrt_y == 'logD': \\n ax.yaxis.set_ticks(range(5))\\n ax.set_yticklabels(logD_ticks, rotation=45, fontsize='small')\\n\\n if figure_name is not None:\\n plt.savefig(figure_name)\\n logger.info('marginal_2D: saved {0}'.format(figure_name))\\n plt.close()\\n\\n return (x, y, xi, yi, zi)\",\n \"def get_pmi_mvn(x, y, z):\\n\\n d = x.shape[1]\\n hz = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(z.T)))\\n hxz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=z.T)))\\n hyz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(y.T, y=z.T)))\\n hxyz = 0.5 * log((2 * np.pi * np.e)**(3*d) * det(np.cov(np.c_[x,y,z].T)))\\n\\n pmi = hxz + hyz - hxyz - hz\\n return pmi\",\n \"def _mutual_info(self, object_focus, premise_focus, object_cp):\\n\\n # match up change points with known object's\\n assert object_focus.shape[0] == premise_focus.shape[0]\\n n_focus = object_focus.shape[0]\\n object_cp_mask = util.list_to_mask(object_cp, n_focus)\\n\\n # filter out those timestamp when object's far from premise\\n prox_mask = self._get_prox_mask(object_focus, premise_focus)\\n match_mask = object_cp_mask & prox_mask\\n diffs_mask = object_cp_mask ^ prox_mask\\n if self.verbose:\\n logger.info('prox filter valid= %d: match= %3d, diff= %3d'%(\\n np.sum(prox_mask), np.sum(match_mask), np.sum(diffs_mask)))\\n\\n # probability of proximal conditioned on changepoint\\n frame_shape = self.frame_source.get_shape()[-2:]\\n frame_shape = (frame_shape[0] // 8, frame_shape[1] // 8)\\n is_object_cp = set(object_cp)\\n tp, fp, fn, tn = 1e-10, 1e-10, 1e-10, 1e-10\\n cp_cnt = np.zeros(frame_shape)\\n prox_cnt = np.zeros(frame_shape)\\n cp_prox_cnt = np.zeros(frame_shape)\\n total_cnt = np.zeros(frame_shape)\\n for i, obj_fx in enumerate(object_focus):\\n obj_x = (obj_fx * frame_shape).astype(int)\\n total_cnt[obj_x[0], obj_x[1]] += 1\\n if prox_mask[i]:\\n prox_cnt[obj_x[0], obj_x[1]] += 1\\n if i in is_object_cp:\\n tp += 1\\n else:\\n fp += 1\\n else:\\n if i in is_object_cp:\\n fn += 1\\n else:\\n tn += 1\\n for cpi in object_cp:\\n obj_x = (object_focus[cpi] * frame_shape).astype(int)\\n premise_x = (premise_focus[cpi] * frame_shape).astype(int)\\n cp_cnt[obj_x[0], obj_x[1]] += 1\\n if prox_mask[cpi]:\\n cp_prox_cnt[obj_x[0], obj_x[1]] += 1\\n none_cnt = total_cnt - cp_cnt - prox_cnt + cp_prox_cnt\\n cnt_valid = np.logical_and(cp_prox_cnt > 0.0, \\n prox_cnt - cp_prox_cnt > 0.0)\\n cndcp_score = np.mean(2 * cp_prox_cnt[cnt_valid]\\n / (cp_cnt[cnt_valid] + prox_cnt[cnt_valid])) \\\\\\n if np.sum(cnt_valid) > 0.0 else 0.0\\n # util.confuse_metrics(cp_prox_cnt, prox_cnt-cp_prox_cnt, \\n # cp_cnt-cp_prox_cnt, none_cnt)\\n \\n # print('tp', int(tp), 'fp', int(fp), 'fn', int(fn), 'tn', int(tn))\\n # util.confuse_metrics(tp, fp, fn, tn)\\n\\n return np.sum(match_mask)/n_focus, \\\\\\n np.sum(diffs_mask)/n_focus, \\\\\\n np.sum(prox_mask)/n_focus, \\\\\\n cndcp_score\",\n \"def _mutual_info(self, focus, object_cp, premise_cp):\\n\\n # match up change points with known object's\\n n_focus = focus.shape[0]\\n match_mask, diffs_mask = util.match_diffs(object_cp, premise_cp, n_focus)\\n\\n return np.sum(match_mask)/n_focus, np.sum(diffs_mask)/n_focus, n_focus\",\n \"def posteriorDistribution(x,z,beta,sigma2):\\r\\n ### TODO: Write your code here\\r\\n mu = 0\\r\\n Cov = 0\\r\\n\\r\\n x_s = []\\r\\n for i in np.linspace(-1 , 1 , 150):\\r\\n for j in np.linspace(-1 , 1 , 150):\\r\\n x_s.append([i,j])\\r\\n x_s = np.array(x_s)\\r\\n\\r\\n X = []\\r\\n for i in x:\\r\\n j = [1,i[0]]\\r\\n X.append(j)\\r\\n X = np.array(X)\\r\\n\\r\\n common = np.matmul( X.T , X) + np.identity(2) * sigma2/beta\\r\\n common = np.linalg.inv(common)\\r\\n Cov = common * sigma2\\r\\n mu = np.matmul(common , np.matmul (X.T , z) )\\r\\n mu = mu.flatten()\\r\\n print(\\\"X.shape: \\\" , X.shape)\\r\\n print(\\\"z.shape: \\\",z.shape)\\r\\n print(\\\"Cov.shape\\\" , Cov.shape)\\r\\n print(\\\"mu.shape: \\\",mu.shape)\\r\\n density = util.density_Gaussian(mu , Cov , x_s).reshape(150 , 150 ).T\\r\\n print(\\\"density.shape\\\",density.shape)\\r\\n X,Y = np.meshgrid( np.linspace(-1,1,150) , np.linspace(-1,1,150) )\\r\\n\\r\\n \\r\\n\\r\\n plt.contour( X , Y , np.reshape(density , (150, 150 )))\\r\\n plt.plot(-0.1 , -0.5 , marker = 'o' , MarkerSize = 10 , label = 'point a')\\r\\n plt.xlabel('a0 ')\\r\\n plt.ylabel(' a1 ')\\r\\n plt.legend()\\r\\n plt.xlim = (-1,1)\\r\\n plt.ylim = (-1,1)\\r\\n plt.title('p(a|x1,z1....xn,zn) for '+ str(len(x)) +' samples')\\r\\n plt.show() \\r\\n print('-x-x-x-x-x-x-x-x-x')\\r\\n\\r\\n return (mu,Cov)\",\n \"def cross_entropy(x, y, bins, xy_probabilities=False):\\n # calculate probabilities if probabilities == False\\n if xy_probabilities:\\n # same bins for x and y -> same length of x and y if xy_probabilities == True\\n assert len(x) == len(y)\\n\\n # if x does not sum up to 1, raise an error\\n if not np.isclose(sum(x),1,atol=0.0001):\\n raise ValueError('Probabilities in vector x do not sum up to 1.')\\n # if y does not sum up to 1, raise an error\\n if not np.isclose(sum(y),1,atol=0.0001):\\n raise ValueError('Probabilities in vector y do not sum up to 1.')\\n\\n # add a small number to all probabilities if zero occurs\\n if x.any(0):\\n px = x + 1e-15\\n py = y + 1e-15\\n else:\\n px = x\\n py = y\\n else:\\n # get the bins, joint bins for x and y (same_bins=True)\\n bins = get_2D_bins(x, y, bins, same_bins=True)\\n\\n # calculate unconditioned histograms\\n hist_x = np.histogram(x, bins=bins[0])[0]\\n hist_y = np.histogram(y, bins=bins[1])[0]\\n\\n px = (hist_x / np.sum(hist_x)) + 1e-15\\n py = (hist_y / np.sum(hist_y)) + 1e-15\\n\\n return - px.dot(np.log2(py))\",\n \"def obtain_consistent_marginals(self, priv_marginal_config, priv_split_method) -> Marginals:\\n\\n # generate_all_pub_marginals() generates all the one and two way marginals of the public set which is implemented in DataLoader.py\\n if self.data.pub_ref:\\n pub_marginals = self.data.generate_all_pub_marginals()\\n \\n # get_noisy_marginals() is in synthesizer.py\\n # which first calls generate_..._by_config(), and computes on priv_data to return marginal_sets, epss\\n # (note that 'marginal_key' could be 'priv_all_one_way' or 'priv_all_two_way')\\n # later it calls anonymize() which add noises to marginals\\n # (what decides noises is 'priv_split_method') \\n # priv_split_method[set_key]='lap' or....\\n # Step 1: generate noisy marginals\\n noisy_marginals = self.get_noisy_marginals(priv_marginal_config, priv_split_method)\\n\\n # since calculated on noisy marginals\\n # we use mean function to estimate the number of synthesized records\\n num_synthesize_records = np.mean([np.sum(x.values) for _, x in noisy_marginals.items()]).round().astype(np.int)\\n print(\\\"------------------------> now we get the estimate of records' num by averaging from nosiy marginals:\\\", num_synthesize_records)\\n \\n \\n \\n # the list of all attributes' name(str) except the identifier attribute\\n self.attr_list = self.data.obtain_attrs()\\n # domain_list is an array recording the count of each attribute's candidate values\\n self.domain_list = np.array([len(self.data.encode_schema[att]) for att in self.attr_list])\\n \\n # map the attribute str to its index in attr_list, for possible use\\n # use enumerate to return Tuple(index, element) \\n self.attr_index_map = {att: att_i for att_i, att in enumerate(self.attr_list)}\\n\\n\\n # views are wrappers of marginals with additional functions for consistency\\n # if there exist public dataset to refer to\\n if self.data.pub_ref:\\n pub_onehot_view_dict, pub_attr_view_dict = self.construct_views(pub_marginals)\\n # Step 2: create some data structures\\n noisy_onehot_view_dict, noisy_attr_view_dict = self.construct_views(noisy_marginals)\\n \\n # all_views is one-hot to view dict, views_dict is attribute to view dict\\n # they have different format to satisfy the needs of consistenter and synthesiser\\n # to fit in code when we do not have public things to utilize \\n if not self.data.pub_ref:\\n pub_onehot_view_dict = noisy_onehot_view_dict\\n pub_attr_view_dict = noisy_attr_view_dict\\n\\n self.onehot_view_dict, self.attrs_view_dict = self.normalize_views(\\n pub_onehot_view_dict,\\n pub_attr_view_dict,\\n noisy_attr_view_dict,\\n self.attr_index_map,\\n num_synthesize_records)\\n\\n # consist the noisy marginals to submit to some rules\\n consistenter = Consistenter(self.onehot_view_dict, self.domain_list)\\n consistenter.consist_views()\\n\\n # consistenter uses unnormalized counts;\\n # after consistency, synthesizer uses normalized counts\\n for _, view in self.onehot_view_dict.items():\\n view.count /= sum(view.count)\\n\\n return noisy_marginals, num_synthesize_records\",\n \"def make_frequency_table(x, y, X, Y):\\n freq = dict()\\n\\n for i in range(len(X)):\\n freq[X[i]] = [0, 0]\\n\\n # merging the two to get a matrix\\n\\n M = np.array([[x[i], y[i]] for i in range(len(x))])\\n\\n for i in range(len(M)):\\n if M[i][1] == Y[0]:\\n freq[M[i][0]][0] += 1\\n else:\\n freq[M[i][0]][1] += 1\\n\\n return freq\",\n \"def _update_info_and_n(self, y_i, h_tilde, phi_p, msr_cov):\\n h_i = np.matmul(h_tilde, phi_p)\\n # update fisher_info\\n L = np.matmul(np.transpose(h_i), np.matmul(msr_cov, h_i)) # placeholder matrix for computations\\n self.fisher_info.append(np.add(self.fisher_info[-1], L))\\n # update N\\n M = np.matmul(np.transpose(h_i), np.matmul(msr_cov, np.transpose(y_i))) #placeholder matrix for computations\\n self.N.append(np.add(self.N[-1], M))\",\n \"def _impurity(y, y1, y2, sample_weights=None):\\n # YOUR CODE HERE\\n # begin answer\\n weight_1=len(y1)\\n weight_2=len(y2)\\n meal_1=np.sum(y1)/float(weight_1)\\n meal_2=np.sum(y2)/float(weight_2)\\n diff=meal_1-meal_2\\n sum_var=weight_1*weight_2*diff*diff/(weight_1+weight_2)\\n # end answer\\n return sum_var\",\n \"def get_mutual_information(filename):\\n categories = {} #{category: speakers of this category}\\n features = {} #{feat: speakers who use this feature}\\n pos_categories_features = {} #{category: {feat: speakers of category who use this feat}}\\n neg_categories_features = {} #{category: {feat: speakers of category who do not use this feat}}\\n users = set() #set of all users in data\\n \\n for line in open(filename):\\n userid, c, date, statusid, rawtweet, toktweet, tagtweet = line.split('\\\\t')\\n users.add(userid)\\n \\n if c not in categories:\\n categories[c] = set()\\n pos_categories_features[c] = {}\\n categories[c].add(userid)\\n \\n feats = set(toktweet.lower().split()) #lowercase tweet and split into words\\n\\n for feat in feats:\\n if feat not in pos_categories_features[c]:\\n pos_categories_features[c][feat] = set()\\n pos_categories_features[c][feat].add(userid)\\n \\n if feat not in features:\\n features[feat] = set()\\n features[feat].add(userid)\\n\\n print \\\"Parsed data\\\"\\n\\n numfeats = len(features) #num of features\\n print numfeats, \\\"features\\\"\\n numusers = len(users) #num of users \\n print numusers, \\\"users\\\"\\n\\n #keep sizes of sets, not sets themselves\\n for feat in features:\\n features[feat] = len(features[feat])\\n for c in categories:\\n categories[c] = len(categories[c])\\n for c in pos_categories_features:\\n for feat in features:\\n if feat in pos_categories_features[c]:\\n pos_categories_features[c][feat] = len(pos_categories_features[c][feat])\\n else:\\n pos_categories_features[c][feat] = 0\\n\\n for c in categories:\\n print c, categories[c], \\\"users\\\"\\n\\n print \\\"Computed counts\\\"\\n \\n mi = {}\\n for feat in features:\\n mi[feat] = 0.0\\n for c in categories:\\n #print c, feat, features[feat], pos_categories_features[c][feat]\\n \\n catprob = categories[c]/numusers\\n\\n #prob of speakers of category c using feat\\n featprob = features[feat]/numusers\\n jointprob = pos_categories_features[c][feat]/numusers\\n if jointprob > 0 and featprob > 0:\\n mi[feat] += jointprob * log2(jointprob/(catprob * featprob))\\n \\n #prob of speakers of category c NOT using feat\\n featprob = 1 - featprob\\n jointprob = (categories[c] - pos_categories_features[c][feat])/numusers\\n if jointprob > 0 and featprob > 0:\\n mi[feat] += jointprob * log2(jointprob/(catprob * featprob))\\n\\n print \\\"Computed mutual information\\\"\\n\\n feature_scores = sorted(mi.items(), key=lambda x:x[1], reverse=True)\\n refcat = categories.keys()[0] #pick one of the categories\\n print 'Feature\\\\tMI\\\\tP({0}|Feature)\\\\tNum. users'.format(refcat)\\n for feat, score in feature_scores[:200]:\\n prob = pos_categories_features[refcat][feat]/features[feat]\\n print '{0}\\\\t{1:.3f}\\\\t{2:.3f}\\\\t{3}'.format(feat, score, prob, features[feat])\",\n \"def C(self, y, x):\\n return self.minor(y,x).det()*(-1.0)**(y+x+2.0)\",\n \"def mmi_norm(self, x, y, tuples):\\r\\n P_ = {x: self.P(x, tuples), y: self.P(y, tuples)}\\r\\n P_xy = self.condP(x, y, tuples)\\r\\n return - P_[x] * log2(P_[x]) - P_[y] * (-P_xy * log2(P_xy))\",\n \"def information_reduction(\\n X: np.ndarray, Y: np.ndarray, uni_entropy: Callable, tol_dims: int, p: float = 0.25,\\n) -> float:\\n # calculate the marginal entropy\\n hx = jax.vmap(uni_entropy)(X.T)\\n hy = jax.vmap(uni_entropy)(Y.T)\\n\\n # Information content\\n delta_info = np.sum(hy) - np.sum(hx)\\n tol_info = np.sqrt(np.sum((hy - hx) ** 2))\\n\\n # get tolerance\\n n_dimensions = X.shape[1]\\n\\n # conditional\\n cond = np.logical_or(\\n tol_info < np.sqrt(n_dimensions * p * tol_dims ** 2), delta_info < 0\\n )\\n return np.array(np.where(cond, 0.0, delta_info))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8168408","0.78968424","0.74779177","0.73788935","0.72612417","0.71773905","0.7003771","0.66112494","0.63962644","0.6395062","0.6346539","0.6204402","0.61775285","0.61775285","0.6012243","0.59877944","0.58945143","0.588451","0.5869148","0.5841374","0.5809743","0.5729805","0.5727414","0.56662536","0.5636081","0.56304675","0.5628946","0.5613597","0.5563033","0.55395275","0.5447546","0.5433021","0.543216","0.54252166","0.5414748","0.54035026","0.53933233","0.5380384","0.5380088","0.53800124","0.5378057","0.53614","0.53254634","0.527559","0.52741164","0.52741164","0.5272789","0.527138","0.5267276","0.5230705","0.5224003","0.522376","0.5207498","0.51915324","0.5176436","0.5167963","0.51548064","0.5146139","0.5128395","0.51241577","0.5120819","0.5117544","0.51168674","0.5107121","0.51004153","0.5099705","0.5099515","0.50876856","0.5086105","0.50697327","0.5061687","0.5059447","0.505844","0.5046841","0.50450414","0.5036962","0.50272846","0.50199515","0.501416","0.50084525","0.49955836","0.49914473","0.4981081","0.4976352","0.4972747","0.49637088","0.49626595","0.49565917","0.49551675","0.49524516","0.49500343","0.49450034","0.4944269","0.494324","0.49373305","0.4935795","0.49297708","0.49266875","0.49172008","0.49082807"],"string":"[\n \"0.8168408\",\n \"0.78968424\",\n \"0.74779177\",\n \"0.73788935\",\n \"0.72612417\",\n \"0.71773905\",\n \"0.7003771\",\n \"0.66112494\",\n \"0.63962644\",\n \"0.6395062\",\n \"0.6346539\",\n \"0.6204402\",\n \"0.61775285\",\n \"0.61775285\",\n \"0.6012243\",\n \"0.59877944\",\n \"0.58945143\",\n \"0.588451\",\n \"0.5869148\",\n \"0.5841374\",\n \"0.5809743\",\n \"0.5729805\",\n \"0.5727414\",\n \"0.56662536\",\n \"0.5636081\",\n \"0.56304675\",\n \"0.5628946\",\n \"0.5613597\",\n \"0.5563033\",\n \"0.55395275\",\n \"0.5447546\",\n \"0.5433021\",\n \"0.543216\",\n \"0.54252166\",\n \"0.5414748\",\n \"0.54035026\",\n \"0.53933233\",\n \"0.5380384\",\n \"0.5380088\",\n \"0.53800124\",\n \"0.5378057\",\n \"0.53614\",\n \"0.53254634\",\n \"0.527559\",\n \"0.52741164\",\n \"0.52741164\",\n \"0.5272789\",\n \"0.527138\",\n \"0.5267276\",\n \"0.5230705\",\n \"0.5224003\",\n \"0.522376\",\n \"0.5207498\",\n \"0.51915324\",\n \"0.5176436\",\n \"0.5167963\",\n \"0.51548064\",\n \"0.5146139\",\n \"0.5128395\",\n \"0.51241577\",\n \"0.5120819\",\n \"0.5117544\",\n \"0.51168674\",\n \"0.5107121\",\n \"0.51004153\",\n \"0.5099705\",\n \"0.5099515\",\n \"0.50876856\",\n \"0.5086105\",\n \"0.50697327\",\n \"0.5061687\",\n \"0.5059447\",\n \"0.505844\",\n \"0.5046841\",\n \"0.50450414\",\n \"0.5036962\",\n \"0.50272846\",\n \"0.50199515\",\n \"0.501416\",\n \"0.50084525\",\n \"0.49955836\",\n \"0.49914473\",\n \"0.4981081\",\n \"0.4976352\",\n \"0.4972747\",\n \"0.49637088\",\n \"0.49626595\",\n \"0.49565917\",\n \"0.49551675\",\n \"0.49524516\",\n \"0.49500343\",\n \"0.49450034\",\n \"0.4944269\",\n \"0.494324\",\n \"0.49373305\",\n \"0.4935795\",\n \"0.49297708\",\n \"0.49266875\",\n \"0.49172008\",\n \"0.49082807\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7191145"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":3391,"cells":{"query":{"kind":"string","value":"Cross Entropy Calculates the cross entropy of two discrete distributions x and y."},"document":{"kind":"string","value":"def cross_entropy(x, y, bins, xy_probabilities=False):\n # calculate probabilities if probabilities == False\n if xy_probabilities:\n # same bins for x and y -> same length of x and y if xy_probabilities == True\n assert len(x) == len(y)\n\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y),1,atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n\n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n return - px.dot(np.log2(py))"},"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 cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def crossEntropy(p_m1):\n p_m2 = 1 - p_m1\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\n return D","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def alt_cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\n np.std(y_arr, ddof=1) ** 2) / 2.0)\n return delta / pooled_std","def cross_entropy(y_observed, p):\n\n pass","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt(\n (\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\n ) / (len(x_arr) + len(y_arr))\n )\n return delta / pooled_std","def cohens_d(x, y):\n nx, ny = len(x), len(y)\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\n ((nx - 1) + (ny - 1))\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)","def transfer_entropy(X, Y):\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\n\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\n for y_f, x_p, y_p in coords.keys():\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\n\n p_yp = p_dist.sum(axis=2).sum(axis=1)\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\n\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\n denominator[denominator == 0] = np.nan\n\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\n division[division == 0] = np.nan\n\n log = np.log2(division)\n\n return np.nansum(np.multiply(p_dist, log))","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def conditional_entropy(f1, f2):\n\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\n return ce","def compute_cross_entropy(probs, target):\n avg_probs_per_sample = probs.mean(\n -1)\n xe = torch.nn.CrossEntropyLoss(reduction='none')\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()","def cross_entropy(self):\n return self._cross_entropy_func","def J(W1, b1, W2, b2, x, y):\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\n return crossEntropy(y, yhat)","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def calculate_entropy(y):\n\tlog2 = lambda x: math.log(x) / math.log(2)\n\tunique_labels = np.unique(y)\n\tentropy = 0\n\tfor label in unique_labels:\n\t\tcount = len(y[y == label])\n\t\tp = count / len(y)\n\t\tentropy += -p * log2(p)\n\treturn entropy","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def entropyCategorical(attr, X, y):\n uniques = X[attr].unique().tolist()\n idxLists = []\n entropies = []\n weights = []\n for u in uniques:\n idxLists.append(X.index[X[attr] == u].tolist())\n entropies.append(entropy(y, idxLists[-1]))\n weights.append(len(idxLists[-1]))\n\n entropies = np.array(entropies).reshape(1, -1)\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\n weights /= np.sum(weights)\n\n return (uniques, idxLists, (entropies @ weights)[0, 0])","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def crossEntropyPredict(YPredict):\n YPredict = np.atleast_2d(YPredict)\n return np.argmax(YPredict, axis=1)","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def dist_calc(self, x, y):\n p_xy = self.d2_bin(x, y)\n p_x = np.sum(p_xy, axis=1)\n p_y = np.sum(p_xy, axis=0)\n\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\n\n output = max(0.0, (1 - (info / entropy)))\n return output","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def joint_entropy(x, y, bins):\n # assert array length\n assert len(x) == len(y)\n\n # get the bins, x and y get their own bins in case of joint entropy\n bins = get_2D_bins(x, y, bins)\n\n # get the joint histogram\n joint_hist = np.histogram2d(x, y, bins)[0]\n\n # calculate the joint probability and add a small number\n joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15\n\n # calculate and return the joint entropy\n return - np.sum(joint_p * np.log2(joint_p))","def crossEntropyLoss(YPredict, YTrueOneHot):\n if YPredict.shape != YTrueOneHot.shape:\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def compute_dists(x, y):\r\n \r\n return (x - y.permute(0, 2, 1)) ** 2","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def cross_entropy(self, sents):\n return (-1) * self.log_prob(sents) / len(self._count)","def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\n norm_log = log_softmax(input, 1)\n\n np_one_hot = np.eye(input.shape[1])[target.data]\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\n\n mask = -norm_log * tensor_one_hot\n mask_sum = sum(mask, 1)\n loss = sum(mask_sum, 0)\n\n return loss / input.shape[0]","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def cross_entropy_loss():\n return nn.CrossEntropyLoss()","def NCC_loss(x, y):\n len_x = torch.sqrt(torch.sum(x ** 2))\n len_y = torch.sqrt(torch.sum(y ** 2))\n return torch.sqrt(torch.sum((x / len_x - y / len_y) ** 2))","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def categorical_crossentropy(self, y_hat, y):\n y_hat[y_hat == 0] = 10 ** -10\n return -np.sum(y * np.log(y_hat))","def cross_entropy_four_hot(x: float, y: float, width: int, height: int) -> torch.Tensor:\n t = torch.zeros(height, width)\n\n from_left = (x + 1.0) / 2.0 * (width - 1)\n from_top = (y + 1.0) / 2.0 * (height - 1)\n\n width_idx = math.floor(from_left)\n height_idx = math.floor(from_top)\n\n left_frac = from_left - width_idx\n top_frac = from_top - height_idx\n\n t[height_idx + 0, width_idx + 0] = (1 - top_frac) * (1 - left_frac)\n\n if width_idx + 1 < width:\n t[height_idx + 0, width_idx + 1] = (1 - top_frac) * left_frac\n\n if height_idx + 1 < height:\n t[height_idx + 1, width_idx + 0] = top_frac * (1 - left_frac)\n\n if width_idx + 1 < width and height_idx + 1 < height:\n t[height_idx + 1, width_idx + 1] = top_frac * left_frac\n\n return t","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def cross_entropy(\n **kwargs\n) -> Callable:\n return categorical_crossentropy","def cross(x, y):\n x = x.reshape(3)\n y = y.reshape(3)\n z = np.cross(x, y)\n z = z.reshape((3, 1))\n return z","def cross_covariance(\n self, kernel: Kernel, x: Float[Array, \"N D\"], y: Float[Array, \"M D\"]\n ) -> Float[Array, \"N M\"]:\n cross_cov = vmap(lambda x: vmap(lambda y: kernel(x, y))(y))(x)\n return cross_cov","def euclidean_dist(X, y):\n return np.sqrt(np.sum((X - y) ** 2, 1)) # broadcasted calculations","def cid(x, y):\n assert(len(x.shape) == 2 and x.shape == y.shape) # time series must have same length and dimensionality\n ce_x = np.sqrt(np.sum(np.square(np.diff(x, axis=0)), axis=0) + 1e-9)\n ce_y = np.sqrt(np.sum(np.square(np.diff(y, axis=0)), axis=0) + 1e-9)\n d = np.sqrt(np.sum(np.square(x - y), axis=0)) * np.divide(np.maximum(ce_x, ce_y), np.minimum(ce_x, ce_y))\n return np.sum(d)","def calc_euclidian_dists(x, y):\n n = x.shape[0]\n m = y.shape[0]\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)","def entropy(a, b):\n with mp.extradps(5):\n a, b = _validate_a_b(a, b)\n return (_fun.logbeta(a, b)\n - (a - 1)*mp.psi(0, a)\n - (b - 1)*mp.psi(0, b)\n + (a + b - 2)*mp.psi(0, a + b))","def get_cross_entropy(self):\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\n potential = 0.0\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\n return potential","def cv_with_entropy(X, Y):\n\t# Decision tree with entropy\n\tclf_entropy = decision_tree_clf()\n\n\t# Returns score\n\tresult = cross_val_score(\n\t\tclf_entropy, X, Y, \n\t\tscoring='f1_macro', \n\t\tcv=StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)\n\t\t)\n\treturn result","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n # Tip: You can implement XELoss all here, without creating a new subclass of Function.\n # However, if you'd prefer to implement a Function subclass you're free to.\n # Just be sure that nn.loss.CrossEntropyLoss calls it properly.\n\n # Tip 2: Remember to divide the loss by batch_size; this is equivalent\n # to reduction='mean' in PyTorch's nn.CrossEntropyLoss\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def associate_comp(x, y):\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])","def cross(x, y, target=utils.CCE):\n utils.elemwise_shape_check(get_shape(y), get_shape(x))\n utils.elemwise_dtype_check(\n y.dtype, x.dtype,\n (utils.DtypeForDavinci.ALL_FLOAT) if product_is_mini() \\\n else (utils.DtypeForDavinci.FLOAT16,\n utils.DtypeForDavinci.FLOAT32,\n utils.DtypeForDavinci.INT32,\n utils.DtypeForDavinci.INT8, utils.DtypeForDavinci.UINT8))\n\n shape = get_shape(x)\n\n if shape[0] != 3:\n raise RuntimeError(\n \"The first axis of input must be 3, actual input is %d\" % shape[0])\n\n inp_dtype = x.dtype\n need_type_convert = inp_dtype in (\"int8\", \"uint8\")\n\n shape = get_shape(x)\n shp = shape[1:]\n\n if need_type_convert:\n x = cast(x, \"float16\", target=utils.CCE)\n y = cast(y, \"float16\", target=utils.CCE)\n\n a0b1 = tvm.compute(shp, lambda *i: x(0, *i) * y(1, *i), name=\"a0b1\")\n a0b2 = tvm.compute(shp, lambda *i: x(0, *i) * y(2, *i), name=\"a0b2\")\n a1b0 = tvm.compute(shp, lambda *i: x(1, *i) * y(0, *i), name=\"a1b0\")\n a1b2 = tvm.compute(shp, lambda *i: x(1, *i) * y(2, *i), name=\"a1b2\")\n a2b0 = tvm.compute(shp, lambda *i: x(2, *i) * y(0, *i), name=\"a2b0\")\n a2b1 = tvm.compute(shp, lambda *i: x(2, *i) * y(1, *i), name=\"a2b1\")\n\n res0 = tvm.compute(shp, lambda *i: a1b2(*i) - a2b1(*i), name=\"res0\")\n res1 = tvm.compute(shp, lambda *i: a2b0(*i) - a0b2(*i), name=\"res1\")\n res2 = tvm.compute(shp, lambda *i: a0b1(*i) - a1b0(*i), name=\"res2\")\n\n res = tvm.compute(\n shape,\n lambda *i:\n tvm.expr.Select(\n i[0] == 0,\n res0(*i[1:]),\n tvm.expr.Select(i[0] == 1, res1(*i[1:]), res2(*i[1:]))),\n name='res')\n\n if need_type_convert:\n res = cast(res, inp_dtype, target=utils.CCE)\n\n return res","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def _cross_valid_h(h, x, y):\n n = x.shape[0]\n # allocate output\n out = np.empty(n)\n # Loop through each regression point\n for i in range(n):\n # all-1 points\n xx = np.delete(x, i, axis=0)\n yy = np.delete(y, i, axis=0)\n z = (xx - x[i, :]) / h\n out[i] = _nadaraya_watson(z, yy)\n cv = np.sum((y - out)**2) / float(n)\n\n return cv","def d_cross(a, b):\n d_cross = np.zeros((3, 3), dtype=float)\n for i in range(3):\n ei = np.zeros(3, dtype=float)\n ei[i] = 1.0\n d_cross[i] = np.cross(ei, b)\n return d_cross","def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n return -torch.log2(probability_fn(args))","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def cross_cov(a, b): \n da = a - np.mean(a, axis=0)\n db = b - np.mean(b, axis=0)\n\n return np.matmul(da.T, db) / a.shape[0]","def get_cross_entropy(actual, expected):\n\n\t# use try except to handle overflow in the log\n\ttry:\t\n\t\t# formula -(y*log(a) + (1-y)log(1-a))\n\t\tones = np.ones(actual.shape) # used to subtract array from one\n\t\tcross_entropy_vec = np.multiply(expected, np.log(actual)) + np.multiply(ones - expected, np.log(ones - actual))\n\t\tcross_entropy = np.sum(cross_entropy_vec)\n\texcept:\n\t\treturn sys.maxsize\n\n\treturn -1.0*cross_entropy","def cross_entropy(self, true_values, predicted_values):\n\n testing_set_size = len(true_values)\n running_sum = 0\n for i in range(len(true_values)):\n true_set = true_values[i]\n predicted_set = predicted_values[i]\n running_sum += sum([(true_set[j] * math.log(predicted_set[j])) for j in range(len(true_set))])\n\n #print(f\"Average cross entropy:\\t{-running_sum / testing_set_size}\")\n self.performance += (-running_sum / testing_set_size)\n return -running_sum / testing_set_size","def chl_entropy(y, base=2):\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\n p = p[p!=0]/float(len(y))\n S = -1.0*sum(p*log(p))/log(base)\n return S","def evaluate(self, X, y):\n y_pred = self.predict(X)\n return self.cross_entropy_loss(y, y_pred)","def cross_covariance(\n self, kernel: Kernel, x: Float[Array, \"N D\"], y: Float[Array, \"M D\"]\n ) -> Float[Array, \"N M\"]:\n # TODO: This is currently a dense implementation. We should implement\n # a sparse LinearOperator for non-square cross-covariance matrices.\n cross_cov = vmap(lambda x: vmap(lambda y: kernel(x, y))(y))(x)\n return cross_cov","def cross_entropy(p, q, base=2):\n q = ma.array(q, mask=(q == 0))\n return - np.vdot(p, ma.log(q)) / np.log(base)","def _calculate_probs_and_entropy_y(self):\n #calculate y probabilities and H(Y)\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\n self.lab_entropy = 0\n s = sum(self.lab_counts.values())\n for label, count in self.lab_counts.items():\n self.lab_probs[label] = count / s\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])","def entropy(y,w):\r\n\r\n\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\r\n\r\n # y_partition = partition(y)\r\n # elements,counts = np.unique(y,return_counts = True)\r\n # entropy=0\r\n\r\n # for i in range(len(elements)):\r\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\r\n # return entropy\r\n\r\n entropy = 0\r\n # two hypothesis cases 0,1\r\n h = {0: 0, 1: 0}\r\n leny = len(y)\r\n for i in range(leny):\r\n # if y is 0 add 0 to the weight\r\n if y[i] == 0:\r\n h[0] += w[i]\r\n # if y is 1 add 1 to the weight\r\n elif y[i] == 1:\r\n h[1] += + w[i]\r\n # summing all the weighted values \r\n val_sum = h[0] + h[1]\r\n\r\n # entropy calculation\r\n for j in range(len(h)):\r\n h[j] = h[j]/val_sum\r\n # to prevent divide by zero\r\n if h[j] != 0:\r\n entropy += h[j] * np.log2(h[j])\r\n entropy = -(entropy)\r\n return entropy","def ucross(a, b):\n ev = a / np.linalg.norm(a)\n return np.cross(ev, b)","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def crossentropy_loss(y_true, y_pred):\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \n return ce","def __test_cross_entropy_loss():\n y = np.array([[0, 1], [1, 0], [1, 0]])\n yhat = np.array([[.5, .5], [.5, .5], [.5, .5]])\n\n test1 = cross_entropy_loss(tf.constant(y, dtype=tf.int32), tf.constant(yhat, dtype=tf.float32))\n with tf.Session() as sess:\n test1 = sess.run(test1)\n expected = -3 * np.log(.5)\n __test_all_close(\"Cross-entropy test 1\", test1, expected)\n\n print(\"Basic (non-exhaustive) cross-entropy tests pass\")","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def cross(a, b):\n return np.array([a[1]*b[2] - a[2]*b[1],\n a[2]*b[0] - a[0]*b[2],\n a[0]*b[1] - a[1]*b[0]])","def test_cross_entropy(self):\n loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n kl = loss.mean()\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertAlmostEqual(kl, expected_loss)","def _entropy2(labels, base=None):\n\n n_labels = len(labels)\n\n if n_labels <= 1:\n return 0\n\n value,counts = np.unique(labels, return_counts=True)\n probs = counts / n_labels\n n_classes = np.count_nonzero(probs)\n\n if n_classes <= 1:\n return 0\n\n ent = 0.\n\n # Compute entropy\n base = e if base is None else base\n for i in probs:\n ent -= i * log(i, base)\n\n # quick observation shows ent between 0.0 and 4.0.\n return ent","def loss_fn(outputs, labels):\n return nn.CrossEntropyLoss()(outputs, labels)","def get_entropy(*labels):\n entropies = [] #list of entropy values from each subset\n total = 0 #total number of datapoints\n for subset in labels:\n n = len(subset)\n total += n\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\n entropies.append((entropy, n))\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])","def xCrossProd(self, other):\n return other.y * self.z - other.z * self.y","def __init__(self):\n super(MetricCrossEntropy, self).__init__()","def cross_entropy_with_probs(pred_probs, target_probs, name=None):\n with tf.name_scope(name, \"SoftmaxCrossEntropyWithProb\", [pred_probs, target_probs]):\n crossent_loss = -tf.reduce_sum(target_probs * tf.log(pred_probs), reduction_indices=[1], keep_dims=False)\n return crossent_loss","def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\n if type(y_pred) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_pred)))\n if type(y_true) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_true)))\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\n # y_pred = clip(y_pred)\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\n loss = -1 * np.sum(l).item()\n if normalize:\n loss = loss / len(y_pred)\n return loss","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def train_batch(x, y, clf, opt, args):\n opt.zero_grad()\n criterion = nn.CrossEntropyLoss()\n if args.cuda:\n x = x.cuda()\n y = y.cuda()\n\n res = clf(x)\n ncorrect = 0\n for i in range(y.size(0)):\n _, ind = res[i].max(0)\n\n if torch.equal(y[i], ind):\n ncorrect +=1\n\n loss = criterion(res, y)\n loss.backward()\n opt.step()\n\n return loss, ncorrect","def euclidean(x, y):\n return np.sqrt(np.sum((x - y) ** 2))","def getCrossEntropy(visible, PDF):\n\n\tndocs = visible.shape[0]\n\tCrossEnt = numpy.zeros((ndocs,))\n\tfor doc in xrange(ndocs):\n\t\tCrossEnt[doc] = numpy.dot(visible[doc], numpy.log(PDF[doc]))\n\n\treturn CrossEnt.mean()","def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\n log_pred = ivy.log(pred)\n # noinspection PyUnresolvedReferences\n return -ivy.reduce_sum(log_pred * true, axis)","def cross(a,b):\n \n return [ a[1]*b[2] - a[2]*b[1],\n a[2]*b[0] - a[0]*b[2],\n a[0]*b[1] - a[1]*b[0],\n 1.0 ]","def cross(v1, v2):\n return np.cross(v1, v2)","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def categorical_crossentropy(y_pred, y_true):\n with tf.name_scope(\"Crossentropy\"):\n y_pred /= tf.reduce_sum(y_pred,\n reduction_indices=len(y_pred.get_shape())-1,\n keep_dims=True)\n # manual computation of crossentropy\n y_pred = tf.clip_by_value(y_pred, tf.cast(_EPSILON, dtype=_FLOATX),\n tf.cast(1.-_EPSILON, dtype=_FLOATX))\n cross_entropy = - tf.reduce_sum(y_true * tf.log(y_pred),\n reduction_indices=len(y_pred.get_shape())-1)\n return tf.reduce_mean(cross_entropy)"],"string":"[\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def crossEntropy(p_m1):\\n p_m2 = 1 - p_m1\\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\\n return D\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def alt_cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\\n np.std(y_arr, ddof=1) ** 2) / 2.0)\\n return delta / pooled_std\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt(\\n (\\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\\n ) / (len(x_arr) + len(y_arr))\\n )\\n return delta / pooled_std\",\n \"def cohens_d(x, y):\\n nx, ny = len(x), len(y)\\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\\\\n ((nx - 1) + (ny - 1))\\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)\",\n \"def transfer_entropy(X, Y):\\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\\n\\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\\n for y_f, x_p, y_p in coords.keys():\\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\\n\\n p_yp = p_dist.sum(axis=2).sum(axis=1)\\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\\n\\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\\n denominator[denominator == 0] = np.nan\\n\\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\\n division[division == 0] = np.nan\\n\\n log = np.log2(division)\\n\\n return np.nansum(np.multiply(p_dist, log))\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def conditional_entropy(f1, f2):\\n\\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\\n return ce\",\n \"def compute_cross_entropy(probs, target):\\n avg_probs_per_sample = probs.mean(\\n -1)\\n xe = torch.nn.CrossEntropyLoss(reduction='none')\\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()\",\n \"def cross_entropy(self):\\n return self._cross_entropy_func\",\n \"def J(W1, b1, W2, b2, x, y):\\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\\n return crossEntropy(y, yhat)\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def calculate_entropy(y):\\n\\tlog2 = lambda x: math.log(x) / math.log(2)\\n\\tunique_labels = np.unique(y)\\n\\tentropy = 0\\n\\tfor label in unique_labels:\\n\\t\\tcount = len(y[y == label])\\n\\t\\tp = count / len(y)\\n\\t\\tentropy += -p * log2(p)\\n\\treturn entropy\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def entropyCategorical(attr, X, y):\\n uniques = X[attr].unique().tolist()\\n idxLists = []\\n entropies = []\\n weights = []\\n for u in uniques:\\n idxLists.append(X.index[X[attr] == u].tolist())\\n entropies.append(entropy(y, idxLists[-1]))\\n weights.append(len(idxLists[-1]))\\n\\n entropies = np.array(entropies).reshape(1, -1)\\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\\n weights /= np.sum(weights)\\n\\n return (uniques, idxLists, (entropies @ weights)[0, 0])\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def crossEntropyPredict(YPredict):\\n YPredict = np.atleast_2d(YPredict)\\n return np.argmax(YPredict, axis=1)\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def dist_calc(self, x, y):\\n p_xy = self.d2_bin(x, y)\\n p_x = np.sum(p_xy, axis=1)\\n p_y = np.sum(p_xy, axis=0)\\n\\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\\n\\n output = max(0.0, (1 - (info / entropy)))\\n return output\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def joint_entropy(x, y, bins):\\n # assert array length\\n assert len(x) == len(y)\\n\\n # get the bins, x and y get their own bins in case of joint entropy\\n bins = get_2D_bins(x, y, bins)\\n\\n # get the joint histogram\\n joint_hist = np.histogram2d(x, y, bins)[0]\\n\\n # calculate the joint probability and add a small number\\n joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15\\n\\n # calculate and return the joint entropy\\n return - np.sum(joint_p * np.log2(joint_p))\",\n \"def crossEntropyLoss(YPredict, YTrueOneHot):\\n if YPredict.shape != YTrueOneHot.shape:\\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def compute_dists(x, y):\\r\\n \\r\\n return (x - y.permute(0, 2, 1)) ** 2\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def cross_entropy(self, sents):\\n return (-1) * self.log_prob(sents) / len(self._count)\",\n \"def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\\n norm_log = log_softmax(input, 1)\\n\\n np_one_hot = np.eye(input.shape[1])[target.data]\\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\\n\\n mask = -norm_log * tensor_one_hot\\n mask_sum = sum(mask, 1)\\n loss = sum(mask_sum, 0)\\n\\n return loss / input.shape[0]\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def NCC_loss(x, y):\\n len_x = torch.sqrt(torch.sum(x ** 2))\\n len_y = torch.sqrt(torch.sum(y ** 2))\\n return torch.sqrt(torch.sum((x / len_x - y / len_y) ** 2))\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def categorical_crossentropy(self, y_hat, y):\\n y_hat[y_hat == 0] = 10 ** -10\\n return -np.sum(y * np.log(y_hat))\",\n \"def cross_entropy_four_hot(x: float, y: float, width: int, height: int) -> torch.Tensor:\\n t = torch.zeros(height, width)\\n\\n from_left = (x + 1.0) / 2.0 * (width - 1)\\n from_top = (y + 1.0) / 2.0 * (height - 1)\\n\\n width_idx = math.floor(from_left)\\n height_idx = math.floor(from_top)\\n\\n left_frac = from_left - width_idx\\n top_frac = from_top - height_idx\\n\\n t[height_idx + 0, width_idx + 0] = (1 - top_frac) * (1 - left_frac)\\n\\n if width_idx + 1 < width:\\n t[height_idx + 0, width_idx + 1] = (1 - top_frac) * left_frac\\n\\n if height_idx + 1 < height:\\n t[height_idx + 1, width_idx + 0] = top_frac * (1 - left_frac)\\n\\n if width_idx + 1 < width and height_idx + 1 < height:\\n t[height_idx + 1, width_idx + 1] = top_frac * left_frac\\n\\n return t\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def cross_entropy(\\n **kwargs\\n) -> Callable:\\n return categorical_crossentropy\",\n \"def cross(x, y):\\n x = x.reshape(3)\\n y = y.reshape(3)\\n z = np.cross(x, y)\\n z = z.reshape((3, 1))\\n return z\",\n \"def cross_covariance(\\n self, kernel: Kernel, x: Float[Array, \\\"N D\\\"], y: Float[Array, \\\"M D\\\"]\\n ) -> Float[Array, \\\"N M\\\"]:\\n cross_cov = vmap(lambda x: vmap(lambda y: kernel(x, y))(y))(x)\\n return cross_cov\",\n \"def euclidean_dist(X, y):\\n return np.sqrt(np.sum((X - y) ** 2, 1)) # broadcasted calculations\",\n \"def cid(x, y):\\n assert(len(x.shape) == 2 and x.shape == y.shape) # time series must have same length and dimensionality\\n ce_x = np.sqrt(np.sum(np.square(np.diff(x, axis=0)), axis=0) + 1e-9)\\n ce_y = np.sqrt(np.sum(np.square(np.diff(y, axis=0)), axis=0) + 1e-9)\\n d = np.sqrt(np.sum(np.square(x - y), axis=0)) * np.divide(np.maximum(ce_x, ce_y), np.minimum(ce_x, ce_y))\\n return np.sum(d)\",\n \"def calc_euclidian_dists(x, y):\\n n = x.shape[0]\\n m = y.shape[0]\\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)\",\n \"def entropy(a, b):\\n with mp.extradps(5):\\n a, b = _validate_a_b(a, b)\\n return (_fun.logbeta(a, b)\\n - (a - 1)*mp.psi(0, a)\\n - (b - 1)*mp.psi(0, b)\\n + (a + b - 2)*mp.psi(0, a + b))\",\n \"def get_cross_entropy(self):\\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\\n potential = 0.0\\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\\n return potential\",\n \"def cv_with_entropy(X, Y):\\n\\t# Decision tree with entropy\\n\\tclf_entropy = decision_tree_clf()\\n\\n\\t# Returns score\\n\\tresult = cross_val_score(\\n\\t\\tclf_entropy, X, Y, \\n\\t\\tscoring='f1_macro', \\n\\t\\tcv=StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)\\n\\t\\t)\\n\\treturn result\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n # Tip: You can implement XELoss all here, without creating a new subclass of Function.\\n # However, if you'd prefer to implement a Function subclass you're free to.\\n # Just be sure that nn.loss.CrossEntropyLoss calls it properly.\\n\\n # Tip 2: Remember to divide the loss by batch_size; this is equivalent\\n # to reduction='mean' in PyTorch's nn.CrossEntropyLoss\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def associate_comp(x, y):\\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])\",\n \"def cross(x, y, target=utils.CCE):\\n utils.elemwise_shape_check(get_shape(y), get_shape(x))\\n utils.elemwise_dtype_check(\\n y.dtype, x.dtype,\\n (utils.DtypeForDavinci.ALL_FLOAT) if product_is_mini() \\\\\\n else (utils.DtypeForDavinci.FLOAT16,\\n utils.DtypeForDavinci.FLOAT32,\\n utils.DtypeForDavinci.INT32,\\n utils.DtypeForDavinci.INT8, utils.DtypeForDavinci.UINT8))\\n\\n shape = get_shape(x)\\n\\n if shape[0] != 3:\\n raise RuntimeError(\\n \\\"The first axis of input must be 3, actual input is %d\\\" % shape[0])\\n\\n inp_dtype = x.dtype\\n need_type_convert = inp_dtype in (\\\"int8\\\", \\\"uint8\\\")\\n\\n shape = get_shape(x)\\n shp = shape[1:]\\n\\n if need_type_convert:\\n x = cast(x, \\\"float16\\\", target=utils.CCE)\\n y = cast(y, \\\"float16\\\", target=utils.CCE)\\n\\n a0b1 = tvm.compute(shp, lambda *i: x(0, *i) * y(1, *i), name=\\\"a0b1\\\")\\n a0b2 = tvm.compute(shp, lambda *i: x(0, *i) * y(2, *i), name=\\\"a0b2\\\")\\n a1b0 = tvm.compute(shp, lambda *i: x(1, *i) * y(0, *i), name=\\\"a1b0\\\")\\n a1b2 = tvm.compute(shp, lambda *i: x(1, *i) * y(2, *i), name=\\\"a1b2\\\")\\n a2b0 = tvm.compute(shp, lambda *i: x(2, *i) * y(0, *i), name=\\\"a2b0\\\")\\n a2b1 = tvm.compute(shp, lambda *i: x(2, *i) * y(1, *i), name=\\\"a2b1\\\")\\n\\n res0 = tvm.compute(shp, lambda *i: a1b2(*i) - a2b1(*i), name=\\\"res0\\\")\\n res1 = tvm.compute(shp, lambda *i: a2b0(*i) - a0b2(*i), name=\\\"res1\\\")\\n res2 = tvm.compute(shp, lambda *i: a0b1(*i) - a1b0(*i), name=\\\"res2\\\")\\n\\n res = tvm.compute(\\n shape,\\n lambda *i:\\n tvm.expr.Select(\\n i[0] == 0,\\n res0(*i[1:]),\\n tvm.expr.Select(i[0] == 1, res1(*i[1:]), res2(*i[1:]))),\\n name='res')\\n\\n if need_type_convert:\\n res = cast(res, inp_dtype, target=utils.CCE)\\n\\n return res\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def _cross_valid_h(h, x, y):\\n n = x.shape[0]\\n # allocate output\\n out = np.empty(n)\\n # Loop through each regression point\\n for i in range(n):\\n # all-1 points\\n xx = np.delete(x, i, axis=0)\\n yy = np.delete(y, i, axis=0)\\n z = (xx - x[i, :]) / h\\n out[i] = _nadaraya_watson(z, yy)\\n cv = np.sum((y - out)**2) / float(n)\\n\\n return cv\",\n \"def d_cross(a, b):\\n d_cross = np.zeros((3, 3), dtype=float)\\n for i in range(3):\\n ei = np.zeros(3, dtype=float)\\n ei[i] = 1.0\\n d_cross[i] = np.cross(ei, b)\\n return d_cross\",\n \"def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n return -torch.log2(probability_fn(args))\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def cross_cov(a, b): \\n da = a - np.mean(a, axis=0)\\n db = b - np.mean(b, axis=0)\\n\\n return np.matmul(da.T, db) / a.shape[0]\",\n \"def get_cross_entropy(actual, expected):\\n\\n\\t# use try except to handle overflow in the log\\n\\ttry:\\t\\n\\t\\t# formula -(y*log(a) + (1-y)log(1-a))\\n\\t\\tones = np.ones(actual.shape) # used to subtract array from one\\n\\t\\tcross_entropy_vec = np.multiply(expected, np.log(actual)) + np.multiply(ones - expected, np.log(ones - actual))\\n\\t\\tcross_entropy = np.sum(cross_entropy_vec)\\n\\texcept:\\n\\t\\treturn sys.maxsize\\n\\n\\treturn -1.0*cross_entropy\",\n \"def cross_entropy(self, true_values, predicted_values):\\n\\n testing_set_size = len(true_values)\\n running_sum = 0\\n for i in range(len(true_values)):\\n true_set = true_values[i]\\n predicted_set = predicted_values[i]\\n running_sum += sum([(true_set[j] * math.log(predicted_set[j])) for j in range(len(true_set))])\\n\\n #print(f\\\"Average cross entropy:\\\\t{-running_sum / testing_set_size}\\\")\\n self.performance += (-running_sum / testing_set_size)\\n return -running_sum / testing_set_size\",\n \"def chl_entropy(y, base=2):\\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\\n p = p[p!=0]/float(len(y))\\n S = -1.0*sum(p*log(p))/log(base)\\n return S\",\n \"def evaluate(self, X, y):\\n y_pred = self.predict(X)\\n return self.cross_entropy_loss(y, y_pred)\",\n \"def cross_covariance(\\n self, kernel: Kernel, x: Float[Array, \\\"N D\\\"], y: Float[Array, \\\"M D\\\"]\\n ) -> Float[Array, \\\"N M\\\"]:\\n # TODO: This is currently a dense implementation. We should implement\\n # a sparse LinearOperator for non-square cross-covariance matrices.\\n cross_cov = vmap(lambda x: vmap(lambda y: kernel(x, y))(y))(x)\\n return cross_cov\",\n \"def cross_entropy(p, q, base=2):\\n q = ma.array(q, mask=(q == 0))\\n return - np.vdot(p, ma.log(q)) / np.log(base)\",\n \"def _calculate_probs_and_entropy_y(self):\\n #calculate y probabilities and H(Y)\\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\\n self.lab_entropy = 0\\n s = sum(self.lab_counts.values())\\n for label, count in self.lab_counts.items():\\n self.lab_probs[label] = count / s\\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])\",\n \"def entropy(y,w):\\r\\n\\r\\n\\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\\r\\n\\r\\n # y_partition = partition(y)\\r\\n # elements,counts = np.unique(y,return_counts = True)\\r\\n # entropy=0\\r\\n\\r\\n # for i in range(len(elements)):\\r\\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\\r\\n # return entropy\\r\\n\\r\\n entropy = 0\\r\\n # two hypothesis cases 0,1\\r\\n h = {0: 0, 1: 0}\\r\\n leny = len(y)\\r\\n for i in range(leny):\\r\\n # if y is 0 add 0 to the weight\\r\\n if y[i] == 0:\\r\\n h[0] += w[i]\\r\\n # if y is 1 add 1 to the weight\\r\\n elif y[i] == 1:\\r\\n h[1] += + w[i]\\r\\n # summing all the weighted values \\r\\n val_sum = h[0] + h[1]\\r\\n\\r\\n # entropy calculation\\r\\n for j in range(len(h)):\\r\\n h[j] = h[j]/val_sum\\r\\n # to prevent divide by zero\\r\\n if h[j] != 0:\\r\\n entropy += h[j] * np.log2(h[j])\\r\\n entropy = -(entropy)\\r\\n return entropy\",\n \"def ucross(a, b):\\n ev = a / np.linalg.norm(a)\\n return np.cross(ev, b)\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def crossentropy_loss(y_true, y_pred):\\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \\n return ce\",\n \"def __test_cross_entropy_loss():\\n y = np.array([[0, 1], [1, 0], [1, 0]])\\n yhat = np.array([[.5, .5], [.5, .5], [.5, .5]])\\n\\n test1 = cross_entropy_loss(tf.constant(y, dtype=tf.int32), tf.constant(yhat, dtype=tf.float32))\\n with tf.Session() as sess:\\n test1 = sess.run(test1)\\n expected = -3 * np.log(.5)\\n __test_all_close(\\\"Cross-entropy test 1\\\", test1, expected)\\n\\n print(\\\"Basic (non-exhaustive) cross-entropy tests pass\\\")\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def cross(a, b):\\n return np.array([a[1]*b[2] - a[2]*b[1],\\n a[2]*b[0] - a[0]*b[2],\\n a[0]*b[1] - a[1]*b[0]])\",\n \"def test_cross_entropy(self):\\n loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n kl = loss.mean()\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertAlmostEqual(kl, expected_loss)\",\n \"def _entropy2(labels, base=None):\\n\\n n_labels = len(labels)\\n\\n if n_labels <= 1:\\n return 0\\n\\n value,counts = np.unique(labels, return_counts=True)\\n probs = counts / n_labels\\n n_classes = np.count_nonzero(probs)\\n\\n if n_classes <= 1:\\n return 0\\n\\n ent = 0.\\n\\n # Compute entropy\\n base = e if base is None else base\\n for i in probs:\\n ent -= i * log(i, base)\\n\\n # quick observation shows ent between 0.0 and 4.0.\\n return ent\",\n \"def loss_fn(outputs, labels):\\n return nn.CrossEntropyLoss()(outputs, labels)\",\n \"def get_entropy(*labels):\\n entropies = [] #list of entropy values from each subset\\n total = 0 #total number of datapoints\\n for subset in labels:\\n n = len(subset)\\n total += n\\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\\n entropies.append((entropy, n))\\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])\",\n \"def xCrossProd(self, other):\\n return other.y * self.z - other.z * self.y\",\n \"def __init__(self):\\n super(MetricCrossEntropy, self).__init__()\",\n \"def cross_entropy_with_probs(pred_probs, target_probs, name=None):\\n with tf.name_scope(name, \\\"SoftmaxCrossEntropyWithProb\\\", [pred_probs, target_probs]):\\n crossent_loss = -tf.reduce_sum(target_probs * tf.log(pred_probs), reduction_indices=[1], keep_dims=False)\\n return crossent_loss\",\n \"def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\\n if type(y_pred) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_pred)))\\n if type(y_true) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_true)))\\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\\n # y_pred = clip(y_pred)\\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\\n loss = -1 * np.sum(l).item()\\n if normalize:\\n loss = loss / len(y_pred)\\n return loss\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def train_batch(x, y, clf, opt, args):\\n opt.zero_grad()\\n criterion = nn.CrossEntropyLoss()\\n if args.cuda:\\n x = x.cuda()\\n y = y.cuda()\\n\\n res = clf(x)\\n ncorrect = 0\\n for i in range(y.size(0)):\\n _, ind = res[i].max(0)\\n\\n if torch.equal(y[i], ind):\\n ncorrect +=1\\n\\n loss = criterion(res, y)\\n loss.backward()\\n opt.step()\\n\\n return loss, ncorrect\",\n \"def euclidean(x, y):\\n return np.sqrt(np.sum((x - y) ** 2))\",\n \"def getCrossEntropy(visible, PDF):\\n\\n\\tndocs = visible.shape[0]\\n\\tCrossEnt = numpy.zeros((ndocs,))\\n\\tfor doc in xrange(ndocs):\\n\\t\\tCrossEnt[doc] = numpy.dot(visible[doc], numpy.log(PDF[doc]))\\n\\n\\treturn CrossEnt.mean()\",\n \"def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\\n log_pred = ivy.log(pred)\\n # noinspection PyUnresolvedReferences\\n return -ivy.reduce_sum(log_pred * true, axis)\",\n \"def cross(a,b):\\n \\n return [ a[1]*b[2] - a[2]*b[1],\\n a[2]*b[0] - a[0]*b[2],\\n a[0]*b[1] - a[1]*b[0],\\n 1.0 ]\",\n \"def cross(v1, v2):\\n return np.cross(v1, v2)\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def categorical_crossentropy(y_pred, y_true):\\n with tf.name_scope(\\\"Crossentropy\\\"):\\n y_pred /= tf.reduce_sum(y_pred,\\n reduction_indices=len(y_pred.get_shape())-1,\\n keep_dims=True)\\n # manual computation of crossentropy\\n y_pred = tf.clip_by_value(y_pred, tf.cast(_EPSILON, dtype=_FLOATX),\\n tf.cast(1.-_EPSILON, dtype=_FLOATX))\\n cross_entropy = - tf.reduce_sum(y_true * tf.log(y_pred),\\n reduction_indices=len(y_pred.get_shape())-1)\\n return tf.reduce_mean(cross_entropy)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7399793","0.7246357","0.71943384","0.70277774","0.6669306","0.6637702","0.6602384","0.65894943","0.65266645","0.6473503","0.6437216","0.642684","0.63894004","0.6365542","0.6353329","0.63220906","0.628778","0.6279644","0.62760943","0.6269529","0.62406224","0.62195385","0.61654633","0.6152873","0.6143035","0.61429644","0.6135727","0.6133718","0.60981774","0.60756135","0.6072393","0.60690266","0.60622185","0.6049972","0.60315335","0.60290545","0.6018554","0.60074216","0.5996101","0.59799945","0.5966888","0.59644103","0.59559864","0.5950494","0.59398454","0.5934339","0.59282357","0.5917388","0.59104455","0.58902115","0.58900064","0.5873779","0.5868822","0.5856024","0.5849674","0.58225507","0.5822494","0.5809818","0.58094764","0.5807639","0.5807032","0.58044803","0.580027","0.5770744","0.5748133","0.57479316","0.5746499","0.5740157","0.5736116","0.57275593","0.5718761","0.5712834","0.5708433","0.57054484","0.57036364","0.56999415","0.569966","0.5696662","0.56869596","0.567938","0.5666363","0.56654423","0.56379944","0.5637788","0.5631408","0.56308454","0.5612492","0.5610317","0.5607675","0.5601812","0.55823976","0.55810976","0.55792344","0.55780286","0.55705804","0.5565569","0.55633736","0.55602086","0.55582935","0.55575573"],"string":"[\n \"0.7399793\",\n \"0.7246357\",\n \"0.71943384\",\n \"0.70277774\",\n \"0.6669306\",\n \"0.6637702\",\n \"0.6602384\",\n \"0.65894943\",\n \"0.65266645\",\n \"0.6473503\",\n \"0.6437216\",\n \"0.642684\",\n \"0.63894004\",\n \"0.6365542\",\n \"0.6353329\",\n \"0.63220906\",\n \"0.628778\",\n \"0.6279644\",\n \"0.62760943\",\n \"0.6269529\",\n \"0.62406224\",\n \"0.62195385\",\n \"0.61654633\",\n \"0.6152873\",\n \"0.6143035\",\n \"0.61429644\",\n \"0.6135727\",\n \"0.6133718\",\n \"0.60981774\",\n \"0.60756135\",\n \"0.6072393\",\n \"0.60690266\",\n \"0.60622185\",\n \"0.6049972\",\n \"0.60315335\",\n \"0.60290545\",\n \"0.6018554\",\n \"0.60074216\",\n \"0.5996101\",\n \"0.59799945\",\n \"0.5966888\",\n \"0.59644103\",\n \"0.59559864\",\n \"0.5950494\",\n \"0.59398454\",\n \"0.5934339\",\n \"0.59282357\",\n \"0.5917388\",\n \"0.59104455\",\n \"0.58902115\",\n \"0.58900064\",\n \"0.5873779\",\n \"0.5868822\",\n \"0.5856024\",\n \"0.5849674\",\n \"0.58225507\",\n \"0.5822494\",\n \"0.5809818\",\n \"0.58094764\",\n \"0.5807639\",\n \"0.5807032\",\n \"0.58044803\",\n \"0.580027\",\n \"0.5770744\",\n \"0.5748133\",\n \"0.57479316\",\n \"0.5746499\",\n \"0.5740157\",\n \"0.5736116\",\n \"0.57275593\",\n \"0.5718761\",\n \"0.5712834\",\n \"0.5708433\",\n \"0.57054484\",\n \"0.57036364\",\n \"0.56999415\",\n \"0.569966\",\n \"0.5696662\",\n \"0.56869596\",\n \"0.567938\",\n \"0.5666363\",\n \"0.56654423\",\n \"0.56379944\",\n \"0.5637788\",\n \"0.5631408\",\n \"0.56308454\",\n \"0.5612492\",\n \"0.5610317\",\n \"0.5607675\",\n \"0.5601812\",\n \"0.55823976\",\n \"0.55810976\",\n \"0.55792344\",\n \"0.55780286\",\n \"0.55705804\",\n \"0.5565569\",\n \"0.55633736\",\n \"0.55602086\",\n \"0.55582935\",\n \"0.55575573\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7348612"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3392,"cells":{"query":{"kind":"string","value":"r\"\"\"Joint Entropy Calculates the joint entropy of two discrete distributions x and y. This is the combined Entropy of X added to the conditional Entropy of x given y."},"document":{"kind":"string","value":"def joint_entropy(x, y, bins):\n # assert array length\n assert len(x) == len(y)\n\n # get the bins, x and y get their own bins in case of joint entropy\n bins = get_2D_bins(x, y, bins)\n\n # get the joint histogram\n joint_hist = np.histogram2d(x, y, bins)[0]\n\n # calculate the joint probability and add a small number\n joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15\n\n # calculate and return the joint entropy\n return - np.sum(joint_p * np.log2(joint_p))"},"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 mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def joint_entropy(column_i, column_j):\n\tfreq_ij = dict()\n\ttotal = len(column_i)\n\tentropy = 0\n\tfor index in range(total):\n\t\ti = column_i[index]\n\t\tj = column_j[index]\n\t\tif i+j in freq_ij:\n\t\t\tfreq_ij[i+j] +=1\n\t\telse:\n\t\t\tfreq_ij[i+j] = 1\n\n\tfor key in freq_ij:\n\t\tfreq_ij[key] /= total\n\t\tentropy += freq_ij[key]*math.log(freq_ij[key], 2)\n\treturn -entropy","def joint_entropy(column_i, column_j):\n\tif len(column_i) != len(column_j):\n\t\traise IndexError(\"The two MSA should have the same number of related sequences (same species)\")\n\tfreq_ij = dict()\n\ttotal = len(column_i)\n\tentropy = 0\n\tfor index in range(total):\n\t\ti = column_i[index]\n\t\tj = column_j[index]\n\t\tif i+j in freq_ij:\n\t\t\tfreq_ij[i+j] +=1\n\t\telse:\n\t\t\tfreq_ij[i+j] = 1\n\n\tfor key in freq_ij:\n\t\tfreq_ij[key] /= total\n\t\tentropy += freq_ij[key]*math.log(freq_ij[key], 2)\n\tif entropy != 0.0:\n\t\treturn -entropy\n\telse:\n\t\treturn entropy","def joint_pdf(self, x1, x2 = None):\n return np.exp(self.joint_logpdf(x1, x2))","def transfer_entropy(X, Y):\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\n\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\n for y_f, x_p, y_p in coords.keys():\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\n\n p_yp = p_dist.sum(axis=2).sum(axis=1)\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\n\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\n denominator[denominator == 0] = np.nan\n\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\n division[division == 0] = np.nan\n\n log = np.log2(division)\n\n return np.nansum(np.multiply(p_dist, log))","def J(W1, b1, W2, b2, x, y):\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\n return crossEntropy(y, yhat)","def cross_entropy(x, y, bins, xy_probabilities=False):\n # calculate probabilities if probabilities == False\n if xy_probabilities:\n # same bins for x and y -> same length of x and y if xy_probabilities == True\n assert len(x) == len(y)\n\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y),1,atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n\n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n return - px.dot(np.log2(py))","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def entropy(y,w):\r\n\r\n\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\r\n\r\n # y_partition = partition(y)\r\n # elements,counts = np.unique(y,return_counts = True)\r\n # entropy=0\r\n\r\n # for i in range(len(elements)):\r\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\r\n # return entropy\r\n\r\n entropy = 0\r\n # two hypothesis cases 0,1\r\n h = {0: 0, 1: 0}\r\n leny = len(y)\r\n for i in range(leny):\r\n # if y is 0 add 0 to the weight\r\n if y[i] == 0:\r\n h[0] += w[i]\r\n # if y is 1 add 1 to the weight\r\n elif y[i] == 1:\r\n h[1] += + w[i]\r\n # summing all the weighted values \r\n val_sum = h[0] + h[1]\r\n\r\n # entropy calculation\r\n for j in range(len(h)):\r\n h[j] = h[j]/val_sum\r\n # to prevent divide by zero\r\n if h[j] != 0:\r\n entropy += h[j] * np.log2(h[j])\r\n entropy = -(entropy)\r\n return entropy","def dist_calc(self, x, y):\n p_xy = self.d2_bin(x, y)\n p_x = np.sum(p_xy, axis=1)\n p_y = np.sum(p_xy, axis=0)\n\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\n\n output = max(0.0, (1 - (info / entropy)))\n return output","def joint_logpdf(self, x1, x2 = None):\n dists = self.conditionalMVNs\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\n return np.log(np.sum(self.weights * joint_pdfs))","def joint_feature(self, x, y):\n self._check_size_x(x)\n features, edges = self._get_features(x), self._get_edges(x)\n n_nodes = features.shape[0]\n\n if isinstance(y, tuple):\n # y is result of relaxation, tuple of unary and pairwise marginals\n unary_marginals, pw = y\n unary_marginals = unary_marginals.reshape(n_nodes, self.n_states)\n # accumulate pairwise\n pw = pw.reshape(-1, self.n_states, self.n_states).sum(axis=0)\n else:\n y = y.reshape(n_nodes)\n gx = np.ogrid[:n_nodes]\n\n #make one hot encoding\n unary_marginals = np.zeros((n_nodes, self.n_states), dtype=np.int)\n gx = np.ogrid[:n_nodes]\n unary_marginals[gx, y] = 1\n\n ##accumulated pairwise\n pw = np.dot(unary_marginals[edges[:, 0]].T,\n unary_marginals[edges[:, 1]])\n unaries_acc = np.dot(unary_marginals.T, features)\n if self.directed:\n pw = pw.ravel()\n else:\n pw = compress_sym(pw)\n joint_feature_vector = np.hstack([unaries_acc.ravel(), pw])\n return joint_feature_vector","def joint_entropy(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))","def calculateLogJointProbabilities(self, datum):\n\tlogJoint = util.Counter()\n\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\n\t#where y is a label\n\tfor label in self.legalLabels:\n\t\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\n\t\tfor feature, value in datum.items():\n\t\t\tcp = self.conditional_prob[label][feature][value]\n\t\t\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\n\t\t\t\tlogJoint[label] += math.log(cp) #summing up\n\t\t\t\t\n\treturn logJoint","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def mutual_info(l1, l2):\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n \"*** YOUR CODE HERE ***\"\n\t#Adds log(P(y)) to calculate P(y|f1,f2...)\n for label in self.legalLabels:\n\t\tlogJoint[label] += math.log(self.prior[label])\n\t#Adds log(P(f1|y)), log(P(f2|y))... to calculate P(y|f1, f2...)\n for key in datum:\n\t\t#if key == (7, 3):\n\t\t\t#print self.condprobs[key, 0]\n\t\tfor label in self.legalLabels:\n\t\t\t#print str(key) + str(datum[key])\n\t\t\tlogJoint[label] += math.log(self.condprobs[key, label][datum[key]])\n return logJoint","def cond_entropy(joint_prob, cond_prob):\n # Computing log2(P cond)\n log2_p = (np.ma.log2(cond_prob)).filled(0)\n # Multipling element wise the arrays\n prod_entropy = np.multiply(joint_prob, log2_p)\n # Getting the - sum of the resulting array.\n H = -( np.sum(prod_entropy))\n return H","def joint_dataset(l1, l2):\n N = np.max(l1) + 1\n return l2 * N + l1","def _calculate_probs_and_entropy_y(self):\n #calculate y probabilities and H(Y)\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\n self.lab_entropy = 0\n s = sum(self.lab_counts.values())\n for label, count in self.lab_counts.items():\n self.lab_probs[label] = count / s\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def log_prob(self, x, y):\n p = self.tag_log_prob(y)\n for i in range(len(y)):\n if self.out_prob(x[i], y[i]) == 0:\n return -math.inf\n\n p += math.log2(self.out_prob(x[i], y[i]))\n\n return p","def logq_joint(self, x, h, return_mu=False):\n logph = distributions.Normal(0, 1).log_prob(h).sum(1)\n gmu = self.g(h)\n px_given_h = distributions.Normal(gmu, self.logsigma.exp())\n logpx_given_h = px_given_h.log_prob(x).flatten(start_dim=1).sum(1)\n if return_mu:\n return logpx_given_h + logph, gmu\n else:\n return logpx_given_h + logph","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def _cal_igr(x, y):\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def prob(self, x, y):\n p = self.tag_prob(y)\n for i in range(len(y)):\n p *= self.out_prob(x[i], y[i])\n\n return p","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))","def conditional_entropy(f1, f2):\n\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\n return ce","def calculate_entropy(y):\n\tlog2 = lambda x: math.log(x) / math.log(2)\n\tunique_labels = np.unique(y)\n\tentropy = 0\n\tfor label in unique_labels:\n\t\tcount = len(y[y == label])\n\t\tp = count / len(y)\n\t\tentropy += -p * log2(p)\n\treturn entropy","def print_entropies(independent_joint_probabilities, conditional_joint_probabilities):\n indepndent_entropy = entropy_from_probability_matrix(independent_joint_probabilities)\n conditional_entropy = entropy_from_probability_matrix(conditional_joint_probabilities)\n\n print 'Independent H(X,Y) = {h}'.format(h=indepndent_entropy)\n print 'Conditional H(X,Y) = {h}'.format(h=conditional_entropy)\n print 'D_KL(Independent, Conditional) = {d_kl}' \\\n .format(d_kl=kullback_leibler_divergence(independent_joint_probabilities, conditional_joint_probabilities))\n print 'D_KL(Conditional, Independent) = {d_kl}' \\\n .format(d_kl=kullback_leibler_divergence(conditional_joint_probabilities, independent_joint_probabilities))\n\n return indepndent_entropy, conditional_entropy","def _entropy_filter(self, prob1, prob2):\n\n\n # calculate merged prob.\n prob_merged = (prob1 + prob2)/2\n # Compute entropy for each prob.\n H1 = -prob1 * math.log(prob1) - (1-prob1) * math.log(1-prob1)\n H2 = -prob2 * math.log(prob2) - (1-prob2) * math.log(1-prob2)\n Hm = -prob_merged * math.log(prob_merged) - (1-prob_merged) * math.log(1-prob_merged)\n\n H_min = min(H1, H2, Hm)\n\n if H_min == H1:\n return prob1\n elif H_min == H2:\n return prob2\n else:\n return prob_merged","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def empirical_bottleneck(x,y,numuniquex=0,numuniquey=0,**kw):\n \n # Marginal, joint and conditional distributions required to calculate the IB\n pxy_j = p_joint(x,y)\n px = pxy_j.sum(axis=1)\n py = pxy_j.sum(axis=0)\n pyx_c = pxy_j.T / px\n #Calculate the information bottleneck for different values of beta\n i_p,i_f,beta = IB(px,py,pyx_c,**kw)\n # Return array of ipasts and ifutures for array of different values of beta - mi should correspond to the saturation point\n mi = mi_x1x2_c(py, px, pyx_c)\n return i_p,i_f,beta,mi,entropy(px,base=2),entropy(py,base=2)","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n \n \"*** YOUR CODE HERE ***\"\n \n # -- OUR CODE HERE\n \n \n import math\n for label in self.legalLabels:\n sumThing = 0.0\n for pixel in self.conditionalProb[label]:\n if datum[pixel] is 1:\n #assert self.conditionalProb[label][pixel] < 1.0 # -- sanity check that the probability is valid\n sumThing += math.log((self.conditionalProb[label][pixel]*1.0))\n else:\n sumThing+=math.log(1-self.conditionalProb[label][pixel]*1.0)\n logJoint[label] = math.log(self.prior[label]*1.0) + sumThing*1.0\n \n\n \n \n import time\n #print \"logJoint is :: \", logJoint\n #time.sleep(2)\n \n \n # -- uses the conditional probability tables computed in the current iteration\n # -- in train and tune\n \n return logJoint","def symbolic_transfer_entropy(symX, symY):\n\n if len(symX) != len(symY):\n raise ValueError('All arrays must have same length')\n \n symX = np.array(symX)\n symY = np.array(symY)\n \n cp = symbolic_conditional_probabilities_consecutive(symX)\n cp2 = symbolic_conditional_probabilities_consecutive_external(symX, symY)\n jp = symbolic_joint_probabilities_consecutive_external(symX, symY)\n \n TE = 0\n \n for yi, xi, xii in list(jp.keys()):\n try:\n a = cp[xi,xii]\n b = cp2[yi,xi,xii]\n c = jp[yi,xi,xii]\n TE += c * np.log(b / a) / np.log(2.)\n except KeyError:\n continue\n except:\n print(\"Unexpected Error\")\n raise\n del cp\n del cp2\n del jp\n \n return TE","def get_information_y_hat(x_pub, x_priv, x_joint, y_hat, num_of_bins_y):\n\tprint('Start calculating the information for y_hat...')\n\ty_hat = np.array(y_hat).astype(np.float)\n\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\n\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(y_hat, x_pub)\n\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\n\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(y_hat, x_joint)\n\t# Shannon Entropy over label\n\tH2Y_hat = -np.sum(pys_hat * np.log2(pys_hat))\n\t# mutual Information between secret layer and label\n\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\n\t# mutual Information between secret layer and label\n\tMI_pub_y_hat = calc_information_for_inp_out(pxs_pub,pys_hat,y_hat,unique_inverse_x_pub)\n\treturn H2Y_hat, MI_pri_y_hat, MI_pub_y_hat","def __call__(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\n return torch.log(1 + torch.exp(-y1 * y2))","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def js_divergence(dist1, dist2):\n mean_dist = (dist1 + dist2) / 2.0\n js = (\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\n ) / 2.0\n return js","def entropy(a, b):\n with mp.extradps(5):\n a, b = _validate_a_b(a, b)\n return (_fun.logbeta(a, b)\n - (a - 1)*mp.psi(0, a)\n - (b - 1)*mp.psi(0, b)\n + (a + b - 2)*mp.psi(0, a + b))","def associate_comp(x, y):\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])","def mutual_information(x, y, w):\r\n \r\n\r\n total_entropy = entropy(y,w)\r\n\r\n partitioned_x = partition(x)\r\n weighted_entropy = 0\r\n # calculate the weighted entropy over the partition of x\r\n vals,counts= np.unique(x,return_counts=True)\r\n for key in partitioned_x:\r\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\r\n\r\n information_gain = total_entropy - weighted_entropy\r\n return information_gain","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def logistic_loss(x, y):\n x = x.reshape((-1,))\n y = y.reshape((-1,))\n \n N, = x.shape\n \n y_p = np.where(y == 1,1,0)\n\n p = sigmoid(x)\n loss = -(y_p*np.log(p) + (1-y_p)*np.log(1-p))\n loss = np.sum(loss)/N\n\n dx = (1/N)*(p - y_p)\n \n return loss, dx","def calculateLogJointProbabilities(self, datum):\n logJoint = util.Counter()\n for cls in self.classes:\n class_probability = self.prior_prob[cls]\n for key, value in datum.items():\n relative_feature_values = self.likelihoods[cls][key]\n class_probability += math.log(relative_feature_values.get(datum[key], 0.01))\n\n logJoint[cls] = class_probability\n\n return logJoint","def symbolic_joint_probabilities(symX, symY):\n\n if len(symX) != len(symY):\n raise ValueError('All arrays must have same length')\n \n symX = np.array(symX)\n symY = np.array(symY)\n \n # initialize\n jp = defaultdict(float)\n n = len(symX)\n\n for yi, xi in zip(symY,symX):\n jp[yi, xi] += 1.0 / n\n\n return dict(jp)","def _compute_prob_y_given_x(self, _x, _y):\n normalisation_constant = sum([\n math.exp(sum([self.weights[_feature] *\n self.feature_funcs[_feature, cls](_feature, cls)\n for _feature in _x]))\n for cls in self.classes])\n\n return math.exp(sum([\n self.weights[_feature] *\n self.feature_funcs[_feature, _y](_feature, _y)\n for _feature in _x])) / normalisation_constant","def Pdist2(x, y):\r\n x_norm = (x ** 2).sum(1).view(-1, 1)\r\n if y is not None:\r\n y_norm = (y ** 2).sum(1).view(1, -1)\r\n else:\r\n y = x\r\n y_norm = x_norm.view(1, -1)\r\n Pdist = x_norm + y_norm - 2.0 * torch.mm(x, torch.transpose(y, 0, 1))\r\n Pdist[Pdist<0]=0\r\n return Pdist","def prob1():\n x, y = sy.symbols('x, y')\n return sy.Rational(2,5) * sy.exp(x**2 - y) * sy.cosh(x + y) + \\\n sy.Rational(3,7) * sy.log(x*y + 1)","def conditional_entropy(x, y, bins, normalize=False):\n \n # get the bins\n bins = get_2D_bins(x, y, bins)\n \n # calculate H(x,y) and H(y)\n hjoint = joint_entropy(x,y,bins)\n hy = entropy(y, bins[1])\n\n if normalize:\n normalizer = entropy(x, bins[0])\n conditional_entropy = hjoint - hy\n\n # check if conditional entropy and normalizer are very small\n if conditional_entropy < 1e-4 and normalizer < 1e-4:\n # return zero to prevent very high values of normalized conditional entropy\n # e.g. conditional entropy = -1.3e-12, normalizer = -1.6e-12 \n # -> normalized conditional entropy = 812.5\n return 0\n else:\n return conditional_entropy / normalizer\n else:\n return hjoint - hy","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def chl_entropy(y, base=2):\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\n p = p[p!=0]/float(len(y))\n S = -1.0*sum(p*log(p))/log(base)\n return S","def dist(x, y):\n dx = x[0] - y[0]\n dy = x[1] - y[1]\n ans = dx**2 + dy**2\n ans = ans**(0.5)\n return ans","def prob_2_entropy(prob):\r\n n, c, h, w = prob.size()\r\n return -torch.mul(prob, torch.log2(prob + 1e-30)) / np.log2(c)","def dist(x, y):\n dx = x[0] - y[0]\n dy = x[1] - y[1]\n ans = dx**2 + dy**2\n ans = ans**(0.5)\n return ans","def compute_dists(x, y):\r\n \r\n return (x - y.permute(0, 2, 1)) ** 2","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def weight(self, y, xn, xo):\n\n return self._model.log_prob(y, xn) + self._model.h_weight(xn, xo) - self._kernel.log_prob(xn)","def logits_and(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n t = (x + y) / 2\n f = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -t)\n return t - f","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def entropy_obj(self, x, h, num_samples_posterior=20, return_score=False, learn_post_sigma=True):\n inf_dist = distributions.Normal(h, self.post_logsigma.detach().exp())\n h_given_x = inf_dist.sample((num_samples_posterior,))\n if len(x.size()) == 4:\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\n xr = x[None].repeat(num_samples_posterior, 1, 1, 1, 1)\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1), x.size(2), x.size(3))\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1), x.size(2), x.size(3))\n logq = logq.view(num_samples_posterior, x.size(0))\n w = (logq - inf_logprob).softmax(dim=0)\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\n weighted_fvals = (fvals * w[:, :, None, None, None]).sum(0).detach()\n c = weighted_fvals\n else:\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\n xr = x[None].repeat(num_samples_posterior, 1, 1)\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1))\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1))\n logq = logq.view(num_samples_posterior, x.size(0))\n w = (logq - inf_logprob).softmax(dim=0)\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\n weighted_fvals = (fvals * w[:, :, None]).sum(0).detach()\n c = weighted_fvals\n\n mgn = c.norm(2, 1).mean()\n g_error_entropy = torch.mul(c, x).mean(0).sum()\n\n post = distributions.Normal(h.detach(), self.post_logsigma.exp())\n h_g_post = post.rsample()\n joint = self.logq_joint(x.detach(), h_g_post)\n post_ent = post.entropy().sum(1)\n\n elbo = joint + post_ent\n post_loss = -elbo.mean()\n\n if learn_post_sigma:\n self.post_optimizer.zero_grad()\n post_loss.backward()\n self.post_optimizer.step()\n\n if return_score:\n return g_error_entropy, mgn, c\n else:\n return g_error_entropy, mgn","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def hyperboloidDist(point1, point2):\n return np.arccosh(-minkowskiDot(point1, point2))","def log_joint(self):\n return sum([\n self.log_marg_like(self.gamma, self.gamma0, self.lamb, self.nu),\n self._gamma0_distribution.logpdf(self.gamma0),\n self._nu_distribution.logpdf(self.nu),\n self._lambda_distribution.logpdf(self.lamb),\n self.probit_distribution(self.xi).logpdf(self.gamma),\n self._xi_distribution.logpdf(self.xi) if self.sample_xi else 0.0\n ])","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def _calculate_probs_and_entropy_x(self, columns):\n #calculate x probabilities and H(Xi)\n #H(Xi) = Sum(x € Xi)(-P(Xi=x) * log(P(Xi=x)))\n for col in columns:\n self.cat_entropies[col] = 0\n xsum = 0\n for val in self.categories[col]:\n self.cat_probs[col][val] = 0\n for label in self.labels:\n self.cat_probs[col][val] += self.cat_counts[col][label][val]\n xsum += self.cat_probs[col][val]\n for val in self.categories[col]:\n self.cat_probs[col][val] /= xsum\n self.cat_entropies[col] -= self.cat_probs[col][val] * self.log(self.cat_probs[col][val])","def entropy(self, X):\n if isinstance(X, np.ndarray):\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\n K = self._posterior_covariance(X)\n L = np.linalg.cholesky(K)\n D = len(X)\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))","def joint_proba(self, X):\n return self.weights * self._bernoulli(X)","def test_get_xentropy_components_one_time_neigh(self):\n\n this_numerator, this_denominator = (\n learning_curves._get_xentropy_components_one_time(\n actual_target_matrix=ACTUAL_TARGET_MATRIX,\n probability_matrix=PROBABILITY_MATRIX,\n eval_mask_matrix=MASK_MATRIX,\n matching_distance_px=NEIGH_DISTANCE_PX\n )\n )\n\n self.assertTrue(numpy.isclose(\n this_numerator, NEIGH_XENTROPY_NUMERATOR, atol=TOLERANCE\n ))\n self.assertTrue(numpy.isclose(\n this_denominator, NEIGH_XENTROPY_DENOM, atol=TOLERANCE\n ))","def max_entangled(h1, h2):\n\n for h in (h1, h2):\n h.assert_ket_space()\n\n field = h1.base_field\n\n d = h1.dim()\n if h2.dim() != d:\n raise HilbertError('spaces must be of the same dimension')\n\n return (h1.H * h2).eye().transpose(h1) / field.sqrt(d)","def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n f = -(x + y) / 2\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\n return t - f","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def prob_larger_continuous(distr1, distr2):\n\n return distr1.expect(distr2.cdf)","def _jsd(prob_dist_p, prob_dist_q):\n prob_dist_p = check_numpy_param('prob_dist_p', prob_dist_p)\n prob_dist_q = check_numpy_param('prob_dist_q', prob_dist_q)\n norm_dist_p = prob_dist_p / (np.linalg.norm(prob_dist_p, ord=1) + 1e-12)\n norm_dist_q = prob_dist_q / (np.linalg.norm(prob_dist_q, ord=1) + 1e-12)\n norm_mean = 0.5*(norm_dist_p + norm_dist_q)\n return 0.5*(stats.entropy(norm_dist_p, norm_mean)\n + stats.entropy(norm_dist_q, norm_mean))","def enumerate_joint_ask(X, e, P):\n Q = ProbDist(X) ## A probability distribution for X, initially empty\n Y = [v for v in P.variables if v != X and v not in e]\n for xi in P.values(X):\n Q[xi] = enumerate_joint(Y, extend(e, X, xi), P)\n return Q.normalize()","def _calculate_probs_and_entropies(self):\n self._calculate_probs_and_entropy_y()\n self._calculate_probs_and_entropy_x(self.cat_cols)","def Dist(p1,p2):\n x1, y1 = p1\n x2, y2 = p2\n return (((x1-x2)*(x1-x2)) + ((y1-y2)*(y1-y2)))**0.5","def forward(self, x, y):\n distance = (x - y).norm(2, dim=-1, keepdim=True)\n z = (distance - self.mu) / self.sigma\n prob = torch.exp(-0.5 * z * z)\n return prob","def get_probability(self, x, y, base_x, base_y):\n delta_x = x - base_x \n delta_y = y - base_y\n prob_x = self.nx_predictor.get_probability(delta_x)\n prob_y = self.ny_predictor.get_probability(delta_y)\n prob_xy = self.prob_alpha_x*prob_x*self.prob_alpha_y*prob_y\n return prob_x, prob_y, prob_xy","def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\n def entropy(freqDict):\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\n freqx = objhist(x)\n freqy = objhist(y)\n \n Hx = freqx.entropy()\n Hy = freqy.entropy()\n Hxy = objhist(zip(x,y)).entropy()\n M = Hx + Hy - Hxy\n Mstar = 2*M / (Hx+Hy)\n\n if len(freqx)==1 or len(freqy)==1:\n p = 1\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\n p = 0\n else:\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\n p = (Mperms >= M).sum() / nperms\n\n return M, Mstar, p, Hx, Hy, Hxy","def joint_likelihood_combine(x2LL, alpha1 = 0.32, alpha2 = 0.05, return_full=False):\n\n # Combine log-likelihood ratios by summing them\n x2LL_sum = np.sum([x2LL[item]['llr'] for item in x2LL], axis=0)\n\n # x-axis values (must be the same for all datasets, take the first one)\n r0_value = [x2LL[item]['val'] for item in x2LL][0]\n \n # Find minimum \n x2LL_min = np.min(x2LL_sum)\n minind = np.argmin(x2LL_sum)\n IFR = r0_value[minind]\n\n # Find first interval\n chi2 = stats.chi2.ppf(q=1-alpha1, df=1)\n ind = (np.where(x2LL_sum - x2LL_min <= chi2))[0] # Note <= not <\n CI68 = np.array([r0_value[ind[0]], r0_value[ind[-1]]])\n \n # Find second interval\n chi2 = stats.chi2.ppf(q=1-alpha2, df=1)\n ind = (np.where(x2LL_sum - x2LL_min <= chi2))[0] # Note <= not <\n CI95 = np.array([r0_value[ind[0]], r0_value[ind[-1]]])\n\n CI_val = np.array([CI95[0], CI68[0], CI68[1], CI95[1]])\n\n if not return_full:\n return IFR, CI_val\n else:\n return IFR, CI_val, x2LL_sum, r0_value","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def dist(self, X, Y):\n raise NotImplementedError","def add_joint(joint: str, x1: int, y1: int, x2: int, y2: int) -> str:\n return joint","def product(self, other: \"DiscreteFactorTable\"):\n\n #Conjunction with null distribution is null table\n if (len(self.support) == 0) or (len(other.support) == 0):\n return DiscreteFactorTable([])\n\n # NOTE: can this be relaxed?\n assert type(self.support[0]) == type(other.support[0])\n\n jsupport = []\n jlogits = []\n # HACK: this should throw a warning or something if the distributions have different headers\n # i.e., dictionary keys interact in a weird way\n for si, oi in product(self.support, other.support):\n if isinstance(si, (dict, frozendict)) and isinstance(oi, (dict, frozendict)):\n if dict_match(si, oi): #not efficient if the cartesian product is large\n soi = dict_merge(si, oi)\n if soi in jsupport:\n continue\n logit = self.logit(si) + other.logit(oi)\n if logit == -np.inf:\n continue\n jsupport.append(soi)\n jlogits.append(logit)\n else:\n jsupport.append((si, oi))\n jlogits.append(self.logit(si) + other.logit(oi))\n if len(jlogits) > 0:\n logger.debug(\"Product distribution has no non-zero support\")\n return DiscreteFactorTable(support=jsupport, logits=jlogits)","def dtw(x, y, dist):\n assert len(x)\n assert len(y)\n r, c = len(x), len(y)\n D0 = zeros((r + 1, c + 1))\n D0[0, 1:] = inf\n D0[1:, 0] = inf\n D1 = D0[1:, 1:] # view\n for i in range(r):\n for j in range(c):\n D1[i, j] = dist(x[i], y[j])\n C = D1.copy()\n for i in range(r):\n for j in range(c):\n D1[i, j] += min(D0[i, j], D0[i, j+1], D0[i+1, j])\n if len(x)==1:\n path = zeros(len(y)), range(len(y))\n elif len(y) == 1:\n path = range(len(x)), zeros(len(x))\n else:\n path = _traceback(D0)\n return D1[-1, -1] / sum(D1.shape), C, D1, path","def join_cinfo(cooccur, percents):\n import math\n\n word1 = cooccur[0][0]\n word2 = cooccur[0][1]\n try:\n word1_percent = percents[word1]\n weight1 = 1 / word1_percent\n word2_percent = percents[word2]\n weight2 = 1 / word2_percent\n return (cooccur[0], cooccur[1], cooccur[1] *\n math.log(min(weight1, weight2)))\n except:\n return 0","def _entropy2(labels, base=None):\n\n n_labels = len(labels)\n\n if n_labels <= 1:\n return 0\n\n value,counts = np.unique(labels, return_counts=True)\n probs = counts / n_labels\n n_classes = np.count_nonzero(probs)\n\n if n_classes <= 1:\n return 0\n\n ent = 0.\n\n # Compute entropy\n base = e if base is None else base\n for i in probs:\n ent -= i * log(i, base)\n\n # quick observation shows ent between 0.0 and 4.0.\n return ent","def probabilities(self, x, y):\n return self.feed_and_return(x, y, self.network.a)","def entropy(self):\r\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)","def theils_u(x,\n y,\n nan_strategy=_REPLACE,\n nan_replace_value=_DEFAULT_REPLACE_VALUE):\n\n print(x.name + ' to ' + y.name + ' with Theils U')\n\n if nan_strategy == _REPLACE:\n x, y = replace_nan_with_value(x, y, nan_replace_value)\n elif nan_strategy == _DROP:\n x, y = remove_incomplete_samples(x, y)\n\n contingency = pd.crosstab(x, y)\n c, p, dof, expected = ss.chi2_contingency(contingency)\n\n s_xy = conditional_entropy(x, y)\n x_counter = Counter(x)\n total_occurrences = sum(x_counter.values())\n p_x = list(map(lambda n: n / total_occurrences, x_counter.values()))\n s_x = ss.entropy(p_x)\n if s_x == 0:\n return 1, 0\n else:\n return (s_x - s_xy) / s_x, p, r'$U$'","def entropyCategorical(attr, X, y):\n uniques = X[attr].unique().tolist()\n idxLists = []\n entropies = []\n weights = []\n for u in uniques:\n idxLists.append(X.index[X[attr] == u].tolist())\n entropies.append(entropy(y, idxLists[-1]))\n weights.append(len(idxLists[-1]))\n\n entropies = np.array(entropies).reshape(1, -1)\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\n weights /= np.sum(weights)\n\n return (uniques, idxLists, (entropies @ weights)[0, 0])","def d2_bin(self, x, y):\n \n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\n KD.fit(np.column_stack((x,y)))\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\n mesh = np.meshgrid(grid1,grid2)\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\n samp = KD.score_samples(data)\n samp = samp.reshape(self.bins,self.bins)\n p = np.exp(samp)/np.sum(np.exp(samp))\n\n return p"],"string":"[\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def joint_entropy(column_i, column_j):\\n\\tfreq_ij = dict()\\n\\ttotal = len(column_i)\\n\\tentropy = 0\\n\\tfor index in range(total):\\n\\t\\ti = column_i[index]\\n\\t\\tj = column_j[index]\\n\\t\\tif i+j in freq_ij:\\n\\t\\t\\tfreq_ij[i+j] +=1\\n\\t\\telse:\\n\\t\\t\\tfreq_ij[i+j] = 1\\n\\n\\tfor key in freq_ij:\\n\\t\\tfreq_ij[key] /= total\\n\\t\\tentropy += freq_ij[key]*math.log(freq_ij[key], 2)\\n\\treturn -entropy\",\n \"def joint_entropy(column_i, column_j):\\n\\tif len(column_i) != len(column_j):\\n\\t\\traise IndexError(\\\"The two MSA should have the same number of related sequences (same species)\\\")\\n\\tfreq_ij = dict()\\n\\ttotal = len(column_i)\\n\\tentropy = 0\\n\\tfor index in range(total):\\n\\t\\ti = column_i[index]\\n\\t\\tj = column_j[index]\\n\\t\\tif i+j in freq_ij:\\n\\t\\t\\tfreq_ij[i+j] +=1\\n\\t\\telse:\\n\\t\\t\\tfreq_ij[i+j] = 1\\n\\n\\tfor key in freq_ij:\\n\\t\\tfreq_ij[key] /= total\\n\\t\\tentropy += freq_ij[key]*math.log(freq_ij[key], 2)\\n\\tif entropy != 0.0:\\n\\t\\treturn -entropy\\n\\telse:\\n\\t\\treturn entropy\",\n \"def joint_pdf(self, x1, x2 = None):\\n return np.exp(self.joint_logpdf(x1, x2))\",\n \"def transfer_entropy(X, Y):\\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\\n\\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\\n for y_f, x_p, y_p in coords.keys():\\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\\n\\n p_yp = p_dist.sum(axis=2).sum(axis=1)\\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\\n\\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\\n denominator[denominator == 0] = np.nan\\n\\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\\n division[division == 0] = np.nan\\n\\n log = np.log2(division)\\n\\n return np.nansum(np.multiply(p_dist, log))\",\n \"def J(W1, b1, W2, b2, x, y):\\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\\n return crossEntropy(y, yhat)\",\n \"def cross_entropy(x, y, bins, xy_probabilities=False):\\n # calculate probabilities if probabilities == False\\n if xy_probabilities:\\n # same bins for x and y -> same length of x and y if xy_probabilities == True\\n assert len(x) == len(y)\\n\\n # if x does not sum up to 1, raise an error\\n if not np.isclose(sum(x),1,atol=0.0001):\\n raise ValueError('Probabilities in vector x do not sum up to 1.')\\n # if y does not sum up to 1, raise an error\\n if not np.isclose(sum(y),1,atol=0.0001):\\n raise ValueError('Probabilities in vector y do not sum up to 1.')\\n\\n # add a small number to all probabilities if zero occurs\\n if x.any(0):\\n px = x + 1e-15\\n py = y + 1e-15\\n else:\\n px = x\\n py = y\\n else:\\n # get the bins, joint bins for x and y (same_bins=True)\\n bins = get_2D_bins(x, y, bins, same_bins=True)\\n\\n # calculate unconditioned histograms\\n hist_x = np.histogram(x, bins=bins[0])[0]\\n hist_y = np.histogram(y, bins=bins[1])[0]\\n\\n px = (hist_x / np.sum(hist_x)) + 1e-15\\n py = (hist_y / np.sum(hist_y)) + 1e-15\\n\\n return - px.dot(np.log2(py))\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(y,w):\\r\\n\\r\\n\\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\\r\\n\\r\\n # y_partition = partition(y)\\r\\n # elements,counts = np.unique(y,return_counts = True)\\r\\n # entropy=0\\r\\n\\r\\n # for i in range(len(elements)):\\r\\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\\r\\n # return entropy\\r\\n\\r\\n entropy = 0\\r\\n # two hypothesis cases 0,1\\r\\n h = {0: 0, 1: 0}\\r\\n leny = len(y)\\r\\n for i in range(leny):\\r\\n # if y is 0 add 0 to the weight\\r\\n if y[i] == 0:\\r\\n h[0] += w[i]\\r\\n # if y is 1 add 1 to the weight\\r\\n elif y[i] == 1:\\r\\n h[1] += + w[i]\\r\\n # summing all the weighted values \\r\\n val_sum = h[0] + h[1]\\r\\n\\r\\n # entropy calculation\\r\\n for j in range(len(h)):\\r\\n h[j] = h[j]/val_sum\\r\\n # to prevent divide by zero\\r\\n if h[j] != 0:\\r\\n entropy += h[j] * np.log2(h[j])\\r\\n entropy = -(entropy)\\r\\n return entropy\",\n \"def dist_calc(self, x, y):\\n p_xy = self.d2_bin(x, y)\\n p_x = np.sum(p_xy, axis=1)\\n p_y = np.sum(p_xy, axis=0)\\n\\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\\n\\n output = max(0.0, (1 - (info / entropy)))\\n return output\",\n \"def joint_logpdf(self, x1, x2 = None):\\n dists = self.conditionalMVNs\\n joint_pdfs = np.array([d.joint_pdf(x1, x2) for d in dists])\\n return np.log(np.sum(self.weights * joint_pdfs))\",\n \"def joint_feature(self, x, y):\\n self._check_size_x(x)\\n features, edges = self._get_features(x), self._get_edges(x)\\n n_nodes = features.shape[0]\\n\\n if isinstance(y, tuple):\\n # y is result of relaxation, tuple of unary and pairwise marginals\\n unary_marginals, pw = y\\n unary_marginals = unary_marginals.reshape(n_nodes, self.n_states)\\n # accumulate pairwise\\n pw = pw.reshape(-1, self.n_states, self.n_states).sum(axis=0)\\n else:\\n y = y.reshape(n_nodes)\\n gx = np.ogrid[:n_nodes]\\n\\n #make one hot encoding\\n unary_marginals = np.zeros((n_nodes, self.n_states), dtype=np.int)\\n gx = np.ogrid[:n_nodes]\\n unary_marginals[gx, y] = 1\\n\\n ##accumulated pairwise\\n pw = np.dot(unary_marginals[edges[:, 0]].T,\\n unary_marginals[edges[:, 1]])\\n unaries_acc = np.dot(unary_marginals.T, features)\\n if self.directed:\\n pw = pw.ravel()\\n else:\\n pw = compress_sym(pw)\\n joint_feature_vector = np.hstack([unaries_acc.ravel(), pw])\\n return joint_feature_vector\",\n \"def joint_entropy(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))\",\n \"def calculateLogJointProbabilities(self, datum):\\n\\tlogJoint = util.Counter()\\n\\t#want to calculate log(P(y)) + log(sum(P(fi|y)))\\n\\t#where y is a label\\n\\tfor label in self.legalLabels:\\n\\t\\tlogJoint[label] = math.log(self.prior_distribution_prob[label])\\n\\t\\tfor feature, value in datum.items():\\n\\t\\t\\tcp = self.conditional_prob[label][feature][value]\\n\\t\\t\\tif cp > 0: #condition check for values < 0 because log(0) is undefined and math domain error occurs\\n\\t\\t\\t\\tlogJoint[label] += math.log(cp) #summing up\\n\\t\\t\\t\\t\\n\\treturn logJoint\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def mutual_info(l1, l2):\\n return entropy(l1) + entropy(l2) - entropy(joint_dataset(l1, l2))\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\t#Adds log(P(y)) to calculate P(y|f1,f2...)\\n for label in self.legalLabels:\\n\\t\\tlogJoint[label] += math.log(self.prior[label])\\n\\t#Adds log(P(f1|y)), log(P(f2|y))... to calculate P(y|f1, f2...)\\n for key in datum:\\n\\t\\t#if key == (7, 3):\\n\\t\\t\\t#print self.condprobs[key, 0]\\n\\t\\tfor label in self.legalLabels:\\n\\t\\t\\t#print str(key) + str(datum[key])\\n\\t\\t\\tlogJoint[label] += math.log(self.condprobs[key, label][datum[key]])\\n return logJoint\",\n \"def cond_entropy(joint_prob, cond_prob):\\n # Computing log2(P cond)\\n log2_p = (np.ma.log2(cond_prob)).filled(0)\\n # Multipling element wise the arrays\\n prod_entropy = np.multiply(joint_prob, log2_p)\\n # Getting the - sum of the resulting array.\\n H = -( np.sum(prod_entropy))\\n return H\",\n \"def joint_dataset(l1, l2):\\n N = np.max(l1) + 1\\n return l2 * N + l1\",\n \"def _calculate_probs_and_entropy_y(self):\\n #calculate y probabilities and H(Y)\\n #H(Y) = Sum(y € Y)(-P(Y=y) * log(P(Y=y)))\\n self.lab_entropy = 0\\n s = sum(self.lab_counts.values())\\n for label, count in self.lab_counts.items():\\n self.lab_probs[label] = count / s\\n self.lab_entropy -= self.lab_probs[label] * self.log(self.lab_probs[label])\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def log_prob(self, x, y):\\n p = self.tag_log_prob(y)\\n for i in range(len(y)):\\n if self.out_prob(x[i], y[i]) == 0:\\n return -math.inf\\n\\n p += math.log2(self.out_prob(x[i], y[i]))\\n\\n return p\",\n \"def logq_joint(self, x, h, return_mu=False):\\n logph = distributions.Normal(0, 1).log_prob(h).sum(1)\\n gmu = self.g(h)\\n px_given_h = distributions.Normal(gmu, self.logsigma.exp())\\n logpx_given_h = px_given_h.log_prob(x).flatten(start_dim=1).sum(1)\\n if return_mu:\\n return logpx_given_h + logph, gmu\\n else:\\n return logpx_given_h + logph\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def _cal_igr(x, y):\\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def prob(self, x, y):\\n p = self.tag_prob(y)\\n for i in range(len(y)):\\n p *= self.out_prob(x[i], y[i])\\n\\n return p\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def mutual_info_fast(l1, l2, l1_entropy, l2_entropy):\\n return l1_entropy + l2_entropy - entropy(joint_dataset(l1, l2))\",\n \"def conditional_entropy(f1, f2):\\n\\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\\n return ce\",\n \"def calculate_entropy(y):\\n\\tlog2 = lambda x: math.log(x) / math.log(2)\\n\\tunique_labels = np.unique(y)\\n\\tentropy = 0\\n\\tfor label in unique_labels:\\n\\t\\tcount = len(y[y == label])\\n\\t\\tp = count / len(y)\\n\\t\\tentropy += -p * log2(p)\\n\\treturn entropy\",\n \"def print_entropies(independent_joint_probabilities, conditional_joint_probabilities):\\n indepndent_entropy = entropy_from_probability_matrix(independent_joint_probabilities)\\n conditional_entropy = entropy_from_probability_matrix(conditional_joint_probabilities)\\n\\n print 'Independent H(X,Y) = {h}'.format(h=indepndent_entropy)\\n print 'Conditional H(X,Y) = {h}'.format(h=conditional_entropy)\\n print 'D_KL(Independent, Conditional) = {d_kl}' \\\\\\n .format(d_kl=kullback_leibler_divergence(independent_joint_probabilities, conditional_joint_probabilities))\\n print 'D_KL(Conditional, Independent) = {d_kl}' \\\\\\n .format(d_kl=kullback_leibler_divergence(conditional_joint_probabilities, independent_joint_probabilities))\\n\\n return indepndent_entropy, conditional_entropy\",\n \"def _entropy_filter(self, prob1, prob2):\\n\\n\\n # calculate merged prob.\\n prob_merged = (prob1 + prob2)/2\\n # Compute entropy for each prob.\\n H1 = -prob1 * math.log(prob1) - (1-prob1) * math.log(1-prob1)\\n H2 = -prob2 * math.log(prob2) - (1-prob2) * math.log(1-prob2)\\n Hm = -prob_merged * math.log(prob_merged) - (1-prob_merged) * math.log(1-prob_merged)\\n\\n H_min = min(H1, H2, Hm)\\n\\n if H_min == H1:\\n return prob1\\n elif H_min == H2:\\n return prob2\\n else:\\n return prob_merged\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def empirical_bottleneck(x,y,numuniquex=0,numuniquey=0,**kw):\\n \\n # Marginal, joint and conditional distributions required to calculate the IB\\n pxy_j = p_joint(x,y)\\n px = pxy_j.sum(axis=1)\\n py = pxy_j.sum(axis=0)\\n pyx_c = pxy_j.T / px\\n #Calculate the information bottleneck for different values of beta\\n i_p,i_f,beta = IB(px,py,pyx_c,**kw)\\n # Return array of ipasts and ifutures for array of different values of beta - mi should correspond to the saturation point\\n mi = mi_x1x2_c(py, px, pyx_c)\\n return i_p,i_f,beta,mi,entropy(px,base=2),entropy(py,base=2)\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n # -- OUR CODE HERE\\n \\n \\n import math\\n for label in self.legalLabels:\\n sumThing = 0.0\\n for pixel in self.conditionalProb[label]:\\n if datum[pixel] is 1:\\n #assert self.conditionalProb[label][pixel] < 1.0 # -- sanity check that the probability is valid\\n sumThing += math.log((self.conditionalProb[label][pixel]*1.0))\\n else:\\n sumThing+=math.log(1-self.conditionalProb[label][pixel]*1.0)\\n logJoint[label] = math.log(self.prior[label]*1.0) + sumThing*1.0\\n \\n\\n \\n \\n import time\\n #print \\\"logJoint is :: \\\", logJoint\\n #time.sleep(2)\\n \\n \\n # -- uses the conditional probability tables computed in the current iteration\\n # -- in train and tune\\n \\n return logJoint\",\n \"def symbolic_transfer_entropy(symX, symY):\\n\\n if len(symX) != len(symY):\\n raise ValueError('All arrays must have same length')\\n \\n symX = np.array(symX)\\n symY = np.array(symY)\\n \\n cp = symbolic_conditional_probabilities_consecutive(symX)\\n cp2 = symbolic_conditional_probabilities_consecutive_external(symX, symY)\\n jp = symbolic_joint_probabilities_consecutive_external(symX, symY)\\n \\n TE = 0\\n \\n for yi, xi, xii in list(jp.keys()):\\n try:\\n a = cp[xi,xii]\\n b = cp2[yi,xi,xii]\\n c = jp[yi,xi,xii]\\n TE += c * np.log(b / a) / np.log(2.)\\n except KeyError:\\n continue\\n except:\\n print(\\\"Unexpected Error\\\")\\n raise\\n del cp\\n del cp2\\n del jp\\n \\n return TE\",\n \"def get_information_y_hat(x_pub, x_priv, x_joint, y_hat, num_of_bins_y):\\n\\tprint('Start calculating the information for y_hat...')\\n\\ty_hat = np.array(y_hat).astype(np.float)\\n\\tpys_hat, unique_inverse_y, y_hat = extract_probs_label(y_hat,num_of_bins_y)\\n\\tp_y_given_x_pub, b1_pub, b_pub, unique_a_pub, unique_inverse_x_pub, pxs_pub = extract_probs(y_hat, x_pub)\\n\\tp_y_given_x_priv, b1_priv, b_priv, unique_a_priv, unique_inverse_x_priv, pxs_priv = extract_probs(y_hat, x_priv)\\n\\tp_y_given_x_joint, b1_joint, b_joint, unique_a_joint, unique_inverse_x_joint, pxs_joint = extract_probs(y_hat, x_joint)\\n\\t# Shannon Entropy over label\\n\\tH2Y_hat = -np.sum(pys_hat * np.log2(pys_hat))\\n\\t# mutual Information between secret layer and label\\n\\tMI_pri_y_hat = calc_information_for_inp_out(pxs_priv,pys_hat,y_hat,unique_inverse_x_priv)\\n\\t# mutual Information between secret layer and label\\n\\tMI_pub_y_hat = calc_information_for_inp_out(pxs_pub,pys_hat,y_hat,unique_inverse_x_pub)\\n\\treturn H2Y_hat, MI_pri_y_hat, MI_pub_y_hat\",\n \"def __call__(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\\n return torch.log(1 + torch.exp(-y1 * y2))\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def js_divergence(dist1, dist2):\\n mean_dist = (dist1 + dist2) / 2.0\\n js = (\\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\\n ) / 2.0\\n return js\",\n \"def entropy(a, b):\\n with mp.extradps(5):\\n a, b = _validate_a_b(a, b)\\n return (_fun.logbeta(a, b)\\n - (a - 1)*mp.psi(0, a)\\n - (b - 1)*mp.psi(0, b)\\n + (a + b - 2)*mp.psi(0, a + b))\",\n \"def associate_comp(x, y):\\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])\",\n \"def mutual_information(x, y, w):\\r\\n \\r\\n\\r\\n total_entropy = entropy(y,w)\\r\\n\\r\\n partitioned_x = partition(x)\\r\\n weighted_entropy = 0\\r\\n # calculate the weighted entropy over the partition of x\\r\\n vals,counts= np.unique(x,return_counts=True)\\r\\n for key in partitioned_x:\\r\\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\\r\\n\\r\\n information_gain = total_entropy - weighted_entropy\\r\\n return information_gain\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def logistic_loss(x, y):\\n x = x.reshape((-1,))\\n y = y.reshape((-1,))\\n \\n N, = x.shape\\n \\n y_p = np.where(y == 1,1,0)\\n\\n p = sigmoid(x)\\n loss = -(y_p*np.log(p) + (1-y_p)*np.log(1-p))\\n loss = np.sum(loss)/N\\n\\n dx = (1/N)*(p - y_p)\\n \\n return loss, dx\",\n \"def calculateLogJointProbabilities(self, datum):\\n logJoint = util.Counter()\\n for cls in self.classes:\\n class_probability = self.prior_prob[cls]\\n for key, value in datum.items():\\n relative_feature_values = self.likelihoods[cls][key]\\n class_probability += math.log(relative_feature_values.get(datum[key], 0.01))\\n\\n logJoint[cls] = class_probability\\n\\n return logJoint\",\n \"def symbolic_joint_probabilities(symX, symY):\\n\\n if len(symX) != len(symY):\\n raise ValueError('All arrays must have same length')\\n \\n symX = np.array(symX)\\n symY = np.array(symY)\\n \\n # initialize\\n jp = defaultdict(float)\\n n = len(symX)\\n\\n for yi, xi in zip(symY,symX):\\n jp[yi, xi] += 1.0 / n\\n\\n return dict(jp)\",\n \"def _compute_prob_y_given_x(self, _x, _y):\\n normalisation_constant = sum([\\n math.exp(sum([self.weights[_feature] *\\n self.feature_funcs[_feature, cls](_feature, cls)\\n for _feature in _x]))\\n for cls in self.classes])\\n\\n return math.exp(sum([\\n self.weights[_feature] *\\n self.feature_funcs[_feature, _y](_feature, _y)\\n for _feature in _x])) / normalisation_constant\",\n \"def Pdist2(x, y):\\r\\n x_norm = (x ** 2).sum(1).view(-1, 1)\\r\\n if y is not None:\\r\\n y_norm = (y ** 2).sum(1).view(1, -1)\\r\\n else:\\r\\n y = x\\r\\n y_norm = x_norm.view(1, -1)\\r\\n Pdist = x_norm + y_norm - 2.0 * torch.mm(x, torch.transpose(y, 0, 1))\\r\\n Pdist[Pdist<0]=0\\r\\n return Pdist\",\n \"def prob1():\\n x, y = sy.symbols('x, y')\\n return sy.Rational(2,5) * sy.exp(x**2 - y) * sy.cosh(x + y) + \\\\\\n sy.Rational(3,7) * sy.log(x*y + 1)\",\n \"def conditional_entropy(x, y, bins, normalize=False):\\n \\n # get the bins\\n bins = get_2D_bins(x, y, bins)\\n \\n # calculate H(x,y) and H(y)\\n hjoint = joint_entropy(x,y,bins)\\n hy = entropy(y, bins[1])\\n\\n if normalize:\\n normalizer = entropy(x, bins[0])\\n conditional_entropy = hjoint - hy\\n\\n # check if conditional entropy and normalizer are very small\\n if conditional_entropy < 1e-4 and normalizer < 1e-4:\\n # return zero to prevent very high values of normalized conditional entropy\\n # e.g. conditional entropy = -1.3e-12, normalizer = -1.6e-12 \\n # -> normalized conditional entropy = 812.5\\n return 0\\n else:\\n return conditional_entropy / normalizer\\n else:\\n return hjoint - hy\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def chl_entropy(y, base=2):\\n p,bins = histogram(y, bins=unique(y)) # don't use 'Normed' feature, since that includes the bin-width!\\n p = p[p!=0]/float(len(y))\\n S = -1.0*sum(p*log(p))/log(base)\\n return S\",\n \"def dist(x, y):\\n dx = x[0] - y[0]\\n dy = x[1] - y[1]\\n ans = dx**2 + dy**2\\n ans = ans**(0.5)\\n return ans\",\n \"def prob_2_entropy(prob):\\r\\n n, c, h, w = prob.size()\\r\\n return -torch.mul(prob, torch.log2(prob + 1e-30)) / np.log2(c)\",\n \"def dist(x, y):\\n dx = x[0] - y[0]\\n dy = x[1] - y[1]\\n ans = dx**2 + dy**2\\n ans = ans**(0.5)\\n return ans\",\n \"def compute_dists(x, y):\\r\\n \\r\\n return (x - y.permute(0, 2, 1)) ** 2\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def weight(self, y, xn, xo):\\n\\n return self._model.log_prob(y, xn) + self._model.h_weight(xn, xo) - self._kernel.log_prob(xn)\",\n \"def logits_and(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n t = (x + y) / 2\\n f = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -t)\\n return t - f\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def entropy_obj(self, x, h, num_samples_posterior=20, return_score=False, learn_post_sigma=True):\\n inf_dist = distributions.Normal(h, self.post_logsigma.detach().exp())\\n h_given_x = inf_dist.sample((num_samples_posterior,))\\n if len(x.size()) == 4:\\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\\n xr = x[None].repeat(num_samples_posterior, 1, 1, 1, 1)\\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1), x.size(2), x.size(3))\\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1), x.size(2), x.size(3))\\n logq = logq.view(num_samples_posterior, x.size(0))\\n w = (logq - inf_logprob).softmax(dim=0)\\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\\n weighted_fvals = (fvals * w[:, :, None, None, None]).sum(0).detach()\\n c = weighted_fvals\\n else:\\n inf_logprob = inf_dist.log_prob(h_given_x).sum(2)\\n xr = x[None].repeat(num_samples_posterior, 1, 1)\\n xr = xr.view(x.size(0) * num_samples_posterior, x.size(1))\\n logq, mean_output = self.logq_joint(xr, h_given_x.view(-1, h.size(1)), return_mu=True)\\n mean_output = mean_output.view(num_samples_posterior, x.size(0), x.size(1))\\n logq = logq.view(num_samples_posterior, x.size(0))\\n w = (logq - inf_logprob).softmax(dim=0)\\n fvals = (x[None] - mean_output) / (self.logsigma.exp() ** 2)\\n weighted_fvals = (fvals * w[:, :, None]).sum(0).detach()\\n c = weighted_fvals\\n\\n mgn = c.norm(2, 1).mean()\\n g_error_entropy = torch.mul(c, x).mean(0).sum()\\n\\n post = distributions.Normal(h.detach(), self.post_logsigma.exp())\\n h_g_post = post.rsample()\\n joint = self.logq_joint(x.detach(), h_g_post)\\n post_ent = post.entropy().sum(1)\\n\\n elbo = joint + post_ent\\n post_loss = -elbo.mean()\\n\\n if learn_post_sigma:\\n self.post_optimizer.zero_grad()\\n post_loss.backward()\\n self.post_optimizer.step()\\n\\n if return_score:\\n return g_error_entropy, mgn, c\\n else:\\n return g_error_entropy, mgn\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def hyperboloidDist(point1, point2):\\n return np.arccosh(-minkowskiDot(point1, point2))\",\n \"def log_joint(self):\\n return sum([\\n self.log_marg_like(self.gamma, self.gamma0, self.lamb, self.nu),\\n self._gamma0_distribution.logpdf(self.gamma0),\\n self._nu_distribution.logpdf(self.nu),\\n self._lambda_distribution.logpdf(self.lamb),\\n self.probit_distribution(self.xi).logpdf(self.gamma),\\n self._xi_distribution.logpdf(self.xi) if self.sample_xi else 0.0\\n ])\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def _calculate_probs_and_entropy_x(self, columns):\\n #calculate x probabilities and H(Xi)\\n #H(Xi) = Sum(x € Xi)(-P(Xi=x) * log(P(Xi=x)))\\n for col in columns:\\n self.cat_entropies[col] = 0\\n xsum = 0\\n for val in self.categories[col]:\\n self.cat_probs[col][val] = 0\\n for label in self.labels:\\n self.cat_probs[col][val] += self.cat_counts[col][label][val]\\n xsum += self.cat_probs[col][val]\\n for val in self.categories[col]:\\n self.cat_probs[col][val] /= xsum\\n self.cat_entropies[col] -= self.cat_probs[col][val] * self.log(self.cat_probs[col][val])\",\n \"def entropy(self, X):\\n if isinstance(X, np.ndarray):\\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\\n K = self._posterior_covariance(X)\\n L = np.linalg.cholesky(K)\\n D = len(X)\\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))\",\n \"def joint_proba(self, X):\\n return self.weights * self._bernoulli(X)\",\n \"def test_get_xentropy_components_one_time_neigh(self):\\n\\n this_numerator, this_denominator = (\\n learning_curves._get_xentropy_components_one_time(\\n actual_target_matrix=ACTUAL_TARGET_MATRIX,\\n probability_matrix=PROBABILITY_MATRIX,\\n eval_mask_matrix=MASK_MATRIX,\\n matching_distance_px=NEIGH_DISTANCE_PX\\n )\\n )\\n\\n self.assertTrue(numpy.isclose(\\n this_numerator, NEIGH_XENTROPY_NUMERATOR, atol=TOLERANCE\\n ))\\n self.assertTrue(numpy.isclose(\\n this_denominator, NEIGH_XENTROPY_DENOM, atol=TOLERANCE\\n ))\",\n \"def max_entangled(h1, h2):\\n\\n for h in (h1, h2):\\n h.assert_ket_space()\\n\\n field = h1.base_field\\n\\n d = h1.dim()\\n if h2.dim() != d:\\n raise HilbertError('spaces must be of the same dimension')\\n\\n return (h1.H * h2).eye().transpose(h1) / field.sqrt(d)\",\n \"def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n f = -(x + y) / 2\\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\\n return t - f\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def prob_larger_continuous(distr1, distr2):\\n\\n return distr1.expect(distr2.cdf)\",\n \"def _jsd(prob_dist_p, prob_dist_q):\\n prob_dist_p = check_numpy_param('prob_dist_p', prob_dist_p)\\n prob_dist_q = check_numpy_param('prob_dist_q', prob_dist_q)\\n norm_dist_p = prob_dist_p / (np.linalg.norm(prob_dist_p, ord=1) + 1e-12)\\n norm_dist_q = prob_dist_q / (np.linalg.norm(prob_dist_q, ord=1) + 1e-12)\\n norm_mean = 0.5*(norm_dist_p + norm_dist_q)\\n return 0.5*(stats.entropy(norm_dist_p, norm_mean)\\n + stats.entropy(norm_dist_q, norm_mean))\",\n \"def enumerate_joint_ask(X, e, P):\\n Q = ProbDist(X) ## A probability distribution for X, initially empty\\n Y = [v for v in P.variables if v != X and v not in e]\\n for xi in P.values(X):\\n Q[xi] = enumerate_joint(Y, extend(e, X, xi), P)\\n return Q.normalize()\",\n \"def _calculate_probs_and_entropies(self):\\n self._calculate_probs_and_entropy_y()\\n self._calculate_probs_and_entropy_x(self.cat_cols)\",\n \"def Dist(p1,p2):\\n x1, y1 = p1\\n x2, y2 = p2\\n return (((x1-x2)*(x1-x2)) + ((y1-y2)*(y1-y2)))**0.5\",\n \"def forward(self, x, y):\\n distance = (x - y).norm(2, dim=-1, keepdim=True)\\n z = (distance - self.mu) / self.sigma\\n prob = torch.exp(-0.5 * z * z)\\n return prob\",\n \"def get_probability(self, x, y, base_x, base_y):\\n delta_x = x - base_x \\n delta_y = y - base_y\\n prob_x = self.nx_predictor.get_probability(delta_x)\\n prob_y = self.ny_predictor.get_probability(delta_y)\\n prob_xy = self.prob_alpha_x*prob_x*self.prob_alpha_y*prob_y\\n return prob_x, prob_y, prob_xy\",\n \"def mutual_information(x, y, logfunc=np.log2, nperms=1e4):\\n def entropy(freqDict):\\n return -np.array([p*logFunc(p) for p in freqDict.values()]).sum()\\n freqx = objhist(x)\\n freqy = objhist(y)\\n \\n Hx = freqx.entropy()\\n Hy = freqy.entropy()\\n Hxy = objhist(zip(x,y)).entropy()\\n M = Hx + Hy - Hxy\\n Mstar = 2*M / (Hx+Hy)\\n\\n if len(freqx)==1 or len(freqy)==1:\\n p = 1\\n elif np.all([xi==yi for xi,yi in zip(x,y)]):\\n p = 0\\n else:\\n Mperms = np.array([Hx + Hy - objhist(zip(permutation(x),y)).entropy() for i in np.arange(nperms)])\\n p = (Mperms >= M).sum() / nperms\\n\\n return M, Mstar, p, Hx, Hy, Hxy\",\n \"def joint_likelihood_combine(x2LL, alpha1 = 0.32, alpha2 = 0.05, return_full=False):\\n\\n # Combine log-likelihood ratios by summing them\\n x2LL_sum = np.sum([x2LL[item]['llr'] for item in x2LL], axis=0)\\n\\n # x-axis values (must be the same for all datasets, take the first one)\\n r0_value = [x2LL[item]['val'] for item in x2LL][0]\\n \\n # Find minimum \\n x2LL_min = np.min(x2LL_sum)\\n minind = np.argmin(x2LL_sum)\\n IFR = r0_value[minind]\\n\\n # Find first interval\\n chi2 = stats.chi2.ppf(q=1-alpha1, df=1)\\n ind = (np.where(x2LL_sum - x2LL_min <= chi2))[0] # Note <= not <\\n CI68 = np.array([r0_value[ind[0]], r0_value[ind[-1]]])\\n \\n # Find second interval\\n chi2 = stats.chi2.ppf(q=1-alpha2, df=1)\\n ind = (np.where(x2LL_sum - x2LL_min <= chi2))[0] # Note <= not <\\n CI95 = np.array([r0_value[ind[0]], r0_value[ind[-1]]])\\n\\n CI_val = np.array([CI95[0], CI68[0], CI68[1], CI95[1]])\\n\\n if not return_full:\\n return IFR, CI_val\\n else:\\n return IFR, CI_val, x2LL_sum, r0_value\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def dist(self, X, Y):\\n raise NotImplementedError\",\n \"def add_joint(joint: str, x1: int, y1: int, x2: int, y2: int) -> str:\\n return joint\",\n \"def product(self, other: \\\"DiscreteFactorTable\\\"):\\n\\n #Conjunction with null distribution is null table\\n if (len(self.support) == 0) or (len(other.support) == 0):\\n return DiscreteFactorTable([])\\n\\n # NOTE: can this be relaxed?\\n assert type(self.support[0]) == type(other.support[0])\\n\\n jsupport = []\\n jlogits = []\\n # HACK: this should throw a warning or something if the distributions have different headers\\n # i.e., dictionary keys interact in a weird way\\n for si, oi in product(self.support, other.support):\\n if isinstance(si, (dict, frozendict)) and isinstance(oi, (dict, frozendict)):\\n if dict_match(si, oi): #not efficient if the cartesian product is large\\n soi = dict_merge(si, oi)\\n if soi in jsupport:\\n continue\\n logit = self.logit(si) + other.logit(oi)\\n if logit == -np.inf:\\n continue\\n jsupport.append(soi)\\n jlogits.append(logit)\\n else:\\n jsupport.append((si, oi))\\n jlogits.append(self.logit(si) + other.logit(oi))\\n if len(jlogits) > 0:\\n logger.debug(\\\"Product distribution has no non-zero support\\\")\\n return DiscreteFactorTable(support=jsupport, logits=jlogits)\",\n \"def dtw(x, y, dist):\\n assert len(x)\\n assert len(y)\\n r, c = len(x), len(y)\\n D0 = zeros((r + 1, c + 1))\\n D0[0, 1:] = inf\\n D0[1:, 0] = inf\\n D1 = D0[1:, 1:] # view\\n for i in range(r):\\n for j in range(c):\\n D1[i, j] = dist(x[i], y[j])\\n C = D1.copy()\\n for i in range(r):\\n for j in range(c):\\n D1[i, j] += min(D0[i, j], D0[i, j+1], D0[i+1, j])\\n if len(x)==1:\\n path = zeros(len(y)), range(len(y))\\n elif len(y) == 1:\\n path = range(len(x)), zeros(len(x))\\n else:\\n path = _traceback(D0)\\n return D1[-1, -1] / sum(D1.shape), C, D1, path\",\n \"def join_cinfo(cooccur, percents):\\n import math\\n\\n word1 = cooccur[0][0]\\n word2 = cooccur[0][1]\\n try:\\n word1_percent = percents[word1]\\n weight1 = 1 / word1_percent\\n word2_percent = percents[word2]\\n weight2 = 1 / word2_percent\\n return (cooccur[0], cooccur[1], cooccur[1] *\\n math.log(min(weight1, weight2)))\\n except:\\n return 0\",\n \"def _entropy2(labels, base=None):\\n\\n n_labels = len(labels)\\n\\n if n_labels <= 1:\\n return 0\\n\\n value,counts = np.unique(labels, return_counts=True)\\n probs = counts / n_labels\\n n_classes = np.count_nonzero(probs)\\n\\n if n_classes <= 1:\\n return 0\\n\\n ent = 0.\\n\\n # Compute entropy\\n base = e if base is None else base\\n for i in probs:\\n ent -= i * log(i, base)\\n\\n # quick observation shows ent between 0.0 and 4.0.\\n return ent\",\n \"def probabilities(self, x, y):\\n return self.feed_and_return(x, y, self.network.a)\",\n \"def entropy(self):\\r\\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)\",\n \"def theils_u(x,\\n y,\\n nan_strategy=_REPLACE,\\n nan_replace_value=_DEFAULT_REPLACE_VALUE):\\n\\n print(x.name + ' to ' + y.name + ' with Theils U')\\n\\n if nan_strategy == _REPLACE:\\n x, y = replace_nan_with_value(x, y, nan_replace_value)\\n elif nan_strategy == _DROP:\\n x, y = remove_incomplete_samples(x, y)\\n\\n contingency = pd.crosstab(x, y)\\n c, p, dof, expected = ss.chi2_contingency(contingency)\\n\\n s_xy = conditional_entropy(x, y)\\n x_counter = Counter(x)\\n total_occurrences = sum(x_counter.values())\\n p_x = list(map(lambda n: n / total_occurrences, x_counter.values()))\\n s_x = ss.entropy(p_x)\\n if s_x == 0:\\n return 1, 0\\n else:\\n return (s_x - s_xy) / s_x, p, r'$U$'\",\n \"def entropyCategorical(attr, X, y):\\n uniques = X[attr].unique().tolist()\\n idxLists = []\\n entropies = []\\n weights = []\\n for u in uniques:\\n idxLists.append(X.index[X[attr] == u].tolist())\\n entropies.append(entropy(y, idxLists[-1]))\\n weights.append(len(idxLists[-1]))\\n\\n entropies = np.array(entropies).reshape(1, -1)\\n weights = np.array(weights).reshape(-1, 1).astype(np.float32)\\n weights /= np.sum(weights)\\n\\n return (uniques, idxLists, (entropies @ weights)[0, 0])\",\n \"def d2_bin(self, x, y):\\n \\n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\\n KD.fit(np.column_stack((x,y)))\\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\\n mesh = np.meshgrid(grid1,grid2)\\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\\n samp = KD.score_samples(data)\\n samp = samp.reshape(self.bins,self.bins)\\n p = np.exp(samp)/np.sum(np.exp(samp))\\n\\n return p\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6370943","0.63690835","0.63631195","0.6334478","0.6209416","0.6186507","0.60127246","0.5941165","0.58904195","0.5855695","0.5840326","0.5787013","0.5770392","0.57627195","0.5750125","0.5739848","0.5735412","0.56943065","0.56919396","0.5672802","0.5654701","0.5654116","0.5653314","0.55887705","0.5579684","0.55605185","0.55579716","0.5546054","0.55091","0.55074996","0.5497917","0.54649127","0.54270536","0.5422829","0.54179776","0.5417916","0.5415684","0.5415396","0.5408408","0.5403634","0.53971446","0.5395479","0.5389612","0.5354745","0.5353193","0.533573","0.53214014","0.53104955","0.53034663","0.5293938","0.5278855","0.52698445","0.52678806","0.5254893","0.5224478","0.5222314","0.5217103","0.5204719","0.5194968","0.5192214","0.51861906","0.51808023","0.51387227","0.51316315","0.51276195","0.51250756","0.5117498","0.5103547","0.5097237","0.50930595","0.50733805","0.5056223","0.5049023","0.50472176","0.5039295","0.50384253","0.5034905","0.5029633","0.502199","0.5016586","0.5012152","0.5009688","0.5008646","0.5006071","0.5001007","0.49994475","0.49986508","0.49882424","0.49779013","0.49739307","0.49614325","0.4954653","0.4954478","0.49493438","0.4948907","0.49487337","0.49457723","0.49456576","0.49426118","0.49263316"],"string":"[\n \"0.6370943\",\n \"0.63690835\",\n \"0.63631195\",\n \"0.6334478\",\n \"0.6209416\",\n \"0.6186507\",\n \"0.60127246\",\n \"0.5941165\",\n \"0.58904195\",\n \"0.5855695\",\n \"0.5840326\",\n \"0.5787013\",\n \"0.5770392\",\n \"0.57627195\",\n \"0.5750125\",\n \"0.5739848\",\n \"0.5735412\",\n \"0.56943065\",\n \"0.56919396\",\n \"0.5672802\",\n \"0.5654701\",\n \"0.5654116\",\n \"0.5653314\",\n \"0.55887705\",\n \"0.5579684\",\n \"0.55605185\",\n \"0.55579716\",\n \"0.5546054\",\n \"0.55091\",\n \"0.55074996\",\n \"0.5497917\",\n \"0.54649127\",\n \"0.54270536\",\n \"0.5422829\",\n \"0.54179776\",\n \"0.5417916\",\n \"0.5415684\",\n \"0.5415396\",\n \"0.5408408\",\n \"0.5403634\",\n \"0.53971446\",\n \"0.5395479\",\n \"0.5389612\",\n \"0.5354745\",\n \"0.5353193\",\n \"0.533573\",\n \"0.53214014\",\n \"0.53104955\",\n \"0.53034663\",\n \"0.5293938\",\n \"0.5278855\",\n \"0.52698445\",\n \"0.52678806\",\n \"0.5254893\",\n \"0.5224478\",\n \"0.5222314\",\n \"0.5217103\",\n \"0.5204719\",\n \"0.5194968\",\n \"0.5192214\",\n \"0.51861906\",\n \"0.51808023\",\n \"0.51387227\",\n \"0.51316315\",\n \"0.51276195\",\n \"0.51250756\",\n \"0.5117498\",\n \"0.5103547\",\n \"0.5097237\",\n \"0.50930595\",\n \"0.50733805\",\n \"0.5056223\",\n \"0.5049023\",\n \"0.50472176\",\n \"0.5039295\",\n \"0.50384253\",\n \"0.5034905\",\n \"0.5029633\",\n \"0.502199\",\n \"0.5016586\",\n \"0.5012152\",\n \"0.5009688\",\n \"0.5008646\",\n \"0.5006071\",\n \"0.5001007\",\n \"0.49994475\",\n \"0.49986508\",\n \"0.49882424\",\n \"0.49779013\",\n \"0.49739307\",\n \"0.49614325\",\n \"0.4954653\",\n \"0.4954478\",\n \"0.49493438\",\n \"0.4948907\",\n \"0.49487337\",\n \"0.49457723\",\n \"0.49456576\",\n \"0.49426118\",\n \"0.49263316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7735844"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3393,"cells":{"query":{"kind":"string","value":"r\"\"\"KullbackLeibler Divergence Calculates the KullbackLeibler Divergence between two discrete distributions x and y. X is considered to be an empirical discrete distribution while y is considered to be the real discrete distribution of the underlying population."},"document":{"kind":"string","value":"def kullback_leibler(x, y, bins, xy_probabilities=False):\n if xy_probabilities:\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x),1,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y),1,atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n \n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n #calculate probabilities\n px = (hist_x / np.sum(hist_x))\n py = (hist_y / np.sum(hist_y))\n\n # calculate the cross entropy and unconditioned entropy of y\n hcross = cross_entropy(px, py, bins, xy_probabilities=True)\n hx = entropy(px, bins, xy_probabilities=True)\n \n return hcross - hx"},"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 kl_bern(x, y):\n x = min(max(x, eps), 1-eps)\n y = min(max(y, eps), 1-eps)\n return x*log(x/y) + (1-x)*log((1-x)/(1-y))","def kl_divergence(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tdistance = np.sum( x.flat_cpt() * np.log( x.flat_cpt() / y.flat_cpt() ) )\n\treturn distance","def kl_divergence(x, y, thresholded=True, symmetrized=True, normalize=True):\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\n x.dtype == np.float32 and y.dtype == np.float32)\n # assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\n if thresholded:\n normalize = True\n if normalize:\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n if thresholded:\n eps = np.finfo(x.dtype).eps\n x = x + eps\n y = y + eps\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n res = __kl_divergence(x, y)\n\n if symmetrized:\n res = 0.5 * res + 0.5 * __kl_divergence(y, x).transpose()\n\n return np.float64(res).reshape(res.shape)","def kullback_leibler_divergence_loss(self, y_true=None, y_pred=None, decimal=5, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data2(y_true, y_pred, decimal)\n y_pred = np.clip(y_pred, self.EPSILON, 1 - self.EPSILON) # Clip predicted probabilities\n if binary:\n y_true = np.clip(y_true, self.EPSILON, 1 - self.EPSILON) # Clip true labels\n res = y_true * np.log(y_true / y_pred) + (1 - y_true) * np.log((1 - y_true) / (1 - y_pred))\n res = np.mean(res)\n else:\n # Convert y_true to one-hot encoded array\n num_classes = len(np.unique(y_true))\n y_true = np.eye(num_classes)[y_true]\n y_true = np.clip(y_true, self.EPSILON, 1 - self.EPSILON) # Clip true labels\n res = np.sum(y_true * np.log(y_true / y_pred), axis=1)\n res = np.mean(res)\n return np.round(res, decimal)","def kl_divergence(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n y_true = backend.clip(y_true, backend.epsilon(), 1)\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)","def kl_divergence(p_dist, q_dist, n_samples_per_axis=30, n_axis=2):\r\n global COUNTER\r\n if n_axis == 2:\r\n x = np.linspace(-1.0, 1.0, n_samples_per_axis)\r\n y = np.linspace(-1.0, 1.0, n_samples_per_axis)\r\n grids = np.meshgrid(x, y)\r\n elif n_axis == 3:\r\n x = np.linspace(-1.0, 1.0, n_samples_per_axis)\r\n y = np.linspace(-1.0, 1.0, n_samples_per_axis)\r\n z = np.linspace(-1.0, 1.0, n_samples_per_axis)\r\n grids = np.meshgrid(x, y, z)\r\n elif n_axis == 1:\r\n grids = np.linspace(-1.1, 1.1, 120)\r\n print(\"Grid complete!\")\r\n if n_axis != 1:\r\n grid = np.vstack(grids).reshape((n_axis, n_samples_per_axis**n_axis)).T\r\n else:\r\n grid = grids\r\n grid = np.reshape(grid, (grid.shape[0], 1))\r\n probs_p = np.exp(p_dist.score_samples(grid))\r\n probs_q = np.exp(q_dist.score_samples(grid))\r\n print(\"prob_calc_complete\")\r\n kl = entropy(probs_p, probs_q)\r\n return kl","def kl_divergence_from_logits(self, logits_a, logits_b):\n distribution1 = tf.contrib.distributions.Categorical(logits=logits_a)\n distribution2 = tf.contrib.distributions.Categorical(logits=logits_b)\n return tf.contrib.distributions.kl_divergence(distribution1, distribution2)","def KL_divergence(model_1, model_2, samples):\n posterior_1 = create_posterior_object(model_1, samples)\n posterior_2 = create_posterior_object(model_2, samples)\n return posterior_1.KL(posterior_2)","def KL_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\n if data_range is None:\n data_range = list(set(xs)) + list(set(ys))\n if pdf_x is None:\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\n if pdf_y is None:\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\n keys = set(pdf_x.keys()+pdf_y.keys())\n PQ = []\n for k in keys:\n if k in pdf_x and k in pdf_y:\n PQ.append((pdf_x[k],pdf_y[k]))\n return np.sum([p*np.log(float(p)/float(q)) for (p,q) in PQ if q>0 and p>0])","def _graph_fn_kl_divergence(distribution_a, distribution_b):\n if get_backend() == \"tf\":\n return tf.no_op()\n # TODO: never tested. tf throws error: NotImplementedError: No KL(distribution_a || distribution_b) registered for distribution_a type Bernoulli and distribution_b type ndarray\n #return tf.distributions.kl_divergence(\n # distribution_a=distribution_a,\n # distribution_b=distribution_b,\n # allow_nan_stats=True,\n # name=None\n #)","def __init__(self, name='backward_kl_divergence', **kwargs):\n\n super(BackwardKLDivergence, self).__init__(name=name, **kwargs)\n\n return","def test_divergences_to_kl2(dists, divergence):\n for dist1, dist2 in combinations(dists, 2):\n assert divergence(dist1, dist2, alpha=1) == pytest.approx(kullback_leibler_divergence(dist1, dist2))","def get_KL_divergence(self):\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\n KL_loss_b = 0\n if self.bias is not None:\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\n \n KL_loss = KL_loss_W + KL_loss_b\n \n return KL_loss","def elbo(self, x, y):\n self.forward(x, y)\n\n # prior-posterior divergence\n kl_loss = kl.kl_divergence(\n self.prior_latent_distribution, self.posterior_latent_distribution).mean()\n\n # reconstruction loss\n if not self.training:\n # resample output based on prior, not posterior\n self.forward(x)\n reconstruction_loss = self.recon_loss_fun(self.y_hat_raw, y[:, 0])\n\n # training loss\n loss = reconstruction_loss + self.beta * kl_loss\n\n # statictics about prior and posterior\n mu_prior = self.prior_latent_distribution.mean\n mu_posterior = self.posterior_latent_distribution.mean\n mu_dist = torch.norm(mu_prior - mu_posterior, dim=-1).mean()\n std_prior = self.prior_latent_distribution.stddev\n std_prior = torch.norm(std_prior - mu_posterior, dim=-1).mean()\n std_posterior = self.posterior_latent_distribution.stddev\n std_posterior = torch.norm(std_posterior - mu_posterior, dim=-1).mean()\n\n return loss, reconstruction_loss, kl_loss, mu_dist, std_prior, std_posterior","def kl_divergence(a, b, normalize=True):\n a, b = np.array(a), np.array(b)\n\n x = np.linspace(\n min(a.min(), b.min()) - 1,\n max(a.max(), b.max()) + 1,\n 100\n )\n\n p = gaussian_kde(a)(x)\n q = gaussian_kde(b)(x)\n\n if normalize:\n p = p/np.sum(p)\n q = q/np.sum(q)\n\n return np.sum(np.where(p != 0, (p) * np.log(p / q), 0))","def kde2D(x, y, bandwidth, xbins=100j, ybins=100j, **kwargs):\n\n # create grid of sample locations (default: 100x100)\n xx, yy = np.mgrid[x.min():x.max():xbins, \n y.min():y.max():ybins]\n\n xy_sample = np.vstack([yy.ravel(), xx.ravel()]).T\n xy_train = np.vstack([y, x]).T\n\n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\n kde_skl.fit(xy_train)\n\n # score_samples() returns the log-likelihood of the samples\n z = np.exp(kde_skl.score_samples(xy_sample))\n return xx, yy, np.reshape(z, xx.shape)","def zkl_divergence(x, y, gamma):\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])","def find_knee(x,y):\n\n # find ranges\n if len(x) != len(y):\n raise Exception(\"bad data\")\n tot_len = len(x)\n \n \n \n # fit strait lines to both\n\n # find intercept\n knee_r = (f_top.beta[1] - f_bottom.beta[1])/(-f_top.beta[0] + f_bottom.beta[0])","def kl_gauss(x, y, sig2=1.):\n return (x - y) ** 2 / (2 * sig2)","def kl_div_prior_gradient(self, posterior_logits, posterior_binary_samples):\n #DVAE Eq11 - gradient of prior\n #gradient of the KLD between posterior and prior wrt to prior\n #parameters theta, i.e. generative model parameters.\n #logits to probabilities\n posterior_probs=torch.sigmoid(posterior_logits)\n positive_probs=posterior_probs.detach()\n \n #samples from posterior are labelled positive\n positive_samples=posterior_binary_samples.detach()\n\n n_split=positive_samples.size()[1]//2\n positive_samples_left,positive_samples_right=torch.split(positive_samples,split_size_or_sections=int(n_split),dim=1)\n \n #-z_left^t J z_right\n pos_first_term=torch.matmul(positive_samples_left,self.prior.get_weights())*positive_samples_right\n \n rbm_bias_left=self.prior.get_visible_bias()\n rbm_bias_right=self.prior.get_hidden_bias()\n rbm_bias=torch.cat([rbm_bias_left,rbm_bias_right])#self._h\n \n #this gives [42,400] size\n #- z^t h\n #TODO this uses positive probs. Should it not use positive samples?\n # FIXME an indication are the negative ones where samples are used! On\n #other hand this is the only place this this used\n pos_sec_term=positive_probs*rbm_bias\n # pos_sec_term=positive_samples*rbm_bias\n\n # Energy = -z_left^t J z_right - z^t h\n pos_kld_per_sample=-(torch.sum(pos_first_term,axis=1)+torch.sum(pos_sec_term,axis=1))\n #samples from rbm are labelled negative\n\n #rbm_samples Tensor(\"zeros:0\", shape=(200, 200), dtype=float32)\n #this returns the full RBM set: left and right nodes concatenated\n\n #TODO What are these samples here?\n #TODO what's the impact of doing gibbs sampling here? does this make\n #sense?\n rbm_samples=self.prior.get_samples_kld(approx_post_samples=positive_samples_left,n_gibbs_sampling_steps=1)\n negative_samples=rbm_samples.detach()\n\n # print(self.prior.get_weights())\n n_split=negative_samples.size()[1]//2\n negative_samples_left,negative_samples_right=torch.split(negative_samples,split_size_or_sections=int(n_split),dim=1)\n neg_first_term=torch.matmul(negative_samples_left,self.prior.get_weights())*negative_samples_right\n \n #FIXME see above, the positive case looks different. Why?\n neg_sec_term=negative_samples*rbm_bias\n neg_kld_per_sample=(torch.sum(neg_first_term,axis=1)+torch.sum(neg_sec_term,axis=1))\n \n kld_per_sample=pos_kld_per_sample+neg_kld_per_sample\n\n return kld_per_sample","def kl_divergence(self, samples):\n # Check size of input\n if not len(samples.shape) == 2:\n raise ValueError('Given samples list must be n x 2.')\n if samples.shape[1] != self._n_parameters:\n raise ValueError(\n 'Given samples must have length ' + str(self._n_parameters))\n\n best_mode = np.zeros(samples.shape[0])\n for i in range(samples.shape[0]):\n a_sample = samples[i, :]\n a_log_pdf = -np.inf\n a_max_index = -1\n for j, var in enumerate(self._vars):\n a_test_log_pdf = var.logpdf(a_sample)\n if a_test_log_pdf > a_log_pdf:\n a_log_pdf = a_test_log_pdf\n a_max_index = j\n best_mode[i] = a_max_index\n\n kl = np.zeros(len(self._vars))\n for i in range(len(self._vars)):\n y = np.array(samples[best_mode == i, :], copy=True)\n # when a mode has no points use all samples\n if y.shape[0] == 0:\n y = np.array(samples, copy=True)\n m0 = np.mean(y, axis=0)\n s0 = np.cov(y.T)\n s1 = self._covs[i]\n m1 = self._modes[i]\n s1_inv = np.linalg.inv(s1)\n if len(np.atleast_1d(s0)) > 1:\n kl[i] = 0.5 * (\n np.trace(np.matmul(s1_inv, s0)) +\n np.matmul(np.matmul(m1 - m0, s1_inv), m1 - m0) -\n np.log(np.linalg.det(s0)) +\n np.log(np.linalg.det(s1)) -\n self._n_parameters)\n else:\n kl[i] = 0.5 * (\n np.sum(s1_inv * s0) +\n (m1 - m0) * s1_inv * (m1 - m0) -\n np.log(s0) +\n np.log(s1) -\n 1)\n return kl","def kl_divergence(dist1, dist2, symmetrized=True):\n if symmetrized == True:\n kl = (\n scipy.stats.entropy(dist1, dist2) + scipy.stats.entropy(dist2, dist1)\n ) / 2.0\n return kl\n else:\n kl = scipy.stats.entropy(dist1, dist2)\n return kl","def MyKLD(X,Y): \n mu1,mu2 = tuple(np.mean(X,axis=0))\n sigma1,sigma2 = tuple(np.std(X,axis=0))\n m1,m2 = tuple(np.mean(X,axis=0))\n s1,s2 = tuple(np.std(X,axis=0))\n rho = np.corrcoef(X,rowvar=False)[0,1]\n r = np.corrcoef(Y,rowvar=False)[0,1]\n \n return (\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\n (2 * (1 - r**2)) +\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \n (sigma2**2-s2**2)/s2**2) /\n (2 * (1 - r**2)) +\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\n )","def kl_divergence(self) -> Tensor:\n return torch.tensor(0.0)","def maxkl_strategy(self):\n # TODO: rewrite to update only distribution from sampled bucket\n # Instead of computing everything again every iteration\n\n # Label model distributions\n lm_posteriors = self.bucket_probs.clip(1e-5, 1-1e-5)\n\n # Sample distributions\n # D_KL(LM distribution||Sample distribution)\n rel_entropy = np.zeros(len(lm_posteriors))\n sample_posteriors = np.zeros(lm_posteriors.shape)\n\n # Iterate over buckets\n for i in range(len(lm_posteriors)):\n # Collect points in bucket\n bucket_items = self.ground_truth_labels[np.where(self.unique_inverse == i)[0]]\n # Collect labeled points in bucket\n bucket_gt = list(bucket_items[bucket_items != -1])\n # Add initial labeled point\n if not bucket_gt:\n bucket_gt.append(\n int(np.round(\n self.probs[\"bucket_labels_train\"][0][i].clip(0, 1)\n )))\n bucket_gt = np.array(bucket_gt)\n\n # Bucket distribution, clip to avoid D_KL undefined\n eps = 1e-2 / (len(bucket_gt))\n sample_posteriors[i, 1] = bucket_gt.mean().clip(eps, 1 - eps)\n sample_posteriors[i, 0] = 1 - sample_posteriors[i, 1]\n\n # KL divergence\n rel_entropy[i] = entropy(lm_posteriors[i, :], sample_posteriors[i, :])\n self.bucket_values = rel_entropy\n\n # Select buckets with highest KL divergence\n return np.where(\n np.logical_and(\n rel_entropy == np.max(rel_entropy[self.is_valid_bucket]), self.is_valid_bucket\n )\n )[0]","def test_divergences_to_kl(dists):\n for dist1, dist2 in combinations(dists, 2):\n assert alpha_divergence(dist1, dist2, alpha=-1) == pytest.approx(kullback_leibler_divergence(dist2, dist1))\n\n assert alpha_divergence(dist1, dist2, alpha=0) != pytest.approx(kullback_leibler_divergence(dist2, dist1))\n assert alpha_divergence(dist1, dist2, alpha=2) != pytest.approx(kullback_leibler_divergence(dist2, dist1))","def Kernel(x, y):\n\n Result = (np.dot(x_train[x, :], x_train[y, :])+1)**5 # Polynomial\n #Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\n #Gaussian\n \"\"\"\n sigma = 1\n if np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\n elif (np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\n elif np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\n \"\"\"\n return Result","def kl_poisson(x, y):\n x = max(x, eps)\n y = max(y, eps)\n return y-x+x*log(x/y)","def test_kl_divergence(get_distributions):\n for i, dist_a in enumerate(get_distributions):\n for j, dist_b in enumerate(get_distributions):\n kl = kl_divergence(dist_a, dist_b)\n if i == j:\n assert pytest.approx(kl, 0.0001) == 0.0\n else:\n assert kl > 0","def kl_divergence(self) -> Tensor:\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()","def kl_divergence(self):\n return self._kl_divergence_func","def kullback_leibler_divergence(p, q):\n null = 1e-10\n return sum(p.get(key, null) * math.log(p.get(key, null) / q.get(key, null))\n for key in set(chain(p.keys(), q.keys())))","def kl_divergence_bern_bern(z_pres_logits, prior_pres_prob, eps=1e-15):\n z_pres_probs = torch.sigmoid(z_pres_logits)\n kl = z_pres_probs * (torch.log(z_pres_probs + eps) - torch.log(prior_pres_prob + eps)) + \\\n (1 - z_pres_probs) * (torch.log(1 - z_pres_probs + eps) - torch.log(1 - prior_pres_prob + eps))\n\n return kl","def kl_div_posterior_gradient(self, posterior_logits, posterior_binary_samples):\n #DVAE Eq12\n #gradient of the KLD between posterior and prior wrt to posterior\n #parameters phi\n \n logger.debug(\"kl_div_posterior_gradient\")\n posterior_upper_bound = 0.999*torch.ones_like(posterior_logits)\n #logits to probabilities\n posterior_probs=torch.min(posterior_upper_bound, torch.sigmoid(posterior_logits))\n \n n_split=int(posterior_binary_samples.size()[1]//2)\n #binarised samples from posterior to RBM layers\n rbm_samples_left,rbm_samples_right=torch.split(posterior_binary_samples,split_size_or_sections=n_split,dim=1)\n\n #the following prepares the variables in the calculation in tehir format\n rbm_bias_left=self.prior.get_visible_bias()\n rbm_bias_right=self.prior.get_hidden_bias()\n\n rbm_bias=torch.cat([rbm_bias_left,rbm_bias_right])#self._h\n rbm_weight=self.prior.get_weights()#self._J\n\n # this is transposed, so we multiply what we call \"right hand\" (\"hidden layer\")\n # samples with right rbm nodes\n # rbm_weight_t=torch.transpose(rbm_weight,0,1)#self._J\n \n rbm_activation_right=torch.matmul(rbm_samples_right,rbm_weight.t())\n rbm_activation_left=torch.matmul(rbm_samples_left,rbm_weight)\n\n #corresponds to samples_times_J\n rbm_activation=torch.cat([rbm_activation_right,rbm_activation_left],1)\n \n #TODO what is this scaling factor?\n #[400,400] \n hierarchy_scaling= (1.0 - posterior_binary_samples) / (1.0 - posterior_probs)\n hierarchy_scaling_left,hierarchy_scaling_right=torch.split(hierarchy_scaling, split_size_or_sections=int(n_split),dim=1)\n \n #TODO why does this happen? This seems to scale only the left side of\n #the RBM. Th right side is replaced with ones.\n hierarchy_scaling_with_ones=torch.cat([hierarchy_scaling_left,torch.ones(hierarchy_scaling_right.size())],axis=1)\n \n with torch.no_grad():\n undifferentiated_component=posterior_logits-rbm_bias-rbm_activation*hierarchy_scaling_with_ones\n undifferentiated_component=undifferentiated_component.detach()\n \n kld_per_sample = torch.sum(undifferentiated_component * posterior_probs, dim=1)\n\n return kld_per_sample","def get_KL_divergence(self):\n KL_loss = 0\n if(self.Bayesian):\n for i in range(self.num_layers):\n KL_loss += getattr(self, 'LSTMCell%i'%(i+1)).get_KL_divergence()\n \n return KL_loss","def kl_divergence(self, post_logits, post_samples, is_training=True):\n logger.debug(\"GumBolt::kl_divergence\")\n \n # Concatenate all hierarchy levels\n logits_q_z = torch.cat(post_logits, 1)\n post_zetas = torch.cat(post_samples, 1)\n \n # Compute cross-entropy b/w post_logits and post_samples\n cross_entropy = - self._bce_loss(logits_q_z, post_zetas)\n cross_entropy = torch.mean(torch.sum(cross_entropy, 1), 0)\n \n # Compute positive energy expval using hierarchical posterior samples\n \n # Number of hidden and visible variables on each side of the RBM\n num_var_rbm = (self.n_latent_hierarchy_lvls * self._latent_dimensions)//2\n \n # Compute positive energy contribution to the KL divergence\n post_zetas_vis, post_zetas_hid = post_zetas[:, :num_var_rbm], post_zetas[:, num_var_rbm:]\n pos_energy = self.energy_exp(post_zetas_vis, post_zetas_hid)\n \n # Compute gradient contribution of the logZ term\n rbm_visible_samples, rbm_hidden_samples = self.sampler.block_gibbs_sampling()\n rbm_vis, rbm_hid = rbm_visible_samples.detach(), rbm_hidden_samples.detach()\n neg_energy = - self.energy_exp(rbm_vis, rbm_hid)\n \n kl_loss = cross_entropy + pos_energy + neg_energy\n return kl_loss, cross_entropy, pos_energy, neg_energy","def kl(self, other: \"Distribution\", **kwargs) -> TensorType:","def kl(self, other: \"Distribution\", **kwargs) -> TensorType:","def rbf_kernel(x_1, x_2, l):\n\n\tassert l > 0, \"The hyperparameter l must be > 0\"\n\tdist = euclidean_distances(x_1.reshape(-1,1), x_2.reshape(-1,1))\n\treturn np.exp(dist**2 / -(2*l**2))","def kde_sklearn(x, x_grid, bandwidth=0.8, **kwargs):\n \n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\n #kde_skl = KernelDensity()\n kde_skl.fit(x[:, np.newaxis])\n # score_samples() returns the log-likelihood of the samples\n log_pdf = kde_skl.score_samples(x_grid[:, np.newaxis])\n \n pdf = np.exp(log_pdf)\n\n fig = plt.figure(figsize=(10,10))\n ax = fig.add_subplot(111)\n #ax.imshow((1,1), cmap=plt.cm.gist_earth_r,extent=[xmin, xmax])\n ax.plot(x_grid, pdf, '.', label=\"kernel = kde_sklearn gaussian\", markersize=2)\n ax.text(700, 0.0035, \"N={0} points\".format(x.shape[0]))\n ax.legend(loc='upper left')\n ax.set_xlim([min(x), max(x)])\n ax.set_ylim(-0.001, 0.006)\n plt.show()","def kl(self):\n weights_logvar = self.weights_logvar\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\n 2 * self.prior_stdv.pow(2)) - 0.5\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\n 2 * self.prior_bias_stdv.pow(2)) \\\n - 0.5\n return kld_weights.sum() + kld_bias.sum()","def _grid_search_wl_kernel(\n k: WeisfilerLehman,\n subtree_candidates,\n train_x: list,\n train_y: torch.Tensor,\n lik: float,\n subtree_prior=None, # pylint: disable=unused-argument\n lengthscales=None,\n lengthscales_prior=None, # pylint: disable=unused-argument\n):\n # lik = 1e-6\n assert len(train_x) == len(train_y)\n best_nlml = torch.tensor(np.inf)\n best_subtree_depth = None\n best_lengthscale = None\n best_K = None\n if lengthscales is not None and k.se is not None:\n candidates = [(h_, l_) for h_ in subtree_candidates for l_ in lengthscales]\n else:\n candidates = [(h_, None) for h_ in subtree_candidates]\n\n for i in candidates:\n if k.se is not None:\n k.change_se_params({\"lengthscale\": i[1]})\n k.change_kernel_params({\"h\": i[0]})\n K = k.fit_transform(train_x, rebuild_model=True, save_gram_matrix=True)\n # self.logger.debug(K)\n K_i, logDetK = compute_pd_inverse(K, lik)\n # self.logger.debug(train_y)\n nlml = -compute_log_marginal_likelihood(K_i, logDetK, train_y)\n # self.logger.debug(f\"{i} {nlml}\")\n if nlml < best_nlml:\n best_nlml = nlml\n best_subtree_depth, best_lengthscale = i\n best_K = torch.clone(K)\n # self.logger.debug(f\"h: {best_subtree_depth} theta: {best_lengthscale}\")\n # self.logger.debug(best_subtree_depth)\n k.change_kernel_params({\"h\": best_subtree_depth})\n if k.se is not None:\n k.change_se_params({\"lengthscale\": best_lengthscale})\n k._gram = best_K # pylint: disable=protected-access","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def kl_divergence(self):\r\n\r\n target_columns = list(self.origdst.columns[11:-3])\r\n target_columns.append(self.origdst.columns[1]) # channel\r\n target_columns.append(self.origdst.columns[2]) # program_title\r\n target_columns.append(self.origdst.columns[3]) # genre\r\n\r\n kl_dict = {}\r\n\r\n for col in target_columns:\r\n\r\n try:\r\n\r\n col_counts_orig = self.origdst[col].value_counts(normalize=True).sort_index(ascending=True)\r\n col_counts_synth = self.synthdst[col].value_counts(normalize=True).sort_index(ascending=True)\r\n\r\n kl = sum(rel_entr(col_counts_orig.tolist(), col_counts_synth.tolist()))\r\n\r\n kl_dict[col] = kl\r\n\r\n except:\r\n\r\n print('For the column ', col, ' you must generate the same unique values as the real dataset.')\r\n print('The number of unique values than you should generate for column ', col, 'is ',\r\n len(self.origdst[col].unique()))\r\n\r\n return kl_dict","def kl_gamma(x, y, a=1):\n x = max(x, eps)\n y = max(y, eps)\n return a*(x/y - 1 - log(x/y))","def kl_loss(y_true, y_pred):\n #y_true = tf.constant(y_true, dtype=tf.dtypes.float64)\n #y_pred = tf.constant(y_pred, dtype=tf.dtypes.float64)\n #y_true = tf.reshape(y_true, shape=[y_true.shape[0], y_true.shape[1] * y_true.shape[2]])\n #y_pred = tf.reshape(y_pred, shape=[y_pred.shape[0], y_pred.shape[1] * y_pred.shape[2]])\n loss = 0\n if y_true.shape[-1] is None:\n return 0.0\n for i in range(y_true.shape[-1]):\n hist_true = np.histogram(y_true[:,i], bins=10, density=True)\n hist_pred = np.histogram(y_pred[:,i], bins=10, density=True)\n loss += kl(hist_true[0], hist_pred[0])\n return loss","def js_divergence(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tz = 0.5 * ( x.flat_cpt() + y.flat_cpt() )\n\tdistance = 0.5 * kl_divergence(x,z) + 0.5 * kl_divergence(y,z)\n\treturn distance","def _kl_divergence(p, p_logits, q):\n for tensor in [p, p_logits, q]:\n if not tensor.dtype.is_floating:\n raise ValueError('Input %s must be floating type.', tensor.name)\n p.shape.assert_has_rank(2)\n p_logits.shape.assert_has_rank(2)\n q.shape.assert_has_rank(1)\n return math_ops.reduce_sum(\n p * (nn_ops.log_softmax(p_logits) - math_ops.log(q)), axis=1)","def kl_divergence(self, params_q, params_p):\n means_q = params_q[:, :, 0]\n log_std_q = params_q[:, :, 1]\n\n means_p = params_p[:, :, 0]\n log_std_p = params_p[:, :, 1]\n\n std_q = torch.exp(log_std_q)\n std_p = torch.exp(log_std_p)\n\n kl_div = log_std_p - log_std_q + (std_q ** 2 + (means_q - means_p) ** 2) / (2.0 * std_p ** 2) - 0.5\n\n return kl_div.sum(dim=-1)","def kl_divergence(self, logits_q, logits_p):\n return (torch.exp(logits_q) * (logits_q - logits_p)).sum(1, keepdim=True)","def kl_neg_bin(x, y, r=1):\n return r*log((r+x)/(r+y)) - x * log(y*(r+x)/(x*(r+y)))","def kl_divergence_symmetric(a, b, lowlim=1e-10):\n return kl_divergence(a, b, lowlim) + kl_divergence(b, a, lowlim)","def kl_dist_smoothing(distribution1: np.array, distribution2: np.array, epsilon: float) -> float:\n # Performs smoothing\n distributions = [distribution1, distribution2]\n smoothed_distributions = []\n for distribution in distributions:\n nonzeros = np.count_nonzero(distribution)\n zeros = len(distribution) - nonzeros\n smoothed_distributions.append([epsilon if prob == 0 else prob - zeros * epsilon / nonzeros\n for prob in distribution])\n\n return sum(kl_div(smoothed_distributions[0], smoothed_distributions[1]))","def kernel_rbf(x, y,gamma):\r\n return np.exp(- gamma * np.linalg.norm(x- y)**2)","def _k_lin_rbf(x, hyp, y=None, diag_only=False):\n prod_rbf_lengthscale = hyp[\"prod.rbf.lengthscale\"]\n prod_rbf_variance = hyp[\"prod.rbf.variance\"]\n prod_linear_variances = hyp[\"prod.linear.variances\"]\n linear_variances = hyp[\"linear.variances\"]\n\n x_rbf = cas_reshape(x[:, 1], (-1, 1))\n y_rbf = y\n if not y is None:\n y_rbf = cas_reshape(y[:, 1], (-1, 1))\n\n k_prod_rbf = _k_rbf(x_rbf, y_rbf, prod_rbf_variance, prod_rbf_lengthscale,\n diag_only)\n\n x_prod_lin = cas_reshape(x[:, 1], (-1, 1))\n y_prod_lin = y\n if not y is None:\n y_prod_lin = cas_reshape(y[:, 1], (-1, 1))\n\n k_prod_lin = _k_lin(x_prod_lin, y_prod_lin, prod_linear_variances, diag_only)\n\n k_linear = _k_lin(x, y, linear_variances, diag_only)\n\n return k_prod_lin * k_prod_rbf + k_linear","def kl(self, other, xs, reversesd=False, **kwargs):\n raise NotImplementedError","def kl_divergence(id1,id2,m1,m2,cache_val_preds,val_dl,device=\"cpu\"):\n if m1 == m2:\n return 0\n \n m1_preds = F.log_softmax(get_preds(m1,val_dl,device),dim=1) if cache_val_preds[id1] == None else cache_val_preds[id1]\n m2_preds = F.log_softmax(get_preds(m2,val_dl,device),dim=1) if cache_val_preds[id2] == None else cache_val_preds[id2]\n\n cache_val_preds[id1] = m1_preds\n cache_val_preds[id2] = m2_preds\n\n print(\"PRED SHAPE:\", m1_preds.shape)\n\n kl_loss = nn.KLDivLoss(reduction=\"batchmean\",log_target=True)\n\n result = kl_loss(m1_preds, m2_preds)\n print(\"\\t\",result,\"dtype:\",result.dtype)\n\n return result","def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\n kl_cost = torch.mean(kl_cost, 0)\n return torch.sum(kl_cost)","def kullback_leibler(p: np.ndarray, q: np.ndarray) -> float:\n kl = 0\n for pi, qi in zip(p, q):\n if pi > 0:\n if qi > 0:\n kl += pi * np.log(pi/qi)\n else:\n kl = np.inf\n return kl","def KernelTest(x, y):\n\n Result = (np.dot(x_test[x, :], x_train[y, :])+1)**5 # Polynomial\n # Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\n # Sum = DotProduct(x, y)\n #Sum = 0.0\n #for i in range(2):\n # Sum = Sum + x_train[x, i]*x_train[y, i]\n # Result = (Sum+1)**5\n \"\"\"\n #Gaussian\n sigma = 1\n if np.ndim(x_test[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\n Result = np.exp(- (np.linalg.norm(x_test[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\n elif (np.ndim(x_test[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_test[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\n Result = np.exp(- (np.linalg.norm(x_test[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\n elif np.ndim(x_test[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\n \"\"\"\n return Result","def klucb(x, d, div, upperbound, lowerbound=-float('inf'), precision=1e-6):\n low = max(x, lowerbound)\n up = upperbound\n while up-low > precision:\n m = (low+up)/2\n if div(x, m) > d:\n up = m\n else:\n low = m\n return (low+up)/2","def fit(self, X: TwoDimArray, y: OneDimArray = None) -> 'KDE':\n\n self.check_params(X)\n\n if self.kde_params is None:\n kde_params = {}\n else:\n kde_params = self.kde_params\n\n self._kde = KernelDensity(**kde_params).fit(X)\n\n self.threshold_ = np.percentile(\n self.anomaly_score(), 100. * (1. - self.contamination)\n )\n\n return self","def calculate_kld(p, q, limits, dx=0.01):\n if p.shape != q.shape:\n raise ValueError('Cannot calculate KLD between two ensembles with different shapes')\n\n # Make a grid from the limits and resolution\n grid = _calculate_grid_parameters(limits, dx)\n\n # Evaluate the functions on the grid and normalize\n pe = p.gridded(grid.grid_values)\n pn = pe[1]\n qe = q.gridded(grid.grid_values)\n qn = qe[1]\n\n # Calculate the KLD from q to p\n Dpq = array_metrics.quick_kld(pn, qn, grid.resolution)# np.dot(pn * logquotient, np.ones(len(grid)) * dx)\n\n if np.any(Dpq < 0.): #pragma: no cover\n print('broken KLD: '+str((Dpq, pn, qn, grid.resolution)))\n Dpq = epsilon*np.ones(Dpq.shape)\n return Dpq","def kl_dirichlet(alpha, beta):\n alpha_0 = torch.sum(alpha, dim=-1, keepdim=True)\n beta_0 = torch.sum(beta, dim=-1, keepdim=True)\n t1 = torch.lgamma(alpha_0) - torch.sum(torch.lgamma(alpha), dim=-1, keepdim=True)\n t2 = torch.lgamma(beta_0) - torch.sum(torch.lgamma(beta), dim=-1, keepdim=True)\n t3 = torch.sum((alpha - beta) * (torch.digamma(alpha) - torch.digamma(alpha_0)), dim=-1, keepdim=True)\n return t1 - t2 + t3","def kl_divergence_fn(\n args: StepFunctionArgs,\n contrast_sources: Optional[FeatureAttributionInput] = None,\n contrast_target_prefixes: Optional[FeatureAttributionInput] = None,\n contrast_targets: Optional[FeatureAttributionInput] = None,\n contrast_targets_alignments: Optional[List[List[Tuple[int, int]]]] = None,\n top_k: int = 0,\n top_p: float = 1.0,\n min_tokens_to_keep: int = 1,\n) -> SingleScorePerStepTensor:\n\n original_logits: torch.Tensor = args.attribution_model.output2logits(args.forward_output)\n contrast_output = _get_contrast_output(\n args=args,\n contrast_sources=contrast_sources,\n contrast_targets=contrast_targets,\n contrast_target_prefixes=contrast_target_prefixes,\n contrast_targets_alignments=contrast_targets_alignments,\n return_contrastive_target_ids=False,\n )\n contrast_logits: torch.Tensor = args.attribution_model.output2logits(contrast_output)\n return logits_kl_divergence(\n original_logits=original_logits,\n contrast_logits=contrast_logits,\n top_p=top_p,\n top_k=top_k,\n min_tokens_to_keep=min_tokens_to_keep,\n )","def kernel_regression_h(x, y, silverman=False):\n xx = np.array(x)\n yy = np.array(y)\n # Check input\n assert xx.shape[0] == yy.size, (\n f'size(x, 0) != size(y): {xx.shape[0]} != {yy.size}' )\n if xx.ndim == 1: # deal with 1d-arrays\n xx = xx[:, np.newaxis]\n n = xx.shape[0]\n d = xx.shape[1]\n\n # Silverman (1986), Scott (1992), Bowman and Azzalini (1997)\n # Very similar to stats.gaussian_kde\n # h has dimension d\n h = ( (4. / float(d + 2) / float(n))**(1. / float(d + 4)) *\n np.std(xx, axis=0, ddof=1) )\n\n if not silverman:\n # Find the optimal h\n bounds = [(0.2*i, 5.0*i) for i in h]\n if n <= 100:\n res = opt.minimize(\n _cross_valid_h, h, args=(xx, yy), method='TNC', bounds=bounds,\n options={'ftol': 1e-10, 'xtol': 1e-10, 'maxfun': 1000})\n h = res.x\n else:\n res = opt.minimize(\n _boot_h, h, args=(xx, yy), method='TNC', bounds=bounds,\n options={'ftol': 1e-10, 'xtol': 1e-10, 'maxfun': 1000})\n h = res.x\n\n if len(h) == 1:\n h = h[0]\n\n return h","def hellinger(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tdistance = ( 1 / np.sqrt( 2 ) ) * np.sqrt( np.sum( ( np.sqrt( x.flat_cpt() ) - np.sqrt( y.flat_cpt() ) )**2) )\n\treturn distance","def kld(cls,\n y_true,\n y_pred):\n y_pred /= np.sum(y_pred)\n y_true = np.clip(y_true, cls.eps, 1)\n y_pred = np.clip(y_pred, cls.eps, 1)\n print(y_pred)\n print(y_true)\n print(y_true * np.log(y_true / y_pred))\n _kld = np.sum(y_true * np.log(y_true / y_pred), axis=-1)\n print('KLD: ' + str(_kld))\n return _kld","def get_Kl_divergence(model1, model2, collection, lam, missing_val = 0.0001):\n smoot_m2 = {key: (1-lam)*model2.get(key, 0) + lam*collection.get(key, missing_val) for key in model1}\n\n divergence = sum([model1[key]*math.log(model1[key]/smoot_m2[key]) for key in model1])\n return divergence","def train(self, X, y):\n m = X.shape[0]\n D = np.empty(m)\n D.fill(1/(m*1.0))\n\n hs = 0\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n eps = 0\n\n for j in range(m): \n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\n eps+=D[j]\n\n self.w[t] =0.5*math.log((1/eps)-1)\n\n Dtmp = []\n for j in range(m):\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\n\n Dtmp = np.array(Dtmp) \n s = np.sum(Dtmp)\n\n for i in range(m):\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s","def train_LVQ2(self, x, y):\n while self.epsilon >= 0.01:\n rnd_i = np.random.randint(0, len(x))\n rnd_s = x[rnd_i]\n target_y = y[rnd_i]\n \n self.epsilon = self.epsilon - self.epsilon_dec_factor\n \n closest_pvector = self.find_closest(rnd_s)[1]\n second_closest_pvector = self.find_runnerup(rnd_s)\n compare_distance = np.linalg.norm(closest_pvector.p_vector - rnd_s)/np.linalg.norm(second_closest_pvector.p_vector - rnd_s)\n \n if target_y == second_closest_pvector.class_id and target_y != closest_pvector.class_id and compare_distance > 0.8 and compare_distance < 1.2:\n closest_pvector.update(rnd_s, False)\n second_closest_pvector.update(rnd_s)\n elif target_y == closest_pvector.class_id:\n closest_pvector.update(rnd_s)\n elif target_y != closest_pvector.class_id:\n closest_pvector.update(rnd_s, False)\n closest_pvector.epsilon = self.epsilon\n return self.p_vectors","def kl_divergence(a, b, lowlim=1e-10):\n mask = np.logical_and(b > lowlim, a > lowlim)\n return np.sum(a[mask] * np.log(a[mask] / b[mask]))","def bhhh_internal(\n criterion_and_derivative,\n x,\n convergence_absolute_gradient_tolerance,\n stopping_max_iterations,\n):\n criterion_accepted, gradient = criterion_and_derivative(x)\n x_accepted = x\n\n hessian_approx = np.dot(gradient.T, gradient)\n gradient_sum = np.sum(gradient, axis=0)\n direction = np.linalg.solve(hessian_approx, gradient_sum)\n gtol = np.dot(gradient_sum, direction)\n\n initial_step_size = 1\n step_size = initial_step_size\n\n niter = 1\n while niter < stopping_max_iterations:\n niter += 1\n\n x_candidate = x_accepted + step_size * direction\n criterion_candidate, gradient = criterion_and_derivative(x_candidate)\n\n # If previous step was accepted\n if step_size == initial_step_size:\n hessian_approx = np.dot(gradient.T, gradient)\n\n else:\n criterion_candidate, gradient = criterion_and_derivative(x_candidate)\n\n # Line search\n if np.sum(criterion_candidate) > np.sum(criterion_accepted):\n step_size /= 2\n\n if step_size <= 0.01:\n # Accept step\n x_accepted = x_candidate\n criterion_accepted = criterion_candidate\n\n # Reset step size\n step_size = initial_step_size\n\n # If decrease in likelihood, calculate new direction vector\n else:\n # Accept step\n x_accepted = x_candidate\n criterion_accepted = criterion_candidate\n\n gradient_sum = np.sum(gradient, axis=0)\n direction = np.linalg.solve(hessian_approx, gradient_sum)\n gtol = np.dot(gradient_sum, direction)\n\n if gtol < 0:\n hessian_approx = np.dot(gradient.T, gradient)\n direction = np.linalg.solve(hessian_approx, gradient_sum)\n\n # Reset stepsize\n step_size = initial_step_size\n\n if gtol < convergence_absolute_gradient_tolerance:\n break\n\n result_dict = {\n \"solution_x\": x_accepted,\n \"solution_criterion\": criterion_accepted,\n \"n_iterations\": niter,\n \"message\": \"Under develpment\",\n }\n\n return result_dict","def my_kernel(X, Y):\n S = 0.84 # parameter from rhos\n\n if dset == 1:\n gamma = 0.0005\n else:\n gamma = 0.00087 # maximise variance of kernel matrix\n if np.array_equal(X, Y):\n N = X.shape[0]\n M = (1 - S) * np.ones((N, N)) + S * np.eye(N)\n else:\n M = 1\n\n pairwise_sq_dists = cdist(X, Y, 'sqeuclidean')\n K = exp(-gamma * pairwise_sq_dists) * M\n return K","def _kernel(self, x1, x2, beta=1):\n d = (x1 - x2)**2\n return np.exp(-beta * d)","def test_KL_divergence(generator, noise_dim, code_dim, validation_kernels, val_codes, training_noise_dict, n_samples_per_axis=40, n_axis=1):\r\n total_KL = 0\r\n for code in validation_kernels:\r\n print(code)\r\n fakes = generate_fake_samples_constant_code(generator, code_dim, noise_dim, code, n_samples_per_axis**n_axis, val_codes, training_noise_dict)\r\n print(\"Fake generation complete\")\r\n fakes_kernel = KernelDensity(kernel='gaussian', bandwidth=KD_BANDWIDTH).fit(fakes)\r\n print(\"Kernel complete\")\r\n total_KL += kl_divergence(validation_kernels[code], fakes_kernel, n_samples_per_axis, n_axis)\r\n return total_KL","def LD(x, y, lodict={}):\n return needleman_wunsch(x, y, lodict=lodict, gop=-1, gep=-1)","def calculate_convergence(v1, v2):\r\n\r\n return norm(v2 - v1, ord=1)","def compute_kl(self, df):\n value_counts = [df[col].value_counts() for col in self.hist_cols]\n next_hists = self.value_counts_to_hists(value_counts)\n\n if self.prev_hists is None:\n self.prev_hists = next_hists\n return None\n\n output = []\n for prev_h, curr_h in zip(self.prev_hists, next_hists):\n for i in range(len(prev_h)):\n prev_h[i] = prev_h[i] if prev_h[i] != 0 else 1\n curr_h[i] = curr_h[i] if curr_h[i] != 0 else 1\n kl = entropy(prev_h, curr_h)\n output.append(kl)\n\n self.prev_hists = next_hists\n return output","def d_bernoulli_kullback_leibler_dq(p: float, q: float) -> float:\n return (1 - p) / (1 - q) - p/q","def add_kl_loss(self, posterior_dist, prior_dist):\n if self.kl_use_exact:\n self.add_loss(\n kl_lib.kl_divergence(\n posterior_dist, prior_dist\n ) * self.kl_weight * self.kl_anneal\n )\n else:\n self.add_loss(\n self._kl_approximation(\n posterior_dist, prior_dist\n ) * self.kl_weight * self.kl_anneal\n )","def kl(mu1, mu2):\n return (mu2-mu1)**2/2","def kl(mu1, mu2):\n return (mu2-mu1)**2/2","def JS_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\n if data_range is None:\n data_range = list(set(xs)) + list(set(ys))\n if pdf_x is None:\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\n if pdf_y is None:\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\n M = {}\n for i in pdf_x:\n if i not in pdf_y:\n pdf_y[i] = 0.0\n for i in pdf_y:\n if i not in pdf_x:\n pdf_y[i] = 0.0\n for i in pdf_x:\n M[i] = .5*(pdf_x[i] + pdf_y[i])\n return .5*KL_divergence(None,\n None,\n pdf_x=pdf_x,\n pdf_y=M,\n data_range=data_range) + \\\n .5*KL_divergence(None,\n None,\n pdf_x=pdf_y,\n pdf_y=M,\n data_range=data_range)","def lkendalltau(x,y):\r\n n1 = 0\r\n n2 = 0\r\n iss = 0\r\n for j in range(len(x)-1):\r\n for k in range(j,len(y)):\r\n a1 = x[j] - x[k]\r\n a2 = y[j] - y[k]\r\n aa = a1 * a2\r\n if (aa): # neither list has a tie\r\n n1 = n1 + 1\r\n n2 = n2 + 1\r\n if aa > 0:\r\n iss = iss + 1\r\n else:\r\n iss = iss -1\r\n else:\r\n if (a1):\r\n n1 = n1 + 1\r\n else:\r\n n2 = n2 + 1\r\n tau = iss / math.sqrt(n1*n2)\r\n svar = (4.0*len(x)+10.0) / (9.0*len(x)*(len(x)-1))\r\n z = tau / math.sqrt(svar)\r\n prob = erfcc(abs(z)/1.4142136)\r\n return tau, prob","def compute_kl(mu1, mu2, sigma1, sigma2):\n k = len(mu1)\n try:\n term1 = np.trace(np.matmul(np.linalg.inv(sigma2), sigma1))\n term2 = np.matmul(np.matmul((mu2 - mu1).T,\n np.linalg.inv(sigma2)),\n (mu2 - mu1))\n det_sigma1 = compute_determinant(sigma1)\n det_sigma2 = compute_determinant(sigma2)\n # term3 = np.log(np.linalg.det(sigma2)/np.linalg.det(sigma1))\n term3 = np.log(det_sigma2)\n term4 = np.log(det_sigma1)\n kl = (term1 + term2 - k + term3 - term4)/2.\n return kl\n except np.linalg.LinAlgError:\n return np.nan","def kl(mu1, mu2):\n return (mu2 - mu1) ** 2 / 2","def d2_bin(self, x, y):\n \n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\n KD.fit(np.column_stack((x,y)))\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\n mesh = np.meshgrid(grid1,grid2)\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\n samp = KD.score_samples(data)\n samp = samp.reshape(self.bins,self.bins)\n p = np.exp(samp)/np.sum(np.exp(samp))\n\n return p","def lpointbiserialr(x,y):\r\n TINY = 1e-30\r\n if len(x) <> len(y):\r\n raise ValueError, 'INPUT VALUES NOT PAIRED IN pointbiserialr. ABORTING.'\r\n data = pstats.abut(x,y)\r\n categories = pstats.unique(x)\r\n if len(categories) <> 2:\r\n raise ValueError, \"Exactly 2 categories required for pointbiserialr().\"\r\n else: # there are 2 categories, continue\r\n codemap = pstats.abut(categories,range(2))\r\n recoded = pstats.recode(data,codemap,0)\r\n x = pstats.linexand(data,0,categories[0])\r\n y = pstats.linexand(data,0,categories[1])\r\n xmean = mean(pstats.colex(x,1))\r\n ymean = mean(pstats.colex(y,1))\r\n n = len(data)\r\n adjust = math.sqrt((len(x)/float(n))*(len(y)/float(n)))\r\n rpb = (ymean - xmean)/samplestdev(pstats.colex(data,1))*adjust\r\n df = n-2\r\n t = rpb*math.sqrt(df/((1.0-rpb+TINY)*(1.0+rpb+TINY)))\r\n prob = betai(0.5*df,0.5,df/(df+t*t)) # t already a float\r\n return rpb, prob","def klucb_bern(x, d, precision=1e-6):\n upperbound = min(1., klucb_gauss(x, d))\n return klucb(x, d, kl_bern, upperbound, precision)","def bernoulli_kullback_leibler(p: float, q: float) -> float:\n kl1, kl2 = 0, np.infty\n if p > 0:\n if q > 0:\n kl1 = p*np.log(p/q)\n\n if q < 1:\n if p < 1:\n kl2 = (1 - p) * np.log((1 - p) / (1 - q))\n else:\n kl2 = 0\n return kl1 + kl2","def KL_divergence(value_counts1, value_counts2):\n divergence = 0\n s1 = sum([value_counts1[value] for value in value_counts1])\n s2 = sum([value_counts2[value] for value in value_counts2])\n for value in set(value_counts1).union(value_counts2):\n assert(value in value_counts1 or value in value_counts2)\n if value not in value_counts1:\n s1 += KL_SMOOTHING\n if value not in value_counts2:\n s2 += KL_SMOOTHING\n for value in set(value_counts1).union(value_counts2):\n v1 = v2 = KL_SMOOTHING\n if value in value_counts1:\n v1 = value_counts1[value]\n if value in value_counts2:\n v2 = value_counts2[value]\n v1 = float(v1) / s1\n v2 = float(v2) / s2\n divergence += v1 * math.log(v1 / v2)\n if divergence > math.e:\n divergence = math.e\n return divergence","def k(xs, ys, sigma=1, l=1):\n\n # Pairwise difference matrix.\n dx = np.expand_dims(xs, 1) - np.expand_dims(ys, 0)\n return (sigma ** 2) * np.exp(-((dx / l) ** 2) / 2)","def distorted_data(X_train,y_train,X_test,y_test,dialation=10.):\n\n t,l1 = regularized_grad_descent(X_train,y_train,lambda_reg=1e-6)\n\n X_train[:,0] *= dialation\n X_test[:,0] *= dialation\n \n t,l2 = regularized_grad_descent(X_train,y_train,lambda_reg=1e-6)\n\n plt.plot(np.log(l1),'b--')\n plt.plot(np.log(l2),'r--')\n plt.show()\n plt.close()","def KL(P,Q):\n epsilon = 0.00001\n \n #You may want to instead make copies to avoid changing the np arrays.\n P = P+epsilon\n Q = Q+epsilon\n \n divergence = np.sum(P*np.log(P/Q))\n return divergence","def kl(\n self,\n x: Tensor,\n covariates: Tensor,\n use_temp: bool,\n ) -> Tuple[Tensor, Tensor]:\n log_probs, ldj_sum, _ = self.compute_probabilities(x, covariates, use_temp)\n\n return -(torch.logsumexp(log_probs, dim=1) + ldj_sum).mean()","def kl(self, old_dist_info, new_dist_info):\n old_prob = old_dist_info[\"prob\"]\n new_prob = new_dist_info[\"prob\"]\n return np.sum(\n old_prob * (np.log(old_prob + TINY) - np.log(new_prob + TINY)),\n axis=2\n )","def kde_2d_multiple_times(plume_x, plume_y, X, Y):\n Z = []\n positions = np.vstack([X.ravel(), Y.ravel()])\n for i in range(len(plume_x)):\n values = np.vstack([plume_x[i], plume_y[i]])\n kernel = stats.gaussian_kde(values)\n Z.append(np.reshape(kernel(positions).T, X.shape))\n return Z","def kde_scipy(x, x_grid, bandwidth=0.2, **kwargs):\n # Note that scipy weights its bandwidth by the covariance of the\n # input data. To make the results comparable to the other methods,\n # we divide the bandwidth by the sample standard deviation here.\n #kde = gaussian_kde(x, bw_method=bandwidth / x.std(ddof=1), **kwargs)\n kde = gaussian_kde(x)\n return kde.evaluate(x_grid)","def hellinger_distance(x, y):\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\n x.dtype == np.float32 and y.dtype == np.float32)\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n x = np.sqrt(x)\n y = np.sqrt(y)\n # x (120, 40), y (100, 40), H(x,y) (120, 100)\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\n yy = np.tile(y, (x.shape[0], 1, 1))\n xx_yy = xx - yy\n res = np.sqrt(np.sum(xx_yy ** 2, axis=-1))\n return np.float64((1. / np.sqrt(2)) * res)"],"string":"[\n \"def kl_bern(x, y):\\n x = min(max(x, eps), 1-eps)\\n y = min(max(y, eps), 1-eps)\\n return x*log(x/y) + (1-x)*log((1-x)/(1-y))\",\n \"def kl_divergence(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tdistance = np.sum( x.flat_cpt() * np.log( x.flat_cpt() / y.flat_cpt() ) )\\n\\treturn distance\",\n \"def kl_divergence(x, y, thresholded=True, symmetrized=True, normalize=True):\\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\\n x.dtype == np.float32 and y.dtype == np.float32)\\n # assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\\n if thresholded:\\n normalize = True\\n if normalize:\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n if thresholded:\\n eps = np.finfo(x.dtype).eps\\n x = x + eps\\n y = y + eps\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n res = __kl_divergence(x, y)\\n\\n if symmetrized:\\n res = 0.5 * res + 0.5 * __kl_divergence(y, x).transpose()\\n\\n return np.float64(res).reshape(res.shape)\",\n \"def kullback_leibler_divergence_loss(self, y_true=None, y_pred=None, decimal=5, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data2(y_true, y_pred, decimal)\\n y_pred = np.clip(y_pred, self.EPSILON, 1 - self.EPSILON) # Clip predicted probabilities\\n if binary:\\n y_true = np.clip(y_true, self.EPSILON, 1 - self.EPSILON) # Clip true labels\\n res = y_true * np.log(y_true / y_pred) + (1 - y_true) * np.log((1 - y_true) / (1 - y_pred))\\n res = np.mean(res)\\n else:\\n # Convert y_true to one-hot encoded array\\n num_classes = len(np.unique(y_true))\\n y_true = np.eye(num_classes)[y_true]\\n y_true = np.clip(y_true, self.EPSILON, 1 - self.EPSILON) # Clip true labels\\n res = np.sum(y_true * np.log(y_true / y_pred), axis=1)\\n res = np.mean(res)\\n return np.round(res, decimal)\",\n \"def kl_divergence(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n y_true = backend.clip(y_true, backend.epsilon(), 1)\\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)\",\n \"def kl_divergence(p_dist, q_dist, n_samples_per_axis=30, n_axis=2):\\r\\n global COUNTER\\r\\n if n_axis == 2:\\r\\n x = np.linspace(-1.0, 1.0, n_samples_per_axis)\\r\\n y = np.linspace(-1.0, 1.0, n_samples_per_axis)\\r\\n grids = np.meshgrid(x, y)\\r\\n elif n_axis == 3:\\r\\n x = np.linspace(-1.0, 1.0, n_samples_per_axis)\\r\\n y = np.linspace(-1.0, 1.0, n_samples_per_axis)\\r\\n z = np.linspace(-1.0, 1.0, n_samples_per_axis)\\r\\n grids = np.meshgrid(x, y, z)\\r\\n elif n_axis == 1:\\r\\n grids = np.linspace(-1.1, 1.1, 120)\\r\\n print(\\\"Grid complete!\\\")\\r\\n if n_axis != 1:\\r\\n grid = np.vstack(grids).reshape((n_axis, n_samples_per_axis**n_axis)).T\\r\\n else:\\r\\n grid = grids\\r\\n grid = np.reshape(grid, (grid.shape[0], 1))\\r\\n probs_p = np.exp(p_dist.score_samples(grid))\\r\\n probs_q = np.exp(q_dist.score_samples(grid))\\r\\n print(\\\"prob_calc_complete\\\")\\r\\n kl = entropy(probs_p, probs_q)\\r\\n return kl\",\n \"def kl_divergence_from_logits(self, logits_a, logits_b):\\n distribution1 = tf.contrib.distributions.Categorical(logits=logits_a)\\n distribution2 = tf.contrib.distributions.Categorical(logits=logits_b)\\n return tf.contrib.distributions.kl_divergence(distribution1, distribution2)\",\n \"def KL_divergence(model_1, model_2, samples):\\n posterior_1 = create_posterior_object(model_1, samples)\\n posterior_2 = create_posterior_object(model_2, samples)\\n return posterior_1.KL(posterior_2)\",\n \"def KL_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\\n if data_range is None:\\n data_range = list(set(xs)) + list(set(ys))\\n if pdf_x is None:\\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\\n if pdf_y is None:\\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\\n keys = set(pdf_x.keys()+pdf_y.keys())\\n PQ = []\\n for k in keys:\\n if k in pdf_x and k in pdf_y:\\n PQ.append((pdf_x[k],pdf_y[k]))\\n return np.sum([p*np.log(float(p)/float(q)) for (p,q) in PQ if q>0 and p>0])\",\n \"def _graph_fn_kl_divergence(distribution_a, distribution_b):\\n if get_backend() == \\\"tf\\\":\\n return tf.no_op()\\n # TODO: never tested. tf throws error: NotImplementedError: No KL(distribution_a || distribution_b) registered for distribution_a type Bernoulli and distribution_b type ndarray\\n #return tf.distributions.kl_divergence(\\n # distribution_a=distribution_a,\\n # distribution_b=distribution_b,\\n # allow_nan_stats=True,\\n # name=None\\n #)\",\n \"def __init__(self, name='backward_kl_divergence', **kwargs):\\n\\n super(BackwardKLDivergence, self).__init__(name=name, **kwargs)\\n\\n return\",\n \"def test_divergences_to_kl2(dists, divergence):\\n for dist1, dist2 in combinations(dists, 2):\\n assert divergence(dist1, dist2, alpha=1) == pytest.approx(kullback_leibler_divergence(dist1, dist2))\",\n \"def get_KL_divergence(self):\\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\\n KL_loss_b = 0\\n if self.bias is not None:\\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\\n \\n KL_loss = KL_loss_W + KL_loss_b\\n \\n return KL_loss\",\n \"def elbo(self, x, y):\\n self.forward(x, y)\\n\\n # prior-posterior divergence\\n kl_loss = kl.kl_divergence(\\n self.prior_latent_distribution, self.posterior_latent_distribution).mean()\\n\\n # reconstruction loss\\n if not self.training:\\n # resample output based on prior, not posterior\\n self.forward(x)\\n reconstruction_loss = self.recon_loss_fun(self.y_hat_raw, y[:, 0])\\n\\n # training loss\\n loss = reconstruction_loss + self.beta * kl_loss\\n\\n # statictics about prior and posterior\\n mu_prior = self.prior_latent_distribution.mean\\n mu_posterior = self.posterior_latent_distribution.mean\\n mu_dist = torch.norm(mu_prior - mu_posterior, dim=-1).mean()\\n std_prior = self.prior_latent_distribution.stddev\\n std_prior = torch.norm(std_prior - mu_posterior, dim=-1).mean()\\n std_posterior = self.posterior_latent_distribution.stddev\\n std_posterior = torch.norm(std_posterior - mu_posterior, dim=-1).mean()\\n\\n return loss, reconstruction_loss, kl_loss, mu_dist, std_prior, std_posterior\",\n \"def kl_divergence(a, b, normalize=True):\\n a, b = np.array(a), np.array(b)\\n\\n x = np.linspace(\\n min(a.min(), b.min()) - 1,\\n max(a.max(), b.max()) + 1,\\n 100\\n )\\n\\n p = gaussian_kde(a)(x)\\n q = gaussian_kde(b)(x)\\n\\n if normalize:\\n p = p/np.sum(p)\\n q = q/np.sum(q)\\n\\n return np.sum(np.where(p != 0, (p) * np.log(p / q), 0))\",\n \"def kde2D(x, y, bandwidth, xbins=100j, ybins=100j, **kwargs):\\n\\n # create grid of sample locations (default: 100x100)\\n xx, yy = np.mgrid[x.min():x.max():xbins, \\n y.min():y.max():ybins]\\n\\n xy_sample = np.vstack([yy.ravel(), xx.ravel()]).T\\n xy_train = np.vstack([y, x]).T\\n\\n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\\n kde_skl.fit(xy_train)\\n\\n # score_samples() returns the log-likelihood of the samples\\n z = np.exp(kde_skl.score_samples(xy_sample))\\n return xx, yy, np.reshape(z, xx.shape)\",\n \"def zkl_divergence(x, y, gamma):\\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])\",\n \"def find_knee(x,y):\\n\\n # find ranges\\n if len(x) != len(y):\\n raise Exception(\\\"bad data\\\")\\n tot_len = len(x)\\n \\n \\n \\n # fit strait lines to both\\n\\n # find intercept\\n knee_r = (f_top.beta[1] - f_bottom.beta[1])/(-f_top.beta[0] + f_bottom.beta[0])\",\n \"def kl_gauss(x, y, sig2=1.):\\n return (x - y) ** 2 / (2 * sig2)\",\n \"def kl_div_prior_gradient(self, posterior_logits, posterior_binary_samples):\\n #DVAE Eq11 - gradient of prior\\n #gradient of the KLD between posterior and prior wrt to prior\\n #parameters theta, i.e. generative model parameters.\\n #logits to probabilities\\n posterior_probs=torch.sigmoid(posterior_logits)\\n positive_probs=posterior_probs.detach()\\n \\n #samples from posterior are labelled positive\\n positive_samples=posterior_binary_samples.detach()\\n\\n n_split=positive_samples.size()[1]//2\\n positive_samples_left,positive_samples_right=torch.split(positive_samples,split_size_or_sections=int(n_split),dim=1)\\n \\n #-z_left^t J z_right\\n pos_first_term=torch.matmul(positive_samples_left,self.prior.get_weights())*positive_samples_right\\n \\n rbm_bias_left=self.prior.get_visible_bias()\\n rbm_bias_right=self.prior.get_hidden_bias()\\n rbm_bias=torch.cat([rbm_bias_left,rbm_bias_right])#self._h\\n \\n #this gives [42,400] size\\n #- z^t h\\n #TODO this uses positive probs. Should it not use positive samples?\\n # FIXME an indication are the negative ones where samples are used! On\\n #other hand this is the only place this this used\\n pos_sec_term=positive_probs*rbm_bias\\n # pos_sec_term=positive_samples*rbm_bias\\n\\n # Energy = -z_left^t J z_right - z^t h\\n pos_kld_per_sample=-(torch.sum(pos_first_term,axis=1)+torch.sum(pos_sec_term,axis=1))\\n #samples from rbm are labelled negative\\n\\n #rbm_samples Tensor(\\\"zeros:0\\\", shape=(200, 200), dtype=float32)\\n #this returns the full RBM set: left and right nodes concatenated\\n\\n #TODO What are these samples here?\\n #TODO what's the impact of doing gibbs sampling here? does this make\\n #sense?\\n rbm_samples=self.prior.get_samples_kld(approx_post_samples=positive_samples_left,n_gibbs_sampling_steps=1)\\n negative_samples=rbm_samples.detach()\\n\\n # print(self.prior.get_weights())\\n n_split=negative_samples.size()[1]//2\\n negative_samples_left,negative_samples_right=torch.split(negative_samples,split_size_or_sections=int(n_split),dim=1)\\n neg_first_term=torch.matmul(negative_samples_left,self.prior.get_weights())*negative_samples_right\\n \\n #FIXME see above, the positive case looks different. Why?\\n neg_sec_term=negative_samples*rbm_bias\\n neg_kld_per_sample=(torch.sum(neg_first_term,axis=1)+torch.sum(neg_sec_term,axis=1))\\n \\n kld_per_sample=pos_kld_per_sample+neg_kld_per_sample\\n\\n return kld_per_sample\",\n \"def kl_divergence(self, samples):\\n # Check size of input\\n if not len(samples.shape) == 2:\\n raise ValueError('Given samples list must be n x 2.')\\n if samples.shape[1] != self._n_parameters:\\n raise ValueError(\\n 'Given samples must have length ' + str(self._n_parameters))\\n\\n best_mode = np.zeros(samples.shape[0])\\n for i in range(samples.shape[0]):\\n a_sample = samples[i, :]\\n a_log_pdf = -np.inf\\n a_max_index = -1\\n for j, var in enumerate(self._vars):\\n a_test_log_pdf = var.logpdf(a_sample)\\n if a_test_log_pdf > a_log_pdf:\\n a_log_pdf = a_test_log_pdf\\n a_max_index = j\\n best_mode[i] = a_max_index\\n\\n kl = np.zeros(len(self._vars))\\n for i in range(len(self._vars)):\\n y = np.array(samples[best_mode == i, :], copy=True)\\n # when a mode has no points use all samples\\n if y.shape[0] == 0:\\n y = np.array(samples, copy=True)\\n m0 = np.mean(y, axis=0)\\n s0 = np.cov(y.T)\\n s1 = self._covs[i]\\n m1 = self._modes[i]\\n s1_inv = np.linalg.inv(s1)\\n if len(np.atleast_1d(s0)) > 1:\\n kl[i] = 0.5 * (\\n np.trace(np.matmul(s1_inv, s0)) +\\n np.matmul(np.matmul(m1 - m0, s1_inv), m1 - m0) -\\n np.log(np.linalg.det(s0)) +\\n np.log(np.linalg.det(s1)) -\\n self._n_parameters)\\n else:\\n kl[i] = 0.5 * (\\n np.sum(s1_inv * s0) +\\n (m1 - m0) * s1_inv * (m1 - m0) -\\n np.log(s0) +\\n np.log(s1) -\\n 1)\\n return kl\",\n \"def kl_divergence(dist1, dist2, symmetrized=True):\\n if symmetrized == True:\\n kl = (\\n scipy.stats.entropy(dist1, dist2) + scipy.stats.entropy(dist2, dist1)\\n ) / 2.0\\n return kl\\n else:\\n kl = scipy.stats.entropy(dist1, dist2)\\n return kl\",\n \"def MyKLD(X,Y): \\n mu1,mu2 = tuple(np.mean(X,axis=0))\\n sigma1,sigma2 = tuple(np.std(X,axis=0))\\n m1,m2 = tuple(np.mean(X,axis=0))\\n s1,s2 = tuple(np.std(X,axis=0))\\n rho = np.corrcoef(X,rowvar=False)[0,1]\\n r = np.corrcoef(Y,rowvar=False)[0,1]\\n \\n return (\\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\\n (2 * (1 - r**2)) +\\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \\n (sigma2**2-s2**2)/s2**2) /\\n (2 * (1 - r**2)) +\\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\\n )\",\n \"def kl_divergence(self) -> Tensor:\\n return torch.tensor(0.0)\",\n \"def maxkl_strategy(self):\\n # TODO: rewrite to update only distribution from sampled bucket\\n # Instead of computing everything again every iteration\\n\\n # Label model distributions\\n lm_posteriors = self.bucket_probs.clip(1e-5, 1-1e-5)\\n\\n # Sample distributions\\n # D_KL(LM distribution||Sample distribution)\\n rel_entropy = np.zeros(len(lm_posteriors))\\n sample_posteriors = np.zeros(lm_posteriors.shape)\\n\\n # Iterate over buckets\\n for i in range(len(lm_posteriors)):\\n # Collect points in bucket\\n bucket_items = self.ground_truth_labels[np.where(self.unique_inverse == i)[0]]\\n # Collect labeled points in bucket\\n bucket_gt = list(bucket_items[bucket_items != -1])\\n # Add initial labeled point\\n if not bucket_gt:\\n bucket_gt.append(\\n int(np.round(\\n self.probs[\\\"bucket_labels_train\\\"][0][i].clip(0, 1)\\n )))\\n bucket_gt = np.array(bucket_gt)\\n\\n # Bucket distribution, clip to avoid D_KL undefined\\n eps = 1e-2 / (len(bucket_gt))\\n sample_posteriors[i, 1] = bucket_gt.mean().clip(eps, 1 - eps)\\n sample_posteriors[i, 0] = 1 - sample_posteriors[i, 1]\\n\\n # KL divergence\\n rel_entropy[i] = entropy(lm_posteriors[i, :], sample_posteriors[i, :])\\n self.bucket_values = rel_entropy\\n\\n # Select buckets with highest KL divergence\\n return np.where(\\n np.logical_and(\\n rel_entropy == np.max(rel_entropy[self.is_valid_bucket]), self.is_valid_bucket\\n )\\n )[0]\",\n \"def test_divergences_to_kl(dists):\\n for dist1, dist2 in combinations(dists, 2):\\n assert alpha_divergence(dist1, dist2, alpha=-1) == pytest.approx(kullback_leibler_divergence(dist2, dist1))\\n\\n assert alpha_divergence(dist1, dist2, alpha=0) != pytest.approx(kullback_leibler_divergence(dist2, dist1))\\n assert alpha_divergence(dist1, dist2, alpha=2) != pytest.approx(kullback_leibler_divergence(dist2, dist1))\",\n \"def Kernel(x, y):\\n\\n Result = (np.dot(x_train[x, :], x_train[y, :])+1)**5 # Polynomial\\n #Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\\n #Gaussian\\n \\\"\\\"\\\"\\n sigma = 1\\n if np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\\n elif (np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\\n elif np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\\n \\\"\\\"\\\"\\n return Result\",\n \"def kl_poisson(x, y):\\n x = max(x, eps)\\n y = max(y, eps)\\n return y-x+x*log(x/y)\",\n \"def test_kl_divergence(get_distributions):\\n for i, dist_a in enumerate(get_distributions):\\n for j, dist_b in enumerate(get_distributions):\\n kl = kl_divergence(dist_a, dist_b)\\n if i == j:\\n assert pytest.approx(kl, 0.0001) == 0.0\\n else:\\n assert kl > 0\",\n \"def kl_divergence(self) -> Tensor:\\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()\",\n \"def kl_divergence(self):\\n return self._kl_divergence_func\",\n \"def kullback_leibler_divergence(p, q):\\n null = 1e-10\\n return sum(p.get(key, null) * math.log(p.get(key, null) / q.get(key, null))\\n for key in set(chain(p.keys(), q.keys())))\",\n \"def kl_divergence_bern_bern(z_pres_logits, prior_pres_prob, eps=1e-15):\\n z_pres_probs = torch.sigmoid(z_pres_logits)\\n kl = z_pres_probs * (torch.log(z_pres_probs + eps) - torch.log(prior_pres_prob + eps)) + \\\\\\n (1 - z_pres_probs) * (torch.log(1 - z_pres_probs + eps) - torch.log(1 - prior_pres_prob + eps))\\n\\n return kl\",\n \"def kl_div_posterior_gradient(self, posterior_logits, posterior_binary_samples):\\n #DVAE Eq12\\n #gradient of the KLD between posterior and prior wrt to posterior\\n #parameters phi\\n \\n logger.debug(\\\"kl_div_posterior_gradient\\\")\\n posterior_upper_bound = 0.999*torch.ones_like(posterior_logits)\\n #logits to probabilities\\n posterior_probs=torch.min(posterior_upper_bound, torch.sigmoid(posterior_logits))\\n \\n n_split=int(posterior_binary_samples.size()[1]//2)\\n #binarised samples from posterior to RBM layers\\n rbm_samples_left,rbm_samples_right=torch.split(posterior_binary_samples,split_size_or_sections=n_split,dim=1)\\n\\n #the following prepares the variables in the calculation in tehir format\\n rbm_bias_left=self.prior.get_visible_bias()\\n rbm_bias_right=self.prior.get_hidden_bias()\\n\\n rbm_bias=torch.cat([rbm_bias_left,rbm_bias_right])#self._h\\n rbm_weight=self.prior.get_weights()#self._J\\n\\n # this is transposed, so we multiply what we call \\\"right hand\\\" (\\\"hidden layer\\\")\\n # samples with right rbm nodes\\n # rbm_weight_t=torch.transpose(rbm_weight,0,1)#self._J\\n \\n rbm_activation_right=torch.matmul(rbm_samples_right,rbm_weight.t())\\n rbm_activation_left=torch.matmul(rbm_samples_left,rbm_weight)\\n\\n #corresponds to samples_times_J\\n rbm_activation=torch.cat([rbm_activation_right,rbm_activation_left],1)\\n \\n #TODO what is this scaling factor?\\n #[400,400] \\n hierarchy_scaling= (1.0 - posterior_binary_samples) / (1.0 - posterior_probs)\\n hierarchy_scaling_left,hierarchy_scaling_right=torch.split(hierarchy_scaling, split_size_or_sections=int(n_split),dim=1)\\n \\n #TODO why does this happen? This seems to scale only the left side of\\n #the RBM. Th right side is replaced with ones.\\n hierarchy_scaling_with_ones=torch.cat([hierarchy_scaling_left,torch.ones(hierarchy_scaling_right.size())],axis=1)\\n \\n with torch.no_grad():\\n undifferentiated_component=posterior_logits-rbm_bias-rbm_activation*hierarchy_scaling_with_ones\\n undifferentiated_component=undifferentiated_component.detach()\\n \\n kld_per_sample = torch.sum(undifferentiated_component * posterior_probs, dim=1)\\n\\n return kld_per_sample\",\n \"def get_KL_divergence(self):\\n KL_loss = 0\\n if(self.Bayesian):\\n for i in range(self.num_layers):\\n KL_loss += getattr(self, 'LSTMCell%i'%(i+1)).get_KL_divergence()\\n \\n return KL_loss\",\n \"def kl_divergence(self, post_logits, post_samples, is_training=True):\\n logger.debug(\\\"GumBolt::kl_divergence\\\")\\n \\n # Concatenate all hierarchy levels\\n logits_q_z = torch.cat(post_logits, 1)\\n post_zetas = torch.cat(post_samples, 1)\\n \\n # Compute cross-entropy b/w post_logits and post_samples\\n cross_entropy = - self._bce_loss(logits_q_z, post_zetas)\\n cross_entropy = torch.mean(torch.sum(cross_entropy, 1), 0)\\n \\n # Compute positive energy expval using hierarchical posterior samples\\n \\n # Number of hidden and visible variables on each side of the RBM\\n num_var_rbm = (self.n_latent_hierarchy_lvls * self._latent_dimensions)//2\\n \\n # Compute positive energy contribution to the KL divergence\\n post_zetas_vis, post_zetas_hid = post_zetas[:, :num_var_rbm], post_zetas[:, num_var_rbm:]\\n pos_energy = self.energy_exp(post_zetas_vis, post_zetas_hid)\\n \\n # Compute gradient contribution of the logZ term\\n rbm_visible_samples, rbm_hidden_samples = self.sampler.block_gibbs_sampling()\\n rbm_vis, rbm_hid = rbm_visible_samples.detach(), rbm_hidden_samples.detach()\\n neg_energy = - self.energy_exp(rbm_vis, rbm_hid)\\n \\n kl_loss = cross_entropy + pos_energy + neg_energy\\n return kl_loss, cross_entropy, pos_energy, neg_energy\",\n \"def kl(self, other: \\\"Distribution\\\", **kwargs) -> TensorType:\",\n \"def kl(self, other: \\\"Distribution\\\", **kwargs) -> TensorType:\",\n \"def rbf_kernel(x_1, x_2, l):\\n\\n\\tassert l > 0, \\\"The hyperparameter l must be > 0\\\"\\n\\tdist = euclidean_distances(x_1.reshape(-1,1), x_2.reshape(-1,1))\\n\\treturn np.exp(dist**2 / -(2*l**2))\",\n \"def kde_sklearn(x, x_grid, bandwidth=0.8, **kwargs):\\n \\n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\\n #kde_skl = KernelDensity()\\n kde_skl.fit(x[:, np.newaxis])\\n # score_samples() returns the log-likelihood of the samples\\n log_pdf = kde_skl.score_samples(x_grid[:, np.newaxis])\\n \\n pdf = np.exp(log_pdf)\\n\\n fig = plt.figure(figsize=(10,10))\\n ax = fig.add_subplot(111)\\n #ax.imshow((1,1), cmap=plt.cm.gist_earth_r,extent=[xmin, xmax])\\n ax.plot(x_grid, pdf, '.', label=\\\"kernel = kde_sklearn gaussian\\\", markersize=2)\\n ax.text(700, 0.0035, \\\"N={0} points\\\".format(x.shape[0]))\\n ax.legend(loc='upper left')\\n ax.set_xlim([min(x), max(x)])\\n ax.set_ylim(-0.001, 0.006)\\n plt.show()\",\n \"def kl(self):\\n weights_logvar = self.weights_logvar\\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\\\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\\n 2 * self.prior_stdv.pow(2)) - 0.5\\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\\\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\\n 2 * self.prior_bias_stdv.pow(2)) \\\\\\n - 0.5\\n return kld_weights.sum() + kld_bias.sum()\",\n \"def _grid_search_wl_kernel(\\n k: WeisfilerLehman,\\n subtree_candidates,\\n train_x: list,\\n train_y: torch.Tensor,\\n lik: float,\\n subtree_prior=None, # pylint: disable=unused-argument\\n lengthscales=None,\\n lengthscales_prior=None, # pylint: disable=unused-argument\\n):\\n # lik = 1e-6\\n assert len(train_x) == len(train_y)\\n best_nlml = torch.tensor(np.inf)\\n best_subtree_depth = None\\n best_lengthscale = None\\n best_K = None\\n if lengthscales is not None and k.se is not None:\\n candidates = [(h_, l_) for h_ in subtree_candidates for l_ in lengthscales]\\n else:\\n candidates = [(h_, None) for h_ in subtree_candidates]\\n\\n for i in candidates:\\n if k.se is not None:\\n k.change_se_params({\\\"lengthscale\\\": i[1]})\\n k.change_kernel_params({\\\"h\\\": i[0]})\\n K = k.fit_transform(train_x, rebuild_model=True, save_gram_matrix=True)\\n # self.logger.debug(K)\\n K_i, logDetK = compute_pd_inverse(K, lik)\\n # self.logger.debug(train_y)\\n nlml = -compute_log_marginal_likelihood(K_i, logDetK, train_y)\\n # self.logger.debug(f\\\"{i} {nlml}\\\")\\n if nlml < best_nlml:\\n best_nlml = nlml\\n best_subtree_depth, best_lengthscale = i\\n best_K = torch.clone(K)\\n # self.logger.debug(f\\\"h: {best_subtree_depth} theta: {best_lengthscale}\\\")\\n # self.logger.debug(best_subtree_depth)\\n k.change_kernel_params({\\\"h\\\": best_subtree_depth})\\n if k.se is not None:\\n k.change_se_params({\\\"lengthscale\\\": best_lengthscale})\\n k._gram = best_K # pylint: disable=protected-access\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def kl_divergence(self):\\r\\n\\r\\n target_columns = list(self.origdst.columns[11:-3])\\r\\n target_columns.append(self.origdst.columns[1]) # channel\\r\\n target_columns.append(self.origdst.columns[2]) # program_title\\r\\n target_columns.append(self.origdst.columns[3]) # genre\\r\\n\\r\\n kl_dict = {}\\r\\n\\r\\n for col in target_columns:\\r\\n\\r\\n try:\\r\\n\\r\\n col_counts_orig = self.origdst[col].value_counts(normalize=True).sort_index(ascending=True)\\r\\n col_counts_synth = self.synthdst[col].value_counts(normalize=True).sort_index(ascending=True)\\r\\n\\r\\n kl = sum(rel_entr(col_counts_orig.tolist(), col_counts_synth.tolist()))\\r\\n\\r\\n kl_dict[col] = kl\\r\\n\\r\\n except:\\r\\n\\r\\n print('For the column ', col, ' you must generate the same unique values as the real dataset.')\\r\\n print('The number of unique values than you should generate for column ', col, 'is ',\\r\\n len(self.origdst[col].unique()))\\r\\n\\r\\n return kl_dict\",\n \"def kl_gamma(x, y, a=1):\\n x = max(x, eps)\\n y = max(y, eps)\\n return a*(x/y - 1 - log(x/y))\",\n \"def kl_loss(y_true, y_pred):\\n #y_true = tf.constant(y_true, dtype=tf.dtypes.float64)\\n #y_pred = tf.constant(y_pred, dtype=tf.dtypes.float64)\\n #y_true = tf.reshape(y_true, shape=[y_true.shape[0], y_true.shape[1] * y_true.shape[2]])\\n #y_pred = tf.reshape(y_pred, shape=[y_pred.shape[0], y_pred.shape[1] * y_pred.shape[2]])\\n loss = 0\\n if y_true.shape[-1] is None:\\n return 0.0\\n for i in range(y_true.shape[-1]):\\n hist_true = np.histogram(y_true[:,i], bins=10, density=True)\\n hist_pred = np.histogram(y_pred[:,i], bins=10, density=True)\\n loss += kl(hist_true[0], hist_pred[0])\\n return loss\",\n \"def js_divergence(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tz = 0.5 * ( x.flat_cpt() + y.flat_cpt() )\\n\\tdistance = 0.5 * kl_divergence(x,z) + 0.5 * kl_divergence(y,z)\\n\\treturn distance\",\n \"def _kl_divergence(p, p_logits, q):\\n for tensor in [p, p_logits, q]:\\n if not tensor.dtype.is_floating:\\n raise ValueError('Input %s must be floating type.', tensor.name)\\n p.shape.assert_has_rank(2)\\n p_logits.shape.assert_has_rank(2)\\n q.shape.assert_has_rank(1)\\n return math_ops.reduce_sum(\\n p * (nn_ops.log_softmax(p_logits) - math_ops.log(q)), axis=1)\",\n \"def kl_divergence(self, params_q, params_p):\\n means_q = params_q[:, :, 0]\\n log_std_q = params_q[:, :, 1]\\n\\n means_p = params_p[:, :, 0]\\n log_std_p = params_p[:, :, 1]\\n\\n std_q = torch.exp(log_std_q)\\n std_p = torch.exp(log_std_p)\\n\\n kl_div = log_std_p - log_std_q + (std_q ** 2 + (means_q - means_p) ** 2) / (2.0 * std_p ** 2) - 0.5\\n\\n return kl_div.sum(dim=-1)\",\n \"def kl_divergence(self, logits_q, logits_p):\\n return (torch.exp(logits_q) * (logits_q - logits_p)).sum(1, keepdim=True)\",\n \"def kl_neg_bin(x, y, r=1):\\n return r*log((r+x)/(r+y)) - x * log(y*(r+x)/(x*(r+y)))\",\n \"def kl_divergence_symmetric(a, b, lowlim=1e-10):\\n return kl_divergence(a, b, lowlim) + kl_divergence(b, a, lowlim)\",\n \"def kl_dist_smoothing(distribution1: np.array, distribution2: np.array, epsilon: float) -> float:\\n # Performs smoothing\\n distributions = [distribution1, distribution2]\\n smoothed_distributions = []\\n for distribution in distributions:\\n nonzeros = np.count_nonzero(distribution)\\n zeros = len(distribution) - nonzeros\\n smoothed_distributions.append([epsilon if prob == 0 else prob - zeros * epsilon / nonzeros\\n for prob in distribution])\\n\\n return sum(kl_div(smoothed_distributions[0], smoothed_distributions[1]))\",\n \"def kernel_rbf(x, y,gamma):\\r\\n return np.exp(- gamma * np.linalg.norm(x- y)**2)\",\n \"def _k_lin_rbf(x, hyp, y=None, diag_only=False):\\n prod_rbf_lengthscale = hyp[\\\"prod.rbf.lengthscale\\\"]\\n prod_rbf_variance = hyp[\\\"prod.rbf.variance\\\"]\\n prod_linear_variances = hyp[\\\"prod.linear.variances\\\"]\\n linear_variances = hyp[\\\"linear.variances\\\"]\\n\\n x_rbf = cas_reshape(x[:, 1], (-1, 1))\\n y_rbf = y\\n if not y is None:\\n y_rbf = cas_reshape(y[:, 1], (-1, 1))\\n\\n k_prod_rbf = _k_rbf(x_rbf, y_rbf, prod_rbf_variance, prod_rbf_lengthscale,\\n diag_only)\\n\\n x_prod_lin = cas_reshape(x[:, 1], (-1, 1))\\n y_prod_lin = y\\n if not y is None:\\n y_prod_lin = cas_reshape(y[:, 1], (-1, 1))\\n\\n k_prod_lin = _k_lin(x_prod_lin, y_prod_lin, prod_linear_variances, diag_only)\\n\\n k_linear = _k_lin(x, y, linear_variances, diag_only)\\n\\n return k_prod_lin * k_prod_rbf + k_linear\",\n \"def kl(self, other, xs, reversesd=False, **kwargs):\\n raise NotImplementedError\",\n \"def kl_divergence(id1,id2,m1,m2,cache_val_preds,val_dl,device=\\\"cpu\\\"):\\n if m1 == m2:\\n return 0\\n \\n m1_preds = F.log_softmax(get_preds(m1,val_dl,device),dim=1) if cache_val_preds[id1] == None else cache_val_preds[id1]\\n m2_preds = F.log_softmax(get_preds(m2,val_dl,device),dim=1) if cache_val_preds[id2] == None else cache_val_preds[id2]\\n\\n cache_val_preds[id1] = m1_preds\\n cache_val_preds[id2] = m2_preds\\n\\n print(\\\"PRED SHAPE:\\\", m1_preds.shape)\\n\\n kl_loss = nn.KLDivLoss(reduction=\\\"batchmean\\\",log_target=True)\\n\\n result = kl_loss(m1_preds, m2_preds)\\n print(\\\"\\\\t\\\",result,\\\"dtype:\\\",result.dtype)\\n\\n return result\",\n \"def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\\n kl_cost = torch.mean(kl_cost, 0)\\n return torch.sum(kl_cost)\",\n \"def kullback_leibler(p: np.ndarray, q: np.ndarray) -> float:\\n kl = 0\\n for pi, qi in zip(p, q):\\n if pi > 0:\\n if qi > 0:\\n kl += pi * np.log(pi/qi)\\n else:\\n kl = np.inf\\n return kl\",\n \"def KernelTest(x, y):\\n\\n Result = (np.dot(x_test[x, :], x_train[y, :])+1)**5 # Polynomial\\n # Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\\n # Sum = DotProduct(x, y)\\n #Sum = 0.0\\n #for i in range(2):\\n # Sum = Sum + x_train[x, i]*x_train[y, i]\\n # Result = (Sum+1)**5\\n \\\"\\\"\\\"\\n #Gaussian\\n sigma = 1\\n if np.ndim(x_test[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\\n Result = np.exp(- (np.linalg.norm(x_test[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\\n elif (np.ndim(x_test[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_test[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\\n Result = np.exp(- (np.linalg.norm(x_test[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\\n elif np.ndim(x_test[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\\n \\\"\\\"\\\"\\n return Result\",\n \"def klucb(x, d, div, upperbound, lowerbound=-float('inf'), precision=1e-6):\\n low = max(x, lowerbound)\\n up = upperbound\\n while up-low > precision:\\n m = (low+up)/2\\n if div(x, m) > d:\\n up = m\\n else:\\n low = m\\n return (low+up)/2\",\n \"def fit(self, X: TwoDimArray, y: OneDimArray = None) -> 'KDE':\\n\\n self.check_params(X)\\n\\n if self.kde_params is None:\\n kde_params = {}\\n else:\\n kde_params = self.kde_params\\n\\n self._kde = KernelDensity(**kde_params).fit(X)\\n\\n self.threshold_ = np.percentile(\\n self.anomaly_score(), 100. * (1. - self.contamination)\\n )\\n\\n return self\",\n \"def calculate_kld(p, q, limits, dx=0.01):\\n if p.shape != q.shape:\\n raise ValueError('Cannot calculate KLD between two ensembles with different shapes')\\n\\n # Make a grid from the limits and resolution\\n grid = _calculate_grid_parameters(limits, dx)\\n\\n # Evaluate the functions on the grid and normalize\\n pe = p.gridded(grid.grid_values)\\n pn = pe[1]\\n qe = q.gridded(grid.grid_values)\\n qn = qe[1]\\n\\n # Calculate the KLD from q to p\\n Dpq = array_metrics.quick_kld(pn, qn, grid.resolution)# np.dot(pn * logquotient, np.ones(len(grid)) * dx)\\n\\n if np.any(Dpq < 0.): #pragma: no cover\\n print('broken KLD: '+str((Dpq, pn, qn, grid.resolution)))\\n Dpq = epsilon*np.ones(Dpq.shape)\\n return Dpq\",\n \"def kl_dirichlet(alpha, beta):\\n alpha_0 = torch.sum(alpha, dim=-1, keepdim=True)\\n beta_0 = torch.sum(beta, dim=-1, keepdim=True)\\n t1 = torch.lgamma(alpha_0) - torch.sum(torch.lgamma(alpha), dim=-1, keepdim=True)\\n t2 = torch.lgamma(beta_0) - torch.sum(torch.lgamma(beta), dim=-1, keepdim=True)\\n t3 = torch.sum((alpha - beta) * (torch.digamma(alpha) - torch.digamma(alpha_0)), dim=-1, keepdim=True)\\n return t1 - t2 + t3\",\n \"def kl_divergence_fn(\\n args: StepFunctionArgs,\\n contrast_sources: Optional[FeatureAttributionInput] = None,\\n contrast_target_prefixes: Optional[FeatureAttributionInput] = None,\\n contrast_targets: Optional[FeatureAttributionInput] = None,\\n contrast_targets_alignments: Optional[List[List[Tuple[int, int]]]] = None,\\n top_k: int = 0,\\n top_p: float = 1.0,\\n min_tokens_to_keep: int = 1,\\n) -> SingleScorePerStepTensor:\\n\\n original_logits: torch.Tensor = args.attribution_model.output2logits(args.forward_output)\\n contrast_output = _get_contrast_output(\\n args=args,\\n contrast_sources=contrast_sources,\\n contrast_targets=contrast_targets,\\n contrast_target_prefixes=contrast_target_prefixes,\\n contrast_targets_alignments=contrast_targets_alignments,\\n return_contrastive_target_ids=False,\\n )\\n contrast_logits: torch.Tensor = args.attribution_model.output2logits(contrast_output)\\n return logits_kl_divergence(\\n original_logits=original_logits,\\n contrast_logits=contrast_logits,\\n top_p=top_p,\\n top_k=top_k,\\n min_tokens_to_keep=min_tokens_to_keep,\\n )\",\n \"def kernel_regression_h(x, y, silverman=False):\\n xx = np.array(x)\\n yy = np.array(y)\\n # Check input\\n assert xx.shape[0] == yy.size, (\\n f'size(x, 0) != size(y): {xx.shape[0]} != {yy.size}' )\\n if xx.ndim == 1: # deal with 1d-arrays\\n xx = xx[:, np.newaxis]\\n n = xx.shape[0]\\n d = xx.shape[1]\\n\\n # Silverman (1986), Scott (1992), Bowman and Azzalini (1997)\\n # Very similar to stats.gaussian_kde\\n # h has dimension d\\n h = ( (4. / float(d + 2) / float(n))**(1. / float(d + 4)) *\\n np.std(xx, axis=0, ddof=1) )\\n\\n if not silverman:\\n # Find the optimal h\\n bounds = [(0.2*i, 5.0*i) for i in h]\\n if n <= 100:\\n res = opt.minimize(\\n _cross_valid_h, h, args=(xx, yy), method='TNC', bounds=bounds,\\n options={'ftol': 1e-10, 'xtol': 1e-10, 'maxfun': 1000})\\n h = res.x\\n else:\\n res = opt.minimize(\\n _boot_h, h, args=(xx, yy), method='TNC', bounds=bounds,\\n options={'ftol': 1e-10, 'xtol': 1e-10, 'maxfun': 1000})\\n h = res.x\\n\\n if len(h) == 1:\\n h = h[0]\\n\\n return h\",\n \"def hellinger(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tdistance = ( 1 / np.sqrt( 2 ) ) * np.sqrt( np.sum( ( np.sqrt( x.flat_cpt() ) - np.sqrt( y.flat_cpt() ) )**2) )\\n\\treturn distance\",\n \"def kld(cls,\\n y_true,\\n y_pred):\\n y_pred /= np.sum(y_pred)\\n y_true = np.clip(y_true, cls.eps, 1)\\n y_pred = np.clip(y_pred, cls.eps, 1)\\n print(y_pred)\\n print(y_true)\\n print(y_true * np.log(y_true / y_pred))\\n _kld = np.sum(y_true * np.log(y_true / y_pred), axis=-1)\\n print('KLD: ' + str(_kld))\\n return _kld\",\n \"def get_Kl_divergence(model1, model2, collection, lam, missing_val = 0.0001):\\n smoot_m2 = {key: (1-lam)*model2.get(key, 0) + lam*collection.get(key, missing_val) for key in model1}\\n\\n divergence = sum([model1[key]*math.log(model1[key]/smoot_m2[key]) for key in model1])\\n return divergence\",\n \"def train(self, X, y):\\n m = X.shape[0]\\n D = np.empty(m)\\n D.fill(1/(m*1.0))\\n\\n hs = 0\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n eps = 0\\n\\n for j in range(m): \\n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\\n eps+=D[j]\\n\\n self.w[t] =0.5*math.log((1/eps)-1)\\n\\n Dtmp = []\\n for j in range(m):\\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\\n\\n Dtmp = np.array(Dtmp) \\n s = np.sum(Dtmp)\\n\\n for i in range(m):\\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s\",\n \"def train_LVQ2(self, x, y):\\n while self.epsilon >= 0.01:\\n rnd_i = np.random.randint(0, len(x))\\n rnd_s = x[rnd_i]\\n target_y = y[rnd_i]\\n \\n self.epsilon = self.epsilon - self.epsilon_dec_factor\\n \\n closest_pvector = self.find_closest(rnd_s)[1]\\n second_closest_pvector = self.find_runnerup(rnd_s)\\n compare_distance = np.linalg.norm(closest_pvector.p_vector - rnd_s)/np.linalg.norm(second_closest_pvector.p_vector - rnd_s)\\n \\n if target_y == second_closest_pvector.class_id and target_y != closest_pvector.class_id and compare_distance > 0.8 and compare_distance < 1.2:\\n closest_pvector.update(rnd_s, False)\\n second_closest_pvector.update(rnd_s)\\n elif target_y == closest_pvector.class_id:\\n closest_pvector.update(rnd_s)\\n elif target_y != closest_pvector.class_id:\\n closest_pvector.update(rnd_s, False)\\n closest_pvector.epsilon = self.epsilon\\n return self.p_vectors\",\n \"def kl_divergence(a, b, lowlim=1e-10):\\n mask = np.logical_and(b > lowlim, a > lowlim)\\n return np.sum(a[mask] * np.log(a[mask] / b[mask]))\",\n \"def bhhh_internal(\\n criterion_and_derivative,\\n x,\\n convergence_absolute_gradient_tolerance,\\n stopping_max_iterations,\\n):\\n criterion_accepted, gradient = criterion_and_derivative(x)\\n x_accepted = x\\n\\n hessian_approx = np.dot(gradient.T, gradient)\\n gradient_sum = np.sum(gradient, axis=0)\\n direction = np.linalg.solve(hessian_approx, gradient_sum)\\n gtol = np.dot(gradient_sum, direction)\\n\\n initial_step_size = 1\\n step_size = initial_step_size\\n\\n niter = 1\\n while niter < stopping_max_iterations:\\n niter += 1\\n\\n x_candidate = x_accepted + step_size * direction\\n criterion_candidate, gradient = criterion_and_derivative(x_candidate)\\n\\n # If previous step was accepted\\n if step_size == initial_step_size:\\n hessian_approx = np.dot(gradient.T, gradient)\\n\\n else:\\n criterion_candidate, gradient = criterion_and_derivative(x_candidate)\\n\\n # Line search\\n if np.sum(criterion_candidate) > np.sum(criterion_accepted):\\n step_size /= 2\\n\\n if step_size <= 0.01:\\n # Accept step\\n x_accepted = x_candidate\\n criterion_accepted = criterion_candidate\\n\\n # Reset step size\\n step_size = initial_step_size\\n\\n # If decrease in likelihood, calculate new direction vector\\n else:\\n # Accept step\\n x_accepted = x_candidate\\n criterion_accepted = criterion_candidate\\n\\n gradient_sum = np.sum(gradient, axis=0)\\n direction = np.linalg.solve(hessian_approx, gradient_sum)\\n gtol = np.dot(gradient_sum, direction)\\n\\n if gtol < 0:\\n hessian_approx = np.dot(gradient.T, gradient)\\n direction = np.linalg.solve(hessian_approx, gradient_sum)\\n\\n # Reset stepsize\\n step_size = initial_step_size\\n\\n if gtol < convergence_absolute_gradient_tolerance:\\n break\\n\\n result_dict = {\\n \\\"solution_x\\\": x_accepted,\\n \\\"solution_criterion\\\": criterion_accepted,\\n \\\"n_iterations\\\": niter,\\n \\\"message\\\": \\\"Under develpment\\\",\\n }\\n\\n return result_dict\",\n \"def my_kernel(X, Y):\\n S = 0.84 # parameter from rhos\\n\\n if dset == 1:\\n gamma = 0.0005\\n else:\\n gamma = 0.00087 # maximise variance of kernel matrix\\n if np.array_equal(X, Y):\\n N = X.shape[0]\\n M = (1 - S) * np.ones((N, N)) + S * np.eye(N)\\n else:\\n M = 1\\n\\n pairwise_sq_dists = cdist(X, Y, 'sqeuclidean')\\n K = exp(-gamma * pairwise_sq_dists) * M\\n return K\",\n \"def _kernel(self, x1, x2, beta=1):\\n d = (x1 - x2)**2\\n return np.exp(-beta * d)\",\n \"def test_KL_divergence(generator, noise_dim, code_dim, validation_kernels, val_codes, training_noise_dict, n_samples_per_axis=40, n_axis=1):\\r\\n total_KL = 0\\r\\n for code in validation_kernels:\\r\\n print(code)\\r\\n fakes = generate_fake_samples_constant_code(generator, code_dim, noise_dim, code, n_samples_per_axis**n_axis, val_codes, training_noise_dict)\\r\\n print(\\\"Fake generation complete\\\")\\r\\n fakes_kernel = KernelDensity(kernel='gaussian', bandwidth=KD_BANDWIDTH).fit(fakes)\\r\\n print(\\\"Kernel complete\\\")\\r\\n total_KL += kl_divergence(validation_kernels[code], fakes_kernel, n_samples_per_axis, n_axis)\\r\\n return total_KL\",\n \"def LD(x, y, lodict={}):\\n return needleman_wunsch(x, y, lodict=lodict, gop=-1, gep=-1)\",\n \"def calculate_convergence(v1, v2):\\r\\n\\r\\n return norm(v2 - v1, ord=1)\",\n \"def compute_kl(self, df):\\n value_counts = [df[col].value_counts() for col in self.hist_cols]\\n next_hists = self.value_counts_to_hists(value_counts)\\n\\n if self.prev_hists is None:\\n self.prev_hists = next_hists\\n return None\\n\\n output = []\\n for prev_h, curr_h in zip(self.prev_hists, next_hists):\\n for i in range(len(prev_h)):\\n prev_h[i] = prev_h[i] if prev_h[i] != 0 else 1\\n curr_h[i] = curr_h[i] if curr_h[i] != 0 else 1\\n kl = entropy(prev_h, curr_h)\\n output.append(kl)\\n\\n self.prev_hists = next_hists\\n return output\",\n \"def d_bernoulli_kullback_leibler_dq(p: float, q: float) -> float:\\n return (1 - p) / (1 - q) - p/q\",\n \"def add_kl_loss(self, posterior_dist, prior_dist):\\n if self.kl_use_exact:\\n self.add_loss(\\n kl_lib.kl_divergence(\\n posterior_dist, prior_dist\\n ) * self.kl_weight * self.kl_anneal\\n )\\n else:\\n self.add_loss(\\n self._kl_approximation(\\n posterior_dist, prior_dist\\n ) * self.kl_weight * self.kl_anneal\\n )\",\n \"def kl(mu1, mu2):\\n return (mu2-mu1)**2/2\",\n \"def kl(mu1, mu2):\\n return (mu2-mu1)**2/2\",\n \"def JS_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\\n if data_range is None:\\n data_range = list(set(xs)) + list(set(ys))\\n if pdf_x is None:\\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\\n if pdf_y is None:\\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\\n M = {}\\n for i in pdf_x:\\n if i not in pdf_y:\\n pdf_y[i] = 0.0\\n for i in pdf_y:\\n if i not in pdf_x:\\n pdf_y[i] = 0.0\\n for i in pdf_x:\\n M[i] = .5*(pdf_x[i] + pdf_y[i])\\n return .5*KL_divergence(None,\\n None,\\n pdf_x=pdf_x,\\n pdf_y=M,\\n data_range=data_range) + \\\\\\n .5*KL_divergence(None,\\n None,\\n pdf_x=pdf_y,\\n pdf_y=M,\\n data_range=data_range)\",\n \"def lkendalltau(x,y):\\r\\n n1 = 0\\r\\n n2 = 0\\r\\n iss = 0\\r\\n for j in range(len(x)-1):\\r\\n for k in range(j,len(y)):\\r\\n a1 = x[j] - x[k]\\r\\n a2 = y[j] - y[k]\\r\\n aa = a1 * a2\\r\\n if (aa): # neither list has a tie\\r\\n n1 = n1 + 1\\r\\n n2 = n2 + 1\\r\\n if aa > 0:\\r\\n iss = iss + 1\\r\\n else:\\r\\n iss = iss -1\\r\\n else:\\r\\n if (a1):\\r\\n n1 = n1 + 1\\r\\n else:\\r\\n n2 = n2 + 1\\r\\n tau = iss / math.sqrt(n1*n2)\\r\\n svar = (4.0*len(x)+10.0) / (9.0*len(x)*(len(x)-1))\\r\\n z = tau / math.sqrt(svar)\\r\\n prob = erfcc(abs(z)/1.4142136)\\r\\n return tau, prob\",\n \"def compute_kl(mu1, mu2, sigma1, sigma2):\\n k = len(mu1)\\n try:\\n term1 = np.trace(np.matmul(np.linalg.inv(sigma2), sigma1))\\n term2 = np.matmul(np.matmul((mu2 - mu1).T,\\n np.linalg.inv(sigma2)),\\n (mu2 - mu1))\\n det_sigma1 = compute_determinant(sigma1)\\n det_sigma2 = compute_determinant(sigma2)\\n # term3 = np.log(np.linalg.det(sigma2)/np.linalg.det(sigma1))\\n term3 = np.log(det_sigma2)\\n term4 = np.log(det_sigma1)\\n kl = (term1 + term2 - k + term3 - term4)/2.\\n return kl\\n except np.linalg.LinAlgError:\\n return np.nan\",\n \"def kl(mu1, mu2):\\n return (mu2 - mu1) ** 2 / 2\",\n \"def d2_bin(self, x, y):\\n \\n KD = KernelDensity(bandwidth=self.bandwidth,kernel=self.kernel)\\n KD.fit(np.column_stack((x,y)))\\n grid1 = np.linspace(np.min(x),np.max(x),self.bins)\\n grid2 = np.linspace(np.min(y),np.max(y),self.bins)\\n mesh = np.meshgrid(grid1,grid2)\\n data = np.column_stack((mesh[0].reshape(-1,1),mesh[1].reshape(-1,1)))\\n samp = KD.score_samples(data)\\n samp = samp.reshape(self.bins,self.bins)\\n p = np.exp(samp)/np.sum(np.exp(samp))\\n\\n return p\",\n \"def lpointbiserialr(x,y):\\r\\n TINY = 1e-30\\r\\n if len(x) <> len(y):\\r\\n raise ValueError, 'INPUT VALUES NOT PAIRED IN pointbiserialr. ABORTING.'\\r\\n data = pstats.abut(x,y)\\r\\n categories = pstats.unique(x)\\r\\n if len(categories) <> 2:\\r\\n raise ValueError, \\\"Exactly 2 categories required for pointbiserialr().\\\"\\r\\n else: # there are 2 categories, continue\\r\\n codemap = pstats.abut(categories,range(2))\\r\\n recoded = pstats.recode(data,codemap,0)\\r\\n x = pstats.linexand(data,0,categories[0])\\r\\n y = pstats.linexand(data,0,categories[1])\\r\\n xmean = mean(pstats.colex(x,1))\\r\\n ymean = mean(pstats.colex(y,1))\\r\\n n = len(data)\\r\\n adjust = math.sqrt((len(x)/float(n))*(len(y)/float(n)))\\r\\n rpb = (ymean - xmean)/samplestdev(pstats.colex(data,1))*adjust\\r\\n df = n-2\\r\\n t = rpb*math.sqrt(df/((1.0-rpb+TINY)*(1.0+rpb+TINY)))\\r\\n prob = betai(0.5*df,0.5,df/(df+t*t)) # t already a float\\r\\n return rpb, prob\",\n \"def klucb_bern(x, d, precision=1e-6):\\n upperbound = min(1., klucb_gauss(x, d))\\n return klucb(x, d, kl_bern, upperbound, precision)\",\n \"def bernoulli_kullback_leibler(p: float, q: float) -> float:\\n kl1, kl2 = 0, np.infty\\n if p > 0:\\n if q > 0:\\n kl1 = p*np.log(p/q)\\n\\n if q < 1:\\n if p < 1:\\n kl2 = (1 - p) * np.log((1 - p) / (1 - q))\\n else:\\n kl2 = 0\\n return kl1 + kl2\",\n \"def KL_divergence(value_counts1, value_counts2):\\n divergence = 0\\n s1 = sum([value_counts1[value] for value in value_counts1])\\n s2 = sum([value_counts2[value] for value in value_counts2])\\n for value in set(value_counts1).union(value_counts2):\\n assert(value in value_counts1 or value in value_counts2)\\n if value not in value_counts1:\\n s1 += KL_SMOOTHING\\n if value not in value_counts2:\\n s2 += KL_SMOOTHING\\n for value in set(value_counts1).union(value_counts2):\\n v1 = v2 = KL_SMOOTHING\\n if value in value_counts1:\\n v1 = value_counts1[value]\\n if value in value_counts2:\\n v2 = value_counts2[value]\\n v1 = float(v1) / s1\\n v2 = float(v2) / s2\\n divergence += v1 * math.log(v1 / v2)\\n if divergence > math.e:\\n divergence = math.e\\n return divergence\",\n \"def k(xs, ys, sigma=1, l=1):\\n\\n # Pairwise difference matrix.\\n dx = np.expand_dims(xs, 1) - np.expand_dims(ys, 0)\\n return (sigma ** 2) * np.exp(-((dx / l) ** 2) / 2)\",\n \"def distorted_data(X_train,y_train,X_test,y_test,dialation=10.):\\n\\n t,l1 = regularized_grad_descent(X_train,y_train,lambda_reg=1e-6)\\n\\n X_train[:,0] *= dialation\\n X_test[:,0] *= dialation\\n \\n t,l2 = regularized_grad_descent(X_train,y_train,lambda_reg=1e-6)\\n\\n plt.plot(np.log(l1),'b--')\\n plt.plot(np.log(l2),'r--')\\n plt.show()\\n plt.close()\",\n \"def KL(P,Q):\\n epsilon = 0.00001\\n \\n #You may want to instead make copies to avoid changing the np arrays.\\n P = P+epsilon\\n Q = Q+epsilon\\n \\n divergence = np.sum(P*np.log(P/Q))\\n return divergence\",\n \"def kl(\\n self,\\n x: Tensor,\\n covariates: Tensor,\\n use_temp: bool,\\n ) -> Tuple[Tensor, Tensor]:\\n log_probs, ldj_sum, _ = self.compute_probabilities(x, covariates, use_temp)\\n\\n return -(torch.logsumexp(log_probs, dim=1) + ldj_sum).mean()\",\n \"def kl(self, old_dist_info, new_dist_info):\\n old_prob = old_dist_info[\\\"prob\\\"]\\n new_prob = new_dist_info[\\\"prob\\\"]\\n return np.sum(\\n old_prob * (np.log(old_prob + TINY) - np.log(new_prob + TINY)),\\n axis=2\\n )\",\n \"def kde_2d_multiple_times(plume_x, plume_y, X, Y):\\n Z = []\\n positions = np.vstack([X.ravel(), Y.ravel()])\\n for i in range(len(plume_x)):\\n values = np.vstack([plume_x[i], plume_y[i]])\\n kernel = stats.gaussian_kde(values)\\n Z.append(np.reshape(kernel(positions).T, X.shape))\\n return Z\",\n \"def kde_scipy(x, x_grid, bandwidth=0.2, **kwargs):\\n # Note that scipy weights its bandwidth by the covariance of the\\n # input data. To make the results comparable to the other methods,\\n # we divide the bandwidth by the sample standard deviation here.\\n #kde = gaussian_kde(x, bw_method=bandwidth / x.std(ddof=1), **kwargs)\\n kde = gaussian_kde(x)\\n return kde.evaluate(x_grid)\",\n \"def hellinger_distance(x, y):\\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\\n x.dtype == np.float32 and y.dtype == np.float32)\\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n x = np.sqrt(x)\\n y = np.sqrt(y)\\n # x (120, 40), y (100, 40), H(x,y) (120, 100)\\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\\n yy = np.tile(y, (x.shape[0], 1, 1))\\n xx_yy = xx - yy\\n res = np.sqrt(np.sum(xx_yy ** 2, axis=-1))\\n return np.float64((1. / np.sqrt(2)) * res)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70139825","0.6948134","0.6635383","0.6421419","0.63527554","0.6301051","0.62800944","0.62187314","0.6194453","0.6156323","0.6144021","0.61299276","0.61106426","0.6105154","0.6101856","0.6100986","0.6093369","0.6083329","0.60363257","0.6034415","0.6016642","0.6007839","0.6007176","0.59686935","0.5943885","0.59380877","0.5933738","0.59239966","0.58543617","0.58409435","0.57862157","0.5784366","0.57784563","0.577789","0.5705405","0.56565136","0.5646857","0.5646857","0.563422","0.56067544","0.5599206","0.55910003","0.55864877","0.55722225","0.5553416","0.55391544","0.55368483","0.551811","0.55085313","0.55073214","0.5505932","0.5498376","0.5488649","0.5481236","0.54645663","0.54550767","0.54545015","0.54290396","0.5420997","0.5420184","0.5410348","0.5398924","0.53917265","0.53898317","0.5379334","0.5372688","0.53723264","0.53687805","0.5364838","0.53628284","0.53588635","0.535875","0.53586864","0.53429836","0.5340839","0.5339657","0.5337506","0.5334773","0.5331853","0.53246516","0.53225935","0.53181326","0.53181326","0.531505","0.5303839","0.5295617","0.52868265","0.52845466","0.5266413","0.52574503","0.52497154","0.52229965","0.5222858","0.5222764","0.51995504","0.51986456","0.5198613","0.5196632","0.51900464","0.5185609"],"string":"[\n \"0.70139825\",\n \"0.6948134\",\n \"0.6635383\",\n \"0.6421419\",\n \"0.63527554\",\n \"0.6301051\",\n \"0.62800944\",\n \"0.62187314\",\n \"0.6194453\",\n \"0.6156323\",\n \"0.6144021\",\n \"0.61299276\",\n \"0.61106426\",\n \"0.6105154\",\n \"0.6101856\",\n \"0.6100986\",\n \"0.6093369\",\n \"0.6083329\",\n \"0.60363257\",\n \"0.6034415\",\n \"0.6016642\",\n \"0.6007839\",\n \"0.6007176\",\n \"0.59686935\",\n \"0.5943885\",\n \"0.59380877\",\n \"0.5933738\",\n \"0.59239966\",\n \"0.58543617\",\n \"0.58409435\",\n \"0.57862157\",\n \"0.5784366\",\n \"0.57784563\",\n \"0.577789\",\n \"0.5705405\",\n \"0.56565136\",\n \"0.5646857\",\n \"0.5646857\",\n \"0.563422\",\n \"0.56067544\",\n \"0.5599206\",\n \"0.55910003\",\n \"0.55864877\",\n \"0.55722225\",\n \"0.5553416\",\n \"0.55391544\",\n \"0.55368483\",\n \"0.551811\",\n \"0.55085313\",\n \"0.55073214\",\n \"0.5505932\",\n \"0.5498376\",\n \"0.5488649\",\n \"0.5481236\",\n \"0.54645663\",\n \"0.54550767\",\n \"0.54545015\",\n \"0.54290396\",\n \"0.5420997\",\n \"0.5420184\",\n \"0.5410348\",\n \"0.5398924\",\n \"0.53917265\",\n \"0.53898317\",\n \"0.5379334\",\n \"0.5372688\",\n \"0.53723264\",\n \"0.53687805\",\n \"0.5364838\",\n \"0.53628284\",\n \"0.53588635\",\n \"0.535875\",\n \"0.53586864\",\n \"0.53429836\",\n \"0.5340839\",\n \"0.5339657\",\n \"0.5337506\",\n \"0.5334773\",\n \"0.5331853\",\n \"0.53246516\",\n \"0.53225935\",\n \"0.53181326\",\n \"0.53181326\",\n \"0.531505\",\n \"0.5303839\",\n \"0.5295617\",\n \"0.52868265\",\n \"0.52845466\",\n \"0.5266413\",\n \"0.52574503\",\n \"0.52497154\",\n \"0.52229965\",\n \"0.5222858\",\n \"0.5222764\",\n \"0.51995504\",\n \"0.51986456\",\n \"0.5198613\",\n \"0.5196632\",\n \"0.51900464\",\n \"0.5185609\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7132836"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3394,"cells":{"query":{"kind":"string","value":"r\"\"\"JensenShannon Divergence Calculates the JensenShannon Divergence (JSD) between two discrete distributions x and y. JSD quantifies the difference (or similarity) between two probability distributions and uses the KL divergence to calculate a smoothed normalized score [0, 1] that is symmetrical."},"document":{"kind":"string","value":"def jensen_shannon(x, y, bins, calc_distance=False, xy_probabilities=False):\n # assert array length\n assert len(x) == len(y)\n\n if xy_probabilities:\n # if x does not sum up to 1, raise an error\n if not np.isclose(sum(x), 1 ,atol=0.0001):\n raise ValueError('Probabilities in vector x do not sum up to 1.')\n # if y does not sum up to 1, raise an error\n if not np.isclose(sum(y), 1, atol=0.0001):\n raise ValueError('Probabilities in vector y do not sum up to 1.')\n \n # add a small number to all probabilities if zero occurs\n if x.any(0):\n px = x + 1e-15\n py = y + 1e-15\n else:\n px = x\n py = y\n else:\n # get the bins, joint bins for x and y (same_bins=True)\n bins = get_2D_bins(x, y, bins, same_bins=True)\n\n # calculate unconditioned histograms\n hist_x = np.histogram(x, bins=bins[0])[0]\n hist_y = np.histogram(y, bins=bins[1])[0]\n\n # calculate probabilities\n px = (hist_x / np.sum(hist_x)) + 1e-15\n py = (hist_y / np.sum(hist_y)) + 1e-15\n\n # calculate m\n pm = 0.5 * (px + py)\n\n # calculate kullback-leibler divergence between px and pm & py and pm\n kl_xm = kullback_leibler(px, pm, bins=bins, xy_probabilities=True)\n kl_ym = kullback_leibler(py, pm, bins=bins, xy_probabilities=True)\n \n if calc_distance:\n return (0.5 * kl_xm + 0.5 * kl_ym)**0.5\n else:\n return (0.5 * kl_xm + 0.5 * kl_ym)"},"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 compute_js_divergence(df_1, df_2, n_bins=30):\n a = np.concatenate((df_1, df_2), axis=0)\n e, p = prob_mass_fun(df_1, n = n_bins, range = (a.min(), a.max()))\n _, q = prob_mass_fun(df_2, n = e, range = (a.min(), a.max()))\n\n return scipy.spatial.distance.jensenshannon(p, q)","def js_divergence(dist1, dist2):\n mean_dist = (dist1 + dist2) / 2.0\n js = (\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\n ) / 2.0\n return js","def js_divergence(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tz = 0.5 * ( x.flat_cpt() + y.flat_cpt() )\n\tdistance = 0.5 * kl_divergence(x,z) + 0.5 * kl_divergence(y,z)\n\treturn distance","def JS_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\n if data_range is None:\n data_range = list(set(xs)) + list(set(ys))\n if pdf_x is None:\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\n if pdf_y is None:\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\n M = {}\n for i in pdf_x:\n if i not in pdf_y:\n pdf_y[i] = 0.0\n for i in pdf_y:\n if i not in pdf_x:\n pdf_y[i] = 0.0\n for i in pdf_x:\n M[i] = .5*(pdf_x[i] + pdf_y[i])\n return .5*KL_divergence(None,\n None,\n pdf_x=pdf_x,\n pdf_y=M,\n data_range=data_range) + \\\n .5*KL_divergence(None,\n None,\n pdf_x=pdf_y,\n pdf_y=M,\n data_range=data_range)","def kl_divergence(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tdistance = np.sum( x.flat_cpt() * np.log( x.flat_cpt() / y.flat_cpt() ) )\n\treturn distance","def _hess_j(C_j, I_j, b_j, b_j_norm, a_1_j, a_2_j):\n D_j = torch.ger(b_j, b_j)\n return C_j + (a_1_j / b_j_norm) * (I_j - D_j / (b_j_norm ** 2)) + a_2_j * I_j","def js_divergence(x, y, normalize=True):\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\n x.dtype == np.float32 and y.dtype == np.float32)\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\n\n if normalize:\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\n yy = np.tile(y, (x.shape[0], 1, 1))\n m = (xx + yy) / 2\n x_m = np.sum(xx * np.log(m), axis=2)\n y_m = np.sum(yy * np.log(m), axis=2)\n x_x = np.tile(\n np.sum(x * np.log(x), axis=1).reshape(x.shape[0], 1), (1, y.shape[0]))\n y_y = np.tile(np.sum(\n y * np.log(y), axis=1).reshape(y.shape[0], 1),\n (1, x.shape[0])).transpose()\n res = 0.5 * (x_x - x_m) + 0.5 * (y_y - y_m)\n return np.float64(res)\n # division by zero","def JSDivergence(p_output, q_output, get_softmax=True, dim=1):\n if get_softmax:\n p_output = F.softmax(p_output, dim=dim)\n # q_output = F.softmax(q_output, dim=dim)\n log_mean_output = ((p_output + q_output )/2).log()\n return (\n F.kl_div(log_mean_output, p_output, reduction='batchmean') + \n F.kl_div(log_mean_output, q_output, reduction='batchmean')\n ) / 2","def plot_pairwise_jsd(img_dir, mask_dir, outfn='pairwisejsd.png', nbins=200, fit_chi2=True):\n pairwise_jsd = quality.pairwise_jsd(img_dir, mask_dir, nbins=nbins)\n _, ax = plt.subplots(1, 1)\n ax.hist(pairwise_jsd, label='Hist.', density=True)\n if fit_chi2:\n from scipy.stats import chi2\n df, _, scale = chi2.fit(pairwise_jsd, floc=0)\n logger.info(f'df = {df:0.3e}, scale = {scale:0.3e}')\n x = np.linspace(0, np.max(pairwise_jsd), 200)\n ax.plot(x, chi2.pdf(x, df, scale=scale), lw=3, label=r'$\\chi^2$ Fit')\n ax.legend()\n textstr = r'$df = $' + f'{df:0.2f}'\n props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n ax.text(0.72, 0.80, textstr, transform=ax.transAxes,\n verticalalignment='top', bbox=props)\n ax.set_xlabel(r'Jensen-Shannon Divergence')\n ax.set_ylabel('Density')\n ax.set_title(\n r'Density of Pairwise JSD — $\\mu$ = ' + f'{np.mean(pairwise_jsd):.2e}' + r' $\\sigma$ = ' + f'{np.std(pairwise_jsd):.2e}',\n pad=20)\n ax.ticklabel_format(style='sci', axis='both', scilimits=(0, 0))\n if outfn is not None:\n plt.savefig(outfn, transparent=True, dpi=200)\n return ax","def SSD(x,y):\n return np.sum((x-y)**2)","def _jsd(prob_dist_p, prob_dist_q):\n prob_dist_p = check_numpy_param('prob_dist_p', prob_dist_p)\n prob_dist_q = check_numpy_param('prob_dist_q', prob_dist_q)\n norm_dist_p = prob_dist_p / (np.linalg.norm(prob_dist_p, ord=1) + 1e-12)\n norm_dist_q = prob_dist_q / (np.linalg.norm(prob_dist_q, ord=1) + 1e-12)\n norm_mean = 0.5*(norm_dist_p + norm_dist_q)\n return 0.5*(stats.entropy(norm_dist_p, norm_mean)\n + stats.entropy(norm_dist_q, norm_mean))","def dJ(theta, x_b, y):\n return x_b.T.dot(self._sigmoid(x_b.dot(theta)) - y) / len(x_b)","def KolmogorovSmirnoff_statistics(dd1, dd2):\n cum1 = dd1.cumulative_distribution()\n cum2 = dd2.cumulative_distribution()\n minimum = max(cum1[0][0], cum2[0][0])\n maximum = max(cum1[-1][0], cum2[-1][0])\n index1 = len(cum1) - 1\n index2 = len(cum2) - 1\n summa1 = summa2 = 0\n\n difference = 0\n for i in reversed(range(minimum, maximum+1)):\n if cum1[index1][0] == i:\n summa1 = cum1[index1][1]\n index1 -= 1\n if cum2[index2][0] == i:\n summa2 = cum2[index2][1]\n index2 -= 1\n if abs(summa1 - summa2) > difference:\n difference = abs(summa1 - summa2)\n return difference","def js_div(d1, d2):\n part1 = - soft_relu(-d1).mean()\n part2 = - soft_relu(d2).mean() \n return part1 + part2 + np.log(4.0)","def jssim_dist(G1, G2, nodes=None):\n if nodes is None:\n nodes = G1.nodes() | G2.nodes()\n\n sims = []\n for n in nodes:\n set1, set2 = set(G1.neighbors(n)), set(G2.neighbors(n))\n neighbors = list(set1 | set2)\n p1 = np.array([1./len(set1) if _n in set1 else 0 for _n in neighbors])\n p2 = np.array([1./len(set2) if _n in set2 else 0 for _n in neighbors])\n sims.append(1 - jsdiv(p1, p2))\n \n return sims","def js_metric(df_1, df_2, numerical_columns, categorical_columns):\n\n res = {}\n STEPS = 100\n\n for col in categorical_columns:\n # to ensure similar order, concat before computing probability\n col_baseline = df_1[col].to_frame()\n col_sample = df_2[col].to_frame()\n col_baseline[\"source\"] = \"baseline\"\n col_sample[\"source\"] = \"sample\"\n\n col_ = pd.concat([col_baseline, col_sample], ignore_index=True)\n\n # aggregate and convert to probability array\n arr = (\n col_.groupby([col, \"source\"])\n .size()\n .to_frame()\n .reset_index()\n .pivot(index=col, columns=\"source\")\n .droplevel(0, axis=1)\n )\n arr_ = arr.div(arr.sum(axis=0), axis=1)\n arr_.fillna(0, inplace=True)\n\n # calculate js distance\n js_distance = jensenshannon(\n arr_[\"baseline\"].to_numpy(), arr_[\"sample\"].to_numpy()\n )\n\n res.update({col: js_distance})\n\n for col in numerical_columns:\n # fit gaussian_kde\n col_baseline = df_1[col]\n col_sample = df_2[col]\n kde_baseline = gaussian_kde(col_baseline)\n kde_sample = gaussian_kde(col_sample)\n\n # get range of values\n min_ = min(col_baseline.min(), col_sample.min())\n max_ = max(col_baseline.max(), col_sample.max())\n range_ = np.linspace(start=min_, stop=max_, num=STEPS)\n\n # sample range from KDE\n arr_baseline_ = kde_baseline(range_)\n arr_sample_ = kde_sample(range_)\n\n arr_baseline = arr_baseline_ / np.sum(arr_baseline_)\n arr_sample = arr_sample_ / np.sum(arr_sample_)\n\n # calculate js distance\n js_distance = jensenshannon(arr_baseline, arr_sample)\n\n res.update({col: js_distance})\n\n list_output = sorted(res.items(), key=lambda x: x[1], reverse=True)\n dict_output = dict(list_output)\n\n return dict_output","def kl_divergence(dist1, dist2, symmetrized=True):\n if symmetrized == True:\n kl = (\n scipy.stats.entropy(dist1, dist2) + scipy.stats.entropy(dist2, dist1)\n ) / 2.0\n return kl\n else:\n kl = scipy.stats.entropy(dist1, dist2)\n return kl","def JS_divergence(p1, p2, weights, mode='normalized'):\n p1 = np.maximum(p1, 10**-10)\n p2 = np.maximum(p2, 10**-10)\n M = 0.5 * (p1 + p2)\n if mode == 'normalized':\n return 0.5 * (np.sum(weights * p1 * np.log(p1 / M)) + np.sum(weights * p2 * np.log(p2 / M)))\n else:\n I1 = 1 - np.sum(weights * p1)\n I2 = 1 - np.sum(weights * p2)\n return 0.5 * (np.sum(weights * p1 * np.log(p1 / M)) + np.sum(weights * p2 * np.log(p2 / M)) + I1 * np.log(2 * I1 / (I1 + I2)) + I2 * np.log(2 * I2 / (I1 + I2)))","def compute_dists(x, y):\r\n \r\n return (x - y.permute(0, 2, 1)) ** 2","def kl_dist_smoothing(distribution1: np.array, distribution2: np.array, epsilon: float) -> float:\n # Performs smoothing\n distributions = [distribution1, distribution2]\n smoothed_distributions = []\n for distribution in distributions:\n nonzeros = np.count_nonzero(distribution)\n zeros = len(distribution) - nonzeros\n smoothed_distributions.append([epsilon if prob == 0 else prob - zeros * epsilon / nonzeros\n for prob in distribution])\n\n return sum(kl_div(smoothed_distributions[0], smoothed_distributions[1]))","def KL_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\n if data_range is None:\n data_range = list(set(xs)) + list(set(ys))\n if pdf_x is None:\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\n if pdf_y is None:\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\n keys = set(pdf_x.keys()+pdf_y.keys())\n PQ = []\n for k in keys:\n if k in pdf_x and k in pdf_y:\n PQ.append((pdf_x[k],pdf_y[k]))\n return np.sum([p*np.log(float(p)/float(q)) for (p,q) in PQ if q>0 and p>0])","def compute_grassman_distance(Y1, Y2):\n Q1, _ = jnp.linalg.qr(Y1)\n Q2, _ = jnp.linalg.qr(Y2)\n\n _, sigma, _ = jnp.linalg.svd(Q1.T @ Q2)\n sigma = jnp.round(sigma, decimals=6)\n return jnp.linalg.norm(jnp.arccos(sigma))","def zkl_divergence(x, y, gamma):\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])","def jeffreys(self, sigma):\n return 1. / sigma","def J_pointlike(self, dist):\n jfact = self.int_over_rho_sqr(self.max_radius) / dist**2.\n return np.log10(jfact)","def distributions_EMD(d1, d2):\n return ss.wasserstein_distance(d1.get_probs(), d2.get_probs()) / len(d1.get_probs())","def jaccard_dist(X, Y):\n return 1 - jaccard_sim(X, Y)","def dynamax_jaccard(x, y):\n # feature generation\n u = np.vstack((x, y))\n m_x = fuzzify(x, u)\n m_y = fuzzify(y, u)\n # fuzzy jaccard\n m_inter = np.sum(np.minimum(m_x, m_y))\n m_union = np.sum(np.maximum(m_x, m_y))\n return m_inter / m_union","def compute_jensen_shannon_divergence(\n input_file: str, output_file: str, config: Configuration\n) -> str:\n sanitized_input_file = input_file + \".sanitized\"\n _sanitize_jensen_shannon_divergence_input(input_file, sanitized_input_file)\n cmd = \"cd {} && python2 score_conservation.py {} > {}\".format(\n JENSE_SHANNON_DIVERGANCE_DIR,\n os.path.abspath(sanitized_input_file),\n os.path.abspath(output_file),\n )\n logging.info(\"Executing Jense Shannon Divergence script ...\")\n logging.debug(\"Executing command:\\n%s\", cmd)\n config.execute_command(cmd)\n return output_file","def jaccard_distance_loss(y_true, y_pred, smooth=1e-5):\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\n return (1 - jac) * smooth","def Jdiff(self, x1, x2, firstsecond='both'):\n assert (firstsecond in ['first', 'second', 'both'])\n if firstsecond == 'both':\n return [self.Jdiff(x1, x2, 'first'), self.Jdiff(x1, x2, 'second')]\n dx = np.zeros(self.ndx)\n h = self.disturbance\n J = np.zeros([self.ndx, self.ndx])\n d0 = self.diff(x1, x2)\n if firstsecond == 'first':\n for k in range(self.ndx):\n dx[k] = h\n J[:, k] = self.diff(self.integrate(x1, dx), x2) - d0\n dx[k] = 0\n elif firstsecond == 'second':\n for k in range(self.ndx):\n dx[k] = h\n J[:, k] = self.diff(x1, self.integrate(x2, dx)) - d0\n dx[k] = 0\n J /= h\n return J","def kl_divergence(x, y, thresholded=True, symmetrized=True, normalize=True):\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\n x.dtype == np.float32 and y.dtype == np.float32)\n # assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\n if thresholded:\n normalize = True\n if normalize:\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n if thresholded:\n eps = np.finfo(x.dtype).eps\n x = x + eps\n y = y + eps\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n res = __kl_divergence(x, y)\n\n if symmetrized:\n res = 0.5 * res + 0.5 * __kl_divergence(y, x).transpose()\n\n return np.float64(res).reshape(res.shape)","def jaccard_distance_loss(y_true, y_pred, smooth=100):\n\n epsilon = tf.convert_to_tensor(1e-7, dtype='float32')\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\n return (1 - jac)","def jaccard_distance_loss(y_true, y_pred, smooth=10):\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\n return (1 - jac) * smooth","def js_beta(d1, d2, beta):\n part1 = - soft_relu(-d1).mean()\n part2 = (beta + 2.0 - (- soft_relu(-d2)).exp()).log().mean()\n return part1 + part2 - np.log(1.0 + beta)","def kl_divergence(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n y_true = backend.clip(y_true, backend.epsilon(), 1)\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)","def func_ludwigson(eps,k1,n1,k2,n2,):\n return k1*eps**n1+np.exp(k2+n2*eps)","def J(W1, b1, W2, b2, x, y):\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\n return crossEntropy(y, yhat)","def compute_similarity(x, y, metric='kl_divergence'):\n from scipy.stats import entropy, pearsonr\n # remove zeros slightly increase divergence\n x = x[x != 0]\n y = y[y != 0]\n # outer join two distributions\n eps = min(x.min(), y.min()) / 10\n xy = pd.concat([x, y], axis=1).add(eps, fill_value=0)\n x = xy.iloc[:, 0]\n y = xy.iloc[:, 1]\n if metric == 'pearson':\n score, _ = pearsonr(x, y)\n else:\n score = entropy(x, y)\n return score","def d_mse(x, y):\n\n return 2 * (x - y) / x.size(0) / x.size(1)","def wasserstein_distance_1d(pers_diag_1, pers_diag_2) -> float:\n wasserstein_distance = d.wasserstein_distance(pers_diag_1[1], pers_diag_2[1],\n q=1, delta=0.2)\n return wasserstein_distance","def dist(x, y):\n dx = x[0] - y[0]\n dy = x[1] - y[1]\n ans = dx**2 + dy**2\n ans = ans**(0.5)\n return ans","def dist(x, y):\n dx = x[0] - y[0]\n dy = x[1] - y[1]\n ans = dx**2 + dy**2\n ans = ans**(0.5)\n return ans","def cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt(\n (\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\n ) / (len(x_arr) + len(y_arr))\n )\n return delta / pooled_std","def kolmogorov_smirnov_distance(self, other, show=False):\n from scipy.interpolate import interp1d\n cumdist1 = self.get_cumulative_distribution()\n cumdist2 = other.get_cumulative_distribution()\n \n # Normalize the x-values\n # range1 = np.max(cumdist1[\"x\"]) - np.min(cumdist1[\"x\"])\n # range2 = np.max(cumdist2[\"x\"]) - np.min(cumdist2[\"x\"])\n # cumdist1[\"x\"] -= np.min(cumdist1[\"x\"])\n # cumdist1[\"x\"] *= (range2/range1) \n # cumdist1[\"x\"] += np.min(cumdist2[\"x\"])\n\n interp_cumdist1 = interp1d(cumdist1[\"x\"], cumdist1[\"P\"], kind=\"linear\",\n fill_value=(0.0, 1.0), bounds_error=False)\n\n diff = cumdist2[\"P\"] - interp_cumdist1(cumdist2[\"x\"])\n\n ks_distance = np.max(np.abs(diff))\n\n if show:\n from matplotlib import pyplot as plt\n fig = plt.figure()\n ax = fig.add_subplot(1, 1, 1)\n ax.plot(cumdist1[\"x\"], cumdist1[\"P\"], drawstyle=\"steps\", label=\"First\")\n ax.plot(cumdist2[\"x\"], cumdist2[\"P\"], drawstyle=\"steps\", label=\"Second\")\n ax.set_xlabel(\"Normalized distances\")\n ax.set_ylabel(\"Cummulative Distribution\")\n ax.legend(loc=\"best\")\n plt.show()\n return ks_distance","def k(xs, ys, sigma=1, l=1):\n\n # Pairwise difference matrix.\n dx = np.expand_dims(xs, 1) - np.expand_dims(ys, 0)\n return (sigma ** 2) * np.exp(-((dx / l) ** 2) / 2)","def HJ_path(s1, s2):\n from sage.all import xgcd, ceil, floor\n assert s1 > s2, \"s1 must be larger than s2\"\n m1 = s1.numerator()\n d1 = s1.denominator()\n m2 = s2.numerator()\n d2 = s2.denominator()\n path = [(m1, d1)]\n while m1 / d1 > s2:\n _, x, y = xgcd(m1, d1)\n if d1 * m2 - m1 * d2 > 0:\n k = ceil((x * m2 + y * d2) / (d1 * m2 - m1 * d2))\n else:\n k = floor((x * m2 + y * d2) / (d1 * m2 - m1 * d2))\n m = - y - k * m1\n d = x - k * d1\n path.append((m, d))\n m1, d1 = m, d\n\n # these test are for debugging only, and should be unnecessary by now\n assert path[0][0] / path[0][1] == s1, \"first entry not correct: {}\".format(path)\n assert path[-1][0] / path[-1][1] == s2, \"last entry not correct: {}\".format(path)\n assert all([path[i][0] * path[i + 1][1] - path[i + 1][0] * path[i][1] == 1\n for i in range(len(path) - 1)]), \"determinant condition wrong: {}\".format(path)\n\n return path","def jeffreys(self, x):\n return np.sqrt(1. / x)","def J(theta, x, y):\n m = len(y)\n z = theta.dot(x.T) #argument for hypothesis function\n return 1. / m * np.sum(-y * np.log(g(z)) - (1. - y) * np.log(1 - g(z)))","def jeffreys(self, x):\n return 1./np.sqrt(x*(1.-x))","def lks_2samp (data1,data2):\r\n j1 = 0\r\n j2 = 0\r\n fn1 = 0.0\r\n fn2 = 0.0\r\n n1 = len(data1)\r\n n2 = len(data2)\r\n en1 = n1\r\n en2 = n2\r\n d = 0.0\r\n data1.sort()\r\n data2.sort()\r\n while j1 < n1 and j2 < n2:\r\n d1=data1[j1]\r\n d2=data2[j2]\r\n if d1 <= d2:\r\n fn1 = (j1)/float(en1)\r\n j1 = j1 + 1\r\n if d2 <= d1:\r\n fn2 = (j2)/float(en2)\r\n j2 = j2 + 1\r\n dt = (fn2-fn1)\r\n if math.fabs(dt) > math.fabs(d):\r\n d = dt\r\n try:\r\n en = math.sqrt(en1*en2/float(en1+en2))\r\n prob = ksprob((en+0.12+0.11/en)*abs(d))\r\n except:\r\n prob = 1.0\r\n return d, prob","def LJ(epsilon,sigma,r):\n P1=(sigma/r)**12\n P2=(sigma/r)**6\n return 4*epsilon*(P1-P2)","def kl_divergence(a, b, normalize=True):\n a, b = np.array(a), np.array(b)\n\n x = np.linspace(\n min(a.min(), b.min()) - 1,\n max(a.max(), b.max()) + 1,\n 100\n )\n\n p = gaussian_kde(a)(x)\n q = gaussian_kde(b)(x)\n\n if normalize:\n p = p/np.sum(p)\n q = q/np.sum(q)\n\n return np.sum(np.where(p != 0, (p) * np.log(p / q), 0))","def JointDistn(self):\r\n if len(self.factors)==1:\r\n return self.factors[0]\r\n F = self.factors[0]\r\n for i in range(1,len(self.factors)):\r\n F = F * self.factors[i]\r\n self.JDist = F\r\n return F","def cohens_d(x, y):\n nx, ny = len(x), len(y)\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\n ((nx - 1) + (ny - 1))\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)","def MyKLD(X,Y): \n mu1,mu2 = tuple(np.mean(X,axis=0))\n sigma1,sigma2 = tuple(np.std(X,axis=0))\n m1,m2 = tuple(np.mean(X,axis=0))\n s1,s2 = tuple(np.std(X,axis=0))\n rho = np.corrcoef(X,rowvar=False)[0,1]\n r = np.corrcoef(Y,rowvar=False)[0,1]\n \n return (\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\n (2 * (1 - r**2)) +\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \n (sigma2**2-s2**2)/s2**2) /\n (2 * (1 - r**2)) +\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\n )","def compute_distance(self, xi: NumpyFloatArray, xj: NumpyFloatArray) -> float:\n\n return pdist([xi, xj], \"braycurtis\")[0]","def rmsd(x, y):\n\n # get the length of the dataset\n n, = x.shape\n\n return np.sqrt(np.sum((x-y)**2)/n)","def compute_jerk(joint_trajectory):\r\n joint_vel = np.gradient(joint_trajectory, axis=1)\r\n joint_acc = np.gradient(joint_vel, axis=1)\r\n joint_jerk = np.gradient(joint_acc, axis=1)\r\n jerk = np.linalg.norm(joint_jerk)\r\n return jerk","def jackknifed_sdf_variance(yk, eigvals, sides='onesided', adaptive=True):\r\n K = yk.shape[0]\r\n\r\n from nitime.algorithms import mtm_cross_spectrum\r\n\r\n # the samples {S_k} are defined, with or without weights, as\r\n # S_k = | x_k |**2\r\n # | x_k |**2 = | y_k * d_k |**2 (with adaptive weights)\r\n # | x_k |**2 = | y_k * sqrt(eig_k) |**2 (without adaptive weights)\r\n\r\n all_orders = set(range(K))\r\n jk_sdf = []\r\n # get the leave-one-out estimates -- ideally, weights are recomputed\r\n # for each leave-one-out. This is now the case.\r\n for i in range(K):\r\n items = list(all_orders.difference([i]))\r\n spectra_i = np.take(yk, items, axis=0)\r\n eigs_i = np.take(eigvals, items)\r\n if adaptive:\r\n # compute the weights\r\n weights, _ = adaptive_weights(spectra_i, eigs_i, sides=sides)\r\n else:\r\n weights = eigs_i[:, None]\r\n # this is the leave-one-out estimate of the sdf\r\n jk_sdf.append(\r\n mtm_cross_spectrum(\r\n spectra_i, spectra_i, weights, sides=sides\r\n )\r\n )\r\n # log-transform the leave-one-out estimates and the mean of estimates\r\n jk_sdf = np.log(jk_sdf)\r\n # jk_avg should be the mean of the log(jk_sdf(i))\r\n jk_avg = jk_sdf.mean(axis=0)\r\n\r\n K = float(K)\r\n\r\n jk_var = (jk_sdf - jk_avg)\r\n np.power(jk_var, 2, jk_var)\r\n jk_var = jk_var.sum(axis=0)\r\n\r\n # Thompson's recommended factor, eq 18\r\n # Jackknifing Multitaper Spectrum Estimates\r\n # IEEE SIGNAL PROCESSING MAGAZINE [20] JULY 2007\r\n f = (K - 1) ** 2 / K / (K - 0.5)\r\n jk_var *= f\r\n return jk_var","def _sbd(x, y):\r\n ncc = _ncc_c(x, y)\r\n idx = ncc.argmax()\r\n dist = 1 - ncc[idx]\r\n yshift = roll_zeropad(y, (idx + 1) - max(len(x), len(y)))\r\n\r\n return dist, yshift","def jeffreys(self, mu, sigma):\n return 1./sigma**3.","def get_johansen(self, y, p, r=0):\n\n N, l = y.shape\n jres = coint_johansen(y, 0, p)\n trstat = jres.lr1 # trace statistic\n tsignf = jres.cvt # critical values\n\n if not r:\n for i in range(l):\n if trstat[i] > tsignf[i, 1]: # 0: 90% 1:95% 2: 99%\n r = i + 1\n if np.sign(jres.evec[0, i]) == -1: # sign of first elem\n jres.evec[:, i] = -jres.evec[:, i]\n\n jres.r = r\n jres.evecr = jres.evec[:, :r]\n\n return jres","def _build_dist(self):\n lamb = self.params['lamb']\n p = self.params['p']\n\n jac = self.jacobian\n # build D on grids\n xg, yg, mask = self._mask_grid()\n r_max = self._r_max(xg, yg, mask)\n d_mat = self._psf_grid(xg, yg, r_max=r_max)\n # E[yy^T]\n j_j_w = np.dot(jac, jac.transpose())\n r_mat = np.diag(np.diag(j_j_w) ** p)\n jac_inv = la.inv(j_j_w + lamb*r_mat)\n # RM = E[xx^T] / E[yy^T]\n h_mat = np.dot(np.dot(d_mat, jac.transpose()), jac_inv)\n return h_mat","def smoothnessChi2(self, other, params, useSelf = True, useOther = True):\n\t\tif not self.sectors == other.sectors:\n\t\t\traise ValueError(\"Sectors do not match\")\n\t\tDself = np.zeros((2*self.totalBins))\n\t\tDother = np.zeros((2*other.totalBins))\n\t\tparamsSelf = params[:2*self.nZero]\n\t\tparamsOther = params[2*self.nZero:]\n#\t\tprint self.nZero, other.nZero, params,\"LLLLLLLLLOOPPdssa\"\n\n\t\tampsSelf = self.getCorrectedAmplitudes(paramsSelf)\n\t\tampsOther = other.getCorrectedAmplitudes(paramsOther)\n\t\tfor s in range(self.nSect):\n\t\t\tstartSelf = self.borders[s]\n\t\t\tstartOther = other.borders[s]\n\t\t\tnBins = min(self.borders[s+1] - self.borders[s], other.borders[s+1] - other.borders[s])\n\t\t\tfor i in range(nBins):\n\t\t\t\tDself[2*(startSelf + i) ] = ampsSelf[2*(i+startSelf) ] - ampsOther[2*(i+startOther) ]\n\t\t\t\tDself[2*(startSelf + i)+1] = ampsSelf[2*(i+startSelf)+1] - ampsOther[2*(i+startOther)+1]\n\n\t\t\t\tDother[2*(startOther + i) ] = ampsSelf[2*(i+startSelf) ] - ampsOther[2*(i+startOther) ]\n\t\t\t\tDother[2*(startOther + i)+1] = ampsSelf[2*(i+startSelf)+1] - ampsOther[2*(i+startOther)+1]\n\t\tCself = np.dot(Dself, np.dot(self.comaInv, Dself))\n\t\tCother = np.dot(Dother, np.dot(other.comaInv, Dother))\n\t\tretVal = 0.\n\t\tif useSelf:\n\t\t\tretVal += Cself\n\t\tif useOther:\n\t\t\tretVal += Cother\n\t\treturn retVal","def wealth_cons_ratio(ssyd, \n tol=1e-7, \n init_val=1, \n max_iter=1_000_000,\n verbose=False):\n\n # Unpack and set up parameters EpsteinZin parameters\n ψ, γ, β = ssyd.ssy.ψ, ssyd.ssy.γ, ssyd.ssy.β\n θ = (1 - γ) / (1 - 1/ψ)\n ζ = 1 - β\n\n K_matrix = compute_K(ssyd)\n M = ssyd.K * ssyd.I * ssyd.J\n w = np.ones(M) * init_val\n iter = 0\n error = tol + 1\n\n r = compute_spec_rad(K_matrix)\n if verbose:\n print(f\"Test value = {r**(1/θ)} and θ = {θ}\")\n print(\"Beginning iteration\\n\\n\")\n\n\n while error > tol and iter < max_iter:\n Tw = ζ + β * (K_matrix @ (w**θ))**(1/θ)\n error = np.max(np.abs(w - Tw))\n w = Tw\n iter += 1\n\n if verbose:\n print(f\"Iteration converged after {iter} iterations\") \n\n return w / ζ","def kde_agent(beta, bid, i, m, bw = None, *args):\n if bw is None: bw = 'scott'\n\n i0 = D.index[0]\n if only_cond == {'d'}:\n s1 = D.ix[i0:i, 's1_rp']\n if len(s1) == 1:\n s1[i0+1] = sp.mean([s1, 10])\n else:\n s1est = args[0]\n ar = D.ix[i, 'out_bool']\n b1 = D.ix[i, 'bid']\n b1i = round2(b1)\n if len(s1est) == 1:\n s1est.append(sp.mean([s1est[0], 10])) \n else:\n gks = stats.gaussian_kde(s1est, bw_method = bw)\n if ar:\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \n else:\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \n s1est.append(aest) \n s1 = s1est\n gks = stats.gaussian_kde(s1, bw_method = bw)\n Ks1 = gks.pdf(B) \n Ks1 /= sum(Ks1)\n\n if m == 'SC':\n if only_cond == {'d'}:\n s2 = D.ix[i0:i, 's2_rp'].dropna()\n if len(s2) == 1:\n s2[i+1] = sp.mean([s2[i], 10]) \n else:\n s2est = args[1]\n if len(s2est) == 1:\n s2est.append(sp.mean([s2est[0], 10])) \n else:\n gks = stats.gaussian_kde(s2est, bw_method = bw)\n if ar:\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \n else:\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \n s2est.append(aest) \n s2 = s2est\n gks = stats.gaussian_kde(s2, bw_method = bw)\n Ks2 = gks.pdf(B) \n Ks2 /= sum(Ks2)\n U = kdeag_uf(Ks1, Ks2, None)\n s2orb2 = s2\n elif m == 'NC':\n U = kdeag_uf(Ks1, None, None)\n s2orb2 = None\n elif m == 'BC':\n if only_cond == {'d'}:\n b2 = D.ix[i0:i, 'b2_bid'].dropna()\n if len(b2) == 1:\n b2[i+1] = sp.mean([b2[i], 10]) \n else:\n b2est = args[1]\n if len(b2est) == 1:\n b2est.append(sp.mean([b2est[0], 10])) \n else:\n gks = stats.gaussian_kde(b2est, bw_method = bw)\n if ar:\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \n else:\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \n b2est.append(aest) \n b2 = b2est\n gks = stats.gaussian_kde(b2, bw_method = bw)\n Kb2 = gks.pdf(B) \n Kb2 /= sum(Kb2)\n U = kdeag_uf(Ks1, None, Kb2)\n s2orb2 = b2\n \n opb = B[sp.argmax(U)]\n p = boltzmann_dist(beta, U, int(bid*((Bbins-1)/10)))#p = P[int(bid*((Bbins-1)/10))]\n return p, opb, s1, s2orb2, U","def emd(pdd, pdd_, metric='chebyshev', **kwargs):\n \n from .core.Wasserstein import wasserstein\n \n dm = cdist(pdd[:, 1:], pdd_[:, 1:], metric=metric, **kwargs)\n \n return wasserstein(pdd[:, 0], pdd_[:, 0], dm)","def ddf(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\n out = torch.pow(y1, 2)\n mul = y1 * y2\n mul.exp_()\n\n div = mul.reciprocal()\n div.add_(mul).add_(2)\n out.div_(div)\n return out","def hellinger(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\n\n\tdistance = ( 1 / np.sqrt( 2 ) ) * np.sqrt( np.sum( ( np.sqrt( x.flat_cpt() ) - np.sqrt( y.flat_cpt() ) )**2) )\n\treturn distance","def Kendalls_Tau2(xlist, ylist):\n\tif len(xlist) != len(ylist):\n\t\traise StatsError(\"Data sets have different lengths.\")\n\txdata = xlist\n\tydata = ylist\n\t#for i in range(len(xlist)):\n\t#\tif xlist[i] != None and ylist[i] != None:\n\t#\t\txdata.append(xlist[i])\n\t#\t\tydata.append(ylist[i])\n\tassert len(xdata) == len(ydata)\n\t#assert len(xdata) <= len(xlist) - xlist.count(None)\n\t#assert len(ydata) <= len(ylist) - ylist.count(None)\n\t#assert len(ydata) >= len(ylist) - xlist.count(None) - ylist.count(None)\n\tif len(xdata) == 0:\n\t\traise StatsError(\"No valid data entries.\")\n\tn = len(xdata)\n\t# compute the number of concordant and discordant pairs\n\tconc = disc = 0.0 # concordant and discordant pairs\n\tnx = ny = 0.0\n\tupdown = 0\n\tfor i in range(n): # loop over all pairs\n\t\txi = xdata[i]\n\t\tyi = ydata[i]\n\t\tif xi and yi:\n\t\t\tfor j in range(i + 1, n):\n\t\t\t\tif xdata[j] and ydata[j]:\n\t\t\t\t\txd = xi - xdata[j]\n\t\t\t\t\tyd = yi - ydata[j]\n\t\t\t\t\tprod = xd * yd\n\t\t\t\t\tif prod != 0:\n\t\t\t\t\t\tnx += 1\n\t\t\t\t\t\tny += 1\n\t\t\t\t\t\tif prod > 0:\n\t\t\t\t\t\t\tupdown += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tupdown -= 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tif xd != 0:\n\t\t\t\t\t\t\tnx += 1\n\t\t\t\t\t\tif yd != 0:\n\t\t\t\t\t\t\tny += 1\n\t# Compute tau\n\tn = float(n)\n\tdenom = math.sqrt(nx*ny)\n\ttry:\n\t\ttau = float(updown) / denom\n\texcept ZeroDivisionError:\n\t\traise StatsError(\"Too few entries: {:d}\".format(n))\n\t# Compute P-value\n\tz = 3.0 * tau * math.sqrt(n * (n - 1.0)) / math.sqrt(2.0 * (2.0 * n + 5.0))\n\tprob = Prob_Z(z)\n\treturn (tau, prob, int(n))","def _dK_computations(self, dL_dK):\r\n \r\n self._dL_dl = (dL_dK*self.variance*self._K_dvar*(self.input_dim/2.*(self._lengthscales_two.T**4 - self._lengthscales**4) + 2*self._lengthscales2*self._K_dist2)/(self._w2*self._w2*self._lengthscales)).sum(1)\r\n if self._lengthscales_two is self._lengthscales:\r\n self._dL_dl_two = None\r\n else:\r\n self._dL_dl_two = (dL_dK*self.variance*self._K_dvar*(self.input_dim/2.*(self._lengthscales**4 - self._lengthscales_two.T**4 ) + 2*self._lengthscales_two2.T*self._K_dist2)/(self._w2*self._w2*self._lengthscales_two.T)).sum(0)","def compute_sgd_gradient(self, x_j, t_j):\n a = np.dot(x_j.T, self.w)\n return -1 * t_j * (1 / (1 + np.exp(a * t_j))) * x_j","def alt_cohen_d(x_arr, y_arr):\n delta = np.mean(x_arr) - np.mean(y_arr)\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\n np.std(y_arr, ddof=1) ** 2) / 2.0)\n return delta / pooled_std","def hellinger_distance(x, y):\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\n x.dtype == np.float32 and y.dtype == np.float32)\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\n x /= x.sum(1).reshape(x.shape[0], 1)\n y /= y.sum(1).reshape(y.shape[0], 1)\n x = np.sqrt(x)\n y = np.sqrt(y)\n # x (120, 40), y (100, 40), H(x,y) (120, 100)\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\n yy = np.tile(y, (x.shape[0], 1, 1))\n xx_yy = xx - yy\n res = np.sqrt(np.sum(xx_yy ** 2, axis=-1))\n return np.float64((1. / np.sqrt(2)) * res)","def metric(x, y):\n d = 2\n summ = []\n i = 0\n while i < len(x):\n # in this case use euclidean distance\n summ.append((x[i] - y[i])**d)\n i = i + 1\n return sum(summ) ** (1 / float(d))","def test_jn():\n import time\n t1 = time.time()\n\n n_list = [ 3, 4, 1, 0, 9, 7 ]\n x_list = [ 0, 1.01, 0.2, 3.3, 5.9, 77. ]\n vals1 = [ galsim.bessel.jn(n,x) for n,x in zip(n_list,x_list) ]\n print 'x = ',x_list\n print 'vals1 = ',vals1\n\n try:\n import scipy.special\n vals2 = [ scipy.special.jn(n,x) for n,x in zip(n_list,x_list) ]\n print 'vals2 = ',vals2\n np.testing.assert_almost_equal(\n vals1, vals2, 8, \"bessel.jn disagrees with scipy.special.jn\")\n except ImportError:\n print 'Unable to import scipy. Skipping scipy tests of jn.'\n\n # These values are what scipy returns. Check against these, so not require scipy.\n vals2 = [ 0.0,\n 0.0025745895535573995,\n 0.099500832639236036,\n -0.34429626039888467,\n 0.018796532416195257,\n -0.082526868218916541\n ]\n np.testing.assert_almost_equal(\n vals1, vals2, 8, \"bessel.jn disagrees with reference values\")\n\n t2 = time.time()\n print 'time for %s = %.2f'%(funcname(),t2-t1)","def jacaard(clusters_a, clusters_b):\n return jaccard_similarity_score(clusters_a, clusters_b)","def sdep(y, yHat):\n n = y.shape[0]\n\n numer = ((y - yHat) ** 2).sum()\n\n sdep = (numer / n) ** 0.5\n\n return sdep","def _graph_fn_kl_divergence(distribution_a, distribution_b):\n if get_backend() == \"tf\":\n return tf.no_op()\n # TODO: never tested. tf throws error: NotImplementedError: No KL(distribution_a || distribution_b) registered for distribution_a type Bernoulli and distribution_b type ndarray\n #return tf.distributions.kl_divergence(\n # distribution_a=distribution_a,\n # distribution_b=distribution_b,\n # allow_nan_stats=True,\n # name=None\n #)","def JS_divergence_tdp(peq1, D1, p01, peq2, D2, p02, weights, lQ1, Qx1, lQ2, Qx2, terminal_time=0.5, number_of_samples=5):\n time = np.linspace(0, terminal_time, number_of_samples)\n out = JS_divergence(p01, p02, weights) / 2\n rho0d1 = Qx1.T.dot(np.diag(weights)).dot(p01 / np.sqrt(peq1))\n rho0d2 = Qx2.T.dot(np.diag(weights)).dot(p02 / np.sqrt(peq2))\n\n for i in range(1, len(time)):\n p1 = (Qx1.dot(rho0d1.dot(\n np.diag(np.exp(-lQ1 * (time[i] - time[0])))))) * np.sqrt(peq1)\n p2 = (Qx2.dot(rho0d2.dot(\n np.diag(np.exp(-lQ2 * (time[i] - time[0])))))) * np.sqrt(peq2)\n out += JS_divergence(p1, p2, weights, 'unnormalized')\n # print(out)\n return out * (time[1] - time[0])","def kl_bern(x, y):\n x = min(max(x, eps), 1-eps)\n y = min(max(y, eps), 1-eps)\n return x*log(x/y) + (1-x)*log((1-x)/(1-y))","def vf_wasserstein_distance(x, y, critic):\n return torch.mean(critic(x)) - torch.mean(critic(y))","def test_renyi_values():\n d1 = Distribution(['0', '1'], [0, 1])\n d2 = Distribution(['0', '1'], [1 / 2, 1 / 2])\n d3 = Distribution(['0', '1'], [1, 0])\n\n assert renyi_divergence(d1, d2, 1 / 2) == pytest.approx(np.log2(2))\n assert renyi_divergence(d2, d3, 1 / 2) == pytest.approx(np.log2(2))\n assert renyi_divergence(d1, d3, 1 / 2) == pytest.approx(np.inf)","def jaccard_distance(y_true, y_pred, smooth=100):\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\n return K.abs(1 - jac) * smooth","def calc_linear_dispersion(self):\n self._check_k_columns([\"K0L\", \"K0SL\", \"K1SL\"])\n tw = self.twiss_df\n phs_adv = self.get_phase_adv()\n res = self._results_df\n coeff_fun = self._linear_dispersion_coeff\n sum_fun = self._linear_dispersion_sum\n\n # Calculate\n LOG.debug(\"Calculate Linear Dispersion\")\n with timeit(lambda t: LOG.debug(\" Time needed: {:f}\".format(t))):\n # sources\n k0_mask = tw['K0L'] != 0\n k0s_mask = tw['K0SL'] != 0\n k1s_mask = tw['K1SL'] != 0\n\n mx_mask = k0_mask | k1s_mask # magnets contributing to Dx,j (-> Dy,m)\n my_mask = k0s_mask | k1s_mask # magnets contributing to Dy,j (-> Dx,m)\n\n if not any(mx_mask | my_mask):\n LOG.warning(\" No linear dispersion contributions found. Values will be zero.\")\n res['DX'] = 0.\n res['DY'] = 0.\n self._log_added('DX', 'DY')\n return\n\n # create temporary DataFrame for magnets with coefficients already in place\n df = tfs.TfsDataFrame(index=tw.index).join(\n coeff_fun(tw.loc[:, 'BETX'], tw.Q1)).join(\n coeff_fun(tw.loc[:, 'BETY'], tw.Q2))\n df.columns = ['COEFFX', 'COEFFY']\n\n LOG.debug(\" Calculate uncoupled linear dispersion\")\n df.loc[my_mask, 'DX'] = df.loc[my_mask, 'COEFFX'] * \\\n sum_fun(tw.loc[mx_mask, 'K0L'],\n 0,\n 0,\n tw.loc[mx_mask, 'BETX'],\n tau(phs_adv['X'].loc[mx_mask, my_mask], tw.Q1)\n ).transpose()\n df.loc[mx_mask, 'DY'] = df.loc[mx_mask, 'COEFFY'] * \\\n sum_fun(-tw.loc[my_mask, 'K0SL'], # MINUS!\n 0,\n 0,\n tw.loc[my_mask, 'BETY'],\n tau(phs_adv['Y'].loc[my_mask, mx_mask], tw.Q2)\n ).transpose()\n\n LOG.debug(\" Calculate full linear dispersion values\")\n res.loc[:, 'DX'] = df.loc[:, 'COEFFX'] * \\\n sum_fun(tw.loc[mx_mask, 'K0L'],\n tw.loc[mx_mask, 'K1SL'],\n df.loc[mx_mask, 'DY'],\n tw.loc[mx_mask, 'BETX'],\n tau(phs_adv['X'].loc[mx_mask, :], tw.Q1)\n ).transpose()\n res.loc[:, 'DY'] = df.loc[:, 'COEFFY'] * \\\n sum_fun(-tw.loc[my_mask, 'K0SL'], # MINUS!\n tw.loc[my_mask, 'K1SL'],\n df.loc[my_mask, 'DX'],\n tw.loc[my_mask, 'BETY'],\n tau(phs_adv['Y'].loc[my_mask, :], tw.Q2)\n ).transpose()\n\n LOG.debug(\" Average linear dispersion Dx: {:g}\".format(\n np.mean(res['DX'])))\n LOG.debug(\" Average linear dispersion Dy: {:g}\".format(\n np.mean(res['DY'])))\n self._log_added('DX', 'DY')","def grad_j(self,w,j):\n g = 0\n for i in range(len(self.x)):\n # Each example contributes -sigma(-y_i * x_i.w) * y_j x_ij\n g -= sigmoid(-self.y[i] * np.dot(w, self.x[i,:])) * self.y[i] * self.x[i,j]\n #regularisation\n g += self.alpha * w[j]\n return g","def test_divergences_to_kl2(dists, divergence):\n for dist1, dist2 in combinations(dists, 2):\n assert divergence(dist1, dist2, alpha=1) == pytest.approx(kullback_leibler_divergence(dist1, dist2))","def js_sort(d1, d2, beta):\n n = d1.shape[0]\n n_selected = int(n // (1.0 + beta))\n d1_selected = torch.topk(d1, n_selected, largest=False, sorted=False)[0]\n return js_div(d1_selected, d2)","def compute_jacs(x_sp,params_sens_dict,integration_params,**kwargs):\n\n # check if sensitivity to all params\n if kwargs['diffeq_params'] is None:\n diffeq_params = params_sens_dict\n params_sensitivity_sp = list(params_sens_dict.values())\n\n else:\n diffeq_params = kwargs['diffeq_params'].copy()\n params_sensitivity_sp = list(params_sens_dict.values())\n for key,value in params_sens_dict.items():\n diffeq_params[key] = value\n\n SDerivSymbolic = sp.Matrix(SDeriv(0,x_sp,integration_params,diffeq_params))\n\n # derivative of rhs wrt params\n SDerivSymbolicJacParams = SDerivSymbolic.jacobian(params_sensitivity_sp)\n SDerivSymbolicJacParamsLamb = sp.lambdify((x_sp,params_sensitivity_sp), SDerivSymbolicJacParams,'numpy')\n SDerivSymbolicJacParamsLambFun = lambda t,x,params: SDerivSymbolicJacParamsLamb(x,params)\n\n # derivative of rhs wrt Conc\n SDerivSymbolicJacConc = SDerivSymbolic.jacobian(x_sp)\n SDerivSymbolicJacConcLamb = sp.lambdify((x_sp,params_sensitivity_sp),SDerivSymbolicJacConc,'numpy')\n SDerivSymbolicJacConcLambFun = lambda t,x,params: SDerivSymbolicJacConcLamb(x,params)\n\n return [SDerivSymbolicJacParamsLambFun,SDerivSymbolicJacConcLambFun]","def kde2D(x, y, bandwidth, xbins=100j, ybins=100j, **kwargs):\n\n # create grid of sample locations (default: 100x100)\n xx, yy = np.mgrid[x.min():x.max():xbins, \n y.min():y.max():ybins]\n\n xy_sample = np.vstack([yy.ravel(), xx.ravel()]).T\n xy_train = np.vstack([y, x]).T\n\n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\n kde_skl.fit(xy_train)\n\n # score_samples() returns the log-likelihood of the samples\n z = np.exp(kde_skl.score_samples(xy_sample))\n return xx, yy, np.reshape(z, xx.shape)","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n dist = np.sqrt(np.sum(np.square((X[:,None,:]-X2[None,:,:])/self.lengthscale),-1))\r\n invdist = 1./np.where(dist!=0.,dist,np.inf)\r\n dist2M = np.square(X[:,None,:]-X2[None,:,:])/self.lengthscale**3\r\n dvar = (1+np.sqrt(5.)*dist+5./3*dist**2)*np.exp(-np.sqrt(5.)*dist)\r\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\r\n target[0] += np.sum(dvar*dL_dK)\r\n if self.ARD:\r\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\r\n #dl = (self.variance* 3 * dist * np.exp(-np.sqrt(3.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\r\n target[1:] += (dl*dL_dK[:,:,None]).sum(0).sum(0)\r\n else:\r\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist)) * dist2M.sum(-1)*invdist\r\n #dl = (self.variance* 3 * dist * np.exp(-np.sqrt(3.)*dist)) * dist2M.sum(-1)*invdist\r\n target[1] += np.sum(dl*dL_dK)","def dphidalpha_j(x, alpha_j, beta_j, gamma_j):\n def f(xp):\n delta = xp - gamma_j\n return csrbf(math.sqrt(beta_j*delta*beta_j*delta))\n vf = num.vectorize(f)\n return vf(x)","def return_js_matrix(distributions1, distributions2, verbose=0):\n assert distributions1.shape[1] == distributions2.shape[1], \\\n \"Distributions must have matching dimensions. Consider using merge_energies\"\n js_matrix = np.zeros((len(distributions1), len(distributions2)))\n for i in trange(len(distributions1), desc='dist1 loop', disable=verbose<=0):\n for j in trange(len(distributions2), desc='dist2 loop', disable=verbose<=1):\n masses1 = distributions1[i]\n masses2 = distributions2[j]\n js = entropy((masses1+masses2)/2) -\\\n entropy(masses1)/2 - entropy(masses2)/2\n js_matrix[i, j] = js\n return js_matrix","def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\n kl_cost = torch.mean(kl_cost, 0)\n return torch.sum(kl_cost)","def J(cst, x):\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\n [u, v, g1, g2, g3] = x\n df1du = 2*u*g3**2 - 2*g3*u0 + 2*g3*coeffs[3]*(g1*u1-u0) + 2*g3*coeffs[4]*(g2*u2-u0)\n df1dv = -2*v*g3**2 + 2*g3*v0 - 2*g3*coeffs[3]*(g1*v1-v0) - 2*g3*coeffs[4]*(g2*v2-v0)\n df1dg1 = 2*g1*coeffs[0]*(u1**2-v1**2) + 2*(v1*v0-u1*u0)*(coeffs[0]+coeffs[1]+coeffs[3]) + 2*g2*coeffs[1]*(u1*u2-v1*v2) + 2*g3*coeffs[3]*(u1*u-v1*v)\n df1dg2 = 2*g2*coeffs[2]*(u2**2-v2**2) + 2*(v2*v0-u2*u0)*(coeffs[1]+coeffs[2]+coeffs[4]) + 2*g1*coeffs[1]*(u1*u2-v1*v2) + 2*g3*coeffs[4]*(u2*u-v2*v)\n df1dg3 = 2*g3*(u**2-v**2) + 2*(v*v0-u*u0)*(coeffs[3]+coeffs[4]+1) + 2*g1*coeffs[3]*(u1*u-v1*v) + 2*g2*coeffs[4]*(u2*u-v2*v)\n\n df2du = 0\n df2dv = 2*v*g3**2 + 2*g3*(-v0 + coeffs[3]*(g1*v1-v0) + coeffs[4]*(g2*v2-v0))\n df2dg1 = 2*g1*coeffs[0]*(v1**2-1) + 2*(1-v1*v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + 2*g2*coeffs[1]*(v1*v2-1) + 2*g3*coeffs[3]*(v1*v-1)\n df2dg2 = 2*g2*coeffs[2]*(v2**2-1) + 2*(1-v2*v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + 2*g1*coeffs[1]*(v1*v2-1) + 2*g3*coeffs[4]*(v2*v-1)\n df2dg3 = 2*g3*(v**2-1) + 2*(1-v*v0)*(coeffs[3]+coeffs[4]+1) + 2*g1*coeffs[3]*(v1*v-1) + 2*g2*coeffs[4]*(v2*v-1)\n\n df3du = g3*coeffs[3]*(g1*v1-v0) + g3*coeffs[4]*(g2*v2-v0) + g3*(g3*v-v0)\n df3dv = g3*coeffs[3]*(g1*u1-u0) + g3*coeffs[4]*(g2*u2-u0) + g3*(g3*u-u0)\n df3dg1 = 2*g1*coeffs[0]*u1*v1 - (v1*u0+u1*v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(u1*v2+v1*u2) + g3*coeffs[3]*(v1*u+u1*v)\n df3dg2 = 2*g2*coeffs[2]*u2*v2 - (v2*u0+u2*v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(u1*v2+v1*u2) + g3*coeffs[4]*(v2*u+u2*v)\n df3dg3 = 2*g3*u*v - (u*v0+v*u0)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(v1*u+u1*v) + g2*coeffs[4]*(v2*u+u2*v)\n\n df4du = g3*coeffs[3]*(g1-1) + g3*coeffs[4]*(g2-1) + g3*(g3-1)\n df4dv = 0\n df4dg1 = 2*g1*coeffs[0]*u1 - (u0+u1)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(u1+u2) + g3*coeffs[3]*(u+u1)\n df4dg2 = 2*g2*coeffs[2]*u2 - (u0+u2)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(u1+u2) + g3*coeffs[4]*(u+u2)\n df4dg3 = 2*g3*u - (u+u0)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(u+u1) + g2*coeffs[4]*(u+u2)\n\n df5du = 0\n df5dv = g3*coeffs[3]*(g1-1) + g3*coeffs[4]*(g2-1) + g3*(g3-1)\n df5dg1 = 2*g1*coeffs[0]*v1 - (v1+v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(v2+v1) + g3*coeffs[3]*(v1+v)\n df5dg2 = 2*g2*coeffs[2]*v2 - (v2+v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(v2+v1) + g3*coeffs[4]*(v2+v)\n df5dg3 = 2*g3*v - (v0+v)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(v1+v) + g2*coeffs[4]*(v2+v)\n\n return np.array([\n [df1du, df1dv, df1dg1, df1dg2, df1dg3],\n [df2du, df2dv, df2dg1, df2dg2, df2dg3],\n [df3du, df3dv, df3dg1, df3dg2, df3dg3],\n [df4du, df4dv, df4dg1, df4dg2, df4dg3],\n [df5du, df5dv, df5dg1, df5dg2, df5dg3],\n ])","def LJ(r, epsilon, sigma, x, y):\n A=((x/y)**(x/(x-y))/((x/y)-1))\n\n\n V=A*epsilon*((sigma/r)**x-(sigma/r)**y) #-4*Epsilon*((Sigma/Rc)**12-(Sigma/Rc)**6)\n\n return V","def needleman_wunsch(s1, s2):\n\n if s1 is None or s2 is None:\n return np.NaN\n if pd.isnull(s1) or pd.isnull(s2):\n return np.NaN\n\n # Create the similarity measure object\n measure = sm.NeedlemanWunsch()\n\n s1 = gh.convert_to_str_unicode(s1)\n s2 = gh.convert_to_str_unicode(s2)\n\n # Call the function to compute the similarity measure\n return measure.get_raw_score(s1, s2)","def find_knee(x,y):\n\n # find ranges\n if len(x) != len(y):\n raise Exception(\"bad data\")\n tot_len = len(x)\n \n \n \n # fit strait lines to both\n\n # find intercept\n knee_r = (f_top.beta[1] - f_bottom.beta[1])/(-f_top.beta[0] + f_bottom.beta[0])","def KSStat(xs,ys,reweight=False,cdf_x=None,cdf_y=None,data_range=None):\n if cdf_x is None and cdf_y is None and data_range is None:\n data_range = list(set(xs)) + list(set(ys))\n if cdf_x is None:\n cdf_x = cum_density_func(xs,norm=True,rank=False,data_range=data_range)\n if cdf_y is None:\n cdf_y = cum_density_func(ys,norm=True,rank=False,data_range=data_range)\n keys = set(cdf_x.keys()+cdf_y.keys())\n SP = []\n for k in keys:\n if k in cdf_x and k in cdf_y:\n SP.append((cdf_x[k],cdf_y[k]))\n if reweight:\n return np.max([np.abs(s-p)/np.sqrt(p*(1.0-p)) for (s,p) in SP])\n else:\n return np.max([np.abs(s-p) for (s,p) in SP])"],"string":"[\n \"def compute_js_divergence(df_1, df_2, n_bins=30):\\n a = np.concatenate((df_1, df_2), axis=0)\\n e, p = prob_mass_fun(df_1, n = n_bins, range = (a.min(), a.max()))\\n _, q = prob_mass_fun(df_2, n = e, range = (a.min(), a.max()))\\n\\n return scipy.spatial.distance.jensenshannon(p, q)\",\n \"def js_divergence(dist1, dist2):\\n mean_dist = (dist1 + dist2) / 2.0\\n js = (\\n scipy.stats.entropy(dist1, mean_dist) + scipy.stats.entropy(dist2, mean_dist)\\n ) / 2.0\\n return js\",\n \"def js_divergence(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tz = 0.5 * ( x.flat_cpt() + y.flat_cpt() )\\n\\tdistance = 0.5 * kl_divergence(x,z) + 0.5 * kl_divergence(y,z)\\n\\treturn distance\",\n \"def JS_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\\n if data_range is None:\\n data_range = list(set(xs)) + list(set(ys))\\n if pdf_x is None:\\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\\n if pdf_y is None:\\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\\n M = {}\\n for i in pdf_x:\\n if i not in pdf_y:\\n pdf_y[i] = 0.0\\n for i in pdf_y:\\n if i not in pdf_x:\\n pdf_y[i] = 0.0\\n for i in pdf_x:\\n M[i] = .5*(pdf_x[i] + pdf_y[i])\\n return .5*KL_divergence(None,\\n None,\\n pdf_x=pdf_x,\\n pdf_y=M,\\n data_range=data_range) + \\\\\\n .5*KL_divergence(None,\\n None,\\n pdf_x=pdf_y,\\n pdf_y=M,\\n data_range=data_range)\",\n \"def kl_divergence(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tdistance = np.sum( x.flat_cpt() * np.log( x.flat_cpt() / y.flat_cpt() ) )\\n\\treturn distance\",\n \"def _hess_j(C_j, I_j, b_j, b_j_norm, a_1_j, a_2_j):\\n D_j = torch.ger(b_j, b_j)\\n return C_j + (a_1_j / b_j_norm) * (I_j - D_j / (b_j_norm ** 2)) + a_2_j * I_j\",\n \"def js_divergence(x, y, normalize=True):\\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\\n x.dtype == np.float32 and y.dtype == np.float32)\\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\\n\\n if normalize:\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\\n yy = np.tile(y, (x.shape[0], 1, 1))\\n m = (xx + yy) / 2\\n x_m = np.sum(xx * np.log(m), axis=2)\\n y_m = np.sum(yy * np.log(m), axis=2)\\n x_x = np.tile(\\n np.sum(x * np.log(x), axis=1).reshape(x.shape[0], 1), (1, y.shape[0]))\\n y_y = np.tile(np.sum(\\n y * np.log(y), axis=1).reshape(y.shape[0], 1),\\n (1, x.shape[0])).transpose()\\n res = 0.5 * (x_x - x_m) + 0.5 * (y_y - y_m)\\n return np.float64(res)\\n # division by zero\",\n \"def JSDivergence(p_output, q_output, get_softmax=True, dim=1):\\n if get_softmax:\\n p_output = F.softmax(p_output, dim=dim)\\n # q_output = F.softmax(q_output, dim=dim)\\n log_mean_output = ((p_output + q_output )/2).log()\\n return (\\n F.kl_div(log_mean_output, p_output, reduction='batchmean') + \\n F.kl_div(log_mean_output, q_output, reduction='batchmean')\\n ) / 2\",\n \"def plot_pairwise_jsd(img_dir, mask_dir, outfn='pairwisejsd.png', nbins=200, fit_chi2=True):\\n pairwise_jsd = quality.pairwise_jsd(img_dir, mask_dir, nbins=nbins)\\n _, ax = plt.subplots(1, 1)\\n ax.hist(pairwise_jsd, label='Hist.', density=True)\\n if fit_chi2:\\n from scipy.stats import chi2\\n df, _, scale = chi2.fit(pairwise_jsd, floc=0)\\n logger.info(f'df = {df:0.3e}, scale = {scale:0.3e}')\\n x = np.linspace(0, np.max(pairwise_jsd), 200)\\n ax.plot(x, chi2.pdf(x, df, scale=scale), lw=3, label=r'$\\\\chi^2$ Fit')\\n ax.legend()\\n textstr = r'$df = $' + f'{df:0.2f}'\\n props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\\n ax.text(0.72, 0.80, textstr, transform=ax.transAxes,\\n verticalalignment='top', bbox=props)\\n ax.set_xlabel(r'Jensen-Shannon Divergence')\\n ax.set_ylabel('Density')\\n ax.set_title(\\n r'Density of Pairwise JSD — $\\\\mu$ = ' + f'{np.mean(pairwise_jsd):.2e}' + r' $\\\\sigma$ = ' + f'{np.std(pairwise_jsd):.2e}',\\n pad=20)\\n ax.ticklabel_format(style='sci', axis='both', scilimits=(0, 0))\\n if outfn is not None:\\n plt.savefig(outfn, transparent=True, dpi=200)\\n return ax\",\n \"def SSD(x,y):\\n return np.sum((x-y)**2)\",\n \"def _jsd(prob_dist_p, prob_dist_q):\\n prob_dist_p = check_numpy_param('prob_dist_p', prob_dist_p)\\n prob_dist_q = check_numpy_param('prob_dist_q', prob_dist_q)\\n norm_dist_p = prob_dist_p / (np.linalg.norm(prob_dist_p, ord=1) + 1e-12)\\n norm_dist_q = prob_dist_q / (np.linalg.norm(prob_dist_q, ord=1) + 1e-12)\\n norm_mean = 0.5*(norm_dist_p + norm_dist_q)\\n return 0.5*(stats.entropy(norm_dist_p, norm_mean)\\n + stats.entropy(norm_dist_q, norm_mean))\",\n \"def dJ(theta, x_b, y):\\n return x_b.T.dot(self._sigmoid(x_b.dot(theta)) - y) / len(x_b)\",\n \"def KolmogorovSmirnoff_statistics(dd1, dd2):\\n cum1 = dd1.cumulative_distribution()\\n cum2 = dd2.cumulative_distribution()\\n minimum = max(cum1[0][0], cum2[0][0])\\n maximum = max(cum1[-1][0], cum2[-1][0])\\n index1 = len(cum1) - 1\\n index2 = len(cum2) - 1\\n summa1 = summa2 = 0\\n\\n difference = 0\\n for i in reversed(range(minimum, maximum+1)):\\n if cum1[index1][0] == i:\\n summa1 = cum1[index1][1]\\n index1 -= 1\\n if cum2[index2][0] == i:\\n summa2 = cum2[index2][1]\\n index2 -= 1\\n if abs(summa1 - summa2) > difference:\\n difference = abs(summa1 - summa2)\\n return difference\",\n \"def js_div(d1, d2):\\n part1 = - soft_relu(-d1).mean()\\n part2 = - soft_relu(d2).mean() \\n return part1 + part2 + np.log(4.0)\",\n \"def jssim_dist(G1, G2, nodes=None):\\n if nodes is None:\\n nodes = G1.nodes() | G2.nodes()\\n\\n sims = []\\n for n in nodes:\\n set1, set2 = set(G1.neighbors(n)), set(G2.neighbors(n))\\n neighbors = list(set1 | set2)\\n p1 = np.array([1./len(set1) if _n in set1 else 0 for _n in neighbors])\\n p2 = np.array([1./len(set2) if _n in set2 else 0 for _n in neighbors])\\n sims.append(1 - jsdiv(p1, p2))\\n \\n return sims\",\n \"def js_metric(df_1, df_2, numerical_columns, categorical_columns):\\n\\n res = {}\\n STEPS = 100\\n\\n for col in categorical_columns:\\n # to ensure similar order, concat before computing probability\\n col_baseline = df_1[col].to_frame()\\n col_sample = df_2[col].to_frame()\\n col_baseline[\\\"source\\\"] = \\\"baseline\\\"\\n col_sample[\\\"source\\\"] = \\\"sample\\\"\\n\\n col_ = pd.concat([col_baseline, col_sample], ignore_index=True)\\n\\n # aggregate and convert to probability array\\n arr = (\\n col_.groupby([col, \\\"source\\\"])\\n .size()\\n .to_frame()\\n .reset_index()\\n .pivot(index=col, columns=\\\"source\\\")\\n .droplevel(0, axis=1)\\n )\\n arr_ = arr.div(arr.sum(axis=0), axis=1)\\n arr_.fillna(0, inplace=True)\\n\\n # calculate js distance\\n js_distance = jensenshannon(\\n arr_[\\\"baseline\\\"].to_numpy(), arr_[\\\"sample\\\"].to_numpy()\\n )\\n\\n res.update({col: js_distance})\\n\\n for col in numerical_columns:\\n # fit gaussian_kde\\n col_baseline = df_1[col]\\n col_sample = df_2[col]\\n kde_baseline = gaussian_kde(col_baseline)\\n kde_sample = gaussian_kde(col_sample)\\n\\n # get range of values\\n min_ = min(col_baseline.min(), col_sample.min())\\n max_ = max(col_baseline.max(), col_sample.max())\\n range_ = np.linspace(start=min_, stop=max_, num=STEPS)\\n\\n # sample range from KDE\\n arr_baseline_ = kde_baseline(range_)\\n arr_sample_ = kde_sample(range_)\\n\\n arr_baseline = arr_baseline_ / np.sum(arr_baseline_)\\n arr_sample = arr_sample_ / np.sum(arr_sample_)\\n\\n # calculate js distance\\n js_distance = jensenshannon(arr_baseline, arr_sample)\\n\\n res.update({col: js_distance})\\n\\n list_output = sorted(res.items(), key=lambda x: x[1], reverse=True)\\n dict_output = dict(list_output)\\n\\n return dict_output\",\n \"def kl_divergence(dist1, dist2, symmetrized=True):\\n if symmetrized == True:\\n kl = (\\n scipy.stats.entropy(dist1, dist2) + scipy.stats.entropy(dist2, dist1)\\n ) / 2.0\\n return kl\\n else:\\n kl = scipy.stats.entropy(dist1, dist2)\\n return kl\",\n \"def JS_divergence(p1, p2, weights, mode='normalized'):\\n p1 = np.maximum(p1, 10**-10)\\n p2 = np.maximum(p2, 10**-10)\\n M = 0.5 * (p1 + p2)\\n if mode == 'normalized':\\n return 0.5 * (np.sum(weights * p1 * np.log(p1 / M)) + np.sum(weights * p2 * np.log(p2 / M)))\\n else:\\n I1 = 1 - np.sum(weights * p1)\\n I2 = 1 - np.sum(weights * p2)\\n return 0.5 * (np.sum(weights * p1 * np.log(p1 / M)) + np.sum(weights * p2 * np.log(p2 / M)) + I1 * np.log(2 * I1 / (I1 + I2)) + I2 * np.log(2 * I2 / (I1 + I2)))\",\n \"def compute_dists(x, y):\\r\\n \\r\\n return (x - y.permute(0, 2, 1)) ** 2\",\n \"def kl_dist_smoothing(distribution1: np.array, distribution2: np.array, epsilon: float) -> float:\\n # Performs smoothing\\n distributions = [distribution1, distribution2]\\n smoothed_distributions = []\\n for distribution in distributions:\\n nonzeros = np.count_nonzero(distribution)\\n zeros = len(distribution) - nonzeros\\n smoothed_distributions.append([epsilon if prob == 0 else prob - zeros * epsilon / nonzeros\\n for prob in distribution])\\n\\n return sum(kl_div(smoothed_distributions[0], smoothed_distributions[1]))\",\n \"def KL_divergence(xs,ys,pdf_x=None,pdf_y=None,data_range=None):\\n if data_range is None:\\n data_range = list(set(xs)) + list(set(ys))\\n if pdf_x is None:\\n pdf_x = prob_density_func(xs,norm=True,data_range=data_range)\\n if pdf_y is None:\\n pdf_y = prob_density_func(ys,norm=True,data_range=data_range)\\n keys = set(pdf_x.keys()+pdf_y.keys())\\n PQ = []\\n for k in keys:\\n if k in pdf_x and k in pdf_y:\\n PQ.append((pdf_x[k],pdf_y[k]))\\n return np.sum([p*np.log(float(p)/float(q)) for (p,q) in PQ if q>0 and p>0])\",\n \"def compute_grassman_distance(Y1, Y2):\\n Q1, _ = jnp.linalg.qr(Y1)\\n Q2, _ = jnp.linalg.qr(Y2)\\n\\n _, sigma, _ = jnp.linalg.svd(Q1.T @ Q2)\\n sigma = jnp.round(sigma, decimals=6)\\n return jnp.linalg.norm(jnp.arccos(sigma))\",\n \"def zkl_divergence(x, y, gamma):\\n return np.sum([p_i*np.log(p_i/q_i) if q_i > 0 and p_i > 0 else p_i*gamma for (p_i, q_i) in zip(x, y)])\",\n \"def jeffreys(self, sigma):\\n return 1. / sigma\",\n \"def J_pointlike(self, dist):\\n jfact = self.int_over_rho_sqr(self.max_radius) / dist**2.\\n return np.log10(jfact)\",\n \"def distributions_EMD(d1, d2):\\n return ss.wasserstein_distance(d1.get_probs(), d2.get_probs()) / len(d1.get_probs())\",\n \"def jaccard_dist(X, Y):\\n return 1 - jaccard_sim(X, Y)\",\n \"def dynamax_jaccard(x, y):\\n # feature generation\\n u = np.vstack((x, y))\\n m_x = fuzzify(x, u)\\n m_y = fuzzify(y, u)\\n # fuzzy jaccard\\n m_inter = np.sum(np.minimum(m_x, m_y))\\n m_union = np.sum(np.maximum(m_x, m_y))\\n return m_inter / m_union\",\n \"def compute_jensen_shannon_divergence(\\n input_file: str, output_file: str, config: Configuration\\n) -> str:\\n sanitized_input_file = input_file + \\\".sanitized\\\"\\n _sanitize_jensen_shannon_divergence_input(input_file, sanitized_input_file)\\n cmd = \\\"cd {} && python2 score_conservation.py {} > {}\\\".format(\\n JENSE_SHANNON_DIVERGANCE_DIR,\\n os.path.abspath(sanitized_input_file),\\n os.path.abspath(output_file),\\n )\\n logging.info(\\\"Executing Jense Shannon Divergence script ...\\\")\\n logging.debug(\\\"Executing command:\\\\n%s\\\", cmd)\\n config.execute_command(cmd)\\n return output_file\",\n \"def jaccard_distance_loss(y_true, y_pred, smooth=1e-5):\\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\\n return (1 - jac) * smooth\",\n \"def Jdiff(self, x1, x2, firstsecond='both'):\\n assert (firstsecond in ['first', 'second', 'both'])\\n if firstsecond == 'both':\\n return [self.Jdiff(x1, x2, 'first'), self.Jdiff(x1, x2, 'second')]\\n dx = np.zeros(self.ndx)\\n h = self.disturbance\\n J = np.zeros([self.ndx, self.ndx])\\n d0 = self.diff(x1, x2)\\n if firstsecond == 'first':\\n for k in range(self.ndx):\\n dx[k] = h\\n J[:, k] = self.diff(self.integrate(x1, dx), x2) - d0\\n dx[k] = 0\\n elif firstsecond == 'second':\\n for k in range(self.ndx):\\n dx[k] = h\\n J[:, k] = self.diff(x1, self.integrate(x2, dx)) - d0\\n dx[k] = 0\\n J /= h\\n return J\",\n \"def kl_divergence(x, y, thresholded=True, symmetrized=True, normalize=True):\\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\\n x.dtype == np.float32 and y.dtype == np.float32)\\n # assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\\n if thresholded:\\n normalize = True\\n if normalize:\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n if thresholded:\\n eps = np.finfo(x.dtype).eps\\n x = x + eps\\n y = y + eps\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n res = __kl_divergence(x, y)\\n\\n if symmetrized:\\n res = 0.5 * res + 0.5 * __kl_divergence(y, x).transpose()\\n\\n return np.float64(res).reshape(res.shape)\",\n \"def jaccard_distance_loss(y_true, y_pred, smooth=100):\\n\\n epsilon = tf.convert_to_tensor(1e-7, dtype='float32')\\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\\n return (1 - jac)\",\n \"def jaccard_distance_loss(y_true, y_pred, smooth=10):\\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\\n return (1 - jac) * smooth\",\n \"def js_beta(d1, d2, beta):\\n part1 = - soft_relu(-d1).mean()\\n part2 = (beta + 2.0 - (- soft_relu(-d2)).exp()).log().mean()\\n return part1 + part2 - np.log(1.0 + beta)\",\n \"def kl_divergence(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n y_true = backend.clip(y_true, backend.epsilon(), 1)\\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)\",\n \"def func_ludwigson(eps,k1,n1,k2,n2,):\\n return k1*eps**n1+np.exp(k2+n2*eps)\",\n \"def J(W1, b1, W2, b2, x, y):\\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\\n return crossEntropy(y, yhat)\",\n \"def compute_similarity(x, y, metric='kl_divergence'):\\n from scipy.stats import entropy, pearsonr\\n # remove zeros slightly increase divergence\\n x = x[x != 0]\\n y = y[y != 0]\\n # outer join two distributions\\n eps = min(x.min(), y.min()) / 10\\n xy = pd.concat([x, y], axis=1).add(eps, fill_value=0)\\n x = xy.iloc[:, 0]\\n y = xy.iloc[:, 1]\\n if metric == 'pearson':\\n score, _ = pearsonr(x, y)\\n else:\\n score = entropy(x, y)\\n return score\",\n \"def d_mse(x, y):\\n\\n return 2 * (x - y) / x.size(0) / x.size(1)\",\n \"def wasserstein_distance_1d(pers_diag_1, pers_diag_2) -> float:\\n wasserstein_distance = d.wasserstein_distance(pers_diag_1[1], pers_diag_2[1],\\n q=1, delta=0.2)\\n return wasserstein_distance\",\n \"def dist(x, y):\\n dx = x[0] - y[0]\\n dy = x[1] - y[1]\\n ans = dx**2 + dy**2\\n ans = ans**(0.5)\\n return ans\",\n \"def dist(x, y):\\n dx = x[0] - y[0]\\n dy = x[1] - y[1]\\n ans = dx**2 + dy**2\\n ans = ans**(0.5)\\n return ans\",\n \"def cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt(\\n (\\n (len(x_arr) - 1) * np.std(x_arr, ddof=1) ** 2 +\\n (len(y_arr) - 1) * np.std(y_arr, ddof=1) ** 2\\n ) / (len(x_arr) + len(y_arr))\\n )\\n return delta / pooled_std\",\n \"def kolmogorov_smirnov_distance(self, other, show=False):\\n from scipy.interpolate import interp1d\\n cumdist1 = self.get_cumulative_distribution()\\n cumdist2 = other.get_cumulative_distribution()\\n \\n # Normalize the x-values\\n # range1 = np.max(cumdist1[\\\"x\\\"]) - np.min(cumdist1[\\\"x\\\"])\\n # range2 = np.max(cumdist2[\\\"x\\\"]) - np.min(cumdist2[\\\"x\\\"])\\n # cumdist1[\\\"x\\\"] -= np.min(cumdist1[\\\"x\\\"])\\n # cumdist1[\\\"x\\\"] *= (range2/range1) \\n # cumdist1[\\\"x\\\"] += np.min(cumdist2[\\\"x\\\"])\\n\\n interp_cumdist1 = interp1d(cumdist1[\\\"x\\\"], cumdist1[\\\"P\\\"], kind=\\\"linear\\\",\\n fill_value=(0.0, 1.0), bounds_error=False)\\n\\n diff = cumdist2[\\\"P\\\"] - interp_cumdist1(cumdist2[\\\"x\\\"])\\n\\n ks_distance = np.max(np.abs(diff))\\n\\n if show:\\n from matplotlib import pyplot as plt\\n fig = plt.figure()\\n ax = fig.add_subplot(1, 1, 1)\\n ax.plot(cumdist1[\\\"x\\\"], cumdist1[\\\"P\\\"], drawstyle=\\\"steps\\\", label=\\\"First\\\")\\n ax.plot(cumdist2[\\\"x\\\"], cumdist2[\\\"P\\\"], drawstyle=\\\"steps\\\", label=\\\"Second\\\")\\n ax.set_xlabel(\\\"Normalized distances\\\")\\n ax.set_ylabel(\\\"Cummulative Distribution\\\")\\n ax.legend(loc=\\\"best\\\")\\n plt.show()\\n return ks_distance\",\n \"def k(xs, ys, sigma=1, l=1):\\n\\n # Pairwise difference matrix.\\n dx = np.expand_dims(xs, 1) - np.expand_dims(ys, 0)\\n return (sigma ** 2) * np.exp(-((dx / l) ** 2) / 2)\",\n \"def HJ_path(s1, s2):\\n from sage.all import xgcd, ceil, floor\\n assert s1 > s2, \\\"s1 must be larger than s2\\\"\\n m1 = s1.numerator()\\n d1 = s1.denominator()\\n m2 = s2.numerator()\\n d2 = s2.denominator()\\n path = [(m1, d1)]\\n while m1 / d1 > s2:\\n _, x, y = xgcd(m1, d1)\\n if d1 * m2 - m1 * d2 > 0:\\n k = ceil((x * m2 + y * d2) / (d1 * m2 - m1 * d2))\\n else:\\n k = floor((x * m2 + y * d2) / (d1 * m2 - m1 * d2))\\n m = - y - k * m1\\n d = x - k * d1\\n path.append((m, d))\\n m1, d1 = m, d\\n\\n # these test are for debugging only, and should be unnecessary by now\\n assert path[0][0] / path[0][1] == s1, \\\"first entry not correct: {}\\\".format(path)\\n assert path[-1][0] / path[-1][1] == s2, \\\"last entry not correct: {}\\\".format(path)\\n assert all([path[i][0] * path[i + 1][1] - path[i + 1][0] * path[i][1] == 1\\n for i in range(len(path) - 1)]), \\\"determinant condition wrong: {}\\\".format(path)\\n\\n return path\",\n \"def jeffreys(self, x):\\n return np.sqrt(1. / x)\",\n \"def J(theta, x, y):\\n m = len(y)\\n z = theta.dot(x.T) #argument for hypothesis function\\n return 1. / m * np.sum(-y * np.log(g(z)) - (1. - y) * np.log(1 - g(z)))\",\n \"def jeffreys(self, x):\\n return 1./np.sqrt(x*(1.-x))\",\n \"def lks_2samp (data1,data2):\\r\\n j1 = 0\\r\\n j2 = 0\\r\\n fn1 = 0.0\\r\\n fn2 = 0.0\\r\\n n1 = len(data1)\\r\\n n2 = len(data2)\\r\\n en1 = n1\\r\\n en2 = n2\\r\\n d = 0.0\\r\\n data1.sort()\\r\\n data2.sort()\\r\\n while j1 < n1 and j2 < n2:\\r\\n d1=data1[j1]\\r\\n d2=data2[j2]\\r\\n if d1 <= d2:\\r\\n fn1 = (j1)/float(en1)\\r\\n j1 = j1 + 1\\r\\n if d2 <= d1:\\r\\n fn2 = (j2)/float(en2)\\r\\n j2 = j2 + 1\\r\\n dt = (fn2-fn1)\\r\\n if math.fabs(dt) > math.fabs(d):\\r\\n d = dt\\r\\n try:\\r\\n en = math.sqrt(en1*en2/float(en1+en2))\\r\\n prob = ksprob((en+0.12+0.11/en)*abs(d))\\r\\n except:\\r\\n prob = 1.0\\r\\n return d, prob\",\n \"def LJ(epsilon,sigma,r):\\n P1=(sigma/r)**12\\n P2=(sigma/r)**6\\n return 4*epsilon*(P1-P2)\",\n \"def kl_divergence(a, b, normalize=True):\\n a, b = np.array(a), np.array(b)\\n\\n x = np.linspace(\\n min(a.min(), b.min()) - 1,\\n max(a.max(), b.max()) + 1,\\n 100\\n )\\n\\n p = gaussian_kde(a)(x)\\n q = gaussian_kde(b)(x)\\n\\n if normalize:\\n p = p/np.sum(p)\\n q = q/np.sum(q)\\n\\n return np.sum(np.where(p != 0, (p) * np.log(p / q), 0))\",\n \"def JointDistn(self):\\r\\n if len(self.factors)==1:\\r\\n return self.factors[0]\\r\\n F = self.factors[0]\\r\\n for i in range(1,len(self.factors)):\\r\\n F = F * self.factors[i]\\r\\n self.JDist = F\\r\\n return F\",\n \"def cohens_d(x, y):\\n nx, ny = len(x), len(y)\\n pooled_variance = ((nx - 1) * np.std(x, ddof=1) ** 2 +\\n (ny - 1) * np.std(y, ddof=1) ** 2) / \\\\\\n ((nx - 1) + (ny - 1))\\n return (np.mean(x) - np.mean(y)) / np.sqrt(pooled_variance)\",\n \"def MyKLD(X,Y): \\n mu1,mu2 = tuple(np.mean(X,axis=0))\\n sigma1,sigma2 = tuple(np.std(X,axis=0))\\n m1,m2 = tuple(np.mean(X,axis=0))\\n s1,s2 = tuple(np.std(X,axis=0))\\n rho = np.corrcoef(X,rowvar=False)[0,1]\\n r = np.corrcoef(Y,rowvar=False)[0,1]\\n \\n return (\\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\\n (2 * (1 - r**2)) +\\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \\n (sigma2**2-s2**2)/s2**2) /\\n (2 * (1 - r**2)) +\\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\\n )\",\n \"def compute_distance(self, xi: NumpyFloatArray, xj: NumpyFloatArray) -> float:\\n\\n return pdist([xi, xj], \\\"braycurtis\\\")[0]\",\n \"def rmsd(x, y):\\n\\n # get the length of the dataset\\n n, = x.shape\\n\\n return np.sqrt(np.sum((x-y)**2)/n)\",\n \"def compute_jerk(joint_trajectory):\\r\\n joint_vel = np.gradient(joint_trajectory, axis=1)\\r\\n joint_acc = np.gradient(joint_vel, axis=1)\\r\\n joint_jerk = np.gradient(joint_acc, axis=1)\\r\\n jerk = np.linalg.norm(joint_jerk)\\r\\n return jerk\",\n \"def jackknifed_sdf_variance(yk, eigvals, sides='onesided', adaptive=True):\\r\\n K = yk.shape[0]\\r\\n\\r\\n from nitime.algorithms import mtm_cross_spectrum\\r\\n\\r\\n # the samples {S_k} are defined, with or without weights, as\\r\\n # S_k = | x_k |**2\\r\\n # | x_k |**2 = | y_k * d_k |**2 (with adaptive weights)\\r\\n # | x_k |**2 = | y_k * sqrt(eig_k) |**2 (without adaptive weights)\\r\\n\\r\\n all_orders = set(range(K))\\r\\n jk_sdf = []\\r\\n # get the leave-one-out estimates -- ideally, weights are recomputed\\r\\n # for each leave-one-out. This is now the case.\\r\\n for i in range(K):\\r\\n items = list(all_orders.difference([i]))\\r\\n spectra_i = np.take(yk, items, axis=0)\\r\\n eigs_i = np.take(eigvals, items)\\r\\n if adaptive:\\r\\n # compute the weights\\r\\n weights, _ = adaptive_weights(spectra_i, eigs_i, sides=sides)\\r\\n else:\\r\\n weights = eigs_i[:, None]\\r\\n # this is the leave-one-out estimate of the sdf\\r\\n jk_sdf.append(\\r\\n mtm_cross_spectrum(\\r\\n spectra_i, spectra_i, weights, sides=sides\\r\\n )\\r\\n )\\r\\n # log-transform the leave-one-out estimates and the mean of estimates\\r\\n jk_sdf = np.log(jk_sdf)\\r\\n # jk_avg should be the mean of the log(jk_sdf(i))\\r\\n jk_avg = jk_sdf.mean(axis=0)\\r\\n\\r\\n K = float(K)\\r\\n\\r\\n jk_var = (jk_sdf - jk_avg)\\r\\n np.power(jk_var, 2, jk_var)\\r\\n jk_var = jk_var.sum(axis=0)\\r\\n\\r\\n # Thompson's recommended factor, eq 18\\r\\n # Jackknifing Multitaper Spectrum Estimates\\r\\n # IEEE SIGNAL PROCESSING MAGAZINE [20] JULY 2007\\r\\n f = (K - 1) ** 2 / K / (K - 0.5)\\r\\n jk_var *= f\\r\\n return jk_var\",\n \"def _sbd(x, y):\\r\\n ncc = _ncc_c(x, y)\\r\\n idx = ncc.argmax()\\r\\n dist = 1 - ncc[idx]\\r\\n yshift = roll_zeropad(y, (idx + 1) - max(len(x), len(y)))\\r\\n\\r\\n return dist, yshift\",\n \"def jeffreys(self, mu, sigma):\\n return 1./sigma**3.\",\n \"def get_johansen(self, y, p, r=0):\\n\\n N, l = y.shape\\n jres = coint_johansen(y, 0, p)\\n trstat = jres.lr1 # trace statistic\\n tsignf = jres.cvt # critical values\\n\\n if not r:\\n for i in range(l):\\n if trstat[i] > tsignf[i, 1]: # 0: 90% 1:95% 2: 99%\\n r = i + 1\\n if np.sign(jres.evec[0, i]) == -1: # sign of first elem\\n jres.evec[:, i] = -jres.evec[:, i]\\n\\n jres.r = r\\n jres.evecr = jres.evec[:, :r]\\n\\n return jres\",\n \"def _build_dist(self):\\n lamb = self.params['lamb']\\n p = self.params['p']\\n\\n jac = self.jacobian\\n # build D on grids\\n xg, yg, mask = self._mask_grid()\\n r_max = self._r_max(xg, yg, mask)\\n d_mat = self._psf_grid(xg, yg, r_max=r_max)\\n # E[yy^T]\\n j_j_w = np.dot(jac, jac.transpose())\\n r_mat = np.diag(np.diag(j_j_w) ** p)\\n jac_inv = la.inv(j_j_w + lamb*r_mat)\\n # RM = E[xx^T] / E[yy^T]\\n h_mat = np.dot(np.dot(d_mat, jac.transpose()), jac_inv)\\n return h_mat\",\n \"def smoothnessChi2(self, other, params, useSelf = True, useOther = True):\\n\\t\\tif not self.sectors == other.sectors:\\n\\t\\t\\traise ValueError(\\\"Sectors do not match\\\")\\n\\t\\tDself = np.zeros((2*self.totalBins))\\n\\t\\tDother = np.zeros((2*other.totalBins))\\n\\t\\tparamsSelf = params[:2*self.nZero]\\n\\t\\tparamsOther = params[2*self.nZero:]\\n#\\t\\tprint self.nZero, other.nZero, params,\\\"LLLLLLLLLOOPPdssa\\\"\\n\\n\\t\\tampsSelf = self.getCorrectedAmplitudes(paramsSelf)\\n\\t\\tampsOther = other.getCorrectedAmplitudes(paramsOther)\\n\\t\\tfor s in range(self.nSect):\\n\\t\\t\\tstartSelf = self.borders[s]\\n\\t\\t\\tstartOther = other.borders[s]\\n\\t\\t\\tnBins = min(self.borders[s+1] - self.borders[s], other.borders[s+1] - other.borders[s])\\n\\t\\t\\tfor i in range(nBins):\\n\\t\\t\\t\\tDself[2*(startSelf + i) ] = ampsSelf[2*(i+startSelf) ] - ampsOther[2*(i+startOther) ]\\n\\t\\t\\t\\tDself[2*(startSelf + i)+1] = ampsSelf[2*(i+startSelf)+1] - ampsOther[2*(i+startOther)+1]\\n\\n\\t\\t\\t\\tDother[2*(startOther + i) ] = ampsSelf[2*(i+startSelf) ] - ampsOther[2*(i+startOther) ]\\n\\t\\t\\t\\tDother[2*(startOther + i)+1] = ampsSelf[2*(i+startSelf)+1] - ampsOther[2*(i+startOther)+1]\\n\\t\\tCself = np.dot(Dself, np.dot(self.comaInv, Dself))\\n\\t\\tCother = np.dot(Dother, np.dot(other.comaInv, Dother))\\n\\t\\tretVal = 0.\\n\\t\\tif useSelf:\\n\\t\\t\\tretVal += Cself\\n\\t\\tif useOther:\\n\\t\\t\\tretVal += Cother\\n\\t\\treturn retVal\",\n \"def wealth_cons_ratio(ssyd, \\n tol=1e-7, \\n init_val=1, \\n max_iter=1_000_000,\\n verbose=False):\\n\\n # Unpack and set up parameters EpsteinZin parameters\\n ψ, γ, β = ssyd.ssy.ψ, ssyd.ssy.γ, ssyd.ssy.β\\n θ = (1 - γ) / (1 - 1/ψ)\\n ζ = 1 - β\\n\\n K_matrix = compute_K(ssyd)\\n M = ssyd.K * ssyd.I * ssyd.J\\n w = np.ones(M) * init_val\\n iter = 0\\n error = tol + 1\\n\\n r = compute_spec_rad(K_matrix)\\n if verbose:\\n print(f\\\"Test value = {r**(1/θ)} and θ = {θ}\\\")\\n print(\\\"Beginning iteration\\\\n\\\\n\\\")\\n\\n\\n while error > tol and iter < max_iter:\\n Tw = ζ + β * (K_matrix @ (w**θ))**(1/θ)\\n error = np.max(np.abs(w - Tw))\\n w = Tw\\n iter += 1\\n\\n if verbose:\\n print(f\\\"Iteration converged after {iter} iterations\\\") \\n\\n return w / ζ\",\n \"def kde_agent(beta, bid, i, m, bw = None, *args):\\n if bw is None: bw = 'scott'\\n\\n i0 = D.index[0]\\n if only_cond == {'d'}:\\n s1 = D.ix[i0:i, 's1_rp']\\n if len(s1) == 1:\\n s1[i0+1] = sp.mean([s1, 10])\\n else:\\n s1est = args[0]\\n ar = D.ix[i, 'out_bool']\\n b1 = D.ix[i, 'bid']\\n b1i = round2(b1)\\n if len(s1est) == 1:\\n s1est.append(sp.mean([s1est[0], 10])) \\n else:\\n gks = stats.gaussian_kde(s1est, bw_method = bw)\\n if ar:\\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \\n else:\\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \\n s1est.append(aest) \\n s1 = s1est\\n gks = stats.gaussian_kde(s1, bw_method = bw)\\n Ks1 = gks.pdf(B) \\n Ks1 /= sum(Ks1)\\n\\n if m == 'SC':\\n if only_cond == {'d'}:\\n s2 = D.ix[i0:i, 's2_rp'].dropna()\\n if len(s2) == 1:\\n s2[i+1] = sp.mean([s2[i], 10]) \\n else:\\n s2est = args[1]\\n if len(s2est) == 1:\\n s2est.append(sp.mean([s2est[0], 10])) \\n else:\\n gks = stats.gaussian_kde(s2est, bw_method = bw)\\n if ar:\\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \\n else:\\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \\n s2est.append(aest) \\n s2 = s2est\\n gks = stats.gaussian_kde(s2, bw_method = bw)\\n Ks2 = gks.pdf(B) \\n Ks2 /= sum(Ks2)\\n U = kdeag_uf(Ks1, Ks2, None)\\n s2orb2 = s2\\n elif m == 'NC':\\n U = kdeag_uf(Ks1, None, None)\\n s2orb2 = None\\n elif m == 'BC':\\n if only_cond == {'d'}:\\n b2 = D.ix[i0:i, 'b2_bid'].dropna()\\n if len(b2) == 1:\\n b2[i+1] = sp.mean([b2[i], 10]) \\n else:\\n b2est = args[1]\\n if len(b2est) == 1:\\n b2est.append(sp.mean([b2est[0], 10])) \\n else:\\n gks = stats.gaussian_kde(b2est, bw_method = bw)\\n if ar:\\n aestint = gks.pdf(sp.arange(0, b1i, 0.1))\\n aest = sp.dot(aestint, sp.arange(0, b1i, 0.1)) / b1i \\n else:\\n aestint = gks.pdf(sp.arange(b1i, 10, 0.1))\\n aest = sp.dot(aestint, sp.arange(b1i, 10, 0.1)) / (10-b1i) \\n b2est.append(aest) \\n b2 = b2est\\n gks = stats.gaussian_kde(b2, bw_method = bw)\\n Kb2 = gks.pdf(B) \\n Kb2 /= sum(Kb2)\\n U = kdeag_uf(Ks1, None, Kb2)\\n s2orb2 = b2\\n \\n opb = B[sp.argmax(U)]\\n p = boltzmann_dist(beta, U, int(bid*((Bbins-1)/10)))#p = P[int(bid*((Bbins-1)/10))]\\n return p, opb, s1, s2orb2, U\",\n \"def emd(pdd, pdd_, metric='chebyshev', **kwargs):\\n \\n from .core.Wasserstein import wasserstein\\n \\n dm = cdist(pdd[:, 1:], pdd_[:, 1:], metric=metric, **kwargs)\\n \\n return wasserstein(pdd[:, 0], pdd_[:, 0], dm)\",\n \"def ddf(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\\n out = torch.pow(y1, 2)\\n mul = y1 * y2\\n mul.exp_()\\n\\n div = mul.reciprocal()\\n div.add_(mul).add_(2)\\n out.div_(div)\\n return out\",\n \"def hellinger(x,y):\\n\\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\\n\\tassert (x==y), 'Passed-in BayesNet objects are not structurally equal.'\\n\\n\\tdistance = ( 1 / np.sqrt( 2 ) ) * np.sqrt( np.sum( ( np.sqrt( x.flat_cpt() ) - np.sqrt( y.flat_cpt() ) )**2) )\\n\\treturn distance\",\n \"def Kendalls_Tau2(xlist, ylist):\\n\\tif len(xlist) != len(ylist):\\n\\t\\traise StatsError(\\\"Data sets have different lengths.\\\")\\n\\txdata = xlist\\n\\tydata = ylist\\n\\t#for i in range(len(xlist)):\\n\\t#\\tif xlist[i] != None and ylist[i] != None:\\n\\t#\\t\\txdata.append(xlist[i])\\n\\t#\\t\\tydata.append(ylist[i])\\n\\tassert len(xdata) == len(ydata)\\n\\t#assert len(xdata) <= len(xlist) - xlist.count(None)\\n\\t#assert len(ydata) <= len(ylist) - ylist.count(None)\\n\\t#assert len(ydata) >= len(ylist) - xlist.count(None) - ylist.count(None)\\n\\tif len(xdata) == 0:\\n\\t\\traise StatsError(\\\"No valid data entries.\\\")\\n\\tn = len(xdata)\\n\\t# compute the number of concordant and discordant pairs\\n\\tconc = disc = 0.0 # concordant and discordant pairs\\n\\tnx = ny = 0.0\\n\\tupdown = 0\\n\\tfor i in range(n): # loop over all pairs\\n\\t\\txi = xdata[i]\\n\\t\\tyi = ydata[i]\\n\\t\\tif xi and yi:\\n\\t\\t\\tfor j in range(i + 1, n):\\n\\t\\t\\t\\tif xdata[j] and ydata[j]:\\n\\t\\t\\t\\t\\txd = xi - xdata[j]\\n\\t\\t\\t\\t\\tyd = yi - ydata[j]\\n\\t\\t\\t\\t\\tprod = xd * yd\\n\\t\\t\\t\\t\\tif prod != 0:\\n\\t\\t\\t\\t\\t\\tnx += 1\\n\\t\\t\\t\\t\\t\\tny += 1\\n\\t\\t\\t\\t\\t\\tif prod > 0:\\n\\t\\t\\t\\t\\t\\t\\tupdown += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tupdown -= 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif xd != 0:\\n\\t\\t\\t\\t\\t\\t\\tnx += 1\\n\\t\\t\\t\\t\\t\\tif yd != 0:\\n\\t\\t\\t\\t\\t\\t\\tny += 1\\n\\t# Compute tau\\n\\tn = float(n)\\n\\tdenom = math.sqrt(nx*ny)\\n\\ttry:\\n\\t\\ttau = float(updown) / denom\\n\\texcept ZeroDivisionError:\\n\\t\\traise StatsError(\\\"Too few entries: {:d}\\\".format(n))\\n\\t# Compute P-value\\n\\tz = 3.0 * tau * math.sqrt(n * (n - 1.0)) / math.sqrt(2.0 * (2.0 * n + 5.0))\\n\\tprob = Prob_Z(z)\\n\\treturn (tau, prob, int(n))\",\n \"def _dK_computations(self, dL_dK):\\r\\n \\r\\n self._dL_dl = (dL_dK*self.variance*self._K_dvar*(self.input_dim/2.*(self._lengthscales_two.T**4 - self._lengthscales**4) + 2*self._lengthscales2*self._K_dist2)/(self._w2*self._w2*self._lengthscales)).sum(1)\\r\\n if self._lengthscales_two is self._lengthscales:\\r\\n self._dL_dl_two = None\\r\\n else:\\r\\n self._dL_dl_two = (dL_dK*self.variance*self._K_dvar*(self.input_dim/2.*(self._lengthscales**4 - self._lengthscales_two.T**4 ) + 2*self._lengthscales_two2.T*self._K_dist2)/(self._w2*self._w2*self._lengthscales_two.T)).sum(0)\",\n \"def compute_sgd_gradient(self, x_j, t_j):\\n a = np.dot(x_j.T, self.w)\\n return -1 * t_j * (1 / (1 + np.exp(a * t_j))) * x_j\",\n \"def alt_cohen_d(x_arr, y_arr):\\n delta = np.mean(x_arr) - np.mean(y_arr)\\n pooled_std = np.sqrt((np.std(x_arr, ddof=1) ** 2 +\\n np.std(y_arr, ddof=1) ** 2) / 2.0)\\n return delta / pooled_std\",\n \"def hellinger_distance(x, y):\\n assert (x.dtype == np.float64 and y.dtype == np.float64) or (\\n x.dtype == np.float32 and y.dtype == np.float32)\\n assert (np.all(x.sum(1) != 0.) and np.all(y.sum(1) != 0.))\\n x /= x.sum(1).reshape(x.shape[0], 1)\\n y /= y.sum(1).reshape(y.shape[0], 1)\\n x = np.sqrt(x)\\n y = np.sqrt(y)\\n # x (120, 40), y (100, 40), H(x,y) (120, 100)\\n xx = np.tile(x, (y.shape[0], 1, 1)).transpose((1, 0, 2))\\n yy = np.tile(y, (x.shape[0], 1, 1))\\n xx_yy = xx - yy\\n res = np.sqrt(np.sum(xx_yy ** 2, axis=-1))\\n return np.float64((1. / np.sqrt(2)) * res)\",\n \"def metric(x, y):\\n d = 2\\n summ = []\\n i = 0\\n while i < len(x):\\n # in this case use euclidean distance\\n summ.append((x[i] - y[i])**d)\\n i = i + 1\\n return sum(summ) ** (1 / float(d))\",\n \"def test_jn():\\n import time\\n t1 = time.time()\\n\\n n_list = [ 3, 4, 1, 0, 9, 7 ]\\n x_list = [ 0, 1.01, 0.2, 3.3, 5.9, 77. ]\\n vals1 = [ galsim.bessel.jn(n,x) for n,x in zip(n_list,x_list) ]\\n print 'x = ',x_list\\n print 'vals1 = ',vals1\\n\\n try:\\n import scipy.special\\n vals2 = [ scipy.special.jn(n,x) for n,x in zip(n_list,x_list) ]\\n print 'vals2 = ',vals2\\n np.testing.assert_almost_equal(\\n vals1, vals2, 8, \\\"bessel.jn disagrees with scipy.special.jn\\\")\\n except ImportError:\\n print 'Unable to import scipy. Skipping scipy tests of jn.'\\n\\n # These values are what scipy returns. Check against these, so not require scipy.\\n vals2 = [ 0.0,\\n 0.0025745895535573995,\\n 0.099500832639236036,\\n -0.34429626039888467,\\n 0.018796532416195257,\\n -0.082526868218916541\\n ]\\n np.testing.assert_almost_equal(\\n vals1, vals2, 8, \\\"bessel.jn disagrees with reference values\\\")\\n\\n t2 = time.time()\\n print 'time for %s = %.2f'%(funcname(),t2-t1)\",\n \"def jacaard(clusters_a, clusters_b):\\n return jaccard_similarity_score(clusters_a, clusters_b)\",\n \"def sdep(y, yHat):\\n n = y.shape[0]\\n\\n numer = ((y - yHat) ** 2).sum()\\n\\n sdep = (numer / n) ** 0.5\\n\\n return sdep\",\n \"def _graph_fn_kl_divergence(distribution_a, distribution_b):\\n if get_backend() == \\\"tf\\\":\\n return tf.no_op()\\n # TODO: never tested. tf throws error: NotImplementedError: No KL(distribution_a || distribution_b) registered for distribution_a type Bernoulli and distribution_b type ndarray\\n #return tf.distributions.kl_divergence(\\n # distribution_a=distribution_a,\\n # distribution_b=distribution_b,\\n # allow_nan_stats=True,\\n # name=None\\n #)\",\n \"def JS_divergence_tdp(peq1, D1, p01, peq2, D2, p02, weights, lQ1, Qx1, lQ2, Qx2, terminal_time=0.5, number_of_samples=5):\\n time = np.linspace(0, terminal_time, number_of_samples)\\n out = JS_divergence(p01, p02, weights) / 2\\n rho0d1 = Qx1.T.dot(np.diag(weights)).dot(p01 / np.sqrt(peq1))\\n rho0d2 = Qx2.T.dot(np.diag(weights)).dot(p02 / np.sqrt(peq2))\\n\\n for i in range(1, len(time)):\\n p1 = (Qx1.dot(rho0d1.dot(\\n np.diag(np.exp(-lQ1 * (time[i] - time[0])))))) * np.sqrt(peq1)\\n p2 = (Qx2.dot(rho0d2.dot(\\n np.diag(np.exp(-lQ2 * (time[i] - time[0])))))) * np.sqrt(peq2)\\n out += JS_divergence(p1, p2, weights, 'unnormalized')\\n # print(out)\\n return out * (time[1] - time[0])\",\n \"def kl_bern(x, y):\\n x = min(max(x, eps), 1-eps)\\n y = min(max(y, eps), 1-eps)\\n return x*log(x/y) + (1-x)*log((1-x)/(1-y))\",\n \"def vf_wasserstein_distance(x, y, critic):\\n return torch.mean(critic(x)) - torch.mean(critic(y))\",\n \"def test_renyi_values():\\n d1 = Distribution(['0', '1'], [0, 1])\\n d2 = Distribution(['0', '1'], [1 / 2, 1 / 2])\\n d3 = Distribution(['0', '1'], [1, 0])\\n\\n assert renyi_divergence(d1, d2, 1 / 2) == pytest.approx(np.log2(2))\\n assert renyi_divergence(d2, d3, 1 / 2) == pytest.approx(np.log2(2))\\n assert renyi_divergence(d1, d3, 1 / 2) == pytest.approx(np.inf)\",\n \"def jaccard_distance(y_true, y_pred, smooth=100):\\n intersection = K.sum(K.abs(y_true * y_pred), axis=-1)\\n sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1)\\n jac = (intersection + smooth) / (sum_ - intersection + smooth)\\n return K.abs(1 - jac) * smooth\",\n \"def calc_linear_dispersion(self):\\n self._check_k_columns([\\\"K0L\\\", \\\"K0SL\\\", \\\"K1SL\\\"])\\n tw = self.twiss_df\\n phs_adv = self.get_phase_adv()\\n res = self._results_df\\n coeff_fun = self._linear_dispersion_coeff\\n sum_fun = self._linear_dispersion_sum\\n\\n # Calculate\\n LOG.debug(\\\"Calculate Linear Dispersion\\\")\\n with timeit(lambda t: LOG.debug(\\\" Time needed: {:f}\\\".format(t))):\\n # sources\\n k0_mask = tw['K0L'] != 0\\n k0s_mask = tw['K0SL'] != 0\\n k1s_mask = tw['K1SL'] != 0\\n\\n mx_mask = k0_mask | k1s_mask # magnets contributing to Dx,j (-> Dy,m)\\n my_mask = k0s_mask | k1s_mask # magnets contributing to Dy,j (-> Dx,m)\\n\\n if not any(mx_mask | my_mask):\\n LOG.warning(\\\" No linear dispersion contributions found. Values will be zero.\\\")\\n res['DX'] = 0.\\n res['DY'] = 0.\\n self._log_added('DX', 'DY')\\n return\\n\\n # create temporary DataFrame for magnets with coefficients already in place\\n df = tfs.TfsDataFrame(index=tw.index).join(\\n coeff_fun(tw.loc[:, 'BETX'], tw.Q1)).join(\\n coeff_fun(tw.loc[:, 'BETY'], tw.Q2))\\n df.columns = ['COEFFX', 'COEFFY']\\n\\n LOG.debug(\\\" Calculate uncoupled linear dispersion\\\")\\n df.loc[my_mask, 'DX'] = df.loc[my_mask, 'COEFFX'] * \\\\\\n sum_fun(tw.loc[mx_mask, 'K0L'],\\n 0,\\n 0,\\n tw.loc[mx_mask, 'BETX'],\\n tau(phs_adv['X'].loc[mx_mask, my_mask], tw.Q1)\\n ).transpose()\\n df.loc[mx_mask, 'DY'] = df.loc[mx_mask, 'COEFFY'] * \\\\\\n sum_fun(-tw.loc[my_mask, 'K0SL'], # MINUS!\\n 0,\\n 0,\\n tw.loc[my_mask, 'BETY'],\\n tau(phs_adv['Y'].loc[my_mask, mx_mask], tw.Q2)\\n ).transpose()\\n\\n LOG.debug(\\\" Calculate full linear dispersion values\\\")\\n res.loc[:, 'DX'] = df.loc[:, 'COEFFX'] * \\\\\\n sum_fun(tw.loc[mx_mask, 'K0L'],\\n tw.loc[mx_mask, 'K1SL'],\\n df.loc[mx_mask, 'DY'],\\n tw.loc[mx_mask, 'BETX'],\\n tau(phs_adv['X'].loc[mx_mask, :], tw.Q1)\\n ).transpose()\\n res.loc[:, 'DY'] = df.loc[:, 'COEFFY'] * \\\\\\n sum_fun(-tw.loc[my_mask, 'K0SL'], # MINUS!\\n tw.loc[my_mask, 'K1SL'],\\n df.loc[my_mask, 'DX'],\\n tw.loc[my_mask, 'BETY'],\\n tau(phs_adv['Y'].loc[my_mask, :], tw.Q2)\\n ).transpose()\\n\\n LOG.debug(\\\" Average linear dispersion Dx: {:g}\\\".format(\\n np.mean(res['DX'])))\\n LOG.debug(\\\" Average linear dispersion Dy: {:g}\\\".format(\\n np.mean(res['DY'])))\\n self._log_added('DX', 'DY')\",\n \"def grad_j(self,w,j):\\n g = 0\\n for i in range(len(self.x)):\\n # Each example contributes -sigma(-y_i * x_i.w) * y_j x_ij\\n g -= sigmoid(-self.y[i] * np.dot(w, self.x[i,:])) * self.y[i] * self.x[i,j]\\n #regularisation\\n g += self.alpha * w[j]\\n return g\",\n \"def test_divergences_to_kl2(dists, divergence):\\n for dist1, dist2 in combinations(dists, 2):\\n assert divergence(dist1, dist2, alpha=1) == pytest.approx(kullback_leibler_divergence(dist1, dist2))\",\n \"def js_sort(d1, d2, beta):\\n n = d1.shape[0]\\n n_selected = int(n // (1.0 + beta))\\n d1_selected = torch.topk(d1, n_selected, largest=False, sorted=False)[0]\\n return js_div(d1_selected, d2)\",\n \"def compute_jacs(x_sp,params_sens_dict,integration_params,**kwargs):\\n\\n # check if sensitivity to all params\\n if kwargs['diffeq_params'] is None:\\n diffeq_params = params_sens_dict\\n params_sensitivity_sp = list(params_sens_dict.values())\\n\\n else:\\n diffeq_params = kwargs['diffeq_params'].copy()\\n params_sensitivity_sp = list(params_sens_dict.values())\\n for key,value in params_sens_dict.items():\\n diffeq_params[key] = value\\n\\n SDerivSymbolic = sp.Matrix(SDeriv(0,x_sp,integration_params,diffeq_params))\\n\\n # derivative of rhs wrt params\\n SDerivSymbolicJacParams = SDerivSymbolic.jacobian(params_sensitivity_sp)\\n SDerivSymbolicJacParamsLamb = sp.lambdify((x_sp,params_sensitivity_sp), SDerivSymbolicJacParams,'numpy')\\n SDerivSymbolicJacParamsLambFun = lambda t,x,params: SDerivSymbolicJacParamsLamb(x,params)\\n\\n # derivative of rhs wrt Conc\\n SDerivSymbolicJacConc = SDerivSymbolic.jacobian(x_sp)\\n SDerivSymbolicJacConcLamb = sp.lambdify((x_sp,params_sensitivity_sp),SDerivSymbolicJacConc,'numpy')\\n SDerivSymbolicJacConcLambFun = lambda t,x,params: SDerivSymbolicJacConcLamb(x,params)\\n\\n return [SDerivSymbolicJacParamsLambFun,SDerivSymbolicJacConcLambFun]\",\n \"def kde2D(x, y, bandwidth, xbins=100j, ybins=100j, **kwargs):\\n\\n # create grid of sample locations (default: 100x100)\\n xx, yy = np.mgrid[x.min():x.max():xbins, \\n y.min():y.max():ybins]\\n\\n xy_sample = np.vstack([yy.ravel(), xx.ravel()]).T\\n xy_train = np.vstack([y, x]).T\\n\\n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\\n kde_skl.fit(xy_train)\\n\\n # score_samples() returns the log-likelihood of the samples\\n z = np.exp(kde_skl.score_samples(xy_sample))\\n return xx, yy, np.reshape(z, xx.shape)\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n dist = np.sqrt(np.sum(np.square((X[:,None,:]-X2[None,:,:])/self.lengthscale),-1))\\r\\n invdist = 1./np.where(dist!=0.,dist,np.inf)\\r\\n dist2M = np.square(X[:,None,:]-X2[None,:,:])/self.lengthscale**3\\r\\n dvar = (1+np.sqrt(5.)*dist+5./3*dist**2)*np.exp(-np.sqrt(5.)*dist)\\r\\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\\r\\n target[0] += np.sum(dvar*dL_dK)\\r\\n if self.ARD:\\r\\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\\r\\n #dl = (self.variance* 3 * dist * np.exp(-np.sqrt(3.)*dist))[:,:,np.newaxis] * dist2M*invdist[:,:,np.newaxis]\\r\\n target[1:] += (dl*dL_dK[:,:,None]).sum(0).sum(0)\\r\\n else:\\r\\n dl = (self.variance * 5./3 * dist * (1 + np.sqrt(5.)*dist ) * np.exp(-np.sqrt(5.)*dist)) * dist2M.sum(-1)*invdist\\r\\n #dl = (self.variance* 3 * dist * np.exp(-np.sqrt(3.)*dist)) * dist2M.sum(-1)*invdist\\r\\n target[1] += np.sum(dl*dL_dK)\",\n \"def dphidalpha_j(x, alpha_j, beta_j, gamma_j):\\n def f(xp):\\n delta = xp - gamma_j\\n return csrbf(math.sqrt(beta_j*delta*beta_j*delta))\\n vf = num.vectorize(f)\\n return vf(x)\",\n \"def return_js_matrix(distributions1, distributions2, verbose=0):\\n assert distributions1.shape[1] == distributions2.shape[1], \\\\\\n \\\"Distributions must have matching dimensions. Consider using merge_energies\\\"\\n js_matrix = np.zeros((len(distributions1), len(distributions2)))\\n for i in trange(len(distributions1), desc='dist1 loop', disable=verbose<=0):\\n for j in trange(len(distributions2), desc='dist2 loop', disable=verbose<=1):\\n masses1 = distributions1[i]\\n masses2 = distributions2[j]\\n js = entropy((masses1+masses2)/2) -\\\\\\n entropy(masses1)/2 - entropy(masses2)/2\\n js_matrix[i, j] = js\\n return js_matrix\",\n \"def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\\n kl_cost = torch.mean(kl_cost, 0)\\n return torch.sum(kl_cost)\",\n \"def J(cst, x):\\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\\n [u, v, g1, g2, g3] = x\\n df1du = 2*u*g3**2 - 2*g3*u0 + 2*g3*coeffs[3]*(g1*u1-u0) + 2*g3*coeffs[4]*(g2*u2-u0)\\n df1dv = -2*v*g3**2 + 2*g3*v0 - 2*g3*coeffs[3]*(g1*v1-v0) - 2*g3*coeffs[4]*(g2*v2-v0)\\n df1dg1 = 2*g1*coeffs[0]*(u1**2-v1**2) + 2*(v1*v0-u1*u0)*(coeffs[0]+coeffs[1]+coeffs[3]) + 2*g2*coeffs[1]*(u1*u2-v1*v2) + 2*g3*coeffs[3]*(u1*u-v1*v)\\n df1dg2 = 2*g2*coeffs[2]*(u2**2-v2**2) + 2*(v2*v0-u2*u0)*(coeffs[1]+coeffs[2]+coeffs[4]) + 2*g1*coeffs[1]*(u1*u2-v1*v2) + 2*g3*coeffs[4]*(u2*u-v2*v)\\n df1dg3 = 2*g3*(u**2-v**2) + 2*(v*v0-u*u0)*(coeffs[3]+coeffs[4]+1) + 2*g1*coeffs[3]*(u1*u-v1*v) + 2*g2*coeffs[4]*(u2*u-v2*v)\\n\\n df2du = 0\\n df2dv = 2*v*g3**2 + 2*g3*(-v0 + coeffs[3]*(g1*v1-v0) + coeffs[4]*(g2*v2-v0))\\n df2dg1 = 2*g1*coeffs[0]*(v1**2-1) + 2*(1-v1*v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + 2*g2*coeffs[1]*(v1*v2-1) + 2*g3*coeffs[3]*(v1*v-1)\\n df2dg2 = 2*g2*coeffs[2]*(v2**2-1) + 2*(1-v2*v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + 2*g1*coeffs[1]*(v1*v2-1) + 2*g3*coeffs[4]*(v2*v-1)\\n df2dg3 = 2*g3*(v**2-1) + 2*(1-v*v0)*(coeffs[3]+coeffs[4]+1) + 2*g1*coeffs[3]*(v1*v-1) + 2*g2*coeffs[4]*(v2*v-1)\\n\\n df3du = g3*coeffs[3]*(g1*v1-v0) + g3*coeffs[4]*(g2*v2-v0) + g3*(g3*v-v0)\\n df3dv = g3*coeffs[3]*(g1*u1-u0) + g3*coeffs[4]*(g2*u2-u0) + g3*(g3*u-u0)\\n df3dg1 = 2*g1*coeffs[0]*u1*v1 - (v1*u0+u1*v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(u1*v2+v1*u2) + g3*coeffs[3]*(v1*u+u1*v)\\n df3dg2 = 2*g2*coeffs[2]*u2*v2 - (v2*u0+u2*v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(u1*v2+v1*u2) + g3*coeffs[4]*(v2*u+u2*v)\\n df3dg3 = 2*g3*u*v - (u*v0+v*u0)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(v1*u+u1*v) + g2*coeffs[4]*(v2*u+u2*v)\\n\\n df4du = g3*coeffs[3]*(g1-1) + g3*coeffs[4]*(g2-1) + g3*(g3-1)\\n df4dv = 0\\n df4dg1 = 2*g1*coeffs[0]*u1 - (u0+u1)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(u1+u2) + g3*coeffs[3]*(u+u1)\\n df4dg2 = 2*g2*coeffs[2]*u2 - (u0+u2)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(u1+u2) + g3*coeffs[4]*(u+u2)\\n df4dg3 = 2*g3*u - (u+u0)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(u+u1) + g2*coeffs[4]*(u+u2)\\n\\n df5du = 0\\n df5dv = g3*coeffs[3]*(g1-1) + g3*coeffs[4]*(g2-1) + g3*(g3-1)\\n df5dg1 = 2*g1*coeffs[0]*v1 - (v1+v0)*(coeffs[0]+coeffs[1]+coeffs[3]) + g2*coeffs[1]*(v2+v1) + g3*coeffs[3]*(v1+v)\\n df5dg2 = 2*g2*coeffs[2]*v2 - (v2+v0)*(coeffs[1]+coeffs[2]+coeffs[4]) + g1*coeffs[1]*(v2+v1) + g3*coeffs[4]*(v2+v)\\n df5dg3 = 2*g3*v - (v0+v)*(coeffs[3]+coeffs[4]+1) + g1*coeffs[3]*(v1+v) + g2*coeffs[4]*(v2+v)\\n\\n return np.array([\\n [df1du, df1dv, df1dg1, df1dg2, df1dg3],\\n [df2du, df2dv, df2dg1, df2dg2, df2dg3],\\n [df3du, df3dv, df3dg1, df3dg2, df3dg3],\\n [df4du, df4dv, df4dg1, df4dg2, df4dg3],\\n [df5du, df5dv, df5dg1, df5dg2, df5dg3],\\n ])\",\n \"def LJ(r, epsilon, sigma, x, y):\\n A=((x/y)**(x/(x-y))/((x/y)-1))\\n\\n\\n V=A*epsilon*((sigma/r)**x-(sigma/r)**y) #-4*Epsilon*((Sigma/Rc)**12-(Sigma/Rc)**6)\\n\\n return V\",\n \"def needleman_wunsch(s1, s2):\\n\\n if s1 is None or s2 is None:\\n return np.NaN\\n if pd.isnull(s1) or pd.isnull(s2):\\n return np.NaN\\n\\n # Create the similarity measure object\\n measure = sm.NeedlemanWunsch()\\n\\n s1 = gh.convert_to_str_unicode(s1)\\n s2 = gh.convert_to_str_unicode(s2)\\n\\n # Call the function to compute the similarity measure\\n return measure.get_raw_score(s1, s2)\",\n \"def find_knee(x,y):\\n\\n # find ranges\\n if len(x) != len(y):\\n raise Exception(\\\"bad data\\\")\\n tot_len = len(x)\\n \\n \\n \\n # fit strait lines to both\\n\\n # find intercept\\n knee_r = (f_top.beta[1] - f_bottom.beta[1])/(-f_top.beta[0] + f_bottom.beta[0])\",\n \"def KSStat(xs,ys,reweight=False,cdf_x=None,cdf_y=None,data_range=None):\\n if cdf_x is None and cdf_y is None and data_range is None:\\n data_range = list(set(xs)) + list(set(ys))\\n if cdf_x is None:\\n cdf_x = cum_density_func(xs,norm=True,rank=False,data_range=data_range)\\n if cdf_y is None:\\n cdf_y = cum_density_func(ys,norm=True,rank=False,data_range=data_range)\\n keys = set(cdf_x.keys()+cdf_y.keys())\\n SP = []\\n for k in keys:\\n if k in cdf_x and k in cdf_y:\\n SP.append((cdf_x[k],cdf_y[k]))\\n if reweight:\\n return np.max([np.abs(s-p)/np.sqrt(p*(1.0-p)) for (s,p) in SP])\\n else:\\n return np.max([np.abs(s-p) for (s,p) in SP])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7116401","0.6758938","0.6689075","0.654391","0.6027384","0.60244334","0.6005269","0.59004337","0.58797586","0.58616793","0.58290076","0.58030003","0.57559144","0.57503366","0.569734","0.5691851","0.5684341","0.5684016","0.5652677","0.5649112","0.5614351","0.56037545","0.55800897","0.55391544","0.5523207","0.5495863","0.5484064","0.54637396","0.5449351","0.5437303","0.5434162","0.5433914","0.5402381","0.53985476","0.53901345","0.5387793","0.53687453","0.53558046","0.53152585","0.53126055","0.5297076","0.52926975","0.52903086","0.5278519","0.526033","0.5255974","0.5255236","0.52487403","0.52478635","0.5245473","0.52281076","0.5206418","0.518174","0.51780736","0.51732624","0.5172519","0.51678056","0.5157482","0.5141861","0.514042","0.5140277","0.51364803","0.513556","0.5126144","0.5119942","0.5118737","0.5110861","0.5105823","0.5104839","0.510277","0.50997126","0.5089965","0.5087287","0.5077184","0.50745445","0.5068356","0.5057886","0.5057605","0.505078","0.50496805","0.5045632","0.5040716","0.50399345","0.50391704","0.5038244","0.5035356","0.50346226","0.5030205","0.50217545","0.502063","0.50194097","0.50165117","0.50153285","0.5005708","0.5002518","0.50012136","0.50011337","0.49997187","0.49924824","0.4989253"],"string":"[\n \"0.7116401\",\n \"0.6758938\",\n \"0.6689075\",\n \"0.654391\",\n \"0.6027384\",\n \"0.60244334\",\n \"0.6005269\",\n \"0.59004337\",\n \"0.58797586\",\n \"0.58616793\",\n \"0.58290076\",\n \"0.58030003\",\n \"0.57559144\",\n \"0.57503366\",\n \"0.569734\",\n \"0.5691851\",\n \"0.5684341\",\n \"0.5684016\",\n \"0.5652677\",\n \"0.5649112\",\n \"0.5614351\",\n \"0.56037545\",\n \"0.55800897\",\n \"0.55391544\",\n \"0.5523207\",\n \"0.5495863\",\n \"0.5484064\",\n \"0.54637396\",\n \"0.5449351\",\n \"0.5437303\",\n \"0.5434162\",\n \"0.5433914\",\n \"0.5402381\",\n \"0.53985476\",\n \"0.53901345\",\n \"0.5387793\",\n \"0.53687453\",\n \"0.53558046\",\n \"0.53152585\",\n \"0.53126055\",\n \"0.5297076\",\n \"0.52926975\",\n \"0.52903086\",\n \"0.5278519\",\n \"0.526033\",\n \"0.5255974\",\n \"0.5255236\",\n \"0.52487403\",\n \"0.52478635\",\n \"0.5245473\",\n \"0.52281076\",\n \"0.5206418\",\n \"0.518174\",\n \"0.51780736\",\n \"0.51732624\",\n \"0.5172519\",\n \"0.51678056\",\n \"0.5157482\",\n \"0.5141861\",\n \"0.514042\",\n \"0.5140277\",\n \"0.51364803\",\n \"0.513556\",\n \"0.5126144\",\n \"0.5119942\",\n \"0.5118737\",\n \"0.5110861\",\n \"0.5105823\",\n \"0.5104839\",\n \"0.510277\",\n \"0.50997126\",\n \"0.5089965\",\n \"0.5087287\",\n \"0.5077184\",\n \"0.50745445\",\n \"0.5068356\",\n \"0.5057886\",\n \"0.5057605\",\n \"0.505078\",\n \"0.50496805\",\n \"0.5045632\",\n \"0.5040716\",\n \"0.50399345\",\n \"0.50391704\",\n \"0.5038244\",\n \"0.5035356\",\n \"0.50346226\",\n \"0.5030205\",\n \"0.50217545\",\n \"0.502063\",\n \"0.50194097\",\n \"0.50165117\",\n \"0.50153285\",\n \"0.5005708\",\n \"0.5002518\",\n \"0.50012136\",\n \"0.50011337\",\n \"0.49997187\",\n \"0.49924824\",\n \"0.4989253\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6525315"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":3395,"cells":{"query":{"kind":"string","value":"Method for parsing CLI arguments using argparse."},"document":{"kind":"string","value":"def parse_parameters():\n parser = argparse.ArgumentParser(\n description=\"Get all dependent review IDs\")\n parser.add_argument(\"-r\", \"--review-id\", type=str, required=True,\n help=\"Review ID\")\n parser.add_argument(\"-o\", \"--out-file\", type=str, required=False,\n help=\"The out file with the reviews IDs\")\n return parser.parse_args()"},"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 parse_cli_arguments():\n parser = argparse.ArgumentParser('Generates a MANIFEST file used by the '\n 'HMP2 AnADAMA2 workflows.')\n parser.add_argument('-b', '--broad-data-sheet', required=True,\n help='Broad data product status spreadsheet. '\n 'Contains entries indicating new files to be '\n 'processed.')\n parser.add_argument('-o', '--output-manifest', required=True,\n help='Path to desired output manifest file.')\n parser.add_argument('-oi', '--origin-institute', required=True,\n help='Name of institute submitting new files '\n 'to be processed.')\n parser.add_argument('-oc', '--origin-contact', required=True,\n help='Contact person for corresponding origin '\n 'institute.')\n parser.add_argument('-oe', '--origin-contact-email', required=True,\n help='Contact email for contact person.')\n parser.add_argument('-p', '--project-name', dest='project', \n required=True,\n help='Project that sequence files belong too.')\n\n return parser.parse_args()","def parse_cli():\n parser = OptionParser()\n return parser.parse_args()","def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)","def parse_cli_args() -> ArgumentParser:\n parser = ArgumentParser()\n\n group = parser.add_argument_group(\"Run parameters\")\n group.add_argument(\"--url\", type=str, default=\"DEFAULT\", help=\"URL to run the workflow on.\")\n group.add_argument(\n \"--output\",\n type=Path,\n help=\"Where to save the result locally. If save, remember to also add save flag for config.\",\n default=None,\n )\n group.add_argument(\n \"--windows\",\n type=str,\n nargs=\"*\",\n default=[wtl.Workflow.SINGLE_TAB],\n help=\"Tab names (comma-separated). Use space separation for multiple windows.\",\n )\n group.add_argument(\n \"--config\",\n type=str,\n nargs=\"*\",\n default=[],\n required=False,\n help=\"Names of config files in config/, such as \" '\"iphone_x_mobile\", or key=value pairs.',\n )\n\n cli_args = parser.parse_args()\n cli_args.config.insert(0, \"default\")\n\n if cli_args.url == \"DEFAULT\":\n cli_args.url = start_server()\n\n return cli_args","def parse_cli():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"ENV\", help=\"Enviorment SCANNER, PC, REMOMTE\")\n args = parser.parse_args()\n\n return args","def parse_cli_args() -> argparse.Namespace:\n parser = argparse.ArgumentParser(description='Virtual analog synthesizer')\n parser.add_argument(\n '-i', '--input_path', type=str, required=True,\n help='path to input TSV file with definition of a track to be played'\n )\n parser.add_argument(\n '-p', '--presets_path', type=str, required=True,\n help='path to YAML file with definitions of timbres to be used'\n )\n parser.add_argument(\n '-o', '--output_path', type=str, required=True,\n help='path to output file where result is going to be saved as WAV'\n )\n parser.add_argument(\n '-c', '--config_path', type=str, default=None,\n help='path to configuration file'\n )\n parser.add_argument(\n '-s', '--safe_mode', dest='safe', action='store_true',\n help='validate parsed timbres before core tasks'\n )\n parser.set_defaults(safe=False)\n\n cli_args = parser.parse_args()\n return cli_args","def parse_cli_args():\r\n parser = argparse.ArgumentParser(\r\n description=\"list all installed packages\")\r\n\r\n parser.add_argument(\"-v\", \"--verbose\",\r\n help=\"increase output verbosity\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-d\", \"--debug\",\r\n help=\"enable debug output\",\r\n action=\"store_true\")\r\n\r\n parser.add_argument(\"-N\", \"--dry-run\",\r\n help=\"Do not perform any actions, only simulate them.\",\r\n action=\"store_true\")\r\n\r\n args = parser.parse_args()\r\n\r\n # set debug log state\r\n DebugLog.enabled = args.debug\r\n\r\n with DebugLogScopedPush(\"cli arguments:\"):\r\n DebugLog.print(str(args))\r\n\r\n return args","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n help_str = \\\n 'The collection folder to sort files into. ' \\\n 'If the folder does not exist, it will be created along with the ' \\\n 'necessary contents.'\n parser.add_argument('-c', '--collection', help=help_str)\n\n help_str = \\\n 'The source folder to import files from. Has to exist and ' \\\n 'has to be a folder.'\n parser.add_argument('-s', '--source', help=help_str, required=False)\n\n help_str = \\\n 'View the gallery in random order auto skpping after the' \\\n 'given amount of seconds'\n parser.add_argument('-v', '--view', help=help_str, required=False)\n\n return parser.parse_args()","def parse_command_line() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'pet_database',\n type=str,\n help='path to pet database'\n )\n parser.add_argument(\n '--image_dir',\n default='data/images'\n )\n parser.add_argument(\n '--log',\n default=None,\n help='log file path'\n )\n\n args = parser.parse_args()\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\n return args","def __parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--force', action=\"store_true\", default=False,\n help='overwrite existing database files during import')\n parser.add_argument('-e', '--extension', action=\"store\", default='txt',\n help='specify file extension. default is \"txt\"')\n parser.add_argument('-d', '--delimiter', action=\"store\", default='\\t',\n help='specify column delimiter. default is tab (\\\\t)')\n parser.add_argument('-m', '--mark', action=\"store\", default='.',\n help='specify decimal mark for numeric data. default is'\n ' dot (.)')\n parser.add_argument('-o', '--outformat', action=\"store\", default='npz',\n help='specify output database format. default is \"npz\"'\n ' for numpy database. use \"mat\" for matlab '\n ' database format.')\n parser.add_argument('-r', '--recursive', action=\"store_true\", default=False,\n help='recursively walk through all sub-directories of'\n ' current working directory')\n parser.add_argument('-p', '--pcs', action=\"store_true\", default=True,\n help='indicate if files are pcs files.')\n parser.add_argument('-c', '--colheadlines', action=\"store\", default='1',\n help='number of lines spanned by the column headers')\n args = parser.parse_args()\n return args","def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description='Google reminders cli',\n epilog=usage,\n formatter_class=argparse.RawTextHelpFormatter)\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # Optional Argument\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\n return parser.parse_args()","def _parse_cmd_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"--root\", required=True,\n help=\"Root directory of data and logs.\")\n parser.add_argument(\"--log_dir\", default=\"logs\",\n help=\"Sub-directory of tensorboard logs.\")\n parser.add_argument(\"--gpu\", default=\"0\", help=\"GPU device ID.\")\n\n args = parser.parse_args()\n\n return args","def parse_cli_args(self):\n parser = argparse.ArgumentParser(description='Produce an Ansible Inventory file based on Linode')\n parser.add_argument('--list', action='store_true', default=True,\n help='List nodes (default: True)')\n parser.add_argument('--host', action='store',\n help='Get all the variables about a specific node')\n parser.add_argument('--refresh-cache', action='store_true', default=False,\n help='Force refresh of cache by making API requests to Linode (default: False - use cache files)')\n self.args = parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--debug\",\n help=\"Print lots of debugging statements\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.DEBUG,\n default=logging.ERROR,\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n help=\"Be verbose\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.INFO,\n )\n parser.add_argument(\"runscript\", default=None)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n # If user doesn't specify an input file, read from standard input. Since\n # encodings are the worst thing, we're explicitly expecting std\n parser.add_argument('-i', '--infile',\n type=lambda x: open(x, encoding=ENCODE_IN),\n default=io.TextIOWrapper(\n sys.stdin.buffer, encoding=ENCODE_IN)\n )\n # Same thing goes with the output file.\n parser.add_argument('-o', '--outfile',\n type=lambda x: open(x, 'w', encoding=ENCODE_OUT),\n default=io.TextIOWrapper(\n sys.stdout.buffer, encoding=ENCODE_OUT)\n )\n # Set the verbosity level for the logger. The `-v` option will set it to\n # the debug level, while the `-q` will set it to the warning level.\n # Otherwise use the info level.\n verbosity = parser.add_mutually_exclusive_group()\n verbosity.add_argument('-v', '--verbose', action='store_const',\n const=logging.DEBUG, default=logging.INFO)\n verbosity.add_argument('-q', '--quiet', dest='verbose',\n action='store_const', const=logging.WARNING)\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()","def _ParseCommandArguments():\n arg_parser = argparse.ArgumentParser()\n arg_parser.usage = __doc__\n\n arg_parser.add_argument('--download-dir',\n type=str,\n required=True,\n help='Directory into which corpora are downloaded.')\n arg_parser.add_argument('--build-dir',\n required=True,\n type=str,\n help='Directory where fuzzers were built.')\n args = arg_parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=_program_description)\n parser.add_argument('input_file', help=_input_file_description)\n #parser.add_argument('-v', '--verbose', action='store_true', \n # default=False, help='show progress')\n args = parser.parse_args()\n return args","def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()","def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument()\n return p.parse_args()","def _parse_args():\n parser = argparse.ArgumentParser(description='Run DAFI.')\n parser.add_argument('input_file', help='Name (path) of input file')\n return parser.parse_args()","def parse_args(self, argv=None):\n self.opts, self.args = self.cli_parser.parse_args(argv)\n self.check_arguments()\n self._post_process_opts_and_args()\n return self.opts, self.args","def _cli_parser():\n parser = argparse.ArgumentParser()\n # Original flags\n parser.add_argument('-s', type=str, metavar='input_vol',\n help=\"Absolute path to input volume. Input should be \"\n \"in nifti format\")\n parser.add_argument('-o', type=str, metavar='output_dir',\n help=\"Absolute path to output directory\")\n parser.add_argument('-p', type=str, metavar='template_type', default='MNI152_orig',\n help=\"Type of volumetric template used in index files. \"\n \"Use MNI152_orig or Colin27_orig when -r is \"\n \"RF_ANTs. Use MNI152_norm or Colin27_norm when \"\n \"-r is RF_M3Z. Otherwise, an exception is raised. \"\n \"Ensure that the template matches the standard \"\n \"space of -i (i.e., use MNI152_* if -i is \"\n \"in MNI152-space). Default: MNI152_orig\")\n parser.add_argument('-r', type=str, metavar='RF_type', default='RF_ANTs',\n help=\"Type of Registration Fusion approaches used to \"\n \"generate the mappings (RF_M3Z or RF_ANTs). \" \n \"RF_M3Z is recommended if data was registered \" \n \"from subject's space to the volumetric atlas \" \n \"space using FreeSurfer. RF_ANTs is recommended \" \n \"if such registrations were carried out using \" \n \"other tools, especially ANTs. Default: RF_ANTs\")\n parser.add_argument('-i', type=str, metavar='interp', default='linear',\n help=\"Interpolation (linear or nearest). If \"\n \"-g is label.gii, then interpolation is always set \"\n \"to nearest and a warning is raised. Default: \"\n \"linear\")\n # New flags\n parser.add_argument('-t', type=str, metavar='out_type', default='nii.gz',\n help=\"File type of surface files. nii.gz is true to \"\n \"the original Wu et al (2018) implementation. \"\n \"Note that gifti formats, either \"\n \"func.gii or label.gii, are often preferred. \"\n \"Default: nii.gz\")\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n fromfile_prefix_chars='@',\n description='Convert CVAT XML annotations to masks'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--background-color', metavar='COLOR_BGR', default=\"0,0,0\",\n help='specify background color (by default: 0,0,0)'\n )\n\n parser.add_argument(\n '--label-color', metavar='LABEL:COLOR_BGR', action='append',\n default=[],\n help=\"specify a label's color (e.g. 255 or 255,0,0). The color will \" +\n \"be interpreted in accordance with the mask format.\"\n )\n\n parser.add_argument(\n '--mask-bitness', type=int, choices=[8, 24], default=8,\n help='choose bitness for masks'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output masks'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n return parser.parse_args()","def parse_cli_args():\n\n parser = argparse.ArgumentParser(\n description='Create AMICI model and data for steadystate example.')\n\n parser.add_argument('-s', '--sbml', dest='sbml_file_name',\n required=True,\n help='SBML model filename (PEtab format)')\n\n parser.add_argument('-d', '--model-dir', dest='model_dir',\n help='Model directory containing the python module')\n\n parser.add_argument('-n', '--model-name', dest='model_name',\n required=True,\n help='Name of the AMICI model module')\n\n parser.add_argument('-m', '--measurements', dest='measurement_file_name',\n required=True,\n help='Name of measurement table (PEtab format)')\n\n parser.add_argument('-c', '--conditions', dest='condition_file_name',\n required=True,\n help='Condition table (PEtab format)')\n\n parser.add_argument('-p', '--parameters', dest='parameter_file_name',\n required=True,\n help='Condition table (PEtab format)')\n\n parser.add_argument('-o', dest='hdf5_file_name', default='data.h5',\n help='Name of HDF5 file to generate')\n\n args = parser.parse_args()\n\n return args","def _parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n #parser.add_argument(\"args\", metavar=\"N\", type=str, nargs=\"*\", help=\"Positional arguments.\")\n #parser.add_argument(\"\", dest=\"\", type=\"\", default=, help=)\n #parser.add_argument(\"--version\", action=\"version\", version=\"<the version>\")\n\n return parser.parse_args()","def parse_cmd_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-m', '--path_model', type=str, help='Path to trained model.')\n parser.add_argument('-t', '--type', type=str, help='Either \"torch\" or \"sklearn\".')\n # parser.add_argument('-l', '--location', type=str, help='Either \"local\", \"midgard\" or \"rattle\"')\n parser.add_argument('-i', '--path_in', type=str, help='Path to input file.')\n parser.add_argument('-o', '--path_out', type=str, help='Path to output file.')\n parser.add_argument('-c', '--path_config', type=str, help='Path to config file.')\n parser.add_argument('-g', '--gpu', type=int, default=0, help='Number of the gpu to be used.')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"in_fq\", help=\"The fastq file containing Hi-C reads.\")\n parser.add_argument(\n \"-r\",\n \"--reference\",\n required=True,\n help=\"Path to the reference genome, in FASTA format.\",\n )\n parser.add_argument(\n \"-p\",\n \"--nb_processors\",\n default=1,\n type=int,\n help=\"number of CPUs used for alignment.\",\n )\n parser.add_argument(\n \"-o\",\n \"--out_sam\",\n help=\"Path to the output SAM file for the alignment of in_fq.\",\n )\n parser.add_argument(\n \"-T\",\n \"--tempdir\",\n default=\".\",\n help=\"Directory to write temporary files. Defaults to current directory.\",\n )\n parser.add_argument(\n \"-m\",\n \"--minimap2\",\n default=False,\n action=\"store_true\",\n help=\"Use minimap2 instead of bowtie for the alignment.\",\n )\n parser.add_argument(\n \"-l\",\n \"--min_len\",\n type=int,\n default=20,\n help=\"Minimum length to which reads should be truncated.\",\n )\n return parser.parse_args()","def parseargs() -> argparse.ArgumentParser:\n\n parser = worker.parseargs(\"ACT hybrid-analysis.com Client\")\n\n parser.add_argument(\n \"--feed\", action=\"store_true\", help=\"Download the public feed only, no lookup\"\n )\n\n parser.add_argument(\n \"--apikey\", default=\"\", help=\"community apikey for hybrid-analysis.com\"\n )\n\n parser.add_argument(\n \"--user-agent\", default=\"Falcon Sandbox\", help=\"User agent while talking to API\"\n )\n\n parser.add_argument(\n \"--no-check-certificate\",\n action=\"store_true\",\n help=\"Do not check SSL certificate\",\n )\n\n return parser","def parse_args():\n parser = argparse.ArgumentParser(\n description='Convert CVAT XML annotations to PASCAL VOC format'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--image-dir', metavar='DIRECTORY', required=True,\n help='directory which contains original images'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output annotations in PASCAL VOC format'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n formatter_class=RawDescriptionHelpFormatter,\n description=\"This tool compares Master lab data with new data CSV files\",\n epilog=\"E.g.: ./cdc.py Master/Master.csv TestCaptures/data1.csv \"\n \"TestCaptures/data2.csv TestCaptures/data3.csv TestCaptures/data4.csv\",\n )\n parser.add_argument(\n \"master\", help=\"A Master CLIA CDC CSV file to process\",\n )\n parser.add_argument(\n \"new_files\",\n type=argparse.FileType(\"r\"),\n nargs=\"+\",\n help=\"A number of new CLIA CSV files to compare with Master\",\n )\n parser.add_argument(\n \"-e\", \"--extra\", action=\"store_true\", help=\"Display some extra data\",\n )\n parser.add_argument(\n \"-f\",\n \"--force\",\n action=\"store_true\",\n help=\"Bypass safety rails - very dangerous\",\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"store_true\",\n help=\"turn on verbose messages, commands and outputs\",\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description='Convert CVAT XML annotations to YOLO format'\n )\n\n parser.add_argument(\n '--cvat-xml', metavar='FILE', required=True,\n help='input file with CVAT annotation in xml format'\n )\n\n parser.add_argument(\n '--image-dir', metavar='DIRECTORY', required=False,\n help='directory which contains original images'\n )\n\n parser.add_argument(\n '--output-dir', metavar='DIRECTORY', required=True,\n help='directory for output annotations in YOLO format'\n )\n\n parser.add_argument(\n '--username', metavar='USERNAME', required=False,\n help='Username from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--password', metavar='PASSWORD', required=False,\n help='Password from CVAT Login page, required to download images'\n )\n\n parser.add_argument(\n '--labels', metavar='ILABELS', required=False,\n help='Labels (separated by comma) to extract. Example: car,truck,motorcycle'\n )\n\n return parser.parse_args()","def _parse_args():\n args = sys.argv[1:]\n cmd_parser = argparse.ArgumentParser()\n cmd_parser.add_argument(\n '--produce-sub',\n dest='produce_sub',\n help='Produce submision file',\n default=False,\n action='store_true',\n )\n cmd_parser.add_argument(\n '--search-cv',\n dest='search_cv',\n help='Perform Search of parameters',\n default=False,\n action='store_true',\n )\n cmd_opts = cmd_parser.parse_args(args=args)\n return cmd_opts","def parse_command_args():\n parser = argparse.ArgumentParser(prog='iota.intercept')\n parser.add_argument('path', type=str, nargs = '?', default = None,\n help = 'Path to data file')\n parser.add_argument('--backend', type=str, default='dials',\n help='Backend for processing')\n parser.add_argument('--paramfile', type=str, default=None,\n help='Parameter file for processing')\n parser.add_argument('--output', type=str, default=None,\n help='Output filename')\n parser.add_argument('--termfile', type=str, default='.stop',\n help='Termination signal filename')\n parser.add_argument('--index', type=int, default=1,\n help='Numerical index of the image')\n parser.add_argument('--nproc', type=int, default=None,\n help='Number of processors')\n parser.add_argument('--action', type=str, default='spotfind',\n help='Code for how far to go; available codes: '\n 'spotfind, index, integrate')\n parser.add_argument('--verbose', action = 'store_true',\n help='Print information to stdout')\n\n return parser","def parse_cli():\n parser = argparse.ArgumentParser(\n description=\"\"\"\n Get information about Red Hat OpenStack overcloud servers and roles.\n All output is JSON for further processing.\n \"\"\")\n\n parser.add_argument('-d', '--debug', action='store_true',\n default=False,\n help=\"Print additional information for status and diagnosis\")\n selector_group = parser.add_mutually_exclusive_group()\n selector_group.add_argument('-s', '--server',\n help=\"Find the role of a specified server\")\n selector_group.add_argument('-r', '--role',\n help=\"Find the servers under a specified role\")\n selector_group.add_argument('-R', '--list-roles', dest=\"list_roles\",\n action='store_true', default=False,\n help=\"list the roles defined for this cluster\")\n selector_group.add_argument('-o', '--orphan-nodes', action=\"store_true\",\n default=False,\n help='list any undeployed or untagged nodes')\n\n env_group = parser.add_mutually_exclusive_group()\n env_group.add_argument('-V', '--require-env', dest=\"require_env\", action='store_true', default=True)\n env_group.add_argument('--no-require-env', dest=\"require_env\", action='store_false')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--length', required=True, type=int, help='Test length in seconds')\n parser.add_argument('--txs-per-ledger', required=True, type=int, help='Transaction rate to submit (spam) in parallel for every ledger round')\n parser.add_argument('--prioritizer-seeds-file', required=True, type=str, help='File path to prioritizer seeds file')\n parser.add_argument('--spammer-seeds-file', required=True, type=str, help='File path to spammer seeds file')\n parser.add_argument('--out', default='spam-results-{}.json'.format(str(int(time.time()))), type=str, help='Spam results JSON output')\n parser.add_argument('--avg-block-time', type=int, default=5, help='Average block time. Controls the time delay between every spam round and the one just after that')\n\n parser.add_argument('--passphrase', type=str, help='Network passphrase')\n parser.add_argument('--horizon', action='append',\n help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('n_iter',\n help='number of iteration',\n type=int)\n parser.add_argument('n_processes',\n help='number of processes',\n type=int)\n parser.add_argument('method',\n help='mutual exclusion method')\n parser.add_argument('duration',\n help='Duration of each process',\n type=float)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n parser.add_argument(\n \"config_path\",\n type=str,\n help=\"Path to the JSON configuration file containing the image transformation settings.\",\n )\n parser.add_argument(\n \"img_path\",\n type=str,\n help=\"Path to the input image file to apply transformations.\",\n )\n return parser.parse_args()","def parse_cli_args():\n\n parser = argparse.ArgumentParser(\n description='Create AMICI model PEtab files for steadystate example.')\n\n parser.add_argument('-o', '--model-output-dir', dest='model_output_dir',\n default='model_steadystate_scaled',\n help='Name of the AMICI model directory to be created')\n\n parser.add_argument('-f', dest='hdf5_file_name',\n default='example_data.h5',\n help='Name of HDF5 file to generate')\n\n parser.add_argument('-p', dest='petab_dir',\n default='steadystate_petab',\n help='Directory to write PEtab files to')\n\n args = parser.parse_args()\n\n return args","def parse_command_line():\n parser = argparse.ArgumentParser(description='Parses ID\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\n parser.add_argument('-f', '--file', dest='file',\n action='store',\n help='Filenname to be read')\n arg_manager = parser.parse_args()\n return arg_manager","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input-model\", help=\"Path to read input model from\")\n options = parser.parse_args()\n return options","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # All reference encoders\n parser.add_argument(\"--step\", dest=\"step\", default=\"10\", type=int, help=\"step size\")\n parser.add_argument(\"--repeats\", dest=\"repeats\", type=int, default=1, help=\"repeats\")\n\n parser.add_argument(dest=\"image\", default=None,\n help=\"select the test image to run\")\n\n args = parser.parse_args()\n return args","def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()","def _parse_args(argv):\n parser = make_parser()\n args = parser.parse_args(argv)\n LOGGER.setLevel(to_log_level(args.loglevel))\n\n if not args.inputs:\n if args.list:\n tlist = \", \".join(API.list_types())\n _exit_with_output(\"Supported config types: \" + tlist)\n elif args.env:\n cnf = os.environ.copy()\n _output_result(cnf, args.output, args.otype or \"json\", None, None)\n sys.exit(0)\n else:\n parser.print_usage()\n sys.exit(1)\n\n if args.validate and args.schema is None:\n _exit_with_output(\"--validate option requires --scheme option\", 1)\n\n return args","def arg_parse():\n parser = argparse.ArgumentParser()\n # defines command line arguments\n parser.add_argument('-i', '--input_file', help=\"The input .txt file \" +\n \"within the current directory (the file you \" +\n \"downloaded from VEP\")\n parser.add_argument('-o', '--output_file', help=\"Name for the output \" +\n \".txt file\")\n\n return parser.parse_args()","def _parse_cli_opts(self, args):\n self._args = args\n for opt, group in self._all_cli_opts():\n opt._add_to_cli(self._oparser, group)\n\n return self._parse_config_files()","def parse_command_line():\n parser = argparse.ArgumentParser(prog='scoring')\n parser.add_argument(\"pdb_list\", help=\"list of PDB structures\")\n script_args = parser.parse_args()\n return script_args","def parse_command_line():\n parser = ArgumentParser(description=__doc__,\n formatter_class=RawTextHelpFormatter,\n epilog=\"For a list of table formats check this page: \"\n \"https://github.com/astanin/python-tabulate#table-format\"\n )\n requir = parser.add_argument_group(\"required arguments\")\n requir.add_argument(\"-f\", \"--find\",\n required=True,\n help=\"Search string to identify\"\n )\n requir.add_argument(\"-k\", \"--client_id\",\n required=True,\n help=\"CrowdStrike API client ID\"\n )\n requir.add_argument(\"-s\", \"--client_secret\",\n required=True,\n help=\"CrowdStrike API client secret\"\n )\n parser.add_argument(\"-r\", \"--reverse\",\n help=\"Reverse the sort.\",\n default=False,\n action=\"store_true\"\n )\n parser.add_argument(\"-t\", \"--types\",\n help=\"Types to search (indicator, report or actor). Comma delimited.\"\n )\n parser.add_argument(\"-tf\", \"--table_format\",\n help=\"Set the table format.\",\n default=\"fancy_grid\"\n )\n parser.add_argument(\"-o\", \"--output_prefix\",\n help=\"Output filename prefix for storing results (CSV format).\",\n default=None\n )\n\n parsed = parser.parse_args()\n allow = [\"indicator\", \"report\", \"actor\"]\n parsed.types = [t for t in parsed.types.split(\",\") if t in allow] if parsed.types else allow\n\n return parsed","def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments","def parse_args():\n parser = ArgumentParser(\n description=\"This is a script for auto apply ipex optimization.\"\n \"\\n################################# Basic usage ############################# \\n\"\n \"\\n 1. Apply ipex optimization with fp32 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\n\"\n \"\\n 2. Apply ipex optimization with bf16 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\n\",\n formatter_class=RawTextHelpFormatter,\n )\n\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\n\n # positional\n parser.add_argument(\n \"program\",\n type=str,\n help=\"The full path to the proram/script to be launched. \"\n \"followed by all the arguments for the script\",\n )\n # rest from the training program\n parser.add_argument(\"program_args\", nargs=REMAINDER)\n return parser.parse_args()","def parse_args() -> argparse.ArgumentParser:\n parser = argparse.ArgumentParser(description=__doc__)\n\n # Enable command line arguments\n parser.add_argument('--process',\n action='store_true',\n help='Run data processing')\n parser.add_argument('--classify',\n action='store_true',\n help='Run classification')\n parser.add_argument('--lcs_file',\n type=str,\n help='Path to lcs file')\n parser.add_argument('--datasets_file',\n type=str,\n help='Path to datasets file')\n parser.add_argument('--mode',\n type=str,\n help=('Type of data to classify. r=realtime, f=full, r'\n 'fp=realtime+force_photo, ffp=full+force_photo'))\n parser.add_argument('--results_outfile',\n type=str,\n help='Filename to store results',\n default='KNC-Live_Results.csv')\n parser.add_argument('--results_dir',\n type=str,\n help='Directory to save results',\n default='knc_results/')\n parser.add_argument('--rfc_dir',\n type=str,\n help='Path to directory containing classifiers',\n default='classifiers/')\n parser.add_argument('--id_map_file',\n type=str,\n help='Name of ID map file in classifier directory',\n default='id_map.npy')\n parser.add_argument('--verbose',\n action='store_true',\n help='Print status updates')\n parser.add_argument('--skip_cv',\n action='store_true',\n help='Skip hyperparam optimization')\n parser.add_argument('--distribute',\n action='store_true',\n help='Use multiprocessing')\n\n return parser","def parse_args():\n parser = argparse.ArgumentParser(description=\"Hyper parameter\")\n parser.add_argument(\n \"--model\", help=\"Model to use\", default=\"DenseNet169\", type=str)\n parser.add_argument(\n \"--optimizer\", help=\"which optimizer to use\", default=\"Adam\", type=str)\n parser.add_argument(\n \"--lr\", help=\"learning rate\", default=2e-5, type=float)\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n \n parser.add_argument('--p', dest='path_in',\n action='store', type=str, required=True, default='',\n help=\"Path relative to the data/ directory, to the input ATL01, ANC13, and ANC27 files.\")\n parser.add_argument('--atl01', dest='atl01_file',\n action='store', type=str, required=False, default=None,\n help=\"Path + filename to directory of the ATL01.\")\n parser.add_argument('--anc13', dest='anc13_path',\n action='store', type=str, required=False, default=None,\n help=\"Path to outputs directory of the ANC13.\") \n parser.add_argument('--anc27', dest='anc27_path',\n action='store', type=str, required=False, default=None,\n help=\"Path to directory of the ANC27.\")\n\n args = parser.parse_args()\n \n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--start\",\n type=str,\n default=\"\",\n required=False,\n help=\"The start square of the agent, in the form row,col. If not specified, this is randomized\"\n )\n parser.add_argument(\n \"--actions\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The actions the agent takes, comma delimited\"\n )\n parser.add_argument(\n \"--observations\",\n type=str,\n required=True,\n nargs = '+',\n help=\"The observations the agent makes, comma delimited\"\n )\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--version',\n metavar=\"<str>\",\n help=\"Input data version number\",\n type=str,\n required=True\n )\n args = parser.parse_args()\n return args","def parse_args(*opts_args):\n parser = argparse.ArgumentParser()\n cmd = Command()\n parser = cmd.create_parser(\"import_measures\", \"\")\n options = parser.parse_args(opts_args)\n return cmd.parse_options(options.__dict__)","def cmdline_parser():\n parser = argparse.ArgumentParser(description=\"\"\" \"\"\")\n parser.add_argument(\"-i1\",\n help=\"\"\"viral alignments\"\"\",\n dest=\"viral\",\n required=True)\n parser.add_argument(\"-i2\",\n help=\"\"\"GTA alignments\"\"\",\n dest=\"gta\",\n required=True)\n parser.add_argument(\"-o\",\n dest=\"output\",\n help=\"output image file\")\n return parser","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-e', '--env', default='production',\n help='Environment to check: integration, staging, production.')\n parser.add_argument('-l', '--log_type', default='govuk_assets',\n help='Which logs to check: govuk_assets, govuk_www.')\n parser.add_argument('-c', '--critical_age_minutes', type=int, default=60,\n help='If the newest logs are older than this many minutes, '\n 'return CRITICAL status.')\n parser.add_argument('-F', '--fake_time', type=fromisoformat,\n help='For testing purposes, use the given time as if it\\'s the current '\n 'time. Requires the format YYYY-MM-DDTHH:MM. Assumes UTC.')\n parser.add_argument('-v', '--verbose', action='count',\n help='Show DEBUG log messages.')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--zarr_dir',\n type=str,\n help='path to directory of zarr files',\n )\n parser.add_argument(\n '--tiff_dir',\n type=str,\n help='path to directory of tiff files',\n )\n parser.add_argument(\n '--output_dir',\n type=str,\n help='path to directory for writing',\n )\n parser.add_argument(\n '--config_path',\n type=str,\n default=None,\n help='path to yaml preprocess config file',\n )\n \n args = parser.parse_args()\n return args","def cmdline_parser():\n\n # http://docs.python.org/dev/howto/argparse.html\n parser = argparse.ArgumentParser(description=__doc__)\n \n parser.add_argument(\"--verbose\",\n action=\"store_true\",\n help=\"Be verbose\")\n parser.add_argument(\"--debug\",\n action=\"store_true\",\n help=\"Enable debugging\")\n parser.add_argument(\"-b\", \"--bam\",\n required=True,\n help=\"Input BAM file matching vcf\")\n parser.add_argument(\"-i\", \"--vcf\",\n help=\"Input VCF file containing variants to analyze\"\n \" (clashes with --var)\")\n parser.add_argument(\"-v\", \"--var\",\n help=\"Report reads for this variant only. Format: chr:pos:ref-alt\"\n \" (clashes with --vcf)\")\n default = 0\n parser.add_argument(\"--mq-filter\",\n dest=\"min_mq\",\n type=int,\n default=default,\n help=\"Ignore reads with mapping quality below this value (default=%d)\" % default)\n default = 5\n parser.add_argument(\"--bq-filter\",\n dest=\"min_bq\",\n type=int,\n default=default,\n help=\"Ignore reads with bases below this value (default=%d)\" % default)\n parser.add_argument(\"-a\", \"--use-orphan\",\n action=\"store_true\",\n help=\"Don't ignore orphan-reads / anomalous read-pairs\")\n\n return parser","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()","def parse_args():\n global Args\n parser = argparse.ArgumentParser()\n subparsers = parser.add_subparsers()\n pars_simulation(subparsers)\n pars_analyze(subparsers)\n Args = parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n\n parser.add_argument('--source-account', required=True, type=str, help='Source account to pay transaction fees')\n parser.add_argument('--channel-seeds-file', required=True, type=str, help='File path to channel seeds file')\n parser.add_argument('--accounts', required=True, type=int, help='Amount of accounts to create')\n parser.add_argument('--passphrase', required=True, type=str, help='Network passphrase')\n parser.add_argument('--horizon', action='append', help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\n parser.add_argument('--json-output', required=False, type=bool, help='Export output to json format')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Re-ID feature extractor\")\n parser.add_argument(\n \"--model\",\n default=\"resources/networks/mars-small128.ckpt-68577\",\n help=\"Path to checkpoint file\")\n parser.add_argument(\n \"--loss_mode\", default=\"cosine\", help=\"Network loss training mode\")\n parser.add_argument(\n \"--mot_dir\", help=\"Path to MOTChallenge directory (train or test)\",\n required=True)\n parser.add_argument(\n \"--detection_dir\", help=\"Path to custom detections. Defaults to \"\n \"standard MOT detections Directory structure should be the default \"\n \"MOTChallenge structure: [sequence]/det/det.txt\", default=None)\n parser.add_argument(\n \"--output_dir\", help=\"Output directory. Will be created if it does not\"\n \" exist.\", default=\"detections\")\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\"BaselineMembershipInferenceAttack\")\n parser.add_argument(\"--batch_size\",\n type=int, default=128,\n help=\"The batch size of normal training.\")\n parser.add_argument(\"--train_epoch\",\n type=int, default=10,\n help=\"The epoch of training.\")\n parser.add_argument(\"--train_lr\",\n type=float, default=0.0002,\n help=\"The learning rate of training.\")\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description='baseline Mask R-CNN')\n parser.add_argument('--dataset', required=True,\n metavar=\"/path/to/dataset/\",\n help='Directory of the dataset')\n parser.add_argument('--continue_train', type=str, required=False, default='None',\n metavar=\"/path/to/latest/weights.h5\", help=\"Path to lastest training weights .h5 file\")\n parser.add_argument('--weight', required=False,\n metavar='/path/to/pretrained/weight.h5', help=\"Path to trained weight\")\n parser.add_argument('--image', required=False,\n metavar='/path/to/testing/image/directory', help=\"Path to testing image directory\")\n parser.add_argument('--video', required=False,\n metavar='/path/to/testing/image/directory', help=\"Path to testing image directory\")\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"SLOWFAST for AVA Dataset\")\n parser.add_argument(\"--pipeline\", type=str,\n default=\"../data/config/slowfast.pipeline\", help=\"SDK infer pipeline\")\n parser.add_argument(\"--data_dir\", type=str, default=\"../data/input\",\n help=\"Dataset contain frames and ava_annotations\")\n args_opt = parser.parse_args()\n return args_opt","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n # TODO: Check if `verbose` actually does anything.\n parser.add_argument(\"-v\", \"--verbose\",\n dest=\"verbose\", action=\"store_true\", default=False,\n help=\"dump internal state\")\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description=app_description,\n formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"--input-json\", dest=\"input_json_path\", required=True,\n help=input_json_help)\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--duration\",\n type=mesos_maintenance.parse_timedelta,\n default=\"1h\",\n help=\"Duration of the maintenance window. Any pytimeparse unit is supported.\",\n )\n parser.add_argument(\n \"-s\",\n \"--start\",\n type=mesos_maintenance.parse_datetime,\n default=str(mesos_maintenance.now()),\n help=\"Time to start the maintenance window. Defaults to now.\",\n )\n parser.add_argument(\n \"action\",\n choices=[\n \"cluster_status\",\n \"down\",\n \"drain\",\n \"is_host_down\",\n \"is_host_drained\",\n \"is_host_draining\",\n \"is_hosts_past_maintenance_end\",\n \"is_hosts_past_maintenance_start\",\n \"is_safe_to_drain\",\n \"is_safe_to_kill\",\n \"schedule\",\n \"status\",\n \"undrain\",\n \"up\",\n ],\n help=\"Action to perform on the specified hosts\",\n )\n parser.add_argument(\n \"hostname\",\n nargs=\"*\",\n default=[getfqdn()],\n help=\"Hostname(s) of machine(s) to start draining. \"\n \"You can specify <hostname>|<ip> to avoid querying DNS to determine the corresponding IP.\",\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n action=\"count\",\n dest=\"verbose\",\n default=0,\n help=\"Print out more output.\",\n )\n return parser.parse_args()","def __parse_cmd_args():\n parser = argparse.ArgumentParser(description='Python Image Downloader.')\n parser.add_argument(\"-f\", \"--file\",\n help=\"Where the URL file is located.\")\n parser.add_argument(\"-d\", \"--dir\",\n help=\"Where the downloaded files are to be stored.\")\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\n required=False, help='Specifies the base path for both logs and apk_downloads.')\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\n help='Specifies the path to a credential file in .toml format.')\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\n help='Specifies the maximum number of apks per category to download.')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Reads in iClicker data from the submission \"\n \"directory, and then writes it to the given \"\n \"remote file.\")\n parser.add_argument(\"submission_directory\", type=str, help=\"Directory of submissions that \"\n \"contain a 'textbox_0.txt' file that references iClicker ID\")\n parser.add_argument(\"remote_id_file\", type=str)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Subscription Watch CSV file packaging script\", prog=sys.argv[0])\n\n # required args\n parser.add_argument(\"-f\", \"--filepath\", required=True,\n help=\"path to files to package\")\n parser.add_argument(\n \"-s\",\n \"--max-size\",\n type=int,\n default=DEFAULT_MAX_SIZE,\n help=f\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\",\n )\n parser.add_argument(\n \"-o\", \"--overwrite\", action=\"store_true\", default=False, help=\"whether to overwrite existing files.\"\n )\n parser.add_argument(\"--ocp-cluster-id\", required=True,\n help=\"OCP Cluster ID\")\n parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n default=0, help=\"increase verbosity (up to -vvv)\")\n return parser.parse_args()","def parse_command_line(argv):\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--logfile\",\n default=None,\n type=str,\n help=\"If specified, write logs to this file.\",\n )\n parser.add_argument(\n \"--loglevel\",\n help=\"Set logging level (DEBUG, INFO, WARNING, ERROR, or CRITICAL).\",\n default=\"INFO\",\n )\n return parser.parse_args(argv[1:])","def parse_args():\n parser = argparse.ArgumentParser(\n description='Run the destination IoT program (CTRL-C to exit)')\n\n parser.add_argument('-v',\n '--verbose',\n default=False,\n action='store_true',\n help='Print all debug logs')\n\n parser.add_argument('-p',\n '--port',\n metavar='<port number>',\n default=7777,\n type=int,\n help='Default: 7777')\n\n parser.add_argument('-a',\n '--address',\n metavar='<email_address>',\n nargs='*',\n help='Email address(es) to receive notifications')\n\n args = parser.parse_args()\n return args","def parse_args(args):\n parser = argparse.ArgumentParser(\n description=\"Lookup table generator for Image Comparison\")\n parser.add_argument(\n \"--version\",\n action=\"version\",\n version=\"lookuptable {ver}\".format(ver=__version__))\n parser.add_argument(\n \"-f\",\n \"--folder\",\n dest=\"imagefolder\",\n help=\"path to image folder\",\n type=str,\n metavar=\"STRING\")\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action=\"store_const\",\n const=logging.INFO)\n parser.add_argument(\n \"-vv\",\n \"--very-verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action=\"store_const\",\n const=logging.DEBUG)\n return parser.parse_args(args)","def parse_args():\n parser = argparse.ArgumentParser(description=\"Deep SORT\")\n parser.add_argument(\n \"--input\", help=\"Path to MOTChallenge sequence directory\",\n default=None, required=True)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Check the ERC 20 conformance\", usage=\"fortress-check-erc project contractName\",\n )\n\n parser.add_argument(\"project\", help=\"The codebase to be tested.\")\n\n parser.add_argument(\n \"contract_name\",\n help=\"The name of the contract. Specify the first case contract that follow the standard. Derived contracts will be checked.\",\n )\n\n parser.add_argument(\n \"--erc\",\n help=f\"ERC to be tested, available {','.join(ERCS.keys())} (default ERC20)\",\n action=\"store\",\n default=\"erc20\",\n )\n\n parser.add_argument(\n \"--json\",\n help='Export the results as a JSON file (\"--json -\" to export to stdout)',\n action=\"store\",\n default=False,\n )\n\n # Add default arguments from crytic-compile\n cryticparser.init(parser)\n\n return parser.parse_args()","def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale","def parse_args():\n p = argparse.ArgumentParser(\n description='Parse system logs, for fun or something')\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\n return p.parse_args()","def parse_args(self, argv=None):\n self.opts, self.args = self.cli_parser.parse_args(argv)\n self._begin_logging()\n if argv is None:\n argv = sys.argv\n logger.info(' '.join(argv))\n self._process_input_files()\n self._construct_links_of_interest()\n self._open_output_files()\n data = self._construct_data_struct()\n return data","def parse_arguments(args=sys.argv[1:]):\n \n parser = argparse.ArgumentParser()\n \n parser.add_argument('-i', '--input',\n help=\"Path of input file to read. Default: {d}\".format(d=INPUT_FILE),\n default=INPUT_FILE)\n \n return parser.parse_args(args)","def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()","def parse_cmdline_args():\n parser = argparse.ArgumentParser(description=\"Guesses the functional element for host.\")\n ##\n ## Internal options\n ##\n parser.add_argument(\"--json\", dest=\"json\", action='store_true', help=\"output in JSON\")\n\n ##\n ## PuppetDB options\n ##\n pdbconf = PdbConfig()\n pdbconf.add_standard_args(parser)\n\n parser.add_argument(\"host\", metavar=\"HOST\",\n help=\"hostnames to query for FE\")\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()","def parse_cli():\n args = {}\n arg_name = None\n arg_values = None\n parameters = {}\n\n cli_args = sys.argv\n found_params = False\n skip = True\n iterator = enumerate(cli_args)\n\n for idx, arg in iterator:\n if skip:\n skip = False\n continue\n else:\n skip = True\n\n if arg == \"--params\":\n if arg_name:\n args[arg_name] = \" \".join(arg_values)\n found_params = True\n skip = False\n\n elif arg[0:2] == \"--\" and not found_params:\n if arg_name:\n args[arg_name] = \" \".join(arg_values)\n arg_name = arg[2:]\n arg_values = []\n skip = False\n\n elif arg[0:2] == \"--\" and found_params:\n raise ValueError(\"You are trying to specify an argument after the \"\n \"--params argument. Please change the order.\")\n\n elif arg[0] == \"-\" and arg[0:2] != \"--\" and found_params:\n parameters[cli_args[idx][1:]] = cli_args[idx+1]\n\n elif arg[0] == \"-\" and arg[0:2] != \"--\" and not found_params:\n raise ValueError(\"You either try to use arguments with only one lea\"\n \"ding minus or try to specify a hyperparameter bef\"\n \"ore the --params argument. %s\" %\n \" \".join(cli_args))\n elif arg[0:2] != \"--\" and not found_params:\n arg_values.append(arg)\n skip = False\n\n elif not found_params:\n raise ValueError(\"Illegal command line string, expected an argument\"\n \" starting with -- but found %s\" % (arg,))\n\n else:\n raise ValueError(\"Illegal command line string, expected a hyperpara\"\n \"meter starting with - but found %s\" % (arg,))\n\n return args, parameters","def parse_command_line():\n\n desc = \"Perform fluid dynamics simulations.\"\n parser = argparse.ArgumentParser(description=desc)\n\n # Parameter file\n help_txt = \"name of the configuration file (default is 'config.ini.')\"\n parser.add_argument(\"-f\", \"--file\", metavar=\"FILE\", default=\"config.ini\",\n required=False, dest=\"config_file\", help=help_txt)\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\"Run arguments for system submitted tasks\")\n\n parser.add_argument(\"-f\", \"--funcs\", type=str, nargs=\"?\", required=True,\n help=\"path to pickle file containing a list of \"\n \"functions/methods that should be run by the \"\n \"submitted process\"\n )\n parser.add_argument(\"-k\", \"--kwargs\", type=str, nargs=\"?\", required=False,\n default=None,\n help=\"path to pickle file containing a dictionary of \"\n \"keyword argumnets that should be passed to the \"\n \"functions\")\n parser.add_argument(\"-e\", \"--environment\", type=str, nargs=\"?\",\n required=False,\n help=\"Optional comma-separated environment variables, \"\n \"which should be given as \"\n \"VARNAME1=value1,VARNAME2=value2 and so on. These \"\n \"will be separated and instantiated into Python's \"\n \"os.environ\")\n\n return parser.parse_args()","def parse_args():\n\tparser = argparse.ArgumentParser(description='Show video statistics.')\n\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\n\t default='views',\n\t help='sort by the specified field. Options are views, likes and dislikes.')\n\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\n\tparser.add_argument('--csv', action='store_true', default=False,\n\t help='output the data in CSV format.')\n\tparser.add_argument('--table', action='store_true', default=False,\n\t help='output the data in an ascii table.')\n\tparser.add_argument('--workers', type=int, default=8,\n\t help='number of workers to use, 8 by default.')\n\treturn parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(description=\"Sequence Cleaner: Remove Duplicate Sequences, etc\",\n epilog=\"example > sequence_cleaner -q INPUT -o OUTPUT\")\n parser.add_argument('-v', '--version', action='version', version='sequence_cleaner {}'.format(version))\n parser.add_argument(\"-q\", \"--query\", help=\"Path to directory with FAST(A/Q) files\", required=True)\n parser.add_argument(\"-o\", \"--output_directory\", help=\"Path to output files\", required=True)\n parser.add_argument(\"-ml\", \"--minimum_length\", help=\"Minimum length allowed (default=0 - allows all the lengths)\",\n default=\"0\")\n parser.add_argument(\"-mn\", \"--percentage_n\", help=\"Percentage of N is allowed (default=100)\", default=\"100\")\n parser.add_argument('--keep_all_duplicates', help='Keep All Duplicate Sequences', action='store_false', required=False)\n parser.add_argument('--remove_ambiguous', help='Remove any sequence with ambiguous bases', action='store_true', required=False)\n\n parser.add_argument('-l', '--log', help='Path to log file (Default: STDOUT).', required=False)\n\n return parser.parse_args()","def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()","def command_line_parse(iargs=None):\n\n parser = create_parser()\n inps = parser.parse_args(args=iargs)\n\n return inps","def _parse_args(self):\n parser = argparse.ArgumentParser()\n _, args = parser.parse_known_args()\n self.args = [a for a in args if a != '']","def parse_args():\n parser = argparse.ArgumentParser()\n argparse.ArgumentParser(argument_default=False)\n parser.add_argument('-r', type=str, required=True, metavar='[reference.fa]', help=\"Reference file in fasta format\")\n parser.add_argument('-s', type=int, metavar='number of SNPs', help=\"Number of SNPs to introduce\")\n parser.add_argument('-i', type=int, metavar='number of indels', help=\"Number of small indels to introduce. Indel sizes randomly sampled between 1-100bp with a ratio of 9:1 for size being < 11bp\")\n parser.add_argument('-d', type=int, metavar='number of large deletions', help=\"Number of large deletions to introduce. Deletion size randomly sampled between 100-5000bp\")\n parser.add_argument('-t', type=int, metavar='number of translocations', help=\"number of translocations, regions will be randomly selected ranging between 500-5000bp in size\")\n parser.add_argument('-nc', type=bool, default=False, metavar='add at least one non-conserved translocation', help=\"True/False add one non-conserved translocation. Deletion occurs from end of the translocation. Default=False\")\n parser.add_argument('-f', type=str, required=True, metavar='output fasta filename', help=\"Output fasta filename and file path\")\n parser.add_argument('-v', type=str, required=True, metavar='output vcf file of mutations', help=\"Output vcf filename and file path\")\n\n return parser.parse_args()"],"string":"[\n \"def parse_cli_arguments():\\n parser = argparse.ArgumentParser('Generates a MANIFEST file used by the '\\n 'HMP2 AnADAMA2 workflows.')\\n parser.add_argument('-b', '--broad-data-sheet', required=True,\\n help='Broad data product status spreadsheet. '\\n 'Contains entries indicating new files to be '\\n 'processed.')\\n parser.add_argument('-o', '--output-manifest', required=True,\\n help='Path to desired output manifest file.')\\n parser.add_argument('-oi', '--origin-institute', required=True,\\n help='Name of institute submitting new files '\\n 'to be processed.')\\n parser.add_argument('-oc', '--origin-contact', required=True,\\n help='Contact person for corresponding origin '\\n 'institute.')\\n parser.add_argument('-oe', '--origin-contact-email', required=True,\\n help='Contact email for contact person.')\\n parser.add_argument('-p', '--project-name', dest='project', \\n required=True,\\n help='Project that sequence files belong too.')\\n\\n return parser.parse_args()\",\n \"def parse_cli():\\n parser = OptionParser()\\n return parser.parse_args()\",\n \"def parse_command_line(self, argv):\\n from optparse import OptionParser\\n usage = \\\"usage: %prog [options]\\\"\\n parser = OptionParser(usage)\\n\\n (options, args) = parser.parse_args(argv)\",\n \"def parse_cli_args() -> ArgumentParser:\\n parser = ArgumentParser()\\n\\n group = parser.add_argument_group(\\\"Run parameters\\\")\\n group.add_argument(\\\"--url\\\", type=str, default=\\\"DEFAULT\\\", help=\\\"URL to run the workflow on.\\\")\\n group.add_argument(\\n \\\"--output\\\",\\n type=Path,\\n help=\\\"Where to save the result locally. If save, remember to also add save flag for config.\\\",\\n default=None,\\n )\\n group.add_argument(\\n \\\"--windows\\\",\\n type=str,\\n nargs=\\\"*\\\",\\n default=[wtl.Workflow.SINGLE_TAB],\\n help=\\\"Tab names (comma-separated). Use space separation for multiple windows.\\\",\\n )\\n group.add_argument(\\n \\\"--config\\\",\\n type=str,\\n nargs=\\\"*\\\",\\n default=[],\\n required=False,\\n help=\\\"Names of config files in config/, such as \\\" '\\\"iphone_x_mobile\\\", or key=value pairs.',\\n )\\n\\n cli_args = parser.parse_args()\\n cli_args.config.insert(0, \\\"default\\\")\\n\\n if cli_args.url == \\\"DEFAULT\\\":\\n cli_args.url = start_server()\\n\\n return cli_args\",\n \"def parse_cli():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"ENV\\\", help=\\\"Enviorment SCANNER, PC, REMOMTE\\\")\\n args = parser.parse_args()\\n\\n return args\",\n \"def parse_cli_args() -> argparse.Namespace:\\n parser = argparse.ArgumentParser(description='Virtual analog synthesizer')\\n parser.add_argument(\\n '-i', '--input_path', type=str, required=True,\\n help='path to input TSV file with definition of a track to be played'\\n )\\n parser.add_argument(\\n '-p', '--presets_path', type=str, required=True,\\n help='path to YAML file with definitions of timbres to be used'\\n )\\n parser.add_argument(\\n '-o', '--output_path', type=str, required=True,\\n help='path to output file where result is going to be saved as WAV'\\n )\\n parser.add_argument(\\n '-c', '--config_path', type=str, default=None,\\n help='path to configuration file'\\n )\\n parser.add_argument(\\n '-s', '--safe_mode', dest='safe', action='store_true',\\n help='validate parsed timbres before core tasks'\\n )\\n parser.set_defaults(safe=False)\\n\\n cli_args = parser.parse_args()\\n return cli_args\",\n \"def parse_cli_args():\\r\\n parser = argparse.ArgumentParser(\\r\\n description=\\\"list all installed packages\\\")\\r\\n\\r\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\",\\r\\n help=\\\"increase output verbosity\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n parser.add_argument(\\\"-d\\\", \\\"--debug\\\",\\r\\n help=\\\"enable debug output\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n parser.add_argument(\\\"-N\\\", \\\"--dry-run\\\",\\r\\n help=\\\"Do not perform any actions, only simulate them.\\\",\\r\\n action=\\\"store_true\\\")\\r\\n\\r\\n args = parser.parse_args()\\r\\n\\r\\n # set debug log state\\r\\n DebugLog.enabled = args.debug\\r\\n\\r\\n with DebugLogScopedPush(\\\"cli arguments:\\\"):\\r\\n DebugLog.print(str(args))\\r\\n\\r\\n return args\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n help_str = \\\\\\n 'The collection folder to sort files into. ' \\\\\\n 'If the folder does not exist, it will be created along with the ' \\\\\\n 'necessary contents.'\\n parser.add_argument('-c', '--collection', help=help_str)\\n\\n help_str = \\\\\\n 'The source folder to import files from. Has to exist and ' \\\\\\n 'has to be a folder.'\\n parser.add_argument('-s', '--source', help=help_str, required=False)\\n\\n help_str = \\\\\\n 'View the gallery in random order auto skpping after the' \\\\\\n 'given amount of seconds'\\n parser.add_argument('-v', '--view', help=help_str, required=False)\\n\\n return parser.parse_args()\",\n \"def parse_command_line() -> argparse.Namespace:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'pet_database',\\n type=str,\\n help='path to pet database'\\n )\\n parser.add_argument(\\n '--image_dir',\\n default='data/images'\\n )\\n parser.add_argument(\\n '--log',\\n default=None,\\n help='log file path'\\n )\\n\\n args = parser.parse_args()\\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\\n return args\",\n \"def __parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-f', '--force', action=\\\"store_true\\\", default=False,\\n help='overwrite existing database files during import')\\n parser.add_argument('-e', '--extension', action=\\\"store\\\", default='txt',\\n help='specify file extension. default is \\\"txt\\\"')\\n parser.add_argument('-d', '--delimiter', action=\\\"store\\\", default='\\\\t',\\n help='specify column delimiter. default is tab (\\\\\\\\t)')\\n parser.add_argument('-m', '--mark', action=\\\"store\\\", default='.',\\n help='specify decimal mark for numeric data. default is'\\n ' dot (.)')\\n parser.add_argument('-o', '--outformat', action=\\\"store\\\", default='npz',\\n help='specify output database format. default is \\\"npz\\\"'\\n ' for numpy database. use \\\"mat\\\" for matlab '\\n ' database format.')\\n parser.add_argument('-r', '--recursive', action=\\\"store_true\\\", default=False,\\n help='recursively walk through all sub-directories of'\\n ' current working directory')\\n parser.add_argument('-p', '--pcs', action=\\\"store_true\\\", default=True,\\n help='indicate if files are pcs files.')\\n parser.add_argument('-c', '--colheadlines', action=\\\"store\\\", default='1',\\n help='number of lines spanned by the column headers')\\n args = parser.parse_args()\\n return args\",\n \"def parse_command_line():\\r\\n\\r\\n parser = argparse.ArgumentParser(description='User args')\\r\\n parser.add_argument(\\\"--action\\\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\\\"Choose action.\\\")\\r\\n parser.add_argument(\\\"--model\\\", choices=['vgg', 'unet', 'fpn'], required=True, help=\\\"Choose model.\\\")\\r\\n parser.add_argument(\\\"--dataset\\\", choices=['full', 'small'], required=True, help=\\\"Choose dataset.\\\")\\r\\n\\r\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Google reminders cli',\\n epilog=usage,\\n formatter_class=argparse.RawTextHelpFormatter)\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input_path\\\", required=True)\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\", required=True)\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # Optional Argument\\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\\n return parser.parse_args()\",\n \"def _parse_cmd_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\\"--root\\\", required=True,\\n help=\\\"Root directory of data and logs.\\\")\\n parser.add_argument(\\\"--log_dir\\\", default=\\\"logs\\\",\\n help=\\\"Sub-directory of tensorboard logs.\\\")\\n parser.add_argument(\\\"--gpu\\\", default=\\\"0\\\", help=\\\"GPU device ID.\\\")\\n\\n args = parser.parse_args()\\n\\n return args\",\n \"def parse_cli_args(self):\\n parser = argparse.ArgumentParser(description='Produce an Ansible Inventory file based on Linode')\\n parser.add_argument('--list', action='store_true', default=True,\\n help='List nodes (default: True)')\\n parser.add_argument('--host', action='store',\\n help='Get all the variables about a specific node')\\n parser.add_argument('--refresh-cache', action='store_true', default=False,\\n help='Force refresh of cache by making API requests to Linode (default: False - use cache files)')\\n self.args = parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--debug\\\",\\n help=\\\"Print lots of debugging statements\\\",\\n action=\\\"store_const\\\",\\n dest=\\\"loglevel\\\",\\n const=logging.DEBUG,\\n default=logging.ERROR,\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n help=\\\"Be verbose\\\",\\n action=\\\"store_const\\\",\\n dest=\\\"loglevel\\\",\\n const=logging.INFO,\\n )\\n parser.add_argument(\\\"runscript\\\", default=None)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n # If user doesn't specify an input file, read from standard input. Since\\n # encodings are the worst thing, we're explicitly expecting std\\n parser.add_argument('-i', '--infile',\\n type=lambda x: open(x, encoding=ENCODE_IN),\\n default=io.TextIOWrapper(\\n sys.stdin.buffer, encoding=ENCODE_IN)\\n )\\n # Same thing goes with the output file.\\n parser.add_argument('-o', '--outfile',\\n type=lambda x: open(x, 'w', encoding=ENCODE_OUT),\\n default=io.TextIOWrapper(\\n sys.stdout.buffer, encoding=ENCODE_OUT)\\n )\\n # Set the verbosity level for the logger. The `-v` option will set it to\\n # the debug level, while the `-q` will set it to the warning level.\\n # Otherwise use the info level.\\n verbosity = parser.add_mutually_exclusive_group()\\n verbosity.add_argument('-v', '--verbose', action='store_const',\\n const=logging.DEBUG, default=logging.INFO)\\n verbosity.add_argument('-q', '--quiet', dest='verbose',\\n action='store_const', const=logging.WARNING)\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\\n return parser.parse_args()\",\n \"def _ParseCommandArguments():\\n arg_parser = argparse.ArgumentParser()\\n arg_parser.usage = __doc__\\n\\n arg_parser.add_argument('--download-dir',\\n type=str,\\n required=True,\\n help='Directory into which corpora are downloaded.')\\n arg_parser.add_argument('--build-dir',\\n required=True,\\n type=str,\\n help='Directory where fuzzers were built.')\\n args = arg_parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=_program_description)\\n parser.add_argument('input_file', help=_input_file_description)\\n #parser.add_argument('-v', '--verbose', action='store_true', \\n # default=False, help='show progress')\\n args = parser.parse_args()\\n return args\",\n \"def parse_cmd_arguments():\\n parser = argparse.ArgumentParser(description='Process some integers.')\\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\\n parser.add_argument('-o', '--output', required=True,\\n help='ouput JSON file')\\n parser.add_argument('-d', '--debug', required=False,\\n help='log level. Can be 0-3. Defaults to 0')\\n\\n return parser.parse_args()\",\n \"def arg_parse():\\n p = ap.ArgumentParser()\\n p.add_argument()\\n return p.parse_args()\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='Run DAFI.')\\n parser.add_argument('input_file', help='Name (path) of input file')\\n return parser.parse_args()\",\n \"def parse_args(self, argv=None):\\n self.opts, self.args = self.cli_parser.parse_args(argv)\\n self.check_arguments()\\n self._post_process_opts_and_args()\\n return self.opts, self.args\",\n \"def _cli_parser():\\n parser = argparse.ArgumentParser()\\n # Original flags\\n parser.add_argument('-s', type=str, metavar='input_vol',\\n help=\\\"Absolute path to input volume. Input should be \\\"\\n \\\"in nifti format\\\")\\n parser.add_argument('-o', type=str, metavar='output_dir',\\n help=\\\"Absolute path to output directory\\\")\\n parser.add_argument('-p', type=str, metavar='template_type', default='MNI152_orig',\\n help=\\\"Type of volumetric template used in index files. \\\"\\n \\\"Use MNI152_orig or Colin27_orig when -r is \\\"\\n \\\"RF_ANTs. Use MNI152_norm or Colin27_norm when \\\"\\n \\\"-r is RF_M3Z. Otherwise, an exception is raised. \\\"\\n \\\"Ensure that the template matches the standard \\\"\\n \\\"space of -i (i.e., use MNI152_* if -i is \\\"\\n \\\"in MNI152-space). Default: MNI152_orig\\\")\\n parser.add_argument('-r', type=str, metavar='RF_type', default='RF_ANTs',\\n help=\\\"Type of Registration Fusion approaches used to \\\"\\n \\\"generate the mappings (RF_M3Z or RF_ANTs). \\\" \\n \\\"RF_M3Z is recommended if data was registered \\\" \\n \\\"from subject's space to the volumetric atlas \\\" \\n \\\"space using FreeSurfer. RF_ANTs is recommended \\\" \\n \\\"if such registrations were carried out using \\\" \\n \\\"other tools, especially ANTs. Default: RF_ANTs\\\")\\n parser.add_argument('-i', type=str, metavar='interp', default='linear',\\n help=\\\"Interpolation (linear or nearest). If \\\"\\n \\\"-g is label.gii, then interpolation is always set \\\"\\n \\\"to nearest and a warning is raised. Default: \\\"\\n \\\"linear\\\")\\n # New flags\\n parser.add_argument('-t', type=str, metavar='out_type', default='nii.gz',\\n help=\\\"File type of surface files. nii.gz is true to \\\"\\n \\\"the original Wu et al (2018) implementation. \\\"\\n \\\"Note that gifti formats, either \\\"\\n \\\"func.gii or label.gii, are often preferred. \\\"\\n \\\"Default: nii.gz\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n fromfile_prefix_chars='@',\\n description='Convert CVAT XML annotations to masks'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--background-color', metavar='COLOR_BGR', default=\\\"0,0,0\\\",\\n help='specify background color (by default: 0,0,0)'\\n )\\n\\n parser.add_argument(\\n '--label-color', metavar='LABEL:COLOR_BGR', action='append',\\n default=[],\\n help=\\\"specify a label's color (e.g. 255 or 255,0,0). The color will \\\" +\\n \\\"be interpreted in accordance with the mask format.\\\"\\n )\\n\\n parser.add_argument(\\n '--mask-bitness', type=int, choices=[8, 24], default=8,\\n help='choose bitness for masks'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output masks'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n return parser.parse_args()\",\n \"def parse_cli_args():\\n\\n parser = argparse.ArgumentParser(\\n description='Create AMICI model and data for steadystate example.')\\n\\n parser.add_argument('-s', '--sbml', dest='sbml_file_name',\\n required=True,\\n help='SBML model filename (PEtab format)')\\n\\n parser.add_argument('-d', '--model-dir', dest='model_dir',\\n help='Model directory containing the python module')\\n\\n parser.add_argument('-n', '--model-name', dest='model_name',\\n required=True,\\n help='Name of the AMICI model module')\\n\\n parser.add_argument('-m', '--measurements', dest='measurement_file_name',\\n required=True,\\n help='Name of measurement table (PEtab format)')\\n\\n parser.add_argument('-c', '--conditions', dest='condition_file_name',\\n required=True,\\n help='Condition table (PEtab format)')\\n\\n parser.add_argument('-p', '--parameters', dest='parameter_file_name',\\n required=True,\\n help='Condition table (PEtab format)')\\n\\n parser.add_argument('-o', dest='hdf5_file_name', default='data.h5',\\n help='Name of HDF5 file to generate')\\n\\n args = parser.parse_args()\\n\\n return args\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\")\\n #parser.add_argument(\\\"args\\\", metavar=\\\"N\\\", type=str, nargs=\\\"*\\\", help=\\\"Positional arguments.\\\")\\n #parser.add_argument(\\\"\\\", dest=\\\"\\\", type=\\\"\\\", default=, help=)\\n #parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version=\\\"<the version>\\\")\\n\\n return parser.parse_args()\",\n \"def parse_cmd_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-m', '--path_model', type=str, help='Path to trained model.')\\n parser.add_argument('-t', '--type', type=str, help='Either \\\"torch\\\" or \\\"sklearn\\\".')\\n # parser.add_argument('-l', '--location', type=str, help='Either \\\"local\\\", \\\"midgard\\\" or \\\"rattle\\\"')\\n parser.add_argument('-i', '--path_in', type=str, help='Path to input file.')\\n parser.add_argument('-o', '--path_out', type=str, help='Path to output file.')\\n parser.add_argument('-c', '--path_config', type=str, help='Path to config file.')\\n parser.add_argument('-g', '--gpu', type=int, default=0, help='Number of the gpu to be used.')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"in_fq\\\", help=\\\"The fastq file containing Hi-C reads.\\\")\\n parser.add_argument(\\n \\\"-r\\\",\\n \\\"--reference\\\",\\n required=True,\\n help=\\\"Path to the reference genome, in FASTA format.\\\",\\n )\\n parser.add_argument(\\n \\\"-p\\\",\\n \\\"--nb_processors\\\",\\n default=1,\\n type=int,\\n help=\\\"number of CPUs used for alignment.\\\",\\n )\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--out_sam\\\",\\n help=\\\"Path to the output SAM file for the alignment of in_fq.\\\",\\n )\\n parser.add_argument(\\n \\\"-T\\\",\\n \\\"--tempdir\\\",\\n default=\\\".\\\",\\n help=\\\"Directory to write temporary files. Defaults to current directory.\\\",\\n )\\n parser.add_argument(\\n \\\"-m\\\",\\n \\\"--minimap2\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"Use minimap2 instead of bowtie for the alignment.\\\",\\n )\\n parser.add_argument(\\n \\\"-l\\\",\\n \\\"--min_len\\\",\\n type=int,\\n default=20,\\n help=\\\"Minimum length to which reads should be truncated.\\\",\\n )\\n return parser.parse_args()\",\n \"def parseargs() -> argparse.ArgumentParser:\\n\\n parser = worker.parseargs(\\\"ACT hybrid-analysis.com Client\\\")\\n\\n parser.add_argument(\\n \\\"--feed\\\", action=\\\"store_true\\\", help=\\\"Download the public feed only, no lookup\\\"\\n )\\n\\n parser.add_argument(\\n \\\"--apikey\\\", default=\\\"\\\", help=\\\"community apikey for hybrid-analysis.com\\\"\\n )\\n\\n parser.add_argument(\\n \\\"--user-agent\\\", default=\\\"Falcon Sandbox\\\", help=\\\"User agent while talking to API\\\"\\n )\\n\\n parser.add_argument(\\n \\\"--no-check-certificate\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Do not check SSL certificate\\\",\\n )\\n\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Convert CVAT XML annotations to PASCAL VOC format'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--image-dir', metavar='DIRECTORY', required=True,\\n help='directory which contains original images'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output annotations in PASCAL VOC format'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n formatter_class=RawDescriptionHelpFormatter,\\n description=\\\"This tool compares Master lab data with new data CSV files\\\",\\n epilog=\\\"E.g.: ./cdc.py Master/Master.csv TestCaptures/data1.csv \\\"\\n \\\"TestCaptures/data2.csv TestCaptures/data3.csv TestCaptures/data4.csv\\\",\\n )\\n parser.add_argument(\\n \\\"master\\\", help=\\\"A Master CLIA CDC CSV file to process\\\",\\n )\\n parser.add_argument(\\n \\\"new_files\\\",\\n type=argparse.FileType(\\\"r\\\"),\\n nargs=\\\"+\\\",\\n help=\\\"A number of new CLIA CSV files to compare with Master\\\",\\n )\\n parser.add_argument(\\n \\\"-e\\\", \\\"--extra\\\", action=\\\"store_true\\\", help=\\\"Display some extra data\\\",\\n )\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--force\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Bypass safety rails - very dangerous\\\",\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"turn on verbose messages, commands and outputs\\\",\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"auth\\\",\\n help=\\\"authentication string for Infermedica API: \\\"\\n \\\"APP_ID:APP_KEY or path to file containing it.\\\")\\n parser.add_argument(\\\"--model\\\",\\n help=\\\"use non-standard Infermedica model/language, \\\"\\n \\\"e.g. infermedica-es\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"CUDAPOA Python API sample program.\\\")\\n parser.add_argument('-m',\\n help=\\\"Run MSA generation. By default consensusis generated.\\\",\\n action='store_true')\\n parser.add_argument('-p',\\n help=\\\"Print output MSA or consensus for each POA group.\\\",\\n action='store_true')\\n parser.add_argument('-l',\\n help=\\\"Use long or short read sample data.\\\",\\n action='store_true')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Convert CVAT XML annotations to YOLO format'\\n )\\n\\n parser.add_argument(\\n '--cvat-xml', metavar='FILE', required=True,\\n help='input file with CVAT annotation in xml format'\\n )\\n\\n parser.add_argument(\\n '--image-dir', metavar='DIRECTORY', required=False,\\n help='directory which contains original images'\\n )\\n\\n parser.add_argument(\\n '--output-dir', metavar='DIRECTORY', required=True,\\n help='directory for output annotations in YOLO format'\\n )\\n\\n parser.add_argument(\\n '--username', metavar='USERNAME', required=False,\\n help='Username from CVAT Login page, required to download images'\\n )\\n\\n parser.add_argument(\\n '--password', metavar='PASSWORD', required=False,\\n help='Password from CVAT Login page, required to download images'\\n )\\n\\n parser.add_argument(\\n '--labels', metavar='ILABELS', required=False,\\n help='Labels (separated by comma) to extract. Example: car,truck,motorcycle'\\n )\\n\\n return parser.parse_args()\",\n \"def _parse_args():\\n args = sys.argv[1:]\\n cmd_parser = argparse.ArgumentParser()\\n cmd_parser.add_argument(\\n '--produce-sub',\\n dest='produce_sub',\\n help='Produce submision file',\\n default=False,\\n action='store_true',\\n )\\n cmd_parser.add_argument(\\n '--search-cv',\\n dest='search_cv',\\n help='Perform Search of parameters',\\n default=False,\\n action='store_true',\\n )\\n cmd_opts = cmd_parser.parse_args(args=args)\\n return cmd_opts\",\n \"def parse_command_args():\\n parser = argparse.ArgumentParser(prog='iota.intercept')\\n parser.add_argument('path', type=str, nargs = '?', default = None,\\n help = 'Path to data file')\\n parser.add_argument('--backend', type=str, default='dials',\\n help='Backend for processing')\\n parser.add_argument('--paramfile', type=str, default=None,\\n help='Parameter file for processing')\\n parser.add_argument('--output', type=str, default=None,\\n help='Output filename')\\n parser.add_argument('--termfile', type=str, default='.stop',\\n help='Termination signal filename')\\n parser.add_argument('--index', type=int, default=1,\\n help='Numerical index of the image')\\n parser.add_argument('--nproc', type=int, default=None,\\n help='Number of processors')\\n parser.add_argument('--action', type=str, default='spotfind',\\n help='Code for how far to go; available codes: '\\n 'spotfind, index, integrate')\\n parser.add_argument('--verbose', action = 'store_true',\\n help='Print information to stdout')\\n\\n return parser\",\n \"def parse_cli():\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"\\n Get information about Red Hat OpenStack overcloud servers and roles.\\n All output is JSON for further processing.\\n \\\"\\\"\\\")\\n\\n parser.add_argument('-d', '--debug', action='store_true',\\n default=False,\\n help=\\\"Print additional information for status and diagnosis\\\")\\n selector_group = parser.add_mutually_exclusive_group()\\n selector_group.add_argument('-s', '--server',\\n help=\\\"Find the role of a specified server\\\")\\n selector_group.add_argument('-r', '--role',\\n help=\\\"Find the servers under a specified role\\\")\\n selector_group.add_argument('-R', '--list-roles', dest=\\\"list_roles\\\",\\n action='store_true', default=False,\\n help=\\\"list the roles defined for this cluster\\\")\\n selector_group.add_argument('-o', '--orphan-nodes', action=\\\"store_true\\\",\\n default=False,\\n help='list any undeployed or untagged nodes')\\n\\n env_group = parser.add_mutually_exclusive_group()\\n env_group.add_argument('-V', '--require-env', dest=\\\"require_env\\\", action='store_true', default=True)\\n env_group.add_argument('--no-require-env', dest=\\\"require_env\\\", action='store_false')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--length', required=True, type=int, help='Test length in seconds')\\n parser.add_argument('--txs-per-ledger', required=True, type=int, help='Transaction rate to submit (spam) in parallel for every ledger round')\\n parser.add_argument('--prioritizer-seeds-file', required=True, type=str, help='File path to prioritizer seeds file')\\n parser.add_argument('--spammer-seeds-file', required=True, type=str, help='File path to spammer seeds file')\\n parser.add_argument('--out', default='spam-results-{}.json'.format(str(int(time.time()))), type=str, help='Spam results JSON output')\\n parser.add_argument('--avg-block-time', type=int, default=5, help='Average block time. Controls the time delay between every spam round and the one just after that')\\n\\n parser.add_argument('--passphrase', type=str, help='Network passphrase')\\n parser.add_argument('--horizon', action='append',\\n help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('n_iter',\\n help='number of iteration',\\n type=int)\\n parser.add_argument('n_processes',\\n help='number of processes',\\n type=int)\\n parser.add_argument('method',\\n help='mutual exclusion method')\\n parser.add_argument('duration',\\n help='Duration of each process',\\n type=float)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\")\\n parser.add_argument(\\n \\\"config_path\\\",\\n type=str,\\n help=\\\"Path to the JSON configuration file containing the image transformation settings.\\\",\\n )\\n parser.add_argument(\\n \\\"img_path\\\",\\n type=str,\\n help=\\\"Path to the input image file to apply transformations.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse_cli_args():\\n\\n parser = argparse.ArgumentParser(\\n description='Create AMICI model PEtab files for steadystate example.')\\n\\n parser.add_argument('-o', '--model-output-dir', dest='model_output_dir',\\n default='model_steadystate_scaled',\\n help='Name of the AMICI model directory to be created')\\n\\n parser.add_argument('-f', dest='hdf5_file_name',\\n default='example_data.h5',\\n help='Name of HDF5 file to generate')\\n\\n parser.add_argument('-p', dest='petab_dir',\\n default='steadystate_petab',\\n help='Directory to write PEtab files to')\\n\\n args = parser.parse_args()\\n\\n return args\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(description='Parses ID\\\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\\n parser.add_argument('-f', '--file', dest='file',\\n action='store',\\n help='Filenname to be read')\\n arg_manager = parser.parse_args()\\n return arg_manager\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--input-model\\\", help=\\\"Path to read input model from\\\")\\n options = parser.parse_args()\\n return options\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # All reference encoders\\n parser.add_argument(\\\"--step\\\", dest=\\\"step\\\", default=\\\"10\\\", type=int, help=\\\"step size\\\")\\n parser.add_argument(\\\"--repeats\\\", dest=\\\"repeats\\\", type=int, default=1, help=\\\"repeats\\\")\\n\\n parser.add_argument(dest=\\\"image\\\", default=None,\\n help=\\\"select the test image to run\\\")\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='Disk metric sender')\\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\\n\\n return parser.parse_args()\",\n \"def _parse_args(argv):\\n parser = make_parser()\\n args = parser.parse_args(argv)\\n LOGGER.setLevel(to_log_level(args.loglevel))\\n\\n if not args.inputs:\\n if args.list:\\n tlist = \\\", \\\".join(API.list_types())\\n _exit_with_output(\\\"Supported config types: \\\" + tlist)\\n elif args.env:\\n cnf = os.environ.copy()\\n _output_result(cnf, args.output, args.otype or \\\"json\\\", None, None)\\n sys.exit(0)\\n else:\\n parser.print_usage()\\n sys.exit(1)\\n\\n if args.validate and args.schema is None:\\n _exit_with_output(\\\"--validate option requires --scheme option\\\", 1)\\n\\n return args\",\n \"def arg_parse():\\n parser = argparse.ArgumentParser()\\n # defines command line arguments\\n parser.add_argument('-i', '--input_file', help=\\\"The input .txt file \\\" +\\n \\\"within the current directory (the file you \\\" +\\n \\\"downloaded from VEP\\\")\\n parser.add_argument('-o', '--output_file', help=\\\"Name for the output \\\" +\\n \\\".txt file\\\")\\n\\n return parser.parse_args()\",\n \"def _parse_cli_opts(self, args):\\n self._args = args\\n for opt, group in self._all_cli_opts():\\n opt._add_to_cli(self._oparser, group)\\n\\n return self._parse_config_files()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(prog='scoring')\\n parser.add_argument(\\\"pdb_list\\\", help=\\\"list of PDB structures\\\")\\n script_args = parser.parse_args()\\n return script_args\",\n \"def parse_command_line():\\n parser = ArgumentParser(description=__doc__,\\n formatter_class=RawTextHelpFormatter,\\n epilog=\\\"For a list of table formats check this page: \\\"\\n \\\"https://github.com/astanin/python-tabulate#table-format\\\"\\n )\\n requir = parser.add_argument_group(\\\"required arguments\\\")\\n requir.add_argument(\\\"-f\\\", \\\"--find\\\",\\n required=True,\\n help=\\\"Search string to identify\\\"\\n )\\n requir.add_argument(\\\"-k\\\", \\\"--client_id\\\",\\n required=True,\\n help=\\\"CrowdStrike API client ID\\\"\\n )\\n requir.add_argument(\\\"-s\\\", \\\"--client_secret\\\",\\n required=True,\\n help=\\\"CrowdStrike API client secret\\\"\\n )\\n parser.add_argument(\\\"-r\\\", \\\"--reverse\\\",\\n help=\\\"Reverse the sort.\\\",\\n default=False,\\n action=\\\"store_true\\\"\\n )\\n parser.add_argument(\\\"-t\\\", \\\"--types\\\",\\n help=\\\"Types to search (indicator, report or actor). Comma delimited.\\\"\\n )\\n parser.add_argument(\\\"-tf\\\", \\\"--table_format\\\",\\n help=\\\"Set the table format.\\\",\\n default=\\\"fancy_grid\\\"\\n )\\n parser.add_argument(\\\"-o\\\", \\\"--output_prefix\\\",\\n help=\\\"Output filename prefix for storing results (CSV format).\\\",\\n default=None\\n )\\n\\n parsed = parser.parse_args()\\n allow = [\\\"indicator\\\", \\\"report\\\", \\\"actor\\\"]\\n parsed.types = [t for t in parsed.types.split(\\\",\\\") if t in allow] if parsed.types else allow\\n\\n return parsed\",\n \"def process_command_line_arguments() -> Namespace:\\n\\n parser = build_parser()\\n arguments = parser.parse_args()\\n\\n return arguments\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=\\\"This is a script for auto apply ipex optimization.\\\"\\n \\\"\\\\n################################# Basic usage ############################# \\\\n\\\"\\n \\\"\\\\n 1. Apply ipex optimization with fp32 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\\\n\\\"\\n \\\"\\\\n 2. Apply ipex optimization with bf16 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\\\n\\\",\\n formatter_class=RawTextHelpFormatter,\\n )\\n\\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\\n\\n # positional\\n parser.add_argument(\\n \\\"program\\\",\\n type=str,\\n help=\\\"The full path to the proram/script to be launched. \\\"\\n \\\"followed by all the arguments for the script\\\",\\n )\\n # rest from the training program\\n parser.add_argument(\\\"program_args\\\", nargs=REMAINDER)\\n return parser.parse_args()\",\n \"def parse_args() -> argparse.ArgumentParser:\\n parser = argparse.ArgumentParser(description=__doc__)\\n\\n # Enable command line arguments\\n parser.add_argument('--process',\\n action='store_true',\\n help='Run data processing')\\n parser.add_argument('--classify',\\n action='store_true',\\n help='Run classification')\\n parser.add_argument('--lcs_file',\\n type=str,\\n help='Path to lcs file')\\n parser.add_argument('--datasets_file',\\n type=str,\\n help='Path to datasets file')\\n parser.add_argument('--mode',\\n type=str,\\n help=('Type of data to classify. r=realtime, f=full, r'\\n 'fp=realtime+force_photo, ffp=full+force_photo'))\\n parser.add_argument('--results_outfile',\\n type=str,\\n help='Filename to store results',\\n default='KNC-Live_Results.csv')\\n parser.add_argument('--results_dir',\\n type=str,\\n help='Directory to save results',\\n default='knc_results/')\\n parser.add_argument('--rfc_dir',\\n type=str,\\n help='Path to directory containing classifiers',\\n default='classifiers/')\\n parser.add_argument('--id_map_file',\\n type=str,\\n help='Name of ID map file in classifier directory',\\n default='id_map.npy')\\n parser.add_argument('--verbose',\\n action='store_true',\\n help='Print status updates')\\n parser.add_argument('--skip_cv',\\n action='store_true',\\n help='Skip hyperparam optimization')\\n parser.add_argument('--distribute',\\n action='store_true',\\n help='Use multiprocessing')\\n\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Hyper parameter\\\")\\n parser.add_argument(\\n \\\"--model\\\", help=\\\"Model to use\\\", default=\\\"DenseNet169\\\", type=str)\\n parser.add_argument(\\n \\\"--optimizer\\\", help=\\\"which optimizer to use\\\", default=\\\"Adam\\\", type=str)\\n parser.add_argument(\\n \\\"--lr\\\", help=\\\"learning rate\\\", default=2e-5, type=float)\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n \\n parser.add_argument('--p', dest='path_in',\\n action='store', type=str, required=True, default='',\\n help=\\\"Path relative to the data/ directory, to the input ATL01, ANC13, and ANC27 files.\\\")\\n parser.add_argument('--atl01', dest='atl01_file',\\n action='store', type=str, required=False, default=None,\\n help=\\\"Path + filename to directory of the ATL01.\\\")\\n parser.add_argument('--anc13', dest='anc13_path',\\n action='store', type=str, required=False, default=None,\\n help=\\\"Path to outputs directory of the ANC13.\\\") \\n parser.add_argument('--anc27', dest='anc27_path',\\n action='store', type=str, required=False, default=None,\\n help=\\\"Path to directory of the ANC27.\\\")\\n\\n args = parser.parse_args()\\n \\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--start\\\",\\n type=str,\\n default=\\\"\\\",\\n required=False,\\n help=\\\"The start square of the agent, in the form row,col. If not specified, this is randomized\\\"\\n )\\n parser.add_argument(\\n \\\"--actions\\\",\\n type=str,\\n required=True,\\n nargs = '+',\\n help=\\\"The actions the agent takes, comma delimited\\\"\\n )\\n parser.add_argument(\\n \\\"--observations\\\",\\n type=str,\\n required=True,\\n nargs = '+',\\n help=\\\"The observations the agent makes, comma delimited\\\"\\n )\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--version',\\n metavar=\\\"<str>\\\",\\n help=\\\"Input data version number\\\",\\n type=str,\\n required=True\\n )\\n args = parser.parse_args()\\n return args\",\n \"def parse_args(*opts_args):\\n parser = argparse.ArgumentParser()\\n cmd = Command()\\n parser = cmd.create_parser(\\\"import_measures\\\", \\\"\\\")\\n options = parser.parse_args(opts_args)\\n return cmd.parse_options(options.__dict__)\",\n \"def cmdline_parser():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\" \\\"\\\"\\\")\\n parser.add_argument(\\\"-i1\\\",\\n help=\\\"\\\"\\\"viral alignments\\\"\\\"\\\",\\n dest=\\\"viral\\\",\\n required=True)\\n parser.add_argument(\\\"-i2\\\",\\n help=\\\"\\\"\\\"GTA alignments\\\"\\\"\\\",\\n dest=\\\"gta\\\",\\n required=True)\\n parser.add_argument(\\\"-o\\\",\\n dest=\\\"output\\\",\\n help=\\\"output image file\\\")\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-e', '--env', default='production',\\n help='Environment to check: integration, staging, production.')\\n parser.add_argument('-l', '--log_type', default='govuk_assets',\\n help='Which logs to check: govuk_assets, govuk_www.')\\n parser.add_argument('-c', '--critical_age_minutes', type=int, default=60,\\n help='If the newest logs are older than this many minutes, '\\n 'return CRITICAL status.')\\n parser.add_argument('-F', '--fake_time', type=fromisoformat,\\n help='For testing purposes, use the given time as if it\\\\'s the current '\\n 'time. Requires the format YYYY-MM-DDTHH:MM. Assumes UTC.')\\n parser.add_argument('-v', '--verbose', action='count',\\n help='Show DEBUG log messages.')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--zarr_dir',\\n type=str,\\n help='path to directory of zarr files',\\n )\\n parser.add_argument(\\n '--tiff_dir',\\n type=str,\\n help='path to directory of tiff files',\\n )\\n parser.add_argument(\\n '--output_dir',\\n type=str,\\n help='path to directory for writing',\\n )\\n parser.add_argument(\\n '--config_path',\\n type=str,\\n default=None,\\n help='path to yaml preprocess config file',\\n )\\n \\n args = parser.parse_args()\\n return args\",\n \"def cmdline_parser():\\n\\n # http://docs.python.org/dev/howto/argparse.html\\n parser = argparse.ArgumentParser(description=__doc__)\\n \\n parser.add_argument(\\\"--verbose\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Be verbose\\\")\\n parser.add_argument(\\\"--debug\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Enable debugging\\\")\\n parser.add_argument(\\\"-b\\\", \\\"--bam\\\",\\n required=True,\\n help=\\\"Input BAM file matching vcf\\\")\\n parser.add_argument(\\\"-i\\\", \\\"--vcf\\\",\\n help=\\\"Input VCF file containing variants to analyze\\\"\\n \\\" (clashes with --var)\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--var\\\",\\n help=\\\"Report reads for this variant only. Format: chr:pos:ref-alt\\\"\\n \\\" (clashes with --vcf)\\\")\\n default = 0\\n parser.add_argument(\\\"--mq-filter\\\",\\n dest=\\\"min_mq\\\",\\n type=int,\\n default=default,\\n help=\\\"Ignore reads with mapping quality below this value (default=%d)\\\" % default)\\n default = 5\\n parser.add_argument(\\\"--bq-filter\\\",\\n dest=\\\"min_bq\\\",\\n type=int,\\n default=default,\\n help=\\\"Ignore reads with bases below this value (default=%d)\\\" % default)\\n parser.add_argument(\\\"-a\\\", \\\"--use-orphan\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Don't ignore orphan-reads / anomalous read-pairs\\\")\\n\\n return parser\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\\n parser.add_argument('-r', '--resources_dir', type=unicode)\\n parser.add_argument('-t', '--total_docs', type=int)\\n parser.add_argument('-m', '--mapping', type=unicode,\\n help='File with the yago to lkif mapping')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n global Args\\n parser = argparse.ArgumentParser()\\n subparsers = parser.add_subparsers()\\n pars_simulation(subparsers)\\n pars_analyze(subparsers)\\n Args = parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument('--source-account', required=True, type=str, help='Source account to pay transaction fees')\\n parser.add_argument('--channel-seeds-file', required=True, type=str, help='File path to channel seeds file')\\n parser.add_argument('--accounts', required=True, type=int, help='Amount of accounts to create')\\n parser.add_argument('--passphrase', required=True, type=str, help='Network passphrase')\\n parser.add_argument('--horizon', action='append', help='Horizon endpoint URL (use multiple --horizon flags for multiple addresses)')\\n parser.add_argument('--json-output', required=False, type=bool, help='Export output to json format')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Re-ID feature extractor\\\")\\n parser.add_argument(\\n \\\"--model\\\",\\n default=\\\"resources/networks/mars-small128.ckpt-68577\\\",\\n help=\\\"Path to checkpoint file\\\")\\n parser.add_argument(\\n \\\"--loss_mode\\\", default=\\\"cosine\\\", help=\\\"Network loss training mode\\\")\\n parser.add_argument(\\n \\\"--mot_dir\\\", help=\\\"Path to MOTChallenge directory (train or test)\\\",\\n required=True)\\n parser.add_argument(\\n \\\"--detection_dir\\\", help=\\\"Path to custom detections. Defaults to \\\"\\n \\\"standard MOT detections Directory structure should be the default \\\"\\n \\\"MOTChallenge structure: [sequence]/det/det.txt\\\", default=None)\\n parser.add_argument(\\n \\\"--output_dir\\\", help=\\\"Output directory. Will be created if it does not\\\"\\n \\\" exist.\\\", default=\\\"detections\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\\"BaselineMembershipInferenceAttack\\\")\\n parser.add_argument(\\\"--batch_size\\\",\\n type=int, default=128,\\n help=\\\"The batch size of normal training.\\\")\\n parser.add_argument(\\\"--train_epoch\\\",\\n type=int, default=10,\\n help=\\\"The epoch of training.\\\")\\n parser.add_argument(\\\"--train_lr\\\",\\n type=float, default=0.0002,\\n help=\\\"The learning rate of training.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='baseline Mask R-CNN')\\n parser.add_argument('--dataset', required=True,\\n metavar=\\\"/path/to/dataset/\\\",\\n help='Directory of the dataset')\\n parser.add_argument('--continue_train', type=str, required=False, default='None',\\n metavar=\\\"/path/to/latest/weights.h5\\\", help=\\\"Path to lastest training weights .h5 file\\\")\\n parser.add_argument('--weight', required=False,\\n metavar='/path/to/pretrained/weight.h5', help=\\\"Path to trained weight\\\")\\n parser.add_argument('--image', required=False,\\n metavar='/path/to/testing/image/directory', help=\\\"Path to testing image directory\\\")\\n parser.add_argument('--video', required=False,\\n metavar='/path/to/testing/image/directory', help=\\\"Path to testing image directory\\\")\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"SLOWFAST for AVA Dataset\\\")\\n parser.add_argument(\\\"--pipeline\\\", type=str,\\n default=\\\"../data/config/slowfast.pipeline\\\", help=\\\"SDK infer pipeline\\\")\\n parser.add_argument(\\\"--data_dir\\\", type=str, default=\\\"../data/input\\\",\\n help=\\\"Dataset contain frames and ava_annotations\\\")\\n args_opt = parser.parse_args()\\n return args_opt\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"auth\\\",\\n help=\\\"authentication string for Infermedica API: \\\"\\n \\\"APP_ID:APP_KEY or path to file containing it.\\\")\\n parser.add_argument(\\\"--model\\\",\\n help=\\\"use non-standard Infermedica model/language, \\\"\\n \\\"e.g. infermedica-es\\\")\\n # TODO: Check if `verbose` actually does anything.\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\",\\n dest=\\\"verbose\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"dump internal state\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=app_description,\\n formatter_class=argparse.RawTextHelpFormatter)\\n parser.add_argument(\\\"--input-json\\\", dest=\\\"input_json_path\\\", required=True,\\n help=input_json_help)\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--duration\\\",\\n type=mesos_maintenance.parse_timedelta,\\n default=\\\"1h\\\",\\n help=\\\"Duration of the maintenance window. Any pytimeparse unit is supported.\\\",\\n )\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--start\\\",\\n type=mesos_maintenance.parse_datetime,\\n default=str(mesos_maintenance.now()),\\n help=\\\"Time to start the maintenance window. Defaults to now.\\\",\\n )\\n parser.add_argument(\\n \\\"action\\\",\\n choices=[\\n \\\"cluster_status\\\",\\n \\\"down\\\",\\n \\\"drain\\\",\\n \\\"is_host_down\\\",\\n \\\"is_host_drained\\\",\\n \\\"is_host_draining\\\",\\n \\\"is_hosts_past_maintenance_end\\\",\\n \\\"is_hosts_past_maintenance_start\\\",\\n \\\"is_safe_to_drain\\\",\\n \\\"is_safe_to_kill\\\",\\n \\\"schedule\\\",\\n \\\"status\\\",\\n \\\"undrain\\\",\\n \\\"up\\\",\\n ],\\n help=\\\"Action to perform on the specified hosts\\\",\\n )\\n parser.add_argument(\\n \\\"hostname\\\",\\n nargs=\\\"*\\\",\\n default=[getfqdn()],\\n help=\\\"Hostname(s) of machine(s) to start draining. \\\"\\n \\\"You can specify <hostname>|<ip> to avoid querying DNS to determine the corresponding IP.\\\",\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n action=\\\"count\\\",\\n dest=\\\"verbose\\\",\\n default=0,\\n help=\\\"Print out more output.\\\",\\n )\\n return parser.parse_args()\",\n \"def __parse_cmd_args():\\n parser = argparse.ArgumentParser(description='Python Image Downloader.')\\n parser.add_argument(\\\"-f\\\", \\\"--file\\\",\\n help=\\\"Where the URL file is located.\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--dir\\\",\\n help=\\\"Where the downloaded files are to be stored.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\\n required=False, help='Specifies the base path for both logs and apk_downloads.')\\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\\n help='Specifies the path to a credential file in .toml format.')\\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\\n help='Specifies the maximum number of apks per category to download.')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Reads in iClicker data from the submission \\\"\\n \\\"directory, and then writes it to the given \\\"\\n \\\"remote file.\\\")\\n parser.add_argument(\\\"submission_directory\\\", type=str, help=\\\"Directory of submissions that \\\"\\n \\\"contain a 'textbox_0.txt' file that references iClicker ID\\\")\\n parser.add_argument(\\\"remote_id_file\\\", type=str)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Subscription Watch CSV file packaging script\\\", prog=sys.argv[0])\\n\\n # required args\\n parser.add_argument(\\\"-f\\\", \\\"--filepath\\\", required=True,\\n help=\\\"path to files to package\\\")\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--max-size\\\",\\n type=int,\\n default=DEFAULT_MAX_SIZE,\\n help=f\\\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\\\",\\n )\\n parser.add_argument(\\n \\\"-o\\\", \\\"--overwrite\\\", action=\\\"store_true\\\", default=False, help=\\\"whether to overwrite existing files.\\\"\\n )\\n parser.add_argument(\\\"--ocp-cluster-id\\\", required=True,\\n help=\\\"OCP Cluster ID\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--verbosity\\\", action=\\\"count\\\",\\n default=0, help=\\\"increase verbosity (up to -vvv)\\\")\\n return parser.parse_args()\",\n \"def parse_command_line(argv):\\n parser = argparse.ArgumentParser(description=__doc__)\\n parser.add_argument(\\n \\\"--logfile\\\",\\n default=None,\\n type=str,\\n help=\\\"If specified, write logs to this file.\\\",\\n )\\n parser.add_argument(\\n \\\"--loglevel\\\",\\n help=\\\"Set logging level (DEBUG, INFO, WARNING, ERROR, or CRITICAL).\\\",\\n default=\\\"INFO\\\",\\n )\\n return parser.parse_args(argv[1:])\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Run the destination IoT program (CTRL-C to exit)')\\n\\n parser.add_argument('-v',\\n '--verbose',\\n default=False,\\n action='store_true',\\n help='Print all debug logs')\\n\\n parser.add_argument('-p',\\n '--port',\\n metavar='<port number>',\\n default=7777,\\n type=int,\\n help='Default: 7777')\\n\\n parser.add_argument('-a',\\n '--address',\\n metavar='<email_address>',\\n nargs='*',\\n help='Email address(es) to receive notifications')\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args(args):\\n parser = argparse.ArgumentParser(\\n description=\\\"Lookup table generator for Image Comparison\\\")\\n parser.add_argument(\\n \\\"--version\\\",\\n action=\\\"version\\\",\\n version=\\\"lookuptable {ver}\\\".format(ver=__version__))\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--folder\\\",\\n dest=\\\"imagefolder\\\",\\n help=\\\"path to image folder\\\",\\n type=str,\\n metavar=\\\"STRING\\\")\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to INFO\\\",\\n action=\\\"store_const\\\",\\n const=logging.INFO)\\n parser.add_argument(\\n \\\"-vv\\\",\\n \\\"--very-verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to DEBUG\\\",\\n action=\\\"store_const\\\",\\n const=logging.DEBUG)\\n return parser.parse_args(args)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Deep SORT\\\")\\n parser.add_argument(\\n \\\"--input\\\", help=\\\"Path to MOTChallenge sequence directory\\\",\\n default=None, required=True)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Check the ERC 20 conformance\\\", usage=\\\"fortress-check-erc project contractName\\\",\\n )\\n\\n parser.add_argument(\\\"project\\\", help=\\\"The codebase to be tested.\\\")\\n\\n parser.add_argument(\\n \\\"contract_name\\\",\\n help=\\\"The name of the contract. Specify the first case contract that follow the standard. Derived contracts will be checked.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--erc\\\",\\n help=f\\\"ERC to be tested, available {','.join(ERCS.keys())} (default ERC20)\\\",\\n action=\\\"store\\\",\\n default=\\\"erc20\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--json\\\",\\n help='Export the results as a JSON file (\\\"--json -\\\" to export to stdout)',\\n action=\\\"store\\\",\\n default=False,\\n )\\n\\n # Add default arguments from crytic-compile\\n cryticparser.init(parser)\\n\\n return parser.parse_args()\",\n \"def parse_command_line_arguments(argv):\\n print(\\\"reading command line arguments in...\\\")\\n\\n parser = argparse.ArgumentParser(description='Description of your program')\\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\\n args = parser.parse_args()\\n\\n return args.input, args.predicting, args.scoring, args.scale\",\n \"def parse_args():\\n p = argparse.ArgumentParser(\\n description='Parse system logs, for fun or something')\\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\\n return p.parse_args()\",\n \"def parse_args(self, argv=None):\\n self.opts, self.args = self.cli_parser.parse_args(argv)\\n self._begin_logging()\\n if argv is None:\\n argv = sys.argv\\n logger.info(' '.join(argv))\\n self._process_input_files()\\n self._construct_links_of_interest()\\n self._open_output_files()\\n data = self._construct_data_struct()\\n return data\",\n \"def parse_arguments(args=sys.argv[1:]):\\n \\n parser = argparse.ArgumentParser()\\n \\n parser.add_argument('-i', '--input',\\n help=\\\"Path of input file to read. Default: {d}\\\".format(d=INPUT_FILE),\\n default=INPUT_FILE)\\n \\n return parser.parse_args(args)\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\\n metavar='<application_name>')\\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\\n metavar='<fetch_interval in seconds>')\\n return parser.parse_args()\",\n \"def parse_cmdline_args():\\n parser = argparse.ArgumentParser(description=\\\"Guesses the functional element for host.\\\")\\n ##\\n ## Internal options\\n ##\\n parser.add_argument(\\\"--json\\\", dest=\\\"json\\\", action='store_true', help=\\\"output in JSON\\\")\\n\\n ##\\n ## PuppetDB options\\n ##\\n pdbconf = PdbConfig()\\n pdbconf.add_standard_args(parser)\\n\\n parser.add_argument(\\\"host\\\", metavar=\\\"HOST\\\",\\n help=\\\"hostnames to query for FE\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Bandits algorithms on a click-through \\\"\\n \\\"rate dataset.\\\")\\n parser.add_argument('--plot', action='store_true')\\n return parser.parse_args()\",\n \"def parse_cli():\\n args = {}\\n arg_name = None\\n arg_values = None\\n parameters = {}\\n\\n cli_args = sys.argv\\n found_params = False\\n skip = True\\n iterator = enumerate(cli_args)\\n\\n for idx, arg in iterator:\\n if skip:\\n skip = False\\n continue\\n else:\\n skip = True\\n\\n if arg == \\\"--params\\\":\\n if arg_name:\\n args[arg_name] = \\\" \\\".join(arg_values)\\n found_params = True\\n skip = False\\n\\n elif arg[0:2] == \\\"--\\\" and not found_params:\\n if arg_name:\\n args[arg_name] = \\\" \\\".join(arg_values)\\n arg_name = arg[2:]\\n arg_values = []\\n skip = False\\n\\n elif arg[0:2] == \\\"--\\\" and found_params:\\n raise ValueError(\\\"You are trying to specify an argument after the \\\"\\n \\\"--params argument. Please change the order.\\\")\\n\\n elif arg[0] == \\\"-\\\" and arg[0:2] != \\\"--\\\" and found_params:\\n parameters[cli_args[idx][1:]] = cli_args[idx+1]\\n\\n elif arg[0] == \\\"-\\\" and arg[0:2] != \\\"--\\\" and not found_params:\\n raise ValueError(\\\"You either try to use arguments with only one lea\\\"\\n \\\"ding minus or try to specify a hyperparameter bef\\\"\\n \\\"ore the --params argument. %s\\\" %\\n \\\" \\\".join(cli_args))\\n elif arg[0:2] != \\\"--\\\" and not found_params:\\n arg_values.append(arg)\\n skip = False\\n\\n elif not found_params:\\n raise ValueError(\\\"Illegal command line string, expected an argument\\\"\\n \\\" starting with -- but found %s\\\" % (arg,))\\n\\n else:\\n raise ValueError(\\\"Illegal command line string, expected a hyperpara\\\"\\n \\\"meter starting with - but found %s\\\" % (arg,))\\n\\n return args, parameters\",\n \"def parse_command_line():\\n\\n desc = \\\"Perform fluid dynamics simulations.\\\"\\n parser = argparse.ArgumentParser(description=desc)\\n\\n # Parameter file\\n help_txt = \\\"name of the configuration file (default is 'config.ini.')\\\"\\n parser.add_argument(\\\"-f\\\", \\\"--file\\\", metavar=\\\"FILE\\\", default=\\\"config.ini\\\",\\n required=False, dest=\\\"config_file\\\", help=help_txt)\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\\"Run arguments for system submitted tasks\\\")\\n\\n parser.add_argument(\\\"-f\\\", \\\"--funcs\\\", type=str, nargs=\\\"?\\\", required=True,\\n help=\\\"path to pickle file containing a list of \\\"\\n \\\"functions/methods that should be run by the \\\"\\n \\\"submitted process\\\"\\n )\\n parser.add_argument(\\\"-k\\\", \\\"--kwargs\\\", type=str, nargs=\\\"?\\\", required=False,\\n default=None,\\n help=\\\"path to pickle file containing a dictionary of \\\"\\n \\\"keyword argumnets that should be passed to the \\\"\\n \\\"functions\\\")\\n parser.add_argument(\\\"-e\\\", \\\"--environment\\\", type=str, nargs=\\\"?\\\",\\n required=False,\\n help=\\\"Optional comma-separated environment variables, \\\"\\n \\\"which should be given as \\\"\\n \\\"VARNAME1=value1,VARNAME2=value2 and so on. These \\\"\\n \\\"will be separated and instantiated into Python's \\\"\\n \\\"os.environ\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\tparser = argparse.ArgumentParser(description='Show video statistics.')\\n\\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\\n\\t default='views',\\n\\t help='sort by the specified field. Options are views, likes and dislikes.')\\n\\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\\n\\tparser.add_argument('--csv', action='store_true', default=False,\\n\\t help='output the data in CSV format.')\\n\\tparser.add_argument('--table', action='store_true', default=False,\\n\\t help='output the data in an ascii table.')\\n\\tparser.add_argument('--workers', type=int, default=8,\\n\\t help='number of workers to use, 8 by default.')\\n\\treturn parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Sequence Cleaner: Remove Duplicate Sequences, etc\\\",\\n epilog=\\\"example > sequence_cleaner -q INPUT -o OUTPUT\\\")\\n parser.add_argument('-v', '--version', action='version', version='sequence_cleaner {}'.format(version))\\n parser.add_argument(\\\"-q\\\", \\\"--query\\\", help=\\\"Path to directory with FAST(A/Q) files\\\", required=True)\\n parser.add_argument(\\\"-o\\\", \\\"--output_directory\\\", help=\\\"Path to output files\\\", required=True)\\n parser.add_argument(\\\"-ml\\\", \\\"--minimum_length\\\", help=\\\"Minimum length allowed (default=0 - allows all the lengths)\\\",\\n default=\\\"0\\\")\\n parser.add_argument(\\\"-mn\\\", \\\"--percentage_n\\\", help=\\\"Percentage of N is allowed (default=100)\\\", default=\\\"100\\\")\\n parser.add_argument('--keep_all_duplicates', help='Keep All Duplicate Sequences', action='store_false', required=False)\\n parser.add_argument('--remove_ambiguous', help='Remove any sequence with ambiguous bases', action='store_true', required=False)\\n\\n parser.add_argument('-l', '--log', help='Path to log file (Default: STDOUT).', required=False)\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'config',\\n help='Config file')\\n parser.add_argument(\\n '--quiet',\\n '-q',\\n action='store_true',\\n help='do not print to console'\\n )\\n parser.add_argument(\\n '--password',\\n '-p',\\n action='store_true',\\n help='Set password in keyring.'\\n )\\n parser.add_argument(\\n '--update',\\n '-u',\\n action='store_true',\\n help='Only add transactions after last date in database.'\\n )\\n parser.add_argument(\\n '--mark_seen',\\n '-m',\\n action='store_true',\\n help='Mark fetched emails as seen.'\\n )\\n\\n return parser.parse_args()\",\n \"def command_line_parse(iargs=None):\\n\\n parser = create_parser()\\n inps = parser.parse_args(args=iargs)\\n\\n return inps\",\n \"def _parse_args(self):\\n parser = argparse.ArgumentParser()\\n _, args = parser.parse_known_args()\\n self.args = [a for a in args if a != '']\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n argparse.ArgumentParser(argument_default=False)\\n parser.add_argument('-r', type=str, required=True, metavar='[reference.fa]', help=\\\"Reference file in fasta format\\\")\\n parser.add_argument('-s', type=int, metavar='number of SNPs', help=\\\"Number of SNPs to introduce\\\")\\n parser.add_argument('-i', type=int, metavar='number of indels', help=\\\"Number of small indels to introduce. Indel sizes randomly sampled between 1-100bp with a ratio of 9:1 for size being < 11bp\\\")\\n parser.add_argument('-d', type=int, metavar='number of large deletions', help=\\\"Number of large deletions to introduce. Deletion size randomly sampled between 100-5000bp\\\")\\n parser.add_argument('-t', type=int, metavar='number of translocations', help=\\\"number of translocations, regions will be randomly selected ranging between 500-5000bp in size\\\")\\n parser.add_argument('-nc', type=bool, default=False, metavar='add at least one non-conserved translocation', help=\\\"True/False add one non-conserved translocation. Deletion occurs from end of the translocation. Default=False\\\")\\n parser.add_argument('-f', type=str, required=True, metavar='output fasta filename', help=\\\"Output fasta filename and file path\\\")\\n parser.add_argument('-v', type=str, required=True, metavar='output vcf file of mutations', help=\\\"Output vcf filename and file path\\\")\\n\\n return parser.parse_args()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80792505","0.8012675","0.78432906","0.78108615","0.7765357","0.7751876","0.77110696","0.76705295","0.7647746","0.7644992","0.7644233","0.76380914","0.75653404","0.7562569","0.75440955","0.7535946","0.75321084","0.75190026","0.75150883","0.7505613","0.7491292","0.7490559","0.748476","0.74844605","0.745384","0.7451498","0.74460983","0.74348456","0.74266624","0.7423198","0.7418547","0.74038947","0.7401476","0.73931134","0.73880523","0.7384215","0.73823494","0.7372509","0.73584163","0.73545295","0.73405594","0.73344547","0.7329731","0.73226017","0.73218924","0.7320626","0.7316476","0.73070085","0.73057014","0.7296637","0.7292377","0.7287461","0.7287459","0.7287178","0.7284422","0.7273681","0.7267626","0.7262759","0.7262249","0.7261698","0.7256247","0.7254192","0.72524196","0.7244782","0.72432053","0.72330594","0.72301143","0.722756","0.7222257","0.7215478","0.721014","0.7210101","0.7209053","0.7208629","0.7205561","0.7199625","0.71985763","0.71982235","0.71981925","0.7196416","0.7194187","0.71856034","0.71819746","0.71795917","0.7174014","0.7172088","0.7171325","0.7170273","0.716829","0.716717","0.71669114","0.71668017","0.71638316","0.71593165","0.7158985","0.7157887","0.7154573","0.7144226","0.7138401","0.7137068","0.7130928"],"string":"[\n \"0.80792505\",\n \"0.8012675\",\n \"0.78432906\",\n \"0.78108615\",\n \"0.7765357\",\n \"0.7751876\",\n \"0.77110696\",\n \"0.76705295\",\n \"0.7647746\",\n \"0.7644992\",\n \"0.7644233\",\n \"0.76380914\",\n \"0.75653404\",\n \"0.7562569\",\n \"0.75440955\",\n \"0.7535946\",\n \"0.75321084\",\n \"0.75190026\",\n \"0.75150883\",\n \"0.7505613\",\n \"0.7491292\",\n \"0.7490559\",\n \"0.748476\",\n \"0.74844605\",\n \"0.745384\",\n \"0.7451498\",\n \"0.74460983\",\n \"0.74348456\",\n \"0.74266624\",\n \"0.7423198\",\n \"0.7418547\",\n \"0.74038947\",\n \"0.7401476\",\n \"0.73931134\",\n \"0.73880523\",\n \"0.7384215\",\n \"0.73823494\",\n \"0.7372509\",\n \"0.73584163\",\n \"0.73545295\",\n \"0.73405594\",\n \"0.73344547\",\n \"0.7329731\",\n \"0.73226017\",\n \"0.73218924\",\n \"0.7320626\",\n \"0.7316476\",\n \"0.73070085\",\n \"0.73057014\",\n \"0.7296637\",\n \"0.7292377\",\n \"0.7287461\",\n \"0.7287459\",\n \"0.7287178\",\n \"0.7284422\",\n \"0.7273681\",\n \"0.7267626\",\n \"0.7262759\",\n \"0.7262249\",\n \"0.7261698\",\n \"0.7256247\",\n \"0.7254192\",\n \"0.72524196\",\n \"0.7244782\",\n \"0.72432053\",\n \"0.72330594\",\n \"0.72301143\",\n \"0.722756\",\n \"0.7222257\",\n \"0.7215478\",\n \"0.721014\",\n \"0.7210101\",\n \"0.7209053\",\n \"0.7208629\",\n \"0.7205561\",\n \"0.7199625\",\n \"0.71985763\",\n \"0.71982235\",\n \"0.71981925\",\n \"0.7196416\",\n \"0.7194187\",\n \"0.71856034\",\n \"0.71819746\",\n \"0.71795917\",\n \"0.7174014\",\n \"0.7172088\",\n \"0.7171325\",\n \"0.7170273\",\n \"0.716829\",\n \"0.716717\",\n \"0.71669114\",\n \"0.71668017\",\n \"0.71638316\",\n \"0.71593165\",\n \"0.7158985\",\n \"0.7157887\",\n \"0.7154573\",\n \"0.7144226\",\n \"0.7138401\",\n \"0.7137068\",\n \"0.7130928\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3396,"cells":{"query":{"kind":"string","value":"Main method to get dependent review IDs of a specific review request on the ReviewBoard."},"document":{"kind":"string","value":"def main():\n parameters = parse_parameters()\n review_request_url = \"%s/api/review-requests/%s/\" % (REVIEWBOARD_URL,\n parameters.review_id)\n handler = ReviewBoardHandler()\n review_request = handler.api(review_request_url)[\"review_request\"]\n review_ids = handler.get_dependent_review_ids(review_request)\n if parameters.out_file:\n with open(parameters.out_file, 'w') as f:\n for r_id in review_ids:\n f.write(\"%s\\n\" % (str(r_id)))\n else:\n for r_id in review_ids:\n print(\"%s\\n\" % (str(r_id)))"},"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_review_request(self, rid):\r\n rsp = self.api_call('api/review-requests/%s/' % rid)\r\n return rsp['review_request']","def get_review_request(self, request_id, api_root):\n try:\n request = api_root.get_review_request(review_request_id=request_id)\n except APIError, e:\n raise CommandError(\"Error getting review request: %s\" % e)\n\n return request","def get_reviews(business_id):\n\n reviews_path = BUSINESS_PATH + business_id + '/reviews'\n\n return request(reviews_path)","def fetch_reviews(self, rb_id, start=0, max_results=25):\r\n return self.api_call('/api/review-requests/%s/reviews/?start=%s&max-results=%s'\r\n % (rb_id, start, max_results))['reviews']","def get_reviews(bearer_token, business_id):\n reviews_path = BUSINESS_PATH + business_id + '/reviews'\n\n return request(API_HOST, reviews_path, bearer_token)","def get_reviews(review_url):\n print review_url\n html = urllib.urlopen(review_url).read()\n soup = bs4.BeautifulSoup(html, 'html.parser')\n\n rating_scores = soup.findAll(\"span\", \"ratingScore\")\n num_ratings = len(rating_scores) - 1\n\n current_reviews = soup.findAll(\"div\", \"currentVintageProfessinalReviews\")\n num_cur_reviews = str(current_reviews).count('ratingProvider')\n past_reviews = soup.findAll(\"ul\", \"pastVintagesProfessionalReviews\")\n num_past_reviews = str(past_reviews).count('ratingProvider')\n\n print 'There are {0} reviews for prior vintages of this wine.'.format(num_past_reviews)\n print 'There are {0} current reviews for this vintage.\\n'.format(num_cur_reviews)\n\n rating_provider = soup.findAll(\"span\", \"ratingProvider\")\n rating_score = soup.findAll(\"span\", \"ratingScore\")\n reviewers = re.findall('(?<![A-Z])[>]([A-Z]+(?![A-Z]))', str(rating_provider))\n ratings = re.findall('(?<![A-Z])[0-9]{2}(?![A-Z])', str(rating_score))\n\n print \"Ratings List:\", ratings\n print \"Current Reviews: \", num_cur_reviews\n\n currentreviews = []\n for j in range(num_cur_reviews):\n print \"Current Review #\"+str(j+1)+\":\", reviewers[j], ratings[j]\n currentreviews.append((reviewers[j], ratings[j]))\n print currentreviews\n\n print \"\\nPast Reviews: \", num_past_reviews\n past_review_ratings = []\n for k in range(num_cur_reviews, num_past_reviews+num_cur_reviews):\n #print \"Past Review #\"+str(k-num_cur_reviews+1)+\":\", reviewers[k], int(ratings[k])\n past_review_ratings.append(float(ratings[k]))\n if k > 30:\n break\n if num_past_reviews != 0:\n avg_past_reviews = sum(past_review_ratings)/len(past_review_ratings)\n round(avg_past_reviews, 2)\n else:\n avg_past_reviews = 0\n\n print \"Average of Past Reviews: \", avg_past_reviews\n\n return currentreviews, avg_past_reviews","def test_get_url_on_review_request(self) -> None:\n review_request = self.create_review_request()\n\n self.assertEqual(\n self.action.get_url(context=self._create_request_context(\n review_request=review_request,\n url_name='review-request-detail')),\n '/r/%s/diff/raw/' % review_request.display_id)","def get_completed_chart_reviews(self, request):\n reqParams = request.GET\n project = reqParams.get('project', None)\n cohort = reqParams.get('cohort', None)\n patient_id = reqParams.get('patient_id', None)\n queryset = self.search_chart_review_data(project, cohort, patient_id)\n page = self.paginate_queryset(queryset)\n data = []\n\n if page is not None:\n serializer = self.get_serializer(page, many=True)\n data = serializer.data\n\n return self.get_paginated_response(data)","def get_review(self, id):\n endpoint = '/v3/educator/reviews/%s' % id\n result = self.request(endpoint)","def build_indices(review_ids):\n\n review_indices = {}\n\n # Load qrel_abs_train txt file\n clef_data = pd.read_csv(config.TRAIN_QREL_LOCATION, sep=\"\\s+\", names=['review_id', 'q0', 'pmid', 'included'])\n\n # Get index of documents for each review\n for review_id in review_ids:\n index = clef_data.index[clef_data['review_id'] == review_id].tolist()\n\n # Get the range of index for all documents within each review\n review_indices[review_id] = (min(index), max(index) + 1)\n\n return review_indices","def get_review_status(pr_id):\n reviews = get_status_json(pr_id, 'reviews')\n requests = get_status_json(pr_id, 'reviewRequests')\n\n requested_authors = [r[\"login\"] for r in requests]\n\n review_status = {}\n for r in reviews:\n author = r['author']['login']\n date = datetime.fromisoformat(r['submittedAt'].strip('Z'))\n state = r['state']\n if author not in review_status:\n review_status[author] = ReviewComment(state, date, author)\n elif state != 'COMMENTED' and review_status[author].date < date:\n review_status[author] = ReviewComment(state, date, author)\n for a in review_status:\n if a in requested_authors:\n review_status[a] = ReviewComment('REVIEW_REQUESTED', review_status[a].date, a)\n for a in requested_authors:\n if a not in review_status:\n review_status[a] = ReviewComment('UNRESPONSIVE', None, a)\n return review_status, requested_authors","def get_review(review_id):\n return get(cls, review_id)","def _request_reviews(self, token, owner, repo, number, reviewers):\n post_data = {'reviewers': reviewers.split(',')}\n headers = {'Authorization': 'Basic ' + token}\n response = requests.post(\n flask.current_app.config['GITHUB_API_CREATE_REVIEW_REQUEST'].format(owner=owner, repo=repo, number=number),\n data=json.dumps(post_data), headers=headers)\n\n return response","def get_parent_rr(review_request_details, commit_data=None):\n commit_data = fetch_commit_data(review_request_details, commit_data)\n\n if not is_pushed(review_request_details, commit_data):\n return None\n\n if is_parent(review_request_details, commit_data):\n return review_request_details\n\n identifier = commit_data.get_for(review_request_details, IDENTIFIER_KEY)\n\n return ReviewRequest.objects.get(\n commit_id=identifier,\n repository=review_request_details.repository)","def parse_parameters():\n parser = argparse.ArgumentParser(\n description=\"Get all dependent review IDs\")\n parser.add_argument(\"-r\", \"--review-id\", type=str, required=True,\n help=\"Review ID\")\n parser.add_argument(\"-o\", \"--out-file\", type=str, required=False,\n help=\"The out file with the reviews IDs\")\n return parser.parse_args()","def find_reviews():\n print(\"***** Find Reviews of a Business *****\")\n while (True):\n print()\n business_object = query_business_name()\n if business_object == \"back\":\n return\n elif business_object is None:\n continue\n id = business_object['business_id']\n review_object = review_col.find({\"business_id\": id})\n print(f'{business_object[\"name\"]} has'\n f' {business_object[\"review_count\"]} '\n f'reviews:')\n for review in review_object:\n userid = review['user_id']\n print(f'- ({review[\"stars\"]}):'\n f' {review[\"text\"]}.'\n f' {review[\"date\"]}')","def get_request_ids(request_id=None, workload_id=None, session=None):\n if request_id:\n return [request_id]\n return get_request_ids_by_workload_id(workload_id)","def get_reviews(recipe_id=None):\n\n recipe = storage.get(Recipe, recipe_id)\n print(recipe)\n if not recipe:\n abort(404)\n reviews = []\n for review in recipe.reviews:\n reviews.append(review.to_dict())\n return jsonify(reviews)","def one_review(review_id=None):\n if review_id:\n for item in storage.all(Review).values():\n if review_id == item.id:\n return (jsonify(item.to_dict()))\n abort(404)","def getTaskIds(self, director):\n # the computation record\n computation = self._getComputationRecord(director)\n \n # search for tasks\n iworker = self.inventory.iworker\n tasks = computation.findTasks(director.clerk.db, iworker)\n\n ids = [t.id for t in tasks]\n return ','.join(ids)","def get_reviews(review_id):\n if review_id:\n review = storage.get(Review, review_id) # retrieves obj\n if review is None:\n return jsonify({'error': 'Not found'}), 404\n if request.method == 'DELETE':\n storage.delete(review) # deletes\n storage.save()\n return jsonify({}), 200\n elif request.method == 'PUT':\n js = request.get_json()\n if js is None:\n return jsonify({'error': 'Not a JSON'}), 400\n js.pop('id', None)\n js.pop('user_id', None)\n js.pop('place_id', None)\n js.pop('created_at', None)\n js.pop('updated_at', None)\n for key, value in js.items():\n setattr(review, key, value) # updates\n review.save()\n return jsonify(review.to_dict()), 200\n else:\n return jsonify(review.to_dict()), 200\n\n if request.method == 'POST':\n js = request.get_json()\n if js is None:\n return jsonify({'error': 'Not a JSON'}), 400\n if js.get('user_id', None) is None:\n return jsonify({'error': 'Missing user_id'}), 400\n if js.get('text', None) is None:\n return jsonify({'error': 'Missing text'}), 400\n obj = Review(**js) # creates\n obj.save()\n return jsonify(obj.to_dict()), 201\n\n reviews = []\n reviews_obj = storage.all('Review') # retrieves list obj\n for obj in reviews_obj:\n reviews.append(reviews_obj[obj].to_dict())\n return jsonify(reviews)","def reviews(self):\n reviewList = []\n for review in storage.all(Review).values():\n if review.getattr('place_id') == self.id:\n reviewList.append(review)\n return(reviewList)","def dependent_prs(self):\n comments = self.data['body'].replace('\\r\\n', ' ')\n for comment in self.comments():\n comments += comment['body'].replace('\\r\\n', ' ')\n\n dependent_prs = []\n dependent_keywords = ['depends on']\n for keyword in dependent_keywords:\n pattern = r'%s %s/(\\S+)/(\\S+)/pull/(\\d+)' % (keyword, GITHUB)\n LOGGER.info(\"Finding dependent PRs by '%s' in the comments\")\n dependent_prs += re.findall(pattern, comments)\n return set(dependent_prs)","def task_reviews_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n reviews = Review.objects.filter(task=task).all()\n serializer = ReviewSerializer(reviews, many=True)\n return Response(serializer.data)","def get_context_data(\n self,\n **kwargs,\n ) -> Dict[str, Any]:\n review_request = self.review_request\n draft = review_request.get_draft(self.request.user)\n\n # We only want to show one label. If there's a draft, then that's\n # the most important information, so we'll only show that. Otherwise,\n # we'll show the submitted/discarded state.\n label = None\n\n if draft:\n label = ('review-request-infobox-label-draft', _('Draft'))\n elif review_request.status == ReviewRequest.SUBMITTED:\n label = ('review-request-infobox-label-submitted', _('Submitted'))\n elif review_request.status == ReviewRequest.DISCARDED:\n label = ('review-request-infobox-label-discarded', _('Discarded'))\n\n if label:\n label = format_html('<label class=\"{0}\">{1}</label>', *label)\n\n # Fetch information on the reviews for this review request.\n review_count = (\n review_request.reviews\n .filter(public=True, base_reply_to__isnull=True)\n .count()\n )\n\n # Fetch information on the draft for this review request.\n diffset = None\n\n if draft and draft.diffset_id:\n diffset = draft.diffset\n\n if not diffset and review_request.diffset_history_id:\n try:\n diffset = (\n DiffSet.objects\n .filter(history__pk=review_request.diffset_history_id)\n .latest()\n )\n except DiffSet.DoesNotExist:\n pass\n\n if diffset:\n diff_url = '%s#index_header' % local_site_reverse(\n 'view-diff-revision',\n args=[review_request.display_id, diffset.revision],\n local_site=review_request.local_site)\n else:\n diff_url = None\n\n return {\n 'review_request': review_request,\n 'review_request_label': label or '',\n 'review_request_details': draft or review_request,\n 'issue_total_count': (review_request.issue_open_count +\n review_request.issue_resolved_count +\n review_request.issue_dropped_count +\n review_request.issue_verifying_count),\n 'review_count': review_count,\n 'diffset': diffset,\n 'diff_url': diff_url,\n }","def test_get_dealer_reviews(self):\n pass","def getReviewNumbers(singleStoryFooter):\n\twords = singleStoryFooter.get_text()\n\treview = re.compile(r\"Reviews: \\d+\").search(words)\n\tif review:\n\t\treviewNum = review.group()[9:]\n\t\treturn int(reviewNum)\n\telse: return 0","def _dependency_id(self):\n if self._dependency_ids:\n return self._dependency_ids[0]","def save_draft(self, review_request):\r\n self.api_call('api/review-requests/%s/draft/save/' %\r\n review_request['id'])\r\n self.debug('Review request draft saved')","def get_open_reviews(args):\n args['status'] = 'pending'\n if 'max_results' not in args:\n args['max_results'] = 100\n\n client = RBClient(REVIEWBOARD_URL)\n\n # If we have a username and password, login\n if REVIEWBOARD_USERNAME and REVIEWBOARD_PASSWORD:\n client.login(REVIEWBOARD_USERNAME, REVIEWBOARD_PASSWORD)\n\n root = client.get_root()\n\n if not root:\n logger.error(u'Could not get RBClient root')\n return None\n\n try:\n req = root.get_review_requests(**args)\n except APIError:\n logger.exception(u'Error querying API')\n return None\n\n ret = {'total': req.total_results, 'reviews': []}\n review_fmt = u\"[{user}] {summary} ({url}/r/{id})\"\n\n for review in req:\n ret['reviews'].append(review_fmt.format(user=review.get_submitter().username,\n summary=review.summary,\n url=REVIEWBOARD_URL,\n id=review.id))\n\n return ret","def get_review(self, id_):\n cursor = self._connection.cursor()\n select_command = make_select_command(\"reviews\")\n select_command += \" WHERE id_ = ?\"\n cursor.execute(select_command, (id_,))\n for row in cursor:\n return expandable_from_tuple(row, FIELD_DESCRIPTIONS) \n return None","def dependent_ids(self) -> List[str]:\n return list(map(as_text, self.connection.smembers(self.dependents_key)))","def load_reviews(id_reviews=(), load_polarities=False, load_sentences=False, load_words=False, load_deptrees=False):\n from loacore.conf import DB_TIMEOUT\n reviews = []\n conn = sql.connect(DB_PATH, timeout=DB_TIMEOUT)\n c = conn.cursor()\n if len(id_reviews) > 0:\n for id_review in id_reviews:\n c.execute(\"SELECT ID_Review, Review.ID_File, File_Index, Review \"\n \"FROM Review WHERE ID_Review = \" + str(id_review) + \" ORDER BY File_Index\")\n result = c.fetchone()\n if result is not None:\n reviews.append(Review(result[0], result[1], result[2], result[3]))\n else:\n c.execute(\"SELECT ID_Review, Review.ID_File, File_Index, Review FROM Review\")\n results = c.fetchall()\n for result in results:\n reviews.append(Review(result[0], result[1], result[2], result[3]))\n\n conn.close()\n\n if load_polarities:\n # Load Polarities\n import loacore.load.polarity_load as polarity_load\n polarity_load.load_polarities_in_reviews(reviews)\n\n if load_sentences:\n # Load Sentences\n import loacore.load.sentence_load as sentence_load\n sentence_load.load_sentences_in_reviews(reviews, load_words=load_words, load_deptrees=load_deptrees)\n\n return reviews","def get_reviews(place_id):\n return get_all_cls(parent_cls, place_id, \"reviews\")","def review_by_id(review_id):\n obj = storage.get(\"Review\", review_id)\n if obj is None:\n abort(404)\n return jsonify(obj.to_dict())","def get_reviews(item_id, shop_id, review_num=10) -> list:\n get_url = f\"{_shopee_base_url}/api/v2/item/get_ratings?filter=0&flag=1&itemid={item_id}&limit={review_num}&offset=0&shopid={shop_id}\"\n r = requests.get(get_url, headers=_user_agent_header, proxies=proxy_dict)\n ratings = r.json()['data']['ratings']\n reviews = []\n for rating in ratings:\n reviews.append({\n 'origin': 'Shopee',\n 'author': rating['author_username'],\n 'rating': rating['rating_star'],\n 'review': rating['comment'], \n 'review_likes': rating['like_count'],\n 'summary': 'Summary is very nice. Amazing!'\n })\n return reviews","def multiple(critic, parameters):\n\n review = jsonapi.v1.reviews.Reviews.deduce(critic, parameters)\n return api.log.rebase.fetchAll(critic, review=review)","def get_req_ids(actual_pose, target, req_ids, person_ids):\n train_x = []\n train_y = []\n\n for i in req_ids:\n id_mask = (person_ids == i)\n train_x.append(actual_pose[id_mask])\n train_y.append(target[id_mask, 0])\n\n train_x = np.concatenate(train_x)\n train_y = np.concatenate(train_y)\n \n return train_x, train_y","def get_reviewers(ctx, tickets):\n if ctx.options['--no-reviewer']:\n return []\n reviewers = ctx.options['--reviewer']\n if ctx.pagure and not reviewers:\n reviewers = set()\n for ticket in tickets:\n if ticket.reviewer:\n reviewers.add(ticket.reviewer)\n if len(reviewers) > 1:\n print('Reviewers found: %s' % ', '.join(reviewers))\n ctx.die('Too many reviewers found in ticket(s), '\n 'specify --reviewer explicitly')\n if not reviewers:\n ctx.die('No reviewer found in ticket(s), '\n 'specify --reviewer explicitly')\n username_map = ctx.config.get('trac-username-map', {})\n reviewers = [username_map.get(r, r) for r in reviewers]\n if not reviewers:\n ctx.die('No reviewer found, please specify --reviewer')\n return [normalize_reviewer(ctx, r) for r in reviewers]","def check_review_files(input, data_review):\n if \"versions\" not in input:\n return None\n\n input_version_ids = []\n for v in input[\"versions\"]:\n _, version_id = from_global_id(v)\n input_version_ids.append(version_id)\n\n # Check all versions exist\n versions = (\n Version.objects.filter(pk__in=input_version_ids)\n .select_related(\"root_file__study\")\n .all()\n )\n if len(versions) != len(input[\"versions\"]):\n raise GraphQLError(\n \"Error in modifying data_review. All file versions in data \"\n \"review must exist.\"\n )\n\n # Check all versions come from same study\n studies = set(\n [v.root_file.study.pk for v in versions] + [data_review.study.pk]\n )\n if len(studies) > 1:\n raise GraphQLError(\n \"Error in modifying data_review. All file versions in data \"\n \"review must have files that belong to the same study.\"\n )\n\n # Check if data review file versions changed\n if data_review:\n if set(data_review.versions.values_list(\"pk\", flat=True)) == set(\n input_version_ids\n ):\n input_version_ids = None\n\n return input_version_ids","def reviews(self, **kwargs):\n\n path = self._get_movie_id_path('reviews')\n resp = self._get_method(path, kwargs)\n return resp","def test_get_specific_review_sucess(self):\n # Get the User's Auth Token.\n url = '/api-token-auth/'\n data = {'username': 'adam', 'password': '123'}\n response = Client().post(url, data)\n content = json.loads(response.content)\n user_token = content['token']\n\n # Prepare the header with the client's token.\n http_authorization = 'Token %s' % user_token\n client = Client(HTTP_AUTHORIZATION=http_authorization)\n\n # GET the Reviews.\n response = client.get('/reviews/1/')\n self.assertEqual(response.status_code, 200)\n\n # Check if only reviews related to the user were retrieved.\n content = json.loads(response.content)\n expected = {\n 'id': 1,\n 'rating': 5,\n 'title': 'Loved it!',\n 'summary': 'I loved it! Pretty good!',\n 'submission_date': '2020-10-12',\n 'ip_address': '127.0.0.1',\n 'reviewer': 1,\n 'company': 1\n }\n self.assertDictEqual(content, expected)","def process_reviews(reviews: list):\n\n def process_review(review, i, n):\n print(f'\\rProcessing {i + 1} of {n} reviews', end='')\n return nltk.pos_tag(nltk.word_tokenize(review[0].strip())), review[1]\n\n n = len(reviews)\n processed = [process_review(review, i, n)\n for i, review in enumerate(reviews)]\n return processed","def get_restaurant_reviews( self, restaurant_id, set_of_users ):\n\n\t\tcondition = ( ( self.df['business_id'] == restaurant_id ) & \n\t\t\t\t\t ( self.df['user_id'].isin(set_of_users) ) )\n\t\treviews = self.df[condition]\n\n\t\t# remove for duplicated user id \n\t\treviews[ reviews['user_id'].duplicated() == False ] \n\t\treturn reviews","def get_diffstats(review_request, user, rev=None):\n # Ensure we're working with the base review request, not a draft.\n review_request = review_request.get_review_request()\n\n if rev is None:\n # If the user is the submitter we might want to use the draft diffset.\n draft = review_request.get_draft(user=user)\n diffset = ((draft and draft.diffset) or\n review_request.get_latest_diffset())\n else:\n diffset = (\n DiffSet.objects\n .filter(history__pk=review_request.diffset_history_id)\n .filter(revision=rev)).latest()\n\n return diffstats(diffset)","def delete_review(review_id=None):\n if review_id:\n for item in storage.all(Review).values():\n if review_id == item.id:\n item.delete()\n storage.save()\n return (jsonify({}))\n abort(404)","def _get_current_reviewers_and_counts(project_name):\n reviewer_change_count_per_project = current_load_fetcher.\\\n get_open_change_reviewers_per_project()\n\n if project_name not in reviewer_change_count_per_project and \\\n project_name != PROJECT_ALL:\n logging.warning(\"Project %s does not have any current reviewers\",\n project_name)\n return []\n\n if project_name == PROJECT_ALL:\n # go through all projects and combine open change counts for each\n # reviewer\n reviewers_changes_counts = \\\n _get_current_change_counts_across_projects(\n reviewer_change_count_per_project\n )\n else:\n reviewers_changes_counts = \\\n reviewer_change_count_per_project[project_name]\n\n return _create_reviewer_current_change_count_info(reviewers_changes_counts)","def find_n_reviews(x, n, review_books_df):\n asin_1 = x['asin_1']\n asin_2 = x['asin_2']\n\n overall_reviews_1 = review_books_df.query('asin == @asin_1').sort_values(\n 'unixReviewTime').iloc[0:(n+1)].overall.tolist()\n overall_reviews_2 = review_books_df.query('asin == @asin_2').sort_values(\n 'unixReviewTime').iloc[0:(n+1)].overall.tolist()\n\n dic_1 = {'asin': asin_1}\n for i, val in enumerate(overall_reviews_1):\n dic_1[str(i)+\"-th-review\"] = val\n\n dic_2 = {'asin': asin_2}\n for i, val in enumerate(overall_reviews_2):\n dic_2[str(i)+\"-th-review\"] = val\n \n return [dic_1, dic_2]","def _get_approved_reviewers(self, pull_request_number: int) -> List[str]:\n reviews = get_pull_request_reviews(\n self._repo_name, pull_request_number, self._auth)\n if not reviews:\n return []\n approved_reviewers = set()\n for review in reviews:\n if review['state'] == 'APPROVED':\n if review['user']:\n approved_reviewers.add(review['user']['login'])\n else:\n approved_reviewers.add(\"\")\n return list(approved_reviewers)","def GetId(self, request=[], default=None):\n idd = False\n \n partName, partRev, _ = request\n# partName, partRev, updateDate = request\n# if updateDate:\n# if partRev:\n# criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev),\n# ('write_date', '>', updateDate)]\n# else:\n# criteria=[('engineering_code', '=', partName), ('write_date', '>', updateDate)]\n# else:\n# if partRev:\n# criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev)]\n# else:\n# criteria=[('engineering_code', '=', partName)]\n if isinstance(partRev, int):\n criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev)]\n else:\n criteria=[('engineering_code', '=', partName)]\n\n partIds = self.search(criteria, order='engineering_revision')\n if len(partIds) > 0:\n idd=partIds[len(partIds) - 1].id\n return idd","def reviews(self):\n cts = storage.all(Review)\n ltcts = []\n for objects in cts.values():\n if self.id == objects.state_id:\n ltcts.append(objects)\n return ltcts","def get_review(review_id):\n obj = storage.get(Review, review_id)\n if obj is None:\n abort(404)\n return jsonify(obj.to_dict())","def dependents_key(self):\n return self.dependents_key_for(self.id)","def run(self, __eatery_id):\n self.start = time.time()\n\t \n print __eatery_id\n instance = ClassifyReviews([eatery_id])\n instance.run()\n #return group(callback.clone([arg, __eatery_id]) for arg in __review_list)()","def department_reviews(request, department_code):\n department = get_object_or_404(Department, code=department_code)\n\n topic_id_to_course = dict()\n recent_courses = list(\n Course.objects.filter(\n course_filters_pcr_allow_xlist,\n department=department,\n )\n .distinct()\n .values(\"semester\", \"topic_id\", course_title=F(\"title\"), course_code=F(\"full_code\"))\n )\n for c in recent_courses:\n c[\"exclude_from_recent\"] = True\n topic_id = c[\"topic_id\"]\n if (\n topic_id not in topic_id_to_course\n or topic_id_to_course[topic_id][\"semester\"] < c[\"semester\"]\n ):\n topic_id_to_course[topic_id] = c\n\n reviews = list(\n review_averages(\n Review.objects.filter(section__course__department=department),\n reviewbit_subfilters=Q(review_id=OuterRef(\"id\")),\n section_subfilters=Q(id=OuterRef(\"section_id\")),\n fields=ALL_FIELD_SLUGS,\n prefix=\"bit_\",\n extra_metrics=True,\n )\n .annotate(\n topic_id=F(\"section__course__topic_id\"),\n semester=F(\"section__course__semester\"),\n )\n .values()\n )\n for review in reviews:\n course = topic_id_to_course[review[\"topic_id\"]]\n review[\"course_code\"] = course[\"course_code\"]\n review[\"course_title\"] = course[\"course_title\"]\n\n all_courses = reviews + list(topic_id_to_course.values())\n courses = aggregate_reviews(all_courses, \"course_code\", code=\"course_code\", name=\"course_title\")\n\n return Response({\"code\": department.code, \"name\": department.name, \"courses\": courses})","def review_ask(request):\n\n result = {}\n u = request.user\n p = Product.objects.get_by_sku(request.POST['sku'])\n\n if p is None:\n result[\"result\"] = '0'\n\n # change wish review request pending status\n for w in Wishlist.objects.filter(product=p, party=u):\n w.review = Wishlist.REVIEW_REQUESTED \n w.save()\n\n req, created = ReviewRequest.objects.get_or_create(requester=u, product=p)\n\n # could replace above line with these lines if it causes trouble\n #if not ReviewRequest.objects.filter(requester=u.party, product=p).exists():\n # r = ReviewRequest(requester=u.party, product=p)\n # r.save()\n\n # any previous reviews related to this request is linked\n for rev in Review.objects.filter(product=p):\n rev.reply_to.add(req)\n\n result['result'] = str(req.id)\n\n # add a feed\n f = Feed(actor=u, action=Feed.REQUESTED, product=p) \n f.save()\n\n # TODO: notify others that review requested\n\n return JSONHttpResponse(result)","def find_data_breach_record_reviews(self, breach_id=None):\n return self._request('/api/data-breach-record/'+str(breach_id)+'/reviews')","def process_gen_reviews(self, gen_reviews):\n clusters = []\n reviews = []\n for rev in gen_reviews:\n label_delimiter = rev.find('>')\n clusters.append(int(rev[5:label_delimiter]))\n if rev[-1]=='>':\n reviews.append(rev[label_delimiter+2:-6])\n else:\n reviews.append(rev[label_delimiter+2:])\n\n return clusters, reviews","def test_create_with_new_draft(self):\n user1 = User.objects.create(username='reviewer1')\n user2 = User.objects.create(username='reviewer2')\n\n group1 = self.create_review_group(name='group1')\n group2 = self.create_review_group(name='group2')\n\n dep_review_request_1 = self.create_review_request(publish=True)\n dep_review_request_2 = self.create_review_request(publish=True)\n\n review_request = self.create_review_request(\n publish=True,\n bugs_closed='1,20,300',\n commit_id='abc123',\n description_rich_text=True,\n depends_on=[dep_review_request_1, dep_review_request_2],\n rich_text=True,\n target_groups=[group1, group2],\n target_people=[user1, user2],\n testing_done_rich_text=True,\n extra_data={\n 'key': {\n 'values': [1, 2, 3],\n },\n 'mybool': True,\n })\n\n active_file_attachment_1 = self.create_file_attachment(review_request)\n active_file_attachment_2 = self.create_file_attachment(review_request)\n inactive_file_attachment = self.create_file_attachment(review_request,\n active=False)\n\n active_screenshot_1 = self.create_screenshot(review_request)\n active_screenshot_2 = self.create_screenshot(review_request)\n inactive_screenshot = self.create_screenshot(review_request,\n active=False)\n\n # Create the draft.\n draft = ReviewRequestDraft.create(review_request)\n\n # Make sure all the fields are the same.\n self.assertEqual(draft.branch, review_request.branch)\n self.assertEqual(draft.bugs_closed, review_request.bugs_closed)\n self.assertEqual(draft.commit_id, review_request.commit_id)\n self.assertEqual(draft.description, review_request.description)\n self.assertEqual(draft.description_rich_text,\n review_request.description_rich_text)\n self.assertEqual(draft.extra_data, review_request.extra_data)\n self.assertEqual(draft.rich_text, review_request.rich_text)\n self.assertEqual(draft.summary, review_request.summary)\n self.assertEqual(draft.testing_done, review_request.testing_done)\n self.assertEqual(draft.testing_done_rich_text,\n review_request.testing_done_rich_text)\n\n self.assertEqual(list(draft.depends_on.order_by('pk')),\n [dep_review_request_1, dep_review_request_2])\n self.assertEqual(list(draft.target_groups.all()),\n [group1, group2])\n self.assertEqual(list(draft.target_people.all()),\n [user1, user2])\n self.assertEqual(list(draft.file_attachments.all()),\n [active_file_attachment_1, active_file_attachment_2])\n self.assertEqual(list(draft.inactive_file_attachments.all()),\n [inactive_file_attachment])\n self.assertEqual(list(draft.screenshots.all()),\n [active_screenshot_1, active_screenshot_2])\n self.assertEqual(list(draft.inactive_screenshots.all()),\n [inactive_screenshot])\n\n self.assertIsNotNone(draft.changedesc)","def _get_reviewers(project_name, from_datetime):\n logging.debug(\n \"Getting reviewers for project: %s from datetime: %r\",\n project_name, from_datetime)\n if project_name == PROJECT_ALL:\n # reviewers with changes across all projects after from_datetime\n reviewers = Reviewer.objects.filter(\n changes__timestamp__gte=from_datetime).distinct()\n else:\n # reviewers with changes in given project after from_datetime\n reviewers = Reviewer.objects.filter(\n changes__project_name=project_name,\n changes__timestamp__gte=from_datetime).distinct()\n\n logging.debug(\"Found reviewers: %r\", reviewers)\n return reviewers","def ids(self):\n\n if not hasattr(self, \"_ids\"):\n query = db.Query(\"pub_proc_cg c\", \"c.id\").unique().order(\"c.id\")\n query.join(\"query_term t\", \"t.doc_id = c.id\")\n query.join(\"query_term s\", \"s.doc_id = t.int_val\")\n query.where(\"t.path = '/Term/SemanticType/@cdr:ref'\")\n query.where(\"s.path = '/Term/PreferredName'\")\n query.where(\"s.value = 'Drug/agent'\")\n rows = query.execute(self.cdr_cursor).fetchall()\n self._ids = [row.id for row in rows]\n self.logger.info(\"found %d drug terms\", len(self._ids))\n return self._ids","def get_recommendar(\n\treviews,\n\tuser_city,\n\trest_city,\n\trest_id_to_int,\n\tmodel=\"baseline\",\n\tk=TOP_K,\n\tremoveSeen=True,\n\tinfer_loc_by_latest_rating_only=True,\n\tlatest_rating_limiter=3\n\t):\n\treturn LocalRecommendar(\n\t\treviews=reviews,\n\t\tuser_city=user_city,\n\t\trest_city=rest_city,\n\t\trest_id_to_int=rest_id_to_int,\n\t\tmodel=model,\n\t\tk=k,\n\t\tremoveSeen=removeSeen,\n\t\tinfer_loc_by_latest_rating_only=infer_loc_by_latest_rating_only,\n\t\tlatest_rating_limiter=latest_rating_limiter\n\t\t)","def _is_pull_request_reviewer_approved(querier, org, repo, pr_id):\n query = \"\"\"\n query($org:String!, $repo:String!, $pullRequestID:Int!){\n repository(owner: $org, name: $repo){\n protectedBranches(first: 100){\n nodes{\n name\n requiredApprovingReviewCount\n }\n }\n pullRequest(number: $pullRequestID){\n baseRefName\n reviews(last: 100){\n nodes{\n state\n author{\n login\n }\n }\n }\n }\n }\n }\n \"\"\"\n variables = {\n \"pullRequestID\": pr_id,\n \"org\": org,\n \"repo\": repo,\n }\n\n data = querier(query, variables)\n\n base_ref_name = jmespath.search(\n \"data.repository.pullRequest.baseRefName\",\n data\n )\n\n required_approval_count = jmespath.search(\n \"\"\"\n data\n .repository\n .protectedBranches\n .nodes[?name == '{branch}']\n |[0]\n .requiredApprovingReviewCount\n \"\"\".format(branch=base_ref_name),\n data\n )\n\n review_history = jmespath.search(\n \"\"\"\n data\n .repository\n .pullRequest\n .reviews\n .nodes[*]\n .{approver: author.login, state: state}\n \"\"\",\n data\n )\n reviews = {r[\"approver\"]: r[\"state\"] for r in review_history}\n approval_count = reviews.values().count(\"APPROVED\")\n\n if required_approval_count and approval_count < required_approval_count:\n is_approved = False\n else:\n is_approved = True\n\n return is_approved","def get_project_ids(self, *criterion):\n from wkcdd.models.helpers import get_project_ids\n return get_project_ids([self.id], *criterion)","def review_by_id(review_id):\n review = storage.get(\"Review\", review_id)\n if review is None:\n abort(404)\n return jsonify(review.to_json())","def get_data_requests(self, request):\n\n not_reviewed_yet = Task.objects.filter(\n Q(approver_email=request.user.email),\n Q(state=Task.SUCCESS, review_output=True)\n | Q(state=Task.ERROR, review_output=True),\n ).order_by(\"-registered_on\")\n\n reviewed = Task.objects.filter(\n Q(author_email=request.user.email),\n Q(state=Task.RUNNING)\n | Q(state=Task.OUTPUT_RELEASED)\n | Q(state=Task.RELEASE_REJECTED)\n | Q(state=Task.SUCCESS, review_output=False)\n | Q(state=Task.ERROR, review_output=False),\n ).order_by(\"-registered_on\")\n\n return Response(\n {\n \"not_reviewed_yet\": TaskSerializer(not_reviewed_yet, many=True).data,\n \"reviewed\": TaskSerializer(reviewed, many=True).data,\n }\n )","def get_playbook_run_ids(request1_body=None, **kwargs):\n ############################ Custom Code Goes Below This Line #################################\n import json\n import phantom.rules as phantom\n \n outputs = {}\n \n for element in request1_body:\n phantom.debug(element)\n \n # Write your custom code here...\n \n # Return a JSON-serializable object\n assert json.dumps(outputs) # Will raise an exception if the :outputs: object is not JSON-serializable\n return outputs","def GetReviewers(host, change):\n path = '%s/reviewers' % _GetChangePath(change)\n return FetchUrlJson(host, path)","def getDependenceIdAt(self, pos):\n return self.sentence[pos].getDependenceId()","def scraper(storyid, reviews_num, rate_limit=3):\n\n # There may be up to 15 reviews on a single page, therefore the number of\n # pages the reviews are stored on is equal to the following:\n number_of_pages = (reviews_num // 15) + 1\n\n # Returns a list of tuples (based on the contents of _reviews_in_table)\n list_of_review_tuples = []\n\n for p in range(number_of_pages):\n\n soup = soupify('https://www.fanfiction.net/r/' + storyid +\n '/0/' + str(p+1) + '/',\n rate_limit=rate_limit)\n\n for review in _reviews_in_table(soup):\n list_of_review_tuples.append(review)\n\n return list_of_review_tuples","def get_review_comments_for_pr(owner, repo, pr_number, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\n return get_one_item_at_a_time(url, session=session)","def ballot_get_decisions_ids_by_contest(contest_id):\r\n return make_request({\"method\": \"ballot_get_decisions_by_contest\",\r\n \"params\": [contest_id],\r\n \"jsonrpc\": \"2.0\",\r\n \"id\": 0, })","def review_list_handler():\n def fetch_params():\n release_group = Parser.uuid('uri', 'release_group', optional=True)\n user_id = Parser.uuid('uri', 'user_id', optional=True)\n sort = Parser.string('uri', 'sort', valid_values=['rating', 'created'], optional=True) or 'rating'\n limit = Parser.int('uri', 'limit', min=1, max=50, optional=True) or 50\n offset = Parser.int('uri', 'offset', optional=True) or 0\n include = Parser.list('uri', 'inc', Review.allowed_includes, optional=True) or []\n language = Parser.string('uri', 'language', min=2, max=3, optional=True)\n if language and language not in supported_languages:\n raise InvalidRequest(desc='Unsupported language')\n return release_group, user_id, sort, limit, offset, include, language\n release_group, user_id, sort, limit, offset, include, language = fetch_params()\n reviews, count = Review.list(release_group, user_id, sort, limit, offset, language)\n return jsonify(limit=limit, offset=offset, count=count,\n reviews=[p.to_dict(include) for p in reviews])","def reviews(self):\n list_reviews = []\n all_reviews = models.storage.all(Review)\n for review_item in all_reviews.items():\n if review_item.place_id == self.id:\n list_review.append(review_item)\n\n return list_review","def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\n reviewers_mapping = {}\n\n # Reviewers are supposed to be those mentions who have given thumbs up.\n for comment in issue_comments:\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\n reviewers_mapping[comment.user.login] = dict(\n tagged_at=None,\n responded_at=None,\n gave_thumbs_up_at=comment.created_at\n )\n\n # We have reviewers, now, look for the time for their first response in issue comments.\n for comment in issue_comments:\n if comment.user.login in reviewers_mapping.keys() \\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n # TODO: Scrap the time when the PR's body was updated.\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\n # for the reviewers that are in PR's body.\n\n # Look for time when each of reviewer was tagged, this should be\n # searched in pull request body and issue comments.\n for login in reviewers_mapping.keys():\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\n if reviewers_mapping[login]['responded_at'] is None \\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\n reviewers_mapping[login]['tagged_at'] = comment.created_at\n\n # Check for reviewers' first response in review comments too, and\n # update the reviewers_mapping if necessary.\n for comment in review_comments:\n if comment.user.login in reviewers_mapping.keys():\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n return reviewers_mapping","def test_get_ids(civic, main_data, updated_data):\n assert len(civic._get_ids(main_data['assertions'])) == 0\n assert len(civic._get_ids(main_data['variants'])) == 1\n assert len(civic._get_ids(main_data['genes'])) == 2\n assert len(civic._get_ids(main_data['evidence'])) == 1\n\n assert len(civic._get_ids(updated_data['assertions'])) == 1\n assert len(civic._get_ids(updated_data['variants'])) == 1\n assert len(civic._get_ids(updated_data['genes'])) == 1\n assert len(civic._get_ids(updated_data['evidence'])) == 1","def get_review(review_id=None):\n\n review = storage.get(Review, review_id)\n if not review:\n abort(404)\n return jsonify(review.to_dict())","def get_review(review_id):\n review_obj = storage.get(Review, review_id)\n if review_obj:\n return jsonify(review_obj.to_dict())\n else:\n abort(404)","def test_request_review(self):\n other_pk = self.nodes[1].overlay.my_peer.public_key.key_to_bin()\n self.nodes[0].overlay.request_review(1, other_pk)\n yield self.deliver_messages()\n\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\n self.assertTrue(pending_review_requests)\n\n self.nodes[1].overlay.respond_to_review_request(pending_review_requests[0].hash, True)\n yield self.deliver_messages()\n\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\n self.assertFalse(pending_review_requests)\n self.assertEqual(self.nodes[0].overlay.trustchain.persistence.get_number_of_known_blocks(), 2)","def _get_review_comments_body(\n self, pull_request_number: int) -> List[Tuple[str, str]]:\n review_comments = get_pull_request_review_comments(\n self._repo_name, pull_request_number, self._auth)\n if not review_comments:\n return []\n review_comments_msg = []\n for comment in review_comments:\n review_comments_msg.append((comment['path'], comment['body']))\n return review_comments_msg","def get_training_ids(mydb):\n\treturn list(mydb.fetch_table(table_name='training_set',field_names=['CaseId']).CaseId)","def get_repo_review_comments(owner, repo, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/comments'\n return get_one_item_at_a_time(url, session=session)","def ballot_get_decisions_ids_by_voter(voter_id):\r\n return make_request({\"method\": \"ballot_get_decisions_by_voter\",\r\n \"params\": [voter_id],\r\n \"jsonrpc\": \"2.0\",\r\n \"id\": 0, })","def review(args):\n try:\n pr = gh.get_pr(owner, repo, args.pull_request)\n except requests.exceptions.HTTPError:\n print('Couldn\\'t find pull request #%s in %s/%s.' %\n (args.pull_request, owner, repo))\n print('Make sure the number is correct and that you have read '\n 'permissions for this GitHub repository.')\n sys.exit(1)\n\n clone_url = pr['head']['repo']['clone_url']\n fork_branch = pr['head']['ref']\n fork_owner = pr['head']['repo']['owner']['login']\n\n repo_lib.fetch_fork(clone_url, fork_branch, fork_owner)\n repo_lib.checkout(fork_branch, fork_owner)\n sys.exit(0)","def get_pred_ids(predictions):\n le_classes = ['Emotet', 'Mirai', 'Zeus'] \n malwares_dict = {'Emotet': 1, 'Mirai': 2, 'Zeus': 3}\n predicted_ids = []\n \n for idx in predictions:\n pred_name = le_classes[idx]\n pred_id = malwares_dict[pred_name]\n predicted_ids.append(pred_id)\n \n return predicted_ids","def getRelevantPRData():\n prInfoFromAPI = getPRsFromAPI()\n diffHeader = headers.copy()\n diffHeader['Accept'] = \"application/vnd.github.v3.diff\"\n textForReviewPRs = []\n\n for PR in prInfoFromAPI:\n labels = [label[\"name\"] for label in PR['labels']]\n if \"Text for Review\" in labels:\n diffResponse = requests.get(PR[\"url\"], headers=diffHeader)\n diff = diffResponse.text\n # Add the info the list\n textForReviewPRs.append({\n \"pull_request_link\": PR[\"html_url\"],\n \"diff\": diff\n })\n if int(diffResponse.headers[\"X-RateLimit-Remaining\"]) <= 2:\n print('GitHub api rate limit will be exceeded; the GITHUB_TOKEN env variable needs to be set.')\n break\n return textForReviewPRs","def get_outputs(self, input_reviews):\r\n split_list = [1] * self.item_pad_num\r\n splitted_review_wordId_intputs = tf.split(input_reviews, split_list, 1)\r\n cnn_outputs = []\r\n for i in range(self.item_pad_num):\r\n input_review = tf.squeeze(splitted_review_wordId_intputs[i], [1])\r\n cnn_output = self.get_single_output(input_review=input_review, index=i)\r\n cnn_outputs.append(cnn_output)\r\n\r\n return cnn_outputs","def get_possible_ids(self):\n ids = []\n\n dest_data = requests.get(\"https://api.wdpro.disney.go.com/facility-service/destinations/{}\".format(self.__anc_dest_id), headers=getHeaders()).json()\n data = requests.get(dest_data['links']['entertainmentVenues']['href'], headers=getHeaders()).json()\n\n for entry in data['entries']:\n try:\n ids.append(entry['links']['self']['href'].split('/')[-1].split('?')[0])\n except:\n pass\n\n return ids","def get_dependent_objective_id_terms(self):\n return # osid.search.terms.IdTerm","def find_issue_id(self):","def AllocateIds(self, request, context):\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)","def offers_reviews_collection(request, task_id):\n try:\n task = Task.objects.get(id=task_id)\n except Task.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == \"GET\":\n offers = Offer.objects.filter(task=task).all()\n taskers = offers.values_list(\"tasker\", flat=True)\n reviews = Review.objects.filter(reviewee__id__in=taskers, task__assignee__isnull=False).all().order_by(\"-timestamp\")\n serializer = ReviewSerializer(reviews, many=True)\n return Response(serializer.data)","def classify_review(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _get_playground_id(self):\n\n def playground_filter(page: int = 0):\n return {\"filter\": {\"type\": [9], \"page\": page}}\n\n answer = self.client.search_investigations(filter=playground_filter())\n if answer.total == 0:\n raise RuntimeError(\"No playgrounds were detected in the environment.\")\n elif answer.total == 1:\n result = answer.data[0].id\n else:\n # if found more than one playground, try to filter to results against the current user\n user_data, response, _ = self.client.generic_request(\n path=\"/user\",\n method=\"GET\",\n content_type=\"application/json\",\n response_type=object,\n )\n if response != 200:\n raise RuntimeError(\"Cannot find username\")\n username = user_data.get(\"username\")\n\n def filter_by_creating_user_id(playground):\n return playground.creating_user_id == username\n\n playgrounds = list(filter(filter_by_creating_user_id, answer.data))\n\n for i in range(int((answer.total - 1) / len(answer.data))):\n playgrounds.extend(\n filter(\n filter_by_creating_user_id,\n self.client.search_investigations(\n filter=playground_filter(i + 1)\n ).data,\n )\n )\n\n if len(playgrounds) != 1:\n raise RuntimeError(\n f\"There is more than one playground to the user. \"\n f\"Number of playgrounds is: {len(playgrounds)}\"\n )\n result = playgrounds[0].id\n\n logger.debug(f\"Playground ID: {result}\")\n\n return result","def cron_partner_ids(self):\n pass","def review_entity_handler(review_id):\n review = Review.query.get_or_404(str(review_id))\n if review.is_archived is True:\n raise NotFound\n include = Parser.list('uri', 'inc', Review.allowed_includes, optional=True) or []\n return jsonify(review=review.to_dict(include))","def getREVIssues(db):\n return map(trimmedREVDoc,\n db.reviews.find({\"done\": False, \"lgtms\": {\"$exists\": False}}))","def test_get_hidden_on_review_request(self) -> None:\n self.assertTrue(self.action.get_visible(\n context=self._create_request_context(\n url_name='review-request-detail')))","def open_request_review_modal(obj, selenium):\n (_get_ui_service(selenium, obj).open_info_page_of_obj(obj).\n open_submit_for_review_popup())\n modal = request_review.RequestReviewModal(selenium)\n modal.wait_until_present()\n return modal","def _get_information(self):\n reviews = self._tab.find_all(\"div\", class_=\"review\", attrs={'itemprop': 'review'})\n return [(self._get_review(elem), self._get_published_date(elem)) for elem in reviews]"],"string":"[\n \"def get_review_request(self, rid):\\r\\n rsp = self.api_call('api/review-requests/%s/' % rid)\\r\\n return rsp['review_request']\",\n \"def get_review_request(self, request_id, api_root):\\n try:\\n request = api_root.get_review_request(review_request_id=request_id)\\n except APIError, e:\\n raise CommandError(\\\"Error getting review request: %s\\\" % e)\\n\\n return request\",\n \"def get_reviews(business_id):\\n\\n reviews_path = BUSINESS_PATH + business_id + '/reviews'\\n\\n return request(reviews_path)\",\n \"def fetch_reviews(self, rb_id, start=0, max_results=25):\\r\\n return self.api_call('/api/review-requests/%s/reviews/?start=%s&max-results=%s'\\r\\n % (rb_id, start, max_results))['reviews']\",\n \"def get_reviews(bearer_token, business_id):\\n reviews_path = BUSINESS_PATH + business_id + '/reviews'\\n\\n return request(API_HOST, reviews_path, bearer_token)\",\n \"def get_reviews(review_url):\\n print review_url\\n html = urllib.urlopen(review_url).read()\\n soup = bs4.BeautifulSoup(html, 'html.parser')\\n\\n rating_scores = soup.findAll(\\\"span\\\", \\\"ratingScore\\\")\\n num_ratings = len(rating_scores) - 1\\n\\n current_reviews = soup.findAll(\\\"div\\\", \\\"currentVintageProfessinalReviews\\\")\\n num_cur_reviews = str(current_reviews).count('ratingProvider')\\n past_reviews = soup.findAll(\\\"ul\\\", \\\"pastVintagesProfessionalReviews\\\")\\n num_past_reviews = str(past_reviews).count('ratingProvider')\\n\\n print 'There are {0} reviews for prior vintages of this wine.'.format(num_past_reviews)\\n print 'There are {0} current reviews for this vintage.\\\\n'.format(num_cur_reviews)\\n\\n rating_provider = soup.findAll(\\\"span\\\", \\\"ratingProvider\\\")\\n rating_score = soup.findAll(\\\"span\\\", \\\"ratingScore\\\")\\n reviewers = re.findall('(?<![A-Z])[>]([A-Z]+(?![A-Z]))', str(rating_provider))\\n ratings = re.findall('(?<![A-Z])[0-9]{2}(?![A-Z])', str(rating_score))\\n\\n print \\\"Ratings List:\\\", ratings\\n print \\\"Current Reviews: \\\", num_cur_reviews\\n\\n currentreviews = []\\n for j in range(num_cur_reviews):\\n print \\\"Current Review #\\\"+str(j+1)+\\\":\\\", reviewers[j], ratings[j]\\n currentreviews.append((reviewers[j], ratings[j]))\\n print currentreviews\\n\\n print \\\"\\\\nPast Reviews: \\\", num_past_reviews\\n past_review_ratings = []\\n for k in range(num_cur_reviews, num_past_reviews+num_cur_reviews):\\n #print \\\"Past Review #\\\"+str(k-num_cur_reviews+1)+\\\":\\\", reviewers[k], int(ratings[k])\\n past_review_ratings.append(float(ratings[k]))\\n if k > 30:\\n break\\n if num_past_reviews != 0:\\n avg_past_reviews = sum(past_review_ratings)/len(past_review_ratings)\\n round(avg_past_reviews, 2)\\n else:\\n avg_past_reviews = 0\\n\\n print \\\"Average of Past Reviews: \\\", avg_past_reviews\\n\\n return currentreviews, avg_past_reviews\",\n \"def test_get_url_on_review_request(self) -> None:\\n review_request = self.create_review_request()\\n\\n self.assertEqual(\\n self.action.get_url(context=self._create_request_context(\\n review_request=review_request,\\n url_name='review-request-detail')),\\n '/r/%s/diff/raw/' % review_request.display_id)\",\n \"def get_completed_chart_reviews(self, request):\\n reqParams = request.GET\\n project = reqParams.get('project', None)\\n cohort = reqParams.get('cohort', None)\\n patient_id = reqParams.get('patient_id', None)\\n queryset = self.search_chart_review_data(project, cohort, patient_id)\\n page = self.paginate_queryset(queryset)\\n data = []\\n\\n if page is not None:\\n serializer = self.get_serializer(page, many=True)\\n data = serializer.data\\n\\n return self.get_paginated_response(data)\",\n \"def get_review(self, id):\\n endpoint = '/v3/educator/reviews/%s' % id\\n result = self.request(endpoint)\",\n \"def build_indices(review_ids):\\n\\n review_indices = {}\\n\\n # Load qrel_abs_train txt file\\n clef_data = pd.read_csv(config.TRAIN_QREL_LOCATION, sep=\\\"\\\\s+\\\", names=['review_id', 'q0', 'pmid', 'included'])\\n\\n # Get index of documents for each review\\n for review_id in review_ids:\\n index = clef_data.index[clef_data['review_id'] == review_id].tolist()\\n\\n # Get the range of index for all documents within each review\\n review_indices[review_id] = (min(index), max(index) + 1)\\n\\n return review_indices\",\n \"def get_review_status(pr_id):\\n reviews = get_status_json(pr_id, 'reviews')\\n requests = get_status_json(pr_id, 'reviewRequests')\\n\\n requested_authors = [r[\\\"login\\\"] for r in requests]\\n\\n review_status = {}\\n for r in reviews:\\n author = r['author']['login']\\n date = datetime.fromisoformat(r['submittedAt'].strip('Z'))\\n state = r['state']\\n if author not in review_status:\\n review_status[author] = ReviewComment(state, date, author)\\n elif state != 'COMMENTED' and review_status[author].date < date:\\n review_status[author] = ReviewComment(state, date, author)\\n for a in review_status:\\n if a in requested_authors:\\n review_status[a] = ReviewComment('REVIEW_REQUESTED', review_status[a].date, a)\\n for a in requested_authors:\\n if a not in review_status:\\n review_status[a] = ReviewComment('UNRESPONSIVE', None, a)\\n return review_status, requested_authors\",\n \"def get_review(review_id):\\n return get(cls, review_id)\",\n \"def _request_reviews(self, token, owner, repo, number, reviewers):\\n post_data = {'reviewers': reviewers.split(',')}\\n headers = {'Authorization': 'Basic ' + token}\\n response = requests.post(\\n flask.current_app.config['GITHUB_API_CREATE_REVIEW_REQUEST'].format(owner=owner, repo=repo, number=number),\\n data=json.dumps(post_data), headers=headers)\\n\\n return response\",\n \"def get_parent_rr(review_request_details, commit_data=None):\\n commit_data = fetch_commit_data(review_request_details, commit_data)\\n\\n if not is_pushed(review_request_details, commit_data):\\n return None\\n\\n if is_parent(review_request_details, commit_data):\\n return review_request_details\\n\\n identifier = commit_data.get_for(review_request_details, IDENTIFIER_KEY)\\n\\n return ReviewRequest.objects.get(\\n commit_id=identifier,\\n repository=review_request_details.repository)\",\n \"def parse_parameters():\\n parser = argparse.ArgumentParser(\\n description=\\\"Get all dependent review IDs\\\")\\n parser.add_argument(\\\"-r\\\", \\\"--review-id\\\", type=str, required=True,\\n help=\\\"Review ID\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--out-file\\\", type=str, required=False,\\n help=\\\"The out file with the reviews IDs\\\")\\n return parser.parse_args()\",\n \"def find_reviews():\\n print(\\\"***** Find Reviews of a Business *****\\\")\\n while (True):\\n print()\\n business_object = query_business_name()\\n if business_object == \\\"back\\\":\\n return\\n elif business_object is None:\\n continue\\n id = business_object['business_id']\\n review_object = review_col.find({\\\"business_id\\\": id})\\n print(f'{business_object[\\\"name\\\"]} has'\\n f' {business_object[\\\"review_count\\\"]} '\\n f'reviews:')\\n for review in review_object:\\n userid = review['user_id']\\n print(f'- ({review[\\\"stars\\\"]}):'\\n f' {review[\\\"text\\\"]}.'\\n f' {review[\\\"date\\\"]}')\",\n \"def get_request_ids(request_id=None, workload_id=None, session=None):\\n if request_id:\\n return [request_id]\\n return get_request_ids_by_workload_id(workload_id)\",\n \"def get_reviews(recipe_id=None):\\n\\n recipe = storage.get(Recipe, recipe_id)\\n print(recipe)\\n if not recipe:\\n abort(404)\\n reviews = []\\n for review in recipe.reviews:\\n reviews.append(review.to_dict())\\n return jsonify(reviews)\",\n \"def one_review(review_id=None):\\n if review_id:\\n for item in storage.all(Review).values():\\n if review_id == item.id:\\n return (jsonify(item.to_dict()))\\n abort(404)\",\n \"def getTaskIds(self, director):\\n # the computation record\\n computation = self._getComputationRecord(director)\\n \\n # search for tasks\\n iworker = self.inventory.iworker\\n tasks = computation.findTasks(director.clerk.db, iworker)\\n\\n ids = [t.id for t in tasks]\\n return ','.join(ids)\",\n \"def get_reviews(review_id):\\n if review_id:\\n review = storage.get(Review, review_id) # retrieves obj\\n if review is None:\\n return jsonify({'error': 'Not found'}), 404\\n if request.method == 'DELETE':\\n storage.delete(review) # deletes\\n storage.save()\\n return jsonify({}), 200\\n elif request.method == 'PUT':\\n js = request.get_json()\\n if js is None:\\n return jsonify({'error': 'Not a JSON'}), 400\\n js.pop('id', None)\\n js.pop('user_id', None)\\n js.pop('place_id', None)\\n js.pop('created_at', None)\\n js.pop('updated_at', None)\\n for key, value in js.items():\\n setattr(review, key, value) # updates\\n review.save()\\n return jsonify(review.to_dict()), 200\\n else:\\n return jsonify(review.to_dict()), 200\\n\\n if request.method == 'POST':\\n js = request.get_json()\\n if js is None:\\n return jsonify({'error': 'Not a JSON'}), 400\\n if js.get('user_id', None) is None:\\n return jsonify({'error': 'Missing user_id'}), 400\\n if js.get('text', None) is None:\\n return jsonify({'error': 'Missing text'}), 400\\n obj = Review(**js) # creates\\n obj.save()\\n return jsonify(obj.to_dict()), 201\\n\\n reviews = []\\n reviews_obj = storage.all('Review') # retrieves list obj\\n for obj in reviews_obj:\\n reviews.append(reviews_obj[obj].to_dict())\\n return jsonify(reviews)\",\n \"def reviews(self):\\n reviewList = []\\n for review in storage.all(Review).values():\\n if review.getattr('place_id') == self.id:\\n reviewList.append(review)\\n return(reviewList)\",\n \"def dependent_prs(self):\\n comments = self.data['body'].replace('\\\\r\\\\n', ' ')\\n for comment in self.comments():\\n comments += comment['body'].replace('\\\\r\\\\n', ' ')\\n\\n dependent_prs = []\\n dependent_keywords = ['depends on']\\n for keyword in dependent_keywords:\\n pattern = r'%s %s/(\\\\S+)/(\\\\S+)/pull/(\\\\d+)' % (keyword, GITHUB)\\n LOGGER.info(\\\"Finding dependent PRs by '%s' in the comments\\\")\\n dependent_prs += re.findall(pattern, comments)\\n return set(dependent_prs)\",\n \"def task_reviews_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n reviews = Review.objects.filter(task=task).all()\\n serializer = ReviewSerializer(reviews, many=True)\\n return Response(serializer.data)\",\n \"def get_context_data(\\n self,\\n **kwargs,\\n ) -> Dict[str, Any]:\\n review_request = self.review_request\\n draft = review_request.get_draft(self.request.user)\\n\\n # We only want to show one label. If there's a draft, then that's\\n # the most important information, so we'll only show that. Otherwise,\\n # we'll show the submitted/discarded state.\\n label = None\\n\\n if draft:\\n label = ('review-request-infobox-label-draft', _('Draft'))\\n elif review_request.status == ReviewRequest.SUBMITTED:\\n label = ('review-request-infobox-label-submitted', _('Submitted'))\\n elif review_request.status == ReviewRequest.DISCARDED:\\n label = ('review-request-infobox-label-discarded', _('Discarded'))\\n\\n if label:\\n label = format_html('<label class=\\\"{0}\\\">{1}</label>', *label)\\n\\n # Fetch information on the reviews for this review request.\\n review_count = (\\n review_request.reviews\\n .filter(public=True, base_reply_to__isnull=True)\\n .count()\\n )\\n\\n # Fetch information on the draft for this review request.\\n diffset = None\\n\\n if draft and draft.diffset_id:\\n diffset = draft.diffset\\n\\n if not diffset and review_request.diffset_history_id:\\n try:\\n diffset = (\\n DiffSet.objects\\n .filter(history__pk=review_request.diffset_history_id)\\n .latest()\\n )\\n except DiffSet.DoesNotExist:\\n pass\\n\\n if diffset:\\n diff_url = '%s#index_header' % local_site_reverse(\\n 'view-diff-revision',\\n args=[review_request.display_id, diffset.revision],\\n local_site=review_request.local_site)\\n else:\\n diff_url = None\\n\\n return {\\n 'review_request': review_request,\\n 'review_request_label': label or '',\\n 'review_request_details': draft or review_request,\\n 'issue_total_count': (review_request.issue_open_count +\\n review_request.issue_resolved_count +\\n review_request.issue_dropped_count +\\n review_request.issue_verifying_count),\\n 'review_count': review_count,\\n 'diffset': diffset,\\n 'diff_url': diff_url,\\n }\",\n \"def test_get_dealer_reviews(self):\\n pass\",\n \"def getReviewNumbers(singleStoryFooter):\\n\\twords = singleStoryFooter.get_text()\\n\\treview = re.compile(r\\\"Reviews: \\\\d+\\\").search(words)\\n\\tif review:\\n\\t\\treviewNum = review.group()[9:]\\n\\t\\treturn int(reviewNum)\\n\\telse: return 0\",\n \"def _dependency_id(self):\\n if self._dependency_ids:\\n return self._dependency_ids[0]\",\n \"def save_draft(self, review_request):\\r\\n self.api_call('api/review-requests/%s/draft/save/' %\\r\\n review_request['id'])\\r\\n self.debug('Review request draft saved')\",\n \"def get_open_reviews(args):\\n args['status'] = 'pending'\\n if 'max_results' not in args:\\n args['max_results'] = 100\\n\\n client = RBClient(REVIEWBOARD_URL)\\n\\n # If we have a username and password, login\\n if REVIEWBOARD_USERNAME and REVIEWBOARD_PASSWORD:\\n client.login(REVIEWBOARD_USERNAME, REVIEWBOARD_PASSWORD)\\n\\n root = client.get_root()\\n\\n if not root:\\n logger.error(u'Could not get RBClient root')\\n return None\\n\\n try:\\n req = root.get_review_requests(**args)\\n except APIError:\\n logger.exception(u'Error querying API')\\n return None\\n\\n ret = {'total': req.total_results, 'reviews': []}\\n review_fmt = u\\\"[{user}] {summary} ({url}/r/{id})\\\"\\n\\n for review in req:\\n ret['reviews'].append(review_fmt.format(user=review.get_submitter().username,\\n summary=review.summary,\\n url=REVIEWBOARD_URL,\\n id=review.id))\\n\\n return ret\",\n \"def get_review(self, id_):\\n cursor = self._connection.cursor()\\n select_command = make_select_command(\\\"reviews\\\")\\n select_command += \\\" WHERE id_ = ?\\\"\\n cursor.execute(select_command, (id_,))\\n for row in cursor:\\n return expandable_from_tuple(row, FIELD_DESCRIPTIONS) \\n return None\",\n \"def dependent_ids(self) -> List[str]:\\n return list(map(as_text, self.connection.smembers(self.dependents_key)))\",\n \"def load_reviews(id_reviews=(), load_polarities=False, load_sentences=False, load_words=False, load_deptrees=False):\\n from loacore.conf import DB_TIMEOUT\\n reviews = []\\n conn = sql.connect(DB_PATH, timeout=DB_TIMEOUT)\\n c = conn.cursor()\\n if len(id_reviews) > 0:\\n for id_review in id_reviews:\\n c.execute(\\\"SELECT ID_Review, Review.ID_File, File_Index, Review \\\"\\n \\\"FROM Review WHERE ID_Review = \\\" + str(id_review) + \\\" ORDER BY File_Index\\\")\\n result = c.fetchone()\\n if result is not None:\\n reviews.append(Review(result[0], result[1], result[2], result[3]))\\n else:\\n c.execute(\\\"SELECT ID_Review, Review.ID_File, File_Index, Review FROM Review\\\")\\n results = c.fetchall()\\n for result in results:\\n reviews.append(Review(result[0], result[1], result[2], result[3]))\\n\\n conn.close()\\n\\n if load_polarities:\\n # Load Polarities\\n import loacore.load.polarity_load as polarity_load\\n polarity_load.load_polarities_in_reviews(reviews)\\n\\n if load_sentences:\\n # Load Sentences\\n import loacore.load.sentence_load as sentence_load\\n sentence_load.load_sentences_in_reviews(reviews, load_words=load_words, load_deptrees=load_deptrees)\\n\\n return reviews\",\n \"def get_reviews(place_id):\\n return get_all_cls(parent_cls, place_id, \\\"reviews\\\")\",\n \"def review_by_id(review_id):\\n obj = storage.get(\\\"Review\\\", review_id)\\n if obj is None:\\n abort(404)\\n return jsonify(obj.to_dict())\",\n \"def get_reviews(item_id, shop_id, review_num=10) -> list:\\n get_url = f\\\"{_shopee_base_url}/api/v2/item/get_ratings?filter=0&flag=1&itemid={item_id}&limit={review_num}&offset=0&shopid={shop_id}\\\"\\n r = requests.get(get_url, headers=_user_agent_header, proxies=proxy_dict)\\n ratings = r.json()['data']['ratings']\\n reviews = []\\n for rating in ratings:\\n reviews.append({\\n 'origin': 'Shopee',\\n 'author': rating['author_username'],\\n 'rating': rating['rating_star'],\\n 'review': rating['comment'], \\n 'review_likes': rating['like_count'],\\n 'summary': 'Summary is very nice. Amazing!'\\n })\\n return reviews\",\n \"def multiple(critic, parameters):\\n\\n review = jsonapi.v1.reviews.Reviews.deduce(critic, parameters)\\n return api.log.rebase.fetchAll(critic, review=review)\",\n \"def get_req_ids(actual_pose, target, req_ids, person_ids):\\n train_x = []\\n train_y = []\\n\\n for i in req_ids:\\n id_mask = (person_ids == i)\\n train_x.append(actual_pose[id_mask])\\n train_y.append(target[id_mask, 0])\\n\\n train_x = np.concatenate(train_x)\\n train_y = np.concatenate(train_y)\\n \\n return train_x, train_y\",\n \"def get_reviewers(ctx, tickets):\\n if ctx.options['--no-reviewer']:\\n return []\\n reviewers = ctx.options['--reviewer']\\n if ctx.pagure and not reviewers:\\n reviewers = set()\\n for ticket in tickets:\\n if ticket.reviewer:\\n reviewers.add(ticket.reviewer)\\n if len(reviewers) > 1:\\n print('Reviewers found: %s' % ', '.join(reviewers))\\n ctx.die('Too many reviewers found in ticket(s), '\\n 'specify --reviewer explicitly')\\n if not reviewers:\\n ctx.die('No reviewer found in ticket(s), '\\n 'specify --reviewer explicitly')\\n username_map = ctx.config.get('trac-username-map', {})\\n reviewers = [username_map.get(r, r) for r in reviewers]\\n if not reviewers:\\n ctx.die('No reviewer found, please specify --reviewer')\\n return [normalize_reviewer(ctx, r) for r in reviewers]\",\n \"def check_review_files(input, data_review):\\n if \\\"versions\\\" not in input:\\n return None\\n\\n input_version_ids = []\\n for v in input[\\\"versions\\\"]:\\n _, version_id = from_global_id(v)\\n input_version_ids.append(version_id)\\n\\n # Check all versions exist\\n versions = (\\n Version.objects.filter(pk__in=input_version_ids)\\n .select_related(\\\"root_file__study\\\")\\n .all()\\n )\\n if len(versions) != len(input[\\\"versions\\\"]):\\n raise GraphQLError(\\n \\\"Error in modifying data_review. All file versions in data \\\"\\n \\\"review must exist.\\\"\\n )\\n\\n # Check all versions come from same study\\n studies = set(\\n [v.root_file.study.pk for v in versions] + [data_review.study.pk]\\n )\\n if len(studies) > 1:\\n raise GraphQLError(\\n \\\"Error in modifying data_review. All file versions in data \\\"\\n \\\"review must have files that belong to the same study.\\\"\\n )\\n\\n # Check if data review file versions changed\\n if data_review:\\n if set(data_review.versions.values_list(\\\"pk\\\", flat=True)) == set(\\n input_version_ids\\n ):\\n input_version_ids = None\\n\\n return input_version_ids\",\n \"def reviews(self, **kwargs):\\n\\n path = self._get_movie_id_path('reviews')\\n resp = self._get_method(path, kwargs)\\n return resp\",\n \"def test_get_specific_review_sucess(self):\\n # Get the User's Auth Token.\\n url = '/api-token-auth/'\\n data = {'username': 'adam', 'password': '123'}\\n response = Client().post(url, data)\\n content = json.loads(response.content)\\n user_token = content['token']\\n\\n # Prepare the header with the client's token.\\n http_authorization = 'Token %s' % user_token\\n client = Client(HTTP_AUTHORIZATION=http_authorization)\\n\\n # GET the Reviews.\\n response = client.get('/reviews/1/')\\n self.assertEqual(response.status_code, 200)\\n\\n # Check if only reviews related to the user were retrieved.\\n content = json.loads(response.content)\\n expected = {\\n 'id': 1,\\n 'rating': 5,\\n 'title': 'Loved it!',\\n 'summary': 'I loved it! Pretty good!',\\n 'submission_date': '2020-10-12',\\n 'ip_address': '127.0.0.1',\\n 'reviewer': 1,\\n 'company': 1\\n }\\n self.assertDictEqual(content, expected)\",\n \"def process_reviews(reviews: list):\\n\\n def process_review(review, i, n):\\n print(f'\\\\rProcessing {i + 1} of {n} reviews', end='')\\n return nltk.pos_tag(nltk.word_tokenize(review[0].strip())), review[1]\\n\\n n = len(reviews)\\n processed = [process_review(review, i, n)\\n for i, review in enumerate(reviews)]\\n return processed\",\n \"def get_restaurant_reviews( self, restaurant_id, set_of_users ):\\n\\n\\t\\tcondition = ( ( self.df['business_id'] == restaurant_id ) & \\n\\t\\t\\t\\t\\t ( self.df['user_id'].isin(set_of_users) ) )\\n\\t\\treviews = self.df[condition]\\n\\n\\t\\t# remove for duplicated user id \\n\\t\\treviews[ reviews['user_id'].duplicated() == False ] \\n\\t\\treturn reviews\",\n \"def get_diffstats(review_request, user, rev=None):\\n # Ensure we're working with the base review request, not a draft.\\n review_request = review_request.get_review_request()\\n\\n if rev is None:\\n # If the user is the submitter we might want to use the draft diffset.\\n draft = review_request.get_draft(user=user)\\n diffset = ((draft and draft.diffset) or\\n review_request.get_latest_diffset())\\n else:\\n diffset = (\\n DiffSet.objects\\n .filter(history__pk=review_request.diffset_history_id)\\n .filter(revision=rev)).latest()\\n\\n return diffstats(diffset)\",\n \"def delete_review(review_id=None):\\n if review_id:\\n for item in storage.all(Review).values():\\n if review_id == item.id:\\n item.delete()\\n storage.save()\\n return (jsonify({}))\\n abort(404)\",\n \"def _get_current_reviewers_and_counts(project_name):\\n reviewer_change_count_per_project = current_load_fetcher.\\\\\\n get_open_change_reviewers_per_project()\\n\\n if project_name not in reviewer_change_count_per_project and \\\\\\n project_name != PROJECT_ALL:\\n logging.warning(\\\"Project %s does not have any current reviewers\\\",\\n project_name)\\n return []\\n\\n if project_name == PROJECT_ALL:\\n # go through all projects and combine open change counts for each\\n # reviewer\\n reviewers_changes_counts = \\\\\\n _get_current_change_counts_across_projects(\\n reviewer_change_count_per_project\\n )\\n else:\\n reviewers_changes_counts = \\\\\\n reviewer_change_count_per_project[project_name]\\n\\n return _create_reviewer_current_change_count_info(reviewers_changes_counts)\",\n \"def find_n_reviews(x, n, review_books_df):\\n asin_1 = x['asin_1']\\n asin_2 = x['asin_2']\\n\\n overall_reviews_1 = review_books_df.query('asin == @asin_1').sort_values(\\n 'unixReviewTime').iloc[0:(n+1)].overall.tolist()\\n overall_reviews_2 = review_books_df.query('asin == @asin_2').sort_values(\\n 'unixReviewTime').iloc[0:(n+1)].overall.tolist()\\n\\n dic_1 = {'asin': asin_1}\\n for i, val in enumerate(overall_reviews_1):\\n dic_1[str(i)+\\\"-th-review\\\"] = val\\n\\n dic_2 = {'asin': asin_2}\\n for i, val in enumerate(overall_reviews_2):\\n dic_2[str(i)+\\\"-th-review\\\"] = val\\n \\n return [dic_1, dic_2]\",\n \"def _get_approved_reviewers(self, pull_request_number: int) -> List[str]:\\n reviews = get_pull_request_reviews(\\n self._repo_name, pull_request_number, self._auth)\\n if not reviews:\\n return []\\n approved_reviewers = set()\\n for review in reviews:\\n if review['state'] == 'APPROVED':\\n if review['user']:\\n approved_reviewers.add(review['user']['login'])\\n else:\\n approved_reviewers.add(\\\"\\\")\\n return list(approved_reviewers)\",\n \"def GetId(self, request=[], default=None):\\n idd = False\\n \\n partName, partRev, _ = request\\n# partName, partRev, updateDate = request\\n# if updateDate:\\n# if partRev:\\n# criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev),\\n# ('write_date', '>', updateDate)]\\n# else:\\n# criteria=[('engineering_code', '=', partName), ('write_date', '>', updateDate)]\\n# else:\\n# if partRev:\\n# criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev)]\\n# else:\\n# criteria=[('engineering_code', '=', partName)]\\n if isinstance(partRev, int):\\n criteria=[('engineering_code', '=', partName), ('engineering_revision', '=', partRev)]\\n else:\\n criteria=[('engineering_code', '=', partName)]\\n\\n partIds = self.search(criteria, order='engineering_revision')\\n if len(partIds) > 0:\\n idd=partIds[len(partIds) - 1].id\\n return idd\",\n \"def reviews(self):\\n cts = storage.all(Review)\\n ltcts = []\\n for objects in cts.values():\\n if self.id == objects.state_id:\\n ltcts.append(objects)\\n return ltcts\",\n \"def get_review(review_id):\\n obj = storage.get(Review, review_id)\\n if obj is None:\\n abort(404)\\n return jsonify(obj.to_dict())\",\n \"def dependents_key(self):\\n return self.dependents_key_for(self.id)\",\n \"def run(self, __eatery_id):\\n self.start = time.time()\\n\\t \\n print __eatery_id\\n instance = ClassifyReviews([eatery_id])\\n instance.run()\\n #return group(callback.clone([arg, __eatery_id]) for arg in __review_list)()\",\n \"def department_reviews(request, department_code):\\n department = get_object_or_404(Department, code=department_code)\\n\\n topic_id_to_course = dict()\\n recent_courses = list(\\n Course.objects.filter(\\n course_filters_pcr_allow_xlist,\\n department=department,\\n )\\n .distinct()\\n .values(\\\"semester\\\", \\\"topic_id\\\", course_title=F(\\\"title\\\"), course_code=F(\\\"full_code\\\"))\\n )\\n for c in recent_courses:\\n c[\\\"exclude_from_recent\\\"] = True\\n topic_id = c[\\\"topic_id\\\"]\\n if (\\n topic_id not in topic_id_to_course\\n or topic_id_to_course[topic_id][\\\"semester\\\"] < c[\\\"semester\\\"]\\n ):\\n topic_id_to_course[topic_id] = c\\n\\n reviews = list(\\n review_averages(\\n Review.objects.filter(section__course__department=department),\\n reviewbit_subfilters=Q(review_id=OuterRef(\\\"id\\\")),\\n section_subfilters=Q(id=OuterRef(\\\"section_id\\\")),\\n fields=ALL_FIELD_SLUGS,\\n prefix=\\\"bit_\\\",\\n extra_metrics=True,\\n )\\n .annotate(\\n topic_id=F(\\\"section__course__topic_id\\\"),\\n semester=F(\\\"section__course__semester\\\"),\\n )\\n .values()\\n )\\n for review in reviews:\\n course = topic_id_to_course[review[\\\"topic_id\\\"]]\\n review[\\\"course_code\\\"] = course[\\\"course_code\\\"]\\n review[\\\"course_title\\\"] = course[\\\"course_title\\\"]\\n\\n all_courses = reviews + list(topic_id_to_course.values())\\n courses = aggregate_reviews(all_courses, \\\"course_code\\\", code=\\\"course_code\\\", name=\\\"course_title\\\")\\n\\n return Response({\\\"code\\\": department.code, \\\"name\\\": department.name, \\\"courses\\\": courses})\",\n \"def review_ask(request):\\n\\n result = {}\\n u = request.user\\n p = Product.objects.get_by_sku(request.POST['sku'])\\n\\n if p is None:\\n result[\\\"result\\\"] = '0'\\n\\n # change wish review request pending status\\n for w in Wishlist.objects.filter(product=p, party=u):\\n w.review = Wishlist.REVIEW_REQUESTED \\n w.save()\\n\\n req, created = ReviewRequest.objects.get_or_create(requester=u, product=p)\\n\\n # could replace above line with these lines if it causes trouble\\n #if not ReviewRequest.objects.filter(requester=u.party, product=p).exists():\\n # r = ReviewRequest(requester=u.party, product=p)\\n # r.save()\\n\\n # any previous reviews related to this request is linked\\n for rev in Review.objects.filter(product=p):\\n rev.reply_to.add(req)\\n\\n result['result'] = str(req.id)\\n\\n # add a feed\\n f = Feed(actor=u, action=Feed.REQUESTED, product=p) \\n f.save()\\n\\n # TODO: notify others that review requested\\n\\n return JSONHttpResponse(result)\",\n \"def find_data_breach_record_reviews(self, breach_id=None):\\n return self._request('/api/data-breach-record/'+str(breach_id)+'/reviews')\",\n \"def process_gen_reviews(self, gen_reviews):\\n clusters = []\\n reviews = []\\n for rev in gen_reviews:\\n label_delimiter = rev.find('>')\\n clusters.append(int(rev[5:label_delimiter]))\\n if rev[-1]=='>':\\n reviews.append(rev[label_delimiter+2:-6])\\n else:\\n reviews.append(rev[label_delimiter+2:])\\n\\n return clusters, reviews\",\n \"def test_create_with_new_draft(self):\\n user1 = User.objects.create(username='reviewer1')\\n user2 = User.objects.create(username='reviewer2')\\n\\n group1 = self.create_review_group(name='group1')\\n group2 = self.create_review_group(name='group2')\\n\\n dep_review_request_1 = self.create_review_request(publish=True)\\n dep_review_request_2 = self.create_review_request(publish=True)\\n\\n review_request = self.create_review_request(\\n publish=True,\\n bugs_closed='1,20,300',\\n commit_id='abc123',\\n description_rich_text=True,\\n depends_on=[dep_review_request_1, dep_review_request_2],\\n rich_text=True,\\n target_groups=[group1, group2],\\n target_people=[user1, user2],\\n testing_done_rich_text=True,\\n extra_data={\\n 'key': {\\n 'values': [1, 2, 3],\\n },\\n 'mybool': True,\\n })\\n\\n active_file_attachment_1 = self.create_file_attachment(review_request)\\n active_file_attachment_2 = self.create_file_attachment(review_request)\\n inactive_file_attachment = self.create_file_attachment(review_request,\\n active=False)\\n\\n active_screenshot_1 = self.create_screenshot(review_request)\\n active_screenshot_2 = self.create_screenshot(review_request)\\n inactive_screenshot = self.create_screenshot(review_request,\\n active=False)\\n\\n # Create the draft.\\n draft = ReviewRequestDraft.create(review_request)\\n\\n # Make sure all the fields are the same.\\n self.assertEqual(draft.branch, review_request.branch)\\n self.assertEqual(draft.bugs_closed, review_request.bugs_closed)\\n self.assertEqual(draft.commit_id, review_request.commit_id)\\n self.assertEqual(draft.description, review_request.description)\\n self.assertEqual(draft.description_rich_text,\\n review_request.description_rich_text)\\n self.assertEqual(draft.extra_data, review_request.extra_data)\\n self.assertEqual(draft.rich_text, review_request.rich_text)\\n self.assertEqual(draft.summary, review_request.summary)\\n self.assertEqual(draft.testing_done, review_request.testing_done)\\n self.assertEqual(draft.testing_done_rich_text,\\n review_request.testing_done_rich_text)\\n\\n self.assertEqual(list(draft.depends_on.order_by('pk')),\\n [dep_review_request_1, dep_review_request_2])\\n self.assertEqual(list(draft.target_groups.all()),\\n [group1, group2])\\n self.assertEqual(list(draft.target_people.all()),\\n [user1, user2])\\n self.assertEqual(list(draft.file_attachments.all()),\\n [active_file_attachment_1, active_file_attachment_2])\\n self.assertEqual(list(draft.inactive_file_attachments.all()),\\n [inactive_file_attachment])\\n self.assertEqual(list(draft.screenshots.all()),\\n [active_screenshot_1, active_screenshot_2])\\n self.assertEqual(list(draft.inactive_screenshots.all()),\\n [inactive_screenshot])\\n\\n self.assertIsNotNone(draft.changedesc)\",\n \"def _get_reviewers(project_name, from_datetime):\\n logging.debug(\\n \\\"Getting reviewers for project: %s from datetime: %r\\\",\\n project_name, from_datetime)\\n if project_name == PROJECT_ALL:\\n # reviewers with changes across all projects after from_datetime\\n reviewers = Reviewer.objects.filter(\\n changes__timestamp__gte=from_datetime).distinct()\\n else:\\n # reviewers with changes in given project after from_datetime\\n reviewers = Reviewer.objects.filter(\\n changes__project_name=project_name,\\n changes__timestamp__gte=from_datetime).distinct()\\n\\n logging.debug(\\\"Found reviewers: %r\\\", reviewers)\\n return reviewers\",\n \"def ids(self):\\n\\n if not hasattr(self, \\\"_ids\\\"):\\n query = db.Query(\\\"pub_proc_cg c\\\", \\\"c.id\\\").unique().order(\\\"c.id\\\")\\n query.join(\\\"query_term t\\\", \\\"t.doc_id = c.id\\\")\\n query.join(\\\"query_term s\\\", \\\"s.doc_id = t.int_val\\\")\\n query.where(\\\"t.path = '/Term/SemanticType/@cdr:ref'\\\")\\n query.where(\\\"s.path = '/Term/PreferredName'\\\")\\n query.where(\\\"s.value = 'Drug/agent'\\\")\\n rows = query.execute(self.cdr_cursor).fetchall()\\n self._ids = [row.id for row in rows]\\n self.logger.info(\\\"found %d drug terms\\\", len(self._ids))\\n return self._ids\",\n \"def get_recommendar(\\n\\treviews,\\n\\tuser_city,\\n\\trest_city,\\n\\trest_id_to_int,\\n\\tmodel=\\\"baseline\\\",\\n\\tk=TOP_K,\\n\\tremoveSeen=True,\\n\\tinfer_loc_by_latest_rating_only=True,\\n\\tlatest_rating_limiter=3\\n\\t):\\n\\treturn LocalRecommendar(\\n\\t\\treviews=reviews,\\n\\t\\tuser_city=user_city,\\n\\t\\trest_city=rest_city,\\n\\t\\trest_id_to_int=rest_id_to_int,\\n\\t\\tmodel=model,\\n\\t\\tk=k,\\n\\t\\tremoveSeen=removeSeen,\\n\\t\\tinfer_loc_by_latest_rating_only=infer_loc_by_latest_rating_only,\\n\\t\\tlatest_rating_limiter=latest_rating_limiter\\n\\t\\t)\",\n \"def _is_pull_request_reviewer_approved(querier, org, repo, pr_id):\\n query = \\\"\\\"\\\"\\n query($org:String!, $repo:String!, $pullRequestID:Int!){\\n repository(owner: $org, name: $repo){\\n protectedBranches(first: 100){\\n nodes{\\n name\\n requiredApprovingReviewCount\\n }\\n }\\n pullRequest(number: $pullRequestID){\\n baseRefName\\n reviews(last: 100){\\n nodes{\\n state\\n author{\\n login\\n }\\n }\\n }\\n }\\n }\\n }\\n \\\"\\\"\\\"\\n variables = {\\n \\\"pullRequestID\\\": pr_id,\\n \\\"org\\\": org,\\n \\\"repo\\\": repo,\\n }\\n\\n data = querier(query, variables)\\n\\n base_ref_name = jmespath.search(\\n \\\"data.repository.pullRequest.baseRefName\\\",\\n data\\n )\\n\\n required_approval_count = jmespath.search(\\n \\\"\\\"\\\"\\n data\\n .repository\\n .protectedBranches\\n .nodes[?name == '{branch}']\\n |[0]\\n .requiredApprovingReviewCount\\n \\\"\\\"\\\".format(branch=base_ref_name),\\n data\\n )\\n\\n review_history = jmespath.search(\\n \\\"\\\"\\\"\\n data\\n .repository\\n .pullRequest\\n .reviews\\n .nodes[*]\\n .{approver: author.login, state: state}\\n \\\"\\\"\\\",\\n data\\n )\\n reviews = {r[\\\"approver\\\"]: r[\\\"state\\\"] for r in review_history}\\n approval_count = reviews.values().count(\\\"APPROVED\\\")\\n\\n if required_approval_count and approval_count < required_approval_count:\\n is_approved = False\\n else:\\n is_approved = True\\n\\n return is_approved\",\n \"def get_project_ids(self, *criterion):\\n from wkcdd.models.helpers import get_project_ids\\n return get_project_ids([self.id], *criterion)\",\n \"def review_by_id(review_id):\\n review = storage.get(\\\"Review\\\", review_id)\\n if review is None:\\n abort(404)\\n return jsonify(review.to_json())\",\n \"def get_data_requests(self, request):\\n\\n not_reviewed_yet = Task.objects.filter(\\n Q(approver_email=request.user.email),\\n Q(state=Task.SUCCESS, review_output=True)\\n | Q(state=Task.ERROR, review_output=True),\\n ).order_by(\\\"-registered_on\\\")\\n\\n reviewed = Task.objects.filter(\\n Q(author_email=request.user.email),\\n Q(state=Task.RUNNING)\\n | Q(state=Task.OUTPUT_RELEASED)\\n | Q(state=Task.RELEASE_REJECTED)\\n | Q(state=Task.SUCCESS, review_output=False)\\n | Q(state=Task.ERROR, review_output=False),\\n ).order_by(\\\"-registered_on\\\")\\n\\n return Response(\\n {\\n \\\"not_reviewed_yet\\\": TaskSerializer(not_reviewed_yet, many=True).data,\\n \\\"reviewed\\\": TaskSerializer(reviewed, many=True).data,\\n }\\n )\",\n \"def get_playbook_run_ids(request1_body=None, **kwargs):\\n ############################ Custom Code Goes Below This Line #################################\\n import json\\n import phantom.rules as phantom\\n \\n outputs = {}\\n \\n for element in request1_body:\\n phantom.debug(element)\\n \\n # Write your custom code here...\\n \\n # Return a JSON-serializable object\\n assert json.dumps(outputs) # Will raise an exception if the :outputs: object is not JSON-serializable\\n return outputs\",\n \"def GetReviewers(host, change):\\n path = '%s/reviewers' % _GetChangePath(change)\\n return FetchUrlJson(host, path)\",\n \"def getDependenceIdAt(self, pos):\\n return self.sentence[pos].getDependenceId()\",\n \"def scraper(storyid, reviews_num, rate_limit=3):\\n\\n # There may be up to 15 reviews on a single page, therefore the number of\\n # pages the reviews are stored on is equal to the following:\\n number_of_pages = (reviews_num // 15) + 1\\n\\n # Returns a list of tuples (based on the contents of _reviews_in_table)\\n list_of_review_tuples = []\\n\\n for p in range(number_of_pages):\\n\\n soup = soupify('https://www.fanfiction.net/r/' + storyid +\\n '/0/' + str(p+1) + '/',\\n rate_limit=rate_limit)\\n\\n for review in _reviews_in_table(soup):\\n list_of_review_tuples.append(review)\\n\\n return list_of_review_tuples\",\n \"def get_review_comments_for_pr(owner, repo, pr_number, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def ballot_get_decisions_ids_by_contest(contest_id):\\r\\n return make_request({\\\"method\\\": \\\"ballot_get_decisions_by_contest\\\",\\r\\n \\\"params\\\": [contest_id],\\r\\n \\\"jsonrpc\\\": \\\"2.0\\\",\\r\\n \\\"id\\\": 0, })\",\n \"def review_list_handler():\\n def fetch_params():\\n release_group = Parser.uuid('uri', 'release_group', optional=True)\\n user_id = Parser.uuid('uri', 'user_id', optional=True)\\n sort = Parser.string('uri', 'sort', valid_values=['rating', 'created'], optional=True) or 'rating'\\n limit = Parser.int('uri', 'limit', min=1, max=50, optional=True) or 50\\n offset = Parser.int('uri', 'offset', optional=True) or 0\\n include = Parser.list('uri', 'inc', Review.allowed_includes, optional=True) or []\\n language = Parser.string('uri', 'language', min=2, max=3, optional=True)\\n if language and language not in supported_languages:\\n raise InvalidRequest(desc='Unsupported language')\\n return release_group, user_id, sort, limit, offset, include, language\\n release_group, user_id, sort, limit, offset, include, language = fetch_params()\\n reviews, count = Review.list(release_group, user_id, sort, limit, offset, language)\\n return jsonify(limit=limit, offset=offset, count=count,\\n reviews=[p.to_dict(include) for p in reviews])\",\n \"def reviews(self):\\n list_reviews = []\\n all_reviews = models.storage.all(Review)\\n for review_item in all_reviews.items():\\n if review_item.place_id == self.id:\\n list_review.append(review_item)\\n\\n return list_review\",\n \"def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\\n reviewers_mapping = {}\\n\\n # Reviewers are supposed to be those mentions who have given thumbs up.\\n for comment in issue_comments:\\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\\n reviewers_mapping[comment.user.login] = dict(\\n tagged_at=None,\\n responded_at=None,\\n gave_thumbs_up_at=comment.created_at\\n )\\n\\n # We have reviewers, now, look for the time for their first response in issue comments.\\n for comment in issue_comments:\\n if comment.user.login in reviewers_mapping.keys() \\\\\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n # TODO: Scrap the time when the PR's body was updated.\\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\\n # for the reviewers that are in PR's body.\\n\\n # Look for time when each of reviewer was tagged, this should be\\n # searched in pull request body and issue comments.\\n for login in reviewers_mapping.keys():\\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\\n if reviewers_mapping[login]['responded_at'] is None \\\\\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\\n reviewers_mapping[login]['tagged_at'] = comment.created_at\\n\\n # Check for reviewers' first response in review comments too, and\\n # update the reviewers_mapping if necessary.\\n for comment in review_comments:\\n if comment.user.login in reviewers_mapping.keys():\\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n return reviewers_mapping\",\n \"def test_get_ids(civic, main_data, updated_data):\\n assert len(civic._get_ids(main_data['assertions'])) == 0\\n assert len(civic._get_ids(main_data['variants'])) == 1\\n assert len(civic._get_ids(main_data['genes'])) == 2\\n assert len(civic._get_ids(main_data['evidence'])) == 1\\n\\n assert len(civic._get_ids(updated_data['assertions'])) == 1\\n assert len(civic._get_ids(updated_data['variants'])) == 1\\n assert len(civic._get_ids(updated_data['genes'])) == 1\\n assert len(civic._get_ids(updated_data['evidence'])) == 1\",\n \"def get_review(review_id=None):\\n\\n review = storage.get(Review, review_id)\\n if not review:\\n abort(404)\\n return jsonify(review.to_dict())\",\n \"def get_review(review_id):\\n review_obj = storage.get(Review, review_id)\\n if review_obj:\\n return jsonify(review_obj.to_dict())\\n else:\\n abort(404)\",\n \"def test_request_review(self):\\n other_pk = self.nodes[1].overlay.my_peer.public_key.key_to_bin()\\n self.nodes[0].overlay.request_review(1, other_pk)\\n yield self.deliver_messages()\\n\\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\\n self.assertTrue(pending_review_requests)\\n\\n self.nodes[1].overlay.respond_to_review_request(pending_review_requests[0].hash, True)\\n yield self.deliver_messages()\\n\\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\\n self.assertFalse(pending_review_requests)\\n self.assertEqual(self.nodes[0].overlay.trustchain.persistence.get_number_of_known_blocks(), 2)\",\n \"def _get_review_comments_body(\\n self, pull_request_number: int) -> List[Tuple[str, str]]:\\n review_comments = get_pull_request_review_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not review_comments:\\n return []\\n review_comments_msg = []\\n for comment in review_comments:\\n review_comments_msg.append((comment['path'], comment['body']))\\n return review_comments_msg\",\n \"def get_training_ids(mydb):\\n\\treturn list(mydb.fetch_table(table_name='training_set',field_names=['CaseId']).CaseId)\",\n \"def get_repo_review_comments(owner, repo, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def ballot_get_decisions_ids_by_voter(voter_id):\\r\\n return make_request({\\\"method\\\": \\\"ballot_get_decisions_by_voter\\\",\\r\\n \\\"params\\\": [voter_id],\\r\\n \\\"jsonrpc\\\": \\\"2.0\\\",\\r\\n \\\"id\\\": 0, })\",\n \"def review(args):\\n try:\\n pr = gh.get_pr(owner, repo, args.pull_request)\\n except requests.exceptions.HTTPError:\\n print('Couldn\\\\'t find pull request #%s in %s/%s.' %\\n (args.pull_request, owner, repo))\\n print('Make sure the number is correct and that you have read '\\n 'permissions for this GitHub repository.')\\n sys.exit(1)\\n\\n clone_url = pr['head']['repo']['clone_url']\\n fork_branch = pr['head']['ref']\\n fork_owner = pr['head']['repo']['owner']['login']\\n\\n repo_lib.fetch_fork(clone_url, fork_branch, fork_owner)\\n repo_lib.checkout(fork_branch, fork_owner)\\n sys.exit(0)\",\n \"def get_pred_ids(predictions):\\n le_classes = ['Emotet', 'Mirai', 'Zeus'] \\n malwares_dict = {'Emotet': 1, 'Mirai': 2, 'Zeus': 3}\\n predicted_ids = []\\n \\n for idx in predictions:\\n pred_name = le_classes[idx]\\n pred_id = malwares_dict[pred_name]\\n predicted_ids.append(pred_id)\\n \\n return predicted_ids\",\n \"def getRelevantPRData():\\n prInfoFromAPI = getPRsFromAPI()\\n diffHeader = headers.copy()\\n diffHeader['Accept'] = \\\"application/vnd.github.v3.diff\\\"\\n textForReviewPRs = []\\n\\n for PR in prInfoFromAPI:\\n labels = [label[\\\"name\\\"] for label in PR['labels']]\\n if \\\"Text for Review\\\" in labels:\\n diffResponse = requests.get(PR[\\\"url\\\"], headers=diffHeader)\\n diff = diffResponse.text\\n # Add the info the list\\n textForReviewPRs.append({\\n \\\"pull_request_link\\\": PR[\\\"html_url\\\"],\\n \\\"diff\\\": diff\\n })\\n if int(diffResponse.headers[\\\"X-RateLimit-Remaining\\\"]) <= 2:\\n print('GitHub api rate limit will be exceeded; the GITHUB_TOKEN env variable needs to be set.')\\n break\\n return textForReviewPRs\",\n \"def get_outputs(self, input_reviews):\\r\\n split_list = [1] * self.item_pad_num\\r\\n splitted_review_wordId_intputs = tf.split(input_reviews, split_list, 1)\\r\\n cnn_outputs = []\\r\\n for i in range(self.item_pad_num):\\r\\n input_review = tf.squeeze(splitted_review_wordId_intputs[i], [1])\\r\\n cnn_output = self.get_single_output(input_review=input_review, index=i)\\r\\n cnn_outputs.append(cnn_output)\\r\\n\\r\\n return cnn_outputs\",\n \"def get_possible_ids(self):\\n ids = []\\n\\n dest_data = requests.get(\\\"https://api.wdpro.disney.go.com/facility-service/destinations/{}\\\".format(self.__anc_dest_id), headers=getHeaders()).json()\\n data = requests.get(dest_data['links']['entertainmentVenues']['href'], headers=getHeaders()).json()\\n\\n for entry in data['entries']:\\n try:\\n ids.append(entry['links']['self']['href'].split('/')[-1].split('?')[0])\\n except:\\n pass\\n\\n return ids\",\n \"def get_dependent_objective_id_terms(self):\\n return # osid.search.terms.IdTerm\",\n \"def find_issue_id(self):\",\n \"def AllocateIds(self, request, context):\\n context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\",\n \"def offers_reviews_collection(request, task_id):\\n try:\\n task = Task.objects.get(id=task_id)\\n except Task.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == \\\"GET\\\":\\n offers = Offer.objects.filter(task=task).all()\\n taskers = offers.values_list(\\\"tasker\\\", flat=True)\\n reviews = Review.objects.filter(reviewee__id__in=taskers, task__assignee__isnull=False).all().order_by(\\\"-timestamp\\\")\\n serializer = ReviewSerializer(reviews, many=True)\\n return Response(serializer.data)\",\n \"def classify_review(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _get_playground_id(self):\\n\\n def playground_filter(page: int = 0):\\n return {\\\"filter\\\": {\\\"type\\\": [9], \\\"page\\\": page}}\\n\\n answer = self.client.search_investigations(filter=playground_filter())\\n if answer.total == 0:\\n raise RuntimeError(\\\"No playgrounds were detected in the environment.\\\")\\n elif answer.total == 1:\\n result = answer.data[0].id\\n else:\\n # if found more than one playground, try to filter to results against the current user\\n user_data, response, _ = self.client.generic_request(\\n path=\\\"/user\\\",\\n method=\\\"GET\\\",\\n content_type=\\\"application/json\\\",\\n response_type=object,\\n )\\n if response != 200:\\n raise RuntimeError(\\\"Cannot find username\\\")\\n username = user_data.get(\\\"username\\\")\\n\\n def filter_by_creating_user_id(playground):\\n return playground.creating_user_id == username\\n\\n playgrounds = list(filter(filter_by_creating_user_id, answer.data))\\n\\n for i in range(int((answer.total - 1) / len(answer.data))):\\n playgrounds.extend(\\n filter(\\n filter_by_creating_user_id,\\n self.client.search_investigations(\\n filter=playground_filter(i + 1)\\n ).data,\\n )\\n )\\n\\n if len(playgrounds) != 1:\\n raise RuntimeError(\\n f\\\"There is more than one playground to the user. \\\"\\n f\\\"Number of playgrounds is: {len(playgrounds)}\\\"\\n )\\n result = playgrounds[0].id\\n\\n logger.debug(f\\\"Playground ID: {result}\\\")\\n\\n return result\",\n \"def cron_partner_ids(self):\\n pass\",\n \"def review_entity_handler(review_id):\\n review = Review.query.get_or_404(str(review_id))\\n if review.is_archived is True:\\n raise NotFound\\n include = Parser.list('uri', 'inc', Review.allowed_includes, optional=True) or []\\n return jsonify(review=review.to_dict(include))\",\n \"def getREVIssues(db):\\n return map(trimmedREVDoc,\\n db.reviews.find({\\\"done\\\": False, \\\"lgtms\\\": {\\\"$exists\\\": False}}))\",\n \"def test_get_hidden_on_review_request(self) -> None:\\n self.assertTrue(self.action.get_visible(\\n context=self._create_request_context(\\n url_name='review-request-detail')))\",\n \"def open_request_review_modal(obj, selenium):\\n (_get_ui_service(selenium, obj).open_info_page_of_obj(obj).\\n open_submit_for_review_popup())\\n modal = request_review.RequestReviewModal(selenium)\\n modal.wait_until_present()\\n return modal\",\n \"def _get_information(self):\\n reviews = self._tab.find_all(\\\"div\\\", class_=\\\"review\\\", attrs={'itemprop': 'review'})\\n return [(self._get_review(elem), self._get_published_date(elem)) for elem in reviews]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57654417","0.5477173","0.5378847","0.5101541","0.5080031","0.4982286","0.49632528","0.49589026","0.49061635","0.48880798","0.488128","0.4835317","0.48325068","0.4829637","0.48200688","0.48102397","0.47959515","0.4773191","0.4731234","0.4722772","0.4721991","0.4713366","0.46949184","0.46884874","0.46866146","0.46725786","0.46725452","0.46543872","0.46502155","0.4646397","0.46461037","0.46435386","0.46341643","0.46335217","0.46236423","0.46070418","0.46060032","0.45929664","0.45798194","0.45728022","0.45700163","0.4569141","0.45608562","0.45533565","0.45463666","0.45317265","0.4530752","0.45104018","0.45101324","0.45082387","0.44920763","0.44887868","0.4481015","0.44685504","0.4463508","0.4462432","0.44607398","0.4441797","0.44417593","0.44281328","0.4424175","0.44237086","0.44235528","0.4421035","0.4409393","0.43953493","0.43803963","0.4375565","0.43721598","0.4366847","0.43590173","0.43555844","0.43555325","0.4352946","0.43527824","0.43464768","0.4342137","0.4321572","0.43209848","0.43180037","0.4312672","0.43121743","0.43095982","0.4305824","0.43053895","0.4302593","0.43010953","0.42956054","0.4294625","0.42868307","0.4284321","0.42836323","0.42808568","0.4280707","0.42761636","0.4276151","0.42601857","0.42575967","0.42550382","0.4253029"],"string":"[\n \"0.57654417\",\n \"0.5477173\",\n \"0.5378847\",\n \"0.5101541\",\n \"0.5080031\",\n \"0.4982286\",\n \"0.49632528\",\n \"0.49589026\",\n \"0.49061635\",\n \"0.48880798\",\n \"0.488128\",\n \"0.4835317\",\n \"0.48325068\",\n \"0.4829637\",\n \"0.48200688\",\n \"0.48102397\",\n \"0.47959515\",\n \"0.4773191\",\n \"0.4731234\",\n \"0.4722772\",\n \"0.4721991\",\n \"0.4713366\",\n \"0.46949184\",\n \"0.46884874\",\n \"0.46866146\",\n \"0.46725786\",\n \"0.46725452\",\n \"0.46543872\",\n \"0.46502155\",\n \"0.4646397\",\n \"0.46461037\",\n \"0.46435386\",\n \"0.46341643\",\n \"0.46335217\",\n \"0.46236423\",\n \"0.46070418\",\n \"0.46060032\",\n \"0.45929664\",\n \"0.45798194\",\n \"0.45728022\",\n \"0.45700163\",\n \"0.4569141\",\n \"0.45608562\",\n \"0.45533565\",\n \"0.45463666\",\n \"0.45317265\",\n \"0.4530752\",\n \"0.45104018\",\n \"0.45101324\",\n \"0.45082387\",\n \"0.44920763\",\n \"0.44887868\",\n \"0.4481015\",\n \"0.44685504\",\n \"0.4463508\",\n \"0.4462432\",\n \"0.44607398\",\n \"0.4441797\",\n \"0.44417593\",\n \"0.44281328\",\n \"0.4424175\",\n \"0.44237086\",\n \"0.44235528\",\n \"0.4421035\",\n \"0.4409393\",\n \"0.43953493\",\n \"0.43803963\",\n \"0.4375565\",\n \"0.43721598\",\n \"0.4366847\",\n \"0.43590173\",\n \"0.43555844\",\n \"0.43555325\",\n \"0.4352946\",\n \"0.43527824\",\n \"0.43464768\",\n \"0.4342137\",\n \"0.4321572\",\n \"0.43209848\",\n \"0.43180037\",\n \"0.4312672\",\n \"0.43121743\",\n \"0.43095982\",\n \"0.4305824\",\n \"0.43053895\",\n \"0.4302593\",\n \"0.43010953\",\n \"0.42956054\",\n \"0.4294625\",\n \"0.42868307\",\n \"0.4284321\",\n \"0.42836323\",\n \"0.42808568\",\n \"0.4280707\",\n \"0.42761636\",\n \"0.4276151\",\n \"0.42601857\",\n \"0.42575967\",\n \"0.42550382\",\n \"0.4253029\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6459412"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3397,"cells":{"query":{"kind":"string","value":"Initalize with a usersupplied list of segments."},"document":{"kind":"string","value":"def __init__(self, segments, lemma = None, case = None):\n self.segments = segments\n if isinstance(self.segments, str):\n self.segments = [Segment.new_segment(s) for s in self.segments]\n self.lemma = lemma\n self.case = case"},"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 construct_segments(self):\n for strand in self.strand_list:\n strand.construct_segment()","def set_segments(self, segments):\n self.send_command(Command.SET_SEGMENT_COUNT, [segments])","def form_segment(self, node_oid):\n # init empty segment and stuff\n new_segment = Segment()\n new_segment.save()\n name = \"%s_seg_%s\" % (self.PREFIX, new_segment.id)\n node = Node.objects(id=node_oid)[0]\n list_id = DripCampaign.objects(id=node[\"drip_campaign_id\"])[0][\"list_id\"]\n node.update(set__segment_oid=new_segment.id, set__updated_at=datetime.utcnow())\n\n # gather all users that apply for this node after triggers on previous nodes\n all_euids = set()\n if node[\"initial\"]:\n all_euids = set(List.objects(list_id=list_id)[0][\"members_euid\"])\n else:\n for trg in Trigger.objects(node_to=node_oid):\n for euids, to_node_oid in self.segment_by_triggers(trg[\"node_from\"]):\n if to_node_oid == node_oid:\n all_euids.update(set(euids))\n\n # # intersect euids with current state of the list\n # # it might be the case that some people are removed from the list since previous email\n self.fetch_members_for_list(list_id)\n all_euids = all_euids & set(List.objects(list_id=list_id)[0][\"members_euid\"])\n\n all_euids = list(all_euids)\n\n # apply the user list to segment n stuff\n # if user list is empty, save only meta info and don't actually work with mailchimp\n if all_euids:\n segment_id = self.mw.create_segment(list_id, name)\n self.mw.update_segment_members(list_id, segment_id, all_euids)\n else:\n segment_id = None\n new_segment.update(set__segment_id=segment_id, set__name=name, members_euid=all_euids,\n set__updated_at=datetime.utcnow())","def __load_segments(self):\r\n self.__segments = []\r\n if len(self.points) > 1:\r\n s = self.points[0]\r\n k = 1\r\n while k < len(self.points):\r\n e = self.points[k]\r\n self.__segments.append(Segment(s, e))\r\n s = e \r\n k += 1\r\n e = self.points[0]\r\n self.__segments.append(Segment(s, e))","def setSegments(self, segments):\n for point, segment in zip(self.points, segments):\n point.set(segment.p1)","def __init__(self, sets: List[ColdStartUserSet]):\n self.sets = sets","def __init__(self, segments, display_res=\"1920x1080\", stream_id=None):\n self.segments = segments\n self.display_res = display_res\n self.stream_id = stream_id\n self.o22 = []\n self.mode = None","def create_network_segments(self, tenant_id, network_id,\n network_name, segments):","def _setup_splits(self):\n #ntot = self.reredux_conf['nperfile']\n ntot = self.reredux_conf['Ngals']\n npersplit = self.runconf['nper']\n\n self.beglist, self.endlist = get_splits(ntot, npersplit)","def __init__(__self__, *,\n segment_name: Optional[pulumi.Input[str]] = None):\n if segment_name is not None:\n pulumi.set(__self__, \"segment_name\", segment_name)","def _trainBySegments(self, divisions, trainingSet):\n # train the subdomain ROMs\n counter, remainder = divisions\n roms = self._trainSubdomainROMs(self._templateROM, counter, trainingSet, self._romGlobalAdjustments)\n # if there were leftover domain segments that didn't go with the rest, train those now\n if remainder:\n unclusteredROMs = self._trainSubdomainROMs(self._templateROM, remainder, trainingSet, self._romGlobalAdjustments)\n roms = np.hstack([roms, unclusteredROMs])\n self._roms = roms","def __init__(self, segments='CCCVV', root_length=3):\n # residue should be at least 1 segment long\n assert(root_length < len(segments))\n\n self.segments = segments\n self.root_length = root_length\n self.residue_length = len(segments) - root_length","def __init__(self):\n super().__init__()\n self._points = 0\n self._segments = []\n self.fill_list()\n # i = random.randint(0, len(self._segments) - 1)\n # self.set_text(self._segments[i])\n self.reset()","def initialize_vasp_runs(self):\n\n\t\treference_polarization_path = self.get_extended_path('reference_polarization')\n\t\tdistorted_polarization_path = self.get_extended_path('distorted_polarization')\n\n\t\t#if not Path.exists(reference_polarization_path):\n\t\tself.create_new_vasp_run(reference_polarization_path, self.reference_structure)\n\n\t\t# if not Path.exists(distorted_polarization_path):\n\t\tself.create_new_vasp_run(distorted_polarization_path, self.distorted_structure)","def add_segments(self, *segments):\n for s in segments:\n self._add_one(s)","def prepareParrallelize(self,segs):\n\n angles = numpy.array([s.angle for s in segs ])\n angles[numpy.where(angles<0)] += _pi # we care about direction, not angle orientation\n clList = clusterValues(angles, 0.15, refScaleAbs='abs')\n\n for cl in clList:\n meanA = angles[list(cl)].mean()\n for i in cl:\n seg = segs[i]\n seg.newAngle = meanA if seg.angle>=0. else meanA-_pi","def __init__(self, path_list):\n self.path_list = path_list","def __init__(\n self,\n segments: Tuple[\"BaseSegment\", ...],\n # These are tuples of segments but we're expecting them to\n # be tuples of length 1. This is because we'll almost always\n # be doing tuple arithmetic with the results and constructing\n # 1-tuples on the fly is very easy to misread.\n start_bracket: Tuple[BaseSegment],\n end_bracket: Tuple[BaseSegment],\n pos_marker: Optional[PositionMarker] = None,\n uuid: Optional[UUID] = None,\n ):\n if not start_bracket or not end_bracket: # pragma: no cover\n raise ValueError(\n \"Attempted to construct Bracketed segment without specifying brackets.\"\n )\n self.start_bracket = start_bracket\n self.end_bracket = end_bracket\n super().__init__(segments=segments, pos_marker=pos_marker, uuid=uuid)","def __init__(self, focalPoint, focalDist, angles, segments):\n self.focalPoint = focalPoint\n self.focalDist = focalDist\n self.angles = angles\n self.segments = segments","def set_calculated_segments(self, total_lights, segments):\n self.set_segments(segments)\n self.set_lights_per_segment(int(total_lights / segments))","def __init__(self, tag: str, *elements: Union[str, List[str]]):\n if type(tag) != str:\n raise TypeError(\"'tag' argument must be a str\")\n if tag == \"\":\n raise ValueError(\"The tag of a segment must not be empty.\")\n self.tag = tag\n\n # The data elements for this segment.\n # this is converted to a list (due to the fact that python creates a tuple\n # when passing a variable arguments list to a method)\n self.elements = list(elements)","def __init__(self):\n self.s_sect = []","def __init__(self, name, ssn, address, courses=None):\n super().__init__(name, ssn, address)\n if courses is None:\n courses = []\n if courses == isinstance(courses, list):\n self.courses = courses\n else:\n self.courses = list(courses)","def initialize(self):\n self.path = []\n self.sectorClean = False","def __init__(self,numSegments,startX,startY):\n \n self.numSegments = numSegments\n\n # Construct the body\n self.body = []\n\n for i in range(numSegments):\n self.body.append([startX-i, startY])","def set_market_segments(self, segments):\r\n \"\"\"\r\n Q1-2. Implement this method, which takes an iterable of MarketSegments\r\n to which this Account will be attached. This method REPLACES all\r\n MarketSegment associations, so be sure to update each\r\n MarketSegment's internal representation of associated Accounts\r\n appropriately.\r\n \"\"\"\r\n for existing_segment in self._market_segments:\r\n # only need to remove the ones that aren't in the new list\r\n if existing_segment not in segments:\r\n existing_segment.remove_account(self)\r\n for segment in segments:\r\n # add segments, catch ValueErrors which means the segment was\r\n # already part of this account, therefor no followup action is\r\n # needed\r\n try:\r\n self._market_segments.append(segment)\r\n # add_ms_to_account needs to be False because we've already\r\n # added the segment to this account\r\n segment.add_account(self, add_ms_to_account=False)\r\n except ValueError:\r\n # this account was already associated to that segment,\r\n # continue on\r\n continue","def __init__(self, word_string, feature_table):\n self.word_string = word_string\n self.feature_table = feature_table\n self.segments = [Segment(char, self.feature_table) for char in self.word_string]","def segment(raw_sents:List[str], segment=\"jieba\") -> List[List[str]]:\n\t# segment_list = [\"pkuseg\", \"jieba\"]\n\t# if segment.strip() not in segment_list:\n\t# \treturn []\n\n\tseg_sents = []\n\tif segment == \"pkuseg\":\n\t\timport pkuseg\n\n\t\t## init the seg\n\t\tseg = pkuseg.pkuseg()\n\n\t\t## segment the sentence by pkuseg\n\t\tfor sent in raw_sents:\n\t\t\tres_seg = seg.cut(sent)\n\t\t\tseg_sents.append(res_seg)\n\t\t# print(seg_sents)\n\telif segment == \"jieba\":\n\t\timport jieba\n\t\tfor sent in raw_sents:\n\t\t\tres_seg = jieba.lcut(sent)\n\t\t\tsentence = \" \".join(res_seg)\n\t\t\tpattern4 = re.compile(\" +\", re.S)\n\t\t\tsentence = pattern4.sub(\" \", sentence)\n\t\t\tres_seg = sentence.split(\" \")\n\t\t\tseg_sents.append(res_seg)\n\n\treturn seg_sents","def test_getting_segments(self):\n pass","def populate_vertices(self, vertices_list):\n vertices = []\n for vertex in vertices_list:\n vertex_id = vertex[0]\n vertices.append(Vertex(vertex_id))\n self.vertices = vertices","def create_snake(self):\n for position in SNAKE_STARTING_POSITIONS:\n self.add_segment(position)","def __init__(self, N, S, students, leaders):\n self.N = N\n self.S = S\n self.G = int(math.ceil(N/S))\n self.partitions = []\n self.students = students\n self.leaders = leaders","def getsegs (bounds, split):\n segmentslist=bisect_rectange(split, bounds[0], bounds[1], bounds[2], bounds[3])\n count=1\n segpass=0\n \n #Get list of segment ids currently in database\n query=\"\"\"select seg_id from segment;\"\"\"\n df = pd.read_sql_query(query,con=engine)\n segids=set(df.seg_id)\n \n while count < len(segmentslist):\n try:\n for i in segmentslist:\n segments=getsegmentinfo(i)\n \n \n for seg in segments:\n #If running function several times for different splits, this ignores existing segments and prints a message\n if seg.id in segids: \n segpass+=1\n if (segpass % 10 == 0): \n print (\"{} segments already exist\".format(segpass))\n #Else this is a new segment, so get details from the strava and geocodio apis and save them to a dataframe and eventually to the database\n else:\n location = geocodio_client.reverse((seg.start_latlng[0], seg.start_latlng[1]))\n zipcode=location['results'][0]['address_components']['zip']\n \n newrow = {'seg_id' : seg.id,\n 'resource_state': seg.resource_state,\n 'climb_category':seg.climb_category,\n 'climb_category_desc':seg.climb_category_desc,\n 'average_grade':seg.avg_grade,\n 'elev_difference': str(seg.elev_difference).split()[0],\n 'distance': str(seg.distance).split()[0],\n 'name' : seg.name,\n 'start_lat' : seg.start_latlng[0],\n 'start_long' : seg.start_latlng[1],\n 'end_lat' : seg.end_latlng[0],\n 'end_long' : seg.end_latlng[1],\n 'points' : seg.points,\n 'starred':seg.starred,\n 'zipcode':zipcode\n }\n df=pd.DataFrame(newrow, index=[0])\n \n try:\n #Save dataframe to database\n df.to_sql('segment', engine,index=False,if_exists='append')\n except:\n pass\n\n #Prints message which keeps track of number of sub bounds completed \n if (count % 10) == 0:\n print (\"Getting segments in bound {} of {}\".format(count, len(segmentslist)))\n count+=1\n except Exception as inst:\n print (inst) \n return None","def __init__(self, *segments, **params):\n self.url = URL(*segments, **params)","def submitlist(jb, ls):\n segstart, segend = calculatestartend(ls) # Get the segment id for the current segment\n seg = None\n opp = None\n with jb.lock: # Lock the segments dictionary\n segments = jb.segments\n if segstart in segments:\n seg, opp = segments.pop(segstart, None)\n elif segend in segments:\n seg, opp = segments.pop(segend, None)\n if seg:\n segments.pop(opp)\n else:\n segments[segstart] = (ls, segend)\n segments[segend] = (ls, segstart)\n if seg:\n reqq.put((\"merge\", (ls, seg)), )","def new_segments_center_of_mass_set(self, segments_center_of_mass):\n if segments_center_of_mass.time.size != 1:\n raise IndexError(\"Segments center of mass should be from one frame only\")\n self.segments_center_of_mass = segments_center_of_mass\n\n # Remove previous actors from the scene\n for actor in self.segments_center_of_mass_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.segments_center_of_mass_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtk.vtkPoints()\n for i in range(segments_center_of_mass.channel.size):\n # Create a mapper\n mapper = vtkPolyDataMapper()\n\n # Create an actor\n self.segments_center_of_mass_actors.append(vtkActor())\n self.segments_center_of_mass_actors[i].SetMapper(mapper)\n\n self.parent_window.ren.AddActor(self.segments_center_of_mass_actors[i])\n\n # Update marker position\n self.update_segments_center_of_mass(self.segments_center_of_mass)","def __init__(__self__, *,\n domains: Optional[Sequence[str]] = None,\n verticals: Optional[Sequence[str]] = None):\n if domains is not None:\n pulumi.set(__self__, \"domains\", domains)\n if verticals is not None:\n pulumi.set(__self__, \"verticals\", verticals)","def initialize(self, keys: List[str]):","def create_from_bounds(self, lbs, ubs):\n self.base_vertices = (np.array([lbs])+np.array([ubs])).T/2\n self.base_vectors = np.diag((np.array(ubs)-np.array(lbs))/2)","def _trainBySegments(self, divisions, trainingSet):\n # subdivide domain and train subdomain ROMs, as with the segmentation\n ## TODO can we increase the inheritance more here, or is this the minimum cutset?\n counter, remainder = divisions\n # store delimiters\n if len(remainder):\n self.raiseADebug('\"{}\" division(s) are being excluded from clustering consideration.'.format(len(remainder)))\n ## train ROMs for each segment\n roms = self._trainSubdomainROMs(self._templateROM, counter, trainingSet, self._romGlobalAdjustments)\n # collect ROM features (basic stats, etc)\n clusterFeatures = self._gatherClusterFeatures(roms, counter, trainingSet)\n # future: requested metrics\n ## TODO someday\n # store clustering info, unweighted\n self._clusterInfo['features'] = {'unscaled': copy.deepcopy(clusterFeatures)}\n # weight and scale data\n ## create hierarchy for cluster params\n features = sorted(clusterFeatures.keys())\n hierarchFeatures = defaultdict(list)\n for feature in features:\n _, metric, ident = feature.split('|', 2)\n # the same identifier might show up for multiple targets\n if ident not in hierarchFeatures[metric]:\n hierarchFeatures[metric].append(ident)\n ## weighting strategy, TODO make optional for the user\n weightingStrategy = 'uniform'\n clusterFeatures = self._weightAndScaleClusters(features, hierarchFeatures, clusterFeatures, weightingStrategy)\n self._clusterInfo['features']['scaled'] = copy.deepcopy(clusterFeatures)\n # perform clustering\n labels = self._classifyROMs(self._divisionClassifier, features, clusterFeatures)\n uniqueLabels = sorted(list(set(labels))) # note: keep these ordered! Many things hinge on this.\n self.raiseAMessage('Identified {} clusters while training clustered ROM \"{}\".'.format(len(uniqueLabels), self._romName))\n # if there were some segments that won't compare well (e.g. leftovers), handle those separately\n if len(remainder):\n unclusteredROMs = self._trainSubdomainROMs(self._templateROM, remainder, trainingSet, self._romGlobalAdjustments)\n else:\n unclusteredROMs = []\n # make cluster information dict\n self._clusterInfo['labels'] = labels\n ## clustered\n self._clusterInfo['map'] = dict((label, roms[labels == label]) for label in uniqueLabels)\n ## unclustered\n self._clusterInfo['map']['unclustered'] = unclusteredROMs\n # TODO what about the unclustered ones? We throw them out in truncated representation, of necessity.\n self._roms = list(self._clusterInfo['map'][label][0] for label in uniqueLabels)","def onSegmentButton(self):\n markupsNode = slicer.mrmlScene.GetFirstNodeByName(\"MarkupsFiducial\")\n\n seedsFileName = self.fileNameSeedsLineEdit.text\n marginMask = int(self.marginMask.value)\n distance = int(self.distance.value)\n gamma = float(self.gammaSpinBox.value)\n regularizationDiameter = int(self.regularizationDiameter.value)\n minThreshold = int(self.minThresholdSlider.value)\n maxThreshold = int(self.maxThresholdSlider.value)\n \n self.markupsList = []\n if markupsNode != None:\n for i in range(markupsNode.GetNumberOfFiducials()):\n point_ras = [0, 0, 0]\n markupsNode.GetNthFiducialPosition(i, point_ras)\n name = markupsNode.GetNthFiducialLabel(i)\n label = int(markupsNode.GetNthControlPointDescription(i))\n self.markupsList.append([name, point_ras, label])\n \n if len(self.markupsList) == 0:\n fileName = self.seedsPath + self.fileNameSeedsLineEdit.text\n self.markupsList = self.loadMarkupsFromSeedFile(fileName)\n \n if len(self.markupsList) == 0:\n print(\"There is no fiducial markups !\")\n return\n \n self.logic.setGlobalPath(self.globalPath)\n self.logic.setSeedsFileName(seedsFileName)\n self.logic.setRemoveLastSegmentation(self.removeLastSegmentationCheckBox.isChecked())\n self.logic.setShowBackGround(self.showBackGroundCheckBox.isChecked())\n result = self.logic.run(self.inputSelector.currentNode(), self.labelColorsList, self.markupsList,\n marginMask, distance, gamma, regularizationDiameter, [minThreshold, maxThreshold])\n\n if result: # Run succeed\n # Set the segmentation file UI name with this seeds file name and the used paramaters\n segmentationFileName = getSegmentationFileName(seedsFileName, distance, gamma, marginMask, regularizationDiameter)\n self.saveSegmentationName.text = segmentationFileName \n self.outputVolume = result","def fillData(self):\n self.users = c.getUserNames()\n self.userlist.SetItems(self.users)","def __init__(self, name, ssn, address, courses_grades=None):\n super().__init__(name, ssn, address)\n if courses_grades is None:\n courses_grades = []\n if courses_grades == isinstance(courses_grades, list):\n self.courses_grades = courses_grades\n else:\n self.courses_grades = list(courses_grades)","def __init__(self):\n self._create_options()\n self._create_sections()","def __init__ (self, points):\n\n self.points = tuple (points)\n # maximum number of enitities in this mount\n self.amount = len (self.points)\n # list of all entities in this mount\n # indices correspond with self.points\n self.mounts = [None] * self.amount","def set_segments_to_value(arr, segments, value=0):\n for segment in segments:\n arr[segment[0]:segment[1]] = value","def __init__(self, name, accounts=None):\r\n self.name = name\r\n if accounts:\r\n self._accounts = accounts\r\n for account in accounts:\r\n # add_account_to_ms is False because we've already added the\r\n # account to this segment, don't want to do it again\r\n account.add_to_market_segment(self, add_account_to_ms=False)\r\n else:\r\n self._accounts = []\r\n check_for_existing_market_segment(self)","def __init__(self):\n segment_number = 2\n list_digits = 4\n super().__init__(4, segment_number, list_digits, default_val=\"0 \")\n self.set_credit(self.get_credit())","def __init__(self, name, hip, foot, *segments):\n super().__init__(name=name, joint=hip, appendage=foot, segments=segments)","def test_creating_a_new_segment(self):\n pass","def configure_segment(**kwargs):\n sessiontoken = kwargs['sessiontoken']\n proxy = kwargs['proxy']\n segment_name = kwargs[\"objectname\"]\n # Quick search to see if the segment exists of not.\n segment=search_nsx_json(proxy, sessiontoken, \"Segment\", segment_name)\n # If the segment exists, capture the path for the API call, and the existing configuration in JSON.\n if len(segment['results']) > 0:\n json_init=segment['results'][0]\n segment_path = segment['results'][0]['path']\n else:\n print(\"The segment does not exist. Please create a segment using 'new-segment'.\")\n sys.exit(1)\n # Establish a list of keys to keep - these represent the values we are willing/able to update.\n keep_list = ['display_name', 'connectivity_path', 'advanced_config', 'resource_type', 'subnets']\n # Construct a new JSON using just the keys we want to keep\n json_data = dict([(key, val) for key, val in \n json_init.items() if key in keep_list])\n # Update the json_data with the configuration specified by the user.\n if kwargs['connectivity'] is not None:\n json_data[\"advanced_config\"][\"connectivity\"] = f'{kwargs[\"connectivity\"]}'\n if kwargs['tier1_id'] is not None:\n if segment_path == \"/infra/tier-1s/cgw\":\n print(\"This is a fixed segment - you may not alter the connectivity path. Please create a 'flexible' segment.\")\n else:\n json_data[\"connectivity_path\"] = f'/infra/tier-1s/{kwargs[\"tier1_id\"]}'\n#\n # make the call to the API\n status = configure_segment_json(proxy, sessiontoken, segment_path, json_data)\n # present results.\n if status == 200:\n print(f'The following network has been modified: {segment_name}')\n vars = {\"proxy\":proxy, \"sessiontoken\":sessiontoken, \"object_type\":\"Segment\", \"object_id\":segment_name}\n search_nsx(**vars)\n else:\n print(\"The segment was not modified. Please check your syntax and try again.\")\n sys.exit(1)","def __init__(self, subsection_arch, subsection_id, server_range,\n serviced_passengers):\n self.server_list = self.init_server_list(subsection_arch,\n subsection_id,\n server_range,\n serviced_passengers)\n self.has_space_in_a_server_queue = True\n self.queue_size = 0\n self.min_queue = self.server_list[0]\n self.online_server_count = 0","def __init__(self, *points, width=1, color=colors.WHITE, conversion=True):\n if len(points) > 0: # Extracting the points arguments under the same list format\n if type(points[0]) == list:\n points = points[0]\n if len(points) == 1: points = points[0]\n if len(points) != 2: raise Exception(\"A segment must have 2 points.\")\n self.points = list(points)\n self.width = width\n self.color = color\n self.conversion = conversion","def __init__(self, *args):\n this = _ida_segment.new_lock_segment(*args)\n try: self.this.append(this)\n except: self.this = this","def __init__(\n self, user_message: str, yaml_path: str, segment: Optional[str] = None\n ) -> None:\n super().__init__(\n user_message=user_message, yaml_path=yaml_path, segment=segment)","def __init__(self, params):\r\n _params = {'Application': 'None',\r\n 'Algorithm':\r\n 'first: \"chooses first seq listed, corresponding to cluster seed for uclust\"',\r\n 'ChoiceF': first,\r\n 'ChoiceFRequiresSeqs': False\r\n }\r\n _params.update(params)\r\n RepSetPicker.__init__(self, _params)","def __init__(self, params):\r\n _params = {'Application': 'None',\r\n 'Algorithm':\r\n 'first: \"chooses first seq listed, corresponding to cluster seed for uclust\"',\r\n 'ChoiceF': first,\r\n 'ChoiceFRequiresSeqs': False\r\n }\r\n _params.update(params)\r\n RepSetPicker.__init__(self, _params)","def __init__(self, scn_line_list):\n self.scn_line_list = scn_line_list","def __init__(self):\n segment_number = 2\n list_digits = 3\n super().__init__(6, segment_number, list_digits, \"000000\")","def init_data(partitions_file):\n mapping = []\n\n drive_size = None\n for line in partitions_file:\n if drive_size is None:\n drive_size = parse_drive_size(line.rstrip())\n else:\n partitions_list = parse_partitions(line.rstrip())\n mapping.append((drive_size, partitions_list))\n drive_size = None\n\n return mapping","def __init__(self):\n segment_number = 2\n list_digits = 2\n super().__init__(6, segment_number, list_digits, \"000000\")","def get_segments(self):\n\t\tos.chdir(self.segment_path)\n\t\tfor path in glob.glob(\"%s/*.seg\" % self.segment_path):\n\t\t\t_file = os.path.split(path)[1]\n\t\t\tdae = DiscreetArchiveElement(self,_file,element_type='segment')\n\t\t\tself.elements.append(dae)\n\t\treturn True","def __init__(self, shared_list):\n self.shared_list = shared_list","def construct_sub_segment(self, start_frag_id, stop_frag_id):\n fragiter = iter_fragments(iter(self.fragment_list), start_frag_id, stop_frag_id)\n segment = self.construct_segment()\n for frag in fragiter:\n segment.add_fragment(frag, True)\n return segment","def new_segment(**kwargs):\n sessiontoken = kwargs['sessiontoken']\n proxy = kwargs['proxy']\n if kwargs['objectname'] is None or kwargs['gateway'] is None:\n print(\"Please specify a name for the segment, and the gateway/network.\")\n sys.exit(1)\n if kwargs['segment_type'] == \"flexible\" and kwargs['tier1_id'] is None:\n print(\"Please specify either the segment type as 'fixed' (-st fixed) OR segment type as 'flexible' as well as the ID of the Tier1 for connectivity (-t1id TIER1ID). Use pyVMC -h for additional options.\")\n sys.exit(1)\n if kwargs['segment_type'] == \"fixed\" and kwargs['tier1_id'] is not None:\n print(\"Invalid configuration - 'fixed' segments may only be connected to the default CGW. To attach to a customer Tier1, please create a 'flexible' segment.\")\n sys.exit(1)\n rt_set = [None, \"ROUTED\", \"DISCONNECTED\"]\n if kwargs['segment_type'] == \"fixed\" and kwargs['routing_type'] not in rt_set:\n print(\"Invalid configuration. For a 'fixed' segment, the routing type must be left blank or set explicitly to 'ROUTED' or 'DISCONNECTED.'\")\n sys.exit(1)\n\n segment_name = kwargs[\"objectname\"]\n gateway = kwargs['gateway']\n\n # Search for segment to determine if it already exists\n segment=search_nsx_json(proxy, sessiontoken, \"Segment\", segment_name)\n if len(segment['results']) > 0:\n print(\"The segment already appears to exist.\")\n sys.exit(1)\n\n\n # Establish baseline json payload\n json_data = {\n \"display_name\":segment_name,\n \"id\":segment_name,\n \"advanced_config\":{\"connectivity\":\"ON\"},\n \"subnets\":[\n {\n \"gateway_address\": gateway\n }\n ]\n }\n #set segment type as either \"fixed\" or \"flexible\"\n segment_type = kwargs['segment_type']\n tier1_id = kwargs['tier1_id']\n\n if segment_type == \"fixed\":\n json_data[\"connectivity_path\"] = \"/infra/tier-1s/cgw\"\n if kwargs['routing_type'] == \"DISCONNECTED\":\n json_data[\"advanced_config\"][\"connectivity\"] = \"OFF\"\n else:\n json_data[\"advanced_config\"][\"connectivity\"] = \"ON\"\n elif segment_type == \"flexible\" and tier1_id is not None:\n json_data[\"connectivity_path\"] = f'/infra/tier-1s/{tier1_id}'\n else:\n print(\"Please specify either the segment type as 'fixed' (-st fixed) OR segment type as 'flexible' as well as the ID of the Tier1 for connectivity (-t1id TIER1ID). Use pyVMC -h for additional options.\")\n if kwargs['dhcp_range'] is not None:\n json_data[\"subnets\"][0][\"dhcp_ranges\"] = [f'{kwargs[\"dhcp_range\"]}']\n if kwargs['domain_name'] is not None:\n json_data[\"domain_name\"] = kwargs[\"domain_name\"]\n\n print(json.dumps(json_data, indent = 2))\n\n status = new_segment_json(proxy, sessiontoken, segment_name, segment_type, json_data)\n if status == 200:\n print(f'The following network has been created: {segment_name}')\n vars = {\"proxy\":proxy, \"sessiontoken\":sessiontoken, \"object_type\":\"Segment\", \"object_id\":segment_name}\n search_nsx(**vars)\n else:\n print(\"The segment was not created. Please check your syntax and try again.\")\n sys.exit(1)","def __init__(self, coords, name=None):\n self.points = [\n Point(c[0], c[1], None if name is None else \"{}[{}]\".format(name, i))\n for i, c in enumerate(coords)\n ]\n self.line_segments = [\n LineSegment(p1, p2) for p1, p2 in zip(self.points[:-1], self.points[1:])\n ]\n self.line_segments.append(LineSegment(self.points[-1], self.points[0]))","def fill_list(self):\n for i in range(0, constants.STARTING_WORDS):\n random_word = constants.LIBRARY[random.randint(0, len(constants.LIBRARY) - 1)]\n x = random.randint(1, constants.MAX_X - len(self.get_text()))\n y = random.randint(1, constants.MAX_Y - len(self.get_text()))\n position = Point(x, y)\n self.set_position(position)\n velocity = Point(0, 1)\n self._add_segment(random_word, position, velocity)\n print()","def prepare_training_data(collection_of_positive_segments, collection_of_negative_segments):\n\n\n\tprint \"Preparing training data...\"\n\n\ttraining_vectors = []\n\ttraining_labels = []\n\n\n\tfor segment in collection_of_positive_segments.list_of_segments:\n\t\tvector = get_segment_feature_vector(segment)\n\n\t\ttraining_labels.append(\"Correct\")\n\t\ttraining_vectors.append(vector)\n\t\t\n\t\t\n\tfor segment in collection_of_negative_segments.list_of_segments:\n\t\tvector = get_segment_feature_vector(segment)\n\t\ttraining_labels.append(\"Incorrect\")\n\t\ttraining_vectors.append(vector)\n\t\t\n\t\n\ttraining_vectors = normalize_train_data(training_vectors)\n\t\n\t\t\n\t#data = VectorDataSet(training_vectors,L=training_labels)","def assign_actual(segments_path, training_path):\n pass","def parse_segments(self):\n segs = self.unixtext.split(\"$$\")\n for seg in segs:\n self.segments.append(TextProductSegment(seg, self))","def _set_out_segments(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGListType(\"outgoing_interface\",out_segments.out_segments, yang_name=\"out-segments\", rest_name=\"out-segments\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='outgoing-interface', extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}), is_container='list', yang_name=\"out-segments\", rest_name=\"out-segments\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-mpls-operational', defining_module='brocade-mpls-operational', yang_type='list', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"out_segments must be of a type compatible with list\"\"\",\n 'defined-type': \"list\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGListType(\"outgoing_interface\",out_segments.out_segments, yang_name=\"out-segments\", rest_name=\"out-segments\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='outgoing-interface', extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}), is_container='list', yang_name=\"out-segments\", rest_name=\"out-segments\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-mpls-operational', defining_module='brocade-mpls-operational', yang_type='list', is_config=False)\"\"\",\n })\n\n self.__out_segments = t\n if hasattr(self, '_set'):\n self._set()","def init(self):\n self.mrs = []\n if self.args.block_ctrl is not None:\n self.block_ctrl_list = self.args.block_ctrl.split(\",\")\n # Verify User input as per 0,1,2 format.\n if \"\" in self.block_ctrl_list:\n raise SALError(\"Invalid Input:[%s] to block controller \"\n \"arguments given to scripts!!!\"\n % (self.block_ctrl_list))\n else:\n self.block_ctrl_list = \"\"\n # Create MR instance for controller index using --ctrl input.\n self.mrs.append(create_mradapter(ctrl_index=self.args.ctrl))\n self.ctrl_cnt = self.mrs[0].cli.controller_count()\n for index in range(0, self.ctrl_cnt):\n # Check for Block controller list.\n if str(index) not in self.block_ctrl_list:\n # Check for --Ctrl index given as arg to script.\n if index != self.args.ctrl:\n self.log.info(\"Creating MR instance for Controller-%d\"\n % (index))\n self.mrs.append(create_mradapter(ctrl_index=index))\n else:\n self.log.info(\"*****TC will not execute on Blocked \"\n \"Controller-%d*****\" % (index))\n for mr in self.mrs:\n if not mr.is_mr():\n raise SALError(\"This script is applicable only for MR \"\n \"controller cards\")","def network_initialize(self, payments):\n for pt in payments:\n if pt.id1 not in self.users.keys():\n self.users[pt.id1] = set()\n if pt.id2 not in self.users.keys():\n self.users[pt.id2] = set()\n self.users[pt.id1].add(pt.id2)\n self.users[pt.id2].add(pt.id1)","def create_hltsv_segment(config_db, default_host, hltsv_host, sfos, hlt_segments):\n config_rules = config_db.getObject(\"ConfigurationRuleBundle\",\n \"DefaultConfigurationRuleBundle\")\n efio_config = config_db.getObject(\"EFIOConfiguration\", \"EFIO-Configuration-1\")\n hltsv_segment = dal.Segment(\"HLT\")\n defrc_controller = config_db.getObject(\"RunControlTemplateApplication\",\n \"DefRC\")\n hltsv_segment.IsControlledBy = defrc_controller\n hltsv_app = create_hltsv_app(config_db, hltsv_host)\n\n sfo_apps = []\n for index, sfo_host in zip(range(1, len(sfos)+1), sfos):\n sfo_application = create_sfo_application(config_db, str(index),\n sfo_host)\n sfo_apps.append(sfo_application)\n \n hltsv_resources = [hltsv_app] + sfo_apps\n hltsv_segment.Resources = hltsv_resources\n\n top_aggregator_app = create_aggregator_app(config_db, \"top_aggregator.py\",\n default_host)\n hltsv_segment.Applications = [top_aggregator_app]\n\n hltsv_segment.Hosts = [default_host]\n\n #infrastructure applications\n is_server = config_db.getObject(\"InfrastructureTemplateApplication\",\n \"DF_IS\")\n oh_server = config_db.getObject(\"InfrastructureTemplateApplication\",\n \"DF_Histogramming\")\n hltsv_segment.Infrastructure = [is_server, oh_server]\n \n #Resources\n mon_is = config_db.getObject(\"MIGApplication\", \"TopMIG-IS\")\n mon_oh = config_db.getObject(\"MIGApplication\", \"TopMIG-OH\")\n hltsv_segment.Resources.append(mon_is)\n hltsv_segment.Resources.append(mon_oh)\n\n hltsv_segment.Segments = hlt_segments\n \n return hltsv_segment","def initialize():\n\n with settings(prompts={'Password: ': 'test', 'Password (again): ': 'test'}):\n for user, group in USER_GROUPS:\n sudo(\"useradd %s -G %s,minv -g minv -N || true\" % (user, group))\n sudo(\"chmod g+rwx /home/%s\" % user)\n sudo('minv_ createuser %s -g %s' % (user, group), user=\"minv\")\n\n # upload script to create collections\n put(\n join(env.testdata_path, \"scripts/initial_collections.sh\"),\n \"\", mode=0755\n )\n sudo(\"cp initial_collections.sh /home/minv-app-administrator/\")\n\n # upload collection configs\n for conf in glob(join(env.testdata_path, \"configurations/*.conf\")):\n put(conf, \"\", mode=0444, use_sudo=True)\n sudo(\"cp %s /home/minv-app-administrator/\" % basename(conf))\n\n with cd(\"/home/minv-app-administrator/\"):\n sudo(\"chmod a+rx . *\")\n sudo(\n \"sh -l ./initial_collections.sh\",\n user=\"minv-app-administrator\"\n )","def __init__(self, users=()):\n self.users = {str(x.id): x for x in users}","def _cluster_segments_all_way(self, segmented_instances, labels, \\\n end_points, stats, cluster_thresh=0.5):\n\n #self.showme(segmented_instances, 'main img')\n segment_association_list = []\n max_num_end_points= 0\n\n # for each stem segment\n for i in range(0, len(labels)):\n # each end point in the current segment i\n if max_num_end_points < len(end_points[i]):\n max_num_end_points = len(end_points[i])\n for k in range(0, len(end_points[i])):\n angle_list=[]\n # find the segment that is most likely connected to segment i at end point[i][k]\n for j in range(0, len(labels)):\n # make sure we are not trying to connect the segment to itself\n if i!= j:\n # angle calculates the angle between the line stats['centroid'][i]-end_points[i][k]\n # and stats['centroid'][i]-stats['centroid'][j]\n\n angle = self._ang([stats['centroid'][i],end_points[i][k]], \\\n [stats['centroid'][i], stats['centroid'][j]] )\n # if the angle value is within the acceptable range of +/- angle_thresh\n if angle<=self.angle_thresh or angle>=360-self.angle_thresh:\n other_angle, other_seg_section, end_point_dist = self._get_best_fit(segmented_instances, \\\n len(labels), \\\n stats, end_points,\\\n i, j, k, pos_angle=angle<=self.angle_thresh)\n # if the best fit segment also has a small angle between its\n # end point-centroid line and centroid-centroid line,\n # add it to segments connected to segment i\n if other_angle!=None and other_angle<=self.angle_thresh:\n angle_list.append((j, other_seg_section, other_angle, end_point_dist, angle))\n #Sort the list of stem segments connected to i by end_point_dist\n angle_list = sorted(angle_list, key=lambda x:x[3])\n #Sorting by the Euclidian distance of the end_point_dist and the other_angle does not change end result\n #angle_list = sorted(angle_list, key=lambda x:(math.sqrt(x[3]**2.0+x[2]**2.0)))\n # the angle value reflects how far segment k is from the straight line\n # going through the centroids\n if len(angle_list)>0:\n # (i, j, k, l, angle between i and centroid line, angle between j and centroid line, distance between closest end points k in seg i and l in seg j)\n segment_association_list.append((i,angle_list[0][0],k, angle_list[0][1], angle_list[0][4], angle_list[0][2], angle_list[0][3]))\n\n\n # sort slope differences in an increasing order\n segment_association_list = sorted(segment_association_list,key=lambda x:(x[6]))\n\n # find best match by iteretively selecting the smallest difference\n # and adding it to the ith cluster\n cluster_list = []\n cluster = np.full(len(labels),None)\n colored_clusterImg = np.zeros(segmented_instances.shape).astype(np.uint8)\n #clusterImg = np.zeros(segmented_instances.shape).astype(np.uint8)\n\n # initialize cluster list to single clusters contianing only each individual segment\n for i in range(0, len(labels)):\n cluster[i]=i\n cluster_list.append([i])\n #self.showme(clusterImg, str(i))\n\n visited=np.full((len(labels),max_num_end_points), False)\n\n #cluster=np.frompyfunc(list,1,1)(cluster) # allows us to append to only the specified list end_points[i]\n new_cluster_num=0\n color_offset=len(labels)\n\n # for each pair of segments in our list of best fit segments\n for curr_tuple in segment_association_list:\n img = np.zeros(segmented_instances.shape)\n i = curr_tuple[0] # index of first segment\n j = curr_tuple[1] # index of second segment in the tuple\n i_section = curr_tuple[2] #end point number in segment i\n j_section = curr_tuple[3] #end point number in segment j\n angle = curr_tuple[4]\n other_angle = curr_tuple[5]\n end_point_dist = curr_tuple[6] #distance between the connecting end points of segments i and j\n img[segmented_instances== i]= 255\n img[segmented_instances== j]= 255\n if (visited[i][i_section]==False)and(visited[j][j_section]==False):\n #cv2.line(clusterImg,(end_points[i][i_section][0],end_points[i][i_section][1]),\\\n # (end_points[j][j_section][0], end_points[j][j_section][1]),150,2)\n #self.showme(clusterImg, str(i))\n visited[i][i_section]=True\n visited[j][j_section]=True\n cluster_num = cluster[i]\n if cluster[i]!=cluster[j]:\n other_cluster_num = cluster[j]\n cluster_list[cluster_num] = list(set(cluster_list[cluster_num]+\\\n copy.deepcopy(cluster_list[other_cluster_num])))\n # update cluster numbers for all segments moved into new cluster\n for seg in cluster_list[other_cluster_num]:\n cluster[seg]=cluster_num\n # update cluster numbers for clusters larger than cluster to be removed\n for idx in range(0, len(cluster)):\n if (cluster[idx]>other_cluster_num):\n cluster[idx]= cluster[idx]-1\n del cluster_list[other_cluster_num]\n\n\n #show clustered segments\n color = 0\n cluster_num = 0\n cluster_mask=[]\n\n for c in cluster_list:\n color = color+0.1\n cluster_mask.append(np.zeros(segmented_instances.shape).astype(np.uint8))\n\n for i in c:\n cluster_mask[cluster_num][(segmented_instances == labels[i])]=1\n colored_clusterImg[(segmented_instances == labels[i])]= int(color*255)\n \"\"\"if self.key in ['../data/images/image1672', '../data/images/image1289']:\n self.showme(colored_clusterImg)\"\"\"\n cluster_num +=1\n\n return cluster_mask, colored_clusterImg","def build_subsets(self):\n self.all = nrn.SectionList()\n self.all.wholetree(sec=self.soma)","def set_vendors(self, vendors_list):\n self.multiple_items_selection_from_kendo_dropdown(self.vendors_kendo_dropdown_locator, vendors_list)\n self.wait_for_ajax_spinner_load()","def setInitialized( initialized, ants, subarray=DEFAULT ):\n antlist = helpers.makeList(ants)\n multiSubarray('antennaInitialized', subarray, initialized, antlist )","def __init__(self, length=None, primary=None):\n if primary:\n self._primary_list = primary\n else:\n self._primary_list = [None] * length\n self._dot_bracket = None\n self._current_site = 0","def __init__(__self__, *,\n vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\n if vnet_subnet_ids is not None:\n pulumi.set(__self__, \"vnet_subnet_ids\", vnet_subnet_ids)","def __init__(self, uccsdslice, slice_index, angle_deg):\n super()\n # IMPLEMENTATION NOTE: This probably doesn't need to be a deepcopy since\n # the state is passed to seperate processes.\n self.uccsdslice = deepcopy(uccsdslice)\n self.slice_index = slice_index\n self.angle_deg = angle_deg\n self.angle = np.deg2rad(angle_deg)\n self.uccsdslice.update_angles([self.angle] * len(self.uccsdslice.angles))\n self.file_name = \"s{}_a{}\".format(slice_index, angle_deg)\n self.pulse_time = UCCSD_LIH_SLICE_TIMES[slice_index]\n self.lr = UCCSD_LIH_HYPERPARAMETERS[slice_index][\"lr\"]\n self.decay = UCCSD_LIH_HYPERPARAMETERS[slice_index][\"decay\"]","def make_segments(date_start=None, date_end=None, date_freq=None,\n n_series=3, n_segments=2, seg_sep=None,\n means=None, stds=None, trends=None,\n amplitudes=None, phases=None):\n assert isinstance(n_series, int)\n assert isinstance(n_segments, int) and n_segments >= 1\n # TODO\n pass","def __init__(self, pair_list=None):\n\n self.plugleads = []\n if pair_list is not None:\n self.add_many(pair_list)","def initDefaults(self):\n return _libsbml.LineSegment_initDefaults(self)","def _prepPointsForSegments(points):\n while 1:\n point = points[-1]\n if point.segmentType:\n break\n else:\n point = points.pop()\n points.insert(0, point)\n continue\n break","def __init__(self, substrates=None, products=None):\n self.substrates = substrates or []\n self.products = products or []","def init_managers(endpoints_file: Optional[Text]) -> None:","def __init__(self, station_file: str, ride_file: str) -> None:\n self.all_stations = create_stations(station_file)\n self.all_rides = create_rides(ride_file, self.all_stations)\n self.visualizer = Visualizer()\n self.active_rides = []","def init_subsections(self, customs_arch):\n section_list = []\n\n # Identify number of unique subsections in the server arcitecture.\n num_subsections = len(customs_arch['subsection'].unique())\n\n # Retrieve number of total servers and start an ID counter.\n num_servers = sum(customs_arch['max'])\n server_id = 1\n\n # Initialize each Subsection Class with a loop.\n for i in range(num_subsections):\n\n # Get the label of the subsection.\n subsection_id = customs_arch['subsection'].unique()[i]\n\n # Subset the master architecture into an architecture just for\n # for the subsection.\n subsection_arch = customs_arch[customs_arch['subsection'] == subsection_id]\n\n # Get server ID range.\n server_range = (server_id, server_id + subsection_arch.iloc[0]['max'])\n server_id = server_id + subsection_arch.iloc[0]['max']\n\n # Get the processed passenger queue from the Class Data Members list.\n serviced_passengers_list = self.outputs\n\n # Init a subsection and append to the list.\n section_list.append(Subsection(subsection_id,\n subsection_arch,\n server_range,\n serviced_passengers_list))\n\n return section_list","def region_setup(self, slices, ipa_regions):\n self.ipa_regions = ipa_regions\n self.slices = slices","def init_server_list(self, subsection_arch, subsection_id, server_range,\n output_list):\n\n # Init a list of servers to return.\n rtn = []\n\n # Loop through all servers in the arch.\n for i in range(server_range[0], server_range[1]):\n\n # Pass the ID of the server and Init a server.\n rtn.append(ServiceAgent(str(i), subsection_id, output_list))\n\n # Return the list.\n return rtn","def __init__(self, list: List[DiagramView], start_button: StartButtonView):\n super().__init__()\n\n self.__init_ui(list, start_button)","def setUserIDRefs( self, text ):\n self.user_id_list= text.split()","def __init__(self, contact_loader):\n self.contacts_by_group_list = contact_loader.contacts_by_group_list\n self.contact_list = None","def update_nets_with_segments(pcb_data: List[Dict[str, Any]], nets: List[Net]):\n segments = get_all_dicts_by_key(pcb_data, 'segment')\n for segment in segments:\n start: Coords = get_dict_by_key(segment['segment'], 'start')['start']\n start[1] = str(-1*float(start[1]))\n end: Coords = get_dict_by_key(segment['segment'], 'end')['end']\n end[1] = str(-1 * float(end[1]))\n width: str = get_dict_by_key(segment['segment'], 'width')['width']\n layer_data: str = get_dict_by_key(segment['segment'], 'layer')['layer']\n layers: List[Layer] = convert_to_layers(layer_data)\n new_segment: Segment = Segment(start=start, end=end, width=width, layers=layers)\n net_id: str = get_dict_by_key(segment['segment'], 'net')['net']\n for net in nets:\n if float(net.net_id) == float(net_id):\n net.segments.append(new_segment)","def setPUsers(self, users):\n model = self.tvPUsers.get_model()\n model.clear()\n for user in users:\n model.append((user,))\n\n self.on_entPUser_changed(self.entPUser)\n self.on_tvPUsers_cursor_changed(self.tvPUsers)","def __init__(self):\n self.g_sect = []","def segment(args):\n from jcvi.formats.base import SetFile\n\n p = OptionParser(segment.__doc__)\n p.add_option(\n \"--chain\",\n default=1,\n type=\"int\",\n help=\"Allow next N genes to be chained\",\n )\n opts, args = p.parse_args(args)\n\n if len(args) != 2:\n sys.exit(not p.print_help())\n\n idsfile, bedfile = args\n bed = Bed(bedfile)\n order = bed.order\n ids = SetFile(idsfile)\n losses = Grouper()\n skip = opts.chain\n for i, a in enumerate(bed):\n a = a.accn\n for j in range(i + 1, i + 1 + skip):\n if j >= len(bed):\n break\n b = bed[j].accn\n if a in ids:\n losses.join(a, a)\n if a in ids and b in ids:\n losses.join(a, b)\n\n losses = list(losses)\n singletons = [x for x in losses if len(x) == 1]\n segments = [x for x in losses if len(x) > 1]\n ns, nm, nt = len(singletons), len(segments), len(losses)\n assert ns + nm == nt\n\n # Summary for all segments\n for x in sorted(singletons) + sorted(segments):\n print(\n \"\\t\".join(\n str(x)\n for x in (\"|\".join(sorted(x)), len(x), estimate_size(x, bed, order))\n )\n )\n\n # Find longest segment stretch\n if segments:\n mx, maxsegment = max([(len(x), x) for x in segments])\n print(\"Longest stretch: run of {0} genes\".format(mx), file=sys.stderr)\n print(\" {0}\".format(\"|\".join(sorted(maxsegment))), file=sys.stderr)\n seg_asize = sum(estimate_size(x, bed, order) for x in segments)\n seg_bsize = sum(\n estimate_size(x, bed, order, conservative=False) for x in segments\n )\n else:\n seg_asize = seg_bsize = 0\n\n sing_asize = sum(estimate_size(x, bed, order) for x in singletons)\n sing_bsize = sum(\n estimate_size(x, bed, order, conservative=False) for x in singletons\n )\n total_asize = sing_asize + seg_asize\n total_bsize = sing_bsize + seg_bsize\n print(\n \"Singleton ({0}): {1} - {2} bp\".format(ns, sing_asize, sing_bsize),\n file=sys.stderr,\n )\n print(\n \"Segment ({0}): {1} - {2} bp\".format(nm, seg_asize, seg_bsize), file=sys.stderr\n )\n print(\n \"Total ({0}): {1} - {2} bp\".format(nt, total_asize, total_bsize),\n file=sys.stderr,\n )\n print(\n \"Average ({0}): {1} bp\".format(nt, (total_asize + total_bsize) / 2),\n file=sys.stderr,\n )"],"string":"[\n \"def construct_segments(self):\\n for strand in self.strand_list:\\n strand.construct_segment()\",\n \"def set_segments(self, segments):\\n self.send_command(Command.SET_SEGMENT_COUNT, [segments])\",\n \"def form_segment(self, node_oid):\\n # init empty segment and stuff\\n new_segment = Segment()\\n new_segment.save()\\n name = \\\"%s_seg_%s\\\" % (self.PREFIX, new_segment.id)\\n node = Node.objects(id=node_oid)[0]\\n list_id = DripCampaign.objects(id=node[\\\"drip_campaign_id\\\"])[0][\\\"list_id\\\"]\\n node.update(set__segment_oid=new_segment.id, set__updated_at=datetime.utcnow())\\n\\n # gather all users that apply for this node after triggers on previous nodes\\n all_euids = set()\\n if node[\\\"initial\\\"]:\\n all_euids = set(List.objects(list_id=list_id)[0][\\\"members_euid\\\"])\\n else:\\n for trg in Trigger.objects(node_to=node_oid):\\n for euids, to_node_oid in self.segment_by_triggers(trg[\\\"node_from\\\"]):\\n if to_node_oid == node_oid:\\n all_euids.update(set(euids))\\n\\n # # intersect euids with current state of the list\\n # # it might be the case that some people are removed from the list since previous email\\n self.fetch_members_for_list(list_id)\\n all_euids = all_euids & set(List.objects(list_id=list_id)[0][\\\"members_euid\\\"])\\n\\n all_euids = list(all_euids)\\n\\n # apply the user list to segment n stuff\\n # if user list is empty, save only meta info and don't actually work with mailchimp\\n if all_euids:\\n segment_id = self.mw.create_segment(list_id, name)\\n self.mw.update_segment_members(list_id, segment_id, all_euids)\\n else:\\n segment_id = None\\n new_segment.update(set__segment_id=segment_id, set__name=name, members_euid=all_euids,\\n set__updated_at=datetime.utcnow())\",\n \"def __load_segments(self):\\r\\n self.__segments = []\\r\\n if len(self.points) > 1:\\r\\n s = self.points[0]\\r\\n k = 1\\r\\n while k < len(self.points):\\r\\n e = self.points[k]\\r\\n self.__segments.append(Segment(s, e))\\r\\n s = e \\r\\n k += 1\\r\\n e = self.points[0]\\r\\n self.__segments.append(Segment(s, e))\",\n \"def setSegments(self, segments):\\n for point, segment in zip(self.points, segments):\\n point.set(segment.p1)\",\n \"def __init__(self, sets: List[ColdStartUserSet]):\\n self.sets = sets\",\n \"def __init__(self, segments, display_res=\\\"1920x1080\\\", stream_id=None):\\n self.segments = segments\\n self.display_res = display_res\\n self.stream_id = stream_id\\n self.o22 = []\\n self.mode = None\",\n \"def create_network_segments(self, tenant_id, network_id,\\n network_name, segments):\",\n \"def _setup_splits(self):\\n #ntot = self.reredux_conf['nperfile']\\n ntot = self.reredux_conf['Ngals']\\n npersplit = self.runconf['nper']\\n\\n self.beglist, self.endlist = get_splits(ntot, npersplit)\",\n \"def __init__(__self__, *,\\n segment_name: Optional[pulumi.Input[str]] = None):\\n if segment_name is not None:\\n pulumi.set(__self__, \\\"segment_name\\\", segment_name)\",\n \"def _trainBySegments(self, divisions, trainingSet):\\n # train the subdomain ROMs\\n counter, remainder = divisions\\n roms = self._trainSubdomainROMs(self._templateROM, counter, trainingSet, self._romGlobalAdjustments)\\n # if there were leftover domain segments that didn't go with the rest, train those now\\n if remainder:\\n unclusteredROMs = self._trainSubdomainROMs(self._templateROM, remainder, trainingSet, self._romGlobalAdjustments)\\n roms = np.hstack([roms, unclusteredROMs])\\n self._roms = roms\",\n \"def __init__(self, segments='CCCVV', root_length=3):\\n # residue should be at least 1 segment long\\n assert(root_length < len(segments))\\n\\n self.segments = segments\\n self.root_length = root_length\\n self.residue_length = len(segments) - root_length\",\n \"def __init__(self):\\n super().__init__()\\n self._points = 0\\n self._segments = []\\n self.fill_list()\\n # i = random.randint(0, len(self._segments) - 1)\\n # self.set_text(self._segments[i])\\n self.reset()\",\n \"def initialize_vasp_runs(self):\\n\\n\\t\\treference_polarization_path = self.get_extended_path('reference_polarization')\\n\\t\\tdistorted_polarization_path = self.get_extended_path('distorted_polarization')\\n\\n\\t\\t#if not Path.exists(reference_polarization_path):\\n\\t\\tself.create_new_vasp_run(reference_polarization_path, self.reference_structure)\\n\\n\\t\\t# if not Path.exists(distorted_polarization_path):\\n\\t\\tself.create_new_vasp_run(distorted_polarization_path, self.distorted_structure)\",\n \"def add_segments(self, *segments):\\n for s in segments:\\n self._add_one(s)\",\n \"def prepareParrallelize(self,segs):\\n\\n angles = numpy.array([s.angle for s in segs ])\\n angles[numpy.where(angles<0)] += _pi # we care about direction, not angle orientation\\n clList = clusterValues(angles, 0.15, refScaleAbs='abs')\\n\\n for cl in clList:\\n meanA = angles[list(cl)].mean()\\n for i in cl:\\n seg = segs[i]\\n seg.newAngle = meanA if seg.angle>=0. else meanA-_pi\",\n \"def __init__(self, path_list):\\n self.path_list = path_list\",\n \"def __init__(\\n self,\\n segments: Tuple[\\\"BaseSegment\\\", ...],\\n # These are tuples of segments but we're expecting them to\\n # be tuples of length 1. This is because we'll almost always\\n # be doing tuple arithmetic with the results and constructing\\n # 1-tuples on the fly is very easy to misread.\\n start_bracket: Tuple[BaseSegment],\\n end_bracket: Tuple[BaseSegment],\\n pos_marker: Optional[PositionMarker] = None,\\n uuid: Optional[UUID] = None,\\n ):\\n if not start_bracket or not end_bracket: # pragma: no cover\\n raise ValueError(\\n \\\"Attempted to construct Bracketed segment without specifying brackets.\\\"\\n )\\n self.start_bracket = start_bracket\\n self.end_bracket = end_bracket\\n super().__init__(segments=segments, pos_marker=pos_marker, uuid=uuid)\",\n \"def __init__(self, focalPoint, focalDist, angles, segments):\\n self.focalPoint = focalPoint\\n self.focalDist = focalDist\\n self.angles = angles\\n self.segments = segments\",\n \"def set_calculated_segments(self, total_lights, segments):\\n self.set_segments(segments)\\n self.set_lights_per_segment(int(total_lights / segments))\",\n \"def __init__(self, tag: str, *elements: Union[str, List[str]]):\\n if type(tag) != str:\\n raise TypeError(\\\"'tag' argument must be a str\\\")\\n if tag == \\\"\\\":\\n raise ValueError(\\\"The tag of a segment must not be empty.\\\")\\n self.tag = tag\\n\\n # The data elements for this segment.\\n # this is converted to a list (due to the fact that python creates a tuple\\n # when passing a variable arguments list to a method)\\n self.elements = list(elements)\",\n \"def __init__(self):\\n self.s_sect = []\",\n \"def __init__(self, name, ssn, address, courses=None):\\n super().__init__(name, ssn, address)\\n if courses is None:\\n courses = []\\n if courses == isinstance(courses, list):\\n self.courses = courses\\n else:\\n self.courses = list(courses)\",\n \"def initialize(self):\\n self.path = []\\n self.sectorClean = False\",\n \"def __init__(self,numSegments,startX,startY):\\n \\n self.numSegments = numSegments\\n\\n # Construct the body\\n self.body = []\\n\\n for i in range(numSegments):\\n self.body.append([startX-i, startY])\",\n \"def set_market_segments(self, segments):\\r\\n \\\"\\\"\\\"\\r\\n Q1-2. Implement this method, which takes an iterable of MarketSegments\\r\\n to which this Account will be attached. This method REPLACES all\\r\\n MarketSegment associations, so be sure to update each\\r\\n MarketSegment's internal representation of associated Accounts\\r\\n appropriately.\\r\\n \\\"\\\"\\\"\\r\\n for existing_segment in self._market_segments:\\r\\n # only need to remove the ones that aren't in the new list\\r\\n if existing_segment not in segments:\\r\\n existing_segment.remove_account(self)\\r\\n for segment in segments:\\r\\n # add segments, catch ValueErrors which means the segment was\\r\\n # already part of this account, therefor no followup action is\\r\\n # needed\\r\\n try:\\r\\n self._market_segments.append(segment)\\r\\n # add_ms_to_account needs to be False because we've already\\r\\n # added the segment to this account\\r\\n segment.add_account(self, add_ms_to_account=False)\\r\\n except ValueError:\\r\\n # this account was already associated to that segment,\\r\\n # continue on\\r\\n continue\",\n \"def __init__(self, word_string, feature_table):\\n self.word_string = word_string\\n self.feature_table = feature_table\\n self.segments = [Segment(char, self.feature_table) for char in self.word_string]\",\n \"def segment(raw_sents:List[str], segment=\\\"jieba\\\") -> List[List[str]]:\\n\\t# segment_list = [\\\"pkuseg\\\", \\\"jieba\\\"]\\n\\t# if segment.strip() not in segment_list:\\n\\t# \\treturn []\\n\\n\\tseg_sents = []\\n\\tif segment == \\\"pkuseg\\\":\\n\\t\\timport pkuseg\\n\\n\\t\\t## init the seg\\n\\t\\tseg = pkuseg.pkuseg()\\n\\n\\t\\t## segment the sentence by pkuseg\\n\\t\\tfor sent in raw_sents:\\n\\t\\t\\tres_seg = seg.cut(sent)\\n\\t\\t\\tseg_sents.append(res_seg)\\n\\t\\t# print(seg_sents)\\n\\telif segment == \\\"jieba\\\":\\n\\t\\timport jieba\\n\\t\\tfor sent in raw_sents:\\n\\t\\t\\tres_seg = jieba.lcut(sent)\\n\\t\\t\\tsentence = \\\" \\\".join(res_seg)\\n\\t\\t\\tpattern4 = re.compile(\\\" +\\\", re.S)\\n\\t\\t\\tsentence = pattern4.sub(\\\" \\\", sentence)\\n\\t\\t\\tres_seg = sentence.split(\\\" \\\")\\n\\t\\t\\tseg_sents.append(res_seg)\\n\\n\\treturn seg_sents\",\n \"def test_getting_segments(self):\\n pass\",\n \"def populate_vertices(self, vertices_list):\\n vertices = []\\n for vertex in vertices_list:\\n vertex_id = vertex[0]\\n vertices.append(Vertex(vertex_id))\\n self.vertices = vertices\",\n \"def create_snake(self):\\n for position in SNAKE_STARTING_POSITIONS:\\n self.add_segment(position)\",\n \"def __init__(self, N, S, students, leaders):\\n self.N = N\\n self.S = S\\n self.G = int(math.ceil(N/S))\\n self.partitions = []\\n self.students = students\\n self.leaders = leaders\",\n \"def getsegs (bounds, split):\\n segmentslist=bisect_rectange(split, bounds[0], bounds[1], bounds[2], bounds[3])\\n count=1\\n segpass=0\\n \\n #Get list of segment ids currently in database\\n query=\\\"\\\"\\\"select seg_id from segment;\\\"\\\"\\\"\\n df = pd.read_sql_query(query,con=engine)\\n segids=set(df.seg_id)\\n \\n while count < len(segmentslist):\\n try:\\n for i in segmentslist:\\n segments=getsegmentinfo(i)\\n \\n \\n for seg in segments:\\n #If running function several times for different splits, this ignores existing segments and prints a message\\n if seg.id in segids: \\n segpass+=1\\n if (segpass % 10 == 0): \\n print (\\\"{} segments already exist\\\".format(segpass))\\n #Else this is a new segment, so get details from the strava and geocodio apis and save them to a dataframe and eventually to the database\\n else:\\n location = geocodio_client.reverse((seg.start_latlng[0], seg.start_latlng[1]))\\n zipcode=location['results'][0]['address_components']['zip']\\n \\n newrow = {'seg_id' : seg.id,\\n 'resource_state': seg.resource_state,\\n 'climb_category':seg.climb_category,\\n 'climb_category_desc':seg.climb_category_desc,\\n 'average_grade':seg.avg_grade,\\n 'elev_difference': str(seg.elev_difference).split()[0],\\n 'distance': str(seg.distance).split()[0],\\n 'name' : seg.name,\\n 'start_lat' : seg.start_latlng[0],\\n 'start_long' : seg.start_latlng[1],\\n 'end_lat' : seg.end_latlng[0],\\n 'end_long' : seg.end_latlng[1],\\n 'points' : seg.points,\\n 'starred':seg.starred,\\n 'zipcode':zipcode\\n }\\n df=pd.DataFrame(newrow, index=[0])\\n \\n try:\\n #Save dataframe to database\\n df.to_sql('segment', engine,index=False,if_exists='append')\\n except:\\n pass\\n\\n #Prints message which keeps track of number of sub bounds completed \\n if (count % 10) == 0:\\n print (\\\"Getting segments in bound {} of {}\\\".format(count, len(segmentslist)))\\n count+=1\\n except Exception as inst:\\n print (inst) \\n return None\",\n \"def __init__(self, *segments, **params):\\n self.url = URL(*segments, **params)\",\n \"def submitlist(jb, ls):\\n segstart, segend = calculatestartend(ls) # Get the segment id for the current segment\\n seg = None\\n opp = None\\n with jb.lock: # Lock the segments dictionary\\n segments = jb.segments\\n if segstart in segments:\\n seg, opp = segments.pop(segstart, None)\\n elif segend in segments:\\n seg, opp = segments.pop(segend, None)\\n if seg:\\n segments.pop(opp)\\n else:\\n segments[segstart] = (ls, segend)\\n segments[segend] = (ls, segstart)\\n if seg:\\n reqq.put((\\\"merge\\\", (ls, seg)), )\",\n \"def new_segments_center_of_mass_set(self, segments_center_of_mass):\\n if segments_center_of_mass.time.size != 1:\\n raise IndexError(\\\"Segments center of mass should be from one frame only\\\")\\n self.segments_center_of_mass = segments_center_of_mass\\n\\n # Remove previous actors from the scene\\n for actor in self.segments_center_of_mass_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.segments_center_of_mass_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtk.vtkPoints()\\n for i in range(segments_center_of_mass.channel.size):\\n # Create a mapper\\n mapper = vtkPolyDataMapper()\\n\\n # Create an actor\\n self.segments_center_of_mass_actors.append(vtkActor())\\n self.segments_center_of_mass_actors[i].SetMapper(mapper)\\n\\n self.parent_window.ren.AddActor(self.segments_center_of_mass_actors[i])\\n\\n # Update marker position\\n self.update_segments_center_of_mass(self.segments_center_of_mass)\",\n \"def __init__(__self__, *,\\n domains: Optional[Sequence[str]] = None,\\n verticals: Optional[Sequence[str]] = None):\\n if domains is not None:\\n pulumi.set(__self__, \\\"domains\\\", domains)\\n if verticals is not None:\\n pulumi.set(__self__, \\\"verticals\\\", verticals)\",\n \"def initialize(self, keys: List[str]):\",\n \"def create_from_bounds(self, lbs, ubs):\\n self.base_vertices = (np.array([lbs])+np.array([ubs])).T/2\\n self.base_vectors = np.diag((np.array(ubs)-np.array(lbs))/2)\",\n \"def _trainBySegments(self, divisions, trainingSet):\\n # subdivide domain and train subdomain ROMs, as with the segmentation\\n ## TODO can we increase the inheritance more here, or is this the minimum cutset?\\n counter, remainder = divisions\\n # store delimiters\\n if len(remainder):\\n self.raiseADebug('\\\"{}\\\" division(s) are being excluded from clustering consideration.'.format(len(remainder)))\\n ## train ROMs for each segment\\n roms = self._trainSubdomainROMs(self._templateROM, counter, trainingSet, self._romGlobalAdjustments)\\n # collect ROM features (basic stats, etc)\\n clusterFeatures = self._gatherClusterFeatures(roms, counter, trainingSet)\\n # future: requested metrics\\n ## TODO someday\\n # store clustering info, unweighted\\n self._clusterInfo['features'] = {'unscaled': copy.deepcopy(clusterFeatures)}\\n # weight and scale data\\n ## create hierarchy for cluster params\\n features = sorted(clusterFeatures.keys())\\n hierarchFeatures = defaultdict(list)\\n for feature in features:\\n _, metric, ident = feature.split('|', 2)\\n # the same identifier might show up for multiple targets\\n if ident not in hierarchFeatures[metric]:\\n hierarchFeatures[metric].append(ident)\\n ## weighting strategy, TODO make optional for the user\\n weightingStrategy = 'uniform'\\n clusterFeatures = self._weightAndScaleClusters(features, hierarchFeatures, clusterFeatures, weightingStrategy)\\n self._clusterInfo['features']['scaled'] = copy.deepcopy(clusterFeatures)\\n # perform clustering\\n labels = self._classifyROMs(self._divisionClassifier, features, clusterFeatures)\\n uniqueLabels = sorted(list(set(labels))) # note: keep these ordered! Many things hinge on this.\\n self.raiseAMessage('Identified {} clusters while training clustered ROM \\\"{}\\\".'.format(len(uniqueLabels), self._romName))\\n # if there were some segments that won't compare well (e.g. leftovers), handle those separately\\n if len(remainder):\\n unclusteredROMs = self._trainSubdomainROMs(self._templateROM, remainder, trainingSet, self._romGlobalAdjustments)\\n else:\\n unclusteredROMs = []\\n # make cluster information dict\\n self._clusterInfo['labels'] = labels\\n ## clustered\\n self._clusterInfo['map'] = dict((label, roms[labels == label]) for label in uniqueLabels)\\n ## unclustered\\n self._clusterInfo['map']['unclustered'] = unclusteredROMs\\n # TODO what about the unclustered ones? We throw them out in truncated representation, of necessity.\\n self._roms = list(self._clusterInfo['map'][label][0] for label in uniqueLabels)\",\n \"def onSegmentButton(self):\\n markupsNode = slicer.mrmlScene.GetFirstNodeByName(\\\"MarkupsFiducial\\\")\\n\\n seedsFileName = self.fileNameSeedsLineEdit.text\\n marginMask = int(self.marginMask.value)\\n distance = int(self.distance.value)\\n gamma = float(self.gammaSpinBox.value)\\n regularizationDiameter = int(self.regularizationDiameter.value)\\n minThreshold = int(self.minThresholdSlider.value)\\n maxThreshold = int(self.maxThresholdSlider.value)\\n \\n self.markupsList = []\\n if markupsNode != None:\\n for i in range(markupsNode.GetNumberOfFiducials()):\\n point_ras = [0, 0, 0]\\n markupsNode.GetNthFiducialPosition(i, point_ras)\\n name = markupsNode.GetNthFiducialLabel(i)\\n label = int(markupsNode.GetNthControlPointDescription(i))\\n self.markupsList.append([name, point_ras, label])\\n \\n if len(self.markupsList) == 0:\\n fileName = self.seedsPath + self.fileNameSeedsLineEdit.text\\n self.markupsList = self.loadMarkupsFromSeedFile(fileName)\\n \\n if len(self.markupsList) == 0:\\n print(\\\"There is no fiducial markups !\\\")\\n return\\n \\n self.logic.setGlobalPath(self.globalPath)\\n self.logic.setSeedsFileName(seedsFileName)\\n self.logic.setRemoveLastSegmentation(self.removeLastSegmentationCheckBox.isChecked())\\n self.logic.setShowBackGround(self.showBackGroundCheckBox.isChecked())\\n result = self.logic.run(self.inputSelector.currentNode(), self.labelColorsList, self.markupsList,\\n marginMask, distance, gamma, regularizationDiameter, [minThreshold, maxThreshold])\\n\\n if result: # Run succeed\\n # Set the segmentation file UI name with this seeds file name and the used paramaters\\n segmentationFileName = getSegmentationFileName(seedsFileName, distance, gamma, marginMask, regularizationDiameter)\\n self.saveSegmentationName.text = segmentationFileName \\n self.outputVolume = result\",\n \"def fillData(self):\\n self.users = c.getUserNames()\\n self.userlist.SetItems(self.users)\",\n \"def __init__(self, name, ssn, address, courses_grades=None):\\n super().__init__(name, ssn, address)\\n if courses_grades is None:\\n courses_grades = []\\n if courses_grades == isinstance(courses_grades, list):\\n self.courses_grades = courses_grades\\n else:\\n self.courses_grades = list(courses_grades)\",\n \"def __init__(self):\\n self._create_options()\\n self._create_sections()\",\n \"def __init__ (self, points):\\n\\n self.points = tuple (points)\\n # maximum number of enitities in this mount\\n self.amount = len (self.points)\\n # list of all entities in this mount\\n # indices correspond with self.points\\n self.mounts = [None] * self.amount\",\n \"def set_segments_to_value(arr, segments, value=0):\\n for segment in segments:\\n arr[segment[0]:segment[1]] = value\",\n \"def __init__(self, name, accounts=None):\\r\\n self.name = name\\r\\n if accounts:\\r\\n self._accounts = accounts\\r\\n for account in accounts:\\r\\n # add_account_to_ms is False because we've already added the\\r\\n # account to this segment, don't want to do it again\\r\\n account.add_to_market_segment(self, add_account_to_ms=False)\\r\\n else:\\r\\n self._accounts = []\\r\\n check_for_existing_market_segment(self)\",\n \"def __init__(self):\\n segment_number = 2\\n list_digits = 4\\n super().__init__(4, segment_number, list_digits, default_val=\\\"0 \\\")\\n self.set_credit(self.get_credit())\",\n \"def __init__(self, name, hip, foot, *segments):\\n super().__init__(name=name, joint=hip, appendage=foot, segments=segments)\",\n \"def test_creating_a_new_segment(self):\\n pass\",\n \"def configure_segment(**kwargs):\\n sessiontoken = kwargs['sessiontoken']\\n proxy = kwargs['proxy']\\n segment_name = kwargs[\\\"objectname\\\"]\\n # Quick search to see if the segment exists of not.\\n segment=search_nsx_json(proxy, sessiontoken, \\\"Segment\\\", segment_name)\\n # If the segment exists, capture the path for the API call, and the existing configuration in JSON.\\n if len(segment['results']) > 0:\\n json_init=segment['results'][0]\\n segment_path = segment['results'][0]['path']\\n else:\\n print(\\\"The segment does not exist. Please create a segment using 'new-segment'.\\\")\\n sys.exit(1)\\n # Establish a list of keys to keep - these represent the values we are willing/able to update.\\n keep_list = ['display_name', 'connectivity_path', 'advanced_config', 'resource_type', 'subnets']\\n # Construct a new JSON using just the keys we want to keep\\n json_data = dict([(key, val) for key, val in \\n json_init.items() if key in keep_list])\\n # Update the json_data with the configuration specified by the user.\\n if kwargs['connectivity'] is not None:\\n json_data[\\\"advanced_config\\\"][\\\"connectivity\\\"] = f'{kwargs[\\\"connectivity\\\"]}'\\n if kwargs['tier1_id'] is not None:\\n if segment_path == \\\"/infra/tier-1s/cgw\\\":\\n print(\\\"This is a fixed segment - you may not alter the connectivity path. Please create a 'flexible' segment.\\\")\\n else:\\n json_data[\\\"connectivity_path\\\"] = f'/infra/tier-1s/{kwargs[\\\"tier1_id\\\"]}'\\n#\\n # make the call to the API\\n status = configure_segment_json(proxy, sessiontoken, segment_path, json_data)\\n # present results.\\n if status == 200:\\n print(f'The following network has been modified: {segment_name}')\\n vars = {\\\"proxy\\\":proxy, \\\"sessiontoken\\\":sessiontoken, \\\"object_type\\\":\\\"Segment\\\", \\\"object_id\\\":segment_name}\\n search_nsx(**vars)\\n else:\\n print(\\\"The segment was not modified. Please check your syntax and try again.\\\")\\n sys.exit(1)\",\n \"def __init__(self, subsection_arch, subsection_id, server_range,\\n serviced_passengers):\\n self.server_list = self.init_server_list(subsection_arch,\\n subsection_id,\\n server_range,\\n serviced_passengers)\\n self.has_space_in_a_server_queue = True\\n self.queue_size = 0\\n self.min_queue = self.server_list[0]\\n self.online_server_count = 0\",\n \"def __init__(self, *points, width=1, color=colors.WHITE, conversion=True):\\n if len(points) > 0: # Extracting the points arguments under the same list format\\n if type(points[0]) == list:\\n points = points[0]\\n if len(points) == 1: points = points[0]\\n if len(points) != 2: raise Exception(\\\"A segment must have 2 points.\\\")\\n self.points = list(points)\\n self.width = width\\n self.color = color\\n self.conversion = conversion\",\n \"def __init__(self, *args):\\n this = _ida_segment.new_lock_segment(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def __init__(\\n self, user_message: str, yaml_path: str, segment: Optional[str] = None\\n ) -> None:\\n super().__init__(\\n user_message=user_message, yaml_path=yaml_path, segment=segment)\",\n \"def __init__(self, params):\\r\\n _params = {'Application': 'None',\\r\\n 'Algorithm':\\r\\n 'first: \\\"chooses first seq listed, corresponding to cluster seed for uclust\\\"',\\r\\n 'ChoiceF': first,\\r\\n 'ChoiceFRequiresSeqs': False\\r\\n }\\r\\n _params.update(params)\\r\\n RepSetPicker.__init__(self, _params)\",\n \"def __init__(self, params):\\r\\n _params = {'Application': 'None',\\r\\n 'Algorithm':\\r\\n 'first: \\\"chooses first seq listed, corresponding to cluster seed for uclust\\\"',\\r\\n 'ChoiceF': first,\\r\\n 'ChoiceFRequiresSeqs': False\\r\\n }\\r\\n _params.update(params)\\r\\n RepSetPicker.__init__(self, _params)\",\n \"def __init__(self, scn_line_list):\\n self.scn_line_list = scn_line_list\",\n \"def __init__(self):\\n segment_number = 2\\n list_digits = 3\\n super().__init__(6, segment_number, list_digits, \\\"000000\\\")\",\n \"def init_data(partitions_file):\\n mapping = []\\n\\n drive_size = None\\n for line in partitions_file:\\n if drive_size is None:\\n drive_size = parse_drive_size(line.rstrip())\\n else:\\n partitions_list = parse_partitions(line.rstrip())\\n mapping.append((drive_size, partitions_list))\\n drive_size = None\\n\\n return mapping\",\n \"def __init__(self):\\n segment_number = 2\\n list_digits = 2\\n super().__init__(6, segment_number, list_digits, \\\"000000\\\")\",\n \"def get_segments(self):\\n\\t\\tos.chdir(self.segment_path)\\n\\t\\tfor path in glob.glob(\\\"%s/*.seg\\\" % self.segment_path):\\n\\t\\t\\t_file = os.path.split(path)[1]\\n\\t\\t\\tdae = DiscreetArchiveElement(self,_file,element_type='segment')\\n\\t\\t\\tself.elements.append(dae)\\n\\t\\treturn True\",\n \"def __init__(self, shared_list):\\n self.shared_list = shared_list\",\n \"def construct_sub_segment(self, start_frag_id, stop_frag_id):\\n fragiter = iter_fragments(iter(self.fragment_list), start_frag_id, stop_frag_id)\\n segment = self.construct_segment()\\n for frag in fragiter:\\n segment.add_fragment(frag, True)\\n return segment\",\n \"def new_segment(**kwargs):\\n sessiontoken = kwargs['sessiontoken']\\n proxy = kwargs['proxy']\\n if kwargs['objectname'] is None or kwargs['gateway'] is None:\\n print(\\\"Please specify a name for the segment, and the gateway/network.\\\")\\n sys.exit(1)\\n if kwargs['segment_type'] == \\\"flexible\\\" and kwargs['tier1_id'] is None:\\n print(\\\"Please specify either the segment type as 'fixed' (-st fixed) OR segment type as 'flexible' as well as the ID of the Tier1 for connectivity (-t1id TIER1ID). Use pyVMC -h for additional options.\\\")\\n sys.exit(1)\\n if kwargs['segment_type'] == \\\"fixed\\\" and kwargs['tier1_id'] is not None:\\n print(\\\"Invalid configuration - 'fixed' segments may only be connected to the default CGW. To attach to a customer Tier1, please create a 'flexible' segment.\\\")\\n sys.exit(1)\\n rt_set = [None, \\\"ROUTED\\\", \\\"DISCONNECTED\\\"]\\n if kwargs['segment_type'] == \\\"fixed\\\" and kwargs['routing_type'] not in rt_set:\\n print(\\\"Invalid configuration. For a 'fixed' segment, the routing type must be left blank or set explicitly to 'ROUTED' or 'DISCONNECTED.'\\\")\\n sys.exit(1)\\n\\n segment_name = kwargs[\\\"objectname\\\"]\\n gateway = kwargs['gateway']\\n\\n # Search for segment to determine if it already exists\\n segment=search_nsx_json(proxy, sessiontoken, \\\"Segment\\\", segment_name)\\n if len(segment['results']) > 0:\\n print(\\\"The segment already appears to exist.\\\")\\n sys.exit(1)\\n\\n\\n # Establish baseline json payload\\n json_data = {\\n \\\"display_name\\\":segment_name,\\n \\\"id\\\":segment_name,\\n \\\"advanced_config\\\":{\\\"connectivity\\\":\\\"ON\\\"},\\n \\\"subnets\\\":[\\n {\\n \\\"gateway_address\\\": gateway\\n }\\n ]\\n }\\n #set segment type as either \\\"fixed\\\" or \\\"flexible\\\"\\n segment_type = kwargs['segment_type']\\n tier1_id = kwargs['tier1_id']\\n\\n if segment_type == \\\"fixed\\\":\\n json_data[\\\"connectivity_path\\\"] = \\\"/infra/tier-1s/cgw\\\"\\n if kwargs['routing_type'] == \\\"DISCONNECTED\\\":\\n json_data[\\\"advanced_config\\\"][\\\"connectivity\\\"] = \\\"OFF\\\"\\n else:\\n json_data[\\\"advanced_config\\\"][\\\"connectivity\\\"] = \\\"ON\\\"\\n elif segment_type == \\\"flexible\\\" and tier1_id is not None:\\n json_data[\\\"connectivity_path\\\"] = f'/infra/tier-1s/{tier1_id}'\\n else:\\n print(\\\"Please specify either the segment type as 'fixed' (-st fixed) OR segment type as 'flexible' as well as the ID of the Tier1 for connectivity (-t1id TIER1ID). Use pyVMC -h for additional options.\\\")\\n if kwargs['dhcp_range'] is not None:\\n json_data[\\\"subnets\\\"][0][\\\"dhcp_ranges\\\"] = [f'{kwargs[\\\"dhcp_range\\\"]}']\\n if kwargs['domain_name'] is not None:\\n json_data[\\\"domain_name\\\"] = kwargs[\\\"domain_name\\\"]\\n\\n print(json.dumps(json_data, indent = 2))\\n\\n status = new_segment_json(proxy, sessiontoken, segment_name, segment_type, json_data)\\n if status == 200:\\n print(f'The following network has been created: {segment_name}')\\n vars = {\\\"proxy\\\":proxy, \\\"sessiontoken\\\":sessiontoken, \\\"object_type\\\":\\\"Segment\\\", \\\"object_id\\\":segment_name}\\n search_nsx(**vars)\\n else:\\n print(\\\"The segment was not created. Please check your syntax and try again.\\\")\\n sys.exit(1)\",\n \"def __init__(self, coords, name=None):\\n self.points = [\\n Point(c[0], c[1], None if name is None else \\\"{}[{}]\\\".format(name, i))\\n for i, c in enumerate(coords)\\n ]\\n self.line_segments = [\\n LineSegment(p1, p2) for p1, p2 in zip(self.points[:-1], self.points[1:])\\n ]\\n self.line_segments.append(LineSegment(self.points[-1], self.points[0]))\",\n \"def fill_list(self):\\n for i in range(0, constants.STARTING_WORDS):\\n random_word = constants.LIBRARY[random.randint(0, len(constants.LIBRARY) - 1)]\\n x = random.randint(1, constants.MAX_X - len(self.get_text()))\\n y = random.randint(1, constants.MAX_Y - len(self.get_text()))\\n position = Point(x, y)\\n self.set_position(position)\\n velocity = Point(0, 1)\\n self._add_segment(random_word, position, velocity)\\n print()\",\n \"def prepare_training_data(collection_of_positive_segments, collection_of_negative_segments):\\n\\n\\n\\tprint \\\"Preparing training data...\\\"\\n\\n\\ttraining_vectors = []\\n\\ttraining_labels = []\\n\\n\\n\\tfor segment in collection_of_positive_segments.list_of_segments:\\n\\t\\tvector = get_segment_feature_vector(segment)\\n\\n\\t\\ttraining_labels.append(\\\"Correct\\\")\\n\\t\\ttraining_vectors.append(vector)\\n\\t\\t\\n\\t\\t\\n\\tfor segment in collection_of_negative_segments.list_of_segments:\\n\\t\\tvector = get_segment_feature_vector(segment)\\n\\t\\ttraining_labels.append(\\\"Incorrect\\\")\\n\\t\\ttraining_vectors.append(vector)\\n\\t\\t\\n\\t\\n\\ttraining_vectors = normalize_train_data(training_vectors)\\n\\t\\n\\t\\t\\n\\t#data = VectorDataSet(training_vectors,L=training_labels)\",\n \"def assign_actual(segments_path, training_path):\\n pass\",\n \"def parse_segments(self):\\n segs = self.unixtext.split(\\\"$$\\\")\\n for seg in segs:\\n self.segments.append(TextProductSegment(seg, self))\",\n \"def _set_out_segments(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGListType(\\\"outgoing_interface\\\",out_segments.out_segments, yang_name=\\\"out-segments\\\", rest_name=\\\"out-segments\\\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='outgoing-interface', extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}), is_container='list', yang_name=\\\"out-segments\\\", rest_name=\\\"out-segments\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-mpls-operational', defining_module='brocade-mpls-operational', yang_type='list', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"out_segments must be of a type compatible with list\\\"\\\"\\\",\\n 'defined-type': \\\"list\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGListType(\\\"outgoing_interface\\\",out_segments.out_segments, yang_name=\\\"out-segments\\\", rest_name=\\\"out-segments\\\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='outgoing-interface', extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}), is_container='list', yang_name=\\\"out-segments\\\", rest_name=\\\"out-segments\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'mpls-out-segment', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-mpls-operational', defining_module='brocade-mpls-operational', yang_type='list', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__out_segments = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def init(self):\\n self.mrs = []\\n if self.args.block_ctrl is not None:\\n self.block_ctrl_list = self.args.block_ctrl.split(\\\",\\\")\\n # Verify User input as per 0,1,2 format.\\n if \\\"\\\" in self.block_ctrl_list:\\n raise SALError(\\\"Invalid Input:[%s] to block controller \\\"\\n \\\"arguments given to scripts!!!\\\"\\n % (self.block_ctrl_list))\\n else:\\n self.block_ctrl_list = \\\"\\\"\\n # Create MR instance for controller index using --ctrl input.\\n self.mrs.append(create_mradapter(ctrl_index=self.args.ctrl))\\n self.ctrl_cnt = self.mrs[0].cli.controller_count()\\n for index in range(0, self.ctrl_cnt):\\n # Check for Block controller list.\\n if str(index) not in self.block_ctrl_list:\\n # Check for --Ctrl index given as arg to script.\\n if index != self.args.ctrl:\\n self.log.info(\\\"Creating MR instance for Controller-%d\\\"\\n % (index))\\n self.mrs.append(create_mradapter(ctrl_index=index))\\n else:\\n self.log.info(\\\"*****TC will not execute on Blocked \\\"\\n \\\"Controller-%d*****\\\" % (index))\\n for mr in self.mrs:\\n if not mr.is_mr():\\n raise SALError(\\\"This script is applicable only for MR \\\"\\n \\\"controller cards\\\")\",\n \"def network_initialize(self, payments):\\n for pt in payments:\\n if pt.id1 not in self.users.keys():\\n self.users[pt.id1] = set()\\n if pt.id2 not in self.users.keys():\\n self.users[pt.id2] = set()\\n self.users[pt.id1].add(pt.id2)\\n self.users[pt.id2].add(pt.id1)\",\n \"def create_hltsv_segment(config_db, default_host, hltsv_host, sfos, hlt_segments):\\n config_rules = config_db.getObject(\\\"ConfigurationRuleBundle\\\",\\n \\\"DefaultConfigurationRuleBundle\\\")\\n efio_config = config_db.getObject(\\\"EFIOConfiguration\\\", \\\"EFIO-Configuration-1\\\")\\n hltsv_segment = dal.Segment(\\\"HLT\\\")\\n defrc_controller = config_db.getObject(\\\"RunControlTemplateApplication\\\",\\n \\\"DefRC\\\")\\n hltsv_segment.IsControlledBy = defrc_controller\\n hltsv_app = create_hltsv_app(config_db, hltsv_host)\\n\\n sfo_apps = []\\n for index, sfo_host in zip(range(1, len(sfos)+1), sfos):\\n sfo_application = create_sfo_application(config_db, str(index),\\n sfo_host)\\n sfo_apps.append(sfo_application)\\n \\n hltsv_resources = [hltsv_app] + sfo_apps\\n hltsv_segment.Resources = hltsv_resources\\n\\n top_aggregator_app = create_aggregator_app(config_db, \\\"top_aggregator.py\\\",\\n default_host)\\n hltsv_segment.Applications = [top_aggregator_app]\\n\\n hltsv_segment.Hosts = [default_host]\\n\\n #infrastructure applications\\n is_server = config_db.getObject(\\\"InfrastructureTemplateApplication\\\",\\n \\\"DF_IS\\\")\\n oh_server = config_db.getObject(\\\"InfrastructureTemplateApplication\\\",\\n \\\"DF_Histogramming\\\")\\n hltsv_segment.Infrastructure = [is_server, oh_server]\\n \\n #Resources\\n mon_is = config_db.getObject(\\\"MIGApplication\\\", \\\"TopMIG-IS\\\")\\n mon_oh = config_db.getObject(\\\"MIGApplication\\\", \\\"TopMIG-OH\\\")\\n hltsv_segment.Resources.append(mon_is)\\n hltsv_segment.Resources.append(mon_oh)\\n\\n hltsv_segment.Segments = hlt_segments\\n \\n return hltsv_segment\",\n \"def initialize():\\n\\n with settings(prompts={'Password: ': 'test', 'Password (again): ': 'test'}):\\n for user, group in USER_GROUPS:\\n sudo(\\\"useradd %s -G %s,minv -g minv -N || true\\\" % (user, group))\\n sudo(\\\"chmod g+rwx /home/%s\\\" % user)\\n sudo('minv_ createuser %s -g %s' % (user, group), user=\\\"minv\\\")\\n\\n # upload script to create collections\\n put(\\n join(env.testdata_path, \\\"scripts/initial_collections.sh\\\"),\\n \\\"\\\", mode=0755\\n )\\n sudo(\\\"cp initial_collections.sh /home/minv-app-administrator/\\\")\\n\\n # upload collection configs\\n for conf in glob(join(env.testdata_path, \\\"configurations/*.conf\\\")):\\n put(conf, \\\"\\\", mode=0444, use_sudo=True)\\n sudo(\\\"cp %s /home/minv-app-administrator/\\\" % basename(conf))\\n\\n with cd(\\\"/home/minv-app-administrator/\\\"):\\n sudo(\\\"chmod a+rx . *\\\")\\n sudo(\\n \\\"sh -l ./initial_collections.sh\\\",\\n user=\\\"minv-app-administrator\\\"\\n )\",\n \"def __init__(self, users=()):\\n self.users = {str(x.id): x for x in users}\",\n \"def _cluster_segments_all_way(self, segmented_instances, labels, \\\\\\n end_points, stats, cluster_thresh=0.5):\\n\\n #self.showme(segmented_instances, 'main img')\\n segment_association_list = []\\n max_num_end_points= 0\\n\\n # for each stem segment\\n for i in range(0, len(labels)):\\n # each end point in the current segment i\\n if max_num_end_points < len(end_points[i]):\\n max_num_end_points = len(end_points[i])\\n for k in range(0, len(end_points[i])):\\n angle_list=[]\\n # find the segment that is most likely connected to segment i at end point[i][k]\\n for j in range(0, len(labels)):\\n # make sure we are not trying to connect the segment to itself\\n if i!= j:\\n # angle calculates the angle between the line stats['centroid'][i]-end_points[i][k]\\n # and stats['centroid'][i]-stats['centroid'][j]\\n\\n angle = self._ang([stats['centroid'][i],end_points[i][k]], \\\\\\n [stats['centroid'][i], stats['centroid'][j]] )\\n # if the angle value is within the acceptable range of +/- angle_thresh\\n if angle<=self.angle_thresh or angle>=360-self.angle_thresh:\\n other_angle, other_seg_section, end_point_dist = self._get_best_fit(segmented_instances, \\\\\\n len(labels), \\\\\\n stats, end_points,\\\\\\n i, j, k, pos_angle=angle<=self.angle_thresh)\\n # if the best fit segment also has a small angle between its\\n # end point-centroid line and centroid-centroid line,\\n # add it to segments connected to segment i\\n if other_angle!=None and other_angle<=self.angle_thresh:\\n angle_list.append((j, other_seg_section, other_angle, end_point_dist, angle))\\n #Sort the list of stem segments connected to i by end_point_dist\\n angle_list = sorted(angle_list, key=lambda x:x[3])\\n #Sorting by the Euclidian distance of the end_point_dist and the other_angle does not change end result\\n #angle_list = sorted(angle_list, key=lambda x:(math.sqrt(x[3]**2.0+x[2]**2.0)))\\n # the angle value reflects how far segment k is from the straight line\\n # going through the centroids\\n if len(angle_list)>0:\\n # (i, j, k, l, angle between i and centroid line, angle between j and centroid line, distance between closest end points k in seg i and l in seg j)\\n segment_association_list.append((i,angle_list[0][0],k, angle_list[0][1], angle_list[0][4], angle_list[0][2], angle_list[0][3]))\\n\\n\\n # sort slope differences in an increasing order\\n segment_association_list = sorted(segment_association_list,key=lambda x:(x[6]))\\n\\n # find best match by iteretively selecting the smallest difference\\n # and adding it to the ith cluster\\n cluster_list = []\\n cluster = np.full(len(labels),None)\\n colored_clusterImg = np.zeros(segmented_instances.shape).astype(np.uint8)\\n #clusterImg = np.zeros(segmented_instances.shape).astype(np.uint8)\\n\\n # initialize cluster list to single clusters contianing only each individual segment\\n for i in range(0, len(labels)):\\n cluster[i]=i\\n cluster_list.append([i])\\n #self.showme(clusterImg, str(i))\\n\\n visited=np.full((len(labels),max_num_end_points), False)\\n\\n #cluster=np.frompyfunc(list,1,1)(cluster) # allows us to append to only the specified list end_points[i]\\n new_cluster_num=0\\n color_offset=len(labels)\\n\\n # for each pair of segments in our list of best fit segments\\n for curr_tuple in segment_association_list:\\n img = np.zeros(segmented_instances.shape)\\n i = curr_tuple[0] # index of first segment\\n j = curr_tuple[1] # index of second segment in the tuple\\n i_section = curr_tuple[2] #end point number in segment i\\n j_section = curr_tuple[3] #end point number in segment j\\n angle = curr_tuple[4]\\n other_angle = curr_tuple[5]\\n end_point_dist = curr_tuple[6] #distance between the connecting end points of segments i and j\\n img[segmented_instances== i]= 255\\n img[segmented_instances== j]= 255\\n if (visited[i][i_section]==False)and(visited[j][j_section]==False):\\n #cv2.line(clusterImg,(end_points[i][i_section][0],end_points[i][i_section][1]),\\\\\\n # (end_points[j][j_section][0], end_points[j][j_section][1]),150,2)\\n #self.showme(clusterImg, str(i))\\n visited[i][i_section]=True\\n visited[j][j_section]=True\\n cluster_num = cluster[i]\\n if cluster[i]!=cluster[j]:\\n other_cluster_num = cluster[j]\\n cluster_list[cluster_num] = list(set(cluster_list[cluster_num]+\\\\\\n copy.deepcopy(cluster_list[other_cluster_num])))\\n # update cluster numbers for all segments moved into new cluster\\n for seg in cluster_list[other_cluster_num]:\\n cluster[seg]=cluster_num\\n # update cluster numbers for clusters larger than cluster to be removed\\n for idx in range(0, len(cluster)):\\n if (cluster[idx]>other_cluster_num):\\n cluster[idx]= cluster[idx]-1\\n del cluster_list[other_cluster_num]\\n\\n\\n #show clustered segments\\n color = 0\\n cluster_num = 0\\n cluster_mask=[]\\n\\n for c in cluster_list:\\n color = color+0.1\\n cluster_mask.append(np.zeros(segmented_instances.shape).astype(np.uint8))\\n\\n for i in c:\\n cluster_mask[cluster_num][(segmented_instances == labels[i])]=1\\n colored_clusterImg[(segmented_instances == labels[i])]= int(color*255)\\n \\\"\\\"\\\"if self.key in ['../data/images/image1672', '../data/images/image1289']:\\n self.showme(colored_clusterImg)\\\"\\\"\\\"\\n cluster_num +=1\\n\\n return cluster_mask, colored_clusterImg\",\n \"def build_subsets(self):\\n self.all = nrn.SectionList()\\n self.all.wholetree(sec=self.soma)\",\n \"def set_vendors(self, vendors_list):\\n self.multiple_items_selection_from_kendo_dropdown(self.vendors_kendo_dropdown_locator, vendors_list)\\n self.wait_for_ajax_spinner_load()\",\n \"def setInitialized( initialized, ants, subarray=DEFAULT ):\\n antlist = helpers.makeList(ants)\\n multiSubarray('antennaInitialized', subarray, initialized, antlist )\",\n \"def __init__(self, length=None, primary=None):\\n if primary:\\n self._primary_list = primary\\n else:\\n self._primary_list = [None] * length\\n self._dot_bracket = None\\n self._current_site = 0\",\n \"def __init__(__self__, *,\\n vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):\\n if vnet_subnet_ids is not None:\\n pulumi.set(__self__, \\\"vnet_subnet_ids\\\", vnet_subnet_ids)\",\n \"def __init__(self, uccsdslice, slice_index, angle_deg):\\n super()\\n # IMPLEMENTATION NOTE: This probably doesn't need to be a deepcopy since\\n # the state is passed to seperate processes.\\n self.uccsdslice = deepcopy(uccsdslice)\\n self.slice_index = slice_index\\n self.angle_deg = angle_deg\\n self.angle = np.deg2rad(angle_deg)\\n self.uccsdslice.update_angles([self.angle] * len(self.uccsdslice.angles))\\n self.file_name = \\\"s{}_a{}\\\".format(slice_index, angle_deg)\\n self.pulse_time = UCCSD_LIH_SLICE_TIMES[slice_index]\\n self.lr = UCCSD_LIH_HYPERPARAMETERS[slice_index][\\\"lr\\\"]\\n self.decay = UCCSD_LIH_HYPERPARAMETERS[slice_index][\\\"decay\\\"]\",\n \"def make_segments(date_start=None, date_end=None, date_freq=None,\\n n_series=3, n_segments=2, seg_sep=None,\\n means=None, stds=None, trends=None,\\n amplitudes=None, phases=None):\\n assert isinstance(n_series, int)\\n assert isinstance(n_segments, int) and n_segments >= 1\\n # TODO\\n pass\",\n \"def __init__(self, pair_list=None):\\n\\n self.plugleads = []\\n if pair_list is not None:\\n self.add_many(pair_list)\",\n \"def initDefaults(self):\\n return _libsbml.LineSegment_initDefaults(self)\",\n \"def _prepPointsForSegments(points):\\n while 1:\\n point = points[-1]\\n if point.segmentType:\\n break\\n else:\\n point = points.pop()\\n points.insert(0, point)\\n continue\\n break\",\n \"def __init__(self, substrates=None, products=None):\\n self.substrates = substrates or []\\n self.products = products or []\",\n \"def init_managers(endpoints_file: Optional[Text]) -> None:\",\n \"def __init__(self, station_file: str, ride_file: str) -> None:\\n self.all_stations = create_stations(station_file)\\n self.all_rides = create_rides(ride_file, self.all_stations)\\n self.visualizer = Visualizer()\\n self.active_rides = []\",\n \"def init_subsections(self, customs_arch):\\n section_list = []\\n\\n # Identify number of unique subsections in the server arcitecture.\\n num_subsections = len(customs_arch['subsection'].unique())\\n\\n # Retrieve number of total servers and start an ID counter.\\n num_servers = sum(customs_arch['max'])\\n server_id = 1\\n\\n # Initialize each Subsection Class with a loop.\\n for i in range(num_subsections):\\n\\n # Get the label of the subsection.\\n subsection_id = customs_arch['subsection'].unique()[i]\\n\\n # Subset the master architecture into an architecture just for\\n # for the subsection.\\n subsection_arch = customs_arch[customs_arch['subsection'] == subsection_id]\\n\\n # Get server ID range.\\n server_range = (server_id, server_id + subsection_arch.iloc[0]['max'])\\n server_id = server_id + subsection_arch.iloc[0]['max']\\n\\n # Get the processed passenger queue from the Class Data Members list.\\n serviced_passengers_list = self.outputs\\n\\n # Init a subsection and append to the list.\\n section_list.append(Subsection(subsection_id,\\n subsection_arch,\\n server_range,\\n serviced_passengers_list))\\n\\n return section_list\",\n \"def region_setup(self, slices, ipa_regions):\\n self.ipa_regions = ipa_regions\\n self.slices = slices\",\n \"def init_server_list(self, subsection_arch, subsection_id, server_range,\\n output_list):\\n\\n # Init a list of servers to return.\\n rtn = []\\n\\n # Loop through all servers in the arch.\\n for i in range(server_range[0], server_range[1]):\\n\\n # Pass the ID of the server and Init a server.\\n rtn.append(ServiceAgent(str(i), subsection_id, output_list))\\n\\n # Return the list.\\n return rtn\",\n \"def __init__(self, list: List[DiagramView], start_button: StartButtonView):\\n super().__init__()\\n\\n self.__init_ui(list, start_button)\",\n \"def setUserIDRefs( self, text ):\\n self.user_id_list= text.split()\",\n \"def __init__(self, contact_loader):\\n self.contacts_by_group_list = contact_loader.contacts_by_group_list\\n self.contact_list = None\",\n \"def update_nets_with_segments(pcb_data: List[Dict[str, Any]], nets: List[Net]):\\n segments = get_all_dicts_by_key(pcb_data, 'segment')\\n for segment in segments:\\n start: Coords = get_dict_by_key(segment['segment'], 'start')['start']\\n start[1] = str(-1*float(start[1]))\\n end: Coords = get_dict_by_key(segment['segment'], 'end')['end']\\n end[1] = str(-1 * float(end[1]))\\n width: str = get_dict_by_key(segment['segment'], 'width')['width']\\n layer_data: str = get_dict_by_key(segment['segment'], 'layer')['layer']\\n layers: List[Layer] = convert_to_layers(layer_data)\\n new_segment: Segment = Segment(start=start, end=end, width=width, layers=layers)\\n net_id: str = get_dict_by_key(segment['segment'], 'net')['net']\\n for net in nets:\\n if float(net.net_id) == float(net_id):\\n net.segments.append(new_segment)\",\n \"def setPUsers(self, users):\\n model = self.tvPUsers.get_model()\\n model.clear()\\n for user in users:\\n model.append((user,))\\n\\n self.on_entPUser_changed(self.entPUser)\\n self.on_tvPUsers_cursor_changed(self.tvPUsers)\",\n \"def __init__(self):\\n self.g_sect = []\",\n \"def segment(args):\\n from jcvi.formats.base import SetFile\\n\\n p = OptionParser(segment.__doc__)\\n p.add_option(\\n \\\"--chain\\\",\\n default=1,\\n type=\\\"int\\\",\\n help=\\\"Allow next N genes to be chained\\\",\\n )\\n opts, args = p.parse_args(args)\\n\\n if len(args) != 2:\\n sys.exit(not p.print_help())\\n\\n idsfile, bedfile = args\\n bed = Bed(bedfile)\\n order = bed.order\\n ids = SetFile(idsfile)\\n losses = Grouper()\\n skip = opts.chain\\n for i, a in enumerate(bed):\\n a = a.accn\\n for j in range(i + 1, i + 1 + skip):\\n if j >= len(bed):\\n break\\n b = bed[j].accn\\n if a in ids:\\n losses.join(a, a)\\n if a in ids and b in ids:\\n losses.join(a, b)\\n\\n losses = list(losses)\\n singletons = [x for x in losses if len(x) == 1]\\n segments = [x for x in losses if len(x) > 1]\\n ns, nm, nt = len(singletons), len(segments), len(losses)\\n assert ns + nm == nt\\n\\n # Summary for all segments\\n for x in sorted(singletons) + sorted(segments):\\n print(\\n \\\"\\\\t\\\".join(\\n str(x)\\n for x in (\\\"|\\\".join(sorted(x)), len(x), estimate_size(x, bed, order))\\n )\\n )\\n\\n # Find longest segment stretch\\n if segments:\\n mx, maxsegment = max([(len(x), x) for x in segments])\\n print(\\\"Longest stretch: run of {0} genes\\\".format(mx), file=sys.stderr)\\n print(\\\" {0}\\\".format(\\\"|\\\".join(sorted(maxsegment))), file=sys.stderr)\\n seg_asize = sum(estimate_size(x, bed, order) for x in segments)\\n seg_bsize = sum(\\n estimate_size(x, bed, order, conservative=False) for x in segments\\n )\\n else:\\n seg_asize = seg_bsize = 0\\n\\n sing_asize = sum(estimate_size(x, bed, order) for x in singletons)\\n sing_bsize = sum(\\n estimate_size(x, bed, order, conservative=False) for x in singletons\\n )\\n total_asize = sing_asize + seg_asize\\n total_bsize = sing_bsize + seg_bsize\\n print(\\n \\\"Singleton ({0}): {1} - {2} bp\\\".format(ns, sing_asize, sing_bsize),\\n file=sys.stderr,\\n )\\n print(\\n \\\"Segment ({0}): {1} - {2} bp\\\".format(nm, seg_asize, seg_bsize), file=sys.stderr\\n )\\n print(\\n \\\"Total ({0}): {1} - {2} bp\\\".format(nt, total_asize, total_bsize),\\n file=sys.stderr,\\n )\\n print(\\n \\\"Average ({0}): {1} bp\\\".format(nt, (total_asize + total_bsize) / 2),\\n file=sys.stderr,\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6232747","0.596336","0.58711517","0.5702215","0.55154556","0.5394213","0.53759134","0.53305984","0.5308964","0.529063","0.5197425","0.51839024","0.5133967","0.5053822","0.50320536","0.5010542","0.50038457","0.4999929","0.49838173","0.4962347","0.49609384","0.49214706","0.48969644","0.48933196","0.48866424","0.48850414","0.48827687","0.48644063","0.4854759","0.48456323","0.48354244","0.4816443","0.48160887","0.47955847","0.47694954","0.47653636","0.4754155","0.47535893","0.47508985","0.4740349","0.47355124","0.4712309","0.47122893","0.4693374","0.4691195","0.4674327","0.46700785","0.46695805","0.4654817","0.46472904","0.46388838","0.46344438","0.463277","0.462129","0.4612358","0.4597923","0.4597923","0.4596566","0.4591489","0.45808166","0.45659292","0.45634958","0.4558433","0.45572707","0.4552204","0.45516923","0.4551272","0.4541491","0.45397142","0.45340165","0.45294172","0.45291016","0.45244905","0.45177776","0.45151123","0.45150173","0.45071426","0.45061377","0.45047173","0.45044583","0.4504141","0.44990864","0.4494506","0.4488189","0.4483834","0.4480248","0.44798985","0.44797873","0.44763216","0.44566116","0.44549328","0.44518548","0.44491574","0.44479638","0.44472665","0.44457617","0.44414386","0.44399932","0.44351396","0.4433871"],"string":"[\n \"0.6232747\",\n \"0.596336\",\n \"0.58711517\",\n \"0.5702215\",\n \"0.55154556\",\n \"0.5394213\",\n \"0.53759134\",\n \"0.53305984\",\n \"0.5308964\",\n \"0.529063\",\n \"0.5197425\",\n \"0.51839024\",\n \"0.5133967\",\n \"0.5053822\",\n \"0.50320536\",\n \"0.5010542\",\n \"0.50038457\",\n \"0.4999929\",\n \"0.49838173\",\n \"0.4962347\",\n \"0.49609384\",\n \"0.49214706\",\n \"0.48969644\",\n \"0.48933196\",\n \"0.48866424\",\n \"0.48850414\",\n \"0.48827687\",\n \"0.48644063\",\n \"0.4854759\",\n \"0.48456323\",\n \"0.48354244\",\n \"0.4816443\",\n \"0.48160887\",\n \"0.47955847\",\n \"0.47694954\",\n \"0.47653636\",\n \"0.4754155\",\n \"0.47535893\",\n \"0.47508985\",\n \"0.4740349\",\n \"0.47355124\",\n \"0.4712309\",\n \"0.47122893\",\n \"0.4693374\",\n \"0.4691195\",\n \"0.4674327\",\n \"0.46700785\",\n \"0.46695805\",\n \"0.4654817\",\n \"0.46472904\",\n \"0.46388838\",\n \"0.46344438\",\n \"0.463277\",\n \"0.462129\",\n \"0.4612358\",\n \"0.4597923\",\n \"0.4597923\",\n \"0.4596566\",\n \"0.4591489\",\n \"0.45808166\",\n \"0.45659292\",\n \"0.45634958\",\n \"0.4558433\",\n \"0.45572707\",\n \"0.4552204\",\n \"0.45516923\",\n \"0.4551272\",\n \"0.4541491\",\n \"0.45397142\",\n \"0.45340165\",\n \"0.45294172\",\n \"0.45291016\",\n \"0.45244905\",\n \"0.45177776\",\n \"0.45151123\",\n \"0.45150173\",\n \"0.45071426\",\n \"0.45061377\",\n \"0.45047173\",\n \"0.45044583\",\n \"0.4504141\",\n \"0.44990864\",\n \"0.4494506\",\n \"0.4488189\",\n \"0.4483834\",\n \"0.4480248\",\n \"0.44798985\",\n \"0.44797873\",\n \"0.44763216\",\n \"0.44566116\",\n \"0.44549328\",\n \"0.44518548\",\n \"0.44491574\",\n \"0.44479638\",\n \"0.44472665\",\n \"0.44457617\",\n \"0.44414386\",\n \"0.44399932\",\n \"0.44351396\",\n \"0.4433871\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6051361"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3398,"cells":{"query":{"kind":"string","value":"Create a WordForm of the given CV shape with random segments."},"document":{"kind":"string","value":"def random_segs(cls, shape, lemma = None, case = None):\n # For each C or V segment in `shape`, initialize a random Segment of the\n # appropriate type. Initialize a new WordForm with all these Segments.\n return cls([Segment(seg_type = seg) for seg in shape], lemma, case)"},"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 create_word(self):\r\n\r\n template = self.word_constructions.get()\r\n word = \"\"\r\n for c in template:\r\n if c == \"v\":\r\n letter = self.get_letter(100)\r\n else:\r\n letter = self.get_letter(0)\r\n word += letter\r\n\r\n while not any(letter in self.vowels for letter in word):\r\n length = len(word)\r\n if length == 1:\r\n index = 0\r\n elif length == 2:\r\n index = random.randrange(0, 2)\r\n else:\r\n a = len(word) / 2\r\n index = a + random.randrange(-a / 2, a / 2)\r\n word = word[:index] + self.get_letter(100) + word[index + 1:]\r\n\r\n if random.random() > self.capital_chance:\r\n word = word.capitalize()\r\n self.words.append(word)\r\n self.word_count += 1\r\n return word","def generateByWord(model, voc, maxlen=20, diversity=0.5, numwords=42):\n\n text, sym_indices, indices_sym = voc\n syms = set(text)\n start_index = random.randint(0, len(text) - maxlen - 1) \n generated = ''\n sentence = text[start_index: start_index + maxlen]\n \n #generated += sentence\n generated += ' '.join(sentence)\n print('----- Generating with seed: \"' + ' '.join(sentence) + '\"')\n sys.stdout.write(generated)\n\n for i in range(numwords):\n x = np.zeros((1, maxlen, len(syms)))\n for t, sym in enumerate(sentence):\n x[0, t, sym_indices[sym]] = 1.\n \n preds = model.predict(x, verbose=0)[0]\n next_index = sample(preds, diversity)\n next_sym = indices_sym[next_index]\n generated += ' '+next_sym\n sentence.append(next_sym)\n tmpsentence = sentence[1:]\n sentence = tmpsentence\n sys.stdout.write(next_sym+' ')\n sys.stdout.flush()\n print()","def create(seed, model, tokenizer, temp=0.5):\n\n dictionary = [\"\"] + list(tokenizer.index_word.values())\n start = np.array(tokenizer.texts_to_sequences(seed)).reshape(1, -1)\n if seed[0] == '<start>':\n output = [seed[-1]]\n else:\n output = seed[:]\n\n for _ in range(45):\n weights = reweight_distribution(model.predict(start), temperature=temp)\n word = np.random.choice(dictionary, size=1, p=weights[0, :])[0]\n if word == '<end>': \n if len(output) > 10:\n break\n else:\n continue\n output.append(word)\n start = np.append(start[0, 1:], tokenizer.texts_to_sequences([word])).reshape(1, -1)\n return \" \".join(output)","def create_word(self):\n return self.random.choice(CONSONANTS) + self.random.choice(VOWELS)","def build_vocabulary(image_paths, vocab_size):\n n_image = len(image_paths)\n\n # Since want to sample tens of thousands of SIFT descriptors from different images, we\n # calculate the number of SIFT descriptors we need to sample from each image.\n n_each = int(np.ceil(40000 / n_image)) # You can adjust 10000 if more is desired\n\n # Initialize an array of features, which will store the sampled descriptors\n features = np.zeros((n_image * n_each, 128))\n j=0\n for i, path in enumerate(image_paths):\n # Load SIFT features from path\n descriptors = np.loadtxt(path, delimiter=',',dtype=float)\n\n # TODO: Randomly sample n_each features from descriptors, and store them in features\n #use the randomizer in numpy library to make n_each random index\n idx= np.array(np.random.randint(0,len(descriptors),n_each))\n\n # choose randomly n_each number of discriptor to train K-mean classifier\n for k in idx:\n\n features[j] = descriptors[k,:]\n j = j+1\n # TODO: pefrom k-means clustering to cluster sampled SIFT features into vocab_size regions.\n # You can use KMeans from sci-kit learn.\n # Reference: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html\n\n #use K_mean classifier to make Bag of visual words represantation for SIFT features\n kmeans = KMeans(n_clusters=250).fit(features)\n #kmeans= clustering = AgglomerativeClustering().fit(features)\n\n\n return kmeans","def create_new_doc(self, doc: Doc, min_prob: float = 0.25) -> Doc:\n\n # print(\"running on\", doc[:10])\n\n if not self.form_frequencies:\n raise RuntimeError(\n \"Cannot truecase without a dictionary of form frequencies\")\n\n tokens = []\n spaces = []\n doctext = doc.text\n for tok in doc:\n toktext = tok.text\n\n # We only change casing for words in Title or UPPER\n if tok.is_alpha and toktext[0].isupper():\n cond1 = tok.is_upper and len(toktext) > 2 # word in uppercase\n cond2 = toktext[0].isupper(\n ) and not tok.is_sent_start # titled word\n if cond1 or cond2:\n token_lc = toktext.lower()\n if token_lc in self.form_frequencies:\n frequencies = self.form_frequencies[token_lc]\n if frequencies.get(toktext, 0) < min_prob:\n alternative = sorted(\n frequencies.keys(), key=lambda x: frequencies[x])[-1]\n\n # We do not change from Title to to UPPER\n if not tok.is_title or not alternative.isupper():\n toktext = alternative\n\n tokens.append(toktext)\n\n # Spacy needs to know whether the token is followed by a space\n if tok.i < len(doc)-1:\n spaces.append(doctext[tok.idx+len(tok)].isspace())\n else:\n spaces.append(False)\n\n # Creates a new document with the tokenised words and space information\n doc2 = Doc(self.model.vocab, words=tokens, spaces=spaces) #type: ignore\n # print(\"finished with doc\", doc2[:10])\n return doc2","def create_wordcloud(self, text):\n text = ' '.join(f\"{word}\" for word in text)\n mask = np.array(Image.open(os.path.join(CURRDIR, \"cloud.png\")))\n wc = WordCloud(background_color=\"white\",\n max_words=200,\n mask=mask)\n wc.generate(text)\n wc.to_file(PATH_TO_SAVE_IMG, \"wordle.png\")","def word(length, upper=False):\n letters = \"abcdefghijklmnopqrstuvwxyz\"\n if upper:\n letters = letters.upper()\n\n def gen(shape):\n lengths = _ints(length, shape)\n field_length = lengths.max()\n dtype = \"U{}\".format(field_length)\n\n result = np.empty(shape, dtype=dtype)\n flat = result.ravel()\n for i, l in enumerate(lengths):\n flat[i] = \"\".join( random.choice(letters) for _ in range(l) )\n return result\n\n return gen","def create_random_text(word_count=10):\n sample_text_lst = TEXT_BASE_RUS.replace('\\n', '').split(' ')\n generate_text_lst = []\n for i in range(word_count):\n generate_text_lst.append(random.choice(sample_text_lst))\n generate_text = ' '.join(generate_text_lst)\n return generate_text","def generate(model, voc, maxlen=20, diversity=0.5, numchars=100):\n\n text, char_indices, indices_char = voc\n chars = set(text)\n start_index = random.randint(0, len(text) - maxlen - 1) \n generated = ''\n sentence = text[start_index: start_index + maxlen]\n #print(\"Insert text to start from [min 20 chars]:\")\n #sentence = str(raw_input())\n #sentence = sentence[:maxlen]\n generated += sentence\n print('----- Generating with seed: \"' + sentence + '\"')\n sys.stdout.write(generated)\n\n for i in range(numchars):\n x = np.zeros((1, maxlen, len(chars)))\n for t, char in enumerate(sentence):\n x[0, t, char_indices[char]] = 1.\n \n preds = model.predict(x, verbose=0)[0]\n next_index = sample(preds, diversity)\n next_char = indices_char[next_index]\n generated += next_char\n sentence = sentence[1:] + next_char\n sys.stdout.write(next_char)\n sys.stdout.flush()\n print()","def generate_sentence():\n markov_chain = makeMarkovDict(\"text.txt\")\n\n # Pick a random word to begin with.\n first_word = random.choice(markov_chain.keys()) # Illegall\n\n # print first_word\n # random_choice = random.randint(0, len(markov_chain.keys()))\n # index = 0\n # first_word = \"\"\n # for word in markov_chain:\n # print word\n # if index == random_choice:\n # first_word = word\n # break\n # index += 1\n\n # Based on that word, call function to chose the next word.\n # print markov_chain[first_word]\n # print word_selection(markov_chain[first_word])\n\n lenght_of_sentence = 10\n sentence = [first_word] # First word already in there\n for i in range(lenght_of_sentence):\n sentence.append(word_selection(markov_chain[sentence[i]]))\n # Sentence after loop: ['fish', 'red', 'fish', 'two', 'fish', 'red', 'fish', 'red', 'fish', 'two', 'fish']\n\n # Cap with letter and add period at the end.\n final_sentece = \" \".join(sentence) + \".\"\n return final_sentece.capitalize()","def create_vocab(vocab_path='ORBvoc-synth.txt'):\n total_time = 10 # seconds\n num_frames = 20\n speed = 3.0\n vocab_builder = VocabularyBuilder()\n for seed in tqdm(range(100), total=100):\n image_builder = DemoImageBuilder(\n mode=ImageMode.MONOCULAR, seed=seed,\n length=total_time * speed\n )\n for idx in range(num_frames):\n time = total_time * idx / num_frames\n image = image_builder.create_frame(time)\n vocab_builder.add_image(image.pixels)\n vocab_builder.build_vocabulary(str(vocab_path))","def word_cloud_generator(text: str, mask_image: Path, save_to_file=False) -> WordCloud:\n mask = imageio.imread(mask_image)\n word_cloud = WordCloud(colormap='prism', mask=mask, background_color='white')\n word_cloud = word_cloud.generate(text)\n if save_to_file:\n word_cloud.to_file('word_cloud.png')\n return word_cloud","def generate_wordcloud(topic_description, use_mask='rectangle', store_to_file=False):\n\n # transform the topic description in frequencies\n topic_frequencies = get_word_frequencies(topic_description)\n\n if use_mask == 'oval':\n mask = numpy.array(Image.open(os.path.join(config.__resources_folder_path, \"oval.jpg\")))\n else:\n mask = numpy.array(Image.open(os.path.join(config.__resources_folder_path, \"rect.png\")))\n\n wc = WordCloud(background_color=\"white\", max_words=2000, mask=mask)\n # generate word cloud\n wc.generate_from_frequencies(topic_frequencies)\n\n if store_to_file:\n # store to file\n wc.to_file(os.path.join(config.__inputs_outputs_folder_path, \"wordcloud_{0}_{1}.png\".format(\n hash(str(topic_description)), use_mask)))\n\n # show\n plt.imshow(wc, interpolation='bilinear')\n plt.axis(\"off\")\n plt.show()","def generate(self, count=15):\n\n sentence = []\n print(\"self.word_dict\", self.word_dict)\n for i in range(count):\n first_tuple = random.choice(list(self.word_dict.keys())) # first word for our sentence\n first_word = random.choice(first_tuple)\n sentence.append(first_word)\n second_word = self.word_dict[first_tuple]\n # print(\"second_word\", second_word)\n next_word = second_word.sample()\n # print(\"next_word\", next_word)\n # first_tuple = second_word\n sentence.append(next_word)\n # end_tuple =\n sentence = ' '.join(sentence)\n return sentence + \".\"\n # for i in range(len(self.token)):\n # val = list(self.word_dict.values())[i]\n # print(len(val))\n # # print(\"val\", val)\n # next_word = val.sample()\n # sentence.append(next_word)\n # sentence = ' '.join(sentence)\n # return sentence + \".\"","def build_from_words(self, words):\n if isinstance(words, unicode):\n self.build(words)\n elif isinstance(words, list):\n flag = \"seg\"\n assert len(words) > 0\n\n word = words[0]\n if isinstance(word, unicode):\n flag = \"seg\"\n elif ((isinstance(word, list) or isinstance(word, tuple)) and\n len(word) == 2 and isinstance(word[0], unicode) and isinstance(word[1], unicode)):\n flag = \"pos\"\n elif ((isinstance(word, list) or isinstance(word, tuple)) and\n len(word) == 4 and isinstance(word[0], unicode) and isinstance(word[1], unicode)):\n flag = \"dp\"\n else:\n flag = \"unknown\"\n\n self._xml4nlp = Element('xml4nlp')\n self._note = SubElement(self._xml4nlp, 'note')\n self._doc = SubElement(self._xml4nlp, 'doc')\n\n para = SubElement(self._doc, 'para')\n sent = SubElement(para, 'sent')\n\n para.set(\"id\", \"0\")\n sent.set(\"id\", \"0\")\n\n self._clean_note()\n\n if flag == \"seg\":\n for i, word in enumerate(words):\n sent.append(Element('word', {\n 'id': unicode(i),\n 'cont': word\n }))\n sent.set('cont', (\"\".join(words)))\n self._set_word_on_note()\n elif flag == \"pos\":\n for i, word_pos in enumerate(words):\n word, pos = word_pos\n sent.append(Element('word', {\n 'id': unicode(i),\n 'cont': word,\n 'pos': pos\n }))\n sent.set('cont', (\"\".join([word[0] for word in words])))\n self._set_pos_on_note()\n elif flag == \"dp\":\n for i, rep in enumerate(words):\n word, pos, head, dep_rel = rep\n sent.append(Element('word', {\n 'id': unicode(i),\n 'cont': word,\n 'pos': pos,\n 'parent': str(int(head) - 1),\n 'relation': dep_rel\n }))\n sent.set('cont', (\"\".join([word[0] for word in words])))\n self._set_parser_on_note()\n\n self.dom = self._xml4nlp","def generate_words(text='', train_path=None, case_sensitive=True, epochs=20, classifier=nlup.BinaryAveragedPerceptron, **kwargs):\n if train_path:\n generate_sentences.detector = Detector(slurp(train_path), epochs=epochs, nocase=not case_sensitive)\n # generate_sentences.detector = SentenceDetector(text=text, nocase=not case_sensitive, epochs=epochs, classifier=classifier)\n return iter(generate_sentences.detector.segments(text))","def surface_labelled_data_preparation_pipeline(word_list: [str]):\n X = []\n\n for word in word_list:\n segments = word.split('-')\n segment_features = []\n for i in range(len(segments)):\n features = {}\n\n segment_length = len(segments[i])\n features['length'] = segment_length\n\n features['segment.lower()'] = segments[i].lower()\n features['pos_in_word'] = i\n\n if segment_length % 2 == 0:\n features['even'] = 1\n else:\n features['odd'] = 1\n\n features['begin'] = segments[i][0]\n features['end'] = segments[i][len(segments[i]) - 1]\n\n try:\n features['prev_segment'] = segments[i - 1]\n except IndexError:\n features['prev_segment'] = ''\n # continue\n\n try:\n features['next_segment'] = segments[i + 1]\n except IndexError:\n features['next_segment'] = ''\n\n if segments[0].isupper():\n features['start_upper'] = 1\n else:\n features['start_lower'] = 1\n\n if segments[0] in 'aeiou':\n features['first_vowel'] = 1\n else:\n features['first_const'] = 1\n\n segment_features.append(features)\n\n X.append(segment_features)\n\n return X","def makeFeatureVec(words, model, num_features):\n featureVec = np.zeros((num_features,),dtype=\"float32\")\n num_words = 0.\n index2word_set = set(model.wv.index2word)\n for word in words:\n if word in index2word_set:\n num_words += 1\n featureVec = np.add(featureVec,model[word]) \n featureVec = np.divide(featureVec,num_words)\n return featureVec","def gen_words(self, doc):\n pattern = re.compile(u'[\\\\s\\\\d,.<>/?:;\\'\\\"[\\\\]{}()\\\\|~!@#$%^&*\\\\-_=+a-zA-Z，。《》、？：；“”‘’｛｝【】（）…￥！—┄－]+')\n doc = re.sub(pattern, ' ', doc)\n suffix_indexes = index_of_sorted_suffix(doc, self.max_word_len)\n word_cands = {}\n # compute frequency and neighbors\n for suf in suffix_indexes:\n word = doc[suf[0]:suf[1]]\n if word not in word_cands:\n word_cands[word] = WordInfo(word)\n word_cands[word].update(doc[suf[0] - 1:suf[0]], doc[suf[1]:suf[1] + 1])\n # compute probability and entropy\n length = len(doc)\n for k in word_cands:\n word_cands[k].compute(length)\n word_cands[k].compute_pp(self.pos_prop)\n # compute aggregation of words whose length > 1\n values = sorted(word_cands.values(), key=lambda x: len(x.text))\n for v in values:\n if len(v.text) == 1:\n continue\n v.compute_cohesion(word_cands)\n\n return sorted(values, key=lambda v: v.freq, reverse=True)","def make_text(markov_chains):\n\n random_num = generate_random_number(markov_chains.keys())\n\n random_text = []\n\n start_words = generate_start_words(random_num, markov_chains.keys())\n \n random_text.extend(start_words)\n\n\n for i in range(500):\n word_tuple = (random_text[-2],random_text[-1])\n next_word = add_next_word(word_tuple, markov_chains)\n random_text.append(next_word)\n\n return random_text","def word2vec_model(sentences, size=100, min_count=5, window=5,\n negative=5, cbow=True, iterations=5, seed=0,\n workers=1):\n if cbow is True:\n sg = 0\n else:\n sg = 1\n model = Word2Vec(size=size, window=window,\n min_count=min_count, workers=workers,\n sg=sg, negative=negative, seed=seed)\n\n model.build_vocab(sentences)\n\n model.train(sentences, total_examples=model.corpus_count,\n epochs=iterations)\n return model","def create_random_tags(count=100):\n all_words = words.words('en')\n selected_words = []\n picker = ColorPicker(reset=True)\n colors = picker._get_colors()\n while count > 0:\n word = random.choice(all_words)\n selected_words.insert(0, word)\n all_words.remove(word)\n count += -1\n del all_words\n for word in selected_words:\n color = colors.next()\n tag = Tag(slug=slugify(word), tag=word, color=color)\n tag.save()","def generate_sample(sentences, vocab, window):\n for sentence in sentences:\n word_vocabs = [vocab[w] for w in sentence if w in vocab and\n vocab[w]['prob'] > np.random.rand()]\n\n for index, word in enumerate(word_vocabs):\n center = word['index']\n reduced_window = np.random.randint(1, window + 1)\n\n # words before the center word\n for context in word_vocabs[max(0, index - reduced_window):index]:\n target = context['index']\n yield center, target\n\n # words after the center word\n for context in word_vocabs[(index + 1):(index + 1 + reduced_window)]:\n target = context['index']\n yield center, target","def generate_text_owc(model: Dict[str, Set[str]], n: int) -> str:\n # ACCUMULATOR: a list of the randomly-generated words so far\n words_so_far = []\n # We've provided this template as a starting point; you may modify it as necessary.\n words_so_far.append(generate_new_word(model))\n for x in range(0, n-1):\n key = words_so_far[x]\n new_word = generate_next_word(model,key)\n if new_word == \".\":\n words_so_far[x] = words_so_far[x]+'.'\n new_word= generate_new_word(model)\n elif new_word == {}:\n new_word = generate_new_word(model)\n words_so_far.append(new_word)\n\n return str.join(' ', words_so_far)","def generate_words(num_words, word_len, grid, reject_func=is_overlapping):\n height, width = len(grid), len(grid[0])\n restrictions = position_restrictions(word_len, height, width)\n word_hashes = set()\n words_positions = []\n words = []\n while len(word_hashes) < num_words:\n cardinal = random.choice(list(restrictions.keys()))\n (min_h, max_h), (min_w, max_w) = restrictions[cardinal]\n x0, y0 = random.randint(min_h, max_h), random.randint(min_w, max_w)\n x, y = DIRECTIONS[cardinal]\n positions = [(x0 + x * i, y0 + y * i) for i in range(word_len)]\n if (word_hash := (cardinal, (x0, y0))) not in word_hashes \\\n and not reject_func(p_set := set(positions), words_positions):\n words.append(\"\".join(str(grid[x][y]) for x, y in positions))\n word_hashes.add(word_hash)\n words_positions.append(p_set)\n return words","def build_vocab(sentences_list, vocab_size, visual_fld):\n words = [word for sentence in sentences_list for word in sentence]\n utils.safe_mkdir(visual_fld)\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\n dictionary = {}\n index_dictionary = {}\n count = [('UNK', -1)]\n count.extend(Counter(words).most_common(vocab_size - 1))\n for index, (word, _) in enumerate(count):\n dictionary[word] = index\n index_dictionary[index] = word\n fd.write(word + '\\n')\n\n return dictionary, index_dictionary","def generate_words(self, count=100):\n\n with self.open_text_data() as f:\n result = self.read_words(f, count=count)\n return result","def create_word(char_list):","def fill_list(self):\n for i in range(0, constants.STARTING_WORDS):\n random_word = constants.LIBRARY[random.randint(0, len(constants.LIBRARY) - 1)]\n x = random.randint(1, constants.MAX_X - len(self.get_text()))\n y = random.randint(1, constants.MAX_Y - len(self.get_text()))\n position = Point(x, y)\n self.set_position(position)\n velocity = Point(0, 1)\n self._add_segment(random_word, position, velocity)\n print()","def build_vocab(words, vocab_size, visual_fld=None):\n utils.safe_mkdir(visual_fld)\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\n\n dictionary = dict()\n count = [('UNK', -1)]\n index = 0\n count.extend(Counter(words).most_common(vocab_size - 1))\n\n for word, _ in count:\n dictionary[word] = index\n index += 1\n file.write(word + '\\n')\n\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n file.close()\n return dictionary, index_dictionary","def random_shape(gts, reference_shape, pca_model):\n\n def synthesize(lms):\n return detect.synthesize_detection(pca_model, menpo.shape.PointCloud(\n lms).bounding_box()).points.astype(np.float32)\n\n bb, = tf.py_func(synthesize, [gts], [tf.float32])\n shape = align_reference_shape(reference_shape, bb)\n shape.set_shape(reference_shape.get_shape())\n\n return shape","def sample( self, n, words = 100, n_views = 3 ):\n\n # Initialise each view to be 0s\n docs = [ sc.zeros( (n, self.W) ) for v in xrange( n_views ) ]\n\n for i in xrange( n ):\n # Draw topic weights once for a document\n weights = dirichlet( self.alphas )\n\n # Draw the words/k for each view\n for v in xrange( n_views ):\n words_ = words/n_views\n # Get the topic counts\n cnts = multinomial( words_, weights )\n for (k, cnt) in zip( xrange( self.K ), cnts ):\n freq = multinomial( cnt, self.topics.T[k] )/float(words_)\n # Get the word frequencies for this document\n docs[v][i] += freq\n\n return docs","def generate_sample(index_words, context_window_size):\n for index, center in enumerate(index_words):\n context = random.randint(1, context_window_size)\n # get a random target before the center word\n for target in index_words[max(0, index - context): index]:\n yield center, target\n # get a random target after the center wrod\n for target in index_words[index + 1: index + context + 1]:\n yield center, target","def words_to_edges_v(words, word_threshold=DEFAULT_MIN_WORDS_VERTICAL):\n # Find words that share the same left, right, or centerpoints\n by_x0 = cluster_objects(words, \"x0\", 1)\n by_x1 = cluster_objects(words, \"x1\", 1)\n by_center = cluster_objects(words, lambda x: (x[\"x0\"] + x[\"x1\"]) / 2, 1)\n clusters = by_x0 + by_x1 + by_center\n\n # Find the points that align with the most words\n sorted_clusters = sorted(clusters, key=lambda x: -len(x))\n large_clusters = filter(lambda x: len(x) >= word_threshold, sorted_clusters)\n\n # For each of those points, find the bboxes fitting all matching words\n bboxes = list(map(objects_to_bbox, large_clusters))\n\n # Iterate through those bboxes, condensing overlapping bboxes\n condensed_bboxes = []\n for bbox in bboxes:\n overlap = False\n for c in condensed_bboxes:\n if get_bbox_overlap(bbox, c):\n overlap = True\n break\n if not overlap:\n condensed_bboxes.append(bbox)\n\n if len(condensed_bboxes) == 0:\n return []\n\n condensed_rects = map(bbox_to_rect, condensed_bboxes)\n sorted_rects = list(sorted(condensed_rects, key=itemgetter(\"x0\")))\n\n max_x1 = max(map(itemgetter(\"x1\"), sorted_rects))\n min_top = min(map(itemgetter(\"top\"), sorted_rects))\n max_bottom = max(map(itemgetter(\"bottom\"), sorted_rects))\n\n # Describe all the left-hand edges of each text cluster\n edges = [\n {\n \"x0\": b[\"x0\"],\n \"x1\": b[\"x0\"],\n \"top\": min_top,\n \"bottom\": max_bottom,\n \"height\": max_bottom - min_top,\n \"orientation\": \"v\",\n }\n for b in sorted_rects\n ] + [\n {\n \"x0\": max_x1,\n \"x1\": max_x1,\n \"top\": min_top,\n \"bottom\": max_bottom,\n \"height\": max_bottom - min_top,\n \"orientation\": \"v\",\n }\n ]\n\n return edges","def createParagraph(self, nsentences=0, words=[]):\n ww = []\n for w in words:\n w_ = w.lower()\n if w_ in self.plain_words:\n ww.append(w_)\n words = ww\n if not nsentences:\n nsentences = n.random.randint(3,10)\n sentences = []\n ri = n.random.randint\n for i in range(nsentences):\n sentences.append(self.createSentence(ri(1,4),ri(1,4),ri(1,4),ri(1,4),prep=n.random.randint(0,2)))\n\n w = set()\n s1 = []\n s2 = []\n for s in sentences:\n have_word = 0\n for ww in words:\n if ww in s:\n w.add(ww)\n have_word = 1\n if have_word:\n s1.append(s)\n else:\n s2.append(s)\n w2 = set(words)\n w_ = w2.difference(w)\n while s2 and w_:\n ss = self.createSentence(prep=n.random.randint(0,2))\n w__ = w_.copy()\n for w in w__:\n if w in ss:\n s1.append(ss)\n s2.pop()\n w_.remove(w)\n paragraph = \". \".join(s1+s2)\n return paragraph","def gen_fake_topic_word(topic_word_shape, fake_idxs):\n if topic_word_shape[0] != len(fake_idxs):\n raise ValueError(\"topic num isn't equal\")\n fake_topic_word = np.full(topic_word_shape, -1, dtype=np.int32)\n for tidx in range(topic_word_shape[0]):\n tmp = len(fake_idxs[0])\n for widx in fake_idxs[tidx]:\n fake_topic_word[tidx][widx] = tmp\n tmp -= 1\n return fake_topic_word","def makeFeatureVec(words, model, num_features):\n\t# Initialize an empty numpy array (for speed) \n\tfeatureVec = np.zeros((num_features,), dtype=\"float32\")\n\t# Initialize a counter (number of words)\n\tnwords = 0.\n\t \n\t# Index2word is a list that contains the names of the words in the model's vocabulary. \n\tindex2word_set = set(model.index2word)\n\t# \n\t# Loop over each word in the review and, if it is in the model's vocaublary, add \n\t# its feature vector to the total \n\tfor word in words:\n\t\tif word in index2word_set:\n\t\t\tnwords = nwords + 1.\n\t\t\tfeatureVec = np.add(featureVec,model[word])\n\t# \n\t# Divide the result by the number of words to get the average \n\tfeatureVec = np.divide(featureVec,nwords)\n\treturn featureVec","def build_doc_sense_vec(self):\n\t\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\n\t\t\tline = infile.readline()\n\t\t\ti = 0\n\t\t\twhile line:\n\t\t\t\tword = line.split()[0]\n\t\t\t\tif not self.word2IdVocabulary.has_key(word):\n\t\t\t\t\t# print i, word\n\t\t\t\t\t# else:\n\t\t\t\t\tself.word2IdVocabulary[word] = i\n\t\t\t\tif not self.id2WordVocabulary.has_key(i):\n\t\t\t\t\tself.id2WordVocabulary[i] = word\n\t\t\t\tline = infile.readline()\n\t\t\t\ti += 1\n\t\t\tself.vocab_num = len(self.word2IdVocabulary)\n\t\t\tprint \"vocabulary number:\" + str(self.vocab_num)\n\n\t\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\n\t\t\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\n\n\t\t\t\tfor i, line in enumerate(vecfile):\n\t\t\t\t\tif i % 10000 == 0:\n\t\t\t\t\t\tprint i\n\t\t\t\t\t# if i > 72:\n\t\t\t\t\t# \tbreak\n\t\t\t\t\tif i == 0:\n\t\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\telif i > 462667:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tvector_list.append(sline[1:])\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\t# vector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_array\n\t\t\t\t\t\t# vec_outfile.write(line)\n\t\t\t\t\telif i > 462887:\n\t\t\t\t\t\tbreak\n\t\t\t\t\telse:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_mean\n\t\t\t\t\t\t'''j = 0\n\t\t\t\t\t\tfor each_sense_vec in vector_array:\n\t\t\t\t\t\t\tif len(vector_array) > 1:\n\t\t\t\t\t\t\t\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n'\n\t\t\t\t\t\t\t\tj += 1\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t x: '%6f' % x})[1:-1] + '\\n'\n\n\t\t\t\t\t\t\tvec_outfile.write(new_line)'''\n\n\t\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\n\t\t\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\n\t\t\t\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\n\t\t\t\t\tprint \"Processing document file......\"\n\t\t\t\t\tline = docfile.readline().strip('\\n')\n\t\t\t\t\twhile line:\n\t\t\t\t\t\twords = line.split()\n\t\t\t\t\t\tnew_words = [x for x in words]\n\t\t\t\t\t\tfor i in range(len(words)):\n\t\t\t\t\t\t\tword_id = self.word2IdVocabulary[words[i]]\n\t\t\t\t\t\t\tsense_vecs = self.vectors[word_id]\n\t\t\t\t\t\t\tsense_num = len(sense_vecs)\n\t\t\t\t\t\t\tif sense_num > 1:\n\t\t\t\t\t\t\t\tcontext_words = []\n\t\t\t\t\t\t\t\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\n\t\t\t\t\t\t\t\t\tif x != i and 0 <= x < len(words):\n\t\t\t\t\t\t\t\t\t\tcontext_words.append(words[x])\n\t\t\t\t\t\t\t\tsense_index = self.select_attention(context_words, sense_vecs)\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[sense_index]\n\t\t\t\t\t\t\t\tnew_wordi = words[i] + '_' + str(sense_index)\n\t\t\t\t\t\t\t\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\t\tnew_words[i] = new_wordi\n\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[0]\n\t\t\t\t\t\t\t\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n')\n\n\t\t\t\t\t\tdoc_outfile.write(' '.join(new_words) + '\\n')\n\n\t\t\t\t\t\tline = docfile.readline()\n\n\t\treturn self.vector_word_doc","def make_image():\n # get the mask\n twitter_mask = np.array(Image.open('resource/twitter-mask.png'))\n\n wc = WordCloud(background_color='white', max_words=100, mask=twitter_mask, contour_width=3,\n contour_color='steelblue')\n\n # generate word cloud\n wc.generate_from_frequencies(get_word_frequency())\n\n # store to file\n wc.to_file('/tmp/twitter.png')\n\n # show\n frame = cv2.imread('/tmp/twitter.png')\n cv2.imshow('figure', frame)\n cv2.waitKey(60000)\n cv2.destroyAllWindows()","def get_random_words_from_wordnik(part_of_speech, limit):\n words = words_api.getRandomWords(includePartOfSpeech=part_of_speech, limit=limit)\n\n random_words = []\n for word in words:\n random_words.append(word.word)\n # pprint(random_words)\n return random_words","def generateWord(self, parameters=None):\n\t\t# Initial set-up\n\t\tvowels = ['a', 'e', 'i', 'o', 'u']\n\t\tspecialVowels = ['y']\n\n\t\tconsonants = ['b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't']\n\t\tspecialConsonants = ['j', 'q', 'v', 'w', 'x', 'z']\n\n\t\tnewLetterFraction = 5\n\t\tvowelChance = 50 #percent\n\n\t\t#Determine how many words we're going to have to generate\n\t\trepeats = 1\n\t\tif parameters and len(parameters) > 0:\n\t\t\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\n\n\t\twords = []\n\t\tfor i in xrange(0, repeats):\n\t\t\tword = u\"\"\n\t\t\tcurrentVowelChance = vowelChance\n\t\t\tcurrentNewLetterFraction = newLetterFraction\n\t\t\tconsonantCount = 0\n\t\t\twhile random.randint(0, currentNewLetterFraction) <= 6:\n\t\t\t\tif random.randint(1, 100) <= currentVowelChance:\n\t\t\t\t\tconsonantCount = 0\n\t\t\t\t\t#vowel. Check if we're going to add a special or normal vowel\n\t\t\t\t\tif random.randint(1, 100) <= 10:\n\t\t\t\t\t\tword += random.choice(specialVowels)\n\t\t\t\t\t\tcurrentVowelChance -= 30\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(vowels)\n\t\t\t\t\t\tcurrentVowelChance -= 20\n\t\t\t\telse:\n\t\t\t\t\tconsonantCount += 1\n\t\t\t\t\t#consonant, same deal\n\t\t\t\t\tif random.randint(1, 100) <= 25:\n\t\t\t\t\t\tword += random.choice(specialConsonants)\n\t\t\t\t\t\tcurrentVowelChance += 30\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(consonants)\n\t\t\t\t\t\tcurrentVowelChance += 20\n\t\t\t\t\tif consonantCount > 3:\n\t\t\t\t\t\tcurrentVowelChance = 100\n\t\t\t\tcurrentNewLetterFraction += 1\n\n\t\t\t#Enough letters added. Finish up\n\t\t\tword = word[0].upper() + word[1:]\n\t\t\twords.append(word)\n\n\t\t#Enough words generated, let's return the result\n\t\treturn u\", \".join(words)","def createSentence(self, n=0, v=0, o=0, p=0,prep=True):\n sentence = ''\n if not n:\n n = np.random.randint(1, 5)\n if not v:\n v = np.random.randint(1, 5)\n if not o:\n o = np.random.randint(1, 5)\n sentence += self.createPhrase(nwords=n) + ' '\n if sentence[:-1] not in ('mi', 'sina'):\n sentence += 'li '\n sentence += self.createPhrase(nwords=v) + ' e '\n sentence += self.createPhrase(nwords=o)\n if prep:\n if not p:\n p = np.random.randint(1, 5)\n sentence += ' ' + np.random.choice(self.prepositions) + ' ' + self.createPhrase(nwords=p)\n return sentence","def create_vocabulary(sentences, path):\n print('creating vocab..')\n\n word_dict = dict(); vocabulary = dict()\n for sentence in sentences:\n for word in nltk.word_tokenize(sentence):\n if word not in word_dict:\n word_dict[word] = ''\n word_dict['<s>'] = ''\n word_dict['</s>'] = ''\n\n with open(path, encoding=\"utf8\") as f:\n for line in f:\n word, vec = line.split(' ', 1)\n if word in word_dict:\n vocabulary[word] = np.fromstring(vec, sep=' ')\n\n print('vocabulary was created successfully!')\n return vocabulary","def generate(net, z, maxlen=50, im=None, init=None, use_end=True):\n caption = lm_tools.sample(net, z['word_dict'], z['index_dict'], num=maxlen, Im=im, initial=init, use_end=use_end)\n print ' '.join(caption)","def generate(handle, occurrence_threshold): # verbose, static creation\n tokenizer = Tokenizer(occurrence_threshold=occurrence_threshold)\n tokenizer.generate(handle)\n return tokenizer","def buildVocabulary(paragraphs, verbose=True):\n vocabulary = []\n \n for p in paragraphs:\n for word in p.split():\n vocabulary.append(word)\n\n vocabulary = set(vocabulary)\n if verbose:\n print('Built vocabulary of %d unique words'%len(vocabulary))\n \n return list(vocabulary)","def create_wordcloud(processed_text, filename):\n\n\n pyplot.clf()\n wordcloud = WordCloud(background_color='white', max_font_size=40, relative_scaling=.5).generate(' '.join(processed_text))\n pyplot.imshow(wordcloud)\n pyplot.axis('off')\n\n pyplot.savefig(filename)","def card_generator(mw, prob_dist_dict, gensim_model):\n\n # First things first: make sure that the word is actually in the word2vec vocab.\n # word_vectors = gensim_model.wv\n if mw not in gensim_model.wv.vocab:\n return False\n\n # Generate five categories with the weighted probabilities based on their frequency in the gold standard data.\n five_semrels_list = select_five_categories(prob_dist_dict)\n five_semrels = pd.Series(five_semrels_list)\n\n # Count the number of instances of each semrel category in that list.\n semrels_counts = dict( five_semrels.value_counts() )\n\n # Generate the semantic relations dictionary.\n srdict = sr.make_semrel_dict(mw)\n\n # Rejig five_semrels_list, if need be, to one whose labels are compatible with the cardinality of the sets available\n # in srdict.\n good_five_labels = get_good_label_distrib(srdict, semrels_counts)\n\n # Now we just populate a list with the required number of each kind of word!\n # First, initialise list to contain the five final Taboo words (yay!)\n tws = []\n\n # Go through good_five_labels and, for the labels that aren't 'collocation', access their list in the dictionary and\n # randomly select however many out of it.\n for label, count in good_five_labels.items():\n if label != 'collocation':\n tws.extend( rd.sample( tuple( srdict[label] ), count ) )\n\n # Now, take the number of collocations needed and return the most similar words according to gensim, removing the\n # words that are forbidden (i.e. the main word and also the other words that are already in tws)\n forbidden_words = set(tws + [mw])\n num_coll = good_five_labels['collocation']\n collocates = sr.get_collocations(mw, forbidden_words, gensim_model, num_collocates = num_coll)\n\n # If there are more collocates than needed, randomly select num_coll of them and add to tws. Else just add list to tws.\n if len(collocates) > num_coll:\n tws.extend( rd.sample( tuple(collocates), num_coll ) )\n else:\n tws.extend(collocates)\n\n return {mw: tws}","def paragraph_selection(sample, mode):\n # predefined maximum length of paragraph\n MAX_P_LEN = 500\n # predefined splitter\n splitter = u'<splitter>'\n # topN of related paragraph to choose\n topN = 3\n doc_id = None\n if 'answer_docs' in sample and len(sample['answer_docs']) > 0:\n doc_id = sample['answer_docs'][0]\n if doc_id >= len(sample['documents']):\n # Data error, answer doc ID > number of documents, this sample\n # will be filtered by dataset.py\n return\n for d_idx, doc in enumerate(sample['documents']):\n if 'segmented_paragraphs_scores' not in doc:\n continue\n status = dup_remove(doc)\n segmented_title = doc[\"segmented_title\"]\n title_len = len(segmented_title)\n para_id = None\n if doc_id is not None:\n para_id = sample['documents'][doc_id]['most_related_para']\n total_len = title_len + sum(doc['paragraphs_length'])\n # add splitter\n para_num = len(doc[\"segmented_paragraphs\"])\n total_len += para_num\n if total_len <= MAX_P_LEN:\n incre_len = title_len\n total_segmented_content = copy.deepcopy(segmented_title)\n for p_idx, segmented_para in enumerate(doc[\"segmented_paragraphs\"]):\n if doc_id == d_idx and para_id > p_idx:\n incre_len += len([splitter] + segmented_para)\n if doc_id == d_idx and para_id == p_idx:\n incre_len += 1\n total_segmented_content += [splitter] + segmented_para\n if doc_id == d_idx:\n answer_start = incre_len + sample['answer_spans'][0][0]\n answer_end = incre_len + sample['answer_spans'][0][1]\n sample['answer_spans'][0][0] = answer_start\n sample['answer_spans'][0][1] = answer_end\n doc[\"segmented_paragraphs\"] = [total_segmented_content]\n doc[\"segmented_paragraphs_scores\"] = [1.0]\n doc['paragraphs_length'] = [total_len]\n doc['paragraphs'] = [''.join(total_segmented_content)]\n doc['most_related_para'] = 0\n continue\n # find topN paragraph id\n para_infos = []\n for p_idx, (para_tokens, para_scores) in \\\n enumerate(zip(doc['segmented_paragraphs'], doc['segmented_paragraphs_scores'])):\n para_infos.append((para_tokens, para_scores, len(para_tokens), p_idx))\n para_infos.sort(key=lambda x: (-x[1], x[2]))\n topN_idx = []\n for para_info in para_infos[:topN]:\n topN_idx.append(para_info[-1])\n final_idx = []\n total_len = title_len\n if doc_id == d_idx:\n if mode == \"train\":\n final_idx.append(para_id)\n total_len = title_len + 1 + doc['paragraphs_length'][para_id]\n for id in topN_idx:\n if total_len > MAX_P_LEN:\n break\n if doc_id == d_idx and id == para_id and mode == \"train\":\n continue\n total_len += 1 + doc['paragraphs_length'][id] \n final_idx.append(id)\n total_segmented_content = copy.deepcopy(segmented_title)\n final_idx.sort()\n incre_len = title_len\n for id in final_idx:\n if doc_id == d_idx and id < para_id:\n incre_len += 1 + doc['paragraphs_length'][id]\n if doc_id == d_idx and id == para_id:\n incre_len += 1\n total_segmented_content += [splitter] + doc['segmented_paragraphs'][id]\n if doc_id == d_idx:\n answer_start = incre_len + sample['answer_spans'][0][0]\n answer_end = incre_len + sample['answer_spans'][0][1]\n sample['answer_spans'][0][0] = answer_start\n sample['answer_spans'][0][1] = answer_end\n doc[\"segmented_paragraphs\"] = [total_segmented_content]\n doc[\"segmented_paragraphs_scores\"] = [1.0]\n doc['paragraphs_length'] = [total_len]\n doc['paragraphs'] = [''.join(total_segmented_content)]\n doc['most_related_para'] = 0","def build_model():\n \n #english trained optimized pipeline for word embedding\n nlp = spacy.load(\"en_core_web_md\") # this model will give you 300D\n \n pipeline = Pipeline([\n ('features', FeatureUnion([\n ('text_pipeline', Pipeline([\n ('vect', CountVectorizer(tokenizer=tokenize)),\n ('tfidf', TfidfTransformer()),\n ])),\n \n ('embeddings_pipeline', Pipeline([\n ('vect_trans',SpacyVectorTransformer(nlp)),\n ('reduce_dim', TruncatedSVD(50)),\n ])),\n \n ])),\n \n ('clf', MultiOutputClassifier(RandomForestClassifier()))\n ])\n \n parameters = {\n 'features__text_pipeline__vect__max_df': (0.5, 0.75, 1.0),\n 'features__embeddings_pipeline__reduce_dim__n_components':(50,60,70,100,120,130,150)\n }\n cv = GridSearchCV(pipeline, param_grid=parameters,cv=2)\n \n return cv","def build_data(self, data_folder, cv=10, clean_string=False):\n revs = []\n # pos_file = loadmodel(data_folder[0])\n # neg_file = loadmodel(data_folder[1])\n pos_texts = loadmodel(data_folder[0]).get(\"content\")\n neg_texts = loadmodel(data_folder[1]).get(\"content\")\n vocab = defaultdict(float)\n happyList = [ \":-)\", \":)\", \":D\", \":o)\", \":]\", \":3\", \":c)\", \":>\", \"=]\", \"8)\", \"=)\", \":}\", \":^)\", \":?)\", \":-)\", \": )\", \": D\", \": o)\", \":]\", \": 3\", \":c)\", \":>\", \"= ]\", \"8 )\", \"= )\", \": }\", \":^)\", \":?)\" ]\n sadList = [ \">:[\", \":-(\", \":(\", \":-c\", \":c\", \":-<\", \":?C\", \":<\", \":-[\", \":[\", \":{\",\">:[\", \":-(\", \": (\", \":-c\", \": c\", \": -<\", \": ?C\", \": <\", \": -[\", \": [\", \": {\" ]\n for line in pos_texts:\n rev = []\n rev.append(line.strip())\n\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n #print orig_rev\n words = set(orig_rev.split())\n for word in words:\n if word in happyList or word in sadList:\n pass\n else:\n vocab[word] += 1\n datum = {\"y\":1,\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n \"split\": np.random.randint(0,cv)}\n revs.append(datum)\n\n for line in neg_texts:\n rev = []\n rev.append(line.strip())\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n words = set(orig_rev.split())\n for word in words:\n if word in happyList or word in sadList:\n pass\n else:\n vocab[word] += 1\n datum = {\"y\":0,\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n \"split\": np.random.randint(0,cv)}\n revs.append(datum)\n return revs, vocab","def generate(size, data_dim=5, n_phrase_labels=4, n_words=3,\n n_phrase_words=3, n_phrases=5, label_noise=0.,\n min_sent_len=5, max_sent_len=5, tag_end=True):\n assert n_words < 256\n assert max_sent_len >= n_phrase_words\n global dictionary, phrases\n\n # generate dictionary\n dictionary = uniform(-1.0, 1.0, size=(n_words, data_dim))\n\n # generate n_phrases unique word sequences of length n_phrase_words\n print \"Generating %d phrases\" % n_phrases\n phrases = []\n phrase_labels = []\n while len(phrases) != n_phrases:\n phrases = np.unique(np.array([\"\".join(map(chr, randint(n_words, size=n_phrase_words)))\n for i in xrange(n_phrases)], dtype=np.object))\n assert np.unique(map(len, phrases)) == n_phrase_words\n phrase_labels = 1+randint(n_phrase_labels-1, size=n_phrases)\n\n # generate 'sentences'\n print \"Generating %d sentences\" % sum(size)\n Xind = []\n Y = []\n for i in xrange(sum(size)):\n while True:\n sent_len = randint(min_sent_len, max_sent_len+1)\n sent = \"\".join(map(chr, randint(n_words, size=sent_len)))\n if contains_any_phrase(sent, phrases):\n print \".\",\n break\n Y.append(np.zeros(sent_len,dtype=np.int))\n Xind.append(sent)\n\n # generate labels for dataset\n print \"Generating labels for the sentences...\"\n for phrase, plabel in zip(phrases, phrase_labels):\n for idx, sent in enumerate(Xind):\n start = 0\n while True:\n sidx = sent.find(phrase, start)\n if sidx < 0:\n break\n if tag_end:\n Y[idx][sidx+len(phrase)-1] = plabel\n else:\n Y[idx][sidx] = plabel\n start += 1\n\n print \"Trafo...\"\n # transform dataset to code\n if data_dim > 1:\n X = [[dictionary[ord(c)] for c in sent] for sent in Xind]\n else:\n X = [[ord(c) for c in sent] for sent in Xind]\n\n Xtrain, Xtest = X[:size[0]], X[size[0]:]\n Ytrain, Ytest = Y[:size[0]], Y[size[0]:]\n\n # training label noise\n for sent in Ytrain:\n mask = uniform(size=sent.size) < label_noise\n sent[mask] = randint(n_phrase_labels, size=mask.sum())\n print \"Done.\"\n\n return Xtrain, Xtest, Ytrain, Ytest","def feature_vecs_DOC(train_pos, train_neg, test_pos, test_neg):\n # Doc2Vec requires LabeledSentence objects as input.\n # Turn the datasets from lists of words to lists of LabeledSentence objects.\n # YOUR CODE HERE\n labeled_train_pos = []\n labeled_train_neg = []\n labeled_test_pos = []\n labeled_test_neg = []\n i = 0\n for line in train_pos:\n labeled_train_pos.append(LabeledSentence(line, ['TRAIN_POS_%i' % i]))\n i += 1\n i = 0\n for line in train_neg:\n labeled_train_neg.append(LabeledSentence(line, ['TRAIN_NEG_%i' % i]))\n i += 1\n i = 0\n for line in test_pos:\n labeled_test_pos.append(LabeledSentence(line, ['TEST_POS_%i' % i]))\n i += 1\n i = 0\n for line in test_neg:\n labeled_test_neg.append(LabeledSentence(line, ['TEST_NEG_%i' % i]))\n i += 1\n\n # Initialize model\n model = Doc2Vec(min_count=1, window=10, size=100, sample=1e-4, negative=5, workers=4)\n sentences = labeled_train_pos + labeled_train_neg + labeled_test_pos + labeled_test_neg\n model.build_vocab(sentences)\n\n # Train the model\n # This may take a bit to run \n for i in range(5):\n print \"Training iteration %d\" % (i)\n random.shuffle(sentences)\n model.train(sentences)\n\n # Use the docvecs function to extract the feature vectors for the training and test data\n # YOUR CODE HERE\n train_pos_vec = []\n train_neg_vec = []\n test_pos_vec = []\n test_neg_vec = []\n for j in range(len(train_pos)):\n train_pos_vec.append(model.docvecs['TRAIN_POS_%i' % j])\n for j in range(len(train_neg)):\n train_neg_vec.append(model.docvecs['TRAIN_NEG_%i' % j])\n for j in range(len(test_pos)):\n test_pos_vec.append(model.docvecs['TEST_POS_%i' % j])\n for j in range(len(test_neg)):\n test_neg_vec.append(model.docvecs['TEST_NEG_%i' % j])\n\n # Return the four feature vectors\n return train_pos_vec, train_neg_vec, test_pos_vec, test_neg_vec","def build_Wordv(word2vec_dict, k):\r\n vocab_size = len(word2vec_dict)\r\n word2id_dict = dict()\r\n W = np.zeros(shape=(vocab_size + 1, k))\r\n W[0] = np.zeros(k)\r\n i = 1\r\n for word in word2vec_dict:\r\n # print type(word), ' | ', word\r\n W[i] = word2vec_dict[word]\r\n # print type(W[i]), \" | \", W[i]\r\n word2id_dict[word] = i\r\n i += 1\r\n return W, word2id_dict","def creating_feature_vector():\r\n\twordlist = []\r\n\tlabel = \"\"\r\n\tfw = open(\"feature_vector.txt\", \"w+\", encoding = \"utf-8\")\r\n\twith open(\"D:\\\\Python_Prac\\\\wordstag\\\\modules\\\\HI_EN_TRAIN.txt\", \"r\", encoding = \"utf-8\") as f:\r\n\t\tfor line in f:\r\n\t\t\twordlist.append(line)\r\n\t\tfor index, line in enumerate(wordlist):\r\n\t\t\tif line == \"\\n\":\r\n\t\t\t\tcontinue\r\n\t\t\tcontext = line.split(\"\\t\")\r\n\t\t\tlabel = context[1]\r\n\t\t\tfeature_vector = label+\" \"\r\n\t\t\tngram_vector = ngram_frequency(str(context[0]))\r\n\t\t\tfor vector in ngram_vector:\r\n\t\t\t\tfeature_vector += str(vector)+\" \"\r\n\t\t\tfeature_vector += str(is_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_hindi(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_abbr(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_hindi(context[0]))+\" \"\r\n\t\t\tbefore = [0,0,0]\r\n\t\t\tafter = [0,0,0]\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index+i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in before:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfor i in after:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfeature_vector += \"\\n\"\r\n\t\t\tfw.write(feature_vector)\r\n\t\t\tprint(\"Proceeding...\"+str(index+1)+\" of 16683\")\r\n\r\n\tfw.close()","def word2vec_generation(self, utterance, with_punctuations):\n vector = []\n\n #words = self.text_preparation(utterance)\n\n words = utterance\n\n #model_ = Word2Vec.load('model.bin')\n #if not self.is_word_in_word2vec_vocabulary(utterance, model_):\n # self.retrain_model([words])\n\n if with_punctuations:\n new_model = Word2Vec.load('./model/model_word2vec.bin')\n else:\n new_model = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\n\n\n\n # TODO: how generate word2vec vectors for each utterance using the vocabularies in Word2vec model?\n\n #First: average of Word2Vec vectors in each utterance\n for w in words:\n vector.append(new_model.wv[w])\n\n return np.mean(vector, axis=0)","def build_data_cv(file, split_dict, label_dict, clean_string=False):\n revs = []\n f = open(file)\n vocab = defaultdict(float)\n \n for index, line in enumerate(f.readlines()): \n rev = []\n rev.append(line.strip())\n if clean_string:\n orig_rev = clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev)\n words = set(orig_rev.split())\n for word in words:\n vocab[word] += 1\n datum = {\"y\":label_dict[index], \n \"text\": orig_rev, \n \"num_words\": len(orig_rev.split()),\n \"split\": split_dict[index]}#1 or 2\n revs.append(datum)\n\n return revs, vocab","def pregroup_draw(words, cups, **params):\n textpad = params.get('textpad', (.1, .2))\n textpad_words = params.get('textpad_words', (0, .1))\n space = params.get('space', .5)\n width = params.get('width', 2.)\n fontsize = params.get('fontsize', None)\n\n backend = TikzBackend(use_tikzstyles=params.get('use_tikzstyles', None))\\\n if params.get('to_tikz', False)\\\n else MatBackend(figsize=params.get('figsize', None))\n\n def draw_triangles(words):\n scan = []\n for i, word in enumerate(words.boxes):\n for j, _ in enumerate(word.cod):\n x_wire = (space + width) * i\\\n + (width / (len(word.cod) + 1)) * (j + 1)\n scan.append(x_wire)\n if params.get('draw_types', True):\n backend.draw_text(\n str(word.cod[j]), x_wire + textpad[0], -textpad[1],\n fontsize=params.get('fontsize_types', fontsize))\n backend.draw_polygon(\n ((space + width) * i, 0),\n ((space + width) * i + width, 0),\n ((space + width) * i + width / 2, 1),\n color=DEFAULT.color)\n backend.draw_text(\n str(word), (space + width) * i + width / 2 + textpad_words[0],\n textpad_words[1], ha='center', fontsize=fontsize)\n return scan\n\n def draw_cups_and_wires(cups, scan):\n for j, off in [(j, off)\n for j, s in enumerate(cups) for off in s.offsets]:\n middle = (scan[off] + scan[off + 1]) / 2\n backend.draw_wire((scan[off], 0), (middle, - j - 1), bend_in=True)\n backend.draw_wire(\n (scan[off + 1], 0), (middle, - j - 1), bend_in=True)\n scan = scan[:off] + scan[off + 2:]\n for i, _ in enumerate(cups[-1].cod if cups else words.cod):\n label = str(cups[-1].cod[i]) if cups else \"\"\n backend.draw_wire((scan[i], 0), (scan[i], - (len(cups) or 1) - 1))\n if params.get('draw_types', True):\n backend.draw_text(\n label, scan[i] + textpad[0], - (len(cups) or 1) - space,\n fontsize=params.get('fontsize_types', fontsize))\n\n scan = draw_triangles(words.normal_form())\n draw_cups_and_wires(cups, scan)\n backend.output(\n params.get('path', None),\n tikz_options=params.get('tikz_options', None),\n xlim=(0, (space + width) * len(words.boxes) - space),\n ylim=(- len(cups) - space, 1),\n margins=params.get('margins', DEFAULT.margins),\n aspect=params.get('aspect', DEFAULT.aspect))","def build_new_text(tgram, start_words, max_words):\n out_words = []\n for i in range(max_words - 2):\n if start_words in tgram:\n next_word = random.choice(tgram[start_words])\n out_words.append(next_word)\n start_words = start_words.split()\n start_words = start_words[1] + \" \" + next_word\n else:\n break\n out_words = \" \".join(out_words)\n return out_words","def createPhrase(self, nsy=0, nwords=0, vowel=False):\n phrase = ''\n if nwords:\n if nsy == 0:\n nsy = n.random.randint(1,7)\n for i in range(nwords):\n w = n.random.choice(self.plain_words)\n phrase += w + ' '\n else:\n if nsy == 0:\n nsy = n.random.randint(1,7)\n nsy_ = 0\n while nsy_ < nsy:\n w = n.random.choice(self.plain_words)\n s = self._getSyllables(w)\n l = len(s)\n if w[0] in self.vowels and vowel: # elision\n l -= 1\n if nsy_+l > nsy:\n continue\n nsy_ += l\n phrase += w + ' '\n if w[-1] in self.vowels:\n vowel = 1\n else:\n vowel = 0\n p = phrase[:-1]\n p_ = p.split()\n nsy_ = sum([len(self._getSyllables(i)) for i in p_])\n if len(p_) > 2 and nsy_ > 4:\n if n.random.random() < .2: # use pi in 1/5 of sentences\n # print('\\n', p, self._countSyllables(p))\n where = n.random.randint(len(p_)-2)\n p_.insert(where+1, 'pi')\n if p_[where+2][0] not in self.vowels or (p_[where+2][0] in self.vowels and p_[where][-1] in self.vowels):\n # choose a words with two or three syllables\n # and make them one syllable shorter\n p__ = ' '.join(p_)\n while self._countSyllables(p__) != self._countSyllables(p):\n sy__ = n.array([len(self._getSyllables(i)) for i in p_])\n if n.all(sy__ == 1):\n if self._countSyllables(' '.join(p_)) < nsy:\n where_ = n.random.randint(len(p_))\n p_.insert(where_, n.random.choice(self.plain_words))\n elif self._countSyllables(' '.join(p_)) > nsy:\n chosen = n.random.randint(0, len(p_))\n while p_[chosen] == 'pi':\n\n chosen = n.random.randint(0, len(p_))\n p_.pop(chosen)\n else:\n ok = (sy__ > 1).nonzero()[0]\n chosen = n.random.choice(ok)\n size = sy__[chosen]\n w = n.random.choice(self.words_nsy[size-2])\n p_[chosen] = w\n p__ = ' '.join(p_)\n # print(' '.join(p_), self._countSyllables(' '.join(p_)))\n pp = ' '.join(p_)\n\n return pp","def generate_text(model, w2vmodel, nb_epoch, length=75, max_seq_length=20, seed=\"Rain drop drop top\"):\n global sample\n generated = ''\n sequences = seed\n\n generated += seed\n\n #clean seed\n seed=re.sub(r'<[^<]+?>', '', seed)\n #remove encoding characters like \\x86\n seed=re.sub(r'[^\\x00-\\x7f]','',seed)\n seed=re.sub(r'\\#','',seed)\n #remove punctuation\n seed=re.sub(r'[^A-Za-z0-9\\s]','',seed)\n\n #shorten if longer than max_seq_length\n seed = seed.split(' ')[:max_seq_length]\n\n word_ix_list = []\n for word in seed:\n try:\n word = word_to_ix(word,w2vmodel)\n except:\n #since we're using -1 as a null word (why we also pad with the not in vocab index), we'll use that for words that aren't in the word2vec model\n print('Warning: {0} not contained in training vocabulary. It will be ignored when computing output.'.format(word))\n word = word_to_ix('_UNSEEN_',w2vmodel)\n word_ix_list.append(word)\n\n #pad word_list with the unseen word2vec if shorter than max_seq_length\n word_ix_list = [word_to_ix('_UNSEEN_',w2vmodel)] * (max_seq_length-len(word_ix_list)) + word_ix_list\n\n for temp in [0.2, 0.5, .75, 1.0]:\n print('temperature: ', temp)\n for word in range(length):\n #reshape wordlist\n word_ix_list = np.asarray(word_ix_list).reshape(1,max_seq_length)\n\n #prediction = model.predict(x=word_ix_list)\n #next_ix = np.argmax(prediction)\n prediction = model.predict(x=word_ix_list,verbose=0)[0]\n next_ix = sample(prediction, temp)\n predicted_word = ix_to_word(next_ix,w2vmodel)\n\n generated += (' ' + predicted_word) #add predicted word to the generated output\n\n #remove first word from the word list to reduce the array for the max sequence length for the model\n word_ix_list = np.append(word_ix_list,next_ix)\n word_ix_list.shape\n word_ix_list = np.delete(word_ix_list,0,0)\n print(generated)\n print('-----')\n #print(generated)\n return","def create_instances_from_document(\n all_documents, document_index, max_seq_length, short_seq_prob,\n masked_lm_prob, max_predictions_per_seq, vocab_words, rng):\n document = all_documents[document_index]\n\n # Account for [CLS], [SEP], [SEP]\n max_num_tokens = max_seq_length - 3\n\n # We *usually* want to fill up the entire sequence since we are padding\n # to `max_seq_length` anyways, so short sequences are generally wasted\n # computation. However, we *sometimes*\n # (i.e., short_seq_prob == 0.1 == 10% of the time) want to use shorter\n # sequences to minimize the mismatch between pre-training and fine-tuning.\n # The `target_seq_length` is just a rough target however, whereas\n # `max_seq_length` is a hard limit.\n target_seq_length = max_num_tokens\n if rng.random() < short_seq_prob:\n target_seq_length = rng.randint(2, max_num_tokens)\n\n # We DON'T just concatenate all of the tokens from a document into a long\n # sequence and choose an arbitrary split point because this would make the\n # next sentence prediction task too easy. Instead, we split the input into\n # segments \"A\" and \"B\" based on the actual \"sentences\" provided by the user\n # input.\n instances = []\n current_chunk = []\n current_length = 0\n i = 0\n while i < len(document):\n segment = document[i]\n current_chunk.append(segment)\n current_length += len(segment)\n if i == len(document) - 1 or current_length >= target_seq_length:\n if current_chunk:\n # `a_end` is how many segments from `current_chunk` go into the `A`\n # (first) sentence.\n a_end = 1\n if len(current_chunk) >= 2:\n a_end = rng.randint(1, len(current_chunk) - 1)\n\n tokens_a = []\n for j in range(a_end):\n tokens_a.extend(current_chunk[j])\n\n tokens_b = []\n # Random next\n is_random_next = False\n if len(current_chunk) == 1 or rng.random() < 0.5:\n is_random_next = True\n target_b_length = target_seq_length - len(tokens_a)\n\n # This should rarely go for more than one iteration for large\n # corpora. However, just to be careful, we try to make sure that\n # the random document is not the same as the document\n # we're processing.\n for _ in range(10):\n random_document_index = rng.randint(\n 0, len(all_documents) - 1)\n if random_document_index != document_index:\n break\n\n random_document = all_documents[random_document_index]\n random_start = rng.randint(0, len(random_document) - 1)\n for j in range(random_start, len(random_document)):\n tokens_b.extend(random_document[j])\n if len(tokens_b) >= target_b_length:\n break\n # We didn't actually use these segments so we \"put them back\" so\n # they don't go to waste.\n num_unused_segments = len(current_chunk) - a_end\n i -= num_unused_segments\n # Actual next\n else:\n is_random_next = False\n for j in range(a_end, len(current_chunk)):\n tokens_b.extend(current_chunk[j])\n truncate_seq_pair(tokens_a, tokens_b, None,\n max_num_tokens, rng)\n if len(tokens_a) < 1 or len(tokens_b) < 1:\n current_chunk = []\n current_length = 0\n i += 1\n continue\n assert len(tokens_a) >= 1, tokens_a\n assert len(tokens_b) >= 1, tokens_b\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\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n for token in tokens_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n\n (tokens, masked_lm_positions,\n masked_lm_labels) = create_masked_lm_predictions(\n tokens, masked_lm_prob, max_predictions_per_seq, vocab_words, rng)\n instance = TrainingInstance(\n tokens=tokens,\n segment_ids=segment_ids,\n is_random_next=is_random_next,\n masked_lm_positions=masked_lm_positions,\n masked_lm_labels=masked_lm_labels)\n instances.append(instance)\n current_chunk = []\n current_length = 0\n i += 1\n\n return instances","def make_text(sent, begin, end):\n lemmas = [sent.morps[begin].lemma(), ]\n for idx in range(begin+1, end):\n if sent.mid2wid[idx-1] != sent.mid2wid[idx]: # if go over word boundary\n # insert space between words\n lemmas.append(' ')\n lemmas.append(sent.morps[idx].lemma())\n return ''.join(lemmas)","def voc_rand_crop(feature, label, height, width):\n i, j, h, w = torchvision.transforms.RandomCrop.get_params(\n feature, output_size=(height, width))\n \n feature = torchvision.transforms.functional.crop(feature, i, j, h, w)\n label = torchvision.transforms.functional.crop(label, i, j, h, w) \n\n return feature, label","def initialize_out_of_vocab_words(dimension, choice='zero'):\r\n if choice == 'random':\r\n \"\"\"Returns a random vector of size dimension where mean is 0 and standard deviation is 1.\"\"\"\r\n return np.random.normal(size=dimension)\r\n elif choice == 'zero':\r\n \"\"\"Returns a vector of zeros of size dimension.\"\"\"\r\n return np.zeros(shape=dimension)","def construct_embedding(self):\n i = 0\n self.load_dicts()\n embedding_shape = (max(self.word2idx.values()) + 1,\n self.embedding_size)\n self.embedding = np.zeros(embedding_shape)\n\n with open(self.config.word_vec_fi_glove, 'r') as fi:\n for line in fi:\n word_vec = line.split(\" \")[1:]\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\n i += 1\n\n self.write_embedding()","def generate_bar_example(\n num_topics=10, num_documents=500, num_words_per_doc=100, alpha=1, beta=1, seed=None\n):\n\n width = 5\n\n vocab_size = width * width\n rng = random.Random()\n if seed is not None:\n rng.seed(seed)\n\n zeros = [[0 for i in range(width)] for j in range(width)]\n topic_squares = [zeros for i in range(num_topics)]\n for i in range(width):\n for j in range(width):\n topic_squares[i][i][j] = 1.0 / width\n for i in range(width):\n for j in range(width):\n topic_squares[width + i][j][i] = 1.0 / width\n topics = []\n for k in range(num_topics):\n topics.append(list(_itertools.chain(*topic_squares[k])))\n\n def weighted_choice(probs):\n total = sum(probs)\n r = rng.uniform(0, total)\n upto = 0\n for i, w in enumerate(probs):\n if upto + w > r:\n return i\n upto += w\n assert False, \"Shouldn't get here\"\n\n documents = []\n thetas = []\n for d in range(num_documents):\n doc = [0 for i in range(width * width)]\n topic_dist = [rng.gammavariate(1, 1) for k in range(num_topics)]\n topic_dist = [z / sum(topic_dist) for z in topic_dist]\n for i in range(num_words_per_doc):\n k = weighted_choice(topic_dist)\n w = weighted_choice(topics[k])\n doc[w] += 1\n thetas.append(topic_dist)\n documents.append(doc)\n\n sparse_documents = []\n for d in documents:\n sd = {}\n for i in range(width):\n for j in range(width):\n k = str(i) + \",\" + str(j)\n sd[k] = d[i * width + j]\n sparse_documents.append(sd)\n bow_documents = turicreate.SArray(sparse_documents)\n return bow_documents","def build_vocab(vocab_size, text_vector):\n vocab = Counter()\n for text in text_vector:\n for word in text.split(' '):\n vocab[word.lower()]+=1\n vocab = dict(vocab.most_common(vocab_size))\n return vocab","def surface_labelled_data_preparation(word_dictionary: {str, str}):\n X = []\n Y = []\n words = []\n\n for word in word_dictionary:\n segments = word.split('-')\n labels = word_dictionary[word].split('-')\n segment_features = []\n for i in range(len(segments)):\n features = {}\n\n segment_length = len(segments[i])\n features['length'] = segment_length\n\n features['segment.lower()'] = segments[i].lower()\n features['pos_in_word'] = i\n\n if segment_length % 2 == 0:\n features['even'] = 1\n else:\n features['odd'] = 1\n\n features['begin'] = segments[i][0]\n features['end'] = segments[i][len(segments[i]) - 1]\n\n try:\n features['prev_segment'] = segments[i - 1]\n except IndexError:\n features['prev_segment'] = ''\n # continue\n\n try:\n features['next_segment'] = segments[i + 1]\n except IndexError:\n features['next_segment'] = ''\n\n if segments[0].isupper():\n features['start_upper'] = 1\n else:\n features['start_lower'] = 1\n\n if segments[0] in 'aeiou':\n features['first_vowel'] = 1\n else:\n features['first_const'] = 1\n\n segment_features.append(features)\n words.append(segments)\n\n X.append(segment_features)\n Y.append(labels)\n words.append(word)\n\n return X, Y, words","def make_embedding(path, words, indices):\n #root = '/'.join(path.split('/')[0:-1])\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n #for path in all_paths:\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\n print(vec_path)\n if os.path.exists(vec_path+'.npy'):\n np_vecs = np.load(vec_path+'.npy')\n else:\n words_len = len(words)\n vecs = []\n if mode == 'word':\n f = load_model('wiki.en.bin')\n for i, w in enumerate(words):\n if mode == 'word':\n vec = f.get_word_vector(w)\n else:\n vec = eye[indices[w]]\n vecs.append(vec) \n if i % 10000 == 0:\n print(\"{} / {}\".format(i, words_len))\n np_vecs = np.asarray(vecs, dtype=np.int8)\n np.save(vec_path, np_vecs)\n return np_vecs","def build_vocab(captions, threshold=0):\n\n\tcounter = Counter()\n\tfor caption in captions:\n\t\ttokens = caption.lower().split('/') \n\t\tcounter.update(tokens)\n\n\n\t# If the word frequency is less than 'threshold', then the word is discarded.\n\twords = [word for word, cnt in counter.items() if cnt >= threshold]\n\t# Creates a vocab wrapper and add some special tokens.\n\tvocab = Vocabulary()\n\tvocab.add_word('<pad>')\n\tvocab.add_word('<start>')\n\tvocab.add_word('<end>')\n\tvocab.add_word('<unk>')\n\n\t# Adds the words to the vocabulary.\n\tfor i, word in enumerate(words):\n\t\tvocab.add_word(word)\n\treturn vocab","def generate_wordcloud(dict_, title='WordCloud', PATH=None):\n wordcloud = WordCloud(min_font_size=10).generate_from_frequencies(dict_)\n plt.figure(figsize = (8, 8), facecolor = None) \n plt.imshow(wordcloud) \n plt.axis(\"off\") \n plt.title(title, size = 24)\n plt.tight_layout(pad = 0) \n if PATH:\n plt.savefig(PATH, bbox_inches=\"tight\", transparent=True)\n plt.show()","def _create_vocab(captions):\n print(\"Creating vocabulary.\")\n min_word_count = 4\n word_counts_output_file = '/Users/lzg/Desktop/image_caption/word_count.txt'\n counter = Counter()\n for c in captions:\n counter.update(c)\n print(\"Total words:\", len(counter))\n\n # Filter uncommon words and sort by descending count.\n word_counts = [x for x in counter.items() if x[1] >= min_word_count]\n word_counts.sort(key=lambda x: x[1], reverse=True)\n print(\"Words in vocabulary:\", len(word_counts))\n\n # Write out the word counts file.\n with tf.gfile.FastGFile(word_counts_output_file, \"w\") as f:\n f.write(\"\\n\".join([\"%s %d\" % (w, c) for w, c in word_counts]))\n print(\"Wrote vocabulary file:\", word_counts_output_file)\n\n # Create the vocabulary dictionary.\n reverse_vocab = [x[0] for x in word_counts]\n unk_id = len(reverse_vocab)\n vocab_dict = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])\n # vocab = Vocabulary(vocab_dict, unk_id)\n\n return vocab_dict, unk_id","def wordcloud_maker(df, stopwords = None):\n all_clean = \" \".join(review for review in df.clean)\n wordcloud = WordCloud(stopwords = stopwords, background_color=\"white\").generate(all_clean)\n plt.imshow(wordcloud, interpolation='bilinear')\n plt.axis(\"off\")\n plt.show()","def _make_feature_vec(self, word_list):\n\n # Pre-initialize an empty numpy array (for speed)\n feature_vec = np.zeros((self.num_features,), dtype=\"float32\")\n\n # index2word is a list that contains the names of the words in\n # the model's vocabulary. Convert it to a set, for speed.\n index2word_set = set(self.w2v_model.index2word)\n\n # Loop over each word in the word_list and, if it is in the model's\n # vocabulary, add its feature vector to the total\n nwords = 0\n for word in word_list:\n # NOTE: Careful there, if all words are in caps in the article,\n # this function will return nan values and blow up the forest.\n word = word.lower()\n if word in index2word_set:\n nwords += 1\n feature_vec = np.add(feature_vec, self.w2v_model[word])\n\n # Divide the result by the number of words to get the average\n feature_vec = np.divide(feature_vec, nwords)\n return feature_vec","def createDwords(self, start: ghidra.program.model.address.Address, count: int) -> None:\n ...","def make_cloud(\n self,\n image_path: str,\n word_frequency: Dict[str, int],\n font_path: str,\n background_color: str = \"white\",\n width: int = 800,\n height: int = 600,\n **kwargs,\n ) -> WordCloud:\n word_cloud = WordCloud(\n font_path=font_path, background_color=background_color, width=width, height=height, **kwargs\n )\n word_cloud.generate_from_frequencies(word_frequency)\n word_cloud.to_file(image_path)\n print(f\"Saved image to {image_path}\")\n\n return word_cloud","def build_model():\n \n pipeline = Pipeline([\n ('vect', CountVectorizer(tokenizer=tokenize)),\n ('tfidf', TfidfTransformer()),\n ('clf', MultiOutputClassifier(RandomForestClassifier()))\n ])\n \n parameters = {\n 'vect__ngram_range': ((1, 1), (1, 2)),\n 'clf__estimator__min_samples_split': [2, 4],\n }\n \n cv = GridSearchCV(pipeline, param_grid=parameters)\n\n return cv","def fd(self, sent, index, length):\n context = lambda idx, field: sent[index + idx][field] \\\n if index+idx >= 0 and index + idx < length \\\n else \"<s>\" if index+idx < 0 \\\n else \"</s>\"\n\n ## tokens in a 5 token window x_{i-2}..x_{i+2}\n word_unigram_cur = numify(context(0, WORD))\n word_unigram_pre = numify(context(-1, WORD))\n word_unigram_2pre = numify(context(-2, WORD))\n word_unigram_post = numify(context(1, WORD))\n word_unigram_2post = numify(context(2, WORD))\n\n ## token bigrams in a 5 token window\n word_bigram_pre_cur = \"/\".join([word_unigram_pre, word_unigram_cur])\n word_bigram_cur_post = \"/\".join([word_unigram_cur, word_unigram_post])\n\n ## pos in a 5 token window\n pos_cur = context(0, POS)\n pos_pre = context(-1, POS)\n pos_post = context(1, POS)\n pos_2pre = context(-2, POS)\n pos_2post = context(2, POS)\n\n ## pos bigrams in a 3 token window\n pos_bigram_pre_cur = \"/\".join([pos_pre, pos_cur])\n pos_bigram_cur_post = \"/\".join([pos_cur, pos_post])\n #pre_pre_pos_bigram = \"/\".join([pre_pre_pos, pre_pos])\n #post_post_pos_bigram = \"/\".join([post_pos, post_post_pos])\n\n pos_posw_cur = \"/\".join([word_unigram_cur, pos_cur])\n\n ## Word shape features (5 token window)\n shape_istitle_cur = word_unigram_cur.istitle()\n shape_isdigit_cur = context(0, WORD).isdigit()\n shape_isupper_cur = word_unigram_cur.isupper()\n shape_hyphen_cur = \"-\" in word_unigram_cur[1:-1]\n shape_isalnum_cur = context(0, WORD).isalnum()\n #shape_mixedcase_cur = self.mixedcase.match(context(0, WORD)) != None\n\n shape_istitle_pre = word_unigram_pre.istitle()\n shape_isdigit_pre = context(-1, WORD).isdigit()\n shape_isupper_pre = word_unigram_pre.isupper()\n shape_hyphen_pre = \"-\" in word_unigram_pre[1:-1]\n shape_isalnum_pre = context(-1, WORD).isalnum()\n #shape_mixedcase_pre = self.mixedcase.match(context(-1, WORD)) != None\n\n shape_istitle_2pre = word_unigram_2pre.istitle()\n shape_isdigit_2pre = context(-2, WORD).isdigit()\n shape_isupper_2pre = word_unigram_2pre.isupper()\n shape_hyphen_2pre = \"-\" in word_unigram_2pre[1:-1]\n shape_isalnum_2pre = context(-2, WORD).isalnum()\n #shape_mixedcase_2pre = self.mixedcase.match(context(-2, WORD)) != None\n\n shape_istitle_post = word_unigram_post.istitle()\n shape_isdigit_post = context(1, WORD).isdigit()\n shape_isupper_post = word_unigram_post.isupper()\n shape_hypen_post = \"-\" in word_unigram_post[1:-1]\n shape_isalnum_post = context(1, WORD).isalnum()\n #shape_mixedcase_post = self.mixedcase.match(context(1, WORD)) != None\n\n shape_istitle_2post = word_unigram_2post.istitle()\n shape_isdigit_2post = context(2, WORD).isdigit()\n shape_isupper_2post = word_unigram_2post.isupper()\n shape_hypen_2post = \"-\" in word_unigram_2post[1:-1]\n shape_isalnum_2post = context(2, WORD).isalnum()\n #shape_mixedcase_2post = self.mixedcase.match(context(2, WORD)) != None\n\n ## 2-4 suffixes in a 3 token window\n suffix_1_cur = word_unigram_cur[-1:]\n suffix_2_cur = word_unigram_cur[-2:]\n suffix_3_cur = word_unigram_cur[-3:]\n suffix_4_cur = word_unigram_cur[-4:]\n\n suffix_1_pre = word_unigram_pre[-1:]\n suffix_2_pre = word_unigram_pre[-2:]\n suffix_3_pre = word_unigram_pre[-3:]\n suffix_4_pre = word_unigram_pre[-4:]\n\n suffix_1_post = word_unigram_post[-1:]\n suffix_2_post = word_unigram_post[-2:]\n suffix_3_post = word_unigram_post[-3:]\n suffix_4_post = word_unigram_post[-4:]\n\n ## 3-4 prefixes in a 3 token window\n prefix_3_cur = word_unigram_cur[:3]\n prefix_4_cur = word_unigram_cur[:4]\n\n prefix_3_pre = word_unigram_pre[:3]\n prefix_4_pre = word_unigram_pre[:4]\n\n prefix_3_post = word_unigram_post[:3]\n prefix_4_post = word_unigram_post[:4]\n\n ## Noun phrase in a 3 token window\n syn_np_cur = context(0, NP)\n syn_npw_cur = \"/\".join([syn_np_cur, word_unigram_cur])\n syn_np_pre = context(-1, NP)\n syn_np_post = context(1, NP)\n\n ## Extract features from local scope\n features = locals()\n del features[\"context\"]\n del features[\"sent\"]\n del features[\"index\"]\n del features[\"length\"]\n del features[\"self\"]\n features = features.items()\n\n features.extend(self.brown_extractor(\"brown_%d_cur\", context(0, WORD)))\n features.extend(self.brown_extractor(\"brown_%d_pre\", context(-1, WORD)))\n features.extend(self.brown_extractor(\"brown_%d_2pre\", context(-2, WORD)))\n features.extend(self.brown_extractor(\"brown_%d_post\", context(1, WORD)))\n features.extend(self.brown_extractor(\"brown_%d_2post\", context(2, WORD))) \n\n return features","def generate_babble_text(self):\n markov_chain_output = []\n for n in range(self.number_of_sentences):\n sentence_length = random.randint(self.min_sentence_length, self.max_sentence_length)\n markov_chain_output.append(self.markov_chain.generate_sentence(sentence_length))\n\n random.shuffle(markov_chain_output)\n\n to_display = ''\n for i in markov_chain_output:\n to_display += i + '\\n'\n\n # Clears any old text in the display, then inserts the newly created text\n self.display.delete('1.0', tk.END)\n self.display.insert('1.0', to_display)","def trainingModel4wmd(corpus):\n model = Word2Vec(corpus, workers = nCores, size = 100, window = 300,\n min_count = 2, iter = 250)\n # model = Word2Vec(corpus)\n\n # use the following if we want to normalize the vectors\n model.init_sims(replace=True)\n\n return model","def definition(self, definition):\n result = Words()\n result.words = DefinitionHelper.words_for_definition(definition)\n return result","def build_data_cv(self, data_folder, cv=10, clean_string=True):\n revs = []\n pos_file = data_folder[0]\n neg_file = data_folder[1]\n vocab = defaultdict(float)\n with open(pos_file, \"rb\") as f:\n for line in f:\n rev = []\n rev.append(line.strip())\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n words = set(orig_rev.split())\n for word in words:\n vocab[word] += 1\n datum = {\"y\":1,\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n \"split\": np.random.randint(0,cv)}\n revs.append(datum)\n with open(neg_file, \"rb\") as f:\n for line in f:\n rev = []\n rev.append(line.strip())\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n words = set(orig_rev.split())\n for word in words:\n vocab[word] += 1\n datum = {\"y\":0,\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n \"split\": np.random.randint(0,cv)}\n revs.append(datum)\n return revs, vocab","def make_words(self,lm):\n if \" \" in self.corpus[0] and \" \" in self.corpus[1]: \n print \"assuming BLICK\"\n self.corpus = [convert_to_disc(i) for i in self.corpus]\n else:\n self.disc = 1\n print \"assuming Disc\" \n if not os.path.isfile(self.f): ##check if it already exists\n print \"generating 10 million words\"\n outfile = open(self.f, \"w\")\n outfile.write(\"word,blick,ngram,Real,T,disc\\n\")\n for word in self.corpus:\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Real\", \"1\")\n while len(self.wordlist)<10000000: \n words = lm.generate(100)\n for word in words:\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Simulated\", \"0\")\n self.wordlist[word] = 0\n return","def make_csd(shape, scale, npart, show_plot=False):\r\n if shape == 0:\r\n rads = [scale + 0 * x for x in range(npart)]\r\n else:\r\n rads = lognorm.rvs(shape, scale=scale, size=npart)\r\n with open('diameters.txt', 'w') as fout:\r\n for rad in rads:\r\n fout.write('{0}\\n'.format(rad))\r\n if shape == 0:\r\n xpos = linspace(scale / 2, scale * 2, 100)\r\n else:\r\n xpos = linspace(lognorm.ppf(0.01, shape, scale=scale),\r\n lognorm.ppf(0.99, shape, scale=scale), 100)\r\n plt.plot(xpos, lognorm.pdf(xpos, shape, scale=scale))\r\n plt.hist(rads, normed=True)\r\n plt.savefig('packing_histogram.png')\r\n plt.savefig('packing_histogram.pdf')\r\n if show_plot:\r\n plt.show()","def construct_embedding(captions, cbow=True):\n\n # List of characters to filter out of the caption string\n chars_to_remove = [\"\\n\", \">\", \"--\"]\n\n for char in chars_to_remove:\n captions = captions.replace(char, \" \")\n\n # Perform some necessary tokenization\n data = [word_tokenize(word.lower()) for word in sent_tokenize(captions)]\n\n # Filter out punctuation from the data\n data_minus_punctuation = remove_punctuation(data)\n\n # Filter out stop words from the data\n data_minus_stop_words = remove_stop_words(data_minus_punctuation)\n\n # Filter out any surviving single character list elements\n fully_formatted_data = [\n [word for word in item if len(word) > 1] for item in data_minus_stop_words\n ]\n\n # Train the Word2Vec model using the specified architecture\n if cbow:\n print(\"UTILIZING CBOW ARCHITECTURE\")\n model = Word2Vec(fully_formatted_data, min_count=1, size=100, window=5)\n else:\n print(\"UTILIZING SKIPGRAM ARCHITECTURE\")\n model = Word2Vec(fully_formatted_data, min_count=1, size=100, window=5, sg=1)\n\n return model","def test_topic_model_generator_dimensions( ):\n N = 100\n D = 1000\n K = 10\n W = 100\n\n tm = TopicModel.generate( K, D )\n assert( tm.topics.shape == (D, K) )\n assert( tm.weights.shape == (K,) )\n\n docs = tm.sample( N, words = W )\n # Each document is a column\n assert( docs.shape == (N, D) ) \n # Each doc should have 100 words\n assert( sc.all(docs.sum(1) == W) )","def generate_corpus(model, sample):\r\n \r\n dl_corpus = []\r\n for word in sample:\r\n if word in model:\r\n dl_corpus.append(model[word])\r\n else:\r\n dl_corpus.append([0]*VECTOR_DIM)\r\n\r\n return [dl_corpus]","def build_vocab(cleaned_captions):\n # QUESTION 1.1\n # Here we Build a vocabulary\n\n # create a vocab instance\n vocab = Vocabulary()\n\n words = dict()\n for caption in cleaned_captions: # iterate through all cleaned_caption\n for word in caption.split(): # iterate over all words in a caption\n # add the token words to vocabulary if and only if the count of word is more than MIN_FREQUENCY i.e. 3\n if word not in words.keys():\n words[word] = 1\n else:\n words[word] += 1\n if words[word] > MIN_FREQUENCY:\n vocab.add_word(word)\n\n vocab.add_word('<pad>')\n vocab.add_word('<start>')\n vocab.add_word('<end>')\n vocab.add_word('<unk>')\n\n print(vocab.idx)\n\n return vocab","def model(self, doc_list=None):\r\n\r\n # eta => prior for the per-topic word distribution\r\n eta = torch.ones(self.V)\r\n\r\n with pyro.plate(\"topics\", self.K):\r\n\r\n # Beta => per topic word distribution\r\n Beta = pyro.sample(f\"beta\", dist.Dirichlet(eta))\r\n\r\n # alpha => prior for the per-doc topic vector\r\n alpha = torch.ones(self.K) / self.K\r\n\r\n X_List, Theta = [], []\r\n for d in pyro.plate(\"documents\", self.D, subsample_size=self.S):\r\n\r\n # theta => per-doc topic vector\r\n theta = pyro.sample(f\"theta_{d}\", dist.Dirichlet(alpha))\r\n\r\n doc = None if doc_list is None else doc_list[d]\r\n\r\n with pyro.plate(f\"words_{d}\", self.N[d]):\r\n\r\n # assign a topic\r\n z_assignment = pyro.sample(\r\n f\"z_assignment_{d}\",\r\n dist.Categorical(theta)\r\n )\r\n\r\n # from that topic vec, select a word\r\n X = pyro.sample(\r\n f\"w_{d}\",\r\n dist.Categorical(Beta[z_assignment]),\r\n obs=doc\r\n )\r\n\r\n X_List.append(X)\r\n Theta.append(theta)\r\n\r\n Theta = torch.stack(Theta)\r\n\r\n return X_List, Beta, Theta","def generate_wordcloud_from_probabilities_and_words(prob, words, return_image=True, wordcloud_instance=None,\n **wordcloud_kwargs):\n\n if len(prob) != len(words):\n raise ValueError('`prob` and `words` must have the name length')\n if hasattr(prob, 'ndim') and prob.ndim != 1:\n raise ValueError('`prob` must be a 1D array or sequence')\n if hasattr(words, 'ndim') and words.ndim != 1:\n raise ValueError('`words` must be a 1D array or sequence')\n\n weights = dict(zip(words, prob))\n\n return generate_wordcloud_from_weights(weights, return_image=return_image,\n wordcloud_instance=wordcloud_instance, **wordcloud_kwargs)","def generate(self, seed_text, next_words=20, T=0.9):\n\n index_to_word = {index: word for word, index in self.tokenizer.word_index.items()}\n\n for _ in range(next_words):\n token_list = self.tokenizer.texts_to_sequences([seed_text])[0]\n token_list = pad_sequences([token_list], maxlen=self.max_sequence_len, padding='pre')\n\n probas = self.model.predict(token_list, verbose=0)\n probas = np.array(probas[0][1:])\n probas = probas ** (1.0 / T)\n probas /= np.sum(probas)\n predicted = np.random.choice(range(1,self.total_words), p=probas)\n \n seed_text += \" \" + (index_to_word[predicted] if predicted != 0 else '')\n\n return seed_text","def random_bbox(self, shape, margin, bbox_shape):\r\n img_height = shape\r\n img_width = shape\r\n height = bbox_shape\r\n width = bbox_shape\r\n ver_margin = margin\r\n hor_margin = margin\r\n maxt = img_height - ver_margin - height\r\n maxl = img_width - hor_margin - width\r\n t = np.random.randint(low = ver_margin, high = maxt)\r\n l = np.random.randint(low = hor_margin, high = maxl)\r\n h = height\r\n w = width\r\n return (t, l, h, w)","def random_bbox(self, shape, margin, bbox_shape):\r\n img_height = shape\r\n img_width = shape\r\n height = bbox_shape\r\n width = bbox_shape\r\n ver_margin = margin\r\n hor_margin = margin\r\n maxt = img_height - ver_margin - height\r\n maxl = img_width - hor_margin - width\r\n t = np.random.randint(low = ver_margin, high = maxt)\r\n l = np.random.randint(low = hor_margin, high = maxl)\r\n h = height\r\n w = width\r\n return (t, l, h, w)","def create_vocabs(self):\r\n print('Creating vocabs...')\r\n\r\n # Update surface_char2id\r\n unique_surfaces = set(chain(*[sentence.surface_words for sentence in self.sentences]))\r\n unique_chars = set(chain(*[surface for surface in unique_surfaces]))\r\n for ch in unique_chars:\r\n self.surface_char2id[ch] = len(self.surface_char2id)\r\n\r\n # Update lemma_char2id\r\n unique_lemmas = set(chain(*[sentence.lemmas for sentence in self.sentences]))\r\n unique_chars = set(chain(*[lemma for lemma in unique_lemmas]))\r\n for ch in unique_chars:\r\n self.lemma_char2id[ch] = len(self.lemma_char2id)\r\n\r\n # Update transformation2id\r\n for sentence in self.sentences:\r\n for transformation in sentence.transformations:\r\n for _t in transformation:\r\n if _t not in self.transformation2id:\r\n self.transformation2id[_t] = len(self.transformation2id)\r\n\r\n # Update morph_tag2id\r\n unique_morph_tags = list(chain(*[sentence.morph_tags for sentence in self.sentences]))\r\n unique_tags = set(chain(*[morph_tag for morph_tag in unique_morph_tags]))\r\n for tag in unique_tags:\r\n self.morph_tag2id[tag] = len(self.morph_tag2id)\r\n print('Surface Chars={}, Lemma Chars={}, Transformations={}, tags={}'.format(\r\n len(self.surface_char2id), len(self.lemma_char2id), len(self.transformation2id), len(self.morph_tag2id)\r\n ))","def build_geometry(self, depth=None, maxcount=20000):\n self.G.init()\n self.word_generator = partial(self.G.traverse, depth=depth, maxcount=maxcount)\n self.get_vertices()\n self.get_edges()\n self.get_faces()\n return self","def build_train_data(self,data_folder, cv=10, clean_string=False):\n revs = []\n\n vocab = defaultdict(float)\n print data_folder\n with codecs.open( data_folder, 'rb') as fi:\n for line in fi.readlines():\n line = line.decode('utf-8')\n parts = line.split(\"\\n\")[0].split(\"\\t\")\n if len(parts) > 1:\n sent = parts[1]\n rev = []\n rev.append(sent.strip())\n\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n #print orig_rev\n words = set(orig_rev.split())\n for word in words:\n vocab[word.lower()] += 1\n if len(orig_rev.split()) < 50 :\n\n datum = {\"y\":int(parts[0]),\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n \"split\": np.random.randint(0,cv)}\n revs.append(datum)\n # else:\n # print orig_rev\n\n\n return revs, vocab","def create_vocabulary(vocabulary_path, words, max_vocabulary_size, normalize_digits=True):\n if not gfile.Exists(vocabulary_path):\n print(\"Creating vocabulary %s with max size %d\" % (vocabulary_path, max_vocabulary_size))\n vocab = {}\n counter = 0\n for w in words:\n counter += 1\n if counter % 10000 == 0:\n print(\" processing word %d = %s\" % (counter, w))\n word = re.sub(_DIGIT_RE, \"0\", w) if normalize_digits else w\n if word in vocab:\n vocab[word] += 1\n else:\n vocab[word] = 1\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\n if len(vocab_list) > max_vocabulary_size:\n vocab_list = vocab_list[:max_vocabulary_size]\n with gfile.GFile(vocabulary_path, mode=\"w\") as vocab_file:\n for w in vocab_list:\n vocab_file.write(w + \"\\n\")","def generate_new_word(model: Dict[str, Set[str]]) -> str:\n all_keys = list(dict.keys(model))\n return random.choice(all_keys)"],"string":"[\n \"def create_word(self):\\r\\n\\r\\n template = self.word_constructions.get()\\r\\n word = \\\"\\\"\\r\\n for c in template:\\r\\n if c == \\\"v\\\":\\r\\n letter = self.get_letter(100)\\r\\n else:\\r\\n letter = self.get_letter(0)\\r\\n word += letter\\r\\n\\r\\n while not any(letter in self.vowels for letter in word):\\r\\n length = len(word)\\r\\n if length == 1:\\r\\n index = 0\\r\\n elif length == 2:\\r\\n index = random.randrange(0, 2)\\r\\n else:\\r\\n a = len(word) / 2\\r\\n index = a + random.randrange(-a / 2, a / 2)\\r\\n word = word[:index] + self.get_letter(100) + word[index + 1:]\\r\\n\\r\\n if random.random() > self.capital_chance:\\r\\n word = word.capitalize()\\r\\n self.words.append(word)\\r\\n self.word_count += 1\\r\\n return word\",\n \"def generateByWord(model, voc, maxlen=20, diversity=0.5, numwords=42):\\n\\n text, sym_indices, indices_sym = voc\\n syms = set(text)\\n start_index = random.randint(0, len(text) - maxlen - 1) \\n generated = ''\\n sentence = text[start_index: start_index + maxlen]\\n \\n #generated += sentence\\n generated += ' '.join(sentence)\\n print('----- Generating with seed: \\\"' + ' '.join(sentence) + '\\\"')\\n sys.stdout.write(generated)\\n\\n for i in range(numwords):\\n x = np.zeros((1, maxlen, len(syms)))\\n for t, sym in enumerate(sentence):\\n x[0, t, sym_indices[sym]] = 1.\\n \\n preds = model.predict(x, verbose=0)[0]\\n next_index = sample(preds, diversity)\\n next_sym = indices_sym[next_index]\\n generated += ' '+next_sym\\n sentence.append(next_sym)\\n tmpsentence = sentence[1:]\\n sentence = tmpsentence\\n sys.stdout.write(next_sym+' ')\\n sys.stdout.flush()\\n print()\",\n \"def create(seed, model, tokenizer, temp=0.5):\\n\\n dictionary = [\\\"\\\"] + list(tokenizer.index_word.values())\\n start = np.array(tokenizer.texts_to_sequences(seed)).reshape(1, -1)\\n if seed[0] == '<start>':\\n output = [seed[-1]]\\n else:\\n output = seed[:]\\n\\n for _ in range(45):\\n weights = reweight_distribution(model.predict(start), temperature=temp)\\n word = np.random.choice(dictionary, size=1, p=weights[0, :])[0]\\n if word == '<end>': \\n if len(output) > 10:\\n break\\n else:\\n continue\\n output.append(word)\\n start = np.append(start[0, 1:], tokenizer.texts_to_sequences([word])).reshape(1, -1)\\n return \\\" \\\".join(output)\",\n \"def create_word(self):\\n return self.random.choice(CONSONANTS) + self.random.choice(VOWELS)\",\n \"def build_vocabulary(image_paths, vocab_size):\\n n_image = len(image_paths)\\n\\n # Since want to sample tens of thousands of SIFT descriptors from different images, we\\n # calculate the number of SIFT descriptors we need to sample from each image.\\n n_each = int(np.ceil(40000 / n_image)) # You can adjust 10000 if more is desired\\n\\n # Initialize an array of features, which will store the sampled descriptors\\n features = np.zeros((n_image * n_each, 128))\\n j=0\\n for i, path in enumerate(image_paths):\\n # Load SIFT features from path\\n descriptors = np.loadtxt(path, delimiter=',',dtype=float)\\n\\n # TODO: Randomly sample n_each features from descriptors, and store them in features\\n #use the randomizer in numpy library to make n_each random index\\n idx= np.array(np.random.randint(0,len(descriptors),n_each))\\n\\n # choose randomly n_each number of discriptor to train K-mean classifier\\n for k in idx:\\n\\n features[j] = descriptors[k,:]\\n j = j+1\\n # TODO: pefrom k-means clustering to cluster sampled SIFT features into vocab_size regions.\\n # You can use KMeans from sci-kit learn.\\n # Reference: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html\\n\\n #use K_mean classifier to make Bag of visual words represantation for SIFT features\\n kmeans = KMeans(n_clusters=250).fit(features)\\n #kmeans= clustering = AgglomerativeClustering().fit(features)\\n\\n\\n return kmeans\",\n \"def create_new_doc(self, doc: Doc, min_prob: float = 0.25) -> Doc:\\n\\n # print(\\\"running on\\\", doc[:10])\\n\\n if not self.form_frequencies:\\n raise RuntimeError(\\n \\\"Cannot truecase without a dictionary of form frequencies\\\")\\n\\n tokens = []\\n spaces = []\\n doctext = doc.text\\n for tok in doc:\\n toktext = tok.text\\n\\n # We only change casing for words in Title or UPPER\\n if tok.is_alpha and toktext[0].isupper():\\n cond1 = tok.is_upper and len(toktext) > 2 # word in uppercase\\n cond2 = toktext[0].isupper(\\n ) and not tok.is_sent_start # titled word\\n if cond1 or cond2:\\n token_lc = toktext.lower()\\n if token_lc in self.form_frequencies:\\n frequencies = self.form_frequencies[token_lc]\\n if frequencies.get(toktext, 0) < min_prob:\\n alternative = sorted(\\n frequencies.keys(), key=lambda x: frequencies[x])[-1]\\n\\n # We do not change from Title to to UPPER\\n if not tok.is_title or not alternative.isupper():\\n toktext = alternative\\n\\n tokens.append(toktext)\\n\\n # Spacy needs to know whether the token is followed by a space\\n if tok.i < len(doc)-1:\\n spaces.append(doctext[tok.idx+len(tok)].isspace())\\n else:\\n spaces.append(False)\\n\\n # Creates a new document with the tokenised words and space information\\n doc2 = Doc(self.model.vocab, words=tokens, spaces=spaces) #type: ignore\\n # print(\\\"finished with doc\\\", doc2[:10])\\n return doc2\",\n \"def create_wordcloud(self, text):\\n text = ' '.join(f\\\"{word}\\\" for word in text)\\n mask = np.array(Image.open(os.path.join(CURRDIR, \\\"cloud.png\\\")))\\n wc = WordCloud(background_color=\\\"white\\\",\\n max_words=200,\\n mask=mask)\\n wc.generate(text)\\n wc.to_file(PATH_TO_SAVE_IMG, \\\"wordle.png\\\")\",\n \"def word(length, upper=False):\\n letters = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n if upper:\\n letters = letters.upper()\\n\\n def gen(shape):\\n lengths = _ints(length, shape)\\n field_length = lengths.max()\\n dtype = \\\"U{}\\\".format(field_length)\\n\\n result = np.empty(shape, dtype=dtype)\\n flat = result.ravel()\\n for i, l in enumerate(lengths):\\n flat[i] = \\\"\\\".join( random.choice(letters) for _ in range(l) )\\n return result\\n\\n return gen\",\n \"def create_random_text(word_count=10):\\n sample_text_lst = TEXT_BASE_RUS.replace('\\\\n', '').split(' ')\\n generate_text_lst = []\\n for i in range(word_count):\\n generate_text_lst.append(random.choice(sample_text_lst))\\n generate_text = ' '.join(generate_text_lst)\\n return generate_text\",\n \"def generate(model, voc, maxlen=20, diversity=0.5, numchars=100):\\n\\n text, char_indices, indices_char = voc\\n chars = set(text)\\n start_index = random.randint(0, len(text) - maxlen - 1) \\n generated = ''\\n sentence = text[start_index: start_index + maxlen]\\n #print(\\\"Insert text to start from [min 20 chars]:\\\")\\n #sentence = str(raw_input())\\n #sentence = sentence[:maxlen]\\n generated += sentence\\n print('----- Generating with seed: \\\"' + sentence + '\\\"')\\n sys.stdout.write(generated)\\n\\n for i in range(numchars):\\n x = np.zeros((1, maxlen, len(chars)))\\n for t, char in enumerate(sentence):\\n x[0, t, char_indices[char]] = 1.\\n \\n preds = model.predict(x, verbose=0)[0]\\n next_index = sample(preds, diversity)\\n next_char = indices_char[next_index]\\n generated += next_char\\n sentence = sentence[1:] + next_char\\n sys.stdout.write(next_char)\\n sys.stdout.flush()\\n print()\",\n \"def generate_sentence():\\n markov_chain = makeMarkovDict(\\\"text.txt\\\")\\n\\n # Pick a random word to begin with.\\n first_word = random.choice(markov_chain.keys()) # Illegall\\n\\n # print first_word\\n # random_choice = random.randint(0, len(markov_chain.keys()))\\n # index = 0\\n # first_word = \\\"\\\"\\n # for word in markov_chain:\\n # print word\\n # if index == random_choice:\\n # first_word = word\\n # break\\n # index += 1\\n\\n # Based on that word, call function to chose the next word.\\n # print markov_chain[first_word]\\n # print word_selection(markov_chain[first_word])\\n\\n lenght_of_sentence = 10\\n sentence = [first_word] # First word already in there\\n for i in range(lenght_of_sentence):\\n sentence.append(word_selection(markov_chain[sentence[i]]))\\n # Sentence after loop: ['fish', 'red', 'fish', 'two', 'fish', 'red', 'fish', 'red', 'fish', 'two', 'fish']\\n\\n # Cap with letter and add period at the end.\\n final_sentece = \\\" \\\".join(sentence) + \\\".\\\"\\n return final_sentece.capitalize()\",\n \"def create_vocab(vocab_path='ORBvoc-synth.txt'):\\n total_time = 10 # seconds\\n num_frames = 20\\n speed = 3.0\\n vocab_builder = VocabularyBuilder()\\n for seed in tqdm(range(100), total=100):\\n image_builder = DemoImageBuilder(\\n mode=ImageMode.MONOCULAR, seed=seed,\\n length=total_time * speed\\n )\\n for idx in range(num_frames):\\n time = total_time * idx / num_frames\\n image = image_builder.create_frame(time)\\n vocab_builder.add_image(image.pixels)\\n vocab_builder.build_vocabulary(str(vocab_path))\",\n \"def word_cloud_generator(text: str, mask_image: Path, save_to_file=False) -> WordCloud:\\n mask = imageio.imread(mask_image)\\n word_cloud = WordCloud(colormap='prism', mask=mask, background_color='white')\\n word_cloud = word_cloud.generate(text)\\n if save_to_file:\\n word_cloud.to_file('word_cloud.png')\\n return word_cloud\",\n \"def generate_wordcloud(topic_description, use_mask='rectangle', store_to_file=False):\\n\\n # transform the topic description in frequencies\\n topic_frequencies = get_word_frequencies(topic_description)\\n\\n if use_mask == 'oval':\\n mask = numpy.array(Image.open(os.path.join(config.__resources_folder_path, \\\"oval.jpg\\\")))\\n else:\\n mask = numpy.array(Image.open(os.path.join(config.__resources_folder_path, \\\"rect.png\\\")))\\n\\n wc = WordCloud(background_color=\\\"white\\\", max_words=2000, mask=mask)\\n # generate word cloud\\n wc.generate_from_frequencies(topic_frequencies)\\n\\n if store_to_file:\\n # store to file\\n wc.to_file(os.path.join(config.__inputs_outputs_folder_path, \\\"wordcloud_{0}_{1}.png\\\".format(\\n hash(str(topic_description)), use_mask)))\\n\\n # show\\n plt.imshow(wc, interpolation='bilinear')\\n plt.axis(\\\"off\\\")\\n plt.show()\",\n \"def generate(self, count=15):\\n\\n sentence = []\\n print(\\\"self.word_dict\\\", self.word_dict)\\n for i in range(count):\\n first_tuple = random.choice(list(self.word_dict.keys())) # first word for our sentence\\n first_word = random.choice(first_tuple)\\n sentence.append(first_word)\\n second_word = self.word_dict[first_tuple]\\n # print(\\\"second_word\\\", second_word)\\n next_word = second_word.sample()\\n # print(\\\"next_word\\\", next_word)\\n # first_tuple = second_word\\n sentence.append(next_word)\\n # end_tuple =\\n sentence = ' '.join(sentence)\\n return sentence + \\\".\\\"\\n # for i in range(len(self.token)):\\n # val = list(self.word_dict.values())[i]\\n # print(len(val))\\n # # print(\\\"val\\\", val)\\n # next_word = val.sample()\\n # sentence.append(next_word)\\n # sentence = ' '.join(sentence)\\n # return sentence + \\\".\\\"\",\n \"def build_from_words(self, words):\\n if isinstance(words, unicode):\\n self.build(words)\\n elif isinstance(words, list):\\n flag = \\\"seg\\\"\\n assert len(words) > 0\\n\\n word = words[0]\\n if isinstance(word, unicode):\\n flag = \\\"seg\\\"\\n elif ((isinstance(word, list) or isinstance(word, tuple)) and\\n len(word) == 2 and isinstance(word[0], unicode) and isinstance(word[1], unicode)):\\n flag = \\\"pos\\\"\\n elif ((isinstance(word, list) or isinstance(word, tuple)) and\\n len(word) == 4 and isinstance(word[0], unicode) and isinstance(word[1], unicode)):\\n flag = \\\"dp\\\"\\n else:\\n flag = \\\"unknown\\\"\\n\\n self._xml4nlp = Element('xml4nlp')\\n self._note = SubElement(self._xml4nlp, 'note')\\n self._doc = SubElement(self._xml4nlp, 'doc')\\n\\n para = SubElement(self._doc, 'para')\\n sent = SubElement(para, 'sent')\\n\\n para.set(\\\"id\\\", \\\"0\\\")\\n sent.set(\\\"id\\\", \\\"0\\\")\\n\\n self._clean_note()\\n\\n if flag == \\\"seg\\\":\\n for i, word in enumerate(words):\\n sent.append(Element('word', {\\n 'id': unicode(i),\\n 'cont': word\\n }))\\n sent.set('cont', (\\\"\\\".join(words)))\\n self._set_word_on_note()\\n elif flag == \\\"pos\\\":\\n for i, word_pos in enumerate(words):\\n word, pos = word_pos\\n sent.append(Element('word', {\\n 'id': unicode(i),\\n 'cont': word,\\n 'pos': pos\\n }))\\n sent.set('cont', (\\\"\\\".join([word[0] for word in words])))\\n self._set_pos_on_note()\\n elif flag == \\\"dp\\\":\\n for i, rep in enumerate(words):\\n word, pos, head, dep_rel = rep\\n sent.append(Element('word', {\\n 'id': unicode(i),\\n 'cont': word,\\n 'pos': pos,\\n 'parent': str(int(head) - 1),\\n 'relation': dep_rel\\n }))\\n sent.set('cont', (\\\"\\\".join([word[0] for word in words])))\\n self._set_parser_on_note()\\n\\n self.dom = self._xml4nlp\",\n \"def generate_words(text='', train_path=None, case_sensitive=True, epochs=20, classifier=nlup.BinaryAveragedPerceptron, **kwargs):\\n if train_path:\\n generate_sentences.detector = Detector(slurp(train_path), epochs=epochs, nocase=not case_sensitive)\\n # generate_sentences.detector = SentenceDetector(text=text, nocase=not case_sensitive, epochs=epochs, classifier=classifier)\\n return iter(generate_sentences.detector.segments(text))\",\n \"def surface_labelled_data_preparation_pipeline(word_list: [str]):\\n X = []\\n\\n for word in word_list:\\n segments = word.split('-')\\n segment_features = []\\n for i in range(len(segments)):\\n features = {}\\n\\n segment_length = len(segments[i])\\n features['length'] = segment_length\\n\\n features['segment.lower()'] = segments[i].lower()\\n features['pos_in_word'] = i\\n\\n if segment_length % 2 == 0:\\n features['even'] = 1\\n else:\\n features['odd'] = 1\\n\\n features['begin'] = segments[i][0]\\n features['end'] = segments[i][len(segments[i]) - 1]\\n\\n try:\\n features['prev_segment'] = segments[i - 1]\\n except IndexError:\\n features['prev_segment'] = ''\\n # continue\\n\\n try:\\n features['next_segment'] = segments[i + 1]\\n except IndexError:\\n features['next_segment'] = ''\\n\\n if segments[0].isupper():\\n features['start_upper'] = 1\\n else:\\n features['start_lower'] = 1\\n\\n if segments[0] in 'aeiou':\\n features['first_vowel'] = 1\\n else:\\n features['first_const'] = 1\\n\\n segment_features.append(features)\\n\\n X.append(segment_features)\\n\\n return X\",\n \"def makeFeatureVec(words, model, num_features):\\n featureVec = np.zeros((num_features,),dtype=\\\"float32\\\")\\n num_words = 0.\\n index2word_set = set(model.wv.index2word)\\n for word in words:\\n if word in index2word_set:\\n num_words += 1\\n featureVec = np.add(featureVec,model[word]) \\n featureVec = np.divide(featureVec,num_words)\\n return featureVec\",\n \"def gen_words(self, doc):\\n pattern = re.compile(u'[\\\\\\\\s\\\\\\\\d,.<>/?:;\\\\'\\\\\\\"[\\\\\\\\]{}()\\\\\\\\|~!@#$%^&*\\\\\\\\-_=+a-zA-Z，。《》、？：；“”‘’｛｝【】（）…￥！—┄－]+')\\n doc = re.sub(pattern, ' ', doc)\\n suffix_indexes = index_of_sorted_suffix(doc, self.max_word_len)\\n word_cands = {}\\n # compute frequency and neighbors\\n for suf in suffix_indexes:\\n word = doc[suf[0]:suf[1]]\\n if word not in word_cands:\\n word_cands[word] = WordInfo(word)\\n word_cands[word].update(doc[suf[0] - 1:suf[0]], doc[suf[1]:suf[1] + 1])\\n # compute probability and entropy\\n length = len(doc)\\n for k in word_cands:\\n word_cands[k].compute(length)\\n word_cands[k].compute_pp(self.pos_prop)\\n # compute aggregation of words whose length > 1\\n values = sorted(word_cands.values(), key=lambda x: len(x.text))\\n for v in values:\\n if len(v.text) == 1:\\n continue\\n v.compute_cohesion(word_cands)\\n\\n return sorted(values, key=lambda v: v.freq, reverse=True)\",\n \"def make_text(markov_chains):\\n\\n random_num = generate_random_number(markov_chains.keys())\\n\\n random_text = []\\n\\n start_words = generate_start_words(random_num, markov_chains.keys())\\n \\n random_text.extend(start_words)\\n\\n\\n for i in range(500):\\n word_tuple = (random_text[-2],random_text[-1])\\n next_word = add_next_word(word_tuple, markov_chains)\\n random_text.append(next_word)\\n\\n return random_text\",\n \"def word2vec_model(sentences, size=100, min_count=5, window=5,\\n negative=5, cbow=True, iterations=5, seed=0,\\n workers=1):\\n if cbow is True:\\n sg = 0\\n else:\\n sg = 1\\n model = Word2Vec(size=size, window=window,\\n min_count=min_count, workers=workers,\\n sg=sg, negative=negative, seed=seed)\\n\\n model.build_vocab(sentences)\\n\\n model.train(sentences, total_examples=model.corpus_count,\\n epochs=iterations)\\n return model\",\n \"def create_random_tags(count=100):\\n all_words = words.words('en')\\n selected_words = []\\n picker = ColorPicker(reset=True)\\n colors = picker._get_colors()\\n while count > 0:\\n word = random.choice(all_words)\\n selected_words.insert(0, word)\\n all_words.remove(word)\\n count += -1\\n del all_words\\n for word in selected_words:\\n color = colors.next()\\n tag = Tag(slug=slugify(word), tag=word, color=color)\\n tag.save()\",\n \"def generate_sample(sentences, vocab, window):\\n for sentence in sentences:\\n word_vocabs = [vocab[w] for w in sentence if w in vocab and\\n vocab[w]['prob'] > np.random.rand()]\\n\\n for index, word in enumerate(word_vocabs):\\n center = word['index']\\n reduced_window = np.random.randint(1, window + 1)\\n\\n # words before the center word\\n for context in word_vocabs[max(0, index - reduced_window):index]:\\n target = context['index']\\n yield center, target\\n\\n # words after the center word\\n for context in word_vocabs[(index + 1):(index + 1 + reduced_window)]:\\n target = context['index']\\n yield center, target\",\n \"def generate_text_owc(model: Dict[str, Set[str]], n: int) -> str:\\n # ACCUMULATOR: a list of the randomly-generated words so far\\n words_so_far = []\\n # We've provided this template as a starting point; you may modify it as necessary.\\n words_so_far.append(generate_new_word(model))\\n for x in range(0, n-1):\\n key = words_so_far[x]\\n new_word = generate_next_word(model,key)\\n if new_word == \\\".\\\":\\n words_so_far[x] = words_so_far[x]+'.'\\n new_word= generate_new_word(model)\\n elif new_word == {}:\\n new_word = generate_new_word(model)\\n words_so_far.append(new_word)\\n\\n return str.join(' ', words_so_far)\",\n \"def generate_words(num_words, word_len, grid, reject_func=is_overlapping):\\n height, width = len(grid), len(grid[0])\\n restrictions = position_restrictions(word_len, height, width)\\n word_hashes = set()\\n words_positions = []\\n words = []\\n while len(word_hashes) < num_words:\\n cardinal = random.choice(list(restrictions.keys()))\\n (min_h, max_h), (min_w, max_w) = restrictions[cardinal]\\n x0, y0 = random.randint(min_h, max_h), random.randint(min_w, max_w)\\n x, y = DIRECTIONS[cardinal]\\n positions = [(x0 + x * i, y0 + y * i) for i in range(word_len)]\\n if (word_hash := (cardinal, (x0, y0))) not in word_hashes \\\\\\n and not reject_func(p_set := set(positions), words_positions):\\n words.append(\\\"\\\".join(str(grid[x][y]) for x, y in positions))\\n word_hashes.add(word_hash)\\n words_positions.append(p_set)\\n return words\",\n \"def build_vocab(sentences_list, vocab_size, visual_fld):\\n words = [word for sentence in sentences_list for word in sentence]\\n utils.safe_mkdir(visual_fld)\\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\\n dictionary = {}\\n index_dictionary = {}\\n count = [('UNK', -1)]\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n for index, (word, _) in enumerate(count):\\n dictionary[word] = index\\n index_dictionary[index] = word\\n fd.write(word + '\\\\n')\\n\\n return dictionary, index_dictionary\",\n \"def generate_words(self, count=100):\\n\\n with self.open_text_data() as f:\\n result = self.read_words(f, count=count)\\n return result\",\n \"def create_word(char_list):\",\n \"def fill_list(self):\\n for i in range(0, constants.STARTING_WORDS):\\n random_word = constants.LIBRARY[random.randint(0, len(constants.LIBRARY) - 1)]\\n x = random.randint(1, constants.MAX_X - len(self.get_text()))\\n y = random.randint(1, constants.MAX_Y - len(self.get_text()))\\n position = Point(x, y)\\n self.set_position(position)\\n velocity = Point(0, 1)\\n self._add_segment(random_word, position, velocity)\\n print()\",\n \"def build_vocab(words, vocab_size, visual_fld=None):\\n utils.safe_mkdir(visual_fld)\\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\\n\\n dictionary = dict()\\n count = [('UNK', -1)]\\n index = 0\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n\\n for word, _ in count:\\n dictionary[word] = index\\n index += 1\\n file.write(word + '\\\\n')\\n\\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\\n file.close()\\n return dictionary, index_dictionary\",\n \"def random_shape(gts, reference_shape, pca_model):\\n\\n def synthesize(lms):\\n return detect.synthesize_detection(pca_model, menpo.shape.PointCloud(\\n lms).bounding_box()).points.astype(np.float32)\\n\\n bb, = tf.py_func(synthesize, [gts], [tf.float32])\\n shape = align_reference_shape(reference_shape, bb)\\n shape.set_shape(reference_shape.get_shape())\\n\\n return shape\",\n \"def sample( self, n, words = 100, n_views = 3 ):\\n\\n # Initialise each view to be 0s\\n docs = [ sc.zeros( (n, self.W) ) for v in xrange( n_views ) ]\\n\\n for i in xrange( n ):\\n # Draw topic weights once for a document\\n weights = dirichlet( self.alphas )\\n\\n # Draw the words/k for each view\\n for v in xrange( n_views ):\\n words_ = words/n_views\\n # Get the topic counts\\n cnts = multinomial( words_, weights )\\n for (k, cnt) in zip( xrange( self.K ), cnts ):\\n freq = multinomial( cnt, self.topics.T[k] )/float(words_)\\n # Get the word frequencies for this document\\n docs[v][i] += freq\\n\\n return docs\",\n \"def generate_sample(index_words, context_window_size):\\n for index, center in enumerate(index_words):\\n context = random.randint(1, context_window_size)\\n # get a random target before the center word\\n for target in index_words[max(0, index - context): index]:\\n yield center, target\\n # get a random target after the center wrod\\n for target in index_words[index + 1: index + context + 1]:\\n yield center, target\",\n \"def words_to_edges_v(words, word_threshold=DEFAULT_MIN_WORDS_VERTICAL):\\n # Find words that share the same left, right, or centerpoints\\n by_x0 = cluster_objects(words, \\\"x0\\\", 1)\\n by_x1 = cluster_objects(words, \\\"x1\\\", 1)\\n by_center = cluster_objects(words, lambda x: (x[\\\"x0\\\"] + x[\\\"x1\\\"]) / 2, 1)\\n clusters = by_x0 + by_x1 + by_center\\n\\n # Find the points that align with the most words\\n sorted_clusters = sorted(clusters, key=lambda x: -len(x))\\n large_clusters = filter(lambda x: len(x) >= word_threshold, sorted_clusters)\\n\\n # For each of those points, find the bboxes fitting all matching words\\n bboxes = list(map(objects_to_bbox, large_clusters))\\n\\n # Iterate through those bboxes, condensing overlapping bboxes\\n condensed_bboxes = []\\n for bbox in bboxes:\\n overlap = False\\n for c in condensed_bboxes:\\n if get_bbox_overlap(bbox, c):\\n overlap = True\\n break\\n if not overlap:\\n condensed_bboxes.append(bbox)\\n\\n if len(condensed_bboxes) == 0:\\n return []\\n\\n condensed_rects = map(bbox_to_rect, condensed_bboxes)\\n sorted_rects = list(sorted(condensed_rects, key=itemgetter(\\\"x0\\\")))\\n\\n max_x1 = max(map(itemgetter(\\\"x1\\\"), sorted_rects))\\n min_top = min(map(itemgetter(\\\"top\\\"), sorted_rects))\\n max_bottom = max(map(itemgetter(\\\"bottom\\\"), sorted_rects))\\n\\n # Describe all the left-hand edges of each text cluster\\n edges = [\\n {\\n \\\"x0\\\": b[\\\"x0\\\"],\\n \\\"x1\\\": b[\\\"x0\\\"],\\n \\\"top\\\": min_top,\\n \\\"bottom\\\": max_bottom,\\n \\\"height\\\": max_bottom - min_top,\\n \\\"orientation\\\": \\\"v\\\",\\n }\\n for b in sorted_rects\\n ] + [\\n {\\n \\\"x0\\\": max_x1,\\n \\\"x1\\\": max_x1,\\n \\\"top\\\": min_top,\\n \\\"bottom\\\": max_bottom,\\n \\\"height\\\": max_bottom - min_top,\\n \\\"orientation\\\": \\\"v\\\",\\n }\\n ]\\n\\n return edges\",\n \"def createParagraph(self, nsentences=0, words=[]):\\n ww = []\\n for w in words:\\n w_ = w.lower()\\n if w_ in self.plain_words:\\n ww.append(w_)\\n words = ww\\n if not nsentences:\\n nsentences = n.random.randint(3,10)\\n sentences = []\\n ri = n.random.randint\\n for i in range(nsentences):\\n sentences.append(self.createSentence(ri(1,4),ri(1,4),ri(1,4),ri(1,4),prep=n.random.randint(0,2)))\\n\\n w = set()\\n s1 = []\\n s2 = []\\n for s in sentences:\\n have_word = 0\\n for ww in words:\\n if ww in s:\\n w.add(ww)\\n have_word = 1\\n if have_word:\\n s1.append(s)\\n else:\\n s2.append(s)\\n w2 = set(words)\\n w_ = w2.difference(w)\\n while s2 and w_:\\n ss = self.createSentence(prep=n.random.randint(0,2))\\n w__ = w_.copy()\\n for w in w__:\\n if w in ss:\\n s1.append(ss)\\n s2.pop()\\n w_.remove(w)\\n paragraph = \\\". \\\".join(s1+s2)\\n return paragraph\",\n \"def gen_fake_topic_word(topic_word_shape, fake_idxs):\\n if topic_word_shape[0] != len(fake_idxs):\\n raise ValueError(\\\"topic num isn't equal\\\")\\n fake_topic_word = np.full(topic_word_shape, -1, dtype=np.int32)\\n for tidx in range(topic_word_shape[0]):\\n tmp = len(fake_idxs[0])\\n for widx in fake_idxs[tidx]:\\n fake_topic_word[tidx][widx] = tmp\\n tmp -= 1\\n return fake_topic_word\",\n \"def makeFeatureVec(words, model, num_features):\\n\\t# Initialize an empty numpy array (for speed) \\n\\tfeatureVec = np.zeros((num_features,), dtype=\\\"float32\\\")\\n\\t# Initialize a counter (number of words)\\n\\tnwords = 0.\\n\\t \\n\\t# Index2word is a list that contains the names of the words in the model's vocabulary. \\n\\tindex2word_set = set(model.index2word)\\n\\t# \\n\\t# Loop over each word in the review and, if it is in the model's vocaublary, add \\n\\t# its feature vector to the total \\n\\tfor word in words:\\n\\t\\tif word in index2word_set:\\n\\t\\t\\tnwords = nwords + 1.\\n\\t\\t\\tfeatureVec = np.add(featureVec,model[word])\\n\\t# \\n\\t# Divide the result by the number of words to get the average \\n\\tfeatureVec = np.divide(featureVec,nwords)\\n\\treturn featureVec\",\n \"def build_doc_sense_vec(self):\\n\\t\\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\\n\\t\\t\\tline = infile.readline()\\n\\t\\t\\ti = 0\\n\\t\\t\\twhile line:\\n\\t\\t\\t\\tword = line.split()[0]\\n\\t\\t\\t\\tif not self.word2IdVocabulary.has_key(word):\\n\\t\\t\\t\\t\\t# print i, word\\n\\t\\t\\t\\t\\t# else:\\n\\t\\t\\t\\t\\tself.word2IdVocabulary[word] = i\\n\\t\\t\\t\\tif not self.id2WordVocabulary.has_key(i):\\n\\t\\t\\t\\t\\tself.id2WordVocabulary[i] = word\\n\\t\\t\\t\\tline = infile.readline()\\n\\t\\t\\t\\ti += 1\\n\\t\\t\\tself.vocab_num = len(self.word2IdVocabulary)\\n\\t\\t\\tprint \\\"vocabulary number:\\\" + str(self.vocab_num)\\n\\n\\t\\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\\n\\t\\t\\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\\n\\n\\t\\t\\t\\tfor i, line in enumerate(vecfile):\\n\\t\\t\\t\\t\\tif i % 10000 == 0:\\n\\t\\t\\t\\t\\t\\tprint i\\n\\t\\t\\t\\t\\t# if i > 72:\\n\\t\\t\\t\\t\\t# \\tbreak\\n\\t\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tvector_list.append(sline[1:])\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vec_outfile.write(line)\\n\\t\\t\\t\\t\\telif i > 462887:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_mean\\n\\t\\t\\t\\t\\t\\t'''j = 0\\n\\t\\t\\t\\t\\t\\tfor each_sense_vec in vector_array:\\n\\t\\t\\t\\t\\t\\t\\tif len(vector_array) > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t\\tj += 1\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t x: '%6f' % x})[1:-1] + '\\\\n'\\n\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile.write(new_line)'''\\n\\n\\t\\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\\n\\t\\t\\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\\n\\t\\t\\t\\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\\n\\t\\t\\t\\t\\tprint \\\"Processing document file......\\\"\\n\\t\\t\\t\\t\\tline = docfile.readline().strip('\\\\n')\\n\\t\\t\\t\\t\\twhile line:\\n\\t\\t\\t\\t\\t\\twords = line.split()\\n\\t\\t\\t\\t\\t\\tnew_words = [x for x in words]\\n\\t\\t\\t\\t\\t\\tfor i in range(len(words)):\\n\\t\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[words[i]]\\n\\t\\t\\t\\t\\t\\t\\tsense_vecs = self.vectors[word_id]\\n\\t\\t\\t\\t\\t\\t\\tsense_num = len(sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\tif sense_num > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tcontext_words = []\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif x != i and 0 <= x < len(words):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcontext_words.append(words[x])\\n\\t\\t\\t\\t\\t\\t\\t\\tsense_index = self.select_attention(context_words, sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[sense_index]\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_wordi = words[i] + '_' + str(sense_index)\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_words[i] = new_wordi\\n\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[0]\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tdoc_outfile.write(' '.join(new_words) + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tline = docfile.readline()\\n\\n\\t\\treturn self.vector_word_doc\",\n \"def make_image():\\n # get the mask\\n twitter_mask = np.array(Image.open('resource/twitter-mask.png'))\\n\\n wc = WordCloud(background_color='white', max_words=100, mask=twitter_mask, contour_width=3,\\n contour_color='steelblue')\\n\\n # generate word cloud\\n wc.generate_from_frequencies(get_word_frequency())\\n\\n # store to file\\n wc.to_file('/tmp/twitter.png')\\n\\n # show\\n frame = cv2.imread('/tmp/twitter.png')\\n cv2.imshow('figure', frame)\\n cv2.waitKey(60000)\\n cv2.destroyAllWindows()\",\n \"def get_random_words_from_wordnik(part_of_speech, limit):\\n words = words_api.getRandomWords(includePartOfSpeech=part_of_speech, limit=limit)\\n\\n random_words = []\\n for word in words:\\n random_words.append(word.word)\\n # pprint(random_words)\\n return random_words\",\n \"def generateWord(self, parameters=None):\\n\\t\\t# Initial set-up\\n\\t\\tvowels = ['a', 'e', 'i', 'o', 'u']\\n\\t\\tspecialVowels = ['y']\\n\\n\\t\\tconsonants = ['b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't']\\n\\t\\tspecialConsonants = ['j', 'q', 'v', 'w', 'x', 'z']\\n\\n\\t\\tnewLetterFraction = 5\\n\\t\\tvowelChance = 50 #percent\\n\\n\\t\\t#Determine how many words we're going to have to generate\\n\\t\\trepeats = 1\\n\\t\\tif parameters and len(parameters) > 0:\\n\\t\\t\\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\\n\\n\\t\\twords = []\\n\\t\\tfor i in xrange(0, repeats):\\n\\t\\t\\tword = u\\\"\\\"\\n\\t\\t\\tcurrentVowelChance = vowelChance\\n\\t\\t\\tcurrentNewLetterFraction = newLetterFraction\\n\\t\\t\\tconsonantCount = 0\\n\\t\\t\\twhile random.randint(0, currentNewLetterFraction) <= 6:\\n\\t\\t\\t\\tif random.randint(1, 100) <= currentVowelChance:\\n\\t\\t\\t\\t\\tconsonantCount = 0\\n\\t\\t\\t\\t\\t#vowel. Check if we're going to add a special or normal vowel\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= 10:\\n\\t\\t\\t\\t\\t\\tword += random.choice(specialVowels)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance -= 30\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(vowels)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance -= 20\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tconsonantCount += 1\\n\\t\\t\\t\\t\\t#consonant, same deal\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= 25:\\n\\t\\t\\t\\t\\t\\tword += random.choice(specialConsonants)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance += 30\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(consonants)\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance += 20\\n\\t\\t\\t\\t\\tif consonantCount > 3:\\n\\t\\t\\t\\t\\t\\tcurrentVowelChance = 100\\n\\t\\t\\t\\tcurrentNewLetterFraction += 1\\n\\n\\t\\t\\t#Enough letters added. Finish up\\n\\t\\t\\tword = word[0].upper() + word[1:]\\n\\t\\t\\twords.append(word)\\n\\n\\t\\t#Enough words generated, let's return the result\\n\\t\\treturn u\\\", \\\".join(words)\",\n \"def createSentence(self, n=0, v=0, o=0, p=0,prep=True):\\n sentence = ''\\n if not n:\\n n = np.random.randint(1, 5)\\n if not v:\\n v = np.random.randint(1, 5)\\n if not o:\\n o = np.random.randint(1, 5)\\n sentence += self.createPhrase(nwords=n) + ' '\\n if sentence[:-1] not in ('mi', 'sina'):\\n sentence += 'li '\\n sentence += self.createPhrase(nwords=v) + ' e '\\n sentence += self.createPhrase(nwords=o)\\n if prep:\\n if not p:\\n p = np.random.randint(1, 5)\\n sentence += ' ' + np.random.choice(self.prepositions) + ' ' + self.createPhrase(nwords=p)\\n return sentence\",\n \"def create_vocabulary(sentences, path):\\n print('creating vocab..')\\n\\n word_dict = dict(); vocabulary = dict()\\n for sentence in sentences:\\n for word in nltk.word_tokenize(sentence):\\n if word not in word_dict:\\n word_dict[word] = ''\\n word_dict['<s>'] = ''\\n word_dict['</s>'] = ''\\n\\n with open(path, encoding=\\\"utf8\\\") as f:\\n for line in f:\\n word, vec = line.split(' ', 1)\\n if word in word_dict:\\n vocabulary[word] = np.fromstring(vec, sep=' ')\\n\\n print('vocabulary was created successfully!')\\n return vocabulary\",\n \"def generate(net, z, maxlen=50, im=None, init=None, use_end=True):\\n caption = lm_tools.sample(net, z['word_dict'], z['index_dict'], num=maxlen, Im=im, initial=init, use_end=use_end)\\n print ' '.join(caption)\",\n \"def generate(handle, occurrence_threshold): # verbose, static creation\\n tokenizer = Tokenizer(occurrence_threshold=occurrence_threshold)\\n tokenizer.generate(handle)\\n return tokenizer\",\n \"def buildVocabulary(paragraphs, verbose=True):\\n vocabulary = []\\n \\n for p in paragraphs:\\n for word in p.split():\\n vocabulary.append(word)\\n\\n vocabulary = set(vocabulary)\\n if verbose:\\n print('Built vocabulary of %d unique words'%len(vocabulary))\\n \\n return list(vocabulary)\",\n \"def create_wordcloud(processed_text, filename):\\n\\n\\n pyplot.clf()\\n wordcloud = WordCloud(background_color='white', max_font_size=40, relative_scaling=.5).generate(' '.join(processed_text))\\n pyplot.imshow(wordcloud)\\n pyplot.axis('off')\\n\\n pyplot.savefig(filename)\",\n \"def card_generator(mw, prob_dist_dict, gensim_model):\\n\\n # First things first: make sure that the word is actually in the word2vec vocab.\\n # word_vectors = gensim_model.wv\\n if mw not in gensim_model.wv.vocab:\\n return False\\n\\n # Generate five categories with the weighted probabilities based on their frequency in the gold standard data.\\n five_semrels_list = select_five_categories(prob_dist_dict)\\n five_semrels = pd.Series(five_semrels_list)\\n\\n # Count the number of instances of each semrel category in that list.\\n semrels_counts = dict( five_semrels.value_counts() )\\n\\n # Generate the semantic relations dictionary.\\n srdict = sr.make_semrel_dict(mw)\\n\\n # Rejig five_semrels_list, if need be, to one whose labels are compatible with the cardinality of the sets available\\n # in srdict.\\n good_five_labels = get_good_label_distrib(srdict, semrels_counts)\\n\\n # Now we just populate a list with the required number of each kind of word!\\n # First, initialise list to contain the five final Taboo words (yay!)\\n tws = []\\n\\n # Go through good_five_labels and, for the labels that aren't 'collocation', access their list in the dictionary and\\n # randomly select however many out of it.\\n for label, count in good_five_labels.items():\\n if label != 'collocation':\\n tws.extend( rd.sample( tuple( srdict[label] ), count ) )\\n\\n # Now, take the number of collocations needed and return the most similar words according to gensim, removing the\\n # words that are forbidden (i.e. the main word and also the other words that are already in tws)\\n forbidden_words = set(tws + [mw])\\n num_coll = good_five_labels['collocation']\\n collocates = sr.get_collocations(mw, forbidden_words, gensim_model, num_collocates = num_coll)\\n\\n # If there are more collocates than needed, randomly select num_coll of them and add to tws. Else just add list to tws.\\n if len(collocates) > num_coll:\\n tws.extend( rd.sample( tuple(collocates), num_coll ) )\\n else:\\n tws.extend(collocates)\\n\\n return {mw: tws}\",\n \"def paragraph_selection(sample, mode):\\n # predefined maximum length of paragraph\\n MAX_P_LEN = 500\\n # predefined splitter\\n splitter = u'<splitter>'\\n # topN of related paragraph to choose\\n topN = 3\\n doc_id = None\\n if 'answer_docs' in sample and len(sample['answer_docs']) > 0:\\n doc_id = sample['answer_docs'][0]\\n if doc_id >= len(sample['documents']):\\n # Data error, answer doc ID > number of documents, this sample\\n # will be filtered by dataset.py\\n return\\n for d_idx, doc in enumerate(sample['documents']):\\n if 'segmented_paragraphs_scores' not in doc:\\n continue\\n status = dup_remove(doc)\\n segmented_title = doc[\\\"segmented_title\\\"]\\n title_len = len(segmented_title)\\n para_id = None\\n if doc_id is not None:\\n para_id = sample['documents'][doc_id]['most_related_para']\\n total_len = title_len + sum(doc['paragraphs_length'])\\n # add splitter\\n para_num = len(doc[\\\"segmented_paragraphs\\\"])\\n total_len += para_num\\n if total_len <= MAX_P_LEN:\\n incre_len = title_len\\n total_segmented_content = copy.deepcopy(segmented_title)\\n for p_idx, segmented_para in enumerate(doc[\\\"segmented_paragraphs\\\"]):\\n if doc_id == d_idx and para_id > p_idx:\\n incre_len += len([splitter] + segmented_para)\\n if doc_id == d_idx and para_id == p_idx:\\n incre_len += 1\\n total_segmented_content += [splitter] + segmented_para\\n if doc_id == d_idx:\\n answer_start = incre_len + sample['answer_spans'][0][0]\\n answer_end = incre_len + sample['answer_spans'][0][1]\\n sample['answer_spans'][0][0] = answer_start\\n sample['answer_spans'][0][1] = answer_end\\n doc[\\\"segmented_paragraphs\\\"] = [total_segmented_content]\\n doc[\\\"segmented_paragraphs_scores\\\"] = [1.0]\\n doc['paragraphs_length'] = [total_len]\\n doc['paragraphs'] = [''.join(total_segmented_content)]\\n doc['most_related_para'] = 0\\n continue\\n # find topN paragraph id\\n para_infos = []\\n for p_idx, (para_tokens, para_scores) in \\\\\\n enumerate(zip(doc['segmented_paragraphs'], doc['segmented_paragraphs_scores'])):\\n para_infos.append((para_tokens, para_scores, len(para_tokens), p_idx))\\n para_infos.sort(key=lambda x: (-x[1], x[2]))\\n topN_idx = []\\n for para_info in para_infos[:topN]:\\n topN_idx.append(para_info[-1])\\n final_idx = []\\n total_len = title_len\\n if doc_id == d_idx:\\n if mode == \\\"train\\\":\\n final_idx.append(para_id)\\n total_len = title_len + 1 + doc['paragraphs_length'][para_id]\\n for id in topN_idx:\\n if total_len > MAX_P_LEN:\\n break\\n if doc_id == d_idx and id == para_id and mode == \\\"train\\\":\\n continue\\n total_len += 1 + doc['paragraphs_length'][id] \\n final_idx.append(id)\\n total_segmented_content = copy.deepcopy(segmented_title)\\n final_idx.sort()\\n incre_len = title_len\\n for id in final_idx:\\n if doc_id == d_idx and id < para_id:\\n incre_len += 1 + doc['paragraphs_length'][id]\\n if doc_id == d_idx and id == para_id:\\n incre_len += 1\\n total_segmented_content += [splitter] + doc['segmented_paragraphs'][id]\\n if doc_id == d_idx:\\n answer_start = incre_len + sample['answer_spans'][0][0]\\n answer_end = incre_len + sample['answer_spans'][0][1]\\n sample['answer_spans'][0][0] = answer_start\\n sample['answer_spans'][0][1] = answer_end\\n doc[\\\"segmented_paragraphs\\\"] = [total_segmented_content]\\n doc[\\\"segmented_paragraphs_scores\\\"] = [1.0]\\n doc['paragraphs_length'] = [total_len]\\n doc['paragraphs'] = [''.join(total_segmented_content)]\\n doc['most_related_para'] = 0\",\n \"def build_model():\\n \\n #english trained optimized pipeline for word embedding\\n nlp = spacy.load(\\\"en_core_web_md\\\") # this model will give you 300D\\n \\n pipeline = Pipeline([\\n ('features', FeatureUnion([\\n ('text_pipeline', Pipeline([\\n ('vect', CountVectorizer(tokenizer=tokenize)),\\n ('tfidf', TfidfTransformer()),\\n ])),\\n \\n ('embeddings_pipeline', Pipeline([\\n ('vect_trans',SpacyVectorTransformer(nlp)),\\n ('reduce_dim', TruncatedSVD(50)),\\n ])),\\n \\n ])),\\n \\n ('clf', MultiOutputClassifier(RandomForestClassifier()))\\n ])\\n \\n parameters = {\\n 'features__text_pipeline__vect__max_df': (0.5, 0.75, 1.0),\\n 'features__embeddings_pipeline__reduce_dim__n_components':(50,60,70,100,120,130,150)\\n }\\n cv = GridSearchCV(pipeline, param_grid=parameters,cv=2)\\n \\n return cv\",\n \"def build_data(self, data_folder, cv=10, clean_string=False):\\n revs = []\\n # pos_file = loadmodel(data_folder[0])\\n # neg_file = loadmodel(data_folder[1])\\n pos_texts = loadmodel(data_folder[0]).get(\\\"content\\\")\\n neg_texts = loadmodel(data_folder[1]).get(\\\"content\\\")\\n vocab = defaultdict(float)\\n happyList = [ \\\":-)\\\", \\\":)\\\", \\\":D\\\", \\\":o)\\\", \\\":]\\\", \\\":3\\\", \\\":c)\\\", \\\":>\\\", \\\"=]\\\", \\\"8)\\\", \\\"=)\\\", \\\":}\\\", \\\":^)\\\", \\\":?)\\\", \\\":-)\\\", \\\": )\\\", \\\": D\\\", \\\": o)\\\", \\\":]\\\", \\\": 3\\\", \\\":c)\\\", \\\":>\\\", \\\"= ]\\\", \\\"8 )\\\", \\\"= )\\\", \\\": }\\\", \\\":^)\\\", \\\":?)\\\" ]\\n sadList = [ \\\">:[\\\", \\\":-(\\\", \\\":(\\\", \\\":-c\\\", \\\":c\\\", \\\":-<\\\", \\\":?C\\\", \\\":<\\\", \\\":-[\\\", \\\":[\\\", \\\":{\\\",\\\">:[\\\", \\\":-(\\\", \\\": (\\\", \\\":-c\\\", \\\": c\\\", \\\": -<\\\", \\\": ?C\\\", \\\": <\\\", \\\": -[\\\", \\\": [\\\", \\\": {\\\" ]\\n for line in pos_texts:\\n rev = []\\n rev.append(line.strip())\\n\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n #print orig_rev\\n words = set(orig_rev.split())\\n for word in words:\\n if word in happyList or word in sadList:\\n pass\\n else:\\n vocab[word] += 1\\n datum = {\\\"y\\\":1,\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": np.random.randint(0,cv)}\\n revs.append(datum)\\n\\n for line in neg_texts:\\n rev = []\\n rev.append(line.strip())\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n words = set(orig_rev.split())\\n for word in words:\\n if word in happyList or word in sadList:\\n pass\\n else:\\n vocab[word] += 1\\n datum = {\\\"y\\\":0,\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": np.random.randint(0,cv)}\\n revs.append(datum)\\n return revs, vocab\",\n \"def generate(size, data_dim=5, n_phrase_labels=4, n_words=3,\\n n_phrase_words=3, n_phrases=5, label_noise=0.,\\n min_sent_len=5, max_sent_len=5, tag_end=True):\\n assert n_words < 256\\n assert max_sent_len >= n_phrase_words\\n global dictionary, phrases\\n\\n # generate dictionary\\n dictionary = uniform(-1.0, 1.0, size=(n_words, data_dim))\\n\\n # generate n_phrases unique word sequences of length n_phrase_words\\n print \\\"Generating %d phrases\\\" % n_phrases\\n phrases = []\\n phrase_labels = []\\n while len(phrases) != n_phrases:\\n phrases = np.unique(np.array([\\\"\\\".join(map(chr, randint(n_words, size=n_phrase_words)))\\n for i in xrange(n_phrases)], dtype=np.object))\\n assert np.unique(map(len, phrases)) == n_phrase_words\\n phrase_labels = 1+randint(n_phrase_labels-1, size=n_phrases)\\n\\n # generate 'sentences'\\n print \\\"Generating %d sentences\\\" % sum(size)\\n Xind = []\\n Y = []\\n for i in xrange(sum(size)):\\n while True:\\n sent_len = randint(min_sent_len, max_sent_len+1)\\n sent = \\\"\\\".join(map(chr, randint(n_words, size=sent_len)))\\n if contains_any_phrase(sent, phrases):\\n print \\\".\\\",\\n break\\n Y.append(np.zeros(sent_len,dtype=np.int))\\n Xind.append(sent)\\n\\n # generate labels for dataset\\n print \\\"Generating labels for the sentences...\\\"\\n for phrase, plabel in zip(phrases, phrase_labels):\\n for idx, sent in enumerate(Xind):\\n start = 0\\n while True:\\n sidx = sent.find(phrase, start)\\n if sidx < 0:\\n break\\n if tag_end:\\n Y[idx][sidx+len(phrase)-1] = plabel\\n else:\\n Y[idx][sidx] = plabel\\n start += 1\\n\\n print \\\"Trafo...\\\"\\n # transform dataset to code\\n if data_dim > 1:\\n X = [[dictionary[ord(c)] for c in sent] for sent in Xind]\\n else:\\n X = [[ord(c) for c in sent] for sent in Xind]\\n\\n Xtrain, Xtest = X[:size[0]], X[size[0]:]\\n Ytrain, Ytest = Y[:size[0]], Y[size[0]:]\\n\\n # training label noise\\n for sent in Ytrain:\\n mask = uniform(size=sent.size) < label_noise\\n sent[mask] = randint(n_phrase_labels, size=mask.sum())\\n print \\\"Done.\\\"\\n\\n return Xtrain, Xtest, Ytrain, Ytest\",\n \"def feature_vecs_DOC(train_pos, train_neg, test_pos, test_neg):\\n # Doc2Vec requires LabeledSentence objects as input.\\n # Turn the datasets from lists of words to lists of LabeledSentence objects.\\n # YOUR CODE HERE\\n labeled_train_pos = []\\n labeled_train_neg = []\\n labeled_test_pos = []\\n labeled_test_neg = []\\n i = 0\\n for line in train_pos:\\n labeled_train_pos.append(LabeledSentence(line, ['TRAIN_POS_%i' % i]))\\n i += 1\\n i = 0\\n for line in train_neg:\\n labeled_train_neg.append(LabeledSentence(line, ['TRAIN_NEG_%i' % i]))\\n i += 1\\n i = 0\\n for line in test_pos:\\n labeled_test_pos.append(LabeledSentence(line, ['TEST_POS_%i' % i]))\\n i += 1\\n i = 0\\n for line in test_neg:\\n labeled_test_neg.append(LabeledSentence(line, ['TEST_NEG_%i' % i]))\\n i += 1\\n\\n # Initialize model\\n model = Doc2Vec(min_count=1, window=10, size=100, sample=1e-4, negative=5, workers=4)\\n sentences = labeled_train_pos + labeled_train_neg + labeled_test_pos + labeled_test_neg\\n model.build_vocab(sentences)\\n\\n # Train the model\\n # This may take a bit to run \\n for i in range(5):\\n print \\\"Training iteration %d\\\" % (i)\\n random.shuffle(sentences)\\n model.train(sentences)\\n\\n # Use the docvecs function to extract the feature vectors for the training and test data\\n # YOUR CODE HERE\\n train_pos_vec = []\\n train_neg_vec = []\\n test_pos_vec = []\\n test_neg_vec = []\\n for j in range(len(train_pos)):\\n train_pos_vec.append(model.docvecs['TRAIN_POS_%i' % j])\\n for j in range(len(train_neg)):\\n train_neg_vec.append(model.docvecs['TRAIN_NEG_%i' % j])\\n for j in range(len(test_pos)):\\n test_pos_vec.append(model.docvecs['TEST_POS_%i' % j])\\n for j in range(len(test_neg)):\\n test_neg_vec.append(model.docvecs['TEST_NEG_%i' % j])\\n\\n # Return the four feature vectors\\n return train_pos_vec, train_neg_vec, test_pos_vec, test_neg_vec\",\n \"def build_Wordv(word2vec_dict, k):\\r\\n vocab_size = len(word2vec_dict)\\r\\n word2id_dict = dict()\\r\\n W = np.zeros(shape=(vocab_size + 1, k))\\r\\n W[0] = np.zeros(k)\\r\\n i = 1\\r\\n for word in word2vec_dict:\\r\\n # print type(word), ' | ', word\\r\\n W[i] = word2vec_dict[word]\\r\\n # print type(W[i]), \\\" | \\\", W[i]\\r\\n word2id_dict[word] = i\\r\\n i += 1\\r\\n return W, word2id_dict\",\n \"def creating_feature_vector():\\r\\n\\twordlist = []\\r\\n\\tlabel = \\\"\\\"\\r\\n\\tfw = open(\\\"feature_vector.txt\\\", \\\"w+\\\", encoding = \\\"utf-8\\\")\\r\\n\\twith open(\\\"D:\\\\\\\\Python_Prac\\\\\\\\wordstag\\\\\\\\modules\\\\\\\\HI_EN_TRAIN.txt\\\", \\\"r\\\", encoding = \\\"utf-8\\\") as f:\\r\\n\\t\\tfor line in f:\\r\\n\\t\\t\\twordlist.append(line)\\r\\n\\t\\tfor index, line in enumerate(wordlist):\\r\\n\\t\\t\\tif line == \\\"\\\\n\\\":\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\tcontext = line.split(\\\"\\\\t\\\")\\r\\n\\t\\t\\tlabel = context[1]\\r\\n\\t\\t\\tfeature_vector = label+\\\" \\\"\\r\\n\\t\\t\\tngram_vector = ngram_frequency(str(context[0]))\\r\\n\\t\\t\\tfor vector in ngram_vector:\\r\\n\\t\\t\\t\\tfeature_vector += str(vector)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_abbr(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tbefore = [0,0,0]\\r\\n\\t\\t\\tafter = [0,0,0]\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index+i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in before:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfor i in after:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += \\\"\\\\n\\\"\\r\\n\\t\\t\\tfw.write(feature_vector)\\r\\n\\t\\t\\tprint(\\\"Proceeding...\\\"+str(index+1)+\\\" of 16683\\\")\\r\\n\\r\\n\\tfw.close()\",\n \"def word2vec_generation(self, utterance, with_punctuations):\\n vector = []\\n\\n #words = self.text_preparation(utterance)\\n\\n words = utterance\\n\\n #model_ = Word2Vec.load('model.bin')\\n #if not self.is_word_in_word2vec_vocabulary(utterance, model_):\\n # self.retrain_model([words])\\n\\n if with_punctuations:\\n new_model = Word2Vec.load('./model/model_word2vec.bin')\\n else:\\n new_model = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\\n\\n\\n\\n # TODO: how generate word2vec vectors for each utterance using the vocabularies in Word2vec model?\\n\\n #First: average of Word2Vec vectors in each utterance\\n for w in words:\\n vector.append(new_model.wv[w])\\n\\n return np.mean(vector, axis=0)\",\n \"def build_data_cv(file, split_dict, label_dict, clean_string=False):\\n revs = []\\n f = open(file)\\n vocab = defaultdict(float)\\n \\n for index, line in enumerate(f.readlines()): \\n rev = []\\n rev.append(line.strip())\\n if clean_string:\\n orig_rev = clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev)\\n words = set(orig_rev.split())\\n for word in words:\\n vocab[word] += 1\\n datum = {\\\"y\\\":label_dict[index], \\n \\\"text\\\": orig_rev, \\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": split_dict[index]}#1 or 2\\n revs.append(datum)\\n\\n return revs, vocab\",\n \"def pregroup_draw(words, cups, **params):\\n textpad = params.get('textpad', (.1, .2))\\n textpad_words = params.get('textpad_words', (0, .1))\\n space = params.get('space', .5)\\n width = params.get('width', 2.)\\n fontsize = params.get('fontsize', None)\\n\\n backend = TikzBackend(use_tikzstyles=params.get('use_tikzstyles', None))\\\\\\n if params.get('to_tikz', False)\\\\\\n else MatBackend(figsize=params.get('figsize', None))\\n\\n def draw_triangles(words):\\n scan = []\\n for i, word in enumerate(words.boxes):\\n for j, _ in enumerate(word.cod):\\n x_wire = (space + width) * i\\\\\\n + (width / (len(word.cod) + 1)) * (j + 1)\\n scan.append(x_wire)\\n if params.get('draw_types', True):\\n backend.draw_text(\\n str(word.cod[j]), x_wire + textpad[0], -textpad[1],\\n fontsize=params.get('fontsize_types', fontsize))\\n backend.draw_polygon(\\n ((space + width) * i, 0),\\n ((space + width) * i + width, 0),\\n ((space + width) * i + width / 2, 1),\\n color=DEFAULT.color)\\n backend.draw_text(\\n str(word), (space + width) * i + width / 2 + textpad_words[0],\\n textpad_words[1], ha='center', fontsize=fontsize)\\n return scan\\n\\n def draw_cups_and_wires(cups, scan):\\n for j, off in [(j, off)\\n for j, s in enumerate(cups) for off in s.offsets]:\\n middle = (scan[off] + scan[off + 1]) / 2\\n backend.draw_wire((scan[off], 0), (middle, - j - 1), bend_in=True)\\n backend.draw_wire(\\n (scan[off + 1], 0), (middle, - j - 1), bend_in=True)\\n scan = scan[:off] + scan[off + 2:]\\n for i, _ in enumerate(cups[-1].cod if cups else words.cod):\\n label = str(cups[-1].cod[i]) if cups else \\\"\\\"\\n backend.draw_wire((scan[i], 0), (scan[i], - (len(cups) or 1) - 1))\\n if params.get('draw_types', True):\\n backend.draw_text(\\n label, scan[i] + textpad[0], - (len(cups) or 1) - space,\\n fontsize=params.get('fontsize_types', fontsize))\\n\\n scan = draw_triangles(words.normal_form())\\n draw_cups_and_wires(cups, scan)\\n backend.output(\\n params.get('path', None),\\n tikz_options=params.get('tikz_options', None),\\n xlim=(0, (space + width) * len(words.boxes) - space),\\n ylim=(- len(cups) - space, 1),\\n margins=params.get('margins', DEFAULT.margins),\\n aspect=params.get('aspect', DEFAULT.aspect))\",\n \"def build_new_text(tgram, start_words, max_words):\\n out_words = []\\n for i in range(max_words - 2):\\n if start_words in tgram:\\n next_word = random.choice(tgram[start_words])\\n out_words.append(next_word)\\n start_words = start_words.split()\\n start_words = start_words[1] + \\\" \\\" + next_word\\n else:\\n break\\n out_words = \\\" \\\".join(out_words)\\n return out_words\",\n \"def createPhrase(self, nsy=0, nwords=0, vowel=False):\\n phrase = ''\\n if nwords:\\n if nsy == 0:\\n nsy = n.random.randint(1,7)\\n for i in range(nwords):\\n w = n.random.choice(self.plain_words)\\n phrase += w + ' '\\n else:\\n if nsy == 0:\\n nsy = n.random.randint(1,7)\\n nsy_ = 0\\n while nsy_ < nsy:\\n w = n.random.choice(self.plain_words)\\n s = self._getSyllables(w)\\n l = len(s)\\n if w[0] in self.vowels and vowel: # elision\\n l -= 1\\n if nsy_+l > nsy:\\n continue\\n nsy_ += l\\n phrase += w + ' '\\n if w[-1] in self.vowels:\\n vowel = 1\\n else:\\n vowel = 0\\n p = phrase[:-1]\\n p_ = p.split()\\n nsy_ = sum([len(self._getSyllables(i)) for i in p_])\\n if len(p_) > 2 and nsy_ > 4:\\n if n.random.random() < .2: # use pi in 1/5 of sentences\\n # print('\\\\n', p, self._countSyllables(p))\\n where = n.random.randint(len(p_)-2)\\n p_.insert(where+1, 'pi')\\n if p_[where+2][0] not in self.vowels or (p_[where+2][0] in self.vowels and p_[where][-1] in self.vowels):\\n # choose a words with two or three syllables\\n # and make them one syllable shorter\\n p__ = ' '.join(p_)\\n while self._countSyllables(p__) != self._countSyllables(p):\\n sy__ = n.array([len(self._getSyllables(i)) for i in p_])\\n if n.all(sy__ == 1):\\n if self._countSyllables(' '.join(p_)) < nsy:\\n where_ = n.random.randint(len(p_))\\n p_.insert(where_, n.random.choice(self.plain_words))\\n elif self._countSyllables(' '.join(p_)) > nsy:\\n chosen = n.random.randint(0, len(p_))\\n while p_[chosen] == 'pi':\\n\\n chosen = n.random.randint(0, len(p_))\\n p_.pop(chosen)\\n else:\\n ok = (sy__ > 1).nonzero()[0]\\n chosen = n.random.choice(ok)\\n size = sy__[chosen]\\n w = n.random.choice(self.words_nsy[size-2])\\n p_[chosen] = w\\n p__ = ' '.join(p_)\\n # print(' '.join(p_), self._countSyllables(' '.join(p_)))\\n pp = ' '.join(p_)\\n\\n return pp\",\n \"def generate_text(model, w2vmodel, nb_epoch, length=75, max_seq_length=20, seed=\\\"Rain drop drop top\\\"):\\n global sample\\n generated = ''\\n sequences = seed\\n\\n generated += seed\\n\\n #clean seed\\n seed=re.sub(r'<[^<]+?>', '', seed)\\n #remove encoding characters like \\\\x86\\n seed=re.sub(r'[^\\\\x00-\\\\x7f]','',seed)\\n seed=re.sub(r'\\\\#','',seed)\\n #remove punctuation\\n seed=re.sub(r'[^A-Za-z0-9\\\\s]','',seed)\\n\\n #shorten if longer than max_seq_length\\n seed = seed.split(' ')[:max_seq_length]\\n\\n word_ix_list = []\\n for word in seed:\\n try:\\n word = word_to_ix(word,w2vmodel)\\n except:\\n #since we're using -1 as a null word (why we also pad with the not in vocab index), we'll use that for words that aren't in the word2vec model\\n print('Warning: {0} not contained in training vocabulary. It will be ignored when computing output.'.format(word))\\n word = word_to_ix('_UNSEEN_',w2vmodel)\\n word_ix_list.append(word)\\n\\n #pad word_list with the unseen word2vec if shorter than max_seq_length\\n word_ix_list = [word_to_ix('_UNSEEN_',w2vmodel)] * (max_seq_length-len(word_ix_list)) + word_ix_list\\n\\n for temp in [0.2, 0.5, .75, 1.0]:\\n print('temperature: ', temp)\\n for word in range(length):\\n #reshape wordlist\\n word_ix_list = np.asarray(word_ix_list).reshape(1,max_seq_length)\\n\\n #prediction = model.predict(x=word_ix_list)\\n #next_ix = np.argmax(prediction)\\n prediction = model.predict(x=word_ix_list,verbose=0)[0]\\n next_ix = sample(prediction, temp)\\n predicted_word = ix_to_word(next_ix,w2vmodel)\\n\\n generated += (' ' + predicted_word) #add predicted word to the generated output\\n\\n #remove first word from the word list to reduce the array for the max sequence length for the model\\n word_ix_list = np.append(word_ix_list,next_ix)\\n word_ix_list.shape\\n word_ix_list = np.delete(word_ix_list,0,0)\\n print(generated)\\n print('-----')\\n #print(generated)\\n return\",\n \"def create_instances_from_document(\\n all_documents, document_index, max_seq_length, short_seq_prob,\\n masked_lm_prob, max_predictions_per_seq, vocab_words, rng):\\n document = all_documents[document_index]\\n\\n # Account for [CLS], [SEP], [SEP]\\n max_num_tokens = max_seq_length - 3\\n\\n # We *usually* want to fill up the entire sequence since we are padding\\n # to `max_seq_length` anyways, so short sequences are generally wasted\\n # computation. However, we *sometimes*\\n # (i.e., short_seq_prob == 0.1 == 10% of the time) want to use shorter\\n # sequences to minimize the mismatch between pre-training and fine-tuning.\\n # The `target_seq_length` is just a rough target however, whereas\\n # `max_seq_length` is a hard limit.\\n target_seq_length = max_num_tokens\\n if rng.random() < short_seq_prob:\\n target_seq_length = rng.randint(2, max_num_tokens)\\n\\n # We DON'T just concatenate all of the tokens from a document into a long\\n # sequence and choose an arbitrary split point because this would make the\\n # next sentence prediction task too easy. Instead, we split the input into\\n # segments \\\"A\\\" and \\\"B\\\" based on the actual \\\"sentences\\\" provided by the user\\n # input.\\n instances = []\\n current_chunk = []\\n current_length = 0\\n i = 0\\n while i < len(document):\\n segment = document[i]\\n current_chunk.append(segment)\\n current_length += len(segment)\\n if i == len(document) - 1 or current_length >= target_seq_length:\\n if current_chunk:\\n # `a_end` is how many segments from `current_chunk` go into the `A`\\n # (first) sentence.\\n a_end = 1\\n if len(current_chunk) >= 2:\\n a_end = rng.randint(1, len(current_chunk) - 1)\\n\\n tokens_a = []\\n for j in range(a_end):\\n tokens_a.extend(current_chunk[j])\\n\\n tokens_b = []\\n # Random next\\n is_random_next = False\\n if len(current_chunk) == 1 or rng.random() < 0.5:\\n is_random_next = True\\n target_b_length = target_seq_length - len(tokens_a)\\n\\n # This should rarely go for more than one iteration for large\\n # corpora. However, just to be careful, we try to make sure that\\n # the random document is not the same as the document\\n # we're processing.\\n for _ in range(10):\\n random_document_index = rng.randint(\\n 0, len(all_documents) - 1)\\n if random_document_index != document_index:\\n break\\n\\n random_document = all_documents[random_document_index]\\n random_start = rng.randint(0, len(random_document) - 1)\\n for j in range(random_start, len(random_document)):\\n tokens_b.extend(random_document[j])\\n if len(tokens_b) >= target_b_length:\\n break\\n # We didn't actually use these segments so we \\\"put them back\\\" so\\n # they don't go to waste.\\n num_unused_segments = len(current_chunk) - a_end\\n i -= num_unused_segments\\n # Actual next\\n else:\\n is_random_next = False\\n for j in range(a_end, len(current_chunk)):\\n tokens_b.extend(current_chunk[j])\\n truncate_seq_pair(tokens_a, tokens_b, None,\\n max_num_tokens, rng)\\n if len(tokens_a) < 1 or len(tokens_b) < 1:\\n current_chunk = []\\n current_length = 0\\n i += 1\\n continue\\n assert len(tokens_a) >= 1, tokens_a\\n assert len(tokens_b) >= 1, tokens_b\\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\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n for token in tokens_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n\\n (tokens, masked_lm_positions,\\n masked_lm_labels) = create_masked_lm_predictions(\\n tokens, masked_lm_prob, max_predictions_per_seq, vocab_words, rng)\\n instance = TrainingInstance(\\n tokens=tokens,\\n segment_ids=segment_ids,\\n is_random_next=is_random_next,\\n masked_lm_positions=masked_lm_positions,\\n masked_lm_labels=masked_lm_labels)\\n instances.append(instance)\\n current_chunk = []\\n current_length = 0\\n i += 1\\n\\n return instances\",\n \"def make_text(sent, begin, end):\\n lemmas = [sent.morps[begin].lemma(), ]\\n for idx in range(begin+1, end):\\n if sent.mid2wid[idx-1] != sent.mid2wid[idx]: # if go over word boundary\\n # insert space between words\\n lemmas.append(' ')\\n lemmas.append(sent.morps[idx].lemma())\\n return ''.join(lemmas)\",\n \"def voc_rand_crop(feature, label, height, width):\\n i, j, h, w = torchvision.transforms.RandomCrop.get_params(\\n feature, output_size=(height, width))\\n \\n feature = torchvision.transforms.functional.crop(feature, i, j, h, w)\\n label = torchvision.transforms.functional.crop(label, i, j, h, w) \\n\\n return feature, label\",\n \"def initialize_out_of_vocab_words(dimension, choice='zero'):\\r\\n if choice == 'random':\\r\\n \\\"\\\"\\\"Returns a random vector of size dimension where mean is 0 and standard deviation is 1.\\\"\\\"\\\"\\r\\n return np.random.normal(size=dimension)\\r\\n elif choice == 'zero':\\r\\n \\\"\\\"\\\"Returns a vector of zeros of size dimension.\\\"\\\"\\\"\\r\\n return np.zeros(shape=dimension)\",\n \"def construct_embedding(self):\\n i = 0\\n self.load_dicts()\\n embedding_shape = (max(self.word2idx.values()) + 1,\\n self.embedding_size)\\n self.embedding = np.zeros(embedding_shape)\\n\\n with open(self.config.word_vec_fi_glove, 'r') as fi:\\n for line in fi:\\n word_vec = line.split(\\\" \\\")[1:]\\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\\n i += 1\\n\\n self.write_embedding()\",\n \"def generate_bar_example(\\n num_topics=10, num_documents=500, num_words_per_doc=100, alpha=1, beta=1, seed=None\\n):\\n\\n width = 5\\n\\n vocab_size = width * width\\n rng = random.Random()\\n if seed is not None:\\n rng.seed(seed)\\n\\n zeros = [[0 for i in range(width)] for j in range(width)]\\n topic_squares = [zeros for i in range(num_topics)]\\n for i in range(width):\\n for j in range(width):\\n topic_squares[i][i][j] = 1.0 / width\\n for i in range(width):\\n for j in range(width):\\n topic_squares[width + i][j][i] = 1.0 / width\\n topics = []\\n for k in range(num_topics):\\n topics.append(list(_itertools.chain(*topic_squares[k])))\\n\\n def weighted_choice(probs):\\n total = sum(probs)\\n r = rng.uniform(0, total)\\n upto = 0\\n for i, w in enumerate(probs):\\n if upto + w > r:\\n return i\\n upto += w\\n assert False, \\\"Shouldn't get here\\\"\\n\\n documents = []\\n thetas = []\\n for d in range(num_documents):\\n doc = [0 for i in range(width * width)]\\n topic_dist = [rng.gammavariate(1, 1) for k in range(num_topics)]\\n topic_dist = [z / sum(topic_dist) for z in topic_dist]\\n for i in range(num_words_per_doc):\\n k = weighted_choice(topic_dist)\\n w = weighted_choice(topics[k])\\n doc[w] += 1\\n thetas.append(topic_dist)\\n documents.append(doc)\\n\\n sparse_documents = []\\n for d in documents:\\n sd = {}\\n for i in range(width):\\n for j in range(width):\\n k = str(i) + \\\",\\\" + str(j)\\n sd[k] = d[i * width + j]\\n sparse_documents.append(sd)\\n bow_documents = turicreate.SArray(sparse_documents)\\n return bow_documents\",\n \"def build_vocab(vocab_size, text_vector):\\n vocab = Counter()\\n for text in text_vector:\\n for word in text.split(' '):\\n vocab[word.lower()]+=1\\n vocab = dict(vocab.most_common(vocab_size))\\n return vocab\",\n \"def surface_labelled_data_preparation(word_dictionary: {str, str}):\\n X = []\\n Y = []\\n words = []\\n\\n for word in word_dictionary:\\n segments = word.split('-')\\n labels = word_dictionary[word].split('-')\\n segment_features = []\\n for i in range(len(segments)):\\n features = {}\\n\\n segment_length = len(segments[i])\\n features['length'] = segment_length\\n\\n features['segment.lower()'] = segments[i].lower()\\n features['pos_in_word'] = i\\n\\n if segment_length % 2 == 0:\\n features['even'] = 1\\n else:\\n features['odd'] = 1\\n\\n features['begin'] = segments[i][0]\\n features['end'] = segments[i][len(segments[i]) - 1]\\n\\n try:\\n features['prev_segment'] = segments[i - 1]\\n except IndexError:\\n features['prev_segment'] = ''\\n # continue\\n\\n try:\\n features['next_segment'] = segments[i + 1]\\n except IndexError:\\n features['next_segment'] = ''\\n\\n if segments[0].isupper():\\n features['start_upper'] = 1\\n else:\\n features['start_lower'] = 1\\n\\n if segments[0] in 'aeiou':\\n features['first_vowel'] = 1\\n else:\\n features['first_const'] = 1\\n\\n segment_features.append(features)\\n words.append(segments)\\n\\n X.append(segment_features)\\n Y.append(labels)\\n words.append(word)\\n\\n return X, Y, words\",\n \"def make_embedding(path, words, indices):\\n #root = '/'.join(path.split('/')[0:-1])\\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n #for path in all_paths:\\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\\n print(vec_path)\\n if os.path.exists(vec_path+'.npy'):\\n np_vecs = np.load(vec_path+'.npy')\\n else:\\n words_len = len(words)\\n vecs = []\\n if mode == 'word':\\n f = load_model('wiki.en.bin')\\n for i, w in enumerate(words):\\n if mode == 'word':\\n vec = f.get_word_vector(w)\\n else:\\n vec = eye[indices[w]]\\n vecs.append(vec) \\n if i % 10000 == 0:\\n print(\\\"{} / {}\\\".format(i, words_len))\\n np_vecs = np.asarray(vecs, dtype=np.int8)\\n np.save(vec_path, np_vecs)\\n return np_vecs\",\n \"def build_vocab(captions, threshold=0):\\n\\n\\tcounter = Counter()\\n\\tfor caption in captions:\\n\\t\\ttokens = caption.lower().split('/') \\n\\t\\tcounter.update(tokens)\\n\\n\\n\\t# If the word frequency is less than 'threshold', then the word is discarded.\\n\\twords = [word for word, cnt in counter.items() if cnt >= threshold]\\n\\t# Creates a vocab wrapper and add some special tokens.\\n\\tvocab = Vocabulary()\\n\\tvocab.add_word('<pad>')\\n\\tvocab.add_word('<start>')\\n\\tvocab.add_word('<end>')\\n\\tvocab.add_word('<unk>')\\n\\n\\t# Adds the words to the vocabulary.\\n\\tfor i, word in enumerate(words):\\n\\t\\tvocab.add_word(word)\\n\\treturn vocab\",\n \"def generate_wordcloud(dict_, title='WordCloud', PATH=None):\\n wordcloud = WordCloud(min_font_size=10).generate_from_frequencies(dict_)\\n plt.figure(figsize = (8, 8), facecolor = None) \\n plt.imshow(wordcloud) \\n plt.axis(\\\"off\\\") \\n plt.title(title, size = 24)\\n plt.tight_layout(pad = 0) \\n if PATH:\\n plt.savefig(PATH, bbox_inches=\\\"tight\\\", transparent=True)\\n plt.show()\",\n \"def _create_vocab(captions):\\n print(\\\"Creating vocabulary.\\\")\\n min_word_count = 4\\n word_counts_output_file = '/Users/lzg/Desktop/image_caption/word_count.txt'\\n counter = Counter()\\n for c in captions:\\n counter.update(c)\\n print(\\\"Total words:\\\", len(counter))\\n\\n # Filter uncommon words and sort by descending count.\\n word_counts = [x for x in counter.items() if x[1] >= min_word_count]\\n word_counts.sort(key=lambda x: x[1], reverse=True)\\n print(\\\"Words in vocabulary:\\\", len(word_counts))\\n\\n # Write out the word counts file.\\n with tf.gfile.FastGFile(word_counts_output_file, \\\"w\\\") as f:\\n f.write(\\\"\\\\n\\\".join([\\\"%s %d\\\" % (w, c) for w, c in word_counts]))\\n print(\\\"Wrote vocabulary file:\\\", word_counts_output_file)\\n\\n # Create the vocabulary dictionary.\\n reverse_vocab = [x[0] for x in word_counts]\\n unk_id = len(reverse_vocab)\\n vocab_dict = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])\\n # vocab = Vocabulary(vocab_dict, unk_id)\\n\\n return vocab_dict, unk_id\",\n \"def wordcloud_maker(df, stopwords = None):\\n all_clean = \\\" \\\".join(review for review in df.clean)\\n wordcloud = WordCloud(stopwords = stopwords, background_color=\\\"white\\\").generate(all_clean)\\n plt.imshow(wordcloud, interpolation='bilinear')\\n plt.axis(\\\"off\\\")\\n plt.show()\",\n \"def _make_feature_vec(self, word_list):\\n\\n # Pre-initialize an empty numpy array (for speed)\\n feature_vec = np.zeros((self.num_features,), dtype=\\\"float32\\\")\\n\\n # index2word is a list that contains the names of the words in\\n # the model's vocabulary. Convert it to a set, for speed.\\n index2word_set = set(self.w2v_model.index2word)\\n\\n # Loop over each word in the word_list and, if it is in the model's\\n # vocabulary, add its feature vector to the total\\n nwords = 0\\n for word in word_list:\\n # NOTE: Careful there, if all words are in caps in the article,\\n # this function will return nan values and blow up the forest.\\n word = word.lower()\\n if word in index2word_set:\\n nwords += 1\\n feature_vec = np.add(feature_vec, self.w2v_model[word])\\n\\n # Divide the result by the number of words to get the average\\n feature_vec = np.divide(feature_vec, nwords)\\n return feature_vec\",\n \"def createDwords(self, start: ghidra.program.model.address.Address, count: int) -> None:\\n ...\",\n \"def make_cloud(\\n self,\\n image_path: str,\\n word_frequency: Dict[str, int],\\n font_path: str,\\n background_color: str = \\\"white\\\",\\n width: int = 800,\\n height: int = 600,\\n **kwargs,\\n ) -> WordCloud:\\n word_cloud = WordCloud(\\n font_path=font_path, background_color=background_color, width=width, height=height, **kwargs\\n )\\n word_cloud.generate_from_frequencies(word_frequency)\\n word_cloud.to_file(image_path)\\n print(f\\\"Saved image to {image_path}\\\")\\n\\n return word_cloud\",\n \"def build_model():\\n \\n pipeline = Pipeline([\\n ('vect', CountVectorizer(tokenizer=tokenize)),\\n ('tfidf', TfidfTransformer()),\\n ('clf', MultiOutputClassifier(RandomForestClassifier()))\\n ])\\n \\n parameters = {\\n 'vect__ngram_range': ((1, 1), (1, 2)),\\n 'clf__estimator__min_samples_split': [2, 4],\\n }\\n \\n cv = GridSearchCV(pipeline, param_grid=parameters)\\n\\n return cv\",\n \"def fd(self, sent, index, length):\\n context = lambda idx, field: sent[index + idx][field] \\\\\\n if index+idx >= 0 and index + idx < length \\\\\\n else \\\"<s>\\\" if index+idx < 0 \\\\\\n else \\\"</s>\\\"\\n\\n ## tokens in a 5 token window x_{i-2}..x_{i+2}\\n word_unigram_cur = numify(context(0, WORD))\\n word_unigram_pre = numify(context(-1, WORD))\\n word_unigram_2pre = numify(context(-2, WORD))\\n word_unigram_post = numify(context(1, WORD))\\n word_unigram_2post = numify(context(2, WORD))\\n\\n ## token bigrams in a 5 token window\\n word_bigram_pre_cur = \\\"/\\\".join([word_unigram_pre, word_unigram_cur])\\n word_bigram_cur_post = \\\"/\\\".join([word_unigram_cur, word_unigram_post])\\n\\n ## pos in a 5 token window\\n pos_cur = context(0, POS)\\n pos_pre = context(-1, POS)\\n pos_post = context(1, POS)\\n pos_2pre = context(-2, POS)\\n pos_2post = context(2, POS)\\n\\n ## pos bigrams in a 3 token window\\n pos_bigram_pre_cur = \\\"/\\\".join([pos_pre, pos_cur])\\n pos_bigram_cur_post = \\\"/\\\".join([pos_cur, pos_post])\\n #pre_pre_pos_bigram = \\\"/\\\".join([pre_pre_pos, pre_pos])\\n #post_post_pos_bigram = \\\"/\\\".join([post_pos, post_post_pos])\\n\\n pos_posw_cur = \\\"/\\\".join([word_unigram_cur, pos_cur])\\n\\n ## Word shape features (5 token window)\\n shape_istitle_cur = word_unigram_cur.istitle()\\n shape_isdigit_cur = context(0, WORD).isdigit()\\n shape_isupper_cur = word_unigram_cur.isupper()\\n shape_hyphen_cur = \\\"-\\\" in word_unigram_cur[1:-1]\\n shape_isalnum_cur = context(0, WORD).isalnum()\\n #shape_mixedcase_cur = self.mixedcase.match(context(0, WORD)) != None\\n\\n shape_istitle_pre = word_unigram_pre.istitle()\\n shape_isdigit_pre = context(-1, WORD).isdigit()\\n shape_isupper_pre = word_unigram_pre.isupper()\\n shape_hyphen_pre = \\\"-\\\" in word_unigram_pre[1:-1]\\n shape_isalnum_pre = context(-1, WORD).isalnum()\\n #shape_mixedcase_pre = self.mixedcase.match(context(-1, WORD)) != None\\n\\n shape_istitle_2pre = word_unigram_2pre.istitle()\\n shape_isdigit_2pre = context(-2, WORD).isdigit()\\n shape_isupper_2pre = word_unigram_2pre.isupper()\\n shape_hyphen_2pre = \\\"-\\\" in word_unigram_2pre[1:-1]\\n shape_isalnum_2pre = context(-2, WORD).isalnum()\\n #shape_mixedcase_2pre = self.mixedcase.match(context(-2, WORD)) != None\\n\\n shape_istitle_post = word_unigram_post.istitle()\\n shape_isdigit_post = context(1, WORD).isdigit()\\n shape_isupper_post = word_unigram_post.isupper()\\n shape_hypen_post = \\\"-\\\" in word_unigram_post[1:-1]\\n shape_isalnum_post = context(1, WORD).isalnum()\\n #shape_mixedcase_post = self.mixedcase.match(context(1, WORD)) != None\\n\\n shape_istitle_2post = word_unigram_2post.istitle()\\n shape_isdigit_2post = context(2, WORD).isdigit()\\n shape_isupper_2post = word_unigram_2post.isupper()\\n shape_hypen_2post = \\\"-\\\" in word_unigram_2post[1:-1]\\n shape_isalnum_2post = context(2, WORD).isalnum()\\n #shape_mixedcase_2post = self.mixedcase.match(context(2, WORD)) != None\\n\\n ## 2-4 suffixes in a 3 token window\\n suffix_1_cur = word_unigram_cur[-1:]\\n suffix_2_cur = word_unigram_cur[-2:]\\n suffix_3_cur = word_unigram_cur[-3:]\\n suffix_4_cur = word_unigram_cur[-4:]\\n\\n suffix_1_pre = word_unigram_pre[-1:]\\n suffix_2_pre = word_unigram_pre[-2:]\\n suffix_3_pre = word_unigram_pre[-3:]\\n suffix_4_pre = word_unigram_pre[-4:]\\n\\n suffix_1_post = word_unigram_post[-1:]\\n suffix_2_post = word_unigram_post[-2:]\\n suffix_3_post = word_unigram_post[-3:]\\n suffix_4_post = word_unigram_post[-4:]\\n\\n ## 3-4 prefixes in a 3 token window\\n prefix_3_cur = word_unigram_cur[:3]\\n prefix_4_cur = word_unigram_cur[:4]\\n\\n prefix_3_pre = word_unigram_pre[:3]\\n prefix_4_pre = word_unigram_pre[:4]\\n\\n prefix_3_post = word_unigram_post[:3]\\n prefix_4_post = word_unigram_post[:4]\\n\\n ## Noun phrase in a 3 token window\\n syn_np_cur = context(0, NP)\\n syn_npw_cur = \\\"/\\\".join([syn_np_cur, word_unigram_cur])\\n syn_np_pre = context(-1, NP)\\n syn_np_post = context(1, NP)\\n\\n ## Extract features from local scope\\n features = locals()\\n del features[\\\"context\\\"]\\n del features[\\\"sent\\\"]\\n del features[\\\"index\\\"]\\n del features[\\\"length\\\"]\\n del features[\\\"self\\\"]\\n features = features.items()\\n\\n features.extend(self.brown_extractor(\\\"brown_%d_cur\\\", context(0, WORD)))\\n features.extend(self.brown_extractor(\\\"brown_%d_pre\\\", context(-1, WORD)))\\n features.extend(self.brown_extractor(\\\"brown_%d_2pre\\\", context(-2, WORD)))\\n features.extend(self.brown_extractor(\\\"brown_%d_post\\\", context(1, WORD)))\\n features.extend(self.brown_extractor(\\\"brown_%d_2post\\\", context(2, WORD))) \\n\\n return features\",\n \"def generate_babble_text(self):\\n markov_chain_output = []\\n for n in range(self.number_of_sentences):\\n sentence_length = random.randint(self.min_sentence_length, self.max_sentence_length)\\n markov_chain_output.append(self.markov_chain.generate_sentence(sentence_length))\\n\\n random.shuffle(markov_chain_output)\\n\\n to_display = ''\\n for i in markov_chain_output:\\n to_display += i + '\\\\n'\\n\\n # Clears any old text in the display, then inserts the newly created text\\n self.display.delete('1.0', tk.END)\\n self.display.insert('1.0', to_display)\",\n \"def trainingModel4wmd(corpus):\\n model = Word2Vec(corpus, workers = nCores, size = 100, window = 300,\\n min_count = 2, iter = 250)\\n # model = Word2Vec(corpus)\\n\\n # use the following if we want to normalize the vectors\\n model.init_sims(replace=True)\\n\\n return model\",\n \"def definition(self, definition):\\n result = Words()\\n result.words = DefinitionHelper.words_for_definition(definition)\\n return result\",\n \"def build_data_cv(self, data_folder, cv=10, clean_string=True):\\n revs = []\\n pos_file = data_folder[0]\\n neg_file = data_folder[1]\\n vocab = defaultdict(float)\\n with open(pos_file, \\\"rb\\\") as f:\\n for line in f:\\n rev = []\\n rev.append(line.strip())\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n words = set(orig_rev.split())\\n for word in words:\\n vocab[word] += 1\\n datum = {\\\"y\\\":1,\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": np.random.randint(0,cv)}\\n revs.append(datum)\\n with open(neg_file, \\\"rb\\\") as f:\\n for line in f:\\n rev = []\\n rev.append(line.strip())\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n words = set(orig_rev.split())\\n for word in words:\\n vocab[word] += 1\\n datum = {\\\"y\\\":0,\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": np.random.randint(0,cv)}\\n revs.append(datum)\\n return revs, vocab\",\n \"def make_words(self,lm):\\n if \\\" \\\" in self.corpus[0] and \\\" \\\" in self.corpus[1]: \\n print \\\"assuming BLICK\\\"\\n self.corpus = [convert_to_disc(i) for i in self.corpus]\\n else:\\n self.disc = 1\\n print \\\"assuming Disc\\\" \\n if not os.path.isfile(self.f): ##check if it already exists\\n print \\\"generating 10 million words\\\"\\n outfile = open(self.f, \\\"w\\\")\\n outfile.write(\\\"word,blick,ngram,Real,T,disc\\\\n\\\")\\n for word in self.corpus:\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Real\\\", \\\"1\\\")\\n while len(self.wordlist)<10000000: \\n words = lm.generate(100)\\n for word in words:\\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Simulated\\\", \\\"0\\\")\\n self.wordlist[word] = 0\\n return\",\n \"def make_csd(shape, scale, npart, show_plot=False):\\r\\n if shape == 0:\\r\\n rads = [scale + 0 * x for x in range(npart)]\\r\\n else:\\r\\n rads = lognorm.rvs(shape, scale=scale, size=npart)\\r\\n with open('diameters.txt', 'w') as fout:\\r\\n for rad in rads:\\r\\n fout.write('{0}\\\\n'.format(rad))\\r\\n if shape == 0:\\r\\n xpos = linspace(scale / 2, scale * 2, 100)\\r\\n else:\\r\\n xpos = linspace(lognorm.ppf(0.01, shape, scale=scale),\\r\\n lognorm.ppf(0.99, shape, scale=scale), 100)\\r\\n plt.plot(xpos, lognorm.pdf(xpos, shape, scale=scale))\\r\\n plt.hist(rads, normed=True)\\r\\n plt.savefig('packing_histogram.png')\\r\\n plt.savefig('packing_histogram.pdf')\\r\\n if show_plot:\\r\\n plt.show()\",\n \"def construct_embedding(captions, cbow=True):\\n\\n # List of characters to filter out of the caption string\\n chars_to_remove = [\\\"\\\\n\\\", \\\">\\\", \\\"--\\\"]\\n\\n for char in chars_to_remove:\\n captions = captions.replace(char, \\\" \\\")\\n\\n # Perform some necessary tokenization\\n data = [word_tokenize(word.lower()) for word in sent_tokenize(captions)]\\n\\n # Filter out punctuation from the data\\n data_minus_punctuation = remove_punctuation(data)\\n\\n # Filter out stop words from the data\\n data_minus_stop_words = remove_stop_words(data_minus_punctuation)\\n\\n # Filter out any surviving single character list elements\\n fully_formatted_data = [\\n [word for word in item if len(word) > 1] for item in data_minus_stop_words\\n ]\\n\\n # Train the Word2Vec model using the specified architecture\\n if cbow:\\n print(\\\"UTILIZING CBOW ARCHITECTURE\\\")\\n model = Word2Vec(fully_formatted_data, min_count=1, size=100, window=5)\\n else:\\n print(\\\"UTILIZING SKIPGRAM ARCHITECTURE\\\")\\n model = Word2Vec(fully_formatted_data, min_count=1, size=100, window=5, sg=1)\\n\\n return model\",\n \"def test_topic_model_generator_dimensions( ):\\n N = 100\\n D = 1000\\n K = 10\\n W = 100\\n\\n tm = TopicModel.generate( K, D )\\n assert( tm.topics.shape == (D, K) )\\n assert( tm.weights.shape == (K,) )\\n\\n docs = tm.sample( N, words = W )\\n # Each document is a column\\n assert( docs.shape == (N, D) ) \\n # Each doc should have 100 words\\n assert( sc.all(docs.sum(1) == W) )\",\n \"def generate_corpus(model, sample):\\r\\n \\r\\n dl_corpus = []\\r\\n for word in sample:\\r\\n if word in model:\\r\\n dl_corpus.append(model[word])\\r\\n else:\\r\\n dl_corpus.append([0]*VECTOR_DIM)\\r\\n\\r\\n return [dl_corpus]\",\n \"def build_vocab(cleaned_captions):\\n # QUESTION 1.1\\n # Here we Build a vocabulary\\n\\n # create a vocab instance\\n vocab = Vocabulary()\\n\\n words = dict()\\n for caption in cleaned_captions: # iterate through all cleaned_caption\\n for word in caption.split(): # iterate over all words in a caption\\n # add the token words to vocabulary if and only if the count of word is more than MIN_FREQUENCY i.e. 3\\n if word not in words.keys():\\n words[word] = 1\\n else:\\n words[word] += 1\\n if words[word] > MIN_FREQUENCY:\\n vocab.add_word(word)\\n\\n vocab.add_word('<pad>')\\n vocab.add_word('<start>')\\n vocab.add_word('<end>')\\n vocab.add_word('<unk>')\\n\\n print(vocab.idx)\\n\\n return vocab\",\n \"def model(self, doc_list=None):\\r\\n\\r\\n # eta => prior for the per-topic word distribution\\r\\n eta = torch.ones(self.V)\\r\\n\\r\\n with pyro.plate(\\\"topics\\\", self.K):\\r\\n\\r\\n # Beta => per topic word distribution\\r\\n Beta = pyro.sample(f\\\"beta\\\", dist.Dirichlet(eta))\\r\\n\\r\\n # alpha => prior for the per-doc topic vector\\r\\n alpha = torch.ones(self.K) / self.K\\r\\n\\r\\n X_List, Theta = [], []\\r\\n for d in pyro.plate(\\\"documents\\\", self.D, subsample_size=self.S):\\r\\n\\r\\n # theta => per-doc topic vector\\r\\n theta = pyro.sample(f\\\"theta_{d}\\\", dist.Dirichlet(alpha))\\r\\n\\r\\n doc = None if doc_list is None else doc_list[d]\\r\\n\\r\\n with pyro.plate(f\\\"words_{d}\\\", self.N[d]):\\r\\n\\r\\n # assign a topic\\r\\n z_assignment = pyro.sample(\\r\\n f\\\"z_assignment_{d}\\\",\\r\\n dist.Categorical(theta)\\r\\n )\\r\\n\\r\\n # from that topic vec, select a word\\r\\n X = pyro.sample(\\r\\n f\\\"w_{d}\\\",\\r\\n dist.Categorical(Beta[z_assignment]),\\r\\n obs=doc\\r\\n )\\r\\n\\r\\n X_List.append(X)\\r\\n Theta.append(theta)\\r\\n\\r\\n Theta = torch.stack(Theta)\\r\\n\\r\\n return X_List, Beta, Theta\",\n \"def generate_wordcloud_from_probabilities_and_words(prob, words, return_image=True, wordcloud_instance=None,\\n **wordcloud_kwargs):\\n\\n if len(prob) != len(words):\\n raise ValueError('`prob` and `words` must have the name length')\\n if hasattr(prob, 'ndim') and prob.ndim != 1:\\n raise ValueError('`prob` must be a 1D array or sequence')\\n if hasattr(words, 'ndim') and words.ndim != 1:\\n raise ValueError('`words` must be a 1D array or sequence')\\n\\n weights = dict(zip(words, prob))\\n\\n return generate_wordcloud_from_weights(weights, return_image=return_image,\\n wordcloud_instance=wordcloud_instance, **wordcloud_kwargs)\",\n \"def generate(self, seed_text, next_words=20, T=0.9):\\n\\n index_to_word = {index: word for word, index in self.tokenizer.word_index.items()}\\n\\n for _ in range(next_words):\\n token_list = self.tokenizer.texts_to_sequences([seed_text])[0]\\n token_list = pad_sequences([token_list], maxlen=self.max_sequence_len, padding='pre')\\n\\n probas = self.model.predict(token_list, verbose=0)\\n probas = np.array(probas[0][1:])\\n probas = probas ** (1.0 / T)\\n probas /= np.sum(probas)\\n predicted = np.random.choice(range(1,self.total_words), p=probas)\\n \\n seed_text += \\\" \\\" + (index_to_word[predicted] if predicted != 0 else '')\\n\\n return seed_text\",\n \"def random_bbox(self, shape, margin, bbox_shape):\\r\\n img_height = shape\\r\\n img_width = shape\\r\\n height = bbox_shape\\r\\n width = bbox_shape\\r\\n ver_margin = margin\\r\\n hor_margin = margin\\r\\n maxt = img_height - ver_margin - height\\r\\n maxl = img_width - hor_margin - width\\r\\n t = np.random.randint(low = ver_margin, high = maxt)\\r\\n l = np.random.randint(low = hor_margin, high = maxl)\\r\\n h = height\\r\\n w = width\\r\\n return (t, l, h, w)\",\n \"def random_bbox(self, shape, margin, bbox_shape):\\r\\n img_height = shape\\r\\n img_width = shape\\r\\n height = bbox_shape\\r\\n width = bbox_shape\\r\\n ver_margin = margin\\r\\n hor_margin = margin\\r\\n maxt = img_height - ver_margin - height\\r\\n maxl = img_width - hor_margin - width\\r\\n t = np.random.randint(low = ver_margin, high = maxt)\\r\\n l = np.random.randint(low = hor_margin, high = maxl)\\r\\n h = height\\r\\n w = width\\r\\n return (t, l, h, w)\",\n \"def create_vocabs(self):\\r\\n print('Creating vocabs...')\\r\\n\\r\\n # Update surface_char2id\\r\\n unique_surfaces = set(chain(*[sentence.surface_words for sentence in self.sentences]))\\r\\n unique_chars = set(chain(*[surface for surface in unique_surfaces]))\\r\\n for ch in unique_chars:\\r\\n self.surface_char2id[ch] = len(self.surface_char2id)\\r\\n\\r\\n # Update lemma_char2id\\r\\n unique_lemmas = set(chain(*[sentence.lemmas for sentence in self.sentences]))\\r\\n unique_chars = set(chain(*[lemma for lemma in unique_lemmas]))\\r\\n for ch in unique_chars:\\r\\n self.lemma_char2id[ch] = len(self.lemma_char2id)\\r\\n\\r\\n # Update transformation2id\\r\\n for sentence in self.sentences:\\r\\n for transformation in sentence.transformations:\\r\\n for _t in transformation:\\r\\n if _t not in self.transformation2id:\\r\\n self.transformation2id[_t] = len(self.transformation2id)\\r\\n\\r\\n # Update morph_tag2id\\r\\n unique_morph_tags = list(chain(*[sentence.morph_tags for sentence in self.sentences]))\\r\\n unique_tags = set(chain(*[morph_tag for morph_tag in unique_morph_tags]))\\r\\n for tag in unique_tags:\\r\\n self.morph_tag2id[tag] = len(self.morph_tag2id)\\r\\n print('Surface Chars={}, Lemma Chars={}, Transformations={}, tags={}'.format(\\r\\n len(self.surface_char2id), len(self.lemma_char2id), len(self.transformation2id), len(self.morph_tag2id)\\r\\n ))\",\n \"def build_geometry(self, depth=None, maxcount=20000):\\n self.G.init()\\n self.word_generator = partial(self.G.traverse, depth=depth, maxcount=maxcount)\\n self.get_vertices()\\n self.get_edges()\\n self.get_faces()\\n return self\",\n \"def build_train_data(self,data_folder, cv=10, clean_string=False):\\n revs = []\\n\\n vocab = defaultdict(float)\\n print data_folder\\n with codecs.open( data_folder, 'rb') as fi:\\n for line in fi.readlines():\\n line = line.decode('utf-8')\\n parts = line.split(\\\"\\\\n\\\")[0].split(\\\"\\\\t\\\")\\n if len(parts) > 1:\\n sent = parts[1]\\n rev = []\\n rev.append(sent.strip())\\n\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n #print orig_rev\\n words = set(orig_rev.split())\\n for word in words:\\n vocab[word.lower()] += 1\\n if len(orig_rev.split()) < 50 :\\n\\n datum = {\\\"y\\\":int(parts[0]),\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n \\\"split\\\": np.random.randint(0,cv)}\\n revs.append(datum)\\n # else:\\n # print orig_rev\\n\\n\\n return revs, vocab\",\n \"def create_vocabulary(vocabulary_path, words, max_vocabulary_size, normalize_digits=True):\\n if not gfile.Exists(vocabulary_path):\\n print(\\\"Creating vocabulary %s with max size %d\\\" % (vocabulary_path, max_vocabulary_size))\\n vocab = {}\\n counter = 0\\n for w in words:\\n counter += 1\\n if counter % 10000 == 0:\\n print(\\\" processing word %d = %s\\\" % (counter, w))\\n word = re.sub(_DIGIT_RE, \\\"0\\\", w) if normalize_digits else w\\n if word in vocab:\\n vocab[word] += 1\\n else:\\n vocab[word] = 1\\n vocab_list = _START_VOCAB + sorted(vocab, key=vocab.get, reverse=True)\\n if len(vocab_list) > max_vocabulary_size:\\n vocab_list = vocab_list[:max_vocabulary_size]\\n with gfile.GFile(vocabulary_path, mode=\\\"w\\\") as vocab_file:\\n for w in vocab_list:\\n vocab_file.write(w + \\\"\\\\n\\\")\",\n \"def generate_new_word(model: Dict[str, Set[str]]) -> str:\\n all_keys = list(dict.keys(model))\\n return random.choice(all_keys)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61004114","0.5693294","0.55114466","0.5438077","0.53612614","0.5311946","0.52376354","0.51894677","0.5161035","0.5152379","0.5143327","0.5127287","0.51046485","0.50831926","0.50809175","0.5080614","0.5072338","0.5021304","0.50183684","0.4984602","0.4969572","0.49440196","0.49193308","0.4914714","0.49089342","0.48999873","0.48745552","0.4864325","0.48638293","0.48628196","0.4858256","0.48582435","0.48566815","0.48537022","0.48470083","0.4842336","0.48402998","0.48179993","0.48127428","0.47894543","0.47893265","0.47797585","0.47764012","0.47720045","0.4766227","0.47613114","0.47586912","0.47573754","0.47396976","0.472817","0.47280297","0.4728022","0.47201937","0.47177866","0.47123986","0.47071484","0.4698746","0.46918735","0.46873325","0.4686019","0.46832922","0.46824035","0.4681813","0.4680935","0.4674394","0.46738964","0.4671416","0.46671373","0.4660146","0.4658207","0.46517506","0.46463352","0.46456817","0.46431527","0.46391335","0.46357048","0.46354827","0.4632805","0.46302158","0.46293816","0.46283782","0.46273026","0.46172655","0.46105552","0.46042913","0.46026146","0.46016905","0.45895168","0.458653","0.45864525","0.458507","0.4579809","0.45790774","0.45758802","0.45758802","0.45736805","0.45717034","0.45672423","0.45604864","0.455573"],"string":"[\n \"0.61004114\",\n \"0.5693294\",\n \"0.55114466\",\n \"0.5438077\",\n \"0.53612614\",\n \"0.5311946\",\n \"0.52376354\",\n \"0.51894677\",\n \"0.5161035\",\n \"0.5152379\",\n \"0.5143327\",\n \"0.5127287\",\n \"0.51046485\",\n \"0.50831926\",\n \"0.50809175\",\n \"0.5080614\",\n \"0.5072338\",\n \"0.5021304\",\n \"0.50183684\",\n \"0.4984602\",\n \"0.4969572\",\n \"0.49440196\",\n \"0.49193308\",\n \"0.4914714\",\n \"0.49089342\",\n \"0.48999873\",\n \"0.48745552\",\n \"0.4864325\",\n \"0.48638293\",\n \"0.48628196\",\n \"0.4858256\",\n \"0.48582435\",\n \"0.48566815\",\n \"0.48537022\",\n \"0.48470083\",\n \"0.4842336\",\n \"0.48402998\",\n \"0.48179993\",\n \"0.48127428\",\n \"0.47894543\",\n \"0.47893265\",\n \"0.47797585\",\n \"0.47764012\",\n \"0.47720045\",\n \"0.4766227\",\n \"0.47613114\",\n \"0.47586912\",\n \"0.47573754\",\n \"0.47396976\",\n \"0.472817\",\n \"0.47280297\",\n \"0.4728022\",\n \"0.47201937\",\n \"0.47177866\",\n \"0.47123986\",\n \"0.47071484\",\n \"0.4698746\",\n \"0.46918735\",\n \"0.46873325\",\n \"0.4686019\",\n \"0.46832922\",\n \"0.46824035\",\n \"0.4681813\",\n \"0.4680935\",\n \"0.4674394\",\n \"0.46738964\",\n \"0.4671416\",\n \"0.46671373\",\n \"0.4660146\",\n \"0.4658207\",\n \"0.46517506\",\n \"0.46463352\",\n \"0.46456817\",\n \"0.46431527\",\n \"0.46391335\",\n \"0.46357048\",\n \"0.46354827\",\n \"0.4632805\",\n \"0.46302158\",\n \"0.46293816\",\n \"0.46283782\",\n \"0.46273026\",\n \"0.46172655\",\n \"0.46105552\",\n \"0.46042913\",\n \"0.46026146\",\n \"0.46016905\",\n \"0.45895168\",\n \"0.458653\",\n \"0.45864525\",\n \"0.458507\",\n \"0.4579809\",\n \"0.45790774\",\n \"0.45758802\",\n \"0.45758802\",\n \"0.45736805\",\n \"0.45717034\",\n \"0.45672423\",\n \"0.45604864\",\n \"0.455573\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72299457"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3399,"cells":{"query":{"kind":"string","value":"Add the suffix vowel."},"document":{"kind":"string","value":"def add_suffix(self, suffix):\n # Append the suffix vowel to this WordForm.\n self.segments.append(Segment.new_segment(suffix))"},"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_suffix(word, suffix):\n suffix, sep, rest = suffix.partition(' ')\n expanded = _add_suffix(word, suffix)\n return expanded + sep + rest","def get_vowel_names():","def _replace_suffix(self, word, suffix, replacement):\n assert word.endswith(suffix), \"Given word doesn't end with given suffix\"\n if suffix == \"\":\n return word + replacement\n else:\n return word[: -len(suffix)] + replacement","def translate(self):\n\t\tvowels = \"aeiou\"\n\n\t\tif (self.word[0] not in vowels) and (self.word[1] in vowels):\n\t\t\tnew_word = self.word[1:] + self.word[0] + \"ay\"\n\t\telif self.word[0] in vowels:\n\t\t\tnew_word = self.word + \"way\"\n\t\telse:\n\t\t\tnew_word = self.word[2:] + self.word[:2] + \"ay\"\n\n\t\tprint(new_word)","def pig_word(self, original):\n word = original.lower()\n if word[0] in \"aeiou\":\n new_word = word + 'ay'\n else:\n new_word = word[1:] + word[0] + 'ay'\n return new_word","def stem(self, word):\n word = word.lower()\n\n if word in self.stopwords:\n return word\n\n step1_success = False\n\n r1, r2 = self._r1r2_standard(word, self.__vowels)\n rv = self._rv_standard(word, self.__vowels)\n\n # STEP 0: Attached pronoun\n for suffix in self.__step0_suffixes:\n if not (word.endswith(suffix) and rv.endswith(suffix)):\n continue\n\n if (\n rv[: -len(suffix)].endswith(\n (\n \"ando\",\n \"ar\",\n \"er\",\n \"iendo\",\n \"ir\",\n )\n )\n ) or (\n rv[: -len(suffix)].endswith(\"yendo\")\n and word[: -len(suffix)].endswith(\"uyendo\")\n ):\n\n word = self.__replace_accented(word[: -len(suffix)])\n r1 = self.__replace_accented(r1[: -len(suffix)])\n r2 = self.__replace_accented(r2[: -len(suffix)])\n rv = self.__replace_accented(rv[: -len(suffix)])\n break\n\n # STEP 1: Standard suffix removal\n for suffix in self.__step1_suffixes:\n if not word.endswith(suffix):\n continue\n\n if suffix == \"amente\" and r1.endswith(suffix):\n step1_success = True\n word = word[:-6]\n r2 = r2[:-6]\n rv = rv[:-6]\n\n if r2.endswith(\"iv\"):\n word = word[:-2]\n r2 = r2[:-2]\n rv = rv[:-2]\n\n if r2.endswith(\"at\"):\n word = word[:-2]\n rv = rv[:-2]\n\n elif r2.endswith((\"os\", \"ic\", \"ad\")):\n word = word[:-2]\n rv = rv[:-2]\n\n elif r2.endswith(suffix):\n step1_success = True\n if suffix in (\n \"adora\",\n \"ador\",\n \"acion\",\n \"adoras\",\n \"adores\",\n \"aciones\",\n \"ante\",\n \"antes\",\n \"ancia\",\n \"ancias\",\n ):\n word = word[: -len(suffix)]\n r2 = r2[: -len(suffix)]\n rv = rv[: -len(suffix)]\n\n if r2.endswith(\"ic\"):\n word = word[:-2]\n rv = rv[:-2]\n\n elif suffix in (\"logia\", \"logias\"):\n word = suffix_replace(word, suffix, \"log\")\n rv = suffix_replace(rv, suffix, \"log\")\n\n elif suffix in (\"ucion\", \"uciones\"):\n word = suffix_replace(word, suffix, \"u\")\n rv = suffix_replace(rv, suffix, \"u\")\n\n elif suffix in (\"encia\", \"encias\"):\n word = suffix_replace(word, suffix, \"ente\")\n rv = suffix_replace(rv, suffix, \"ente\")\n\n elif suffix == \"mente\":\n word = word[: -len(suffix)]\n r2 = r2[: -len(suffix)]\n rv = rv[: -len(suffix)]\n\n if r2.endswith((\"ante\", \"able\", \"ible\")):\n word = word[:-4]\n rv = rv[:-4]\n\n elif suffix in (\"idad\", \"idades\"):\n word = word[: -len(suffix)]\n r2 = r2[: -len(suffix)]\n rv = rv[: -len(suffix)]\n\n for pre_suff in (\"abil\", \"ic\", \"iv\"):\n if r2.endswith(pre_suff):\n word = word[: -len(pre_suff)]\n rv = rv[: -len(pre_suff)]\n\n elif suffix in (\"ivo\", \"iva\", \"ivos\", \"ivas\"):\n word = word[: -len(suffix)]\n r2 = r2[: -len(suffix)]\n rv = rv[: -len(suffix)]\n if r2.endswith(\"at\"):\n word = word[:-2]\n rv = rv[:-2]\n else:\n word = word[: -len(suffix)]\n rv = rv[: -len(suffix)]\n break\n\n # STEP 2a: Verb suffixes beginning 'y'\n if not step1_success:\n for suffix in self.__step2a_suffixes:\n if rv.endswith(suffix) and word[-len(suffix) - 1 : -len(suffix)] == \"u\":\n word = word[: -len(suffix)]\n rv = rv[: -len(suffix)]\n break\n\n # STEP 2b: Other verb suffixes\n for suffix in self.__step2b_suffixes:\n if rv.endswith(suffix):\n word = word[: -len(suffix)]\n rv = rv[: -len(suffix)]\n if suffix in (\"en\", \"es\", \"eis\", \"emos\"):\n if word.endswith(\"gu\"):\n word = word[:-1]\n\n if rv.endswith(\"gu\"):\n rv = rv[:-1]\n break\n\n # STEP 3: Residual suffix\n for suffix in self.__step3_suffixes:\n if rv.endswith(suffix):\n word = word[: -len(suffix)]\n if suffix in (\"e\", \"\\xE9\"):\n rv = rv[: -len(suffix)]\n\n if word[-2:] == \"gu\" and rv.endswith(\"u\"):\n word = word[:-1]\n break\n\n word = self.__replace_accented(word)\n\n return word","def create_extended_name(y: str, p: str) -> str:\n final_letter = y[-1]\n if final_letter == \"e\":\n extended_name = y + \"x\" + p\n elif final_letter in [\"a\", \"i\", \"o\", \"u\"]:\n extended_name = y[:-1] + \"ex\" + p\n elif final_letter == \"x\":\n if y[-2] == \"e\":\n extended_name = y + p\n else:\n extended_name = y + \"ex\" + p\n return extended_name","def _ends_with_vowel(self, letter_group: str) -> bool:\n if len(letter_group) == 0:\n return False\n return self._contains_vowels(letter_group[-1])","def find_vowels(s):\n \"*** YOUR CODE HERE ***\"","def add_suffix(name: str, suffix: str):\n return f'{name}_{suffix}'","def addSuffixes(self, alist):\n for i, (word, filename) in enumerate(alist):\n withsuffix = self._findVideoFile(filename)\n alist[i] = (word, withsuffix)\n return alist","def upper_vowel(s):\n for k, v in REPLACED_MAP.iteritems():\n s = s.replace(k, v)\n return s","def last_char_to_vowel(word):\n assert isinstance(word, str)\n # We iterate over characters of the word, because the last might be a\n # punctuation, perhaps.\n for last in reversed(word):\n last = last.lower()\n for ch, prev in ((\"a\", \"a/+£\"),\n (\"e\", \"eébcçdgptvwz&*:.\"),\n (\"o\", \"ohk€å\"),\n (\"ä\", \"äflmnrsx§\"),\n (\"ö\", \"ö\"),\n (\"i\", \"ij%$\"),\n (\"u\", \"uq,\"),\n (\"y\", \"yü\")):\n if last in prev:\n return ch\n return \"e\"","def suffix():\r\n\r\n return _random.choice(\r\n [\r\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\r\n ]\r\n )","def reverse_vowels(s):\n\n phrase = \"\"\n vowels = []\n for letter in s:\n if letter.lower() in \"aeiou\":\n phrase += \"~\"\n vowels.append(letter)\n else: \n phrase += letter\n \n index = 0\n new_phrase = \"\"\n vowels = vowels[-1:-len(vowels)-1:-1]\n \n for letter in phrase:\n\n if letter == \"~\":\n new_phrase += vowels[index]\n index += 1\n else:\n new_phrase += letter\n\n return new_phrase","def find_vowel(text: str) -> str:\r\n\r\n vowel = text.count('a') + text.count('o') + text.count('u') +\\\r\n text.count('i') + text.count('e') + text.count(\"y\") +\\\r\n text.count('A') + text.count('O') + text.count('U') +\\\r\n text.count('I') + text.count('E') + text.count('Y')\r\n\r\n return(vowel)","def _suffix(self) -> str:\n return \"\"","def suffix_replace(original, old, new):\n ...","def add_suffix(in_image,\n suffix_str):\n bandnames = in_image.bandNames().map(lambda elem: ee.String(elem).toLowerCase().cat('_').cat(suffix_str))\n nb = bandnames.length()\n return in_image.select(ee.List.sequence(0, ee.Number(nb).subtract(1)), bandnames)","def FindSuffix(self):\n self.numSuffixes = 0\n self.forceStress = 0\n resultslist = []\n for f in self.suffixes.finditer(self.wd):\n resultslist.append((f.group(), f.start()))\n if not resultslist: return\n # make sure *end* of word is in list! otherwise, 'DESP erate'\n if resultslist[-1][1] + len(resultslist[-1][0]) < len(self.wd):\n return\n resultslist.reverse()\n for res in resultslist:\n # if no vowel left before, false suffix ('singing')\n # n.b.: will choke on 'quest' etc! put in dictionary, I guess\n if not sre.search('[aeiouy]', self.wd[:res[1]]): break\n if res[0] == 'ing' and self.wd[res[1]-1] == self.wd[res[1]-2]:\n self.sylBounds.append(res[1] - 1) # freq special case\n else: self.sylBounds.append(res[1]) # sorted later\n self.wd = self.wd[:res[1]]\n self.numSuffixes += 1\n if res[0] in STRESSSUFFIX:\n self.forceStress = 0 - len(self.sylBounds)\n if res[0] in MULTISUFFIX:\n # tricky bit! it *happens* that secondary division in all these\n # comes after its first character; NOT inevitable!\n # also does not allow for 3-syl: 'ically' (which are reliable!)\n self.sylBounds.append(res[1]+1)\n self.numSuffixes += 1","def generate_vowel():\n return random.sample(['a', 'e', 'i', 'o', 'u', 'y'], 1)","def gerundify(verb):\n if verb.endswith(\"e\"):\n verb = verb[:-1]\n\n if random() < 0.4:\n if (\n not verb.startswith(\"a\")\n and not verb.startswith(\"e\")\n and not verb.startswith(\"i\")\n and not verb.startswith(\"o\")\n and not verb.startswith(\"u\")\n ):\n verb = \"a-\" + verb\n\n return verb + \"ing\"","def apply_sinalefa(self):\n syllables_sinalefa = []\n index = 0\n while index < len(self.word_syllables):\n try:\n # checking if there is sinalefa\n if self.are_vowels(syllables_sinalefa[-1][-1], self.word_syllables[index][0]):\n merged_syllables = ''.join([syllables_sinalefa[-1], self.word_syllables[index]])\n # replacing the last syllable with the merged syllable\n syllables_sinalefa.pop(-1)\n syllables_sinalefa.append(merged_syllables)\n else:\n syllables_sinalefa.append(self.word_syllables[index])\n except IndexError:\n # we reached the last word\n syllables_sinalefa.append(self.word_syllables[index])\n finally:\n index += 1\n\n return '-'.join(syllables_sinalefa)","def is_suffix(v,s):\n c = len(v)-1\n n = len(s)\n return c + v[c] == 2*n","def removesuffix(self, x) -> String:\n pass","def vowel_with_for(character):\r\n\tif character in vowels:\r\n\t\tprint(\"Entered character is vowel..!\")\r\n\telse:\r\n\t\tprint(\"Not a Vowel\")","def step1c(self, word):\r\n\r\n if word.endswith('y'):\r\n result = word.rfind('y')\r\n base = word[:result]\r\n if self.containsVowel(base):\r\n word = base\r\n word += 'i'\r\n return word","def is_suffix(suffix: str, word: str):\n return word.endswith(suffix)","def stem(self, word):\n word = word.lower()\n\n if word in self.__special_words:\n return self.__special_words[word]\n\n # Map the different apostrophe characters to a single consistent one\n word = (word.replace(u(\"\\u2019\"), u(\"\\x27\"))\n .replace(u(\"\\u2018\"), u(\"\\x27\"))\n .replace(u(\"\\u201B\"), u(\"\\x27\")))\n\n if word.startswith(u(\"\\x27\")):\n word = word[1:]\n\n if word.startswith(\"y\"):\n word = \"\".join((\"Y\", word[1:]))\n\n for i in range(1, len(word)):\n if word[i - 1] in self.__vowels and word[i] == \"y\":\n word = \"\".join((word[:i], \"Y\", word[i + 1:]))\n\n step1a_vowel_found = False\n step1b_vowel_found = False\n\n r1 = \"\"\n r2 = \"\"\n\n if word.startswith((\"gener\", \"commun\", \"arsen\")):\n if word.startswith((\"gener\", \"arsen\")):\n r1 = word[5:]\n else:\n r1 = word[6:]\n\n for i in range(1, len(r1)):\n if r1[i] not in self.__vowels and r1[i - 1] in self.__vowels:\n r2 = r1[i + 1:]\n break\n else:\n r1, r2 = self._r1r2_standard(word, self.__vowels)\n\n # STEP 0\n for suffix in self.__step0_suffixes:\n if word.endswith(suffix):\n word = word[:-len(suffix)]\n r1 = r1[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n break\n\n # STEP 1a\n for suffix in self.__step1a_suffixes:\n if word.endswith(suffix):\n\n if suffix == \"sses\":\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n\n elif suffix in (\"ied\", \"ies\"):\n if len(word[:-len(suffix)]) > 1:\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n else:\n word = word[:-1]\n r1 = r1[:-1]\n r2 = r2[:-1]\n\n elif suffix == \"s\":\n for letter in word[:-2]:\n if letter in self.__vowels:\n step1a_vowel_found = True\n break\n\n if step1a_vowel_found:\n word = word[:-1]\n r1 = r1[:-1]\n r2 = r2[:-1]\n break\n\n # STEP 1b\n for suffix in self.__step1b_suffixes:\n if word.endswith(suffix):\n if suffix in (\"eed\", \"eedly\"):\n\n if r1.endswith(suffix):\n word = \"\".join((word[:-len(suffix)], \"ee\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ee\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ee\"))\n else:\n r2 = \"\"\n else:\n for letter in word[:-len(suffix)]:\n if letter in self.__vowels:\n step1b_vowel_found = True\n break\n\n if step1b_vowel_found:\n word = word[:-len(suffix)]\n r1 = r1[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n\n if word.endswith((\"at\", \"bl\", \"iz\")):\n word = \"\".join((word, \"e\"))\n r1 = \"\".join((r1, \"e\"))\n\n if len(word) > 5 or len(r1) >= 3:\n r2 = \"\".join((r2, \"e\"))\n\n elif word.endswith(self.__double_consonants):\n word = word[:-1]\n r1 = r1[:-1]\n r2 = r2[:-1]\n\n elif ((r1 == \"\" and len(word) >= 3 and\n word[-1] not in self.__vowels and\n word[-1] not in \"wxY\" and\n word[-2] in self.__vowels and\n word[-3] not in self.__vowels)\n or\n (r1 == \"\" and len(word) == 2 and\n word[0] in self.__vowels and\n word[1] not in self.__vowels)):\n\n word = \"\".join((word, \"e\"))\n\n if len(r1) > 0:\n r1 = \"\".join((r1, \"e\"))\n\n if len(r2) > 0:\n r2 = \"\".join((r2, \"e\"))\n break\n\n # STEP 1c\n if (len(word) > 2\n and word[-1] in \"yY\"\n and word[-2] not in self.__vowels):\n word = \"\".join((word[:-1], \"i\"))\n if len(r1) >= 1:\n r1 = \"\".join((r1[:-1], \"i\"))\n else:\n r1 = \"\"\n\n if len(r2) >= 1:\n r2 = \"\".join((r2[:-1], \"i\"))\n else:\n r2 = \"\"\n\n # STEP 2\n for suffix in self.__step2_suffixes:\n if word.endswith(suffix):\n if r1.endswith(suffix):\n if suffix == \"tional\":\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n\n elif suffix in (\"enci\", \"anci\", \"abli\"):\n word = \"\".join((word[:-1], \"e\"))\n\n if len(r1) >= 1:\n r1 = \"\".join((r1[:-1], \"e\"))\n else:\n r1 = \"\"\n\n if len(r2) >= 1:\n r2 = \"\".join((r2[:-1], \"e\"))\n else:\n r2 = \"\"\n\n elif suffix == \"entli\":\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n\n elif suffix in (\"izer\", \"ization\"):\n word = \"\".join((word[:-len(suffix)], \"ize\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ize\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ize\"))\n else:\n r2 = \"\"\n\n elif suffix in (\"ational\", \"ation\", \"ator\"):\n word = \"\".join((word[:-len(suffix)], \"ate\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ate\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ate\"))\n else:\n r2 = \"e\"\n\n elif suffix in (\"alism\", \"aliti\", \"alli\"):\n word = \"\".join((word[:-len(suffix)], \"al\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"al\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"al\"))\n else:\n r2 = \"\"\n\n elif suffix == \"fulness\":\n word = word[:-4]\n r1 = r1[:-4]\n r2 = r2[:-4]\n\n elif suffix in (\"ousli\", \"ousness\"):\n word = \"\".join((word[:-len(suffix)], \"ous\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ous\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ous\"))\n else:\n r2 = \"\"\n\n elif suffix in (\"iveness\", \"iviti\"):\n word = \"\".join((word[:-len(suffix)], \"ive\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ive\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ive\"))\n else:\n r2 = \"e\"\n\n elif suffix in (\"biliti\", \"bli\"):\n word = \"\".join((word[:-len(suffix)], \"ble\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ble\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ble\"))\n else:\n r2 = \"\"\n\n elif suffix == \"ogi\" and word[-4] == \"l\":\n word = word[:-1]\n r1 = r1[:-1]\n r2 = r2[:-1]\n\n elif suffix in (\"fulli\", \"lessli\"):\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n\n elif suffix == \"li\" and word[-3] in self.__li_ending:\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n break\n\n # STEP 3\n for suffix in self.__step3_suffixes:\n if word.endswith(suffix):\n if r1.endswith(suffix):\n if suffix == \"tional\":\n word = word[:-2]\n r1 = r1[:-2]\n r2 = r2[:-2]\n\n elif suffix == \"ational\":\n word = \"\".join((word[:-len(suffix)], \"ate\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ate\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ate\"))\n else:\n r2 = \"\"\n\n elif suffix == \"alize\":\n word = word[:-3]\n r1 = r1[:-3]\n r2 = r2[:-3]\n\n elif suffix in (\"icate\", \"iciti\", \"ical\"):\n word = \"\".join((word[:-len(suffix)], \"ic\"))\n\n if len(r1) >= len(suffix):\n r1 = \"\".join((r1[:-len(suffix)], \"ic\"))\n else:\n r1 = \"\"\n\n if len(r2) >= len(suffix):\n r2 = \"\".join((r2[:-len(suffix)], \"ic\"))\n else:\n r2 = \"\"\n\n elif suffix in (\"ful\", \"ness\"):\n word = word[:-len(suffix)]\n r1 = r1[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n\n elif suffix == \"ative\" and r2.endswith(suffix):\n word = word[:-5]\n r1 = r1[:-5]\n r2 = r2[:-5]\n break\n\n # STEP 4\n for suffix in self.__step4_suffixes:\n if word.endswith(suffix):\n if r2.endswith(suffix):\n if suffix == \"ion\":\n if word[-4] in \"st\":\n word = word[:-3]\n r1 = r1[:-3]\n r2 = r2[:-3]\n else:\n word = word[:-len(suffix)]\n r1 = r1[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n break\n\n # STEP 5\n if r2.endswith(\"l\") and word[-2] == \"l\":\n word = word[:-1]\n elif r2.endswith(\"e\"):\n word = word[:-1]\n elif r1.endswith(\"e\"):\n if len(word) >= 4 and (word[-2] in self.__vowels or\n word[-2] in \"wxY\" or\n word[-3] not in self.__vowels or\n word[-4] in self.__vowels):\n word = word[:-1]\n\n word = word.replace(\"Y\", \"y\")\n return word","def is_vowel(self, letter):\n\n if letter in (\"a\", \"e\", \"i\", \"o\", \"u\", \"A\", \"E\", \"I\", \"O\", \"U\"):\n return True\n return False","def replace_vowels(word):\n variants = []\n for c in word:\n if c in vowels:\n for vowel in vowels:\n variants.append(word.replace(c, vowel))\n return variants","def form_ing(word):\n\n # last char of the word\n last = word[-1]\n\n if last == 'e':\n return word[:-1] + 'ing'\n elif last == 'r':\n if word[-2] == 'a': \n return word + \"ring\"\n elif last in ['b', 'd', 'g', 'm', 'n', 'p', 't']:\n if _is_vowel(word[-2]) and not (_is_vowel(word[-3])):\n return word + word[-1] + \"ing\"\n\n return word + \"ing\"","def test_add_filename_suffix(self):\r\n self.assertEqual(add_filename_suffix('/foo/bar/baz.txt', 'z'),\r\n 'bazz.txt')\r\n self.assertEqual(add_filename_suffix('baz.txt', 'z'),\r\n 'bazz.txt')\r\n self.assertEqual(add_filename_suffix('/foo/bar/baz', 'z'),\r\n 'bazz')\r\n self.assertEqual(add_filename_suffix('baz', 'z'),\r\n 'bazz')\r\n self.assertEqual(add_filename_suffix('/baz.fasta.txt', 'z'),\r\n 'baz.fastaz.txt')\r\n self.assertEqual(add_filename_suffix('baz.fasta.txt', 'z'),\r\n 'baz.fastaz.txt')\r\n self.assertEqual(add_filename_suffix('/foo/', 'z'), 'z')","def __add_filename_suffix(filename, suffix):\n return \"{}{}.pdf\".format(filename.split(\".pdf\", 1)[0], suffix)","def suffix(self, e, remaining, rate):\n return f' {e + 1}/{self.max} [{remaining} remaining, {round(rate, 2)} iter/s]'","def remove_vowels(phrase):\n vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']\n cons_word = \"\".join([char for char in phrase if char not in vowels])\n return cons_word","def suffix(rem):\n if rem == 0:\n suf = ''\n else:\n if rem <= 600: #Class A suffix -- only letters.\n rem = rem - 1\n suf = base34[rem // 25]\n if rem % 25 > 0:\n suf = suf + base34[rem % 25 - 1]# second class A letter, if present.\n else: #rems > 600 : First digit of suffix is a number. Second digit may be blank, letter, or number.\n rem = rem - 601\n suf = base10[rem // 35]\n if rem % 35 > 0:\n suf = suf + base34[rem % 35 - 1]\n return suf","def _iendswith(string, suffix):\n return string.lower().endswith(suffix)","def add_possessive(results, form, poss):\n if not poss:\n return results\n\n # Add possessive suffix\n suffixes = nounspecs.possessive_suffixes[poss]\n if isinstance(suffixes, str):\n suffixes = [suffixes]\n results2 = []\n for suffix in suffixes:\n for v in results:\n parts = list(x for x in v)\n if suffix[0] != \"@\":\n for x in suffix:\n if x == \"A\":\n p = \"\".join(parts)\n m = re.search(\"([aouAOU])[^yäöYÄÖ]*$\", p)\n if m:\n parts.append(\"a\")\n else:\n parts.append(\"ä\")\n else:\n parts.append(x)\n v = \"\".join(parts)\n else:\n if form not in (\n \"ine-sg\", \"ine-pl\", \"ela-sg\", \"ela-pl\",\n \"all-sg\", \"all-pl\", \"ade-sg\", \"ade-pl\",\n \"abl-sg\", \"abl-pl\", \"tra-sg\", \"tra-pl\",\n \"ess-sg\", \"ess-pl\", \"abe-sg\", \"abe-pl\",\n \"ptv-sg\", \"ptv-pl\", \"cmt\",\n \"inf1-long\", \"inf2\", \"inf3\", \"inf4\", \"inf5\"):\n continue\n if len(v) < 2 or v[-1] not in \"aeiouyäö\":\n continue\n if v[-2] == v[-1]:\n continue\n v += v[-1]\n v += suffix[1:]\n if v:\n results2.append(v)\n return results2","def add_suffix_to_filename(filename, suffix):\n name, ext = os.path.splitext(filename)\n return ''.join([name, suffix, ext])","def add_edge(self, u, v, weight, pre_start, pre_end, suff_start, suff_end):\n \n self.add_node(u)\n self.add_node(v)\n \n if u not in self.prefix[v] and v not in self.suffix[u]:\n self.edges = self.edges + 1\n \n if u not in self.prefix[v]:\n self.prefix[v][u] = [weight, pre_start, pre_end]\n \n if v not in self.suffix[u]:\n self.suffix[u][v] = [weight, suff_start, suff_end]","def replace_suffix (name, new_suffix):\n assert isinstance(name, basestring)\n assert isinstance(new_suffix, basestring)\n split = os.path.splitext (name)\n return split [0] + new_suffix","def add_extra_words():\n\n with open(ES_STOPWORDS_FILE, \"r\", encoding=\"utf-8\") as temp_file:\n for word in temp_file.read().splitlines():\n STOP_WORDS.add(word)\n\n with open(EN_STOPWORDS_FILE, \"r\", encoding=\"utf-8\") as temp_file:\n for word in temp_file.read().splitlines():\n STOP_WORDS.add(word)\n\n extra_words = list()\n\n for word in STOP_WORDS:\n extra_words.append(word.title())\n extra_words.append(word.upper())\n\n for word in extra_words:\n STOP_WORDS.add(word)","def add_filename_suffix(filepath, suffix):\r\n root, extension = splitext(basename(filepath))\r\n return root + suffix + extension","def censor_vowels(word):\n\n chars = []\n\n for letter in word:\n if letter in \"aeiou\":\n chars.append(\"*\")\n chars.append(letter)\n\n return \"\".join(vowels)","def addSuffixLink(self, suffix_link):\n self.suffix_link = suffix_link","def is_vowel(text):\n return text.lower() in AVRO_VOWELS","def endswith(a, suffix, start=0, end=None):\n return _vec_string(\n a, bool_, 'endswith', [suffix, start] + _clean_args(end))","def suffix(string, suffix, sep = '_'):\n if suffix == 'production':\n suffixed = string\n else:\n suffixed = string + sep + suffix\n return suffixed","def suffix(self, suffix):\n\n self._suffix = suffix","def suffix(self, suffix):\n\n self._suffix = suffix","def suffix(self, suffix):\n\n self._suffix = suffix","def suffix(self, suffix):\n\n self._suffix = suffix","def verb_lemma(word):\n if word.endswith(\"ed\"):\n if word[:-2].endswith(\"v\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"at\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"it\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"et\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"ut\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"ac\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"i\"):\n return word[:-3].lower() + \"y\"\n elif word[:-2].endswith(\"ir\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"ag\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"nc\"):\n return word[:-2].lower() + \"e\"\n elif word[:-2].endswith(\"nu\"):\n return word[:-2].lower() + \"e\"\n else:\n return word[:-2].lower() \n elif word.endswith(\"ing\"):\n if word[:-3].endswith(\"v\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"at\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"it\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"et\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"ut\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"ac\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"i\"):\n return word[:-4].lower() + \"y\"\n elif word[:-3].endswith(\"ir\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"ag\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"nc\"):\n return word[:-3].lower() + \"e\"\n elif word[:-3].endswith(\"nu\"):\n return word[:-3].lower() + \"e\"\n else:\n return word[:-3].lower()\n elif re.match(r\"(does|did|done)\", word):\n return (\"do\")\n elif re.match(r\"(is|are|am|was|will|were|been)\", word):\n return (\"be\")\n elif word == (\"'s\"):\n return (\"be\")\n elif re.match(r\"(had|has|'ve)\", word):\n return (\"have\")\n else:\n return word.lower()","def number_of_vowels(find_vowels):\n v = [\"a\", \"e\", \"i\", \"o\", \"u\", \"y\"]\n new_vowels = find_vowels.lower()\n vowels = \"\"\n for x in new_vowels:\n if x in v:\n vowels += x\n return len(vowels)","def test_suffix():\n transformer = hug.transform.suffix({\".js\": int, \".txt\": str})\n\n class FakeRequest(object):\n path = \"hey.js\"\n\n request = FakeRequest()\n assert transformer(\"1\", request) == 1\n\n request.path = \"hey.txt\"\n assert transformer(2, request) == \"2\"\n\n request.path = \"hey.undefined\"\n transformer({\"data\": \"value\"}, request) == {\"data\": \"value\"}","def setSuffix(self, value):\n return self._set(suffix=value)","def reverse_vowels(s):\n\n vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}\n vowel_indices = { i if s[i] in vowels else None for i in range(len(s)) }\n vowel_indices = tuple(filter(lambda x: x != None, vowel_indices))\n \n new_str = \"\"\n for i in range(len(s)):\n if i in vowel_indices:\n new_str += s[vowel_indices[-vowel_indices.index(i) - 1]]\n else:\n new_str += s[i]\n return new_str","def censor_vowels(word):\n\n chars = []\n\n for letter in word:\n if letter in \"aeiou\":\n chars.append(\"*\")\n else:\n chars.append(letter)\n \n return \"\".join(chars)","def suffix ( self ) :\n return self.__suffix","def suffix ( self ) :\n return self.__suffix","def get_letter(self, vowel_need):\r\n\r\n return self.letters.get(vowel_need, self.vowels)","def __truediv__(self, suffix: str) -> FSSpecTarget:\n return replace(self, root_path=os.path.join(self.root_path, suffix))","def get_suffix(cls, raw_disable: RawDisable) -> str:\n variations = raw_disable.parent_test.variations\n\n maybe_variation_node = raw_disable.node.find(f'.//{cls.VARIATION_TAG}')\n if maybe_variation_node is None:\n return ''\n\n variation = maybe_variation_node.text\n if variation not in variations:\n raise DisableNodeProcessingException(f'could not find {variation!r} in defined variations; skipping node')\n\n idx = variations.index(variation)\n suffix = f'_{idx}'\n return suffix","def is_english_vowel(c):\n # y was included in the vowel set guided by the tests.\n return c in 'aeiouyAEIOUY'","def enc_suffix(suf):\n if len(suf) == 0:\n return 0\n r0 = base34.find(suf[0])\n if len(suf) == 1:\n r1 = 0\n else:\n r1 = base34.find(suf[1]) + 1\n if r0 < 24: # first char is a letter, use base 25\n return r0 * 25 + r1 + 1\n else: # first is a number -- base 35.\n return r0 * 35 + r1 - 239","def makePigLatin(word): \n m = len(word)\n vowels = \"a\", \"e\", \"i\", \"o\", \"u\", \"y\" \n # short words are not converted \n if m<3 or word==\"the\":\n return word\n else:\n for i in vowels:\n if word.find(i) < m and word.find(i) != -1:\n m = word.find(i)\n if m==0:\n return word+\"way\" \n else:\n return word[m:]+word[:m]+\"ay\"","def prefix_suffix_modify():\n prefixes = \"JKLMNOPQ\"\n suffix = \"ack\"\n for letter in prefixes:\n if letter == \"O\" or letter == \"Q\":\n print(letter + \"u\" + suffix)\n else:\n print(letter + suffix)","def SpecialCodes(self):\n if sre.search(r\"[^aeiouy]e\\b\", self.wd): # nonsyllabic final e after C\n if ((not self.isPlural or self.wd[-2] not in SIBILANTS) and\n (not self.isPast or self.wd[-2] not in 'dt')):\n self.wd = self.wd[:-1] + encode(self.wd[-1])\n if not sre.search(r\"[aeiouy]\", self.wd): # any vowel left??\n self.wd = self.wd[:-1] + 'e' # undo the encoding\n self.wd = self.CiVcomb.sub(handleCiV, self.wd)\n self.wd = self.CCpair.sub(handleCC, self.wd)\n self.wd = self.VyVcomb.sub(handleVyV, self.wd)","def _step1b(self, word):\n # this NLTK-only block extends the original algorithm, so that\n # 'spied'->'spi' but 'died'->'die' etc\n if self.mode == self.NLTK_EXTENSIONS:\n if word.endswith(\"ied\"):\n if len(word) == 4:\n return self._replace_suffix(word, \"ied\", \"ie\")\n else:\n return self._replace_suffix(word, \"ied\", \"i\")\n\n # (m>0) EED -> EE\n if word.endswith(\"eed\"):\n stem = self._replace_suffix(word, \"eed\", \"\")\n if self._measure(stem) > 0:\n return stem + \"ee\"\n else:\n return word\n\n rule_2_or_3_succeeded = False\n\n for suffix in [\"ed\", \"ing\"]:\n if word.endswith(suffix):\n intermediate_stem = self._replace_suffix(word, suffix, \"\")\n if self._contains_vowel(intermediate_stem):\n rule_2_or_3_succeeded = True\n break\n\n if not rule_2_or_3_succeeded:\n return word\n\n return self._apply_rule_list(\n intermediate_stem,\n [\n (\"at\", \"ate\", None), # AT -> ATE\n (\"bl\", \"ble\", None), # BL -> BLE\n (\"iz\", \"ize\", None), # IZ -> IZE\n # (*d and not (*L or *S or *Z))\n # -> single letter\n (\n \"*d\",\n intermediate_stem[-1],\n lambda stem: intermediate_stem[-1] not in (\"l\", \"s\", \"z\"),\n ),\n # (m=1 and *o) -> E\n (\n \"\",\n \"e\",\n lambda stem: (self._measure(stem) == 1 and self._ends_cvc(stem)),\n ),\n ],\n )","def has_more_vowels(word):\n\n# If the phrase is over half vowels, it should return True:\n\n # intialize a vowel count variable \n # Loop through the letters of the word:\n # if the letter is in the set of vowels, increment the vowel count\n # if vowel count is greater than length of the word divided by 2, return True\n # else return false\n\n\n vowel_count = 0\n\n for letter in word:\n if letter.lower() in {\"a\", \"e\", \"i\", \"o\", \"u\"}:\n vowel_count += 1\n\n if vowel_count > (len(word) / 2):\n return True\n\n return False","def vowels(self):\n vas = []\n file = self.read()\n words = re.sub(\"[aeiouAEIOU]\",\" \", file).split(\" \")\n for h_u in words:\n if h_u != \"\":\n vas.append(h_u)\n self.print(vas)\n self.write(vas)\n logging.debug(\"Starting with to\")\n return vas","def main():\n word = input(\"Give me a word! \\n\\n\")\n vowels = ['a', 'e', 'i', 'o', 'u']\n if word[0].lower() in vowels:\n print(f\"\\n\\nPig latin: {word}way\")\n else:\n print(f\"\\n\\nPig latin: {word[1:]}{word[0]}ay\")","def wemo_entity_suffix_fixture():\n return \"\"","def removeVowels(self, S: str) -> str:\n \n vowel_list = ['a', 'e', 'i', 'o', 'u']\n output = \"\"\n \n for letter in S:\n \n if letter not in vowel_list:\n \n output += letter\n \n else:\n continue\n \n return output","def suffix(self):\n return self[\"suffix\"]","def suffix(self):\n return self[\"suffix\"]","def doCombineCurEnd(self, endofword, nrc='', nextvowel=''): # nrc = next root consonant\n if not self.end:\n return\n self.final = PhonStateCAT.getFinal(self.end)\n nasalPhon = ''\n postVowelPhon = ''\n preVowelPhon = ''\n # geminates\n geminates = False\n if self.end.startswith('w'):\n preVowelPhon = 'w'\n self.vowel = self.end[1:2]\n else:\n self.vowel = self.end[:1]\n vowelPhon = self.vowel\n if nrc == self.final and self.final != '':\n geminates = True\n if self.gemminatesStrategy == 'len' or self.gemminatesStrategy == 'lentone':\n postVowelPhon = 'ː'\n ## Suffix\n finalPhon = ''\n if self.final == 'ng':\n nasalPhon = self.nasalchar # ?\n if geminates:\n pass\n elif self.final in PhonStateCAT.simpleFinalMapping:\n finalPhon = PhonStateCAT.simpleFinalMapping[self.final]\n elif self.final == '':\n if self.latent != '' and self.prefixStrategy != 'never' and (self.prefixSyllable == 'afterEmptyCoda' or self.prefixSyllable == 'afterEmptyCoda+'):\n finalPhon = PhonStateCAT.simpleLatentMapping[self.latent]\n finalPhon = ''\n else:\n print(\"unrecognized final: \"+self.final)\n self.phon += preVowelPhon+vowelPhon+nasalPhon+postVowelPhon+finalPhon\n if not endofword:\n self.phon += self.syllablesepchar","def new_end(self, end): \n self.last_words.append(end)","def endswith(self, suffix, start=0, end=None):\n return endswith(self, suffix, start, end)","def get_elb_name ( base_name, app_name ) :\n max_len = 32\n name = base_name + '-' + app_name.upper( ) + '-LB'\n if len( name ) > max_len :\n name = base_name + '-' + app_name.upper( )\n if len( name ) > max_len :\n raise NameError( 'ELB Name ' + name + ' exceeds limit of ' + str( max_len ) )\n\n return name","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())","def case_suffix(self, **case_kws):\n if callable(self.output_suffix):\n return self.output_suffix(**case_kws)\n else:\n return self.output_suffix.format(**case_kws)","def disemvowel(string):\n to_return = ''\n for char in string:\n if char not in 'aeiouAEIOU':\n to_return += char\n return to_return","def pluralize(word):\n\n assert word\n assert isinstance(word, basestring)\n assert len(word) > 0\n\n second_last = word[-2]\n last = word[-1]\n if last in ['s', 'z','x']:\n return word + \"es\"\n elif last == 'h':\n if second_last in ['s', 'c']:\n return word + \"es\"\n else:\n return word + 's'\n elif last == 'o':\n if not _is_vowel(second_last):\n return word + \"es\"\n else: \n return word + 's'\n elif last == 'y':\n if not _is_vowel(second_last):\n return word[:-1] + \"ies\"\n else:\n return word + 's'\n else:\n return word + 's'","def needs_aou(word):\n return re.search(\"([aouAOU])[^yäöYÄÖ]*$\", word)","def find_words_using_all_vowels():\n pass","def stem(self, word):\n word = word.lower()\n\n step1_success = False\n\n # All acute accents are replaced by grave accents.\n word = (word.replace(u(\"\\xE1\"), u(\"\\xE0\"))\n .replace(u(\"\\xE9\"), u(\"\\xE8\"))\n .replace(u(\"\\xED\"), u(\"\\xEC\"))\n .replace(u(\"\\xF3\"), u(\"\\xF2\"))\n .replace(u(\"\\xFA\"), u(\"\\xF9\")))\n\n # Every occurrence of 'u' after 'q'\n # is put into upper case.\n for i in range(1, len(word)):\n if word[i - 1] == \"q\" and word[i] == \"u\":\n word = \"\".join((word[:i], \"U\", word[i + 1:]))\n\n # Every occurrence of 'u' and 'i'\n # between vowels is put into upper case.\n for i in range(1, len(word) - 1):\n if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:\n if word[i] == \"u\":\n word = \"\".join((word[:i], \"U\", word[i + 1:]))\n elif word[i] == \"i\":\n word = \"\".join((word[:i], \"I\", word[i + 1:]))\n\n r1, r2 = self._r1r2_standard(word, self.__vowels)\n rv = self._rv_standard(word, self.__vowels)\n\n # STEP 0: Attached pronoun\n for suffix in self.__step0_suffixes:\n if rv.endswith(suffix):\n if rv[-len(suffix) - 4:-len(suffix)] in (\"ando\", \"endo\"):\n word = word[:-len(suffix)]\n r1 = r1[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n rv = rv[:-len(suffix)]\n\n elif (rv[-len(suffix) - 2:-len(suffix)] in\n (\"ar\", \"er\", \"ir\")):\n word = \"\".join((word[:-len(suffix)], \"e\"))\n r1 = \"\".join((r1[:-len(suffix)], \"e\"))\n r2 = \"\".join((r2[:-len(suffix)], \"e\"))\n rv = \"\".join((rv[:-len(suffix)], \"e\"))\n break\n\n # STEP 1: Standard suffix removal\n for suffix in self.__step1_suffixes:\n if word.endswith(suffix):\n if suffix == \"amente\" and r1.endswith(suffix):\n step1_success = True\n word = word[:-6]\n r2 = r2[:-6]\n rv = rv[:-6]\n\n if r2.endswith(\"iv\"):\n word = word[:-2]\n r2 = r2[:-2]\n rv = rv[:-2]\n\n if r2.endswith(\"at\"):\n word = word[:-2]\n rv = rv[:-2]\n\n elif r2.endswith((\"os\", \"ic\")):\n word = word[:-2]\n rv = rv[:-2]\n\n elif r2 .endswith(\"abil\"):\n word = word[:-4]\n rv = rv[:-4]\n\n elif (suffix in (\"amento\", \"amenti\",\n \"imento\", \"imenti\") and\n rv.endswith(suffix)):\n step1_success = True\n word = word[:-6]\n rv = rv[:-6]\n\n elif r2.endswith(suffix):\n step1_success = True\n if suffix in (\"azione\", \"azioni\", \"atore\", \"atori\"):\n word = word[:-len(suffix)]\n r2 = r2[:-len(suffix)]\n rv = rv[:-len(suffix)]\n\n if r2.endswith(\"ic\"):\n word = word[:-2]\n rv = rv[:-2]\n\n elif suffix in (\"logia\", \"logie\"):\n word = word[:-2]\n rv = word[:-2]\n\n elif suffix in (\"uzione\", \"uzioni\",\n \"usione\", \"usioni\"):\n word = word[:-5]\n rv = rv[:-5]\n\n elif suffix in (\"enza\", \"enze\"):\n word = \"\".join((word[:-2], \"te\"))\n rv = \"\".join((rv[:-2], \"te\"))\n\n elif suffix == u(\"it\\xE0\"):\n word = word[:-3]\n r2 = r2[:-3]\n rv = rv[:-3]\n\n if r2.endswith((\"ic\", \"iv\")):\n word = word[:-2]\n rv = rv[:-2]\n\n elif r2.endswith(\"abil\"):\n word = word[:-4]\n rv = rv[:-4]\n\n elif suffix in (\"ivo\", \"ivi\", \"iva\", \"ive\"):\n word = word[:-3]\n r2 = r2[:-3]\n rv = rv[:-3]\n\n if r2.endswith(\"at\"):\n word = word[:-2]\n r2 = r2[:-2]\n rv = rv[:-2]\n\n if r2.endswith(\"ic\"):\n word = word[:-2]\n rv = rv[:-2]\n else:\n word = word[:-len(suffix)]\n rv = rv[:-len(suffix)]\n break\n\n # STEP 2: Verb suffixes\n if not step1_success:\n for suffix in self.__step2_suffixes:\n if rv.endswith(suffix):\n word = word[:-len(suffix)]\n rv = rv[:-len(suffix)]\n break\n\n # STEP 3a\n if rv.endswith((\"a\", \"e\", \"i\", \"o\", u(\"\\xE0\"), u(\"\\xE8\"),\n u(\"\\xEC\"), u(\"\\xF2\"))):\n word = word[:-1]\n rv = rv[:-1]\n\n if rv.endswith(\"i\"):\n word = word[:-1]\n rv = rv[:-1]\n\n # STEP 3b\n if rv.endswith((\"ch\", \"gh\")):\n word = word[:-1]\n\n word = word.replace(\"I\", \"i\").replace(\"U\", \"u\")\n return word","def normalize_suffix_0(string, logger_=_LOGGER):\n if re.search(\"_[A-Z]{1,}$\", string):\n return string\n numbers = re.search(\"[0-9]{1,}$\", string)\n if numbers:\n logger.log(\n level=\"warning\",\n message='Suffix of string \"'\n + string\n + '\" should not have a number. Numbers removed from the suffix',\n logger=logger_,\n )\n instance = numbers.group(0)\n string = string[0 : string.find(instance)]\n lower_case = re.search(\"_[a-z]{1,}$\", string)\n if lower_case:\n instance_ = lower_case.group(0)\n string = string[0 : string.find(instance_)] + instance_.upper()\n return string","def add_word(self, word):\n word = self.map_word(word)\n super(InvariantLanguage, self).add_word(word)","def inner(word):\n return word + '!!!'","def pig_latinify(word):\n\n first_letter = word[0]\n\n if first_letter in VOWELS:\n output_word = word + \"yay\"\n else:\n #scan for vowel if word starts with a consonant\n for i in range(len(word)):\n individual_letter = word[i]\n if individual_letter in VOWELS:\n output_word = word[i:] + word[:i] + \"ay\"\n break\n else:\n continue\n\n return output_word","def pig_latinify(word):\n result = \"\"\n if len(word) > 0 and word.isalpha():\n first = word[0]\n if is_vowel(first): # starts with a vowel\n result = str(word) + \"yay\"\n else: # starts with non-vowel\n cut = position_of_vowel(word) # where to cut the word\n if cut > 0: # \"street\"-->\"eet+str+ay\"\n result = word[cut:] + word[:cut] + \"ay\"\n else: # no vowel found\n result = word + \"ay\"\n else:\n result = 'Only letters allowed!'\n\n return result","def fry(word):\n\n # looks for a Y or y which will be (captured) followed and ended by an 'ou'\n match_you = re.match('([Yy])ou$', word)\n\n # First group will be the (captured) group so either 'Y' or 'y'\n if match_you:\n return match_you.group(1) + \"'all\"\n\n # looks for anyword ending in 'ing'\n match_ing = re.search('(.+)ing$', word)\n\n # checks if vowel exists before the 'ing'\n if match_ing:\n vowel_check = re.search('[aeiouy]', match_ing.group(1))\n # First group will be the (captured) group so everything before the 'ing'\n if vowel_check:\n return match_ing.group(1) + \"in'\"\n\n return word","def _rv_standard(self, word, vowels):\n rv = \"\"\n if len(word) >= 2:\n if word[1] not in vowels:\n for i in range(2, len(word)):\n if word[i] in vowels:\n rv = word[i + 1 :]\n break\n\n elif word[0] in vowels and word[1] in vowels:\n for i in range(2, len(word)):\n if word[i] not in vowels:\n rv = word[i + 1 :]\n break\n else:\n rv = word[3:]\n\n return rv","def add_suffix(self, suffix, axis=1):\n return DataFrameDefault.register(pandas.DataFrame.add_suffix)(\n self, suffix=suffix, axis=axis\n )","def generate_syllable():\n return generate_vowel() + generate_consonant()","def indefinite(self):\n return \"an\" if self.short_desc[0] in 'aeiou' else \"a\"","def _contains_vowel(self, stem):\n for i in range(len(stem)):\n if not self._is_consonant(stem, i):\n return True\n return False","def replace_end(s, old, new):\n assert s.endswith(old)\n return s[:-len(old)] + new"],"string":"[\n \"def add_suffix(word, suffix):\\n suffix, sep, rest = suffix.partition(' ')\\n expanded = _add_suffix(word, suffix)\\n return expanded + sep + rest\",\n \"def get_vowel_names():\",\n \"def _replace_suffix(self, word, suffix, replacement):\\n assert word.endswith(suffix), \\\"Given word doesn't end with given suffix\\\"\\n if suffix == \\\"\\\":\\n return word + replacement\\n else:\\n return word[: -len(suffix)] + replacement\",\n \"def translate(self):\\n\\t\\tvowels = \\\"aeiou\\\"\\n\\n\\t\\tif (self.word[0] not in vowels) and (self.word[1] in vowels):\\n\\t\\t\\tnew_word = self.word[1:] + self.word[0] + \\\"ay\\\"\\n\\t\\telif self.word[0] in vowels:\\n\\t\\t\\tnew_word = self.word + \\\"way\\\"\\n\\t\\telse:\\n\\t\\t\\tnew_word = self.word[2:] + self.word[:2] + \\\"ay\\\"\\n\\n\\t\\tprint(new_word)\",\n \"def pig_word(self, original):\\n word = original.lower()\\n if word[0] in \\\"aeiou\\\":\\n new_word = word + 'ay'\\n else:\\n new_word = word[1:] + word[0] + 'ay'\\n return new_word\",\n \"def stem(self, word):\\n word = word.lower()\\n\\n if word in self.stopwords:\\n return word\\n\\n step1_success = False\\n\\n r1, r2 = self._r1r2_standard(word, self.__vowels)\\n rv = self._rv_standard(word, self.__vowels)\\n\\n # STEP 0: Attached pronoun\\n for suffix in self.__step0_suffixes:\\n if not (word.endswith(suffix) and rv.endswith(suffix)):\\n continue\\n\\n if (\\n rv[: -len(suffix)].endswith(\\n (\\n \\\"ando\\\",\\n \\\"ar\\\",\\n \\\"er\\\",\\n \\\"iendo\\\",\\n \\\"ir\\\",\\n )\\n )\\n ) or (\\n rv[: -len(suffix)].endswith(\\\"yendo\\\")\\n and word[: -len(suffix)].endswith(\\\"uyendo\\\")\\n ):\\n\\n word = self.__replace_accented(word[: -len(suffix)])\\n r1 = self.__replace_accented(r1[: -len(suffix)])\\n r2 = self.__replace_accented(r2[: -len(suffix)])\\n rv = self.__replace_accented(rv[: -len(suffix)])\\n break\\n\\n # STEP 1: Standard suffix removal\\n for suffix in self.__step1_suffixes:\\n if not word.endswith(suffix):\\n continue\\n\\n if suffix == \\\"amente\\\" and r1.endswith(suffix):\\n step1_success = True\\n word = word[:-6]\\n r2 = r2[:-6]\\n rv = rv[:-6]\\n\\n if r2.endswith(\\\"iv\\\"):\\n word = word[:-2]\\n r2 = r2[:-2]\\n rv = rv[:-2]\\n\\n if r2.endswith(\\\"at\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif r2.endswith((\\\"os\\\", \\\"ic\\\", \\\"ad\\\")):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif r2.endswith(suffix):\\n step1_success = True\\n if suffix in (\\n \\\"adora\\\",\\n \\\"ador\\\",\\n \\\"acion\\\",\\n \\\"adoras\\\",\\n \\\"adores\\\",\\n \\\"aciones\\\",\\n \\\"ante\\\",\\n \\\"antes\\\",\\n \\\"ancia\\\",\\n \\\"ancias\\\",\\n ):\\n word = word[: -len(suffix)]\\n r2 = r2[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n\\n if r2.endswith(\\\"ic\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif suffix in (\\\"logia\\\", \\\"logias\\\"):\\n word = suffix_replace(word, suffix, \\\"log\\\")\\n rv = suffix_replace(rv, suffix, \\\"log\\\")\\n\\n elif suffix in (\\\"ucion\\\", \\\"uciones\\\"):\\n word = suffix_replace(word, suffix, \\\"u\\\")\\n rv = suffix_replace(rv, suffix, \\\"u\\\")\\n\\n elif suffix in (\\\"encia\\\", \\\"encias\\\"):\\n word = suffix_replace(word, suffix, \\\"ente\\\")\\n rv = suffix_replace(rv, suffix, \\\"ente\\\")\\n\\n elif suffix == \\\"mente\\\":\\n word = word[: -len(suffix)]\\n r2 = r2[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n\\n if r2.endswith((\\\"ante\\\", \\\"able\\\", \\\"ible\\\")):\\n word = word[:-4]\\n rv = rv[:-4]\\n\\n elif suffix in (\\\"idad\\\", \\\"idades\\\"):\\n word = word[: -len(suffix)]\\n r2 = r2[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n\\n for pre_suff in (\\\"abil\\\", \\\"ic\\\", \\\"iv\\\"):\\n if r2.endswith(pre_suff):\\n word = word[: -len(pre_suff)]\\n rv = rv[: -len(pre_suff)]\\n\\n elif suffix in (\\\"ivo\\\", \\\"iva\\\", \\\"ivos\\\", \\\"ivas\\\"):\\n word = word[: -len(suffix)]\\n r2 = r2[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n if r2.endswith(\\\"at\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n else:\\n word = word[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n break\\n\\n # STEP 2a: Verb suffixes beginning 'y'\\n if not step1_success:\\n for suffix in self.__step2a_suffixes:\\n if rv.endswith(suffix) and word[-len(suffix) - 1 : -len(suffix)] == \\\"u\\\":\\n word = word[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n break\\n\\n # STEP 2b: Other verb suffixes\\n for suffix in self.__step2b_suffixes:\\n if rv.endswith(suffix):\\n word = word[: -len(suffix)]\\n rv = rv[: -len(suffix)]\\n if suffix in (\\\"en\\\", \\\"es\\\", \\\"eis\\\", \\\"emos\\\"):\\n if word.endswith(\\\"gu\\\"):\\n word = word[:-1]\\n\\n if rv.endswith(\\\"gu\\\"):\\n rv = rv[:-1]\\n break\\n\\n # STEP 3: Residual suffix\\n for suffix in self.__step3_suffixes:\\n if rv.endswith(suffix):\\n word = word[: -len(suffix)]\\n if suffix in (\\\"e\\\", \\\"\\\\xE9\\\"):\\n rv = rv[: -len(suffix)]\\n\\n if word[-2:] == \\\"gu\\\" and rv.endswith(\\\"u\\\"):\\n word = word[:-1]\\n break\\n\\n word = self.__replace_accented(word)\\n\\n return word\",\n \"def create_extended_name(y: str, p: str) -> str:\\n final_letter = y[-1]\\n if final_letter == \\\"e\\\":\\n extended_name = y + \\\"x\\\" + p\\n elif final_letter in [\\\"a\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\"]:\\n extended_name = y[:-1] + \\\"ex\\\" + p\\n elif final_letter == \\\"x\\\":\\n if y[-2] == \\\"e\\\":\\n extended_name = y + p\\n else:\\n extended_name = y + \\\"ex\\\" + p\\n return extended_name\",\n \"def _ends_with_vowel(self, letter_group: str) -> bool:\\n if len(letter_group) == 0:\\n return False\\n return self._contains_vowels(letter_group[-1])\",\n \"def find_vowels(s):\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def add_suffix(name: str, suffix: str):\\n return f'{name}_{suffix}'\",\n \"def addSuffixes(self, alist):\\n for i, (word, filename) in enumerate(alist):\\n withsuffix = self._findVideoFile(filename)\\n alist[i] = (word, withsuffix)\\n return alist\",\n \"def upper_vowel(s):\\n for k, v in REPLACED_MAP.iteritems():\\n s = s.replace(k, v)\\n return s\",\n \"def last_char_to_vowel(word):\\n assert isinstance(word, str)\\n # We iterate over characters of the word, because the last might be a\\n # punctuation, perhaps.\\n for last in reversed(word):\\n last = last.lower()\\n for ch, prev in ((\\\"a\\\", \\\"a/+£\\\"),\\n (\\\"e\\\", \\\"eébcçdgptvwz&*:.\\\"),\\n (\\\"o\\\", \\\"ohk€å\\\"),\\n (\\\"ä\\\", \\\"äflmnrsx§\\\"),\\n (\\\"ö\\\", \\\"ö\\\"),\\n (\\\"i\\\", \\\"ij%$\\\"),\\n (\\\"u\\\", \\\"uq,\\\"),\\n (\\\"y\\\", \\\"yü\\\")):\\n if last in prev:\\n return ch\\n return \\\"e\\\"\",\n \"def suffix():\\r\\n\\r\\n return _random.choice(\\r\\n [\\r\\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\\r\\n ]\\r\\n )\",\n \"def reverse_vowels(s):\\n\\n phrase = \\\"\\\"\\n vowels = []\\n for letter in s:\\n if letter.lower() in \\\"aeiou\\\":\\n phrase += \\\"~\\\"\\n vowels.append(letter)\\n else: \\n phrase += letter\\n \\n index = 0\\n new_phrase = \\\"\\\"\\n vowels = vowels[-1:-len(vowels)-1:-1]\\n \\n for letter in phrase:\\n\\n if letter == \\\"~\\\":\\n new_phrase += vowels[index]\\n index += 1\\n else:\\n new_phrase += letter\\n\\n return new_phrase\",\n \"def find_vowel(text: str) -> str:\\r\\n\\r\\n vowel = text.count('a') + text.count('o') + text.count('u') +\\\\\\r\\n text.count('i') + text.count('e') + text.count(\\\"y\\\") +\\\\\\r\\n text.count('A') + text.count('O') + text.count('U') +\\\\\\r\\n text.count('I') + text.count('E') + text.count('Y')\\r\\n\\r\\n return(vowel)\",\n \"def _suffix(self) -> str:\\n return \\\"\\\"\",\n \"def suffix_replace(original, old, new):\\n ...\",\n \"def add_suffix(in_image,\\n suffix_str):\\n bandnames = in_image.bandNames().map(lambda elem: ee.String(elem).toLowerCase().cat('_').cat(suffix_str))\\n nb = bandnames.length()\\n return in_image.select(ee.List.sequence(0, ee.Number(nb).subtract(1)), bandnames)\",\n \"def FindSuffix(self):\\n self.numSuffixes = 0\\n self.forceStress = 0\\n resultslist = []\\n for f in self.suffixes.finditer(self.wd):\\n resultslist.append((f.group(), f.start()))\\n if not resultslist: return\\n # make sure *end* of word is in list! otherwise, 'DESP erate'\\n if resultslist[-1][1] + len(resultslist[-1][0]) < len(self.wd):\\n return\\n resultslist.reverse()\\n for res in resultslist:\\n # if no vowel left before, false suffix ('singing')\\n # n.b.: will choke on 'quest' etc! put in dictionary, I guess\\n if not sre.search('[aeiouy]', self.wd[:res[1]]): break\\n if res[0] == 'ing' and self.wd[res[1]-1] == self.wd[res[1]-2]:\\n self.sylBounds.append(res[1] - 1) # freq special case\\n else: self.sylBounds.append(res[1]) # sorted later\\n self.wd = self.wd[:res[1]]\\n self.numSuffixes += 1\\n if res[0] in STRESSSUFFIX:\\n self.forceStress = 0 - len(self.sylBounds)\\n if res[0] in MULTISUFFIX:\\n # tricky bit! it *happens* that secondary division in all these\\n # comes after its first character; NOT inevitable!\\n # also does not allow for 3-syl: 'ically' (which are reliable!)\\n self.sylBounds.append(res[1]+1)\\n self.numSuffixes += 1\",\n \"def generate_vowel():\\n return random.sample(['a', 'e', 'i', 'o', 'u', 'y'], 1)\",\n \"def gerundify(verb):\\n if verb.endswith(\\\"e\\\"):\\n verb = verb[:-1]\\n\\n if random() < 0.4:\\n if (\\n not verb.startswith(\\\"a\\\")\\n and not verb.startswith(\\\"e\\\")\\n and not verb.startswith(\\\"i\\\")\\n and not verb.startswith(\\\"o\\\")\\n and not verb.startswith(\\\"u\\\")\\n ):\\n verb = \\\"a-\\\" + verb\\n\\n return verb + \\\"ing\\\"\",\n \"def apply_sinalefa(self):\\n syllables_sinalefa = []\\n index = 0\\n while index < len(self.word_syllables):\\n try:\\n # checking if there is sinalefa\\n if self.are_vowels(syllables_sinalefa[-1][-1], self.word_syllables[index][0]):\\n merged_syllables = ''.join([syllables_sinalefa[-1], self.word_syllables[index]])\\n # replacing the last syllable with the merged syllable\\n syllables_sinalefa.pop(-1)\\n syllables_sinalefa.append(merged_syllables)\\n else:\\n syllables_sinalefa.append(self.word_syllables[index])\\n except IndexError:\\n # we reached the last word\\n syllables_sinalefa.append(self.word_syllables[index])\\n finally:\\n index += 1\\n\\n return '-'.join(syllables_sinalefa)\",\n \"def is_suffix(v,s):\\n c = len(v)-1\\n n = len(s)\\n return c + v[c] == 2*n\",\n \"def removesuffix(self, x) -> String:\\n pass\",\n \"def vowel_with_for(character):\\r\\n\\tif character in vowels:\\r\\n\\t\\tprint(\\\"Entered character is vowel..!\\\")\\r\\n\\telse:\\r\\n\\t\\tprint(\\\"Not a Vowel\\\")\",\n \"def step1c(self, word):\\r\\n\\r\\n if word.endswith('y'):\\r\\n result = word.rfind('y')\\r\\n base = word[:result]\\r\\n if self.containsVowel(base):\\r\\n word = base\\r\\n word += 'i'\\r\\n return word\",\n \"def is_suffix(suffix: str, word: str):\\n return word.endswith(suffix)\",\n \"def stem(self, word):\\n word = word.lower()\\n\\n if word in self.__special_words:\\n return self.__special_words[word]\\n\\n # Map the different apostrophe characters to a single consistent one\\n word = (word.replace(u(\\\"\\\\u2019\\\"), u(\\\"\\\\x27\\\"))\\n .replace(u(\\\"\\\\u2018\\\"), u(\\\"\\\\x27\\\"))\\n .replace(u(\\\"\\\\u201B\\\"), u(\\\"\\\\x27\\\")))\\n\\n if word.startswith(u(\\\"\\\\x27\\\")):\\n word = word[1:]\\n\\n if word.startswith(\\\"y\\\"):\\n word = \\\"\\\".join((\\\"Y\\\", word[1:]))\\n\\n for i in range(1, len(word)):\\n if word[i - 1] in self.__vowels and word[i] == \\\"y\\\":\\n word = \\\"\\\".join((word[:i], \\\"Y\\\", word[i + 1:]))\\n\\n step1a_vowel_found = False\\n step1b_vowel_found = False\\n\\n r1 = \\\"\\\"\\n r2 = \\\"\\\"\\n\\n if word.startswith((\\\"gener\\\", \\\"commun\\\", \\\"arsen\\\")):\\n if word.startswith((\\\"gener\\\", \\\"arsen\\\")):\\n r1 = word[5:]\\n else:\\n r1 = word[6:]\\n\\n for i in range(1, len(r1)):\\n if r1[i] not in self.__vowels and r1[i - 1] in self.__vowels:\\n r2 = r1[i + 1:]\\n break\\n else:\\n r1, r2 = self._r1r2_standard(word, self.__vowels)\\n\\n # STEP 0\\n for suffix in self.__step0_suffixes:\\n if word.endswith(suffix):\\n word = word[:-len(suffix)]\\n r1 = r1[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n break\\n\\n # STEP 1a\\n for suffix in self.__step1a_suffixes:\\n if word.endswith(suffix):\\n\\n if suffix == \\\"sses\\\":\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n\\n elif suffix in (\\\"ied\\\", \\\"ies\\\"):\\n if len(word[:-len(suffix)]) > 1:\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n else:\\n word = word[:-1]\\n r1 = r1[:-1]\\n r2 = r2[:-1]\\n\\n elif suffix == \\\"s\\\":\\n for letter in word[:-2]:\\n if letter in self.__vowels:\\n step1a_vowel_found = True\\n break\\n\\n if step1a_vowel_found:\\n word = word[:-1]\\n r1 = r1[:-1]\\n r2 = r2[:-1]\\n break\\n\\n # STEP 1b\\n for suffix in self.__step1b_suffixes:\\n if word.endswith(suffix):\\n if suffix in (\\\"eed\\\", \\\"eedly\\\"):\\n\\n if r1.endswith(suffix):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ee\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ee\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ee\\\"))\\n else:\\n r2 = \\\"\\\"\\n else:\\n for letter in word[:-len(suffix)]:\\n if letter in self.__vowels:\\n step1b_vowel_found = True\\n break\\n\\n if step1b_vowel_found:\\n word = word[:-len(suffix)]\\n r1 = r1[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n\\n if word.endswith((\\\"at\\\", \\\"bl\\\", \\\"iz\\\")):\\n word = \\\"\\\".join((word, \\\"e\\\"))\\n r1 = \\\"\\\".join((r1, \\\"e\\\"))\\n\\n if len(word) > 5 or len(r1) >= 3:\\n r2 = \\\"\\\".join((r2, \\\"e\\\"))\\n\\n elif word.endswith(self.__double_consonants):\\n word = word[:-1]\\n r1 = r1[:-1]\\n r2 = r2[:-1]\\n\\n elif ((r1 == \\\"\\\" and len(word) >= 3 and\\n word[-1] not in self.__vowels and\\n word[-1] not in \\\"wxY\\\" and\\n word[-2] in self.__vowels and\\n word[-3] not in self.__vowels)\\n or\\n (r1 == \\\"\\\" and len(word) == 2 and\\n word[0] in self.__vowels and\\n word[1] not in self.__vowels)):\\n\\n word = \\\"\\\".join((word, \\\"e\\\"))\\n\\n if len(r1) > 0:\\n r1 = \\\"\\\".join((r1, \\\"e\\\"))\\n\\n if len(r2) > 0:\\n r2 = \\\"\\\".join((r2, \\\"e\\\"))\\n break\\n\\n # STEP 1c\\n if (len(word) > 2\\n and word[-1] in \\\"yY\\\"\\n and word[-2] not in self.__vowels):\\n word = \\\"\\\".join((word[:-1], \\\"i\\\"))\\n if len(r1) >= 1:\\n r1 = \\\"\\\".join((r1[:-1], \\\"i\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= 1:\\n r2 = \\\"\\\".join((r2[:-1], \\\"i\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n # STEP 2\\n for suffix in self.__step2_suffixes:\\n if word.endswith(suffix):\\n if r1.endswith(suffix):\\n if suffix == \\\"tional\\\":\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n\\n elif suffix in (\\\"enci\\\", \\\"anci\\\", \\\"abli\\\"):\\n word = \\\"\\\".join((word[:-1], \\\"e\\\"))\\n\\n if len(r1) >= 1:\\n r1 = \\\"\\\".join((r1[:-1], \\\"e\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= 1:\\n r2 = \\\"\\\".join((r2[:-1], \\\"e\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix == \\\"entli\\\":\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n\\n elif suffix in (\\\"izer\\\", \\\"ization\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ize\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ize\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ize\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix in (\\\"ational\\\", \\\"ation\\\", \\\"ator\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ate\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ate\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ate\\\"))\\n else:\\n r2 = \\\"e\\\"\\n\\n elif suffix in (\\\"alism\\\", \\\"aliti\\\", \\\"alli\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"al\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"al\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"al\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix == \\\"fulness\\\":\\n word = word[:-4]\\n r1 = r1[:-4]\\n r2 = r2[:-4]\\n\\n elif suffix in (\\\"ousli\\\", \\\"ousness\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ous\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ous\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ous\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix in (\\\"iveness\\\", \\\"iviti\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ive\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ive\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ive\\\"))\\n else:\\n r2 = \\\"e\\\"\\n\\n elif suffix in (\\\"biliti\\\", \\\"bli\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ble\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ble\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ble\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix == \\\"ogi\\\" and word[-4] == \\\"l\\\":\\n word = word[:-1]\\n r1 = r1[:-1]\\n r2 = r2[:-1]\\n\\n elif suffix in (\\\"fulli\\\", \\\"lessli\\\"):\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n\\n elif suffix == \\\"li\\\" and word[-3] in self.__li_ending:\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n break\\n\\n # STEP 3\\n for suffix in self.__step3_suffixes:\\n if word.endswith(suffix):\\n if r1.endswith(suffix):\\n if suffix == \\\"tional\\\":\\n word = word[:-2]\\n r1 = r1[:-2]\\n r2 = r2[:-2]\\n\\n elif suffix == \\\"ational\\\":\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ate\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ate\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ate\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix == \\\"alize\\\":\\n word = word[:-3]\\n r1 = r1[:-3]\\n r2 = r2[:-3]\\n\\n elif suffix in (\\\"icate\\\", \\\"iciti\\\", \\\"ical\\\"):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"ic\\\"))\\n\\n if len(r1) >= len(suffix):\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"ic\\\"))\\n else:\\n r1 = \\\"\\\"\\n\\n if len(r2) >= len(suffix):\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"ic\\\"))\\n else:\\n r2 = \\\"\\\"\\n\\n elif suffix in (\\\"ful\\\", \\\"ness\\\"):\\n word = word[:-len(suffix)]\\n r1 = r1[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n\\n elif suffix == \\\"ative\\\" and r2.endswith(suffix):\\n word = word[:-5]\\n r1 = r1[:-5]\\n r2 = r2[:-5]\\n break\\n\\n # STEP 4\\n for suffix in self.__step4_suffixes:\\n if word.endswith(suffix):\\n if r2.endswith(suffix):\\n if suffix == \\\"ion\\\":\\n if word[-4] in \\\"st\\\":\\n word = word[:-3]\\n r1 = r1[:-3]\\n r2 = r2[:-3]\\n else:\\n word = word[:-len(suffix)]\\n r1 = r1[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n break\\n\\n # STEP 5\\n if r2.endswith(\\\"l\\\") and word[-2] == \\\"l\\\":\\n word = word[:-1]\\n elif r2.endswith(\\\"e\\\"):\\n word = word[:-1]\\n elif r1.endswith(\\\"e\\\"):\\n if len(word) >= 4 and (word[-2] in self.__vowels or\\n word[-2] in \\\"wxY\\\" or\\n word[-3] not in self.__vowels or\\n word[-4] in self.__vowels):\\n word = word[:-1]\\n\\n word = word.replace(\\\"Y\\\", \\\"y\\\")\\n return word\",\n \"def is_vowel(self, letter):\\n\\n if letter in (\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\", \\\"A\\\", \\\"E\\\", \\\"I\\\", \\\"O\\\", \\\"U\\\"):\\n return True\\n return False\",\n \"def replace_vowels(word):\\n variants = []\\n for c in word:\\n if c in vowels:\\n for vowel in vowels:\\n variants.append(word.replace(c, vowel))\\n return variants\",\n \"def form_ing(word):\\n\\n # last char of the word\\n last = word[-1]\\n\\n if last == 'e':\\n return word[:-1] + 'ing'\\n elif last == 'r':\\n if word[-2] == 'a': \\n return word + \\\"ring\\\"\\n elif last in ['b', 'd', 'g', 'm', 'n', 'p', 't']:\\n if _is_vowel(word[-2]) and not (_is_vowel(word[-3])):\\n return word + word[-1] + \\\"ing\\\"\\n\\n return word + \\\"ing\\\"\",\n \"def test_add_filename_suffix(self):\\r\\n self.assertEqual(add_filename_suffix('/foo/bar/baz.txt', 'z'),\\r\\n 'bazz.txt')\\r\\n self.assertEqual(add_filename_suffix('baz.txt', 'z'),\\r\\n 'bazz.txt')\\r\\n self.assertEqual(add_filename_suffix('/foo/bar/baz', 'z'),\\r\\n 'bazz')\\r\\n self.assertEqual(add_filename_suffix('baz', 'z'),\\r\\n 'bazz')\\r\\n self.assertEqual(add_filename_suffix('/baz.fasta.txt', 'z'),\\r\\n 'baz.fastaz.txt')\\r\\n self.assertEqual(add_filename_suffix('baz.fasta.txt', 'z'),\\r\\n 'baz.fastaz.txt')\\r\\n self.assertEqual(add_filename_suffix('/foo/', 'z'), 'z')\",\n \"def __add_filename_suffix(filename, suffix):\\n return \\\"{}{}.pdf\\\".format(filename.split(\\\".pdf\\\", 1)[0], suffix)\",\n \"def suffix(self, e, remaining, rate):\\n return f' {e + 1}/{self.max} [{remaining} remaining, {round(rate, 2)} iter/s]'\",\n \"def remove_vowels(phrase):\\n vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']\\n cons_word = \\\"\\\".join([char for char in phrase if char not in vowels])\\n return cons_word\",\n \"def suffix(rem):\\n if rem == 0:\\n suf = ''\\n else:\\n if rem <= 600: #Class A suffix -- only letters.\\n rem = rem - 1\\n suf = base34[rem // 25]\\n if rem % 25 > 0:\\n suf = suf + base34[rem % 25 - 1]# second class A letter, if present.\\n else: #rems > 600 : First digit of suffix is a number. Second digit may be blank, letter, or number.\\n rem = rem - 601\\n suf = base10[rem // 35]\\n if rem % 35 > 0:\\n suf = suf + base34[rem % 35 - 1]\\n return suf\",\n \"def _iendswith(string, suffix):\\n return string.lower().endswith(suffix)\",\n \"def add_possessive(results, form, poss):\\n if not poss:\\n return results\\n\\n # Add possessive suffix\\n suffixes = nounspecs.possessive_suffixes[poss]\\n if isinstance(suffixes, str):\\n suffixes = [suffixes]\\n results2 = []\\n for suffix in suffixes:\\n for v in results:\\n parts = list(x for x in v)\\n if suffix[0] != \\\"@\\\":\\n for x in suffix:\\n if x == \\\"A\\\":\\n p = \\\"\\\".join(parts)\\n m = re.search(\\\"([aouAOU])[^yäöYÄÖ]*$\\\", p)\\n if m:\\n parts.append(\\\"a\\\")\\n else:\\n parts.append(\\\"ä\\\")\\n else:\\n parts.append(x)\\n v = \\\"\\\".join(parts)\\n else:\\n if form not in (\\n \\\"ine-sg\\\", \\\"ine-pl\\\", \\\"ela-sg\\\", \\\"ela-pl\\\",\\n \\\"all-sg\\\", \\\"all-pl\\\", \\\"ade-sg\\\", \\\"ade-pl\\\",\\n \\\"abl-sg\\\", \\\"abl-pl\\\", \\\"tra-sg\\\", \\\"tra-pl\\\",\\n \\\"ess-sg\\\", \\\"ess-pl\\\", \\\"abe-sg\\\", \\\"abe-pl\\\",\\n \\\"ptv-sg\\\", \\\"ptv-pl\\\", \\\"cmt\\\",\\n \\\"inf1-long\\\", \\\"inf2\\\", \\\"inf3\\\", \\\"inf4\\\", \\\"inf5\\\"):\\n continue\\n if len(v) < 2 or v[-1] not in \\\"aeiouyäö\\\":\\n continue\\n if v[-2] == v[-1]:\\n continue\\n v += v[-1]\\n v += suffix[1:]\\n if v:\\n results2.append(v)\\n return results2\",\n \"def add_suffix_to_filename(filename, suffix):\\n name, ext = os.path.splitext(filename)\\n return ''.join([name, suffix, ext])\",\n \"def add_edge(self, u, v, weight, pre_start, pre_end, suff_start, suff_end):\\n \\n self.add_node(u)\\n self.add_node(v)\\n \\n if u not in self.prefix[v] and v not in self.suffix[u]:\\n self.edges = self.edges + 1\\n \\n if u not in self.prefix[v]:\\n self.prefix[v][u] = [weight, pre_start, pre_end]\\n \\n if v not in self.suffix[u]:\\n self.suffix[u][v] = [weight, suff_start, suff_end]\",\n \"def replace_suffix (name, new_suffix):\\n assert isinstance(name, basestring)\\n assert isinstance(new_suffix, basestring)\\n split = os.path.splitext (name)\\n return split [0] + new_suffix\",\n \"def add_extra_words():\\n\\n with open(ES_STOPWORDS_FILE, \\\"r\\\", encoding=\\\"utf-8\\\") as temp_file:\\n for word in temp_file.read().splitlines():\\n STOP_WORDS.add(word)\\n\\n with open(EN_STOPWORDS_FILE, \\\"r\\\", encoding=\\\"utf-8\\\") as temp_file:\\n for word in temp_file.read().splitlines():\\n STOP_WORDS.add(word)\\n\\n extra_words = list()\\n\\n for word in STOP_WORDS:\\n extra_words.append(word.title())\\n extra_words.append(word.upper())\\n\\n for word in extra_words:\\n STOP_WORDS.add(word)\",\n \"def add_filename_suffix(filepath, suffix):\\r\\n root, extension = splitext(basename(filepath))\\r\\n return root + suffix + extension\",\n \"def censor_vowels(word):\\n\\n chars = []\\n\\n for letter in word:\\n if letter in \\\"aeiou\\\":\\n chars.append(\\\"*\\\")\\n chars.append(letter)\\n\\n return \\\"\\\".join(vowels)\",\n \"def addSuffixLink(self, suffix_link):\\n self.suffix_link = suffix_link\",\n \"def is_vowel(text):\\n return text.lower() in AVRO_VOWELS\",\n \"def endswith(a, suffix, start=0, end=None):\\n return _vec_string(\\n a, bool_, 'endswith', [suffix, start] + _clean_args(end))\",\n \"def suffix(string, suffix, sep = '_'):\\n if suffix == 'production':\\n suffixed = string\\n else:\\n suffixed = string + sep + suffix\\n return suffixed\",\n \"def suffix(self, suffix):\\n\\n self._suffix = suffix\",\n \"def suffix(self, suffix):\\n\\n self._suffix = suffix\",\n \"def suffix(self, suffix):\\n\\n self._suffix = suffix\",\n \"def suffix(self, suffix):\\n\\n self._suffix = suffix\",\n \"def verb_lemma(word):\\n if word.endswith(\\\"ed\\\"):\\n if word[:-2].endswith(\\\"v\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"at\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"it\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"et\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"ut\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"ac\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"i\\\"):\\n return word[:-3].lower() + \\\"y\\\"\\n elif word[:-2].endswith(\\\"ir\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"ag\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"nc\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n elif word[:-2].endswith(\\\"nu\\\"):\\n return word[:-2].lower() + \\\"e\\\"\\n else:\\n return word[:-2].lower() \\n elif word.endswith(\\\"ing\\\"):\\n if word[:-3].endswith(\\\"v\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"at\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"it\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"et\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"ut\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"ac\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"i\\\"):\\n return word[:-4].lower() + \\\"y\\\"\\n elif word[:-3].endswith(\\\"ir\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"ag\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"nc\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n elif word[:-3].endswith(\\\"nu\\\"):\\n return word[:-3].lower() + \\\"e\\\"\\n else:\\n return word[:-3].lower()\\n elif re.match(r\\\"(does|did|done)\\\", word):\\n return (\\\"do\\\")\\n elif re.match(r\\\"(is|are|am|was|will|were|been)\\\", word):\\n return (\\\"be\\\")\\n elif word == (\\\"'s\\\"):\\n return (\\\"be\\\")\\n elif re.match(r\\\"(had|has|'ve)\\\", word):\\n return (\\\"have\\\")\\n else:\\n return word.lower()\",\n \"def number_of_vowels(find_vowels):\\n v = [\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\", \\\"y\\\"]\\n new_vowels = find_vowels.lower()\\n vowels = \\\"\\\"\\n for x in new_vowels:\\n if x in v:\\n vowels += x\\n return len(vowels)\",\n \"def test_suffix():\\n transformer = hug.transform.suffix({\\\".js\\\": int, \\\".txt\\\": str})\\n\\n class FakeRequest(object):\\n path = \\\"hey.js\\\"\\n\\n request = FakeRequest()\\n assert transformer(\\\"1\\\", request) == 1\\n\\n request.path = \\\"hey.txt\\\"\\n assert transformer(2, request) == \\\"2\\\"\\n\\n request.path = \\\"hey.undefined\\\"\\n transformer({\\\"data\\\": \\\"value\\\"}, request) == {\\\"data\\\": \\\"value\\\"}\",\n \"def setSuffix(self, value):\\n return self._set(suffix=value)\",\n \"def reverse_vowels(s):\\n\\n vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}\\n vowel_indices = { i if s[i] in vowels else None for i in range(len(s)) }\\n vowel_indices = tuple(filter(lambda x: x != None, vowel_indices))\\n \\n new_str = \\\"\\\"\\n for i in range(len(s)):\\n if i in vowel_indices:\\n new_str += s[vowel_indices[-vowel_indices.index(i) - 1]]\\n else:\\n new_str += s[i]\\n return new_str\",\n \"def censor_vowels(word):\\n\\n chars = []\\n\\n for letter in word:\\n if letter in \\\"aeiou\\\":\\n chars.append(\\\"*\\\")\\n else:\\n chars.append(letter)\\n \\n return \\\"\\\".join(chars)\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def get_letter(self, vowel_need):\\r\\n\\r\\n return self.letters.get(vowel_need, self.vowels)\",\n \"def __truediv__(self, suffix: str) -> FSSpecTarget:\\n return replace(self, root_path=os.path.join(self.root_path, suffix))\",\n \"def get_suffix(cls, raw_disable: RawDisable) -> str:\\n variations = raw_disable.parent_test.variations\\n\\n maybe_variation_node = raw_disable.node.find(f'.//{cls.VARIATION_TAG}')\\n if maybe_variation_node is None:\\n return ''\\n\\n variation = maybe_variation_node.text\\n if variation not in variations:\\n raise DisableNodeProcessingException(f'could not find {variation!r} in defined variations; skipping node')\\n\\n idx = variations.index(variation)\\n suffix = f'_{idx}'\\n return suffix\",\n \"def is_english_vowel(c):\\n # y was included in the vowel set guided by the tests.\\n return c in 'aeiouyAEIOUY'\",\n \"def enc_suffix(suf):\\n if len(suf) == 0:\\n return 0\\n r0 = base34.find(suf[0])\\n if len(suf) == 1:\\n r1 = 0\\n else:\\n r1 = base34.find(suf[1]) + 1\\n if r0 < 24: # first char is a letter, use base 25\\n return r0 * 25 + r1 + 1\\n else: # first is a number -- base 35.\\n return r0 * 35 + r1 - 239\",\n \"def makePigLatin(word): \\n m = len(word)\\n vowels = \\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\", \\\"y\\\" \\n # short words are not converted \\n if m<3 or word==\\\"the\\\":\\n return word\\n else:\\n for i in vowels:\\n if word.find(i) < m and word.find(i) != -1:\\n m = word.find(i)\\n if m==0:\\n return word+\\\"way\\\" \\n else:\\n return word[m:]+word[:m]+\\\"ay\\\"\",\n \"def prefix_suffix_modify():\\n prefixes = \\\"JKLMNOPQ\\\"\\n suffix = \\\"ack\\\"\\n for letter in prefixes:\\n if letter == \\\"O\\\" or letter == \\\"Q\\\":\\n print(letter + \\\"u\\\" + suffix)\\n else:\\n print(letter + suffix)\",\n \"def SpecialCodes(self):\\n if sre.search(r\\\"[^aeiouy]e\\\\b\\\", self.wd): # nonsyllabic final e after C\\n if ((not self.isPlural or self.wd[-2] not in SIBILANTS) and\\n (not self.isPast or self.wd[-2] not in 'dt')):\\n self.wd = self.wd[:-1] + encode(self.wd[-1])\\n if not sre.search(r\\\"[aeiouy]\\\", self.wd): # any vowel left??\\n self.wd = self.wd[:-1] + 'e' # undo the encoding\\n self.wd = self.CiVcomb.sub(handleCiV, self.wd)\\n self.wd = self.CCpair.sub(handleCC, self.wd)\\n self.wd = self.VyVcomb.sub(handleVyV, self.wd)\",\n \"def _step1b(self, word):\\n # this NLTK-only block extends the original algorithm, so that\\n # 'spied'->'spi' but 'died'->'die' etc\\n if self.mode == self.NLTK_EXTENSIONS:\\n if word.endswith(\\\"ied\\\"):\\n if len(word) == 4:\\n return self._replace_suffix(word, \\\"ied\\\", \\\"ie\\\")\\n else:\\n return self._replace_suffix(word, \\\"ied\\\", \\\"i\\\")\\n\\n # (m>0) EED -> EE\\n if word.endswith(\\\"eed\\\"):\\n stem = self._replace_suffix(word, \\\"eed\\\", \\\"\\\")\\n if self._measure(stem) > 0:\\n return stem + \\\"ee\\\"\\n else:\\n return word\\n\\n rule_2_or_3_succeeded = False\\n\\n for suffix in [\\\"ed\\\", \\\"ing\\\"]:\\n if word.endswith(suffix):\\n intermediate_stem = self._replace_suffix(word, suffix, \\\"\\\")\\n if self._contains_vowel(intermediate_stem):\\n rule_2_or_3_succeeded = True\\n break\\n\\n if not rule_2_or_3_succeeded:\\n return word\\n\\n return self._apply_rule_list(\\n intermediate_stem,\\n [\\n (\\\"at\\\", \\\"ate\\\", None), # AT -> ATE\\n (\\\"bl\\\", \\\"ble\\\", None), # BL -> BLE\\n (\\\"iz\\\", \\\"ize\\\", None), # IZ -> IZE\\n # (*d and not (*L or *S or *Z))\\n # -> single letter\\n (\\n \\\"*d\\\",\\n intermediate_stem[-1],\\n lambda stem: intermediate_stem[-1] not in (\\\"l\\\", \\\"s\\\", \\\"z\\\"),\\n ),\\n # (m=1 and *o) -> E\\n (\\n \\\"\\\",\\n \\\"e\\\",\\n lambda stem: (self._measure(stem) == 1 and self._ends_cvc(stem)),\\n ),\\n ],\\n )\",\n \"def has_more_vowels(word):\\n\\n# If the phrase is over half vowels, it should return True:\\n\\n # intialize a vowel count variable \\n # Loop through the letters of the word:\\n # if the letter is in the set of vowels, increment the vowel count\\n # if vowel count is greater than length of the word divided by 2, return True\\n # else return false\\n\\n\\n vowel_count = 0\\n\\n for letter in word:\\n if letter.lower() in {\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\"}:\\n vowel_count += 1\\n\\n if vowel_count > (len(word) / 2):\\n return True\\n\\n return False\",\n \"def vowels(self):\\n vas = []\\n file = self.read()\\n words = re.sub(\\\"[aeiouAEIOU]\\\",\\\" \\\", file).split(\\\" \\\")\\n for h_u in words:\\n if h_u != \\\"\\\":\\n vas.append(h_u)\\n self.print(vas)\\n self.write(vas)\\n logging.debug(\\\"Starting with to\\\")\\n return vas\",\n \"def main():\\n word = input(\\\"Give me a word! \\\\n\\\\n\\\")\\n vowels = ['a', 'e', 'i', 'o', 'u']\\n if word[0].lower() in vowels:\\n print(f\\\"\\\\n\\\\nPig latin: {word}way\\\")\\n else:\\n print(f\\\"\\\\n\\\\nPig latin: {word[1:]}{word[0]}ay\\\")\",\n \"def wemo_entity_suffix_fixture():\\n return \\\"\\\"\",\n \"def removeVowels(self, S: str) -> str:\\n \\n vowel_list = ['a', 'e', 'i', 'o', 'u']\\n output = \\\"\\\"\\n \\n for letter in S:\\n \\n if letter not in vowel_list:\\n \\n output += letter\\n \\n else:\\n continue\\n \\n return output\",\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def doCombineCurEnd(self, endofword, nrc='', nextvowel=''): # nrc = next root consonant\\n if not self.end:\\n return\\n self.final = PhonStateCAT.getFinal(self.end)\\n nasalPhon = ''\\n postVowelPhon = ''\\n preVowelPhon = ''\\n # geminates\\n geminates = False\\n if self.end.startswith('w'):\\n preVowelPhon = 'w'\\n self.vowel = self.end[1:2]\\n else:\\n self.vowel = self.end[:1]\\n vowelPhon = self.vowel\\n if nrc == self.final and self.final != '':\\n geminates = True\\n if self.gemminatesStrategy == 'len' or self.gemminatesStrategy == 'lentone':\\n postVowelPhon = 'ː'\\n ## Suffix\\n finalPhon = ''\\n if self.final == 'ng':\\n nasalPhon = self.nasalchar # ?\\n if geminates:\\n pass\\n elif self.final in PhonStateCAT.simpleFinalMapping:\\n finalPhon = PhonStateCAT.simpleFinalMapping[self.final]\\n elif self.final == '':\\n if self.latent != '' and self.prefixStrategy != 'never' and (self.prefixSyllable == 'afterEmptyCoda' or self.prefixSyllable == 'afterEmptyCoda+'):\\n finalPhon = PhonStateCAT.simpleLatentMapping[self.latent]\\n finalPhon = ''\\n else:\\n print(\\\"unrecognized final: \\\"+self.final)\\n self.phon += preVowelPhon+vowelPhon+nasalPhon+postVowelPhon+finalPhon\\n if not endofword:\\n self.phon += self.syllablesepchar\",\n \"def new_end(self, end): \\n self.last_words.append(end)\",\n \"def endswith(self, suffix, start=0, end=None):\\n return endswith(self, suffix, start, end)\",\n \"def get_elb_name ( base_name, app_name ) :\\n max_len = 32\\n name = base_name + '-' + app_name.upper( ) + '-LB'\\n if len( name ) > max_len :\\n name = base_name + '-' + app_name.upper( )\\n if len( name ) > max_len :\\n raise NameError( 'ELB Name ' + name + ' exceeds limit of ' + str( max_len ) )\\n\\n return name\",\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 case_suffix(self, **case_kws):\\n if callable(self.output_suffix):\\n return self.output_suffix(**case_kws)\\n else:\\n return self.output_suffix.format(**case_kws)\",\n \"def disemvowel(string):\\n to_return = ''\\n for char in string:\\n if char not in 'aeiouAEIOU':\\n to_return += char\\n return to_return\",\n \"def pluralize(word):\\n\\n assert word\\n assert isinstance(word, basestring)\\n assert len(word) > 0\\n\\n second_last = word[-2]\\n last = word[-1]\\n if last in ['s', 'z','x']:\\n return word + \\\"es\\\"\\n elif last == 'h':\\n if second_last in ['s', 'c']:\\n return word + \\\"es\\\"\\n else:\\n return word + 's'\\n elif last == 'o':\\n if not _is_vowel(second_last):\\n return word + \\\"es\\\"\\n else: \\n return word + 's'\\n elif last == 'y':\\n if not _is_vowel(second_last):\\n return word[:-1] + \\\"ies\\\"\\n else:\\n return word + 's'\\n else:\\n return word + 's'\",\n \"def needs_aou(word):\\n return re.search(\\\"([aouAOU])[^yäöYÄÖ]*$\\\", word)\",\n \"def find_words_using_all_vowels():\\n pass\",\n \"def stem(self, word):\\n word = word.lower()\\n\\n step1_success = False\\n\\n # All acute accents are replaced by grave accents.\\n word = (word.replace(u(\\\"\\\\xE1\\\"), u(\\\"\\\\xE0\\\"))\\n .replace(u(\\\"\\\\xE9\\\"), u(\\\"\\\\xE8\\\"))\\n .replace(u(\\\"\\\\xED\\\"), u(\\\"\\\\xEC\\\"))\\n .replace(u(\\\"\\\\xF3\\\"), u(\\\"\\\\xF2\\\"))\\n .replace(u(\\\"\\\\xFA\\\"), u(\\\"\\\\xF9\\\")))\\n\\n # Every occurrence of 'u' after 'q'\\n # is put into upper case.\\n for i in range(1, len(word)):\\n if word[i - 1] == \\\"q\\\" and word[i] == \\\"u\\\":\\n word = \\\"\\\".join((word[:i], \\\"U\\\", word[i + 1:]))\\n\\n # Every occurrence of 'u' and 'i'\\n # between vowels is put into upper case.\\n for i in range(1, len(word) - 1):\\n if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:\\n if word[i] == \\\"u\\\":\\n word = \\\"\\\".join((word[:i], \\\"U\\\", word[i + 1:]))\\n elif word[i] == \\\"i\\\":\\n word = \\\"\\\".join((word[:i], \\\"I\\\", word[i + 1:]))\\n\\n r1, r2 = self._r1r2_standard(word, self.__vowels)\\n rv = self._rv_standard(word, self.__vowels)\\n\\n # STEP 0: Attached pronoun\\n for suffix in self.__step0_suffixes:\\n if rv.endswith(suffix):\\n if rv[-len(suffix) - 4:-len(suffix)] in (\\\"ando\\\", \\\"endo\\\"):\\n word = word[:-len(suffix)]\\n r1 = r1[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n rv = rv[:-len(suffix)]\\n\\n elif (rv[-len(suffix) - 2:-len(suffix)] in\\n (\\\"ar\\\", \\\"er\\\", \\\"ir\\\")):\\n word = \\\"\\\".join((word[:-len(suffix)], \\\"e\\\"))\\n r1 = \\\"\\\".join((r1[:-len(suffix)], \\\"e\\\"))\\n r2 = \\\"\\\".join((r2[:-len(suffix)], \\\"e\\\"))\\n rv = \\\"\\\".join((rv[:-len(suffix)], \\\"e\\\"))\\n break\\n\\n # STEP 1: Standard suffix removal\\n for suffix in self.__step1_suffixes:\\n if word.endswith(suffix):\\n if suffix == \\\"amente\\\" and r1.endswith(suffix):\\n step1_success = True\\n word = word[:-6]\\n r2 = r2[:-6]\\n rv = rv[:-6]\\n\\n if r2.endswith(\\\"iv\\\"):\\n word = word[:-2]\\n r2 = r2[:-2]\\n rv = rv[:-2]\\n\\n if r2.endswith(\\\"at\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif r2.endswith((\\\"os\\\", \\\"ic\\\")):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif r2 .endswith(\\\"abil\\\"):\\n word = word[:-4]\\n rv = rv[:-4]\\n\\n elif (suffix in (\\\"amento\\\", \\\"amenti\\\",\\n \\\"imento\\\", \\\"imenti\\\") and\\n rv.endswith(suffix)):\\n step1_success = True\\n word = word[:-6]\\n rv = rv[:-6]\\n\\n elif r2.endswith(suffix):\\n step1_success = True\\n if suffix in (\\\"azione\\\", \\\"azioni\\\", \\\"atore\\\", \\\"atori\\\"):\\n word = word[:-len(suffix)]\\n r2 = r2[:-len(suffix)]\\n rv = rv[:-len(suffix)]\\n\\n if r2.endswith(\\\"ic\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif suffix in (\\\"logia\\\", \\\"logie\\\"):\\n word = word[:-2]\\n rv = word[:-2]\\n\\n elif suffix in (\\\"uzione\\\", \\\"uzioni\\\",\\n \\\"usione\\\", \\\"usioni\\\"):\\n word = word[:-5]\\n rv = rv[:-5]\\n\\n elif suffix in (\\\"enza\\\", \\\"enze\\\"):\\n word = \\\"\\\".join((word[:-2], \\\"te\\\"))\\n rv = \\\"\\\".join((rv[:-2], \\\"te\\\"))\\n\\n elif suffix == u(\\\"it\\\\xE0\\\"):\\n word = word[:-3]\\n r2 = r2[:-3]\\n rv = rv[:-3]\\n\\n if r2.endswith((\\\"ic\\\", \\\"iv\\\")):\\n word = word[:-2]\\n rv = rv[:-2]\\n\\n elif r2.endswith(\\\"abil\\\"):\\n word = word[:-4]\\n rv = rv[:-4]\\n\\n elif suffix in (\\\"ivo\\\", \\\"ivi\\\", \\\"iva\\\", \\\"ive\\\"):\\n word = word[:-3]\\n r2 = r2[:-3]\\n rv = rv[:-3]\\n\\n if r2.endswith(\\\"at\\\"):\\n word = word[:-2]\\n r2 = r2[:-2]\\n rv = rv[:-2]\\n\\n if r2.endswith(\\\"ic\\\"):\\n word = word[:-2]\\n rv = rv[:-2]\\n else:\\n word = word[:-len(suffix)]\\n rv = rv[:-len(suffix)]\\n break\\n\\n # STEP 2: Verb suffixes\\n if not step1_success:\\n for suffix in self.__step2_suffixes:\\n if rv.endswith(suffix):\\n word = word[:-len(suffix)]\\n rv = rv[:-len(suffix)]\\n break\\n\\n # STEP 3a\\n if rv.endswith((\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", u(\\\"\\\\xE0\\\"), u(\\\"\\\\xE8\\\"),\\n u(\\\"\\\\xEC\\\"), u(\\\"\\\\xF2\\\"))):\\n word = word[:-1]\\n rv = rv[:-1]\\n\\n if rv.endswith(\\\"i\\\"):\\n word = word[:-1]\\n rv = rv[:-1]\\n\\n # STEP 3b\\n if rv.endswith((\\\"ch\\\", \\\"gh\\\")):\\n word = word[:-1]\\n\\n word = word.replace(\\\"I\\\", \\\"i\\\").replace(\\\"U\\\", \\\"u\\\")\\n return word\",\n \"def normalize_suffix_0(string, logger_=_LOGGER):\\n if re.search(\\\"_[A-Z]{1,}$\\\", string):\\n return string\\n numbers = re.search(\\\"[0-9]{1,}$\\\", string)\\n if numbers:\\n logger.log(\\n level=\\\"warning\\\",\\n message='Suffix of string \\\"'\\n + string\\n + '\\\" should not have a number. Numbers removed from the suffix',\\n logger=logger_,\\n )\\n instance = numbers.group(0)\\n string = string[0 : string.find(instance)]\\n lower_case = re.search(\\\"_[a-z]{1,}$\\\", string)\\n if lower_case:\\n instance_ = lower_case.group(0)\\n string = string[0 : string.find(instance_)] + instance_.upper()\\n return string\",\n \"def add_word(self, word):\\n word = self.map_word(word)\\n super(InvariantLanguage, self).add_word(word)\",\n \"def inner(word):\\n return word + '!!!'\",\n \"def pig_latinify(word):\\n\\n first_letter = word[0]\\n\\n if first_letter in VOWELS:\\n output_word = word + \\\"yay\\\"\\n else:\\n #scan for vowel if word starts with a consonant\\n for i in range(len(word)):\\n individual_letter = word[i]\\n if individual_letter in VOWELS:\\n output_word = word[i:] + word[:i] + \\\"ay\\\"\\n break\\n else:\\n continue\\n\\n return output_word\",\n \"def pig_latinify(word):\\n result = \\\"\\\"\\n if len(word) > 0 and word.isalpha():\\n first = word[0]\\n if is_vowel(first): # starts with a vowel\\n result = str(word) + \\\"yay\\\"\\n else: # starts with non-vowel\\n cut = position_of_vowel(word) # where to cut the word\\n if cut > 0: # \\\"street\\\"-->\\\"eet+str+ay\\\"\\n result = word[cut:] + word[:cut] + \\\"ay\\\"\\n else: # no vowel found\\n result = word + \\\"ay\\\"\\n else:\\n result = 'Only letters allowed!'\\n\\n return result\",\n \"def fry(word):\\n\\n # looks for a Y or y which will be (captured) followed and ended by an 'ou'\\n match_you = re.match('([Yy])ou$', word)\\n\\n # First group will be the (captured) group so either 'Y' or 'y'\\n if match_you:\\n return match_you.group(1) + \\\"'all\\\"\\n\\n # looks for anyword ending in 'ing'\\n match_ing = re.search('(.+)ing$', word)\\n\\n # checks if vowel exists before the 'ing'\\n if match_ing:\\n vowel_check = re.search('[aeiouy]', match_ing.group(1))\\n # First group will be the (captured) group so everything before the 'ing'\\n if vowel_check:\\n return match_ing.group(1) + \\\"in'\\\"\\n\\n return word\",\n \"def _rv_standard(self, word, vowels):\\n rv = \\\"\\\"\\n if len(word) >= 2:\\n if word[1] not in vowels:\\n for i in range(2, len(word)):\\n if word[i] in vowels:\\n rv = word[i + 1 :]\\n break\\n\\n elif word[0] in vowels and word[1] in vowels:\\n for i in range(2, len(word)):\\n if word[i] not in vowels:\\n rv = word[i + 1 :]\\n break\\n else:\\n rv = word[3:]\\n\\n return rv\",\n \"def add_suffix(self, suffix, axis=1):\\n return DataFrameDefault.register(pandas.DataFrame.add_suffix)(\\n self, suffix=suffix, axis=axis\\n )\",\n \"def generate_syllable():\\n return generate_vowel() + generate_consonant()\",\n \"def indefinite(self):\\n return \\\"an\\\" if self.short_desc[0] in 'aeiou' else \\\"a\\\"\",\n \"def _contains_vowel(self, stem):\\n for i in range(len(stem)):\\n if not self._is_consonant(stem, i):\\n return True\\n return False\",\n \"def replace_end(s, old, new):\\n assert s.endswith(old)\\n return s[:-len(old)] + new\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5983021","0.5954164","0.59408945","0.5778313","0.5686185","0.5563964","0.5542913","0.55272454","0.54683185","0.5462567","0.54531056","0.5446963","0.54377186","0.5427365","0.53498006","0.53402376","0.53384125","0.5302798","0.52940315","0.5291557","0.52781844","0.52564484","0.52411693","0.52356154","0.5230086","0.5162771","0.51485455","0.5136728","0.5126367","0.5126245","0.5104269","0.5102299","0.5078848","0.50750136","0.50700855","0.50556964","0.5021987","0.49928167","0.4991532","0.4985778","0.4983493","0.49590418","0.49586567","0.495339","0.4941221","0.4928155","0.49269378","0.49256873","0.49254015","0.4920181","0.4920181","0.4920181","0.4920181","0.49141145","0.49087605","0.4902713","0.48902482","0.48665494","0.48587644","0.4858456","0.4858456","0.48572665","0.48561782","0.48515445","0.4845795","0.48441982","0.48420036","0.4837805","0.4836","0.48341617","0.48317844","0.48309174","0.48286653","0.48268256","0.48185936","0.47931543","0.47931543","0.47825304","0.47690168","0.4765036","0.47566208","0.4739206","0.47327724","0.47315034","0.47208524","0.4717525","0.47173312","0.47143188","0.47121692","0.47055966","0.4692895","0.46915162","0.4690172","0.46891174","0.46856782","0.4678084","0.46711275","0.46709234","0.4668408","0.46626365"],"string":"[\n \"0.5983021\",\n \"0.5954164\",\n \"0.59408945\",\n \"0.5778313\",\n \"0.5686185\",\n \"0.5563964\",\n \"0.5542913\",\n \"0.55272454\",\n \"0.54683185\",\n \"0.5462567\",\n \"0.54531056\",\n \"0.5446963\",\n \"0.54377186\",\n \"0.5427365\",\n \"0.53498006\",\n \"0.53402376\",\n \"0.53384125\",\n \"0.5302798\",\n \"0.52940315\",\n \"0.5291557\",\n \"0.52781844\",\n \"0.52564484\",\n \"0.52411693\",\n \"0.52356154\",\n \"0.5230086\",\n \"0.5162771\",\n \"0.51485455\",\n \"0.5136728\",\n \"0.5126367\",\n \"0.5126245\",\n \"0.5104269\",\n \"0.5102299\",\n \"0.5078848\",\n \"0.50750136\",\n \"0.50700855\",\n \"0.50556964\",\n \"0.5021987\",\n \"0.49928167\",\n \"0.4991532\",\n \"0.4985778\",\n \"0.4983493\",\n \"0.49590418\",\n \"0.49586567\",\n \"0.495339\",\n \"0.4941221\",\n \"0.4928155\",\n \"0.49269378\",\n \"0.49256873\",\n \"0.49254015\",\n \"0.4920181\",\n \"0.4920181\",\n \"0.4920181\",\n \"0.4920181\",\n \"0.49141145\",\n \"0.49087605\",\n \"0.4902713\",\n \"0.48902482\",\n \"0.48665494\",\n \"0.48587644\",\n \"0.4858456\",\n \"0.4858456\",\n \"0.48572665\",\n \"0.48561782\",\n \"0.48515445\",\n \"0.4845795\",\n \"0.48441982\",\n \"0.48420036\",\n \"0.4837805\",\n \"0.4836\",\n \"0.48341617\",\n \"0.48317844\",\n \"0.48309174\",\n \"0.48286653\",\n \"0.48268256\",\n \"0.48185936\",\n \"0.47931543\",\n \"0.47931543\",\n \"0.47825304\",\n \"0.47690168\",\n \"0.4765036\",\n \"0.47566208\",\n \"0.4739206\",\n \"0.47327724\",\n \"0.47315034\",\n \"0.47208524\",\n \"0.4717525\",\n \"0.47173312\",\n \"0.47143188\",\n \"0.47121692\",\n \"0.47055966\",\n \"0.4692895\",\n \"0.46915162\",\n \"0.4690172\",\n \"0.46891174\",\n \"0.46856782\",\n \"0.4678084\",\n \"0.46711275\",\n \"0.46709234\",\n \"0.4668408\",\n \"0.46626365\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7781676"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":33,"numItemsPerPage":100,"numTotalItems":95772,"offset":3300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzcxNTMzNiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM3MTg5MzYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.iA7nFCq1rkVf4HFYHWMwINQJg0eV98CZLHVH4xLdc4FnDClU8sXQGhGyFiAJ-NFgdB2PJ5L7Fu2NtF3EuLQhAw","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 the plate scale as an `~astropy.units.Quantity`. | def plate_scale(self):
return 206265 * uu.arcsec / (self.diameter.to('mm') * self.f) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale(self):\n return self.scale_factor / CONSTANTS.AU",
"def getScale(self):\n return _libsbml.Unit_getScale(self)",
"def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")",
"def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")",
... | [
"0.7407171",
"0.73354304",
"0.7272574",
"0.7260109",
"0.72580636",
"0.71984255",
"0.7091628",
"0.7008195",
"0.69788766",
"0.6805889",
"0.6759866",
"0.67273027",
"0.67187494",
"0.6713132",
"0.6710965",
"0.6695409",
"0.6635227",
"0.6599181",
"0.65680814",
"0.6560833",
"0.656083... | 0.7882506 | 0 |
Identifies genes that are significantly enriched for insertions (CTGs). This function takes a DataFrame of insertions, coming from multiple samples, and identifies if any genes are more frequently affected by an insertion than would be expected by chance. These genes are called Commonly Targeted Genes (CTGs). CTGs are selected by comparing the number of insertions within the gene to the number of insertions that would be expected from the background insertion rate, which is modeled using a Poisson distribution. | def test_ctgs(
insertions, # type: List[Insertion]
reference, # type: Reference
gene_ids=None, # type: Set[str]
chromosomes=None, # type: Set[str]
pattern=None, # type: str
per_sample=True, # type: bool
window=None #type: Tuple[int, int]
):
# Default to shared chromosome sequences (typically drops some
# of the more esoteric extra scaffold/patch sequences).
if chromosomes is None:
reference_seq = pyfaidx.Fasta(str(reference.fasta_path))
reference_gtf = GtfIterator(reference.indexed_gtf_path)
chromosomes = list(
set(reference_seq.keys()) & set(reference_gtf.contigs))
if len(chromosomes) == 0:
ValueError('No chromosomes are shared between the reference '
'sequence and reference gtf files')
if len(chromosomes) == 0:
raise ValueError('At least one chromosome must be given')
# Determine gene windows using GTF.
logging.info('Generating gene windows')
gene_windows = _build_gene_windows(
reference.indexed_gtf_path, window=window, chromosomes=chromosomes)
# Subset insertions to gene intervals.
insertions = _subset_to_windows(insertions, gene_windows)
if gene_ids is None:
gene_ids = set(ins.metadata['gene_id'] for ins in insertions)
# Collapse insertions per gene/sample (recommended).
# Corrects for hopping/multiple detection issues.
if per_sample:
logging.info('Collapsing insertions')
insertions = list(_collapse_per_sample(insertions))
# Calculate total number of pattern occurrences within intervals.
logging.info('Counting pattern occurrences')
reference_seq = pyfaidx.Fasta(str(reference.fasta_path))
total = count_total(
reference_seq, pattern=pattern, intervals=gene_windows.values())
# Calculate p-values for each gene.
logging.info('Calculating significance for genes')
insertion_trees = GenomicIntervalTree.from_objects_position(
insertions, chrom_attr='seqname')
p_values = {
gene_id: test_region(
insertions=insertions,
reference_seq=reference_seq,
region=gene_windows[gene_id],
total=total,
pattern=pattern,
filters=[lambda ins, gid=gene_id: ins.metadata['gene_id'] == gid],
insertion_trees=insertion_trees)
for gene_id in gene_ids
}
# Build result frame.
result = pd.DataFrame.from_records(
iter(p_values.items()), columns=['gene_id', 'p_value'])
# Calculate corrected p-value using bonferroni correction.
result['q_value'] = (result['p_value'] * len(result)).clip_upper(1.0)
# Sort by q-value and p-value.
result.sort_values(by=['q_value', 'p_value'], inplace=True)
if len(insertions) > 0:
# Annotate with gene_name if possible.
if 'gene_name' in insertions[0].metadata:
name_map = {
ins.metadata['gene_id']: ins.metadata['gene_name']
for ins in insertions
}
result.insert(1, 'gene_name', result['gene_id'].map(name_map))
else:
result['gene_name'] = np.nan
# Annotate with frequency.
frequency = (Insertion.to_frame(insertions)
.groupby('gene_id')['sample'].nunique()
.reset_index(name='n_samples'))
result = pd.merge(result, frequency, on='gene_id', how='left')
else:
result['gene_name'] = np.nan
result['n_samples'] = np.nan
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def genes_GT():\n df1=pd.read_csv(config['geneInfo'], sep=\" \")\n df1=df1[df1.chr == '22']\n df2=pd.read_csv(config['counts'], sep=\" \")\n genes=df1.merge(df2.gene_id, on=\"gene_id\")\n return list(set(genes['gene_id']))",
"def process_cgc(path, return_dataframe=False, fusions=False):\n # rea... | [
"0.62168896",
"0.5950708",
"0.5604085",
"0.5591386",
"0.5474958",
"0.54715043",
"0.5465627",
"0.5456833",
"0.535208",
"0.5323605",
"0.5284358",
"0.52755475",
"0.5262531",
"0.52539337",
"0.52331626",
"0.520046",
"0.5148381",
"0.507968",
"0.5076866",
"0.5065854",
"0.5053424",
... | 0.6928965 | 0 |
Subsets insertions for given gene windows. | def _subset_to_windows(
insertions, # type: List[Insertion]
gene_windows # type: Dict[str, Tuple[str, int, int]]
): # type: (...) -> List[Insertion]
# Create lookup trees.
trees = {
chrom: IntervalTree.from_tuples((i[1:]) for i in chrom_int)
for chrom, chrom_int in itertools.groupby(
sorted(gene_windows.values()), operator.itemgetter(0))
}
# Determine which insertions overlap tree intervals and
# correspond to genes with known gene window.
def _in_windows(ins, trees):
try:
return trees[ins.seqname].overlaps(ins.position)
except KeyError:
return False
return [
ins for ins in insertions
if ins.metadata['gene_id'] in gene_windows and _in_windows(ins, trees)
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_windows(sliding_windows_file, genes_file, output_file):\n\n\t# Read sliding windows file and create a list in the form\n\t# genes = [('gene1', 1000, 2000), ('gene2', 4000, 45000)]\n\tgenes = []\t\t# this could be a dictionary but I prefer not\n\tfor line in genes_file:\n\t\tline = line.strip()\n\n\t\ti... | [
"0.5770418",
"0.53267133",
"0.52984023",
"0.51812553",
"0.51691467",
"0.51118696",
"0.5079057",
"0.50481063",
"0.50467324",
"0.5036095",
"0.50196743",
"0.50149506",
"0.49723238",
"0.49606135",
"0.49236315",
"0.49137327",
"0.48717156",
"0.48612767",
"0.48102915",
"0.48091227",
... | 0.7655855 | 0 |
Tests a given genomic region for enrichment in insertions. | def test_region(
insertions, # type: List[Insertion]
reference_seq, # type: pyfaidx.Fasta
region, # type: Tuple[str, int, int]
pattern=None, # type: Optional[str]
intervals=None, # type: Optional[Iterable[Tuple[str, int, int]]]
total=None, # type: Optional[int]
filters=None, # type: Optional[List[Callable]]
insertion_trees=None # type: GenomicIntervalTree
): # type: (...) -> float
if total is None:
total = count_total(
reference_seq, pattern=pattern, intervals=intervals)
# Count pattern in region.
region_count = count_region(reference_seq, region=region, pattern=pattern)
# Sub-select insertions for region.
if insertion_trees is None:
insertion_trees = GenomicIntervalTree.from_objects_position(
insertions, chrom_attr='seqname')
region_ins = set(interval[2]
for interval in insertion_trees.search(*region))
# Apply additional filter functions to insertions if given
# (such as filtering on gene name/id for example).
if filters is not None:
for filter_func in filters:
region_ins = set(ins for ins in region_ins if filter_func(ins))
# Calculate p-value.
x = len(list(region_ins))
mu = len(insertions) * (region_count / total)
# Note here we use loc=1, because we are interested in
# calculating P(X >= x), not P(X > x) (the default
# surivival function).
p_val = poisson.sf(x, mu=mu, loc=1) # type: float
return p_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_build_genomic_regions(self):\n\n CDS = pybedtools.BedTool(\"\"\"chr1\\t7700\\t7900\\tfoo\\t0\\t+\\n\n chr1\\t7999\\t8500\\tfoo\\t0\\t+\\n\"\"\", from_string = True)\n UTR5 = pybedtools.BedTool(\"\"\"chr1\\t7499\\t7700\\tfoo\\t0\\t+\\n\"\"\", from_string = Tr... | [
"0.6306166",
"0.5873809",
"0.5715272",
"0.5644633",
"0.5633991",
"0.5508607",
"0.55017656",
"0.5482008",
"0.53994864",
"0.53851366",
"0.53696203",
"0.53695005",
"0.53581506",
"0.5352486",
"0.5298148",
"0.5286712",
"0.52787757",
"0.5276704",
"0.52690274",
"0.5268633",
"0.52497... | 0.6274175 | 1 |
Counts occurrences of pattern within given genomic region. | def count_region(
reference_seq, # type: pyfaidx.Fasta
region, # type: Tuple[str, int, int]
pattern=None # type: Optional[str]
): # type: (...) -> int
chrom, start, end = region
seq = reference_seq[chrom][int(start):int(end)]
return _count_sequence(seq, regex=_build_regex(pattern)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(pattern, string, overlapping=True, sensitive=True, regexp=False):\n return len(SE.findall(pattern, string, overlapping, sensitive, regexp))",
"def pattern_count(DNA, pattern, start=0, end=0, mutation_thresh=0):\n if start < 0 or start >= len(DNA):\n raise ValueError(\"The starting posi... | [
"0.690619",
"0.6891801",
"0.6734169",
"0.661228",
"0.64735407",
"0.64611524",
"0.645101",
"0.6441295",
"0.643269",
"0.63974696",
"0.6269934",
"0.6190485",
"0.61015546",
"0.5953266",
"0.5953266",
"0.58486587",
"0.57067573",
"0.56916803",
"0.56484526",
"0.56377214",
"0.56303567... | 0.7694619 | 0 |
Counts occurrences of pattern in sequence. | def _count_sequence(sequence, regex=None):
# type: (pyfaidx.Sequence, Pattern[str]) -> int
if regex is None:
count = len(sequence)
else:
count = sum((1 for _ in regex.finditer(str(sequence))))
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pattern_count(sequence, pattern):\n return len(re.findall(r'(?=' + pattern + ')', sequence))",
"def count_pattern(sentence, pattern):\n n = len(pattern)\n counter = 0\n for i in range(len(sentence) - n + 1):\n if sentence[i:i+n] == pattern:\n counter += 1\n\n return count... | [
"0.8225791",
"0.757032",
"0.74906814",
"0.7362785",
"0.7350869",
"0.73212504",
"0.7278474",
"0.7140979",
"0.707895",
"0.6971106",
"0.6928305",
"0.6643842",
"0.65604806",
"0.64908123",
"0.6395848",
"0.6317644",
"0.6313916",
"0.6293871",
"0.62750435",
"0.62558323",
"0.6236206",... | 0.76051104 | 1 |
Counts total occurrences of pattern in reference. | def count_total(
reference_seq, # type: pyfaidx.Sequence
pattern=None, # type: str
intervals=None # type: Iterable[Tuple[str, int, int]]
): # type: (...) -> int
regex = _build_regex(pattern)
if intervals is None:
# Simply count for the entire sequence.
count = sum(_count_sequence(reference_seq[seq], regex=regex)
for seq in reference_seq.keys()) # yapf: disable
else:
# Flatten intervals, and then only count for sequences
# within the flattened intervals.
merged_intervals = list(merge_genomic_intervals(intervals))
seqs = [
reference_seq[chrom][start:end]
for chrom, start, end in merged_intervals
]
count = sum(_count_sequence(seq, regex=regex) for seq in seqs)
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CountOccurrences(pattern, bwt, starts, occ_counts_before):\n # Implement this function yourself\n return 0",
"def count_occurrences(text, pattern, d=0):\n return len(find_occurrences(text, pattern, d))",
"def calculate_reference(gram_list, references):\n gram_sub_str = ' '.join(gram_list)\n gram... | [
"0.71985865",
"0.7126463",
"0.693929",
"0.6936579",
"0.6664656",
"0.6643048",
"0.6616412",
"0.65986395",
"0.65699697",
"0.6548704",
"0.644031",
"0.6386957",
"0.63118064",
"0.6282825",
"0.6272797",
"0.6222616",
"0.6174506",
"0.61413646",
"0.60996157",
"0.6062659",
"0.606119",
... | 0.68921715 | 4 |
Merges overlapping genomic intervals. | def merge_genomic_intervals(intervals):
# type: (Iterable[Tuple[str, int, int]]) -> Iterable[Tuple[str, int, int]]
# Group intervals by chromosome.
grouped_intervals = itertools.groupby(
sorted(intervals), operator.itemgetter(0))
# Now yield merged intervals per chromosome.
for chrom, grp in grouped_intervals:
chrom_intervals = [interval[1:] for interval in grp]
for low, high in merge_intervals(chrom_intervals, is_sorted=True):
yield chrom, low, high | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_ranges():",
"def test_merge_intervals():\n\n a = pybedtools.example_bedtool(\"a.bed\") # path to test file a\n # This file looks like this:\n # chr1\t1\t100\tfeature1\t0\t+\n # chr1\t100\t200\tfeature2\t0\t+\n # chr1\t150\t500\tfeature3\t0\t-\n # chr1 900\t950\tfeature4\t0\t+\n\n ... | [
"0.75773865",
"0.6600593",
"0.6574509",
"0.6569135",
"0.63968265",
"0.63313943",
"0.6322615",
"0.624788",
"0.6216611",
"0.6146239",
"0.6133331",
"0.60140103",
"0.60021335",
"0.59763306",
"0.5970033",
"0.58648163",
"0.58545077",
"0.57922995",
"0.57907534",
"0.57814354",
"0.572... | 0.6790975 | 1 |
Read file into string. | def read_file(self, file: Path) -> str:
with open(file) as f:
return f.read() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_file(file):\n with open(file, 'r') as f:\n file_string = f.read()\n return file_string",
"def read_file(path): #TODO implementme, handling paths more intelligently\n f = open(path, \"r\")\n string = f.read()\n f.close()\n return string",
"def file2str(file):\n with open(file, \"r\"... | [
"0.8227773",
"0.81447333",
"0.8022711",
"0.79404026",
"0.7933046",
"0.78936315",
"0.78294694",
"0.7784561",
"0.7775774",
"0.7751609",
"0.77187586",
"0.7716427",
"0.77023",
"0.76969075",
"0.76942647",
"0.7690147",
"0.7679615",
"0.7668749",
"0.76600176",
"0.7641418",
"0.7638525... | 0.7827757 | 7 |
Create a new websocket and connect its input and output to the subprocess with the specified PID. | async def websocket_handler(self, request, ws):
if self.repl_mgr is None:
return sanic.response.HTTPResponse(status=404)
log.info('initiating websocket')
await self.repl_mgr.process_websocket(ws)
log.info('terminating websocket') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def launch_web_socket(vnc_port, web_socket_port, server):\n\n path = os.path.abspath(os.path.dirname(__file__))\n ws = os.path.join(path, \"../../webConsole/bin/websockify.py\")\n\n web_socket_path = os.path.abspath(ws)\n\n cmd = \"%s %s:%s %s:%s --idle-timeout=120 &\" % (web_socket_path, server, vnc_p... | [
"0.61489266",
"0.6004585",
"0.58952093",
"0.5711386",
"0.56981546",
"0.5681631",
"0.5521888",
"0.55072397",
"0.5495588",
"0.54655325",
"0.5456767",
"0.5442702",
"0.539571",
"0.53936225",
"0.5373037",
"0.5360796",
"0.53407484",
"0.53166866",
"0.52801496",
"0.5262081",
"0.52579... | 0.0 | -1 |
opener for opening sheets for client stock company name (e.g AAPL for apple inc.) name name of the sheet (e.g 'income' / 'balace'), use sheets_names() to see all names returns a csv sheet of the sheet of the company | def open_file(stock, name, setup=False):
if not isinstance(stock, str):
raise TypeError("Parameter 'stock' should be a string, not a "
+ type(stock).__name__)
if setup is True: # when setup, name is "AAPL_income.csv", not "income"
# path = _os.path.join(datapath(setup=False), stock, name)
path = datapath(True, stock, name)
df = _pd.read_csv(path)
_gc.collect()
return df
# not setup, normal open_file
names = ['major_holders', 'top_institutional_holders', 'top_mutual_fund_holders',
'Trading_Information', 'Financial_Highlights', 'Valuation_Measures',
'Executives', 'Description',
'Earnings_Estimate', 'Revenue_Estimate', 'Earnings_History',
'EPS_Trend', 'EPS_Revisions', 'Growth_Estimates',
'stats', 'statements', 'reports',
'Executives', 'Description', 'analysis', 'Summary',
'balance', 'cash_flow', 'income']
if name not in names:
try:
name = _path(name) # when client mistakenly input factor instead of sheet name
except ValueError:
raise ValueError(
'Parameter "name" should be the name of the financial sheets, not a factor name...Use path method to '
'find the location of a factor')
path = datapath(True, stock, stock)
try:
df = _pd.read_csv(path + '_' + name + '.csv')
_gc.collect()
except FileNotFoundError:
_gc.collect()
if _os.path.exists(datapath(True, stock)):
raise ValueError("There is no sheet - {} - for company {}. Use main_get to retrieve the sheet".format
(name, stock))
else:
raise ValueError("There is no record of '" + stock + "' in database")
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def excel(df_ccl, df_arg_stocks, df_bonds, df_arg_stocks_ccl):\n if os.path.exists('CCL.xlsx'):\n wb = xw.Book('CCL.xlsx')\n # SHEET CEDEARS\n ws = wb.sheets('CCL CEDEARs')\n ws.range('A1').expand().value = df_ccl\n # SHEET MERVAL\n ws_merval = wb.sheets('Merval')\n ... | [
"0.5797708",
"0.5627527",
"0.55049616",
"0.547899",
"0.5430646",
"0.53921485",
"0.53507286",
"0.531778",
"0.5266958",
"0.52605325",
"0.5259202",
"0.52366793",
"0.52347517",
"0.5210146",
"0.5195938",
"0.51869226",
"0.51795375",
"0.5152984",
"0.51428926",
"0.51320624",
"0.51209... | 0.5508073 | 2 |
Read CSV in folder "general" in database. Also used in setup.py | def open_general(file, setup=False):
try:
if setup is False:
p = datapath(True, 'general', file)
df = _pd.read_csv(p + '.csv')
elif setup is True:
p = datapath(True, 'general', file)
df = _pd.read_csv(p + '.py')
else:
df = None # not tested here
return df
except FileNotFoundError as e:
print("There is no record of {} in your database. Go to your chosen setup path to check, if not there go to "
"Github and download the missing sheet".format(file))
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv():",
"def getFake(directory=\"../FakeRealNews/Data\"):\r\n return pd.read_csv(directory + \"/Fake.csv\")",
"def read_csv_file(self):\n pass",
"def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file... | [
"0.6300106",
"0.61802393",
"0.6075419",
"0.60727006",
"0.606177",
"0.6019453",
"0.5933561",
"0.58593744",
"0.5730161",
"0.5652817",
"0.56373644",
"0.5618824",
"0.55967456",
"0.5585875",
"0.55683404",
"0.5567126",
"0.5550129",
"0.5536807",
"0.55361545",
"0.55278426",
"0.550909... | 0.65410346 | 0 |
Read the stock list in database, a wrap up of open_general. Open stock list files in database using open_general() function. | def open_stock_list(exchange='ALL'):
if exchange not in ['NYSE', 'NASDAQ'] and exchange != 'ALL':
raise ValueError("Parameter 'exchange' should either NYSE or NASDAQ")
if exchange == 'ALL': # all tickets
c1 = open_general('NASDAQ')
c2 = open_general('NYSE')
df = _pd.concat([c1, c2], ignore_index=True).drop('Unnamed: 9', axis=1) # drop duplicated column
else:
_csv = open_general(exchange)
df = _csv.drop('Unnamed: 9', axis=1)
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_stock(db, openfile):\n pass",
"def read_stock_codes_from_db():\n\n print('connecting to database...')\n Stocks = get_db()['Stocks']\n print('reading...')\n\n stocks = Stocks.find()\n return stocks",
"def database_open(self):\n\t\n\t\tfilename = tkFileDialog.askopenfilename(multiple=F... | [
"0.8676556",
"0.6498297",
"0.6392442",
"0.62527007",
"0.6116841",
"0.6115268",
"0.60903823",
"0.6079111",
"0.605728",
"0.60320973",
"0.59506726",
"0.58965456",
"0.58925784",
"0.58342135",
"0.581336",
"0.57088405",
"0.5691312",
"0.56265354",
"0.56252694",
"0.5618806",
"0.56076... | 0.6232286 | 4 |
Determines whether the discrepancy has been sufficiently resolved; used as return value for fix_discrepancy. | def discrepancy_resolved(self):
# If there's a discrepancy and distance change matches the existing data, we're good.
if self.distance_change == self.existing_data:
return True
# If recommend_updates, i.e., if self.distance_change == self.new_data, we'll update the data and we're good
elif self.recommend_updates:
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_solved(self):\n if not self._find_empty():\n return True\n else:\n return False",
"def is_solved(self):\n\n marker = self._marker\n amount_of_pegs = 0\n for row in marker:\n for i in row:\n if i == \"*\":\n ... | [
"0.6593381",
"0.622655",
"0.62037015",
"0.6201302",
"0.6191842",
"0.61888754",
"0.60700476",
"0.6044539",
"0.6014487",
"0.6009676",
"0.5961862",
"0.5950892",
"0.5950892",
"0.59451425",
"0.5910703",
"0.58750445",
"0.5857207",
"0.582537",
"0.5819653",
"0.580809",
"0.5805597",
... | 0.7586293 | 0 |
Run when the palette is closed | def on_palette_close(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notify(self, args):\r\n try:\r\n self.cmd_object_.on_palette_close()\r\n\r\n except:\r\n app = adsk.core.Application.cast(adsk.core.Application.get())\r\n ui = app.userInterface\r\n ui.messageBox('Failed During Palette Close:\\n{}'.format(traceback.form... | [
"0.767233",
"0.6960615",
"0.67901963",
"0.6604122",
"0.6592666",
"0.64696324",
"0.64392585",
"0.6405782",
"0.6362652",
"0.6352815",
"0.6348606",
"0.6346555",
"0.63247025",
"0.6313968",
"0.6289701",
"0.6276552",
"0.6267763",
"0.62607265",
"0.62607265",
"0.6249281",
"0.623151",... | 0.91420245 | 0 |
Function is run when the palette is executed. Useful to gather initial data and send to html page | def on_palette_execute(self, palette: adsk.core.Palette):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notify(self, args):\r\n app = adsk.core.Application.cast(adsk.core.Application.get())\r\n ui = app.userInterface\r\n try:\r\n\r\n # Create and display the palette.\r\n palette = ui.palettes.itemById(self.cmd_object_.palette_id)\r\n\r\n if not palette:\r\n ... | [
"0.71663606",
"0.5976665",
"0.59089667",
"0.5755218",
"0.57544327",
"0.56373245",
"0.5611845",
"0.56111276",
"0.5609256",
"0.55880344",
"0.5586924",
"0.5578858",
"0.5556275",
"0.5524903",
"0.55076844",
"0.5467774",
"0.54665",
"0.5456171",
"0.543333",
"0.543",
"0.5428835",
"... | 0.6666663 | 1 |
Function is run when the addin stops. Clean up. If overridden ensure to execute with super().on_stop() | def on_stop(self):
app = adsk.core.Application.cast(adsk.core.Application.get())
ui = app.userInterface
palette = ui.palettes.itemById(self.palette_id)
for handler in self.html_handlers:
palette.incomingFromHTML.remove(handler)
if palette:
palette.deleteMe()
super().on_stop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def on_stop(self):\n pass",
"def post_stop(self):",
"def on_stop(self):\n ... | [
"0.81118715",
"0.81118715",
"0.81118715",
"0.81118715",
"0.81118715",
"0.81118715",
"0.81118715",
"0.7925438",
"0.7536368",
"0.7458011",
"0.7412743",
"0.7316049",
"0.73140156",
"0.7286416",
"0.72050714",
"0.7180944",
"0.71321785",
"0.7109044",
"0.7109044",
"0.71050143",
"0.70... | 0.6577097 | 95 |
Method executed by Fusion. DOn't rename | def notify(self, args):
try:
command_ = args.command
inputs_ = command_.commandInputs
on_execute_handler = _PaletteExecuteHandler(self.cmd_object_)
command_.execute.add(on_execute_handler)
self.cmd_object_.handlers.append(on_execute_handler)
self.cmd_object_.on_create(command_, inputs_)
except:
app = adsk.core.Application.cast(adsk.core.Application.get())
ui = app.userInterface
ui.messageBox('Command created failed: {}'.format(traceback.format_exc())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def my_rename(self, src, dst):\n self.renamerCalled = True",
"def _fix_up(self, cls, code_name):",
"def fix_name(self):\n self._name_fixed = True",
"def OnRenameTimer(self):\r\n \r\n self.Edit(self._current)",
"def rename(old, new):",
"def rename(old, new):",
"def _transform... | [
"0.6707409",
"0.63080657",
"0.6128592",
"0.6127869",
"0.60907537",
"0.60907537",
"0.60767657",
"0.60607314",
"0.5969004",
"0.5958113",
"0.5949128",
"0.59331226",
"0.592982",
"0.5924983",
"0.5913726",
"0.5904696",
"0.59042233",
"0.5902338",
"0.5860706",
"0.5860248",
"0.5841527... | 0.0 | -1 |
Method executed by Fusion. Don't rename | def notify(self, args):
app = adsk.core.Application.cast(adsk.core.Application.get())
ui = app.userInterface
try:
# Create and display the palette.
palette = ui.palettes.itemById(self.cmd_object_.palette_id)
if not palette:
palette = ui.palettes.add(
self.cmd_object_.palette_id,
self.cmd_object_.palette_name,
self.cmd_object_.palette_html_file_url,
self.cmd_object_.palette_is_visible,
self.cmd_object_.palette_show_close_button,
self.cmd_object_.palette_is_resizable,
self.cmd_object_.palette_width,
self.cmd_object_.palette_height,
True
)
# Add handler to HTMLEvent of the palette.
on_html_event_handler = _HTMLEventHandler(self.cmd_object_)
palette.incomingFromHTML.add(on_html_event_handler)
self.cmd_object_.handlers.append(on_html_event_handler)
self.cmd_object_.html_handlers.append(on_html_event_handler)
# Add handler to CloseEvent of the palette.
on_closed_handler = _PaletteCloseHandler(self.cmd_object_)
palette.closed.add(on_closed_handler)
self.cmd_object_.handlers.append(on_closed_handler)
else:
main_url = urlparse(self.cmd_object_.palette_html_file_url)
current_url = urlparse(palette.htmlFileURL)
if not (
(not self.cmd_object_.palette_force_url_reload) &
(main_url.netloc == current_url.netloc) &
(main_url.path == current_url.path)
):
# ui.messageBox(current_url.netloc + " vs. " + main_url.netloc)
# ui.messageBox(current_url.path + " vs. " + main_url.path)
# ui.messageBox(str(self.cmd_object_.palette_force_url_reload))
palette.htmlFileURL = self.cmd_object_.palette_html_file_url
palette.isVisible = True
self.cmd_object_.on_palette_execute(palette)
except:
ui.messageBox('Palette ({}) Execution Failed: {}'.format(
self.cmd_object_.palette_html_file_url,
traceback.format_exc())
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fix_up(self, cls, code_name):",
"def my_rename(self, src, dst):\n self.renamerCalled = True",
"def script(self):",
"def process_file(file_name):\n pass # delete this line and replace with your code here",
"def falcon():",
"def fix_name(self):\n self._name_fixed = True",
"def dumm... | [
"0.6129317",
"0.6021787",
"0.5983167",
"0.59377337",
"0.59124655",
"0.5910845",
"0.5819237",
"0.57898045",
"0.57898045",
"0.5778516",
"0.5760022",
"0.5747388",
"0.5742715",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56460947",
"0.5617484",
"0.5591955",
"0.5591... | 0.0 | -1 |
Method executed by Fusion. Don't rename | def notify(self, args):
try:
html_args = adsk.core.HTMLEventArgs.cast(args)
self.cmd_object_.on_html_event(html_args)
except:
app = adsk.core.Application.cast(adsk.core.Application.get())
ui = app.userInterface
ui.messageBox('Failed Handling HTML Event:\n{}'.format(traceback.format_exc())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fix_up(self, cls, code_name):",
"def my_rename(self, src, dst):\n self.renamerCalled = True",
"def script(self):",
"def process_file(file_name):\n pass # delete this line and replace with your code here",
"def falcon():",
"def fix_name(self):\n self._name_fixed = True",
"def dumm... | [
"0.6129317",
"0.6021787",
"0.5983167",
"0.59377337",
"0.59124655",
"0.5910845",
"0.5819237",
"0.57898045",
"0.57898045",
"0.5778516",
"0.5760022",
"0.5747388",
"0.5742715",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56460947",
"0.5617484",
"0.5591955",
"0.5591... | 0.0 | -1 |
Method executed by Fusion. Don't rename | def notify(self, args):
try:
self.cmd_object_.on_palette_close()
except:
app = adsk.core.Application.cast(adsk.core.Application.get())
ui = app.userInterface
ui.messageBox('Failed During Palette Close:\n{}'.format(traceback.format_exc())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fix_up(self, cls, code_name):",
"def my_rename(self, src, dst):\n self.renamerCalled = True",
"def script(self):",
"def process_file(file_name):\n pass # delete this line and replace with your code here",
"def falcon():",
"def fix_name(self):\n self._name_fixed = True",
"def dumm... | [
"0.6129317",
"0.6021787",
"0.5983167",
"0.59377337",
"0.59124655",
"0.5910845",
"0.5819237",
"0.57898045",
"0.57898045",
"0.5778516",
"0.5760022",
"0.5747388",
"0.5742715",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56831336",
"0.56460947",
"0.5617484",
"0.5591955",
"0.5591... | 0.0 | -1 |
Builds the selection spec. | def build_selection_spec(client_factory, name):
sel_spec = client_factory.create('ns0:SelectionSpec')
sel_spec.name = name
return sel_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_selection ( self ,\n tag , \n algotype ,\n inputs , \n *args ,\n **kwargs ) :\n sel_tag = '%s_Selection' % tag\n sel_name = 'Sel%sFor%s' % ( tag , se... | [
"0.6188935",
"0.59599125",
"0.5944895",
"0.55326456",
"0.5366692",
"0.5328713",
"0.53118664",
"0.53038955",
"0.5270639",
"0.5265871",
"0.5262976",
"0.5192852",
"0.518418",
"0.51645607",
"0.51583874",
"0.5150827",
"0.5110556",
"0.5098783",
"0.5098783",
"0.50898474",
"0.5065787... | 0.72015435 | 0 |
Builds the traversal spec object. | def build_traversal_spec(client_factory, name, spec_type, path, skip,
select_set):
traversal_spec = client_factory.create('ns0:TraversalSpec')
traversal_spec.name = name
traversal_spec.type = spec_type
traversal_spec.path = path
traversal_spec.skip = skip
traversal_spec.selectSet = select_set
return traversal_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_recursive_traversal_spec(client_factory):\r\n visit_folders_select_spec = build_selection_spec(client_factory,\r\n \"visitFolders\")\r\n # For getting to hostFolder from datacenter\r\n dc_to_hf = build_traversal_spec(client_factory, \"dc_to_hf\", \"Datacenter\"... | [
"0.6779343",
"0.64210516",
"0.57740533",
"0.55809647",
"0.5465794",
"0.5431072",
"0.5333568",
"0.52883077",
"0.5245698",
"0.52180934",
"0.5119556",
"0.5117688",
"0.5117688",
"0.5085158",
"0.504372",
"0.5026567",
"0.5005321",
"0.4998705",
"0.4986079",
"0.49831903",
"0.49652678... | 0.70819336 | 0 |
Builds the Recursive Traversal Spec to traverse the object managed object hierarchy. | def build_recursive_traversal_spec(client_factory):
visit_folders_select_spec = build_selection_spec(client_factory,
"visitFolders")
# For getting to hostFolder from datacenter
dc_to_hf = build_traversal_spec(client_factory, "dc_to_hf", "Datacenter",
"hostFolder", False,
[visit_folders_select_spec])
# For getting to vmFolder from datacenter
dc_to_vmf = build_traversal_spec(client_factory, "dc_to_vmf", "Datacenter",
"vmFolder", False,
[visit_folders_select_spec])
# For getting Host System to virtual machine
h_to_vm = build_traversal_spec(client_factory, "h_to_vm", "HostSystem",
"vm", False,
[visit_folders_select_spec])
# For getting to Host System from Compute Resource
cr_to_h = build_traversal_spec(client_factory, "cr_to_h",
"ComputeResource", "host", False, [])
# For getting to datastore from Compute Resource
cr_to_ds = build_traversal_spec(client_factory, "cr_to_ds",
"ComputeResource", "datastore", False, [])
rp_to_rp_select_spec = build_selection_spec(client_factory, "rp_to_rp")
rp_to_vm_select_spec = build_selection_spec(client_factory, "rp_to_vm")
# For getting to resource pool from Compute Resource
cr_to_rp = build_traversal_spec(client_factory, "cr_to_rp",
"ComputeResource", "resourcePool", False,
[rp_to_rp_select_spec, rp_to_vm_select_spec])
# For getting to child res pool from the parent res pool
rp_to_rp = build_traversal_spec(client_factory, "rp_to_rp", "ResourcePool",
"resourcePool", False,
[rp_to_rp_select_spec, rp_to_vm_select_spec])
# For getting to Virtual Machine from the Resource Pool
rp_to_vm = build_traversal_spec(client_factory, "rp_to_vm", "ResourcePool",
"vm", False,
[rp_to_rp_select_spec, rp_to_vm_select_spec])
# Get the assorted traversal spec which takes care of the objects to
# be searched for from the root folder
traversal_spec = build_traversal_spec(client_factory, "visitFolders",
"Folder", "childEntity", False,
[visit_folders_select_spec, dc_to_hf,
dc_to_vmf, cr_to_ds, cr_to_h, cr_to_rp,
rp_to_rp, h_to_vm, rp_to_vm])
return traversal_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_object_spec(client_factory, root_folder, traversal_specs):\r\n object_spec = client_factory.create('ns0:ObjectSpec')\r\n object_spec.obj = root_folder\r\n object_spec.skip = False\r\n object_spec.selectSet = traversal_specs\r\n return object_spec",
"def HierarchyIterator(obj):\n w... | [
"0.63169825",
"0.577359",
"0.5654486",
"0.5466749",
"0.5373837",
"0.52702874",
"0.5185981",
"0.517904",
"0.50982857",
"0.50975597",
"0.5090196",
"0.5065294",
"0.50485235",
"0.50385857",
"0.503404",
"0.49969995",
"0.4953721",
"0.4944381",
"0.49171883",
"0.4908716",
"0.49081615... | 0.6471344 | 0 |
Builds the Property Spec. | def build_property_spec(client_factory, type="VirtualMachine",
properties_to_collect=["name"],
all_properties=False):
property_spec = client_factory.create('ns0:PropertySpec')
property_spec.all = all_properties
property_spec.pathSet = properties_to_collect
property_spec.type = type
return property_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_property_filter_spec(client_factory, property_specs, object_specs):\r\n property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')\r\n property_filter_spec.propSet = property_specs\r\n property_filter_spec.objectSet = object_specs\r\n return property_filter_spec",
"def build(sel... | [
"0.6053929",
"0.595817",
"0.5930383",
"0.5877144",
"0.5749173",
"0.56912214",
"0.5589146",
"0.5584564",
"0.5541774",
"0.5472907",
"0.54651445",
"0.53387296",
"0.5295169",
"0.5217021",
"0.5211193",
"0.51826376",
"0.51688266",
"0.5148735",
"0.5138071",
"0.5137829",
"0.51148397"... | 0.69546396 | 0 |
Builds the object Spec. | def build_object_spec(client_factory, root_folder, traversal_specs):
object_spec = client_factory.create('ns0:ObjectSpec')
object_spec.obj = root_folder
object_spec.skip = False
object_spec.selectSet = traversal_specs
return object_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(self, spec, prefix):\n make()",
"def generate_specs_build(self):\n from django_swagger_utils.drf_server.generators.swagger_generator import SwaggerGenerator\n\n swagger_gen = SwaggerGenerator(self.parser, self.paths, self.app_name)\n # generating request_response files\n ... | [
"0.70841205",
"0.66101444",
"0.6534153",
"0.6428157",
"0.630121",
"0.6247484",
"0.6246544",
"0.6246544",
"0.62344396",
"0.62344396",
"0.62138087",
"0.62038517",
"0.61900073",
"0.61408484",
"0.6102088",
"0.607086",
"0.607086",
"0.607086",
"0.60343456",
"0.599119",
"0.58868694"... | 0.6370524 | 4 |
Builds the Property Filter Spec. | def build_property_filter_spec(client_factory, property_specs, object_specs):
property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')
property_filter_spec.propSet = property_specs
property_filter_spec.objectSet = object_specs
return property_filter_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_prop_filter_spec(client_factory, obj_spec, prop_spec):\r\n prop_filter_spec = \\\r\n client_factory.create('ns0:PropertyFilterSpec')\r\n prop_filter_spec.propSet = prop_spec\r\n prop_filter_spec.objectSet = obj_spec\r\n return prop_filter_spec",
"def get_prop_filter_spec(client_factory... | [
"0.6691381",
"0.6613962",
"0.6211153",
"0.60873485",
"0.59203535",
"0.5826266",
"0.5766887",
"0.546501",
"0.54321504",
"0.5387858",
"0.5352514",
"0.5318498",
"0.53072774",
"0.52971756",
"0.52805036",
"0.5272654",
"0.5242891",
"0.5188393",
"0.51839644",
"0.5144999",
"0.5102500... | 0.76600534 | 0 |
Gets the properties of the Managed object specified. | def get_object_properties(vim, collector, mobj, type, properties):
client_factory = vim.client.factory
if mobj is None:
return None
usecoll = collector
if usecoll is None:
usecoll = vim.get_service_content().propertyCollector
property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')
property_spec = client_factory.create('ns0:PropertySpec')
property_spec.all = (properties is None or len(properties) == 0)
property_spec.pathSet = properties
property_spec.type = type
object_spec = client_factory.create('ns0:ObjectSpec')
object_spec.obj = mobj
object_spec.skip = False
property_filter_spec.propSet = [property_spec]
property_filter_spec.objectSet = [object_spec]
return vim.RetrieveProperties(usecoll, specSet=[property_filter_spec]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_object_properties(vim, collector, mobj, type, properties):\n client_factory = vim.client.factory\n if mobj is None:\n return None\n usecoll = collector\n if usecoll is None:\n usecoll = vim.service_content.propertyCollector\n property_filter_spec = client_factory.create('ns0:Pr... | [
"0.66242605",
"0.6595597",
"0.65718126",
"0.65414923",
"0.64137036",
"0.63451725",
"0.6315363",
"0.6177473",
"0.61558604",
"0.61558604",
"0.61421597",
"0.61126566",
"0.6106942",
"0.6099833",
"0.60941976",
"0.6071322",
"0.6071322",
"0.6018031",
"0.599956",
"0.5993409",
"0.5958... | 0.679616 | 0 |
Gets a particular property of the Managed Object. | def get_dynamic_property(vim, mobj, type, property_name):
obj_content = \
get_object_properties(vim, None, mobj, type, [property_name])
property_value = None
if obj_content:
dynamic_property = obj_content[0].propSet
if dynamic_property:
property_value = dynamic_property[0].val
return property_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_property(self, property):\n return self.shell([\"getprop\", property])",
"def get_property(self,name):\n return self.dp.get_property(name)",
"def get_property(self, key):\n return self.properties.get(key)",
"def get_property(self, name):\n if (not name in self.properties):\n ... | [
"0.7311495",
"0.7275758",
"0.7193801",
"0.7128644",
"0.70792645",
"0.7021553",
"0.6953444",
"0.69131315",
"0.6811504",
"0.67831117",
"0.67660815",
"0.67022717",
"0.66058373",
"0.65965885",
"0.65847474",
"0.6570505",
"0.65630543",
"0.65239185",
"0.63693666",
"0.6347373",
"0.63... | 0.62482166 | 27 |
Gets the list of objects of the type specified. | def get_objects(vim, type, properties_to_collect=["name"], all=False):
client_factory = vim.client.factory
object_spec = build_object_spec(client_factory,
vim.get_service_content().rootFolder,
[build_recursive_traversal_spec(client_factory)])
property_spec = build_property_spec(client_factory, type=type,
properties_to_collect=properties_to_collect,
all_properties=all)
property_filter_spec = build_property_filter_spec(client_factory,
[property_spec],
[object_spec])
return vim.RetrieveProperties(vim.get_service_content().propertyCollector,
specSet=[property_filter_spec]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_objects_by_type(self, *types) -> List[TgnObject]:\n if not types:\n return list(self.objects.values())\n types_l = [o.lower() for o in types]\n return [o for o in self.objects.values() if o.type.lower() in types_l]",
"def all(self, *args, **kwargs):\n list_to_return = [... | [
"0.7903194",
"0.7377341",
"0.73040676",
"0.70410174",
"0.692821",
"0.69026285",
"0.68966556",
"0.6836504",
"0.6808106",
"0.6714846",
"0.6546497",
"0.65462595",
"0.6545677",
"0.6539864",
"0.6508331",
"0.6492654",
"0.64498925",
"0.64006305",
"0.63523966",
"0.63385695",
"0.63068... | 0.6089714 | 40 |
Builds the Property Spec Object. | def get_prop_spec(client_factory, spec_type, properties):
prop_spec = client_factory.create('ns0:PropertySpec')
prop_spec.type = spec_type
prop_spec.pathSet = properties
return prop_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_property_spec(client_factory, type=\"VirtualMachine\",\r\n properties_to_collect=[\"name\"],\r\n all_properties=False):\r\n property_spec = client_factory.create('ns0:PropertySpec')\r\n property_spec.all = all_properties\r\n property_spec.pathSet = p... | [
"0.7005923",
"0.6116688",
"0.5938139",
"0.58759177",
"0.58554643",
"0.57825583",
"0.5649714",
"0.5636901",
"0.5603624",
"0.559764",
"0.5581322",
"0.5505116",
"0.54937416",
"0.54541737",
"0.5407613",
"0.5344718",
"0.532845",
"0.5320788",
"0.52512217",
"0.5245343",
"0.5237961",... | 0.59059453 | 3 |
Builds the Object Spec object. | def get_obj_spec(client_factory, obj, select_set=None):
obj_spec = client_factory.create('ns0:ObjectSpec')
obj_spec.obj = obj
obj_spec.skip = False
if select_set is not None:
obj_spec.selectSet = select_set
return obj_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_object_spec(client_factory, root_folder, traversal_specs):\r\n object_spec = client_factory.create('ns0:ObjectSpec')\r\n object_spec.obj = root_folder\r\n object_spec.skip = False\r\n object_spec.selectSet = traversal_specs\r\n return object_spec",
"def build(self, spec, prefix):\n ... | [
"0.66367",
"0.6583926",
"0.64170843",
"0.62385815",
"0.6159886",
"0.6103416",
"0.60937",
"0.6093361",
"0.5987617",
"0.5961307",
"0.59383756",
"0.59383756",
"0.58615595",
"0.58615595",
"0.58420074",
"0.5829586",
"0.5824573",
"0.58184236",
"0.58095497",
"0.5804861",
"0.5796754"... | 0.54430425 | 40 |
Builds the Property Filter Spec Object. | def get_prop_filter_spec(client_factory, obj_spec, prop_spec):
prop_filter_spec = \
client_factory.create('ns0:PropertyFilterSpec')
prop_filter_spec.propSet = prop_spec
prop_filter_spec.objectSet = obj_spec
return prop_filter_spec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_property_filter_spec(client_factory, property_specs, object_specs):\r\n property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')\r\n property_filter_spec.propSet = property_specs\r\n property_filter_spec.objectSet = object_specs\r\n return property_filter_spec",
"def get_prop_... | [
"0.76403946",
"0.65880555",
"0.6298685",
"0.6076335",
"0.597899",
"0.5965586",
"0.5764983",
"0.5655848",
"0.56413084",
"0.5557564",
"0.5519107",
"0.5488389",
"0.54726166",
"0.5452801",
"0.544979",
"0.5363146",
"0.5314718",
"0.51662815",
"0.5132564",
"0.5092276",
"0.50902605",... | 0.66637796 | 1 |
Gets the list of properties for the collection of objects of the type specified. | def get_properties_for_a_collection_of_objects(vim, type,
obj_list, properties):
client_factory = vim.client.factory
if len(obj_list) == 0:
return []
prop_spec = get_prop_spec(client_factory, type, properties)
lst_obj_specs = []
for obj in obj_list:
lst_obj_specs.append(get_obj_spec(client_factory, obj))
prop_filter_spec = get_prop_filter_spec(client_factory,
lst_obj_specs, [prop_spec])
return vim.RetrieveProperties(vim.get_service_content().propertyCollector,
specSet=[prop_filter_spec]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_properties_for_a_collection_of_objects(vim, type,\n obj_list, properties):\n client_factory = vim.client.factory\n if len(obj_list) == 0:\n return []\n prop_spec = get_prop_spec(client_factory, type, properties)\n lst_obj_specs = []\n for ... | [
"0.7357272",
"0.65244734",
"0.6457637",
"0.6373247",
"0.6370086",
"0.6297487",
"0.62510055",
"0.62469465",
"0.6221552",
"0.6219856",
"0.6206821",
"0.610221",
"0.60433024",
"0.60395074",
"0.5994236",
"0.59763896",
"0.59744734",
"0.59715617",
"0.59705645",
"0.5961555",
"0.59590... | 0.74611396 | 0 |
Take the top c cards of each stack and return a copy | def copy_stacks(self, c1, c2):
return (
deque([n for n in self._s1][-c1:]),
deque([n for n in self._s2][-c2:])
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop_top_card(self):\n return self.pop_card(top=True)",
"def top_draw(self):\n top_card = self.cards.pop(0)\n return top_card",
"def top(self):\n return self.get_cards()[-1]",
"def get_card_at_top_index(deck):\n \n small_joker_value = get_small_joker_value(deck)\n if d... | [
"0.6781717",
"0.6382215",
"0.63411653",
"0.63055867",
"0.6273443",
"0.6257995",
"0.61584336",
"0.61021817",
"0.60572743",
"0.6045613",
"0.6024501",
"0.6022065",
"0.600286",
"0.5925546",
"0.5907862",
"0.58364666",
"0.5817762",
"0.5810385",
"0.5734856",
"0.5729768",
"0.5695732"... | 0.57403517 | 18 |
Return tuple (player number, s1, s2). The first element indicates the winner | def play(self):
while len(self._s1) > 0 and len(self._s2) > 0:
if self._serialize() in self._seen_games:
# Game over player 1 wins
return (1, *self.decks)
self._seen_games.add(self._serialize())
n1, n2 = self._s1.pop(), self._s2.pop()
if len(self._s1) >= n1 and len(self._s2) >= n2:
# Play a sub game
sub_game = Game(*self.copy_stacks(n1, n2))
res, _, _ = sub_game.play()
else:
res = 1 if n1 > n2 else 2
if res == 1:
self._s1.appendleft(n1)
self._s1.appendleft(n2)
else:
self._s2.appendleft(n2)
self._s2.appendleft(n1)
return (1 if len(self._s1) else 2, *self.decks) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def winner(self):\n # Credit to Dariusz Walczak for inspiration.\n # http://stackoverflow.com/questions/1720421/merge-two-lists-in-python\n moves = [p.possible_moves(p.pieces, self) for p in self.players]\n if False in [mv == [] for mv in moves]:\n return (\"None\")\n ... | [
"0.7398989",
"0.7312626",
"0.7270267",
"0.7123724",
"0.7110263",
"0.7102775",
"0.70441735",
"0.70315427",
"0.6907012",
"0.6888181",
"0.6876374",
"0.6870772",
"0.6866335",
"0.6822034",
"0.67885065",
"0.6718184",
"0.67145145",
"0.6701902",
"0.6701902",
"0.6701902",
"0.6685644",... | 0.60619944 | 93 |
Initialize the parameters of the logistic regression | def __init__(self, input, n_in, n_out):
# start-snippet-1
# initialize with 0 the weights W as a matrix of shape (n_in, n_out)
self.W = theano.shared( value=numpy.zeros( (n_in, n_out), dtype=theano.config.floatX ), name='W', borrow=True )
# initialize the baises b as a vector of n_out 0s
self.b = theano.shared(value=numpy.zeros( (n_out,), dtype=theano.config.floatX ), name='b', borrow=True )
# symbolic expression for computing the matrix of class-membership probabilities where:
# W is a matrix where column-k represent the separation hyper plain for class-k
# x is a matrix where row-j represents input training sample-j
# b is a vector where element-k represent the free parameter of hyper plane-k
self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
# symbolic description of how to compute prediction as class whose probability is maximal
self.y_pred = T.argmax(self.p_y_given_x, axis=1)
# end-snippet-1
# parameters of the model
self.params = [self.W, self.b]
# keep track of model input
self.input = input | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_initial_params(model: LogisticRegression):\n n_classes = 15 # threat types\n n_features = 33 # Number of features in dataset\n model.classes_ = np.array([i for i in range(15)])\n\n model.coef_ = np.zeros((n_classes, n_features))\n if model.fit_intercept:\n model.intercept_ = np.zeros(... | [
"0.77980274",
"0.7470837",
"0.72140586",
"0.6893265",
"0.68832946",
"0.6734596",
"0.6729252",
"0.66861194",
"0.6655325",
"0.65969175",
"0.6565215",
"0.65200406",
"0.6474855",
"0.64675874",
"0.6451465",
"0.6448672",
"0.644657",
"0.6324524",
"0.6307155",
"0.6290791",
"0.6231589... | 0.0 | -1 |
Return the mean of the negative loglikelihood of the prediction of this model under a given target distribution. | def negative_log_likelihood(self, y):
# start-snippet-2
# y.shape[0] is (symbolically) the number of rows in y, i.e. number of examples (call it n) in the minibatch
# T.arange(y.shape[0]) is a symbolic vector which will contain [0,1,2,... n-1]
# T.log(self.p_y_given_x) is a matrix of Log-Probabilities (call it LP) with one row per example and one column per class
# LP[T.arange(y.shape[0]),y] is a vector v containing [LP[0,y[0]], LP[1,y[1]], LP[2,y[2]], ..., LP[n-1,y[n-1]]] and
# T.mean(LP[T.arange(y.shape[0]),y]) is the mean (across minibatch examples) of the elements in v, i.e., the mean log-likelihood across the minibatch.
#print "y.ndim = ",y.ndim
return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])
# end-snippet-2
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def negative_log_likelihood(self):\n # y.shape[0] is (symbolically) the number of rows in y, i.e.,\n # number of examples (call it n) in the minibatch\n # T.arange(y.shape[0]) is a symbolic vector which will contain\n # [0,1,2,... n-1] T.log(self.p_y_given_x) is a matrix of\n # L... | [
"0.7408264",
"0.7209359",
"0.7209359",
"0.7208547",
"0.7176592",
"0.7176592",
"0.70599693",
"0.68988174",
"0.68891734",
"0.65442437",
"0.64843166",
"0.64635515",
"0.64410263",
"0.6426811",
"0.6400936",
"0.639749",
"0.639114",
"0.6367916",
"0.6353634",
"0.63428533",
"0.6317736... | 0.6822186 | 9 |
Return a float representing the number of errors in the minibatch over the total number of examples of the minibatch ; zero one loss over the size of the minibatch | def errors(self, y):
# check if y has same dimension of y_pred
if y.ndim != self.y_pred.ndim:
raise TypeError( 'y should have the same shape as self.y_pred', ('y', y.type, 'y_pred', self.y_pred.type) )
# check if y is of the correct datatype
if y.dtype.startswith('int'):
# the T.neq operator returns a vector of 0s and 1s, where 1
# represents a mistake in prediction
return T.mean(T.neq(self.y_pred, y))
else:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_error(self):\n self.prediction = self.predict()\n pred = self.prediction.reshape(-1)\n self.error = np.sum(pred != self.label) / self.train_data.shape[0]\n return(self.error)",
"def nb_errors_nb(self, input_data, target):\n input_data_resize = input_data.view(2000, 1,... | [
"0.64593107",
"0.6453829",
"0.6450095",
"0.6359758",
"0.6284254",
"0.6248897",
"0.61730903",
"0.6143888",
"0.6141596",
"0.61282915",
"0.61234075",
"0.6117177",
"0.6080115",
"0.60368556",
"0.60218304",
"0.60163116",
"0.60140604",
"0.5989487",
"0.59858793",
"0.59834915",
"0.597... | 0.0 | -1 |
Demonstrate stochastic gradient descent optimization of a loglinear model | def sgd_optimization(data_type, target, model_dir, learning_rate=0.1, n_epochs=10, batch_size=100):
test_fold = 1 #xxxxxxxxxxxx TEMP XXXXXXXXXXXXXXXX
write_model_file = model_dir + '/model.' + target + '.' + str(test_fold) +'.pkl'
fold_path = helpers.get_fold_path(data_type)
targets = helpers.build_targets(fold_path, data_type)
fnames = targets[target]
fold_accuracies = {}
did_something = False
# pct_ct = []
# roc_auc = []
# run 4 folds vs 1 fold with each possible scenario
# for curr_fl in range(5):
# print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)
# loop through all folds, for now just do 1!
datasets, test_set_labels = helpers.th_load_data(data_type, fold_path, target, fnames, 0, test_fold)
train_set_x, train_set_y = datasets[0]
test_set_x, test_set_y = datasets[1]
valid_set_x = train_set_x
valid_set_y = train_set_y
# compute number of rows for training, validation and testing
rows_train = train_set_x.get_value(borrow=True).shape[0]
rows_valid = valid_set_x.get_value(borrow=True).shape[0]
rows_test = test_set_x.get_value(borrow=True).shape[0]
# compute number of minibatches for training, validation and testing
n_train_batches = rows_train / batch_size
n_valid_batches = rows_valid / batch_size
n_test_batches = rows_test / batch_size
####################### BUILD ACTUAL MODEL #######################
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
# generate symbolic variables for input (x and y represent a minibatch)
x = T.matrix('x') # data, presented as rasterized images
y = T.ivector('y') # labels, presented as 1D vector of [int] labels
# construct the logistic regression class
# n_in: Each MNIST image has size 32*32 = 1024
# n_out: 10 different digits - multi-task LR
classifier = LogisticRegression(input=x, n_in=32 * 32, n_out=2)
# the cost we minimize during training is the negative log likelihood of the model in symbolic format
cost = classifier.negative_log_likelihood(y)
# compiling a Theano function that computes the mistakes that are made by the model on a minibatch
test_model = theano.function( inputs=[index], outputs=classifier.errors(y),
givens={
x: test_set_x[index * batch_size: (index + 1) * batch_size],
y: test_set_y[index * batch_size: (index + 1) * batch_size]
}
)
validate_model = theano.function(
inputs=[index],
outputs=classifier.errors(y),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
}
)
# compute the gradient of cost with respect to theta = (W,b)
g_W = T.grad(cost=cost, wrt=classifier.W)
g_b = T.grad(cost=cost, wrt=classifier.b)
# start-snippet-3
# specify how to update the parameters of the model as a list of
# (variable, update expression) pairs.
updates = [(classifier.W, classifier.W - learning_rate * g_W),
(classifier.b, classifier.b - learning_rate * g_b)]
# compiling a Theano function `train_model` that returns the cost, but in
# the same time updates the parameter of the model based on the rules
# defined in `updates`
train_model = theano.function( inputs=[index], outputs=cost, updates=updates,
givens={
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
}
)
# end-snippet-3
################ TRAIN MODEL ################
# early-stopping parameters
patience = 5000 # look as this many examples regardless
patience_increase = 2 # wait this much longer when a new best is found
improvement_threshold = 0.995 # a relative improvement of this much is considered significant
validation_frequency = min(n_train_batches, patience / 2)
# go through this many minibatches before checking the network on the validation set; in this case we check every epoch
best_validation_loss = numpy.inf
test_score = 0.
start_time = time.clock()
done_looping = False
epoch = 0
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in xrange(n_train_batches):
minibatch_avg_cost = train_model(minibatch_index)
# iteration number
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
# compute zero-one loss on validation set
validation_losses = [validate_model(i)
for i in xrange(n_valid_batches)]
this_validation_loss = numpy.mean(validation_losses)
# print( 'epoch %i, minibatch %i/%i, validation error %f %%' %
# (epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100.) )
# if we got the best validation score until now
if this_validation_loss < best_validation_loss:
#improve patience if loss improvement is good enough
if this_validation_loss < best_validation_loss * \
improvement_threshold:
patience = max(patience, iter * patience_increase)
best_validation_loss = this_validation_loss
# test it on the test set
test_losses = [test_model(i)
for i in xrange(n_test_batches)]
test_score = numpy.mean(test_losses)
# print( (' epoch %i, minibatch %i/%i, test error of best model %f %%' ) %
# ( epoch, minibatch_index + 1, n_train_batches, test_score * 100. ) )
# save the best model
with open(write_model_file, 'w') as f:
cPickle.dump(classifier, f)
if patience <= iter:
done_looping = True
break
end_time = time.clock()
print( ('Optimization complete for %d with best validation score of %f %% with test performance %f %%')
% (test_fold, best_validation_loss * 100., test_score * 100.) )
print 'The code ran for %d epochs, with %f epochs/sec' % (epoch, 1. * epoch / (end_time - start_time))
# print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.1fs' % ((end_time - start_time)))
# end-snippet-4
# Now we do the predictions
# load the saved best model for this fold
classifier = cPickle.load(open(write_model_file))
# compile a predictor function
predict_model = theano.function(inputs=[classifier.input], outputs=[classifier.y_pred,classifier.p_y_given_x])
# compile a confidence predictor function
# predict_conf_model = theano.function( inputs=[classifier.input], outputs=classifier.p_y_given_x)
# We can test it on some examples from test test
""" *************** build AUC curve *************** """
# get the probability of our predictions
test_set = test_set_x.get_value()
predicted_values, conf_preds = predict_model(test_set[:(rows_test)])
conf_predictions = []
for i in range(len(conf_preds)):
# ignore the first column; this gives a lower score that seems wrong.
conf_predictions.append(conf_preds[i][1])
# determine ROC / AUC
fpr, tpr, thresholds = metrics.roc_curve(test_set_labels, conf_predictions)
auc = metrics.auc(fpr, tpr) # e.g. 0.855
""" *********************************************** """
num_correct = 0
num_false = 0
for i in range(len(predicted_values)):
if predicted_values[i] == test_set_labels[i]:
num_correct += 1
else:
num_false += 1
total = len(predicted_values)
percent_correct = num_correct / float(total)
fold_results = ''
fold_results += '#################### Results for ' + data_type + ' ####################' + '\n'
fold_results += 'target:' + target + ' fold:' + str(test_fold) + ' predicted: ' + \
str(total) + ' wrong: ' + \
str(num_false) + ' pct correct: ' + str(percent_correct) + ', auc: ' + str(auc)
print fold_results
write_predictions_file = model_dir + '/predictions.' + target + '.' + str(test_fold) +'.txt'
with open(write_predictions_file, 'w') as f:
f.write(fold_results + "\n")
# def run_predictions(data_type, curr_target):
# fold_path = get_fold_path(data_type)
# targets = build_targets(fold_path, data_type)
# # print "Found " + str(len(targets)) + " targets for " + data_type
# fold_accuracies = {}
# did_something = False
# for target, fnames in targets.iteritems():
# if (target != curr_target):
# continue
# else:
# did_something = True
# # retrieve our stratified folds
# folds = get_folds(data_type, fold_path, target, fnames)
# pct_ct = []
# roc_auc = []
# # run 4 folds vs 1 fold with each possible scenario
# for curr_fl in range(5):
# print 'Building data for target: ' + target + ', fold: ' + str(curr_fl)
# # folds 1-4
# temp_data = []
# for i in range(len(folds)):
# if(i == curr_fl):
# # don't include the test fold
# continue
# else:
# temp_data += folds[i]
# # vs current 5th test fold
# test_data = folds[curr_fl]
# """ Turning 1024 bits into features is a slow process """
# # build training data
# X = []
# Y = []
# for i in range(len(temp_data)):
# row = []
# for bit in temp_data[i][0]:
# row.append(int(bit))
# X.append(row)
# Y.append(int(temp_data[i][1]))
# X = np.array(X)
# Y = np.array(Y)
# # build test data
# X_test = []
# Y_test = []
# for i in range(len(test_data)):
# row = []
# for bit in test_data[i][0]:
# row.append(int(bit))
# X_test.append(row)
# Y_test.append(int(test_data[i][1]))
# X_test = np.array(X_test)
# Y_test = np.array(Y_test)
# percent_correct, auc = random_forest(target, X, Y, X_test, Y_test, curr_fl)
# pct_ct.append(percent_correct)
# roc_auc.append(auc)
# # now get the average fold results for this target
# accuracy = sum(pct_ct) / float(len(pct_ct))
# all_auc = sum(roc_auc) / float(len(roc_auc))
# print 'Results for '+ target + ': accuracy: ' + str(accuracy) + ', auc: ' + str(all_auc)
# # update fold accuracies
# fold_accuracies[target] = (accuracy, all_auc)
if(did_something == False):
print curr_target + ' not found in ' + data_type + '!'
exit(0)
print '#################### Results for ' + data_type + ' ####################'
# output results
accuracies = 0.00
aucs = 0.00
num_targets = 0.00
for target, obj in fold_accuracies.iteritems():
acc = obj[0]
auc = obj[1]
print target + ' accuracy: ' + str(acc) + ', auc:' + str(auc)
accuracies += acc
aucs += auc
num_targets += 1
# overall_acc = accuracies / num_targets
# overall_auc = aucs / num_targets
# print ' overall accuracy: ' + str(overall_acc) + ', overall auc: ' + str(overall_auc)
print '############################################################' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logistic_regression_SGD(y, tx, initial_w, max_iters, gamma, batch_size=10, verbose=False):\n return stochastic_gradient_descent(y, tx, initial_w, max_iters, gamma, compute_logistic_loss, \n compute_logistic_gradient, batch_size=10, verbose=verbose)",
"def log_prior_gr... | [
"0.7094588",
"0.6940799",
"0.69093955",
"0.6795237",
"0.6782252",
"0.6769422",
"0.67630374",
"0.67446244",
"0.6688038",
"0.66774327",
"0.66749567",
"0.66108364",
"0.66103506",
"0.6609761",
"0.65868056",
"0.6584251",
"0.6573774",
"0.6572846",
"0.6521604",
"0.6511357",
"0.64980... | 0.0 | -1 |
Run `code` with profiler. Used by ``%prun`` and ``%run p``. | def _run_with_profiler(self, code, opts, namespace):
# Fill default values for unspecified options:
opts.merge(Struct(D=[''], l=[], s=['time'], T=['']))
prof = profile.Profile()
try:
prof = prof.runctx(code, namespace, namespace)
sys_exit = ''
except SystemExit:
sys_exit = """*** SystemExit exception caught in code being profiled."""
stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
lims = opts.l
if lims:
lims = [] # rebuild lims with ints/floats/strings
for lim in opts.l:
try:
lims.append(int(lim))
except ValueError:
try:
lims.append(float(lim))
except ValueError:
lims.append(lim)
# Trap output.
stdout_trap = StringIO()
stats_stream = stats.stream
try:
stats.stream = stdout_trap
stats.print_stats(*lims)
finally:
stats.stream = stats_stream
output = stdout_trap.getvalue()
output = output.rstrip()
if 'q' not in opts:
page.page(output)
print(sys_exit, end=' ')
dump_file = opts.D[0]
text_file = opts.T[0]
if dump_file:
prof.dump_stats(dump_file)
if text_file:
with open(text_file, 'w') as pfile:
pfile.write(output)
if 'r' in opts:
return stats
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def profile_code(profiler):\n print('\\n')\n ps = pstats.Stats(profiler).strip_dirs().sort_stats('cumulative')\n ps.print_stats(10)",
"def runner(code, out_stream):\n code_obj = compiler.compile_source(code)\n vm = virtual_machine.VirtualMachine(out_stream)\n vm.run_code(code_obj)",
"def part... | [
"0.6385464",
"0.62743026",
"0.6012042",
"0.5954541",
"0.5947372",
"0.5926711",
"0.5884469",
"0.5836414",
"0.5775137",
"0.5737329",
"0.5666656",
"0.5654356",
"0.55813533",
"0.55803514",
"0.555477",
"0.55139744",
"0.5504729",
"0.5470353",
"0.5440272",
"0.5439059",
"0.5430186",
... | 0.7272947 | 0 |
read feature file, find out mass shift then correct | def feature_file_mass_correction(feature_filename: str):
output_feature_filename = feature_filename + '.mass_corrected'
ppm_shift = []
with open(feature_filename, 'r') as f:
reader = csv.reader(f, delimiter=',')
header = next(reader)
seq_index = header.index("seq")
mz_index = header.index("m/z")
z_index = header.index("z")
for line in reader:
mz = float(line[mz_index])
z = float(line[z_index])
observed_mass = mz * z - z * config.mass_H
if not line[seq_index]:
continue
okay, peptide = parse_raw_sequence(line[seq_index])
if not okay:
# unknown mods
continue
theoretical_mass = compute_neutral_peptide_mass(peptide)
ppm = (observed_mass - theoretical_mass) / theoretical_mass * 1e6
ppm_shift.append(ppm)
if len(ppm_shift) < 100:
raise ValueError("too less identified feature for mass correction")
ppm_shift = np.median(ppm_shift)
print(f"ppm shift: {ppm_shift}")
with open(feature_filename, 'r') as fr:
with open(output_feature_filename, 'w') as fw:
reader = csv.reader(fr, delimiter=',')
writer = csv.writer(fw, delimiter=',')
writer.writerow(next(reader))
for line in reader:
mz = float(line[mz_index])
mz = mz * (1 - ppm_shift * 1e-6)
line[mz_index] = "{}".format(mz)
writer.writerow(line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_msp(infile_name,feat_lim_file=\"\",\n\t\t\t sum_feats=False,selected_features=[],\n\t\t\t max_dist=275,step_size=0.005,feat_bins=[],\n\t\t\t top_peaks=50,windowed_mode=False):\n\n\tinfile = open(infile_name)\n\n\tif len(feat_lim_file) > 0:\n\t\tselected_features = [float(f.strip()) for f in open(feat_lim_... | [
"0.61413145",
"0.6100522",
"0.56102365",
"0.55467093",
"0.55414826",
"0.5517877",
"0.55111635",
"0.5491323",
"0.5489486",
"0.54673564",
"0.5458751",
"0.54487556",
"0.5440117",
"0.5364303",
"0.53435946",
"0.53398484",
"0.5336551",
"0.5330061",
"0.5308056",
"0.5289896",
"0.5265... | 0.6439688 | 0 |
Crop images into the four corners, center, and their mirrored versions. | def _oversample(images, crop_dims):
# Dimensions and center.
im_shape = np.array(images[0].shape)
crop_dims = np.array(crop_dims)
im_center = im_shape[:2] / 2.0
# Make crop coordinates
h_indices = (0, im_shape[0] - crop_dims[0])
w_indices = (0, im_shape[1] - crop_dims[1])
crops_ix = np.empty((5, 4), dtype=int)
curr = 0
for i in h_indices:
for j in w_indices:
crops_ix[curr] = (i, j, i + crop_dims[0], j + crop_dims[1])
curr += 1
crops_ix[4] = np.tile(im_center, (1, 2)) + np.concatenate([
-crop_dims / 2.0,
crop_dims / 2.0
])
crops_ix = np.tile(crops_ix, (2, 1))
# Extract crops
crops = np.empty((NUM_OVER_SAMPLES * len(images), crop_dims[0], crop_dims[1],
im_shape[-1]), dtype=np.float32)
ix = 0
for im in images:
for crop in crops_ix:
crops[ix] = im[crop[0]:crop[2], crop[1]:crop[3], :]
ix += 1
crops[ix-5:ix] = crops[ix-5:ix, :, ::-1, :] # flip for mirrors
return crops | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crop_center_img(self):\n # TODO Task 1.1\n img = self.data\n img_with_missing_crop = np.copy(img)\n dim =128\n crop = dim // 2\n start = crop - (crop // 2)\n #ground truth overlaps img_with_missing_crop by 7 pixels in all directions\n img_with_missing_cro... | [
"0.68269926",
"0.65620327",
"0.648815",
"0.6427035",
"0.6379702",
"0.63226426",
"0.62055635",
"0.6204814",
"0.6204427",
"0.6082633",
"0.604973",
"0.60170174",
"0.59973186",
"0.5994196",
"0.595956",
"0.5947782",
"0.59313524",
"0.5928219",
"0.59176385",
"0.58877224",
"0.5885500... | 0.5979108 | 14 |
Helper to hold params and allow func like the original. | def __init__(self, graph, weights,
input_tensor_name=None,
output_tensor_name=None):
self.sess = tf.Session()
new_saver = tf.train.import_meta_graph(graph)
new_saver.restore(self.sess, weights)
get_tensor = tf.get_default_graph().get_tensor_by_name
# Get the initial place holder, else default
if input_tensor_name:
self.placeholder = get_tensor(input_tensor_name)
else:
self.placeholder = get_tensor('Placeholder:0')
if output_tensor_name:
self.softmax = get_tensor(output_tensor_name)
else:
self.softmax = get_tensor('Softmax:0')
# Save trainables into params
trainable_params = tf.trainable_variables()
layers = {}
params = {}
def add_to_layer(name):
try:
layers[name] = get_tensor("{}:0".format(name))
except KeyError:
try:
layers[name] = get_tensor("{}/Relu:0".format(name))
except KeyError:
print("Activation Not Found.")
pass
for v in trainable_params:
if 'weight' in v.name:
name = v.name.split('/')[0]
params[name] = v
add_to_layer(name)
# Pooling layers usually don't have a nice way of gathering.
for n in tf.get_default_graph().as_graph_def().node:
if 'pool' in n.name:
v = get_tensor("{}:0".format(n.name))
name = n.name.split('/')[0]
params[name] = v
add_to_layer(name)
# Get trainable params - 1 holds locations the other is a dummy script
self.params = {}
self._params = params
self.layers = layers
# Save empty dict into blobs
self.blobs = {} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(*args, **kwargs):\n pass",
"def params(funcarglist):\n def wrapper(function):\n function.funcarglist = funcarglist\n return function\n return wrapper",
"def my_func(a, b):",
"def wrapper(*args):",
"def dummy_fn(self, *args, **kwargs):",
"def test_param_of_func(self):... | [
"0.692556",
"0.6727447",
"0.67098534",
"0.658326",
"0.6408254",
"0.63891876",
"0.6376225",
"0.6366123",
"0.62743974",
"0.62322086",
"0.6189551",
"0.6189551",
"0.6189551",
"0.6188234",
"0.6184675",
"0.6144916",
"0.61128443",
"0.6085491",
"0.6061988",
"0.6006739",
"0.5996577",
... | 0.0 | -1 |
FUNKTION VON EILEEN Loads a data file saved by relacs. Returns a tuple of dictionaries containing the data and the header information | def load(filename):
with open(filename, 'r') as fid:
L = [l.lstrip().rstrip() for l in fid.readlines()]
ret = []
dat = {}
X = []
keyon = False
currkey = None
for l in L:
# if empty line and we have data recorded
if (not l or l.startswith('#')) and len(X) > 0:
keyon = False
currkey = None
dat['data'] = np.array(X)
ret.append(dat)
X = []
dat = {}
if '---' in l:
continue
if l.startswith('#'):
if ":" in l:
tmp = [e.rstrip().lstrip() for e in l[1:].split(':')]
if currkey is None:
dat[tmp[0]] = tmp[1]
else:
dat[currkey][tmp[0]] = tmp[1]
elif "=" in l:
tmp = [e.rstrip().lstrip() for e in l[1:].split('=')]
if currkey is None:
dat[tmp[0]] = tmp[1]
else:
dat[currkey][tmp[0]] = tmp[1]
elif l[1:].lower().startswith('key'):
dat['key'] = []
keyon = True
elif keyon:
dat['key'].append(tuple([e.lstrip().rstrip() for e in l[1:].split()]))
else:
currkey = l[1:].rstrip().lstrip()
dat[currkey] = {}
elif l: # if l != ''
keyon = False
currkey = None
X.append( [float(e) for e in l.split()])
if len(X) > 0:
dat['data'] = np.array(X)
else:
dat['data'] = []
ret.append(dat)
return tuple(ret) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self) -> None:",
"def load_data(self):",
"def load_data():\n\n server_node = load_nodes(SERVER_NODE_INFILE)\n road_node = load_nodes(ROAD_NODE_INFILE)\n road_segment_point = load_nodes(ROAD_SEGMENT_POINT_INFILE)\n\n return server_node, road_node, road_segment_point",
"def getHeaderD... | [
"0.6701253",
"0.64370406",
"0.63576305",
"0.6343084",
"0.62742215",
"0.62503767",
"0.62353116",
"0.62206954",
"0.6175295",
"0.61426353",
"0.61399317",
"0.61399025",
"0.6133964",
"0.61294085",
"0.60999405",
"0.60984147",
"0.60699123",
"0.60694903",
"0.6038092",
"0.60380447",
"... | 0.58532524 | 42 |
Factory method to create a cache object from github/spilchen/baseball_id_db This is called as part of package initialization and so can be refered to via the Lookup variable. >>> from baseball_id import Lookup >>> Lookup.from_yahoo_ids([10794, 9542, 7578]) | def create(cls):
ssl._create_default_https_context = ssl._create_unverified_context
c = lookup.Cache('https://raw.githubusercontent.com/spilchen/baseball_id_db/main/master.csv')
return c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_fake(cls):\n source = pkg_resources.open_text('baseball_id', 'sample.master.csv',\n encoding='iso-8859-1')\n c = lookup.Cache(source)\n return c",
"def construct(cls, obs_lists, platform_id):\n step = 0\n LookupTable = []\n ... | [
"0.6530035",
"0.5592927",
"0.5449668",
"0.54129845",
"0.5390788",
"0.5236379",
"0.52326137",
"0.52017933",
"0.5083397",
"0.50474405",
"0.49929607",
"0.4948093",
"0.49268007",
"0.48906374",
"0.48458242",
"0.48337904",
"0.4833684",
"0.48185053",
"0.481795",
"0.4808004",
"0.4792... | 0.6934165 | 0 |
Factory method to create a fake data source This refers to a static data file that is in the current package. This function exists for testing purposes as it avoids network traffic to get the actual uptodate ID mapping. | def create_fake(cls):
source = pkg_resources.open_text('baseball_id', 'sample.master.csv',
encoding='iso-8859-1')
c = lookup.Cache(source)
return c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_data_source_soaps_id_dynamic_datas_get(self):\n pass",
"def init_locally_processed_dataset(directory, source_datasets, uuid_=None):\n md = ptype.DatasetMetadata(\n id_=uuid_,\n # Default creation time is creation of an image.\n creation_dt=datetime.datetime.utcfromtimestam... | [
"0.6308188",
"0.62671566",
"0.6175177",
"0.61343235",
"0.5995582",
"0.5915337",
"0.59063405",
"0.58865434",
"0.5807432",
"0.57975435",
"0.5794116",
"0.57484156",
"0.5740665",
"0.56791466",
"0.56658155",
"0.56552786",
"0.5642972",
"0.56229484",
"0.5622516",
"0.56089175",
"0.56... | 0.70590085 | 0 |
The extracter moves files. Arguments input_folder and output_folder are set through GUI. Based on the values in the column called column_name in the spreadsheet, files are copied from input_folder to output_folder. Here, these are the gilbert_numbers in the spreadsheet fed from main(). The are matched to the file names. Each gilber_number gets its own directory in the output_folder. output_folder should be empty, at least not contain the same gilbert_numbers already. Also copies all speaker files from input_folder to output_folder. | def extracter(spreadsheet, column_name):
print header, "Running the extracter."
root=Tkinter.Tk()
root.withdraw()
root.update()
input_folder=tkFileDialog.askdirectory(title="Inputfolder: Please choose a directory that contains your corpus files")
root=Tkinter.Tk()
root.withdraw()
root.update()
output_folder=tkFileDialog.askdirectory(title="Outputfolder: Please choose a directory to copy files into")
print header, "Copying files from '{}' to '{}'.".format(input_folder, output_folder)
#collecting input files
inputfiles=[]
print "Locating files."
for dirpath, subdirs, files in os.walk(input_folder):
for f in files:
inputfiles.append(os.path.join(dirpath, f))
if len(inputfiles) in [1000,2000,4000,8000,1600,24000]:
print "{} files processed, still working.".format(len(inputfiles))
print "Found {} files.".format(len(inputfiles))
#read from spreadsheet
# with open(spreadsheet, "r") as spreadsheet:
# spreadsheet=pandas.read_csv(spreadsheet, encoding="utf-8")
numbers_to_be_extracted= spreadsheet[column_name].unique()
print header, "Gilbert numbers to be extracted:"
print ",".join([unicode(i) for i in numbers_to_be_extracted])
#copying speaker files
print header, "Copying speaker files."
speakerfiles=[f for f in inputfiles if re.match(".*\.txt", os.path.split(f)[1])]
os.mkdir(os.path.join(output_folder, "speakers"))
for s in speakerfiles:
shutil.copy2(s, os.path.join(output_folder, "speakers"))
#finding relevant input files
result=[]
for number in numbers_to_be_extracted:
print "Processing {}, creating folder '{}'.".format(number, number)
os.mkdir(os.path.join(output_folder, unicode(number)))
regex="(\d+)-(\d+)-(\d+)-"+number.astype('U')+"-(\D+)\.wav"
findings= [f for f in inputfiles if re.match(regex, os.path.split(f)[1])]
result= result+findings
for find in findings:
shutil.copy2(find, os.path.join(output_folder, unicode(number), os.path.split(find)[1]))
print header, "{} files have been copied to {}.".format(len(result), output_folder) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_sample_folder(self, input_folder, target_folder, sample_name):\n print(f'processing {sample_name} folder.')\n # first make a subfolder to contain the images - e.g. 'target_folder/sample_name'\n sample_dir = join(target_folder, sample_name)\n if not os.path.exists(sample_dir):\n... | [
"0.6164347",
"0.5919336",
"0.5901154",
"0.58560616",
"0.57583755",
"0.5725686",
"0.571907",
"0.56493175",
"0.55794436",
"0.5573059",
"0.55641127",
"0.55598956",
"0.5552147",
"0.55351996",
"0.5534053",
"0.5514603",
"0.55066884",
"0.5490536",
"0.54603547",
"0.5438883",
"0.54376... | 0.76440537 | 0 |
Display info about pet. | def describe_pet(pet_name,animal_type = 'dog'):
print("I have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_pet(self):\n pet = self.pet_factory.get_pet()\n print \"We have a lovely {}\".format(pet)\n print \"It says {}\".format(pet.speak())\n print \"We also have {}\".format(self.pet_factory.get_food())",
"def show_pet(self):\n pet = self.pet_factory.get_pet()\n\n pri... | [
"0.8161232",
"0.81274664",
"0.74135685",
"0.74135685",
"0.74135685",
"0.74135685",
"0.7373951",
"0.7348695",
"0.7348695",
"0.7345544",
"0.7345544",
"0.7304899",
"0.72921777",
"0.72867423",
"0.72316194",
"0.7195379",
"0.71254575",
"0.7090836",
"0.709054",
"0.70647824",
"0.6952... | 0.7029722 | 20 |
Load selected iterations and classes 3D for visualization mode. | def _load(self):
self.firstIter = 1
self.lastIter = self.protocol.getLastFinishedIter()
if self.viewIter.get() == ITER_LAST:
self._iterations = [self.lastIter]
else:
self._iterations = self._getListFromRangeString(self.iterSelection.get())
from matplotlib.ticker import FuncFormatter
self._plotFormatter = FuncFormatter(self._formatFreq) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_i3d(eval_type, h5_dir='param/'):\n state_dict = {}\n load_unit3d(state_dict, eval_type, 'Conv3d_1a_7x7', 'conv_1a', h5_dir)\n\n load_unit3d(state_dict, eval_type, 'Conv3d_2b_1x1', 'conv_2b', h5_dir)\n load_unit3d(state_dict, eval_type, 'Conv3d_2c_3x3', 'conv_2c', h5_dir)\n\n load_block(stat... | [
"0.64956695",
"0.6306034",
"0.60686326",
"0.59560525",
"0.58952993",
"0.57739794",
"0.56377673",
"0.5542612",
"0.5534125",
"0.5517615",
"0.5504378",
"0.5468626",
"0.54292387",
"0.5424756",
"0.5412685",
"0.5403881",
"0.5403201",
"0.5379721",
"0.5374727",
"0.5370032",
"0.536210... | 0.50833565 | 43 |
Format function for Matplotlib formatter. | def _formatFreq(self, value, pos):
inv = 999
if value:
inv = 1/value
return "1/%0.2f" % inv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def float_format(self):\n ...",
"def asformat(self, format):",
"def format(self, *args, **kwargs) -> String:\n pass",
"def add_formatter(self, fmt):\n if fmt and not isfunction(fmt):\n raise TypeError(\"custom format function must be a type of function\")\n\n if fmt and fmt... | [
"0.6947464",
"0.67461205",
"0.65912247",
"0.64709014",
"0.64154315",
"0.635182",
"0.63386416",
"0.63360775",
"0.6247381",
"0.62060654",
"0.62060654",
"0.6194569",
"0.61453986",
"0.6124619",
"0.60353225",
"0.60240173",
"0.6023951",
"0.60086197",
"0.5962071",
"0.5960708",
"0.59... | 0.0 | -1 |
Build or update a Ticker metrics using a Quotecast object. Only the metrics which can be converted to float are supported. But that should be enough to handle all the real use cases. | def build_ticker_from_quotecast(
quotecast: Quotecast,
references: Dict[int, List[str]] = None,
ticker: Ticker = None,
) -> Ticker:
if references is None:
references = dict()
if ticker is None:
ticker = Ticker()
# SETUP PRODUCTS & METRICS
message_array = json.loads(quotecast.json_data)
for message in message_array:
if message["m"] == "un":
reference = message["v"][0]
value = message["v"][1]
product, metric = references[reference]
ticker.products[product].metrics[metric] = value
elif message["m"] == "us":
reference = message["v"][0]
value = message["v"][1]
product, metric = references[reference]
if value[4] == "-":
date = datetime.datetime.strptime(
value,
"%Y-%m-%d",
)
value = datetime.datetime.timestamp(date)
ticker.products[product].metrics[metric] = value
elif value[2] == ":":
time = datetime.time.fromisoformat(value)
value = time.hour * 3600 + time.minute * 60 + time.second
ticker.products[product].metrics[metric] = value
else:
# NOT CONVERTIBLE TO FLOAT
raise RuntimeWarning(
"Unsupported string metric : " f"{metric} = {message}"
)
elif message["m"] == "a_req":
references[message["v"][1]] = message["v"][0].rsplit(
sep=".",
maxsplit=1,
)
elif message["m"] == "a_rel":
delete_list = []
for reference in references:
if ".".join(references[reference]) == message["v"][0]:
delete_list.append(reference)
for reference in delete_list:
del references[reference]
elif message["m"] == "h":
pass
elif message["m"] == "ue":
pass
elif message["m"] == "d":
raise AttributeError(f"Subscription rejected : {message}")
else:
raise AttributeError(f"Unknown metric : {message}")
# SETUP PRODUCT LIST
ticker.product_list.extend(ticker.products)
# SETUP METADATA
ticker.metadata.MergeFrom(quotecast.metadata)
return ticker | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n self.data.update()\n stats = self.data.stats\n ticker = self.data.ticker\n\n if self.type == \"exchangerate\":\n self._attr_state = ticker[self._currency].p15min\n self._attr_unit_of_measurement = self._currency\n elif self.type == \"trad... | [
"0.504665",
"0.49457982",
"0.482276",
"0.47894225",
"0.47741964",
"0.47666577",
"0.4716032",
"0.46845242",
"0.46796387",
"0.46367455",
"0.46182653",
"0.4578131",
"0.4567336",
"0.4567215",
"0.45670658",
"0.4566002",
"0.4552697",
"0.45424986",
"0.45123693",
"0.44995657",
"0.448... | 0.6156283 | 0 |
Rebuild the request from history (self.__references). | def rebuild_request(self) -> Quotecast.Request:
references = self.references
request = Quotecast.Request()
for vwd_id, metric in references.values():
request.subscriptions[vwd_id].append(metric)
return request | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rebuild(self):\n _logger.info( \"Rebuilding the API Caches...\" )\n\n # fill out the data structures\n self._buildApiTypesList()\n #_buildMayaTypesList()\n \n self._buildMayaReservedTypes(force=True)\n\n self._buildApiRelationships()\n\n # merge in the ma... | [
"0.5566847",
"0.546248",
"0.54090655",
"0.5392603",
"0.5335858",
"0.5311608",
"0.52756536",
"0.52722096",
"0.52640605",
"0.5223405",
"0.5222167",
"0.5147405",
"0.5122049",
"0.5031895",
"0.50197256",
"0.5009398",
"0.5008371",
"0.49860406",
"0.49698722",
"0.4964786",
"0.4964781... | 0.67901736 | 0 |
check to see whether an id is for a group | def is_group(id):
return id.startswith('G') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_uuid(self, obj, groupid):\n if self.get_uuid(obj) == groupid:\n return True",
"def alreay_in_group(self,uid,group_id):\n uid = str(uid)\n user_group_list = self.get_group_list_via_uid(uid)\n return True if group_id in user_group_list else False",
"def is_group(s... | [
"0.7496174",
"0.7397895",
"0.7248163",
"0.72468346",
"0.7207925",
"0.7201284",
"0.71829623",
"0.715947",
"0.7065384",
"0.70614374",
"0.6950488",
"0.69323575",
"0.68989813",
"0.6898132",
"0.686232",
"0.6849973",
"0.682175",
"0.68139756",
"0.6812948",
"0.6809037",
"0.6806396",
... | 0.81725055 | 0 |
check to see whether an id is for a user | def is_user(id):
return id.startswith('U') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def userIDExists(self, id : int) -> bool:\n return id in self.users.keys()",
"def hasUser(self, id):\n try:\n self.getUser(id)\n return True\n except KeyError:\n return False",
"def check_user(user):\n result_user = search_column_with_constraint(choose_d... | [
"0.79370236",
"0.75839674",
"0.7334541",
"0.732782",
"0.72933257",
"0.7157885",
"0.71560794",
"0.70645714",
"0.70558435",
"0.7010881",
"0.6988318",
"0.69240403",
"0.69037765",
"0.6896436",
"0.6886491",
"0.6883643",
"0.6861566",
"0.6858304",
"0.6853838",
"0.6834101",
"0.683142... | 0.8175753 | 0 |
a new session has been created add user's sid to cache with their related chat id | def user_joined(cls, sid, token):
session = Session.find(token=token)
if not session:
return False
redis.hset('sid-id', sid, session.user_id)
redis.hset('id-sid', session.user_id, sid)
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_session(self, session_id):\n sessions = self.get_sessions()\n if session_id not in sessions:\n sessions.append(session_id)\n self.ref_cache.set(self.sid, sessions)",
"def add_user_to_session(self,session_id,client_id,display_name):\n self.sessions[session_id][\"... | [
"0.6442786",
"0.60261506",
"0.5993311",
"0.59842753",
"0.59716135",
"0.5773349",
"0.5754616",
"0.5753378",
"0.5728176",
"0.5712133",
"0.5694755",
"0.5632899",
"0.56139004",
"0.5612166",
"0.5564319",
"0.5548212",
"0.55396765",
"0.5534832",
"0.5517975",
"0.5509574",
"0.548927",... | 0.5635927 | 11 |
a user has been disconnected from the server. delete its sid | def user_left(cls, sid):
id = redis.hget('sid-id', sid)
redis.hdel('sid-id', sid)
redis.hdel('id-sid', id)
return id.decode("utf-8") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disconnect():\n\n\tglob.tokens.deleteToken(glob.tokens.getTokenFromUserID(999))",
"def connection_lost(self, exc):\n if isinstance(self.current, Session):\n self.current.removeUser(self)\n elif self.current == self:\n del super.clients[self]\n else:\n ano... | [
"0.72285557",
"0.7040492",
"0.68665254",
"0.6458032",
"0.64499587",
"0.64076656",
"0.6401039",
"0.6399896",
"0.6398915",
"0.6398157",
"0.6392838",
"0.63727134",
"0.6348618",
"0.63431454",
"0.6333374",
"0.6315425",
"0.62992054",
"0.62812126",
"0.6270461",
"0.6263564",
"0.62526... | 0.6578083 | 3 |
search for a user's socket id | def get_user_sid(cls, user_id):
sid = redis.hget('id-sid', user_id)
if not sid:
return None
return sid.decode("utf-8") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_socket(self, user):\n for client in self.clients:\n if user == client.get_name():\n return client.get_socket()",
"def lookup_friend(self,username):\n if self.isBlank(username) or self.isValidLen(username):\n return False\n safe_input = (usern... | [
"0.6524464",
"0.6177678",
"0.6079417",
"0.60470605",
"0.5984913",
"0.59413224",
"0.5857293",
"0.58146036",
"0.5801265",
"0.5664723",
"0.5636931",
"0.5636145",
"0.5635148",
"0.56256527",
"0.56242967",
"0.56242955",
"0.56001824",
"0.56000507",
"0.55688393",
"0.55479366",
"0.554... | 0.527406 | 55 |
get a user id using its sid user has to be joined | def get_sid_id(cls, sid):
id = redis.hget('sid-id', sid)
if not id:
return None
return id.decode("utf-8") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user(id):\n pass",
"def get_user_id(self):\n return self.id_user",
"def fetch_current_user_id(s):",
"def get_id(self): \n\t\treturn (self.user_id)",
"def get_user_id():\n user_id = session.get(\"user_id\")\n return user_id if user_id else None",
"def get_one_user():",
"def get_u... | [
"0.71183956",
"0.67369145",
"0.67288226",
"0.6676",
"0.66554093",
"0.6615446",
"0.6597501",
"0.6586899",
"0.6580105",
"0.6580105",
"0.65061647",
"0.6459379",
"0.6445892",
"0.64429665",
"0.6428113",
"0.64264065",
"0.6411913",
"0.6411254",
"0.64103955",
"0.64056945",
"0.6374203... | 0.0 | -1 |
when a user sends a new message to the server | def new_msg(cls, sender_id, recipient_id, text):
sender = User.find(id=sender_id)
sender_sid = cls.get_user_sid(sender.id)
if is_group(recipient_id):
recipient_group = Group.find(id=recipient_id)
if not recipient_group:
raise Exception('recipient was not found')
if not recipient_group.has_user(sender):
raise Exception('user is not a member of this group')
cls._broadcast_group(sender, sender_sid,
recipient_group, text)
elif is_user(recipient_id):
recipient = User.find(id=recipient_id)
if not sender.is_friends(recipient):
raise Exception('user is not friends with recipient')
if recipient.blocked(sender):
raise Exception('recipient has blocked you')
if not recipient:
raise Exception('recipient was not found')
cls._broadcast_user(sender, sender_sid, recipient,
text)
else:
raise Exception('bad recipient id') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_message(data):\n pass",
"def message_handler(msg):\n logging.info(\"Message Text: %s\" % msg['msg'])\n\n message_entry = Message(request.sid, msg['room'], msg['msg'], msg['time'])\n if msg['msg'] != \"User has connected!\":\n logging.info(\"About to add to DB\")\n db.session.... | [
"0.752636",
"0.74791414",
"0.7469889",
"0.73891926",
"0.7261544",
"0.71904874",
"0.7182423",
"0.7182423",
"0.7182423",
"0.7179466",
"0.71528774",
"0.714717",
"0.7144339",
"0.71373135",
"0.7136156",
"0.71050507",
"0.71050507",
"0.70408386",
"0.7027871",
"0.7018298",
"0.6988954... | 0.0 | -1 |
broadcast a new user joining the group | def user_joined_group(cls, group, user):
text = "{} joined the group chat".format(user.username)
cls._broadcast_group(group, None, group, text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notify_new_user(self, user):\n # join to default group\n g = self.root.get('community-general')\n if g:\n self.join_group(user, g)",
"def join_server(self, data, user):\n # User will spawn in one of following rooms\n user.room = choice((\"100\", \"300\", \"800\",... | [
"0.66464144",
"0.6612628",
"0.65133005",
"0.65117073",
"0.64265233",
"0.6303679",
"0.6245498",
"0.6235882",
"0.6231058",
"0.6172051",
"0.61579597",
"0.61176723",
"0.60869974",
"0.6015817",
"0.6015379",
"0.601436",
"0.5992443",
"0.59782267",
"0.59572095",
"0.59416044",
"0.5917... | 0.71382284 | 0 |
broadcast a user leaving the group | def user_left_group(cls, group, user):
text = "{} left the group chat".format(user.username)
cls._broadcast_group(group, None, group, text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def leave_room(self, label):\n user = self.user\n room = await self.get_room(label)\n\n await self.channel_layer.group_send(\n room.group_name,\n {\n 'type': 'chat.leave',\n 'label': label,\n 'username': user.username,\n ... | [
"0.68877256",
"0.6836113",
"0.6618386",
"0.6293848",
"0.62480164",
"0.6209803",
"0.61928344",
"0.61679953",
"0.61453825",
"0.6137914",
"0.61103255",
"0.6071488",
"0.59881574",
"0.59806395",
"0.5946936",
"0.592674",
"0.5914093",
"0.59117216",
"0.59084827",
"0.5901252",
"0.5890... | 0.7276704 | 0 |
broadcast a new message to a group chat | def _broadcast_group(cls, sender, sender_sid, group, text):
# todo make this method async
for recipient in group.get_users():
if recipient == sender:
continue
cls._broadcast_user(sender, sender_sid, recipient, text, group.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_groupchat_message(self, msg):\n self.xmpp.event('groupchat_message', msg)\n self.xmpp.event(\"muc::%s::message\" % msg['from'].bare, msg)",
"def sendMessage(self, message):\n\t\tm = domish.Element((None, 'message'))\n\t\tm['from'] = self.jid\n\t\tm['to'] = self.room\n\t\tm['type'] = 'gro... | [
"0.74668014",
"0.73062366",
"0.70124036",
"0.6886197",
"0.67108417",
"0.6665333",
"0.66605836",
"0.6642074",
"0.66353",
"0.66307837",
"0.66065943",
"0.6557014",
"0.65497166",
"0.64740735",
"0.6465451",
"0.6459765",
"0.64553064",
"0.64509314",
"0.6406889",
"0.63932914",
"0.639... | 0.67548275 | 4 |
broadcast a new message to a user | def _broadcast_user(cls, sender, sender_sid, recipient, text, chat_id=None):
# todo make this method async
recipient_sid = cls.get_user_sid(recipient.id)
if not recipient_sid:
cls._cache_msg(sender.id, recipient.id, text, chat_id)
return
data = {'sender_id': sender.id, 'recipient_id': recipient.id,
'text': text, 'chat_id': chat_id or 'private', 'time': time()}
app.socketio.emit('message', data, room=recipient_sid) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notify(cls, user_id, message):\n # Find the subscription group for user.\n group = None if user_id is None else f\"user_{user_id}\"\n cls.broadcast(group=group, payload=message)",
"def broadcast(msg):\r\n for user in clients:\r\n msg_client(msg, user)",
"def broadcast(self, m... | [
"0.7328094",
"0.72830236",
"0.71688133",
"0.7001179",
"0.6999174",
"0.69816566",
"0.6812357",
"0.6784205",
"0.6777518",
"0.6767178",
"0.6728205",
"0.6724078",
"0.6669847",
"0.6652716",
"0.6629219",
"0.6618152",
"0.6594717",
"0.6588109",
"0.6582829",
"0.65520984",
"0.6547883",... | 0.71615946 | 3 |
cache a message that failed to be delivered | def _cache_msg(cls, sender_id, recipient_id, text, chat_id=None):
# todo make this method async
message = Message.new(sender_id, recipient_id, text, chat_id)
return message | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_message(self, comm_id, msg):\n if comm_id not in self._cached_messages:\n self._cached_messages[comm_id] = []\n self._cached_messages[comm_id].append(msg)",
"def _mark_discarted_messages():\n\n max_retry_value = getattr(settings, \"DJMAIL_MAX_RETRY_NUMBER\", 3)\n queryset... | [
"0.64296436",
"0.6014829",
"0.5976981",
"0.5920454",
"0.57477766",
"0.56894994",
"0.56732804",
"0.558145",
"0.5558702",
"0.5543183",
"0.5528251",
"0.5498727",
"0.54969853",
"0.54897916",
"0.54788435",
"0.5449968",
"0.54112744",
"0.5403003",
"0.5399943",
"0.5390648",
"0.538709... | 0.5689635 | 5 |
Start an oef node. | def _start_oef_node(self, network_node): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def launch_oef():\n script_path = os.path.join(\"scripts\", \"oef\", \"launch.py\")\n configuration_file_path = os.path.join(\"scripts\", \"oef\", \"launch_config.json\")\n print(\"Launching new OEF Node...\")\n subprocess.Popen(\n [\"python3\", script_path, \"-c\", configuration_file_path, \"--... | [
"0.73455715",
"0.67564565",
"0.6507637",
"0.5896183",
"0.5798123",
"0.56471074",
"0.5645573",
"0.5598258",
"0.5573087",
"0.556594",
"0.55550206",
"0.5545505",
"0.5535845",
"0.5517319",
"0.5511",
"0.55073994",
"0.5473905",
"0.5468678",
"0.54667735",
"0.54622465",
"0.54570323",... | 0.82847816 | 0 |
Set the test up. | def setup_class(cls):
cls.runner = CliRunner()
cls.agent_name = "agent_1"
cls.cwd = os.getcwd()
cls.t = tempfile.mkdtemp()
os.chdir(cls.t) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n logging.debug('setting up')",
"def setUp(self):\n logging.debug('setting up')",
"def setUp(self):\n\n self._set_up()",
"def setUp(self):\n MainTests.setUp(self)",
"def setUp(self):\n \n pass",
"def setUp(self):\n\n # setup init variables... | [
"0.82482773",
"0.82482773",
"0.81176686",
"0.800283",
"0.7907327",
"0.78918254",
"0.7887326",
"0.7848355",
"0.7842833",
"0.7832785",
"0.7832785",
"0.781454",
"0.78136706",
"0.7806924",
"0.78026885",
"0.78026885",
"0.77940094",
"0.7776961",
"0.7776961",
"0.7776961",
"0.7776961... | 0.0 | -1 |
Test that a generated protocol's serialisation + deserialisation work correctly. | def test_generated_protocol_serialisation(self):
# create a message
reply_message = {1: "number one", 2: "number two", 7: "number seven"}
# message 1
message = TwoPartyNegotiationMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=TwoPartyNegotiationMessage.Performative.INFORM_REPLY,
reply_message=reply_message,
)
# serialise the message
encoded_message_in_bytes = TwoPartyNegotiationSerializer().encode(message)
# deserialise the message
decoded_message = TwoPartyNegotiationSerializer().decode(
encoded_message_in_bytes
)
# Compare the original message with the serialised+deserialised message
assert decoded_message.message_id == message.message_id
assert decoded_message.dialogue_reference == message.dialogue_reference
assert decoded_message.dialogue_reference[0] == message.dialogue_reference[0]
assert decoded_message.dialogue_reference[1] == message.dialogue_reference[1]
assert decoded_message.target == message.target
assert decoded_message.performative == message.performative
assert decoded_message.reply_message == message.reply_message | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_proto_serialization() -> None:\n\n uid = UID(value=uuid.UUID(int=333779996850170035686993356951732753684))\n obj = SpecificLocation(id=uid, name=\"Test\")\n\n blob = SpecificLocation.get_protobuf_schema()(id=sy.serialize(uid), name=\"Test\")\n\n assert sy.serialize(obj, to_proto=True) == blob\... | [
"0.6951617",
"0.68632156",
"0.67302066",
"0.661847",
"0.6527949",
"0.6503405",
"0.6458234",
"0.63932693",
"0.63932693",
"0.6388795",
"0.63429564",
"0.63004637",
"0.6290241",
"0.62630475",
"0.6233855",
"0.618288",
"0.61746454",
"0.6163066",
"0.6099586",
"0.6083544",
"0.6072765... | 0.7254605 | 0 |
Test that a generated protocol could be used in exchanging messages between two agents. | def test_generated_protocol_end_to_end(self):
# AEA components
ledger_apis = LedgerApis({}, FETCHAI)
wallet_1 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE})
wallet_2 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE})
identity_1 = Identity(
name="my_aea_1",
address=wallet_1.addresses.get(FETCHAI),
default_address_key=FETCHAI,
)
identity_2 = Identity(
name="my_aea_2",
address=wallet_2.addresses.get(FETCHAI),
default_address_key=FETCHAI,
)
oef_connection_1 = OEFConnection(
address=identity_1.address, oef_addr=HOST, oef_port=PORT
)
oef_connection_2 = OEFConnection(
address=identity_2.address, oef_addr=HOST, oef_port=PORT
)
resources_1 = Resources()
resources_2 = Resources()
# add generated protocols to resources
generated_protocol_configuration = ProtocolConfig.from_json(
yaml.safe_load(
open(
os.path.join(
self.cwd,
"tests",
"data",
"generator",
"two_party_negotiation",
"protocol.yaml",
)
)
)
)
generated_protocol = Protocol(
TwoPartyNegotiationMessage.protocol_id,
TwoPartyNegotiationSerializer(),
generated_protocol_configuration,
)
resources_1.protocol_registry.register(
TwoPartyNegotiationMessage.protocol_id, generated_protocol
)
resources_2.protocol_registry.register(
TwoPartyNegotiationMessage.protocol_id, generated_protocol
)
# create AEAs
aea_1 = AEA(identity_1, [oef_connection_1], wallet_1, ledger_apis, resources_1)
aea_2 = AEA(identity_2, [oef_connection_2], wallet_2, ledger_apis, resources_2)
inform_number = tuple((1370, 1991, 1, 4, 17, 6))
# message 1
message = TwoPartyNegotiationMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=TwoPartyNegotiationMessage.Performative.INFORM,
inform_number=inform_number,
)
encoded_message_in_bytes = TwoPartyNegotiationSerializer().encode(message)
envelope = Envelope(
to=identity_2.address,
sender=identity_1.address,
protocol_id=TwoPartyNegotiationMessage.protocol_id,
message=encoded_message_in_bytes,
)
# message 2
reply_message = {1: "number one", 2: "number two", 7: "number seven"}
message_2 = TwoPartyNegotiationMessage(
message_id=2,
dialogue_reference=(str(0), ""),
target=1,
performative=TwoPartyNegotiationMessage.Performative.INFORM_REPLY,
reply_message=reply_message,
)
encoded_message_2_in_bytes = TwoPartyNegotiationSerializer().encode(message_2)
# add handlers to AEA resources
agent_1_handler = Agent1Handler(
skill_context=SkillContext(aea_1.context), name="fake_skill"
)
resources_1.handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TwoPartyNegotiationMessage.protocol_id,
),
agent_1_handler,
)
agent_2_handler = Agent2Handler(
encoded_messsage=encoded_message_2_in_bytes,
skill_context=SkillContext(aea_2.context),
name="fake_skill",
)
resources_2.handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TwoPartyNegotiationMessage.protocol_id,
),
agent_2_handler,
)
# add error skill to AEAs
error_skill_1 = Skill.from_dir(
os.path.join(AEA_DIR, "skills", "error"), aea_1.context
)
resources_1.add_skill(error_skill_1)
error_skill_2 = Skill.from_dir(
os.path.join(AEA_DIR, "skills", "error"), aea_2.context
)
resources_2.add_skill(error_skill_2)
# Start threads
t_1 = Thread(target=aea_1.start)
t_2 = Thread(target=aea_2.start)
try:
t_1.start()
t_2.start()
time.sleep(1.0)
aea_1.outbox.put(envelope)
time.sleep(5.0)
assert (
agent_2_handler.handled_message.message_id == message.message_id
), "Message from Agent 1 to 2: message ids do not match"
assert (
agent_2_handler.handled_message.dialogue_reference
== message.dialogue_reference
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[0]
== message.dialogue_reference[0]
), "Message from Agent 1 to 2: dialogue reference[0]s do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[1]
== message.dialogue_reference[1]
), "Message from Agent 1 to 2: dialogue reference[1]s do not match"
assert (
agent_2_handler.handled_message.target == message.target
), "Message from Agent 1 to 2: targets do not match"
assert (
agent_2_handler.handled_message.performative == message.performative
), "Message from Agent 1 to 2: performatives do not match"
assert (
agent_2_handler.handled_message.inform_number == message.inform_number
), "Message from Agent 1 to 2: inform_numbers do not match"
assert (
agent_1_handler.handled_message.message_id == message_2.message_id
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference
== message_2.dialogue_reference
), "Message from Agent 2 to 1: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[0]
== message_2.dialogue_reference[0]
), "Message from Agent 2 to 1: dialogue reference[0]s do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[1]
== message_2.dialogue_reference[1]
), "Message from Agent 2 to 1: dialogue reference[1]s do not match"
assert (
agent_1_handler.handled_message.target == message_2.target
), "Message from Agent 2 to 1: targets do not match"
assert (
agent_1_handler.handled_message.performative == message_2.performative
), "Message from Agent 2 to 1: performatives do not match"
assert (
agent_1_handler.handled_message.reply_message == message_2.reply_message
), "Message from Agent 1 to 2: reply_messages do not match"
time.sleep(2.0)
finally:
aea_1.stop()
aea_2.stop()
t_1.join()
t_2.join() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_identify(self):\n\n protocol_a, transport_a, tree_a, _ = self.create_protocol('protocol_a')\n protocol_b, transport_b, tree_b, _ = self.create_protocol('protocol_b')\n\n transport_a.get_extra_info.return_value = ('127.0.0.1', 1000)\n transport_b.get_extra_info.return_value = ('... | [
"0.6693443",
"0.65527207",
"0.64990115",
"0.64490074",
"0.64464223",
"0.6435972",
"0.641256",
"0.63902915",
"0.6338546",
"0.6269686",
"0.6266628",
"0.6260895",
"0.6249174",
"0.61818177",
"0.61632335",
"0.61631536",
"0.61530423",
"0.61333424",
"0.6118203",
"0.60873365",
"0.605... | 0.6860271 | 0 |
Tear the test down. | def teardown_class(cls):
os.chdir(cls.cwd)
try:
shutil.rmtree(cls.t)
except (OSError, IOError):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def teardown_test(self):\n self.log.info('Tearing down the test case')\n self.iperf_server.stop()\n self.access_point.bridge.teardown(self.brconfigs)\n self.access_point.close()\n wputils.reset_host_interface(self.pkt_sender.interface)\n self.mon.usb('on')",
"def tearDow... | [
"0.81449527",
"0.77001065",
"0.77001065",
"0.7650473",
"0.7650473",
"0.76173466",
"0.7492439",
"0.74516493",
"0.74354964",
"0.7418989",
"0.73991543",
"0.73991543",
"0.73991543",
"0.73991543",
"0.7376718",
"0.7350522",
"0.73498565",
"0.7335127",
"0.73328424",
"0.73328424",
"0.... | 0.0 | -1 |
Test _specification_type_to_python_type method unsupported type. | def test__specification_type_to_python_type_unsupported_type(self):
with self.assertRaises(TypeError):
_specification_type_to_python_type("unsupported_type") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_type_error(self):\n self._error_test(TypeError)",
"def test_raises_type_error(self):\n wrong_type = dict()\n self.assertRaises(\n TypeError, util.convert_protobuf_to_proto_plus, wrong_type\n )",
"def test_value_error_for_computing_missing_type():\n with pytest... | [
"0.6947089",
"0.6929546",
"0.6844311",
"0.6795259",
"0.66925305",
"0.6652292",
"0.6652253",
"0.6572005",
"0.65506715",
"0.6511283",
"0.64829165",
"0.6474207",
"0.64679945",
"0.64503706",
"0.64311326",
"0.6370294",
"0.6370191",
"0.6354397",
"0.6286515",
"0.6261668",
"0.6253150... | 0.91027087 | 0 |
Test _union_sub_type_to_protobuf_variable_name method tuple. | def test__union_sub_type_to_protobuf_variable_name_tuple(self, mock):
_union_sub_type_to_protobuf_variable_name("content_name", "Tuple")
mock.assert_called_once() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _union_sub_type_to_protobuf_variable_name(\n content_name: str, content_type: str\n) -> str:\n if content_type.startswith(\"FrozenSet\"):\n sub_type = _get_sub_types_of_compositional_types(content_type)[0]\n expanded_type_str = \"set_of_{}\".format(sub_type)\n elif content_type.startswit... | [
"0.7497985",
"0.54891527",
"0.5454183",
"0.5442474",
"0.5129124",
"0.5115415",
"0.51112336",
"0.5045163",
"0.5033024",
"0.5018397",
"0.49975044",
"0.49971396",
"0.49895564",
"0.4978763",
"0.4951379",
"0.49307013",
"0.49243486",
"0.48797363",
"0.48714188",
"0.485954",
"0.48464... | 0.8391995 | 0 |
Test _includes_custom_type method positive result. | def test__includes_custom_type_positive(self, *mocks):
content_type = "Union[str]"
result = self.protocol_generator._includes_custom_type(content_type)
self.assertTrue(result)
content_type = "Optional[str]"
result = self.protocol_generator._includes_custom_type(content_type)
self.assertTrue(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _includes_custom_type(content_type: str) -> bool:\n\n if content_type.startswith(\"Optional\"):\n sub_type = _get_sub_types_of_compositional_types(content_type)[0]\n result = _includes_custom_type(sub_type)\n elif content_type.startswith(\"Union\"):\n sub_types = _get_sub_types_of_co... | [
"0.7456461",
"0.6151709",
"0.57726073",
"0.5564573",
"0.5552539",
"0.5481914",
"0.5474497",
"0.54267174",
"0.5376972",
"0.534768",
"0.5330371",
"0.5328861",
"0.5311295",
"0.5270746",
"0.52539307",
"0.5240947",
"0.5239048",
"0.5234515",
"0.5231774",
"0.5193669",
"0.5185735",
... | 0.7806248 | 0 |
Implement the setup for the handler. | def setup(self) -> None:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self, *args, **kwargs):\n pass",
"def _setup(self) -> None:\n\t\treturn",
"def setUp(self):\n\n installHandler()",
"def setUp(self):\n\n installHandler()",
"def setup(self,**kwargs):\n pass",
"def setup(self):\n raise NotImplementedError(\"Need to be imple... | [
"0.74647546",
"0.7427192",
"0.74090225",
"0.74090225",
"0.73212504",
"0.7227166",
"0.7225722",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7210512",
"0.7194558",
"0.7194558",
"0.7176307",
"0.7176307",
"0.7176307",
"0.7176307",
"0.7132219",
"0.7116914",... | 0.7172614 | 20 |
Implement the reaction to a message. | def handle(self, message: Message) -> None:
self.handled_message = message | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def custom_mqtt_reaction(self, topic, message):\n raise NotImplementedError(\"Must override method custom_mqtt_reaction\")",
"async def process(self, chan_id: str, msg_id: str, emoji: str, member: discord.Member, add: bool):\n logger.debug(f\"Processing reaction: [ add: {add}, msg_id: {msg_id}, emo... | [
"0.6869177",
"0.6487918",
"0.63162875",
"0.6300903",
"0.6280189",
"0.6270176",
"0.6200644",
"0.61323017",
"0.613172",
"0.6130621",
"0.6107559",
"0.6087531",
"0.6074806",
"0.60717124",
"0.6063858",
"0.6055714",
"0.60538733",
"0.6034891",
"0.6023585",
"0.60027444",
"0.5996093",... | 0.55897665 | 76 |
Implement the handler teardown. | def teardown(self) -> None: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_teardown(self):\n with pytest.raises(NotImplementedError):\n self.handler.teardown()",
"def _teardown(self):\n # No-op base implementation",
"def teardown(self, event):\n pass",
"def cleanup(self) -> None:\n self.handler.cleanup()\n super().cleanup()",
... | [
"0.8065864",
"0.7863261",
"0.78516686",
"0.7751276",
"0.7695875",
"0.76800025",
"0.76800025",
"0.76762605",
"0.76762605",
"0.76578486",
"0.76578486",
"0.76578486",
"0.7586377",
"0.75539047",
"0.7453597",
"0.7453597",
"0.7453597",
"0.7220783",
"0.7112508",
"0.70983917",
"0.708... | 0.7647432 | 13 |
Implement the setup for the handler. | def setup(self) -> None:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self, *args, **kwargs):\n pass",
"def _setup(self) -> None:\n\t\treturn",
"def setUp(self):\n\n installHandler()",
"def setUp(self):\n\n installHandler()",
"def setup(self,**kwargs):\n pass",
"def setup(self):\n raise NotImplementedError(\"Need to be imple... | [
"0.74647546",
"0.7427192",
"0.74090225",
"0.74090225",
"0.73212504",
"0.7227166",
"0.7225722",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7213479",
"0.7210512",
"0.7194558",
"0.7194558",
"0.7176307",
"0.7176307",
"0.7176307",
"0.7176307",
"0.7132219",
"0.7116914",... | 0.7172614 | 21 |
Implement the reaction to a message. | def handle(self, message: Message) -> None:
self.handled_message = message
envelope = Envelope(
to=message.counterparty,
sender=self.context.agent_address,
protocol_id=TwoPartyNegotiationMessage.protocol_id,
message=self.encoded_message_2_in_bytes,
)
self.context.outbox.put(envelope) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def custom_mqtt_reaction(self, topic, message):\n raise NotImplementedError(\"Must override method custom_mqtt_reaction\")",
"async def process(self, chan_id: str, msg_id: str, emoji: str, member: discord.Member, add: bool):\n logger.debug(f\"Processing reaction: [ add: {add}, msg_id: {msg_id}, emo... | [
"0.6869177",
"0.6487918",
"0.63162875",
"0.6300903",
"0.6280189",
"0.6270176",
"0.6200644",
"0.61323017",
"0.613172",
"0.6130621",
"0.6107559",
"0.6087531",
"0.6074806",
"0.60717124",
"0.6063858",
"0.6055714",
"0.60538733",
"0.6034891",
"0.6023585",
"0.60027444",
"0.5996093",... | 0.0 | -1 |
Implement the handler teardown. | def teardown(self) -> None: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_teardown(self):\n with pytest.raises(NotImplementedError):\n self.handler.teardown()",
"def _teardown(self):\n # No-op base implementation",
"def teardown(self, event):\n pass",
"def cleanup(self) -> None:\n self.handler.cleanup()\n super().cleanup()",
... | [
"0.8065864",
"0.7863261",
"0.78516686",
"0.7751276",
"0.7695875",
"0.76800025",
"0.76800025",
"0.76762605",
"0.76762605",
"0.76578486",
"0.76578486",
"0.76578486",
"0.7586377",
"0.75539047",
"0.7453597",
"0.7453597",
"0.7453597",
"0.7220783",
"0.7112508",
"0.70983917",
"0.708... | 0.7647432 | 14 |
Does the program read in records, placing data into correct fields of record objects? | def test_CovidCase_creation(self):
new_Covid = self.create_CovidCase()
self.assertTrue(isinstance(new_Covid, CovidCase))
self.assertEqual(new_Covid.country_id, "TE") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parseRecords(self):\n # dict of parse methods for most common records that will be stored in structured arrays\n FLAG2METHOD = {'PS' : self.parseHighPassRecord,\n 'PC' : self.parseLowPassRecord,\n 'VD' : self.parseDigitalSValRecord}\n # dict of ... | [
"0.62811124",
"0.62365377",
"0.61066103",
"0.60930586",
"0.6048932",
"0.60215473",
"0.6007136",
"0.5951948",
"0.5928344",
"0.59142256",
"0.5856558",
"0.5852108",
"0.5832339",
"0.5824252",
"0.5793622",
"0.579146",
"0.5781421",
"0.57737976",
"0.5772325",
"0.571253",
"0.5677232"... | 0.0 | -1 |
Does the program add a new record into the sequential data structure? | def test_CovidCase_add(self):
add_covid = self.create_CovidCase()
add_covid.save()
self.assertIn(add_covid, CovidCase.objects.all()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_record(self):\n if not self.record_exists(self.args.date):\n record = self.create_record()\n self.records.append(record)\n self.write_json_file(self.records_file, self.records)\n return True\n return False",
"def test_append_updated_record_to_queu... | [
"0.6565922",
"0.64655966",
"0.64488524",
"0.635182",
"0.6166402",
"0.6109293",
"0.60871565",
"0.60605955",
"0.60419774",
"0.6038555",
"0.6027791",
"0.60155684",
"0.6006945",
"0.5984549",
"0.5980958",
"0.5957817",
"0.5919547",
"0.58998924",
"0.58906573",
"0.5881246",
"0.587191... | 0.0 | -1 |
Does the program update a record in the sequential data structure as expected? | def test_CovidCase_update(self):
u_Covid = self.update_CovidCase()
c = CovidCase.objects.get(country_id="UP")
c.name_en = "New name"
c.save()
self.assertEqual(c.name_en, "New name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_record(self):\n pass",
"def test_append_updated_record_to_queue_same_data(small_app):\n pid = PersistentIdentifier.get(\"literature\", 11883)\n publication_id = str(pid.object_uuid)\n record = Record.get_record(publication_id)\n\n append_updated_record_to_queue(None, record, re... | [
"0.6519844",
"0.6387769",
"0.6352885",
"0.6277602",
"0.6213696",
"0.5965861",
"0.5937817",
"0.592395",
"0.58763266",
"0.5874582",
"0.58480644",
"0.58157754",
"0.57564855",
"0.57024807",
"0.5700393",
"0.5700325",
"0.56963235",
"0.56787336",
"0.5669062",
"0.5668286",
"0.5662235... | 0.0 | -1 |
Does the program remove a record from the sequential data structure as expected? | def test_CovidCase_delete(self):
# setting up by creating and saving the the database
del_Covid = self.create_CovidCase()
del_Covid.save()
del_id = del_Covid.id
# we are going to delete by calling the delete function
del_deleted = CovidCase.objects.get(id=del_id)
del_deleted.delete()
self.assertNotIn(del_Covid, CovidCase.objects.all()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, val):\n if not val in self.record:\n return False\n index = self.record[val]\n self.data[index], self.data[-1] = self.data[-1], self.data[index]\n self.record[self.data[index]] = index\n self.data.pop()\n self.record.pop(val)\n return Tru... | [
"0.68329746",
"0.67125225",
"0.6622166",
"0.66102016",
"0.65779585",
"0.65033436",
"0.6474776",
"0.63278514",
"0.6315034",
"0.629419",
"0.6229488",
"0.61964864",
"0.6193291",
"0.6143841",
"0.6140655",
"0.61280227",
"0.6104588",
"0.6092655",
"0.60867935",
"0.6085228",
"0.60814... | 0.0 | -1 |
Does the program catch any exceptions or errors if the file is missing? | def test_file_error(self):
my_reader = DataSetReader()
covid_list = CovidCase.objects.all()
with self.assertRaises(IOError):
my_reader.writeFile(covid_list, "Not_A_File.csv") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_not_present_file(self):\n\t\ttry:\n\t\t\tmain.Main(['input/abc.txt']).run()\n\t\texcept:\n\t\t\tself.assertTrue(True)",
"def FileCheck(fn):\n try:\n open(fn, \"r\")\n return 1\n except IOError:\n print(\"Error: File does not exist.\")\n return 0",
"def test_no_such_fi... | [
"0.7671936",
"0.7364344",
"0.7215916",
"0.7126976",
"0.7051832",
"0.7051832",
"0.7029998",
"0.7013632",
"0.69907284",
"0.6982232",
"0.69754636",
"0.6973892",
"0.6960266",
"0.68636847",
"0.68334687",
"0.6810809",
"0.67925715",
"0.67872965",
"0.67819893",
"0.6771102",
"0.672490... | 0.0 | -1 |
Run the Viterbi algorithm. N number of tokens (length of sentence) L number of labels | def run_viterbi(emission_scores, trans_scores, start_scores, end_scores):
L = start_scores.shape[0]
assert end_scores.shape[0] == L
assert trans_scores.shape[0] == L
assert trans_scores.shape[1] == L
assert emission_scores.shape[1] == L
N = emission_scores.shape[0]
trans_scores += start_scores
back_ptrs = np.zeros_like(emission_scores,dtype=np.int32)
emission_scores += start_scores
em_scores = np.zeros_like(emission_scores)
em_scores[0] = start_scores+emission_scores[0]
for k in range(1,N):
transition_plus_score =trans_scores+np.expand_dims(em_scores[k-1],1)
back_ptrs[k] =np.argmax(transition_plus_score,0)
em_scores[k] =np.max(transition_plus_score,0)+emission_scores[k]
v = [np.argmax(end_scores+em_scores[-1])]
v_score = np.max(end_scores+em_scores[-1])
for back_ptr in reversed(back_ptrs[1:]):
v.append(back_ptr[v[-1]])
v.reverse()
return v_score,v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_viterbi(self, tokens: TokenSeq) -> Tuple[NDArray, NDArray, PosSeq]:",
"def label_n_elements(\n self,\n n_elements: int,\n model,\n data_process_fn,\n ) -> int:\n n_to_sample = min(len(self.unlabelled_idx_set), n_elements)\n model.ev... | [
"0.6409644",
"0.6073446",
"0.6022884",
"0.5973923",
"0.5945685",
"0.58445257",
"0.57420796",
"0.5737962",
"0.56900644",
"0.56370634",
"0.56175566",
"0.5607194",
"0.5601182",
"0.5584242",
"0.55672693",
"0.5564353",
"0.55216706",
"0.5517806",
"0.551739",
"0.5480801",
"0.5472328... | 0.53388405 | 30 |
Run a single epoch | def eval_model(device, model, sampler, loss_compute, logit_modifier_fxn, token_sampler,
print_every, max_len, user_items_df, max_name_len=15, ingr_map=None,
base_save_dir='', pad_ingr=None, ppx_only=False, **tensor_kwargs):
start = datetime.now()
results_dicts = []
# Extract into tuples and list
tensor_names, base_tensors = zip(*tensor_kwargs.items())
# Iterate through batches in the epoch
model.eval()
with torch.no_grad():
total_tokens = 0
total_name_tokens = 0
total_loss = 0.0
total_name_loss = 0.0
print_tokens = 0
for i, batch in enumerate(tqdm(sampler.epoch_batches(), total=sampler.n_batches), 1):
batch_users, items = [t.to(device) for t in batch]
# Fill out batch information
batch_map = dict(zip(
tensor_names,
get_batch_information_general(items, *base_tensors)
))
use_ingr_embedding = batch_map['ingr_tensor'].size(-1) != MAX_INGR * MAX_INGR_TOK
user_prior_technique_masks = torch.stack([get_user_prior_techniques_mask(
user_ix=uix.item(), item_ix=iix.item(),
user_items_df=user_items_df, tech_mask_tensor=tensor_kwargs['tech_mask_tensor'],
device=device, normalize=True
) for uix, iix in zip(batch_users, items)], dim=0)
# Logistics
this_batch_size = batch_map['steps_tensor'].size(0)
this_batch_num_tokens = (batch_map['steps_tensor'] != PAD_INDEX).data.sum().item()
this_batch_num_name_tokens = (batch_map['name_tensor'] != PAD_INDEX).data.sum().item()
name_targets = batch_map['name_tensor'][:, :-1]
'''
Teacher forcing - evaluate
'''
# Comparing out(token[t-1]) to token[t]
(log_probs, _), (name_log_probs, _) = model.forward(
device=device, inputs=(
batch_map['calorie_level_tensor'],
batch_map['name_tensor'],
batch_map['ingr_tensor']
),
ingr_masks=batch_map['ingr_mask_tensor'],
user_prior_technique_masks=user_prior_technique_masks,
targets=batch_map['steps_tensor'][:, :-1], max_len=max_len-1,
start_token=START_INDEX, teacher_forcing=True,
name_targets=name_targets,
max_name_len=max_name_len-1,
visualize=False
)
loss, name_loss = loss_compute(
log_probs, batch_map['steps_tensor'][:, 1:],
name_outputs=name_log_probs,
name_targets=name_targets,
norm=this_batch_size,
model=model,
clip=None
)
total_loss += loss
total_name_loss += name_loss
# Logging
total_tokens += this_batch_num_tokens
total_name_tokens += this_batch_num_name_tokens
print_tokens += this_batch_num_tokens
del log_probs, name_log_probs
# Short-circuit if we only want to calculate test perplexity
if ppx_only:
if i % print_every == 0:
elapsed = datetime.now() - start
print("Epoch Step: {} LM Loss: {:.5f}; Name Loss: {:.5f}; Tok/s: {:.3f}".format(
i, loss / this_batch_size, name_loss / this_batch_size,
print_tokens / elapsed.seconds
))
start = datetime.now()
print_tokens = 0
continue
'''
Non-teacher-forcing - Generate!
'''
# Generates probabilities
(log_probs, output_tokens, ingr_attns, prior_tech_attns), \
(name_log_probs, name_output_tokens) = model.forward(
device=device, inputs=(
batch_map['calorie_level_tensor'],
batch_map['name_tensor'],
batch_map['ingr_tensor']
),
ingr_masks=batch_map['ingr_mask_tensor'],
user_prior_technique_masks=user_prior_technique_masks,
targets=batch_map['steps_tensor'][:, :-1], max_len=max_len-1,
start_token=START_INDEX, teacher_forcing=False,
logit_modifier_fxn=logit_modifier_fxn, token_sampler=token_sampler,
visualize=True, max_name_len=max_name_len-1, name_targets=name_targets,
)
del log_probs, name_log_probs
# Generated recipe
calorie_levels, technique_strs, ingredient_strs, gold_strs, generated_strs, \
prior_items, recipe_reprs = get_batch_generated_recipes(
batch_users=batch_users, batch_generated=output_tokens,
max_ingr=MAX_INGR, max_ingr_tok=MAX_INGR_TOK,
names_generated=name_output_tokens, ingr_map=ingr_map,
user_items_df=user_items_df, **batch_map
)
for ix in range(len(generated_strs)):
# Create save location: test_i<item>_u<user>
ii = items[ix].data.item()
uu = batch_users[ix].data.item()
sample_id = 'test_i{}_u{}'.format(ii, uu)
trial_save_dir = os.path.join(base_save_dir, sample_id)
if not os.path.exists(trial_save_dir):
os.mkdir(trial_save_dir)
# Output tokens for heatmap axes
out_indices = output_tokens[ix].detach().cpu().numpy().tolist()
out_tokens = decode_ids(out_indices)
trunc_indices = out_indices[:out_indices.index(END_INDEX)] \
if END_INDEX in out_indices else out_indices
output_len = len(trunc_indices)
output_techniques = [t for t in TECHNIQUES_LIST if t in generated_strs[ix]]
results_dicts.append({
'u': uu,
'i': ii,
'generated': generated_strs[ix],
'n_tokens': output_len,
'generated_techniques': output_techniques,
'n_techniques': len(output_techniques)
})
# Save output
with open(os.path.join(trial_save_dir, 'output.txt'), 'w+', encoding='utf-8') as wf:
wf.write(recipe_reprs[ix])
# Ingredient Attention
ingr_attentions = np.matrix([
a.squeeze().detach().cpu().numpy().tolist() for a in ingr_attns[ix]
]).T
ingr_attn_df = pd.DataFrame(
ingr_attentions[:len(ingredient_strs[ix])],
index=ingredient_strs[ix], columns=out_tokens
)
ingr_attn_df = ingr_attn_df[ingr_attn_df.index != '']
ingr_attn_df.to_pickle(
os.path.join(trial_save_dir, 'ingredient_attention.pkl')
)
# Prior Technique Attention
prior_tech_attention = np.matrix([
a.squeeze().detach().cpu().numpy().tolist() for a in prior_tech_attns[ix]
]).T
prior_tech_attn_df = pd.DataFrame(
prior_tech_attention, index=TECHNIQUES_LIST + ['PAD'], columns=out_tokens
)
prior_tech_attn_df = prior_tech_attn_df[(prior_tech_attn_df.T != 0.0).any()]
prior_tech_attn_df.to_pickle(
os.path.join(trial_save_dir, 'prior_tech_attention.pkl')
)
if i % print_every == 0:
elapsed = datetime.now() - start
print("Epoch Step: {} LM Loss: {:.5f}; Name Loss: {:.5f}; Tok/s: {:.3f}".format(
i, loss / this_batch_size, name_loss / this_batch_size,
print_tokens / elapsed.seconds
))
print('SAMPLE DECODED RECIPE:\n\n{}\n\n'.format(recipe_reprs[0]))
start = datetime.now()
print_tokens = 0
# Reshuffle the sampler
sampler.renew_indices()
if total_name_tokens > 0:
print('\nName Perplexity: {}'.format(
np.exp(total_name_loss / float(total_name_tokens))
))
# Store perplexity
ppx = np.exp(total_loss / float(total_tokens))
with open(os.path.join(base_save_dir, 'ppx.pkl'), 'wb') as wf:
pickle.dump(ppx, wf)
print('PERPLEXITY: {:.5f}'.format(
ppx
))
if not ppx_only:
# Store recipe information -- generated string, # tokens (length), tech, # tech
gen_df = pd.DataFrame(results_dicts)[[
'u', 'i', 'generated', 'n_tokens', 'generated_techniques', 'n_techniques'
]]
df_loc = os.path.join(base_save_dir, 'generated_df.pkl')
gen_df.to_pickle(df_loc)
print('Saved generation DF to {}'.format(
df_loc
))
print(gen_df.head(3)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_one_epoch(self):\n raise NotImplementedError",
"def run_epoch( self ):\n # --- Init Epoch ----\n total_epoch_loss = 0.0\n epoch_batches = self.dataset.dataloader( self.config.neuron.epoch_length )\n progress_bar = qqdm(enumerate(epoch_batches), total=len(epoch_batches... | [
"0.7596425",
"0.7297351",
"0.71258926",
"0.71189123",
"0.7038193",
"0.70254976",
"0.69980335",
"0.69980335",
"0.6921019",
"0.69073707",
"0.69073707",
"0.69073707",
"0.69073707",
"0.6906141",
"0.6859562",
"0.6859317",
"0.6823435",
"0.6796138",
"0.67864937",
"0.67839265",
"0.67... | 0.0 | -1 |
Convert a text to a format ROUGE understands. The text is assumed to contain one sentence per line. | def convert_text_to_rouge_format(text, title="dummy title"):
sentences = text.split("\n")
sent_elems = [
"<a name=\"{i}\">[{i}]</a> <a href=\"#{i}\" id={i}>"
"{text}</a>".format(i=i, text=sent)
for i, sent in enumerate(sentences, start=1) if sent != '']
html = """<html>
<head>
<title>{title}</title>
</head>
<body bgcolor="white">
{elems}
</body>
</html>""".format(title=title, elems="\n".join(sent_elems))
return html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert(text):\n return NewDocument.from_rst(text).format()",
"def preprocess(self, text):\r\n return text",
"def preprocess(self, text):\n if self.model_name == \"bert-base-arabert\":\n return self._old_preprocess(\n text,\n do_farasa_tokenization=... | [
"0.66363716",
"0.61474895",
"0.6118832",
"0.6097702",
"0.609217",
"0.60894656",
"0.6057062",
"0.60051125",
"0.6003964",
"0.59820795",
"0.59751576",
"0.5925597",
"0.5902075",
"0.5848546",
"0.5844513",
"0.5837306",
"0.58300614",
"0.58283144",
"0.5815858",
"0.5792594",
"0.577824... | 0.6489249 | 1 |
Bin calculation for x and y Calculates the bin edges for the given data arrays x and y. | def get_2D_bins(x, y, bins, same_bins=False):
# precalculated bins [np.ndarray, np.ndarray]: do nothing and return the same bins
if isinstance(bins, list):
if isinstance(bins[0], np.ndarray) and isinstance(bins[1], np.ndarray):
pass
elif 'uniform_counts' in bins:
try:
n = int(bins[1])
bins_x = np.fromiter(
(np.nanpercentile(x, (i / n) * 100) for i in range(1, n + 1)),
dtype=float)
bins_y = np.fromiter(
(np.nanpercentile(y, (i / n) * 100) for i in range(1, n + 1)),
dtype=float)
bins = [bins_x, bins_y]
except:
raise ValueError(f"Please define number of bins for binning method uniform_counts: bins = ['uniform_bins', n_bins]")
else:
# calculate bins with np.histogram_bin_edges(), even_width option == int
if bins in ['fd', 'doane', 'scott', 'stone', 'rice', 'sturges', 'sqrt'] or isinstance(bins, int):
if same_bins:
bins_xy = np.histogram_bin_edges([x, y], bins)
bins = [bins_xy, bins_xy]
else:
bins_x = np.histogram_bin_edges(x, bins)
bins_y = np.histogram_bin_edges(y, bins)
bins = [bins_x, bins_y]
elif bins == 'uniform_counts':
raise ValueError(f"Please define number of bins for binning method uniform_bins: bins = ['uniform_bins', n_bins]")
elif bins == 'unique_values':
if same_bins:
bins_xy = np.unique([x, y])
bins = [bins_xy, bins_xy]
else:
bins_x = np.unique(x)
bins_y = np.unique(y)
bins = [bins_x, bins_y]
else:
raise ValueError(f"Binning option {bins} not know.")
# always return bins as bin edges: [np.ndarray, np.ndarray]
return bins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get2DBins(x, y, binSizeX, binSizeY):\n\n result = []\n xlength = len(x)\n ylength = len(y)\n\n i = 0\n xcount = 0\n for i1 in range(0, xlength, binSizeX):\n i2 = i1 + binSizeX\n if i2 >= xlength:\n i2 = xlength - 1\n xcount += 1\n ycount = 0\n for... | [
"0.7028389",
"0.69049263",
"0.68282115",
"0.6756274",
"0.65525955",
"0.6534234",
"0.6517673",
"0.65156",
"0.6511489",
"0.6493547",
"0.6453416",
"0.63842267",
"0.630369",
"0.6285076",
"0.62552357",
"0.62531275",
"0.6207189",
"0.6184054",
"0.6180757",
"0.61535704",
"0.61472905"... | 0.6405554 | 11 |
Shannon Entropy Calculates the Shannon Entropy for the given data array x. | def entropy(x, bins, normalize=False, xy_probabilities=False):
# calculate probabilities if xy_probabilities == False
if xy_probabilities:
# if x does not sum up to 1, raise an error
if not np.isclose(sum(x),1,atol=0.0001):
raise ValueError('Probabilities in vector x do not sum up to 1.')
# add a small number to all probabilities if zero occurs
if x.any(0):
p = x + 1e-15
else:
p = x
else:
# get the bins
bins = np.histogram_bin_edges(x, bins)
# calculate the empirical probabilities
count = np.histogram(x, bins=bins)[0]
# if counts should be None, raise an error
if np.sum(count) == 0:
raise ValueError('The histogram cannot be empty. Adjust the bins to ' +
'fit the data')
# calculate the probabilities
p = (count / np.sum(count)) + 1e-15
# calculate the Shannon Entropy
if normalize:
# get number of bins
nbins = len(p)
# maximal entropy: uniform distribution
normalizer = np.log2(nbins)
return - p.dot(np.log2(p)) / normalizer
else:
return - p.dot(np.log2(p)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ShannonEntropy(self,s):\n e = s[np.nonzero(s)]**2 * np.log(s[np.nonzero(s)]**2)\n return np.sum(e)",
"def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))",
"def H(self, data):\n entropy = 0\n\n if not data:\n return entropy\n\n ... | [
"0.7339232",
"0.6906172",
"0.67469835",
"0.66126776",
"0.6580351",
"0.6566007",
"0.65266234",
"0.646055",
"0.6361494",
"0.6340554",
"0.62182045",
"0.6194352",
"0.6190961",
"0.6157335",
"0.6148306",
"0.61020863",
"0.6101131",
"0.60966253",
"0.6066495",
"0.60436225",
"0.6029721... | 0.6537447 | 6 |
Conditional Entropy Calculates the conditional Shannon Entropy for two discrete distributions. This metric gives the entropy of the distribution of x in case the distribution of y is known. | def conditional_entropy(x, y, bins, normalize=False):
# get the bins
bins = get_2D_bins(x, y, bins)
# calculate H(x,y) and H(y)
hjoint = joint_entropy(x,y,bins)
hy = entropy(y, bins[1])
if normalize:
normalizer = entropy(x, bins[0])
conditional_entropy = hjoint - hy
# check if conditional entropy and normalizer are very small
if conditional_entropy < 1e-4 and normalizer < 1e-4:
# return zero to prevent very high values of normalized conditional entropy
# e.g. conditional entropy = -1.3e-12, normalizer = -1.6e-12
# -> normalized conditional entropy = 812.5
return 0
else:
return conditional_entropy / normalizer
else:
return hjoint - hy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditional_entropy(f1, f2):\n\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\n return ce",
"def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )",
"def conditional_entropy(sel... | [
"0.7481201",
"0.6875717",
"0.6782211",
"0.6750487",
"0.6720426",
"0.6655979",
"0.6648373",
"0.6570259",
"0.6566688",
"0.64887154",
"0.64597607",
"0.64407265",
"0.63953054",
"0.6383221",
"0.63512045",
"0.63497704",
"0.63459283",
"0.63403004",
"0.6330119",
"0.6322664",
"0.62897... | 0.71850336 | 1 |
Mutual information Calculates the mutual information of a discrete distribution x given a known discrete distribution y. The mutual information is the amount of information that two distributions share. | def mutual_information(x, y, bins, normalize=False):
# assert array length
assert len(x) == len(y)
# get the bins
bins = get_2D_bins(x, y, bins)
# calculate entropy(x) and conditional_entropy(x,y)
hx = entropy(x, bins[0])
hcon = conditional_entropy(x, y, bins)
if normalize:
normalizer = np.min([entropy(x, bins[0]), entropy(y, bins[1])])
mutual_info = hx - hcon
# check if mutual info and normalizer are very small
if mutual_info < 1e-4 and normalizer < 1e-4:
# return zero to prevent very high values of normalized mutual information
# e.g. mutual information = -1.3e-12, normalizer = -1.6e-12
# -> normalized conditional entropy = 812.5
return 0
else:
return mutual_info / normalizer
else:
return hx - hcon | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n ... | [
"0.8168408",
"0.78968424",
"0.74779177",
"0.73788935",
"0.72612417",
"0.71773905",
"0.7003771",
"0.66112494",
"0.63962644",
"0.6395062",
"0.6346539",
"0.6204402",
"0.61775285",
"0.61775285",
"0.6012243",
"0.59877944",
"0.58945143",
"0.588451",
"0.5869148",
"0.5841374",
"0.580... | 0.7191145 | 5 |
Cross Entropy Calculates the cross entropy of two discrete distributions x and y. | def cross_entropy(x, y, bins, xy_probabilities=False):
# calculate probabilities if probabilities == False
if xy_probabilities:
# same bins for x and y -> same length of x and y if xy_probabilities == True
assert len(x) == len(y)
# if x does not sum up to 1, raise an error
if not np.isclose(sum(x),1,atol=0.0001):
raise ValueError('Probabilities in vector x do not sum up to 1.')
# if y does not sum up to 1, raise an error
if not np.isclose(sum(y),1,atol=0.0001):
raise ValueError('Probabilities in vector y do not sum up to 1.')
# add a small number to all probabilities if zero occurs
if x.any(0):
px = x + 1e-15
py = y + 1e-15
else:
px = x
py = y
else:
# get the bins, joint bins for x and y (same_bins=True)
bins = get_2D_bins(x, y, bins, same_bins=True)
# calculate unconditioned histograms
hist_x = np.histogram(x, bins=bins[0])[0]
hist_y = np.histogram(y, bins=bins[1])[0]
px = (hist_x / np.sum(hist_x)) + 1e-15
py = (hist_y / np.sum(hist_y)) + 1e-15
return - px.dot(np.log2(py)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n ... | [
"0.7399793",
"0.7246357",
"0.71943384",
"0.70277774",
"0.6669306",
"0.6637702",
"0.6602384",
"0.65894943",
"0.65266645",
"0.6473503",
"0.6437216",
"0.642684",
"0.63894004",
"0.6365542",
"0.6353329",
"0.63220906",
"0.628778",
"0.6279644",
"0.62760943",
"0.6269529",
"0.62406224... | 0.7348612 | 1 |
r"""Joint Entropy Calculates the joint entropy of two discrete distributions x and y. This is the combined Entropy of X added to the conditional Entropy of x given y. | def joint_entropy(x, y, bins):
# assert array length
assert len(x) == len(y)
# get the bins, x and y get their own bins in case of joint entropy
bins = get_2D_bins(x, y, bins)
# get the joint histogram
joint_hist = np.histogram2d(x, y, bins)[0]
# calculate the joint probability and add a small number
joint_p = (joint_hist / np.sum(joint_hist)) + 1e-15
# calculate and return the joint entropy
return - np.sum(joint_p * np.log2(joint_p)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n ... | [
"0.6370943",
"0.63690835",
"0.63631195",
"0.6334478",
"0.6209416",
"0.6186507",
"0.60127246",
"0.5941165",
"0.58904195",
"0.5855695",
"0.5840326",
"0.5787013",
"0.5770392",
"0.57627195",
"0.5750125",
"0.5739848",
"0.5735412",
"0.56943065",
"0.56919396",
"0.5672802",
"0.565470... | 0.7735844 | 0 |
r"""KullbackLeibler Divergence Calculates the KullbackLeibler Divergence between two discrete distributions x and y. X is considered to be an empirical discrete distribution while y is considered to be the real discrete distribution of the underlying population. | def kullback_leibler(x, y, bins, xy_probabilities=False):
if xy_probabilities:
# if x does not sum up to 1, raise an error
if not np.isclose(sum(x),1,atol=0.0001):
raise ValueError('Probabilities in vector x do not sum up to 1.')
# if y does not sum up to 1, raise an error
if not np.isclose(sum(y),1,atol=0.0001):
raise ValueError('Probabilities in vector y do not sum up to 1.')
# add a small number to all probabilities if zero occurs
if x.any(0):
px = x + 1e-15
py = y + 1e-15
else:
px = x
py = y
else:
# get the bins, joint bins for x and y (same_bins=True)
bins = get_2D_bins(x, y, bins, same_bins=True)
# calculate unconditioned histograms
hist_x = np.histogram(x, bins=bins[0])[0]
hist_y = np.histogram(y, bins=bins[1])[0]
#calculate probabilities
px = (hist_x / np.sum(hist_x))
py = (hist_y / np.sum(hist_y))
# calculate the cross entropy and unconditioned entropy of y
hcross = cross_entropy(px, py, bins, xy_probabilities=True)
hx = entropy(px, bins, xy_probabilities=True)
return hcross - hx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kl_bern(x, y):\n x = min(max(x, eps), 1-eps)\n y = min(max(y, eps), 1-eps)\n return x*log(x/y) + (1-x)*log((1-x)/(1-y))",
"def kl_divergence(x,y):\n\tassert (isinstance(x, BayesNet) and isinstance(y, BayesNet)), 'Must pass in BayesNet objects.'\n\tassert (x==y), 'Passed-in BayesNet objects are not s... | [
"0.70139825",
"0.6948134",
"0.6635383",
"0.6421419",
"0.63527554",
"0.6301051",
"0.62800944",
"0.62187314",
"0.6194453",
"0.6156323",
"0.6144021",
"0.61299276",
"0.61106426",
"0.6105154",
"0.6101856",
"0.6100986",
"0.6093369",
"0.6083329",
"0.60363257",
"0.6034415",
"0.601664... | 0.7132836 | 0 |
r"""JensenShannon Divergence Calculates the JensenShannon Divergence (JSD) between two discrete distributions x and y. JSD quantifies the difference (or similarity) between two probability distributions and uses the KL divergence to calculate a smoothed normalized score [0, 1] that is symmetrical. | def jensen_shannon(x, y, bins, calc_distance=False, xy_probabilities=False):
# assert array length
assert len(x) == len(y)
if xy_probabilities:
# if x does not sum up to 1, raise an error
if not np.isclose(sum(x), 1 ,atol=0.0001):
raise ValueError('Probabilities in vector x do not sum up to 1.')
# if y does not sum up to 1, raise an error
if not np.isclose(sum(y), 1, atol=0.0001):
raise ValueError('Probabilities in vector y do not sum up to 1.')
# add a small number to all probabilities if zero occurs
if x.any(0):
px = x + 1e-15
py = y + 1e-15
else:
px = x
py = y
else:
# get the bins, joint bins for x and y (same_bins=True)
bins = get_2D_bins(x, y, bins, same_bins=True)
# calculate unconditioned histograms
hist_x = np.histogram(x, bins=bins[0])[0]
hist_y = np.histogram(y, bins=bins[1])[0]
# calculate probabilities
px = (hist_x / np.sum(hist_x)) + 1e-15
py = (hist_y / np.sum(hist_y)) + 1e-15
# calculate m
pm = 0.5 * (px + py)
# calculate kullback-leibler divergence between px and pm & py and pm
kl_xm = kullback_leibler(px, pm, bins=bins, xy_probabilities=True)
kl_ym = kullback_leibler(py, pm, bins=bins, xy_probabilities=True)
if calc_distance:
return (0.5 * kl_xm + 0.5 * kl_ym)**0.5
else:
return (0.5 * kl_xm + 0.5 * kl_ym) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_js_divergence(df_1, df_2, n_bins=30):\n a = np.concatenate((df_1, df_2), axis=0)\n e, p = prob_mass_fun(df_1, n = n_bins, range = (a.min(), a.max()))\n _, q = prob_mass_fun(df_2, n = e, range = (a.min(), a.max()))\n\n return scipy.spatial.distance.jensenshannon(p, q)",
"def js_divergence(... | [
"0.7116401",
"0.6758938",
"0.6689075",
"0.654391",
"0.6027384",
"0.60244334",
"0.6005269",
"0.59004337",
"0.58797586",
"0.58616793",
"0.58290076",
"0.58030003",
"0.57559144",
"0.57503366",
"0.569734",
"0.5691851",
"0.5684341",
"0.5684016",
"0.5652677",
"0.5649112",
"0.5614351... | 0.6525315 | 4 |
Method for parsing CLI arguments using argparse. | def parse_parameters():
parser = argparse.ArgumentParser(
description="Get all dependent review IDs")
parser.add_argument("-r", "--review-id", type=str, required=True,
help="Review ID")
parser.add_argument("-o", "--out-file", type=str, required=False,
help="The out file with the reviews IDs")
return parser.parse_args() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_cli_arguments():\n parser = argparse.ArgumentParser('Generates a MANIFEST file used by the '\n 'HMP2 AnADAMA2 workflows.')\n parser.add_argument('-b', '--broad-data-sheet', required=True,\n help='Broad data product status spreadsheet. '\n ... | [
"0.80792505",
"0.8012675",
"0.78432906",
"0.78108615",
"0.7765357",
"0.7751876",
"0.77110696",
"0.76705295",
"0.7647746",
"0.7644992",
"0.7644233",
"0.76380914",
"0.75653404",
"0.7562569",
"0.75440955",
"0.7535946",
"0.75321084",
"0.75190026",
"0.75150883",
"0.7505613",
"0.74... | 0.0 | -1 |
Main method to get dependent review IDs of a specific review request on the ReviewBoard. | def main():
parameters = parse_parameters()
review_request_url = "%s/api/review-requests/%s/" % (REVIEWBOARD_URL,
parameters.review_id)
handler = ReviewBoardHandler()
review_request = handler.api(review_request_url)["review_request"]
review_ids = handler.get_dependent_review_ids(review_request)
if parameters.out_file:
with open(parameters.out_file, 'w') as f:
for r_id in review_ids:
f.write("%s\n" % (str(r_id)))
else:
for r_id in review_ids:
print("%s\n" % (str(r_id))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_review_request(self, rid):\r\n rsp = self.api_call('api/review-requests/%s/' % rid)\r\n return rsp['review_request']",
"def get_review_request(self, request_id, api_root):\n try:\n request = api_root.get_review_request(review_request_id=request_id)\n except APIError, e:\n ... | [
"0.57654417",
"0.5477173",
"0.5378847",
"0.5101541",
"0.5080031",
"0.4982286",
"0.49632528",
"0.49589026",
"0.49061635",
"0.48880798",
"0.488128",
"0.4835317",
"0.48325068",
"0.4829637",
"0.48200688",
"0.48102397",
"0.47959515",
"0.4773191",
"0.4731234",
"0.4722772",
"0.47219... | 0.6459412 | 0 |
Initalize with a usersupplied list of segments. | def __init__(self, segments, lemma = None, case = None):
self.segments = segments
if isinstance(self.segments, str):
self.segments = [Segment.new_segment(s) for s in self.segments]
self.lemma = lemma
self.case = case | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_segments(self):\n for strand in self.strand_list:\n strand.construct_segment()",
"def set_segments(self, segments):\n self.send_command(Command.SET_SEGMENT_COUNT, [segments])",
"def form_segment(self, node_oid):\n # init empty segment and stuff\n new_segment = S... | [
"0.6232747",
"0.596336",
"0.58711517",
"0.5702215",
"0.55154556",
"0.5394213",
"0.53759134",
"0.53305984",
"0.5308964",
"0.529063",
"0.5197425",
"0.51839024",
"0.5133967",
"0.5053822",
"0.50320536",
"0.5010542",
"0.50038457",
"0.4999929",
"0.49838173",
"0.4962347",
"0.4960938... | 0.6051361 | 1 |
Create a WordForm of the given CV shape with random segments. | def random_segs(cls, shape, lemma = None, case = None):
# For each C or V segment in `shape`, initialize a random Segment of the
# appropriate type. Initialize a new WordForm with all these Segments.
return cls([Segment(seg_type = seg) for seg in shape], lemma, case) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_word(self):\r\n\r\n template = self.word_constructions.get()\r\n word = \"\"\r\n for c in template:\r\n if c == \"v\":\r\n letter = self.get_letter(100)\r\n else:\r\n letter = self.get_letter(0)\r\n word += letter\r\n\r\... | [
"0.61004114",
"0.5693294",
"0.55114466",
"0.5438077",
"0.53612614",
"0.5311946",
"0.52376354",
"0.51894677",
"0.5161035",
"0.5152379",
"0.5143327",
"0.5127287",
"0.51046485",
"0.50831926",
"0.50809175",
"0.5080614",
"0.5072338",
"0.5021304",
"0.50183684",
"0.4984602",
"0.4969... | 0.72299457 | 0 |
Add the suffix vowel. | def add_suffix(self, suffix):
# Append the suffix vowel to this WordForm.
self.segments.append(Segment.new_segment(suffix)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_suffix(word, suffix):\n suffix, sep, rest = suffix.partition(' ')\n expanded = _add_suffix(word, suffix)\n return expanded + sep + rest",
"def get_vowel_names():",
"def _replace_suffix(self, word, suffix, replacement):\n assert word.endswith(suffix), \"Given word doesn't end with given ... | [
"0.5983021",
"0.5954164",
"0.59408945",
"0.5778313",
"0.5686185",
"0.5563964",
"0.5542913",
"0.55272454",
"0.54683185",
"0.5462567",
"0.54531056",
"0.5446963",
"0.54377186",
"0.5427365",
"0.53498006",
"0.53402376",
"0.53384125",
"0.5302798",
"0.52940315",
"0.5291557",
"0.5278... | 0.7781676 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.