Dict:\n\n xp_record = dict()\n xp_record['position'] = summary.find('h3').text.strip()\n company = summary.find_all('p', {'class': 'pv-entity__secondary-title'})[0]\n xp_record['company'] = \"; \".join( [ line.strip() for line in company.text.split('\\n')\n if line.strip() != ''] )\n # %%\n for xp_line in summary.find_all('h4'):\n fld_name, value = [span.text.strip() for span in xp_line.find_all('span') ]\n if fld_name == 'Fechas de empleo':\n xp_record['period_raw'] = value\n period = _extract_period( value )\n xp_record['period'] = period\n # print( period )\n xp_record['duration'] = np.round( (period[1] - period[0]).total_seconds()\n / SECS_IN_YEAR, 2)\n elif fld_name == 'Duración del empleo':\n xp_record['duration_raw'] = value\n elif fld_name == 'Ubicación':\n xp_record['location_raw'] = value\n # print( f'location: {value}')\n elif fld_name.startswith('LinkedIn me ayud'):\n continue\n else:\n print( \"proc_employment_summary: \", fld_name, value )\n # %%\n # pprint( xp_record )\n # %%\n return xp_record\n # %%","def treatments_dict():\n treats = 2\n data = pd.DataFrame(\n data={\"id\": np.arange(100), \"block\": [0] * 40 + [1] * 30 + [2] * 30}\n )\n idx_col = \"id\"\n size = 90\n\n treatments = stochatreat(\n data=data,\n block_cols=[\"block\"],\n treats=treats,\n idx_col=idx_col,\n size=size,\n random_state=42,\n )\n\n treatments_dict = {\n \"data\": data,\n \"idx_col\": idx_col,\n \"size\": size,\n \"treatments\": treatments,\n }\n\n return treatments_dict","def lf_findall_interp_with_spikes(report):\n\n if 'interpretation' in report.sections.keys():\n interpretation = report.sections['interpretation']\n interp_text = interpretation['text']\n return abnormal_interp_with_spikes(interp_text)\n else:\n candtext = get_section_with_name(SEIZURE_SECTION_NAMES_LOWER, report)\n if candtext:\n return abnormal_interp_with_spikes(candtext)\n else:\n return ABSTAIN_VAL","def get_hotspot_provenance(self, suptitle, scenario, ancestor_files):\n caption = (f\"{suptitle}. Calculated for seasons \"\n f\"{self.seasons[0].upper()}, \"\n f\"{self.seasons[1].upper()} and {self.seasons[2].upper()} \"\n f\"in the future periods {self.cfg['future_periods'][0]} \"\n f\"and {self.cfg['future_periods'][1]} \"\n f\"for CMIP5 {self.formatter(f'cmip5-{scenario}')} \"\n f\"and CMIP6 {self.formatter(f'cmip6-{scenario}')}\")\n\n record = {\n 'caption': caption,\n 'statistics': ['anomaly', 'diff'],\n 'domains': ['reg'],\n 'plot_types': ['map'],\n 'authors': [\n 'cos_josep',\n ],\n 'references': [\n 'cos22esd',\n ],\n 'ancestors': ancestor_files,\n }\n return record","def getDictWells(self):\n #Method begins here\n #nx=self.__grid['nx'] #From the geometry in grid\n ny=self.__grid['ny']\n nz=self.__grid['nz']\n minx=self.__grid['ox']\n miny=self.__grid['oy']\n minz=self.__grid['oz']\n rx=self.__grid['dx']\n ry=self.__grid['dy']\n rz=self.__grid['dz']\n \n # well package\n # Remember to use zero-based layer, row, column indices!\n lcoordw=np.zeros((self.__nwells,3),dtype=np.int32)\n for i in range (self.__nwells):\n lcoordw[i,0]=floor((self.__dflst.iloc[i,3]-minx)/rx)\n #In MODFLOW y ans z coordinates are inverted\n lcoordw[i,1]=floor((miny+ry*ny-self.__dflst.iloc[i,4])/ry)\n lcoordw[i,2]=floor((minz+rz*nz-self.__dflst.iloc[i,5])/rz)\n \n nper=self.__df.getForcPer()\n wel_sp = {} \n for i in range(nper):\n lst=[]\n for j in range(self.__nwells):\n pumping_rate=self.__dfwells.iloc[i+1,j+1]\n lst.append( [lcoordw[j,2], lcoordw[j,1], lcoordw[j,0], pumping_rate] )\n wel_sp[i]=lst\n print(wel_sp)\n \n print('*--- Succesfull reading of wells ---*')\n \n return wel_sp","def intro_slide(prs):\n # pylint: disable=too-many-locals\n slide = prs.slides.add_slide(prs.slide_layouts[BLANK_SLIDE])\n slide = slide_title_header(\n slide, 'Explanation of Analysis', include_time=False)\n\n explanation_file_path = os.path.join(\"resources\", \"metric_explanation.txt\")\n\n if os.path.exists(explanation_file_path):\n with open(explanation_file_path, 'r', encoding='utf-8') as filer:\n content = filer.readlines()\n\n content2 = []\n for cont in content:\n cropped = cont.split('\\r\\n')[0]\n content2.append(cropped)\n content = content2\n filer.close()\n\n top = Inches(0.81)\n left = Inches(0.42)\n width = Inches(11)\n height = Inches(6)\n txt_box = slide.shapes.add_textbox(left, top, width, height)\n text_frame = txt_box.text_frame\n text_frame.word_wrap = True\n\n paragraph = text_frame.paragraphs[0]\n paragraph.text = content[0]\n paragraph.font.size = Pt(12)\n paragraph.font.bold = True\n\n for i in range(1, len(content)):\n paragraph = text_frame.add_paragraph()\n paragraph.text = content[i]\n\n if i == 5:\n paragraph.font.size = Pt(12)\n paragraph.font.bold = True\n else:\n paragraph.font.size = Pt(10)\n paragraph.font.bold = False\n\n else:\n print(f\"{WARNING}WARNING - file 'metric_explanation.txt' not found.{NORMAL}\")\n\n return prs","def lf_abnormal_interp_with_sharps(report):\n if 'interpretation' in report.sections.keys():\n interpretation = report.sections['interpretation']\n interp_text = interpretation['text']\n return abnormal_interp_with_sharps(interp_text)\n elif 'summary' in report.sections:\n return abnormal_interp_with_sharps(report.sections['summary']['text'])\n elif 'findings' in report.sections: # fall back to look in the findings \n if 'summary' in report.sections['findings']: # fall back to look for a summary instead\n return abnormal_interp_with_sharps(report.sections['findings']['summary'])\n if 'impression' in report.sections['findings']:\n return abnormal_interp_with_sharps(report.sections['findings']['impression'])\n return ABSTAIN_VAL\n elif 'narrative' in report.sections: # fall back to look in the findings \n ky = 'narrative'\n if 'summary' in report.sections[ky]: # fall back to look for a summary instead\n return abnormal_interp_with_sharps(report.sections[ky]['summary'])\n if 'impression' in report.sections[ky]:\n return abnormal_interp_with_sharps(report.sections[ky]['impression']) \n return ABSTAIN_VAL \n else:\n return ABSTAIN_VAL","def _read_stix_spec_file(spec_file):\n sdict = {}\n with fits.open(spec_file) as hdul:\n for i in range(5):\n sdict[str(i)] = [hdul[i].header, hdul[i].data]\n return sdict","def extract_summary(self):\n metadata = {}\n\n ## document Id\n documentId = self.tree.find(\"./id\")\n documentId = documentId.attrib['root'] if documentId is not None and \"root\" in documentId.attrib else \"\"\n metadata[\"documentId\"] = documentId\n\n ## setId\n setid = self.tree.find(\"./setId\")\n setid = setid.attrib['root'] if setid is not None and \"root\" in setid.attrib else \"\"\n metadata[\"setId\"] = setid\n\n ## version number\n splversion = self.tree.find(\"./versionNumber\")\n versionNumber = \"\"\n if splversion is not None:\n if \"value\" in splversion.attrib:\n versionNumber = splversion.attrib[\"value\"]\n metadata[\"versionNumber\"] = versionNumber\n\n ## product type \n code = self.tree.find(\"./code\")\n check_if_attrib_exists = lambda x, key: x[key] if key in x else ''\n product_type = check_if_attrib_exists(code.attrib, \"displayName\")\n metadata[\"productType\"] = product_type\n\n ## title\n title_text = self.tree_et.xpath(\"./title//text()\")\n title = (\" \".join([self.strip_newline_tab(t) for t in title_text]) if len(title_text) > 0 else \"\")\n metadata[\"title\"] = title\n\n ## manufacturer\n manufacturer = self.tree.find(\"./author//representedOrganization/name\")\n if manufacturer != None and manufacturer.text != None:\n manufacturer = self.strip_newline_tab(manufacturer.text)\n else:\n manufacturer = \"\"\n metadata[\"manufacturer\"] = manufacturer\n\n ## effectivetime\n effectiveTime = self.tree_et.xpath(\"./effectiveTime/@value\")\n effectiveTime = self.__normalize_date(effectiveTime)\n\n metadata[\"effectiveTime\"] = effectiveTime\n metadata[\"publishedDate\"] = effectiveTime\n\n ## From manufacturedProduct section\n brand_name = self.tree_et.xpath(\".//manufacturedProduct//name\")\n brand_name = self.strip_newline_tab(brand_name[0].text) if len(brand_name) > 0 else \"\"\n metadata[\"drugName\"] = brand_name\n\n route = self.tree_et.xpath(\".//manufacturedProduct//formCode/@code\")\n route = self.strip_newline_tab(route[0]) if len(route) > 0 else \"\"\n metadata[\"routeOfAdministration\"] = route\n\n product_ndc = self.tree_et.xpath(\".//manufacturedProduct//code/@code\")\n product_ndc = self.strip_newline_tab(product_ndc[0]) if len(product_ndc) > 0 else \"\"\n metadata[\"ndcCode\"] = product_ndc\n\n generic_name = self.tree_et.xpath(\".//manufacturedProduct//asEntityWithGeneric//genericMedicine/name\")\n generic_name = self.strip_newline_tab(generic_name[0].text) if len(generic_name) > 0 else \"\"\n metadata[\"genericName\"] = generic_name\n\n ## dosage form\n dosage_form = self.tree_et.xpath(\".//manufacturedProduct//formCode/@displayName\")\n dosage_form = dosage_form[0] if len(dosage_form) > 0 else \"\"\n metadata[\"dosageForm\"] = dosage_form\n\n # active ingredients\n substance_name = sorted([self.strip_newline_tab(a.text) for a in\n self.tree_et.xpath(\".//.//manufacturedProduct//activeMoiety/activeMoiety/name\")])\n substance_name = \", \".join(set(substance_name))\n metadata[\"substanceName\"] = substance_name\n\n ## inactive ingredients\n inactive_ingredients = sorted([self.strip_newline_tab(inactive.text) for inactive in self.tree_et.xpath(\n \".//manufacturedProduct//inactiveIngredient/inactiveIngredientSubstance/name\")])\n\n if len(inactive_ingredients) == 0:\n inactive_ingredients = \"\"\n else:\n inactive_ingredients = \",\".join(set(inactive_ingredients))\n\n metadata[\"inactiveIngredients\"] = inactive_ingredients\n\n ## other ingredients\n ingredients = sorted([self.strip_newline_tab(ingredient.text) for ingredient in\n self.tree_et.xpath(\".//manufacturedProduct//ingredient/ingredientSubstance/name\")])\n\n if len(ingredients) == 0:\n ingredients = \"\"\n else:\n ingredients = \", \".join(set(ingredients))\n metadata[\"ingredients\"] = ingredients\n\n # marketing_category\n marketing_category = self.tree_et.xpath(\".//manufacturedProduct/subjectOf/approval/code/@displayName\")\n marketing_category = self.strip_newline_tab(marketing_category[0]) if len(marketing_category) > 0 else \"\"\n metadata[\"marketingCategory\"] = marketing_category\n\n # consumed in\n consumed_in = self.tree_et.xpath(\n \".//manufacturedProduct//consumedIn/substanceAdministration/routeCode/@displayName\")\n consumed_in = consumed_in[0] if len(consumed_in) > 0 else \"\"\n metadata[\"consumedIn\"] = consumed_in\n\n # revision date\n marketing_date = self.tree_et.xpath(\".//manufacturedProduct//marketingAct/effectiveTime/low/@value\")\n marketing_date = self.__normalize_date(marketing_date)\n metadata[\"marketingDate\"] = marketing_date\n\n return metadata","def drawsheet_parse(text):\n logging.debug(\"################ PARSING DRAW ##################\")\n\n month = \"({})\".format('|'.join(RE_MONTHS))\n\n patterns = (\n ('surface', r\"Hard|Outdoor Hard|Red Clay|Green Clay|Clay|\"\n r\"Grass|Indoor Hard|Carpet|Indoor Carpet\"),\n ('date', r\"\\d{1,2}(th)? ?- ?\\d{1,2}(th)? \" + month + r\",? \\d{4}|\" +\n month + r\" \\d{1,2}(th)? ?- ?\\d{1,2}(th)?,? \\d{4}\"),\n ('year', r\"\\d{4}\"),\n ('seed', r\"(?<=\\[)\\d+(?=\\])|(?<=\\[ )\\d+(?=\\ ])\"),\n ('round', r\"(1st|2nd|3rd) Round|1/8|1/4|1/2\"),\n ('class', r\"WTA( [A-Za-z0-9]+)*|US Open|\"\n r\"French Open|Australian Open|Wimbledon\"),\n ('orderedname', r\"[A-Z][a-z]+(( |-)[A-Z][a-z]+)*\"\n r\" ([A-Z]+(( |-)[A-Z]+)*)(?= |$)\"),\n ('fullname', r\"(?:^| )[Bb][Yy][Ee](?:$| )|([A-Z]+(( |-)[A-Z]+)*,\\s\"\n r\"[A-Z][a-zA-Z]*(( |-)([A-Z][a-zA-Z]*[a-z]))*)\"),\n #('shortname', r\"[A-Z]\\. ?[A-Z]+(( |-)[A-Z]+)*\"),\n ('shortname', r\"[A-Z]\\. ?[A-Za-z]+(( |-)[A-Za-z]+)*\"),\n ('country', r\"(?:(?!RET)[A-Z]{3}|\\([A-Z]{3}\\))(?= |$)\"),\n ('score',\n r\"([0-7][/-]?[0-7](\\(\\d+\\))?)( [0-7][/-]?[0-7](\\(\\d+\\))?){0,2}\"\n r\" ([Rr]et\\.|[Rr]et'd|[Rr]etired|[Rr]et)\"\n r\"|([0-7][/-]?[0-7](\\(\\d+\\))?)( [0-7][/-]?[0-7](\\(\\d+\\))?){1,2}\"\n r\"|([0-7]/?[0-7](\\(\\d+\\))? ){2}[\\d+]/[\\d+]\"\n r\"|(wo.|[Ww]alkover)\"),\n ('prize', r\"\\$[0-9,]+(?= |$)\"),\n ('number', r\"\\d{1,3}\\.?(?= |$)\"),\n ('city', r\"[A-Z][A-Za-z]*( [A-Z][A-Za-z]+)*,\"\n r\"( [A-Z][A-Z],)? (USA|[A-Z][a-z]*)\"),\n ('status', r\"(^|(?<=\\[|\\(| ))(Q|LL|W|WC)((?=\\]|\\)| )|$)\"),\n ('string', r\"([A-Za-z&,\\']+)( [A-Z&a-z$,]+)*\"),\n )\n \n pattern = re.compile('|'.join([\"(?P<{}>{})\".format(k, v) \n for k, v in patterns]))\n data = { k: [] for k, v in patterns}\n\n short_to_fullnames = {}\n ordered_to_fullnames = {}\n def add_to_fullname_conversion_table(fullname, x, y):\n nm = re.match('(.*), (.)', fullname)\n name = nm.group(2) + \". \" + nm.group(1)\n if name not in short_to_fullnames:\n short_to_fullnames[name] = []\n\n short_to_fullnames[name] += [(fullname, (x,y))]\n\n nm = re.match('(.*), (.*)', fullname)\n name = nm.group(2) + \" \" + nm.group(1)\n ordered_to_fullnames[name] = fullname\n\n\n re_skip = re.compile(r'Seeded +Players')\n # Find scores, names, etc\n y = 0\n skipping_page = False\n\n # collect the data\n width = 0\n lines = text.split('\\n');\n for line in lines:\n if skipping_page:\n if chr(12) in line:\n skipping_page = False\n else:\n continue\n\n if (re_skip.search(line)):\n # skip the seeding/info section, it's useless\n skipping_page = True\n continue;\n\n for m in pattern.finditer(line):\n for group, match in m.groupdict().items():\n if match is not None:\n match = match.strip()\n x1 = m.start(group)\n x2 = m.end(group)\n\n if x2 > width:\n width = x2\n\n data[group] += [(match, ((x1, x2), y))]\n\n if group == 'fullname' and match.upper() != \"BYE\":\n add_to_fullname_conversion_table(match, (x1, x2), y)\n\n y += 1\n\n # hack to catch country codes that got attached to fullnames\n if len(data['country']) > 0:\n cc_re = re.compile(r'^([A-Z]{3}) (.*)')\n # find known country codes\n countries = set(list(zip(*data['country']))[0])\n if len(data['fullname']) > len(data['country']):\n for n, point in data['fullname']:\n m = cc_re.match(n)\n if m and m.group(1) in countries:\n country = m.group(1)\n name = m.group(2)\n idx = data['fullname'].index((n, point))\n del data['fullname'][idx]\n (x1, x2), y = point\n data['fullname'].insert(idx, (name, ((x1 + 4), x2, y)))\n data['country'].append((country, ((x1, x1 + 3), y)))\n add_to_fullname_conversion_table(name)\n if len(data['fullname']) == len(data['country']):\n # we're done\n break\n\n # find any possible country codes\n if len(data['fullname']) > len(data['country']):\n for n, point in data['fullname']:\n m = cc_re.match(n)\n if m:\n country = m.group(1)\n name = m.group(2)\n idx = data['fullname'].index((n, point))\n del data['fullname'][idx]\n (x1, x2), y = point\n data['fullname'].insert(idx, (name, ((x1 + 4, x2), y)))\n data['country'].append((country, ((x1, x1 + 3), y)))\n add_to_fullname_conversion_table(name)\n if len(data['fullname']) == len(data['country']):\n # we're done\n break\n\n orderednames = []\n for n, point in data['orderedname']:\n try:\n n = ordered_to_fullnames[n]\n orderednames += [(n, point)]\n except KeyError:\n data['string'] += [(n, point)]\n\n data['orderedname'] = orderednames\n\n def distance(a, b):\n ax1, ax2 = a[0]\n bx1, bx2 = b[0]\n ax = (ax1 + ax2) / 2\n bx = (bx1 + bx2) / 2\n dx = float(ax - bx) / 10\n dy = float(a[1] - b[1])\n\n return math.sqrt(dx * dx + dy * dy)\n\n # assign shortnames to longnames\n # some people share a shortname, so assign to \n # the longname that is closest\n shortnames = []\n for n, point in data['shortname']:\n n = n.upper()\n if n[2] != ' ':\n short = n[0:2] + ' ' + n[2:]\n else:\n short = n\n\n try:\n shorts = short_to_fullnames[short]\n\n short = min(shorts, key=lambda s: distance(s[1], point))\n shortnames += [(short[0], point)]\n except KeyError:\n data['string'] += [(n, point)]\n\n data['shortname'] = shortnames\n\n logging.debug(pprint.pformat(data))\n\n return data, width;","def processSlideInfo(extractionCtx: ExtractionContext) -> None:\n\n\tlogger = extractionCtx.logger\n\n\t# get a list of mapping and slide info\n\tmappingInfo = _getMappingInfo(extractionCtx)\n\tif not mappingInfo:\n\t\treturn\n\n\t# Process each pair\n\tfor info in mappingInfo:\n\t\tif info.slideInfo.version == 2:\n\t\t\t_V2Rebaser(extractionCtx, info).run()\n\t\telif info.slideInfo.version == 3:\n\t\t\t_V3Rebaser(extractionCtx, info).run()\n\t\telse:\n\t\t\tlogger.error(\"Unknown slide version.\")","def find_patches_from_slide(slide_path, filter_non_tissue=True):\n\n #sampletotal = pd.DataFrame([])\n #base_truth_dir = Path(BASE_TRUTH_DIR)\n #anno_path = Path(anno_path)\n #slide_contains_tumor = osp.basename(slide_paths[i]).startswith('tumor_')\n print (slide_path)\n\n dimensions = []\n \n with openslide.open_slide(slide_path) as slide:\n dtotal = (slide.dimensions[0] / 224, slide.dimensions[1] / 224)\n thumbnail = slide.get_thumbnail((dtotal[0], dtotal[1]))\n thum = np.array(thumbnail)\n ddtotal = thum.shape\n dimensions.extend(ddtotal)\n hsv_image = cv2.cvtColor(thum, cv2.COLOR_BGR2HSV)\n h, s, v = cv2.split(hsv_image)\n hthresh = threshold_otsu(h)\n sthresh = threshold_otsu(s)\n vthresh = threshold_otsu(v)\n # be min value for v can be changed later\n minhsv = np.array([hthresh, sthresh, 70], np.uint8)\n maxhsv = np.array([180, 255, vthresh], np.uint8)\n thresh = [minhsv, maxhsv]\n #extraction the countor for tissue\n\n rgbbinary = cv2.inRange(hsv_image, thresh[0], thresh[1])\n _, contours, _ = cv2.findContours(rgbbinary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n bboxtcols = ['xmin', 'xmax', 'ymin', 'ymax']\n bboxt = pd.DataFrame(columns=bboxtcols)\n for c in contours:\n (x, y, w, h) = cv2.boundingRect(c)\n bboxt = bboxt.append(pd.Series([x, x+w, y, y+h], index = bboxtcols), ignore_index=True)\n bboxt = pd.DataFrame(bboxt)\n \n xxmin = list(bboxt['xmin'].get_values())\n xxmax = list(bboxt['xmax'].get_values())\n yymin = list(bboxt['ymin'].get_values())\n yymax = list(bboxt['ymax'].get_values())\n\n xxxmin = np.min(xxmin)\n xxxmax = np.max(xxmax)\n yyymin = np.min(yymin)\n yyymax = np.max(yymax)\n\n dcoord = (xxxmin, xxxmax, yyymin, yyymax)\n\n dimensions.extend(dcoord)\n\n # bboxt = math.floor(np.min(xxmin)*256), math.floor(np.max(xxmax)*256), math.floor(np.min(yymin)*256), math.floor(np.max(yymax)*256)\n \n samplesnew = pd.DataFrame(pd.DataFrame(np.array(thumbnail.convert('L'))))\n print(samplesnew)\n # very critical: y value is for row, x is for column\n samplesforpred = samplesnew.loc[yyymin:yyymax, xxxmin:xxxmax]\n\n dsample = samplesforpred.shape\n\n dimensions.extend(dsample)\n\n np.save ('dimensions_%s' % (osp.splitext(osp.basename(slide_paths[i]))[0]), dimensions)\n\n print(samplesforpred)\n\n samplesforpredfinal = pd.DataFrame(samplesforpred.stack())\n\n print(samplesforpredfinal)\n\n samplesforpredfinal['tile_loc'] = list(samplesforpredfinal.index)\n\n samplesforpredfinal.reset_index(inplace=True, drop=True)\n\n\n samplesforpredfinal['slide_path'] = slide_paths[i]\n\n\n print(samplesforpredfinal)\n\n\n return samplesforpredfinal","def __local_sp(soup):\n news = []\n titles = soup.find('section', class_='col-xs-12 maislidas-interno').find_all('h3', class_='fifth')\n\n for title in titles:\n news.append(dict(title=title.string, link=title.parent['href']))\n return news","def parse(self):\n result = {}\n if self.detail_statu:\n sel = Selector(text=self.driver.page_source)\n\n fact_table = sel.xpath(\n '//div[@class=\"facts-table\"]//text()').extract()\n result['facts'] = [list(i)\n for i in zip(fact_table[:: 2],\n fact_table[1:: 2])]\n\n tax_table = sel.xpath(\n '//div[@class=\"tax-values\"]//text()').extract()\n result['taxs'] = [list(i)\n for i in zip(tax_table[:: 2],\n tax_table[1:: 2])]\n\n listing_detail = sel.xpath(\n '//div[@class=\"amenities-container\"]//text()').extract()\n result['detail'] = listing_detail\n result['page_source'] = self.driver.page_source\n self.detail_statu = False\n else:\n self.log.warning(\n '---- Detail page url out of reach, use .search() first to get the detail page')\n return result","def get_annotation(file, pos_dict, ex_dict, tag):\n results = {}\n with open(file, 'r', encoding='utf-8') as f:\n par = 0\n par_results = []\n for line in f:\n if line is \"\\n\":\n if par_results:\n if \"paragraph\" + str(par) in results:\n results[\"paragraph\" + str(par)].append(par_results)\n else:\n results[\"paragraph\" + str(par)] = par_results\n par += 1\n par_results = []\n continue\n for q in pos_dict:\n qmatches = re.finditer(q, line, re.I)\n for qmatch in qmatches:\n exclude = 0\n for exItem in ex_dict:\n exMatches = re.finditer(exItem.rstrip('\\n'), line, re.I)\n for exMatch in exMatches:\n if exMatch and qmatch.start(1) is exMatch.start(1):\n exclude = 1\n # Save result to list of results with appropriate tag\n if (qmatch and exclude is 0):\n try:\n #results.append((int(qmatch.group(1)),int(qmatch.group(2)), int(qmatch.group(len(qmatch.groups()))), tag))\n par_results.append({\"sentID\": int(qmatch.group(1)), \"spanStart\":int(qmatch.group(2)), \"spanEnd\":int(qmatch.group(len(qmatch.groups()))), \"tag\": tag})\n except TypeError:\n # TypeErrors are usually raised when one of the capture groups of fields is empty (NoneType)\n # Simply throw a warning message and keep going\n print(\"Warning! Something went wrong while matching expression'\" + q + \"' in line '\" + line[0:50] + \"...'\")\n return results","def return_figures():\n # Add New York Times API Key\n nyt = NYTAPI(\"AsjeHhqDYrePA2GMPpYoY1KAKAdG7P99\")\n\n # Select Year and Month of articles\n data = nyt.archive_metadata(\n date = datetime.datetime(2020, 7, 1)\n )\n\n def data_to_df(data):\n # Initiate list for restructured information\n data_list = []\n\n # Collect Data from API dictionary\n for article in data:\n new_data = [article.get(\"section_name\"),\n article.get(\"news_desk\"),\n article.get(\"pub_date\"),\n article.get(\"headline\").get(\"main\"),\n article.get(\"abstract\"),\n article.get(\"lead_paragraph\"),\n article.get(\"type_of_material\"),\n article.get(\"word_count\")]\n # Append list of information from article to data list\n data_list.append(new_data)\n\n # Convert data list to DataFrame\n df = pd.DataFrame(data_list, columns=[\"section_name\",\"news_desk\", \"pub_date\", \"headline\", \"abstract\", \"lead_paragraph\", \"type_of_material\", \"word_count\"])\n\n return df\n\n df = data_to_df(data)\n\n # first chart plots section distribution\n # as a pie chart\n graph_one = []\n df_one = df.copy()\n\n # filter and sort values for the visualization\n # filtering plots the articles in decreasing order by their values\n labels = df_one.section_name.value_counts().index\n values = df_one.section_name.value_counts().values\n\n graph_one.append(\n go.Pie(\n labels=labels,\n values=values,\n hole=.6,\n textposition=\"inside\"\n )\n )\n\n layout_one = dict(title = 'Distribution of sections of this months New York Times articles')\n\n # second chart plots section distribution\n # as a pie chart\n graph_two = []\n df_two = df.copy()\n\n # filter and sort values for the visualization\n # filtering plots the articles in decreasing order by their values\n labels = df_two.news_desk.value_counts().index\n values = df_two.news_desk.value_counts().values\n\n graph_two.append(\n go.Pie(\n labels=labels,\n values=values,\n hole=.6,\n textposition=\"inside\"\n )\n )\n\n layout_two = dict(title = 'Distribution of news desk of this months articles')\n\n # third chart plots section distribution\n # as a pie chart\n graph_three = []\n df_three = df.copy()\n\n # filter and sort values for the visualization\n # filtering plots the articles in decreasing order by their values\n labels = df_three.type_of_material.value_counts().index\n values = df_three.type_of_material.value_counts().values\n\n graph_three.append(\n go.Pie(\n labels=labels,\n values=values,\n hole=.6,\n textposition=\"inside\"\n )\n )\n\n layout_three = dict(title = 'Distribution for type of material of this months articles')\n\n # fourth chart plots section distribution\n # as a pie chart\n graph_four = []\n\n # Convert publishing date columns to datetime format\n df[\"pub_date\"] = pd.to_datetime(df[\"pub_date\"]).dt.date\n\n df_four = df.copy()\n df_four = df_four.pub_date.value_counts().to_frame().sort_index()\n\n # filter and sort values for the visualization\n # filtering plots the articles in decreasing order by their values\n x_val = df_four.index\n y_val = df_four.values\n\n graph_four.append(\n go.Scatter(\n x=df_four.index,\n y=df_four[\"pub_date\"],\n mode=\"lines\",\n name=\"Articles\"\n )\n )\n\n layout_four = dict(title = 'Number of articles published by days')\n\n # fourth chart plots section distribution\n # as a pie chart\n graph_five = []\n\n # Calculate average number of words for this months articles\n avg_word_count = round(df.word_count.mean(),0)\n\n graph_five.append(\n go.Table(\n header=dict(values=['Average Word Count']),\n cells=dict(values=[avg_word_count])\n )\n )\n\n layout_five = dict(title = '')\n\n # append all charts\n figures = []\n figures.append(dict(data=graph_one, layout=layout_one))\n figures.append(dict(data=graph_two, layout=layout_two))\n figures.append(dict(data=graph_three, layout=layout_three))\n figures.append(dict(data=graph_four, layout=layout_four))\n figures.append(dict(data=graph_five, layout=layout_five))\n\n return figures","def import_landscape_section(self, filename_suffix='lan', ti_offset=0):\n with open('%s/%s.%s' % (self.model_path, self.model_name, filename_suffix)) as f:\n data = f.read()\n _data = re.search(r'\\*THEME.*', data, re.M|re.S).group(0) # strip leading junk\n t_data = re.split(r'\\*THEME.*\\n', _data)[1:] # split into theme-wise chunks\n for ti, t in enumerate(t_data, start=ti_offset):\n self._themes.append({})\n self._theme_basecodes.append([])\n defining_aggregates = False\n for l in [l for l in t.split('\\n') if not re.match('^\\s*(;|{|$)', l)]: \n if re.match('^\\s*\\*AGGREGATE', l): # aggregate theme attribute code\n tac = re.split('\\s+', l.strip())[1].lower()\n self._themes[ti][tac] = []\n defining_aggregates = True\n continue\n if not defining_aggregates: # line defines basic theme attribute code\n tac = re.search('\\S+', l.strip()).group(0).lower()\n self._themes[ti][tac] = tac\n self._theme_basecodes[ti].append(tac)\n else: # line defines aggregate values (parse out multiple values before comment)\n _tacs = [_tac.lower() for _tac in re.split('\\s+', l.strip().partition(';')[0].strip())]\n self._themes[ti][tac].extend(_tacs)\n self.nthemes = len(self._themes)","def variable_dicts(self):\n \n def get_variable_text(rtf_file):\n \"Returns a list of variable_texts for each variable\"\n st='Pos. = '\n return rtf_file.split(st)[1:]\n \n def get_variable_name(variable_text):\n st='Variable = '\n b=variable_text.split(st)[1]\n return b[b.find(' ')+1:b.find('\\t')]\n \n def find_pos(rtf):\n a=rtf\n b=a\n return b[b.find(' ')+1:b.find('\\t')]\n \n def find_variable_label(rtf):\n try:\n a=rtf\n b=a.split('Variable label = ')[1]\n return b[b.find(' ')+1:b.find('\\\\par')]\n except IndexError:\n return None\n \n def find_variable_type(rtf):\n if not 'This variable is ' in rtf: return ''\n a=rtf\n b=a.split('This variable is ')[1]\n i1=b.find(' ')+1\n i2=i1+b[i1:].find('}')\n return b[i1:i2]\n \n def find_SPSS_measurement_level(rtf):\n if not 'the SPSS measurement level is ' in rtf: return ''\n a=rtf\n b=a.split('the SPSS measurement level is ')[1]\n i1=b.find(' ')+1\n i2=i1+b[i1:].find('\\\\par')\n return b[i1:i2]\n \n def find_SPSS_user_missing_values(rtf):\n if not 'SPSS user missing values = ' in rtf: return dict()\n a=rtf\n d=a.split('SPSS user missing values = ')\n if len(d)<2: return None\n e=d[1]\n i1=e.find(' ')+1\n i2=i1+e[i1:].find('\\\\par')\n f=e[i1:i2]\n g=f.split(' ')\n i=' '.join([g[0],g[2],g[4]])\n return i\n \n def find_value_labels(rtf):\n if not 'Value = ' in rtf: return dict()\n a=rtf\n d=a.split('Value = ')[1:]\n z={}\n for e in d:\n value=e[e.find(' ')+1:e.find('\\t')]\n value=float(value)\n f=e.split('Label = ')[1]\n label=f[f.find(' ')+1:f.find('\\\\par')]\n z[value]=label\n #print(z)\n return z\n \n variable_texts=get_variable_text(self.rtf)\n #pprint(variable_texts[0:2])\n \n result=[]\n for variable_text in variable_texts:\n d={'pos':find_pos(variable_text),\n 'variable':get_variable_name(variable_text),\n 'variable_label':find_variable_label(variable_text),\n 'variable_type':find_variable_type(variable_text),\n 'SPSS_measurement_level':find_SPSS_measurement_level(variable_text),\n 'SPSS_user_missing_values':find_SPSS_user_missing_values(variable_text),\n 'value_labels':find_value_labels(variable_text) \n }\n result.append(d)\n \n return result","def pose_structure(pose, display_residues = []):\n # store the pose's number of residues, example Python syntax\n nres = pose.total_residue()\n\n # 1. obtain the pose's sequence\n sequence = pose.sequence()\n\n # 2. obtain a list of PDB numbering and icode as a single string\n pdb_info = pose.pdb_info()\n PDB_nums = [(str( pdb_info.number(i)) + pdb_info.icode(i)).strip()\n for i in range(1, nres + 1)]\n # 3. obtains a list of the chains organized by residue\n chains = [pdb_info.chain(i) for i in range(1, nres + 1)]\n # 4. extracts a list of the unique chain IDs\n unique_chains = []\n for c in chains:\n if c not in unique_chains:\n unique_chains.append(c)\n\n # start outputting information to screen\n print('\\n' + '='*80)\n print('Loaded from' , pdb_info.name())\n print(nres , 'residues')\n print(len(unique_chains), 'chain(s) ('+ str(unique_chains)[1:-1] + ')')\n print('Sequence:\\n' + sequence)\n\n # this object is contained in PyRosetta v2.0 and above\n # 5. obtain the pose's secondary structure as predicted by PyRosetta's\n # built-in DSSP algorithm\n DSSP = protocols.moves.DsspMover()\n DSSP.apply(pose) # populates the pose's Pose.secstruct\n ss = pose.secstruct()\n print( 'Secondary Structure:\\n' + ss )\n print( '\\t' + str(100. * ss.count('H') / len(ss))[:4] + '% Helical' )\n print( '\\t' + str(100. * ss.count('E') / len(ss))[:4] + '% Sheet' )\n print( '\\t' + str(100. * ss.count('L') / len(ss))[:4] + '% Loop' )\n\n # 6. obtain the phi, psi, and omega torsion angles\n phis = [pose.phi(i) for i in range(1, nres + 1)]\n psis = [pose.psi(i) for i in range(1, nres + 1)]\n omegas = [pose.omega(i) for i in range(1, nres + 1)]\n\n # this object is contained in PyRosetta v2.0 and above\n # create a PyMOLMover for exporting structures directly to PyMOL\n pymover = PyMOLMover()\n pymover.apply(pose) # export the structure to PyMOL (optional)\n\n # 7. output information on the requested residues\n # use a simple dictionary to make output nicer\n ss_dict = {'L':'Loop', 'H':'Helix', 'E':'Strand'}\n for i in display_residues:\n print( '='*80 )\n print( 'Pose numbered Residue', i )\n print( 'PDB numbered Residue', PDB_nums[i-1] )\n print( 'Single Letter:', sequence[i-1] )\n print( 'Chain:', chains[i-1] )\n print( 'Secondary Structure:', ss_dict[ss[i-1]] )\n print( 'Phi:', phis[i-1] )\n print( 'Psi:', psis[i-1] )\n print( 'Omega:', omegas[i-1] )\n # extract the chis\n chis = [pose.chi(j + 1, i) for j in range(pose.residue(i).nchi() )]\n for chi_no in range(len(chis)):\n print( 'Chi ' + str(chi_no + 1) + ':', chis[chi_no] )\n print( '='*80 )","def samsemPlots17thru20(samsem_data, path, dict):\n \n path_res = path\n \n if 'subfolder' in dict:\n subfolder = dict['subfolder']\n path_res = os.path.join(path,subfolder)\n if not os.path.exists(path_res): os.makedirs(path_res)\n \n coldef_type = dict['coldef_type']\n print(\"Starting SAMSEM_RES#17+20: Analyzing data of all images for \" + str(settings.id2ColDefLong[dict['coldef_type']]) + \" simulation methods.\")\n \n if 'plot_types' in dict:\n plot_types = dict['plot_types']\n else:\n plot_types = ['RT_boxplots', 'RT_means', 'ACC_CIs', 'median']\n \n method_ids = sorted(set(samsem_data['sim_id'].values.astype(int)))\n image_ids = sorted(set(samsem_data['image_id'].values.astype(int)))\n #print method_ids\n \n for method_id in method_ids:\n if (method_id != 3) and (method_id != 99):\n whatArr_sim = [['sim_id',operator.eq,method_id],['coldef_type',operator.eq,coldef_type],['observer_coldef_type',operator.eq, coldef_type]]\n else:\n whatArr_sim = [['sim_id',operator.eq,method_id],['observer_coldef_type',operator.eq,coldef_type]]\n samsem_data_sim = organizeArray(samsem_data, whatArr_sim)\n \n boxes = []; labels = []; accuracies = {}; mean_cis = {}; order = {}; i=1\n \n for image_id in image_ids:\n whatArr_image = [['image_id', operator.eq, image_id]]\n samsem_data_image = organizeArray(samsem_data_sim,whatArr_image)\n \n dict.update({'filename':str(settings.id2ColDef[coldef_type])+'-simulation-method-'+str(settings.id2Sim[method_id])+'_images'})\n \n # 3. Get response time data\n alg_values = samsem_data_image[samsem_data_image['is_correct']==True]['resp_time'].values*1000; \n if ('RT_boxplots' in plot_types) or ('median-test' in plot_types):\n boxes.append(alg_values)\n labels.append(image_id) if alg_values.size else labels.append(str(image_id) + ' - No data'); \n \n # 4. Get CI of RT means\n if 'RT_means' in plot_types:\n alg_mean = getCIAverage(alg_values);\n alg_mean.append(labels[i-1])\n mean_cis.update({image_id: alg_mean})\n \n # 5. Get accuracy data\n if 'ACC_CIs' in plot_types:\n alg_acc = getAccuracy(samsem_data_image)\n alg_acc.append(labels[i-1])\n accuracies.update({image_id: alg_acc})\n \n order.update({i:image_id})\n i += 1\n if 'RT_boxplots' in plot_types:\n # 6. Plot response time data\n plotRTGraphs(boxes,labels,path_res,dict,order)\n \n if 'RT_means' in plot_types:\n # 7. Plot CI means of RT data\n plotCIAverageGraphs(mean_cis,path_res,dict,order)\n \n if 'ACC_CIs' in plot_types:\n # 8. Plot accuracy data\n plotAccuracyGraphs(accuracies,path_res,dict,order)\n \n if 'median-test' in plot_types:\n # 9. Make median test\n dict.update({'filename': dict['filename']+\"-RT\"})\n makeMedianTest(numpy.array(boxes), path_res, image_ids,dict)","def break_up_pt_and_passage_comparisons(discordance_by_cohort_dict):\n pt_passage_dict = dict()\n early_late_dict = dict()\n for cohort in discordance_by_cohort_dict:\n discordance_dictionary = discordance_by_cohort_dict[cohort]\n pt_passage_discordance = []\n early_late_discordance = []\n for key in discordance_dictionary:\n if \"PT\" in key:\n pt_passage_discordance += discordance_dictionary[key]\n else:\n early_late_discordance += discordance_dictionary[key]\n pt_passage_dict[cohort] = pt_passage_discordance\n early_late_dict[cohort] = early_late_discordance\n return pt_passage_dict, early_late_dict","def test_display_presentation(self):\n response = self._speaker_profile(True)\n self.assertContains(response, FIRST_PRESENTATION_TITLE)\n self.assertContains(response, SECOND_PRESENTATION_TITLE)","def _parse_result(cls, design_folder: str) -> Dict[str, Any]:\n _, folder_name = os.path.split(design_folder)\n raw_folder = os.path.join(design_folder, '{}.raw'.format(folder_name))\n res = SpectreParser.parse(raw_folder)\n return res","def overlay(self):\n # retrieve header for photometry keywords\n # from current frame only\n hdr_str = self.run('fits header', via='get')\n\n # read it in to a fits header\n phdr = fits.Header()\n hdr = phdr.fromstring(hdr_str, sep='\\n')\n\n try:\n srcposx = hdr['SRCPOSX'] + 1\n srcposy = hdr['SRCPOSY'] + 1\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=blue tag={{srcpos}} '\\\n 'text=SRCPOS'.format(srcposx, srcposy)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n photaper = hdr['PHOTAPER']\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\n self.run('regions', s1)\n s2 = 'circle({:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}}'.format(\n stcentx, stcenty, photaper)\n self.run('regions', s2)\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\n stcentx, stcenty, photskap[0], photskap[1])\n self.run('regions', s3)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n flux = hdr['STAPFLX']\n sky = hdr['STAPSKY']\n s1 = 'text({:f} {:f}) # color=cyan ' \\\n 'text=\"Flux={:.2f}, Sky={:.2f}\"'.format(\n stcentx, stcenty - 40, flux, sky)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n\n # try overlaying apertures as well\n try:\n self.overlay_aperture(hdr)\n except ValueError: # pragma: no cover\n # may be encountered with extensions with\n # unexpected WCSs\n pass","def process_sentiment(self, sentiment_data):\n new_utts_dict = {'1':[], '2':[], '3':[], '4':[], '5':[]}\n for l in sentiment_data:\n title = [\"<s>\"] + l[0] + [\"</s>\"]\n context = [\"<s>\"] + l[1] + [\"</s>\"]\n target = [\"<s>\"] + l[2] + [\"</s>\"]\n sentiment = l[3][0]\n new_utts_dict[sentiment].append([title, context, target, sentiment])\n return new_utts_dict","def CreatePresentation(self, event):\n pass","def population_text_parser():\n h = 480\n w = 640\n filenames = []\n # get corrispondence ppoints for all faces\n all_face_verticies = []\n for i in range(1, 41):\n if i == 2 or i == 3 or i == 4:\n # not in data set\n continue\n # get file name\n file_name = \"data/\"\n if i < 10:\n file_name += \"0\" + str(i)\n else:\n file_name += str(i)\n if i == 8 or i == 22 or i == 30 or i == 35 or i == 12 or i ==14 or i == 15:\n # female faces\n file_name += \"-1f.asf\"\n else:\n file_name += \"-1m.asf\"\n filenames.append(file_name[:-3] + \"bmp\")\n # Parse corrispondence points\n face_vertices = file_parser(file_name)\n all_face_verticies.append(np.array(face_vertices))\n\n # adding my face to the set\n # all_face_verticies.append(get_will_points())\n mean_vertices = np.array(sum(all_face_verticies)) / len(all_face_verticies)\n\n # face = plt.imread(filenames[0])\n # mean_vertices = ginput_to_array(appendCorners_other(face, mean_vertices))\n # Morph each of the faces in the dataset into the average shape.\n morphs = []\n for i in range(len(all_face_verticies)):\n # Read in src img\n print(\"Morphing face \" + str(i) + \" into the average shape.\")\n if i == len(all_face_verticies)-1:\n face = plt.imread(\"will_population.jpeg\")/255\n else:\n face = plt.imread(filenames[i])/255\n # print(face.shape)\n # print(mean_vertices)\n im_src_vertices = all_face_verticies[i]\n\n # Create Dalaunay triangulation for the ith morph set\n print(\"Computing Delaunay triangulation.\")\n # morph_verticies = morphPointSet(tri0_vertices, tri1_vertices, i/45)\n t = Delaunay(mean_vertices)\n trianguations = t.simplices\n\n # Compute Affine Transformation matrices for both transformations (src-->mid; dst-->mid)\n print(\"Computing Affine Transformation.\")\n affine_matrices_0 = computeAffines(trianguations, im_src_vertices, mean_vertices)\n affine_matrices_inv_0 = [linalg.inv(A) for A in affine_matrices_0]\n\n morph = warp(h, w, t, affine_matrices_inv_0, face)\n # if i == len(all_face_verticies) -1:\n # plt.imsave(\"will_in_danish_pop.png\", morph)\n morphs.append(morph)\n\n out = sum(morphs) * (1/len(morphs))\n return out","def osp2():\n return dict(\n kloc= range(75,125),\n docu = [3,4], ltex = [2,5],\n sced = [2,3,4], Pmat = [4,5],\n Prec = [3,4, 5],\n Resl = [4], Team = [3],\n acap = [4], aexp = [4],\n cplx = [4], data = [4],\n Flex = [3], pcap = [3],\n pcon = [3], pexp = [4],\n pvol = [3], rely = [5],\n ruse = [4], site = [6],\n stor = [3], time = [3],\n tool = [5])","def test_extract():\n print(\"Executing test_extract:\")\n\n theory_1=[\n (14,),\n (15,),\n (14,),\n (16,)\n ]\n theory_2=[\n (14,),\n (15,),\n (14,),\n (17,)\n ]\n theory_3=[\n (15,),\n (14,)\n ]\n\n mind=minds.new_mind(theories=[theory_1,theory_2,theory_3])\n\n print(\"Mind initial state:\")\n print(minds.mind_string(mind, show_claims=False, show_problems=False))\n\n minds.extract_new_routines(mind,1)\n print(\"Mind after 1 step of extraction:\")\n print(minds.mind_string(mind, show_claims=False, show_problems=False))\n\n minds.extract_new_routines(mind,1)\n print(\"Mind after 2 steps of extraction:\")\n print(minds.mind_string(mind, show_claims=False, show_problems=False))","def save_annotations(self):\n for fp in self.ris_widget.flipbook_pages:\n if len(fp) == 0:\n # skip empty flipbook pages\n continue\n annotations = getattr(fp, 'annotations', {})\n pose = annotations.get('pose', (None, None))\n if pose is not None:\n center_tck, width_tck = pose\n if center_tck is not None:\n path = pathlib.Path(fp[0].name)\n with path.with_suffix('.pickle').open('wb') as f:\n pickle.dump(dict(pose=pose), f)\n\n # warp and save images from all flipbook pages\n for lab_frame in fp:\n lab_frame_image = lab_frame.data\n path = pathlib.Path(lab_frame.name)\n warp = worm_spline.to_worm_frame(lab_frame_image, center_tck, width_tck)\n warp_save_path = path.parent / (path.stem + '-straight.png')\n freeimage.write(warp, warp_save_path)\n\n # If the widths are drawn, then create a mask that allows the user to make an alpha channel later.\n # We create one mask for each flipbook page, in case the images were saved in different places.\n # If we wind up redundantly writing the same mask a few times, so be it.\n if width_tck is not None:\n mask = worm_spline.worm_frame_mask(width_tck, warp.shape)\n mask_save_path = path.parent / (path.stem + '-mask.png')\n freeimage.write(mask, mask_save_path)","def get_soup_general_data(soup):\n data_dict = {}\n\n name = soup.find(class_='product_title')\n if name:\n data_dict['name_of_game'] = name.h1.text\n\n pub = soup.find('li', class_='summary_detail publisher')\n if pub:\n data_dict['publisher'] = pub.a.text.strip()\n\n rel_date = soup.find('li', class_='summary_detail release_data')\n if rel_date:\n rel_date = rel_date.find('span', class_='data')\n if rel_date:\n data_dict['release_date'] = rel_date.text.strip()\n\n num_p = soup.find(\"li\", class_=\"summary_detail product_players\")\n if num_p:\n data_dict['num_players'] = num_p.find(class_=\"data\").text\n\n genres = soup.find(\"li\", class_='summary_detail product_genre')\n if genres:\n genres = genres.find_all('span', class_='data')\n data_dict['genres'] = [genre.text for genre in genres]\n\n age = soup.find(\"li\", class_=\"summary_detail product_rating\")\n if age:\n data_dict['age_rating'] = age.find('span', class_=\"data\").text\n\n return data_dict","def _build_study_info(user, study_proc=None, proc_samples=None):\n # Logic check to make sure both needed parts passed\n if study_proc is not None and proc_samples is None:\n raise IncompetentQiitaDeveloperError(\n 'Must pass proc_samples when study_proc given')\n elif proc_samples is not None and study_proc is None:\n raise IncompetentQiitaDeveloperError(\n 'Must pass study_proc when proc_samples given')\n\n # get list of studies for table","def extract_spacy(self, text: str)->dict:\n ners=None\n try:\n persons=[]\n locations=[]\n orgs=[]\n misc=[]\n docs=[]\n if len(text)>1000000:\n docs=self._splitCount(text,1000000)\n else:\n docs.append(text)\n for doc in docs:\n doc_spacy = self.recognizer(doc)\n for token in doc_spacy:\n if token.ent_type_ == \"PER\":\n persons.append(token.text)\n if token.ent_type_ == \"LOC\":\n locations.append(token.text)\n if token.ent_type_ == \"ORG\":\n orgs.append(token.text)\n if token.ent_type_ == \"MISC\":\n misc.append(token.text)\n ners={\"persons\":list(set(persons)), \"locations\":list(set(locations)),\"orgs\":list(set(orgs)), \"misc\":list(set(misc))}\n except Exception as ex:\n print('Exception while extracting NERs')\n print(str(ex))\n finally:\n return ners","def study(user_preferences: dict, matcher: NodeMatcher):\r\n studysame = user_preferences[\"importancia_estudios\"]\r\n equal_styles = list(matcher.match(\"User\", imp = studysame))\r\n return equal_styles","def _get_summary_struct(self):\n model_fields = [\n ('Number of classes', 'num_classes'),\n ('Number of feature columns', 'num_features'),\n ('Input image shape', 'input_image_shape'),\n ]\n training_fields = [\n ('Number of examples', 'num_examples'),\n (\"Training loss\", 'training_loss'),\n (\"Training time (sec)\", 'training_time'),\n ]\n\n section_titles = ['Schema', 'Training summary']\n return([model_fields, training_fields], section_titles)","def extract_relevant(self):\n item_extraction = self.data\n my_dict = {'tweeted_time': item_extraction['created_at'],\n 'tweet_id': item_extraction['id'],\n # If the time comes when the below becomes more significant, it will be no trouble at all to make an\n # additional column for it, but delimiting it with a ` creates less clutter in the Database\n 'in_reply_to':\n \"NAME/\" + str(item_extraction['in_reply_to_screen_name']) + \"`\" +\n \"STATUSID/\" + str(item_extraction['in_reply_to_status_id_str']) + \"`\" +\n \"USERID/\" + str(item_extraction['in_reply_to_user_id_str']),\n 'lang': item_extraction['lang'],\n 'place': item_extraction['place'], 'source': item_extraction['source']}\n if item_extraction['place'] is not None:\n my_dict['place'] = item_extraction['place']['full_name']\n if 'retweeted_status' in item_extraction.keys():\n my_dict['original_author_id'] = item_extraction['retweeted_status']['user']['id']\n my_dict['original_author_handle'] = item_extraction['retweeted_status']['user']['screen_name']\n tester = item_extraction['retweeted_status']['text']\n cleaned = ' '.join(re.sub(\"(RT : )|(@[\\S]+)|(&\\S+)|(http\\S+)\", \" \", tester).split())\n removed_others = \" \".join(re.sub(\"(#\\S+)\", ' ', cleaned).split())\n final_text = ''.join(list(filter(lambda x: x.isalpha() or x is ' ', removed_others)))\n # This final text will make it a lot easier to run NLP\n final_text = final_text.strip().replace(' ', ' ').replace(' ', ' ')\n my_dict['plain_text'] = final_text.lower()\n my_dict['tweet'] = cleaned\n else:\n my_dict['original_author_id'] = item_extraction['user']['id']\n my_dict['original_author_handle'] = item_extraction['user']['screen_name']\n cleaned = ' '.join(re.sub(\"(@[\\S]+)|(&\\S+)|(http\\S+)\", \" \", item_extraction['text']).split())\n removed_others = \" \".join(re.sub(\"(#\\S+)\", ' ', cleaned).split())\n final_text = ''.join(list(filter(lambda x: x.isalpha() or x is ' ', removed_others)))\n final_text = final_text.strip().replace(' ', ' ').replace(' ', ' ')\n my_dict['plain_text'] = final_text.lower()\n my_dict['tweet'] = cleaned\n return my_dict","def playerStandings(t_name):\n t_id = getTournamentID(t_name, False)\n if t_id == -1:\n return []\n conn, cur = connect()\n cur.execute(\"SELECT create_summary();\")\n conn.commit()\n query = \"SELECT P_ID, P_NAME, WIN, MATCH FROM SUMMARY WHERE T_ID = %s\"\n param = (t_id, )\n cur.execute(query, param)\n ps = [(int(row[0]), str(row[1]), int(row[2]), int(row[3]))\n for row in cur.fetchall()]\n return ps","def make_hst_spec_previews(input_file, flux_scale_factor=\n FLUX_SCALE_FACTOR_DEFAULT, fluxerr_scale_factor=\n FLUXERR_SCALE_FACTOR_DEFAULT, n_consecutive=\n N_CONSECUTIVE_DEFAULT, output_path=\n OUTPUT_PATH_DEFAULT, output_type=OUTPUT_TYPE_DEFAULT,\n dpi_val=DPI_VAL_DEFAULT, debug=DEBUG_DEFAULT,\n full_ylabels=FULL_YLABELS_DEFAULT, optimize=\n not NOOPTIMIZE_DEFAULT, verbose=VERBOSE_DEFAULT):\n\n # Print file name, if verbose is turned on.\n if verbose:\n print(\"Input file: \" + input_file)\n\n # Derive output file names from input file name.\n output_files = []\n for out_type in output_type:\n if out_type != \"screen\":\n if out_type != \"fits\":\n output_file = (path.join(output_path, \"\") +\n path.basename(input_file).split(\".fits\")[0] +\n \".\" + out_type)\n else:\n output_file = (path.join(output_path, \"\") +\n path.basename(input_file).split(\".fits\")[0] +\n \"_prev.\" + out_type)\n else:\n output_file = None\n\n output_files.append(output_file)\n\n # Print name of output file.\n if verbose:\n print(\"Output file names are:\")\n for ofile in output_files:\n if ofile is not None:\n if ofile[-4:] == '.png':\n print(\" Output file: \" + ofile)\n print(\" Output file: \" + ofile.strip('\\.png') +\n '_thumb.png')\n else:\n print(\" Output file: \" + ofile)\n else:\n print(\" Plotting to screen.\")\n\n # Read in the FITS file to determine which instrument it comes from.\n # Print the name of the instrument found in the header if verbose is turned\n # on.\n this_instrument = get_instrument_name(input_file)\n if verbose:\n print(\"Instrument: \" + this_instrument)\n\n # Read in the FITS files and create plots using the local package\n # appropriate for the instrument used in the input file.\n if this_instrument == \"COS\":\n # Get wavelengths, fluxes, flux uncertainties.\n cos_spectrum = specutils_cos.readspec(input_file)\n\n # Get a list of segment names sorted such that the bluest segment is\n # first.\n cos_segment_names = specutils_cos.get_segment_names(cos_spectrum)\n\n # Trim the wavelengths < 900 Angstroms for FUVB segment if optical\n # element used is G140L.\n if (\"FUVB\" in cos_spectrum.segments and cos_spectrum.optical_element ==\n \"G140L\"):\n specutils_cos.extract_subspec(cos_spectrum, \"FUVB\", min_wl=900.)\n\n # Create a stitched spectrum for use when making thumb-size plots.\n stitched_spectrum = specutils.stitch_components(cos_spectrum,\n n_consecutive,\n flux_scale_factor,\n fluxerr_scale_factor,\n segment_names=\n cos_segment_names)\n\n # Calculate plot metrics for the each segment.\n segment_plot_metrics = [\n specutils.calc_plot_metrics(\"cos\",\n cos_spectrum.segments[x].wavelengths,\n cos_spectrum.segments[x].fluxes,\n cos_spectrum.segments[x].fluxerrs,\n cos_spectrum.segments[x].dqs,\n n_consecutive, flux_scale_factor,\n fluxerr_scale_factor)\n for x in cos_segment_names]\n\n # Make \"large-size\" plot.\n for out_type, out_file in zip(output_type, output_files):\n if out_type != \"fits\":\n specutils_cos.plotspec(cos_spectrum, out_type, out_file,\n flux_scale_factor,\n fluxerr_scale_factor,\n segment_plot_metrics,\n dpi_val=dpi_val, output_size=1024,\n debug=debug, full_ylabels=full_ylabels,\n title_addendum=stitched_spectrum[\"title\"],\n optimize=optimize)\n else:\n # Write the spectrum that would be plotted to a binary FITS\n # table.\n specutils_cos.make_fits(cos_spectrum, out_file,\n segment_plot_metrics, input_file)\n\n if not debug and output_type != [\"fits\"]:\n # Calculate plot metrics for the stitched spectrum.\n stitched_plot_metrics = [\n specutils.calc_plot_metrics(\"cos\", stitched_spectrum[\"wls\"],\n stitched_spectrum[\"fls\"],\n stitched_spectrum[\"flerrs\"],\n stitched_spectrum[\"dqs\"],\n n_consecutive, flux_scale_factor,\n fluxerr_scale_factor)]\n\n # Make \"thumbnail-size\" plot, if requested.\n for out_type, out_file in zip(output_type, output_files):\n if out_type != 'fits':\n specutils_cos.plotspec(cos_spectrum, out_type,\n out_file, flux_scale_factor,\n fluxerr_scale_factor,\n stitched_plot_metrics,\n dpi_val=dpi_val, output_size=128,\n stitched_spectrum=stitched_spectrum,\n optimize=optimize)\n\n elif this_instrument == \"STIS\":\n # Get wavelengths, fluxes, flux uncertainties.\n stis_spectrum = specutils_stis.readspec(input_file)\n\n # Get the indices to plot. If the number of associations is <=3 then\n # we will plot all of them, but if >3 then only the first, middle, and\n # last association will be plotted, so it's not necessary to stitch or\n # calculate plot metrics for any of the others.\n indices_to_plot = specutils_stis.get_association_indices(\n stis_spectrum.associations)\n\n # Create a stitched spectrum for each association, used when making\n # thumb-size plots. The stitched spectrum joins the orders together (if\n # there is more than one). The length of the returned list is equal to\n # the number of associations that will be plotted.\n stitched_spectra = [\n specutils.stitch_components(x, n_consecutive, flux_scale_factor,\n fluxerr_scale_factor)\n for x in numpy.asarray(stis_spectrum.associations)[indices_to_plot]]\n\n # Calculate plot metrics for the each association that will be\n # plotted. The length of the returned list is equal to the number of\n # associations that will be plotted.\n association_plot_metrics = [\n specutils.calc_plot_metrics(\"stis\", x[\"wls\"], x[\"fls\"], x[\"flerrs\"],\n x[\"dqs\"], n_consecutive,\n flux_scale_factor, fluxerr_scale_factor)\n for x in stitched_spectra]\n\n # Make \"large-size\" plot.\n for out_type, out_file in zip(output_type, output_files):\n if out_type != 'fits':\n specutils_stis.plotspec(stis_spectrum, indices_to_plot,\n stitched_spectra, out_type, out_file,\n flux_scale_factor, fluxerr_scale_factor,\n association_plot_metrics,\n dpi_val=dpi_val, output_size=1024,\n debug=debug, full_ylabels=full_ylabels,\n optimize=optimize)\n\n # Make \"thumbnail-size\" plot, if requested. Notice that in this\n # case we always plot just the first association, by passing only\n # `stitched_spectra[0]`.\n if not debug:\n specutils_stis.plotspec(stis_spectrum, indices_to_plot,\n [stitched_spectra[0]], out_type,\n out_file, flux_scale_factor,\n fluxerr_scale_factor,\n association_plot_metrics,\n dpi_val=dpi_val,\n output_size=128, optimize=optimize)\n\n else:\n raise HSTSpecPrevError(\"'INSTRUME' keyword not understood: \" +\n this_instrument)","def get_general(soup):\n \n general_info = {}\n general_info.update(get_route_name(soup))\n general_info.update(get_box_data(soup))\n general_info.update(get_description(soup))\n general_info.update(get_hierarchy(soup))\n general_info.update(get_first_img_source(soup))\n\n return general_info","def get_sentiment_lexicon(datafile):\n user_dict = {}\n item_dict = {}\n feature_dict ={}\n aspect_index = 0\n\n for tupel in datafile.iterrows():\n line = tupel[0]\n user_id = datafile[\"user_id\"][line]\n item_id = datafile[\"business_id\"][line]\n list_len = len(datafile['absa'][line])\n if user_id not in user_dict:\n user_dict[user_id] = []\n if item_id not in item_dict:\n item_dict[item_id] = []\n for i in range(0, list_len):\n feature = datafile['absa'][line][i]['aspect']\n fetaure_confidence = datafile['absa'][line][i]['aspect_confidence']\n polarity = datafile['absa'][line][i]['polarity']\n polarity_confidence = datafile['absa'][line][i]['polarity_confidence']\n if feature not in feature_dict:\n feature_dict[feature] = aspect_index\n aspect_index = aspect_index+1\n user_dict[user_id].append([feature, fetaure_confidence, polarity, polarity_confidence])\n item_dict[item_id].append([feature, fetaure_confidence, polarity, polarity_confidence])\n return [feature_dict, user_dict, item_dict]","def parse(u):\n rec = {}\n\n try:\n r = requests.get(u, headers=headers)\n\n if r.status_code == 200:\n html = r.text\n soup = BeautifulSoup(html, 'lxml')\n overview_section = soup.select('.Raw-s14xcvr1-0 gXqFYO')\n full_name_section = soup.select('.sc-iwsKbI kjxnCg')\n years_of_practice_section = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\n language_section = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\n office_location_section = soup.select('.Paragraph-fqygwe-0 cojhks')\n hospital_affiliation_section = soup.select('.Paragraph-fqygwe-0 fwayNy')\n specialties = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\n education_and_medical_training_section = soup.select('.EducationAndExperience__Item-xn5fll-0 bzYYRk')\n certification_and_licensure_section = soup.select('.Paragraph-fqygwe-0 bQPwuv')\n\n if overview_section:\n overview = overview_section[0].text.replace('\"', '')\n if full_name_section:\n full_name = full_name_section[0].text\n if years_of_practice_section:\n years_of_practice = years_of_practice_section[0].text.strip().replace('\"', '')\n if language_section:\n language = language_section[0].text.strip().replace('\"', '')\n if office_location_section:\n office_location = office_location_section[0].text\n if hospital_affiliation_section:\n hospital_affiliation = hospital_affiliation_section[0].text.strip().replace('\"', '')\n if specialties_section:\n specialties = specialties_section[0].text.replace('\"', '')\n if education_and_medical_training_section:\n education_and_medical_training = education_and_medical_training_section[0].text\n if certification_and_licensure_section:\n certification_and_licensure = certification_and_licensure_section[0].text\n\n\n rec = {'overview': overview, 'full_name': full_name, 'years_of_practice': years_of_practice, 'language': language,\n 'office_location': office_location, 'hospital_affiliation': hospital_affiliation, 'specialties':specialties,\n 'education_and_medical_training': education_and_medical_training,\n 'certification_and_licensure': certification_and_licensure}\n except Exception as ex:\n print('Exception while parsing')\n print(str(ex))\n finally:\n return json.dumps(rec)","def processing_function(raw):\r\n\r\n # Sort stewarded & unstewarded depts\r\n STEWARDED_DEPTS = set(stewards.keys()) & kt.ALL_DEPTS\r\n UNSTEWARDED_DEPTS = kt.ALL_DEPTS - STEWARDED_DEPTS\r\n\r\n ##############################\r\n # Filter data in all the ways\r\n ##############################\r\n actives = kt.filterdata(raw, kt.selectors.allactives)\r\n nc = kt.filterdata(actives, kt.selectors.northcampus)\r\n\r\n # International Students\r\n itnl = kt.filterdata(actives, kt.selectors.itnl)\r\n permres = kt.filterdata(actives, kt.selectors.permres)\r\n\r\n # Stewarded / Unstewarded\r\n stewarded= kt.filterdata(\r\n actives,\r\n lambda person: kt.selectors.bydept(person,STEWARDED_DEPTS)\r\n )\r\n unstewarded= kt.filterdata(\r\n actives,\r\n lambda person: kt.selectors.bydept(person,UNSTEWARDED_DEPTS)\r\n )\r\n\r\n # Hire Date\r\n newhires = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.hiredafter(person,NEW_HIRE_DATE)\r\n )\r\n\r\n oldhires = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.hiredbefore(person,NEW_HIRE_DATE)\r\n )\r\n\r\n nohiredate = kt.filterdata(actives, kt.selectors.nohiredate)\r\n\r\n # Degree Program\r\n phd = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.bydegree(person,['PhD'])\r\n )\r\n masters = kt.filterdata(\r\n actives, \r\n lambda person: kt.selectors.bydegree(person, kt.MASTERS)\r\n )\r\n\r\n ###############\r\n # Count things\r\n ###############\r\n\r\n # Unit sizes\r\n bargaining_unit_size = len(actives)\r\n overall_members = kt.count_duespayers(actives)\r\n\r\n # Number of actives currently stewarded\r\n total_stewarded = len(stewarded)\r\n total_unstewarded = len(unstewarded)\r\n stewarded_members = kt.count_duespayers(stewarded)\r\n unstewarded_members = kt.count_duespayers(unstewarded)\r\n\r\n # International students\r\n total_intl = len(itnl)\r\n total_permres = len(permres)\r\n intl_members = kt.count_duespayers(itnl)\r\n permres_members = kt.count_duespayers(permres)\r\n\r\n # New Hires\r\n total_newhires = len(newhires)\r\n total_oldhires = len(oldhires)\r\n total_nohiredate= len(nohiredate)\r\n newhire_members = kt.count_duespayers(newhires)\r\n oldhire_members = kt.count_duespayers(oldhires)\r\n\r\n\r\n # Degree Program\r\n total_phd = len(phd)\r\n total_masters = len(masters)\r\n phd_members = kt.count_duespayers(phd)\r\n masters_members = kt.count_duespayers(masters)\r\n \r\n\r\n ######################################\r\n # Derived Results\r\n ######################################\r\n labels = []\r\n results= []\r\n\r\n labels += ['Current Bargaining Unit Size']\r\n results+= [bargaining_unit_size]\r\n\r\n labels += ['Relative Number of GSIs with >1 Steward (%)']\r\n results+= [(100.0*total_stewarded)/bargaining_unit_size]\r\n\r\n labels += ['Relative Number of International Students (%)']\r\n results+= [(100.0*total_intl)/bargaining_unit_size]\r\n\r\n # labels += ['Relative Number of NC Permanent Resident Students (%)']\r\n # results+= [(100.0*total_permres)/bargaining_unit_size]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Overall GEO Membership (%)']\r\n results+= [(100.0*overall_members)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among Stewarded Depts (%)']\r\n results+= [(100.0*stewarded_members)/total_stewarded]\r\n\r\n labels += ['Membership Among Unstewarded Depts (%)']\r\n results+= [(100.0*unstewarded_members)/total_unstewarded]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of International Students (%)']\r\n results+= [(100.0*total_intl)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among International Students (%)']\r\n results+= [(100.0*intl_members)/total_intl]\r\n\r\n # labels += ['Membership Among Permanent Residents (%)']\r\n # results+= [(100.0*permres_members)/total_permres]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of New Hires (%)']\r\n results+= [(100.0*total_newhires)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among New Hires (%)']\r\n results+= [(100.0*newhire_members)/total_newhires]\r\n\r\n labels += ['Membership Among Old Hires (%)']\r\n results+= [(100.0*oldhire_members)/total_oldhires]\r\n\r\n labels += ['Number of People w/o Known Hire Dates']\r\n results+= [total_nohiredate]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n labels += ['Relative # of Masters Students (%)']\r\n results+= [(100.0*total_masters)/bargaining_unit_size]\r\n\r\n labels += ['Membership Among Masters Students (%)']\r\n results+= [(100.0*masters_members)/total_masters]\r\n\r\n labels += ['Membership Among PhD Students (%)']\r\n results+= [(100.0*phd_members)/total_phd]\r\n\r\n labels += ['']\r\n results+= ['']\r\n\r\n\r\n\r\n # Display summary results\r\n print('\\n')\r\n display_results(labels,results)\r\n\r\n print('Unstewarded Departments:')\r\n for d in UNSTEWARDED_DEPTS: print(d)\r\n\r\n print('\\n')\r\n\r\n\r\n\r\n # Print summary results to csv\r\n kt.writecsv_summary(zip(labels,results), OUT_FILE)\r\n\r\n\r\n\r\n # dump all local variables to file\r\n # v = locals()\r\n\r\n\r\n\r\n return None"],"string":"[\n \"def analyze_pptx(template_file):\\n prs = Presentation(template_file)\\n # Each powerpoint file has multiple layouts\\n # Loop through them all and see where the various elements are\\n slide_masters = prs.slide_masters\\n for index, slide_master in enumerate(prs.slide_masters):\\n print('------------------------------------')\\n print('------------------------------------')\\n print(f\\\"slide master indexed: {index}\\\")\\n print(slide_master)\\n print(\\\"text boxes:\\\")\\n for shape in slide_master.shapes:\\n try:\\n dummystring = f\\\"shape name: {shape.name} - shape text: {shape.text}\\\"\\n shape.text = shape.name\\n print(dummystring)\\n except:\\n pass\\n # shape.text = 'hahahaha'\\n # for shape in slide_master.slideshapes:\\n # print(shape)\\n print('------------------------------------')\\n for index, slide_layout in enumerate(slide_master.slide_layouts):\\n print(f\\\"\\\\tslide layout: {slide_layout.name}\\\")\\n slide = prs.slides.add_slide(slide_master.slide_layouts[index])\\n # Not every slide has to have a title\\n try:\\n title = slide.shapes.title\\n title.text = 'Title for Layout {}'.format(index)\\n except AttributeError:\\n print(\\\"No Title for Layout {}\\\".format(index))\\n # Go through all the placeholders and identify them by index and type\\n for shape in slide.placeholders:\\n if shape.is_placeholder:\\n phf = shape.placeholder_format\\n # Do not overwrite the title which is just a special placeholder\\n try:\\n if 'Title' not in shape.text:\\n shape.text = 'Placeholder index:{} type:{}'.format(phf.idx, shape.name)\\n except AttributeError:\\n print(\\\"{} has no text attribute\\\".format(phf.type))\\n print(f\\\"\\\\t\\\\tid: {phf.idx} - name: {shape.name}\\\")\\n # output_file = '..\\\\\\\\resources\\\\pptx\\\\\\\\template_names.pptx'\\n # prs.save(output_file)\",\n \"def extract_information(preprocessed_sentences):\\n parsed = list(map(lambda sentence: nlp(sentence), preprocessed_sentences))\\n\\n quantities = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'QUANTITY'), parsed))\\n dates = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'DATE'), parsed))\\n\\n hurricane_name = eh.extract_frequent_regex_match(parsed, '[Hh]urricane ([A-Z][a-z]+)').most_common(1)[0][0]\\n hurricane_category = eh.extract_frequent_regex_match(parsed, '[Cc]ategory ([0-9]+)').most_common(1)[0][0]\\n\\n tropical_storm_name = eh.extract_frequent_regex_match(parsed, '[Tt]ropical [Ss]torm ([A-Z][a-z]+)').most_common(1)[0][0]\\n formation_date, middle_month = extract_storm_timeline(dates, hurricane_name)\\n\\n preperation_info = extract_preparation_information(parsed)\\n prep_gpes = preperation_info[0].most_common(3)\\n\\n restore_info = extract_restoration_information(parsed)\\n\\n landfall_info = extract_landfall_information(parsed)\\n\\n wind_info = extract_wind_information(quantities)\\n rain_info = extract_rain_information(quantities)\\n size_info = extract_size_information(parsed)\\n\\n # formation_info = extract_formation_info(parsed)\\n death_info = extract_death_damages_info(parsed)\\n\\n print(constants.HURRICANE_SENTENCE.format(hurricane_name, middle_month, hurricane_category))\\n print(constants.LANDFALL_SENTENCE.format(hurricane_name, landfall_info[2], landfall_info[3], landfall_info[0], landfall_info[1]))\\n print(constants.WIND_SENTENCE.format(wind_info[0], wind_info[1], wind_info[2]))\\n print(constants.RAIN_SENTENCE.format(hurricane_name, rain_info[1], rain_info[0], rain_info[2]))\\n print(constants.FORMATION_SENTENCE.format(formation_date, tropical_storm_name))\\n print(constants.PREPARATION_SENTENCE.format(prep_gpes[0][0], prep_gpes[1][0], prep_gpes[2][0], preperation_info[1].\\n most_common(1)[0][0]))\\n print(constants.SIZE_SENTENCE.format(size_info[0], size_info[1]))\",\n \"def prepare_metadata(self, presentation):\\r\\n return {\\\"title\\\": presentation.title,\\r\\n \\\"artist\\\": presentation.speaker,\\r\\n \\\"performer\\\": presentation.speaker,\\r\\n \\\"album\\\": presentation.event,\\r\\n \\\"location\\\": presentation.room,\\r\\n \\\"date\\\": str(datetime.date.today()),\\r\\n \\\"comment\\\": presentation.description}\",\n \"def create_stim_tables(\\n exptpath,\\n stimulus_names = ['drifting_gratings_grid', 'natural_movie_full', \\n 'natural_movie_one','checkerboard', 'dot'],\\n verbose = True):\\n data = load_stim(exptpath)\\n twop_frames = load_alignment(exptpath)\\n\\n stim_table_funcs = {\\n 'drifting_gratings_grid': DGgrid_table,\\n 'natural_movie_full': NMfull_table,\\n 'natural_movie_one': NMone_table,\\n 'checkerboard': Checkerboard_table,\\n 'dot': Dot_table\\n }\\n stim_table = {}\\n for stim_name in stimulus_names:\\n try:\\n stim_table[stim_name] = stim_table_funcs[stim_name](\\n data, twop_frames\\n )\\n except KeyError:\\n if verbose:\\n print(\\n 'Could not locate stimulus type {} in {}'.format(\\n stim_name, exptpath\\n )\\n )\\n continue\\n\\n return stim_table\",\n \"def count_layouts(prs:Presentation) -> Tuple[int, Dict[str, int]]:\\n layouts = collections.defaultdict(int)\\n layouts_interactive = 0\\n for slide in prs.slides:\\n layouts[slide.slide_layout.name] += 1\\n if slide.slide_layout.name in INTERACTIVE:\\n layouts_interactive += 1\\n return (layouts_interactive, layouts)\",\n \"def debug_dump(prs:Presentation):\\n print(\\\"Presentation has\\\", len(prs.slides), \\\"slides\\\")\\n\\n # Print summary of all slides, plus text\\n n = 0\\n for slide in prs.slides:\\n n += 1\\n print(\\\"========== slide {} ========== [{}]\\\".format(n, slide.slide_layout.name))\\n for shape in slide.shapes:\\n if not shape.has_text_frame:\\n continue\\n print(shape.name)\\n for paragraph in shape.text_frame.paragraphs:\\n for run in paragraph.runs:\\n print(\\\" \\\" + run.text)\",\n \"def featurize_sift(list_of_demonstrations, kinematics, sr):\\n\\n\\tdata_X_xy = {}\\n\\tdata_X_x = {}\\n\\n\\tfor demonstration in list_of_demonstrations:\\n\\t\\tprint \\\"SIFT for \\\", demonstration\\n\\t\\tPATH_TO_ANNOTATION = constants.PATH_TO_DATA + constants.ANNOTATIONS_FOLDER + demonstration + \\\"_\\\" + str(constants.CAMERA) + \\\".p\\\"\\n\\n\\t\\tZ = []\\n\\t\\tstart, end = parser.get_start_end_annotations(PATH_TO_ANNOTATION)\\n\\t\\tfor frm in range(start, end + 1):\\n\\t\\t\\tPATH_TO_IMAGE = constants.PATH_TO_DATA + constants.NEW_FRAMES_FOLDER + demonstration + \\\"_\\\" + constants.CAMERA + \\\"/\\\"\\n\\t\\t\\tZ.append(sift.run_sift_frame(utils.get_full_image_path(PATH_TO_IMAGE, frm)))\\n\\n\\t\\tZ = np.array(Z)\\n\\t\\tZ = Z.reshape(Z.shape[0],1)\\n\\n\\t\\tW = kinematics[demonstration]\\n\\t\\tW_onlyx = utils.only_X(W)\\n\\n\\t\\tX = np.concatenate((W, Z), axis = 1)\\n\\t\\tX_onlyx = np.concatenate((W_onlyx, Z), axis = 1)\\n\\n\\t\\tdata_X_xy[demonstration] = X\\n\\t\\tdata_X_x[demonstration] = X_onlyx\\n\\n\\tpickle.dump(data_X_xy, open(PATH_TO_FEATURES + \\\"SIFT_xy.p\\\", \\\"wb\\\"))\\n\\tpickle.dump(data_X_x, open(PATH_TO_FEATURES + \\\"SIFT_x.p\\\", \\\"wb\\\"))\",\n \"def process_paper(filename):\\n\\n # Start time\\n start_time = time.time()\\n\\n # Read in the paper\\n paper = useful_functions.read_in_paper(filename, sentences_as_lists=True)\\n\\n # Extract the gold summary\\n gold = paper[\\\"HIGHLIGHTS\\\"]\\n gold_string_list = [\\\" \\\".join(x) for x in gold]\\n\\n # Extract the title\\n title = paper[\\\"MAIN-TITLE\\\"][0]\\n title_string = \\\" \\\".join(title)\\n\\n # Extract the abstract\\n abstract = paper[\\\"ABSTRACT\\\"]\\n abstract_string_list = [\\\" \\\".join(x) for x in abstract]\\n\\n # Extract the keyphrases\\n try:\\n keyphrases = paper[\\\"KEYPHRASES\\\"][0]\\n except IndexError:\\n keyphrases = []\\n\\n # Turn the paper into a single string and calculate the bag of words score\\n paper_string = \\\" \\\".join([\\\" \\\".join(x) for key, val in paper.iteritems() for x in val])\\n bag_of_words = useful_functions.calculate_bag_of_words(paper_string)\\n\\n # Get the paper as a list of sentences, associating each sentence with its section name - will be used by oracle\\n # to find best summary sentences.\\n paper_sentences = [(\\\" \\\".join(x), key) for key, val in paper.iteritems() for x in val\\n if key != \\\"ABSTRACT\\\"]\\n\\n # Create a list of sentences, their ROUGE-L scores with the Highlights and the section they occur in\\n # (as a string)\\n sents_scores_secs = []\\n\\n for sentence, section in paper_sentences:\\n # For some reason the candidate sentence needs to be the only item in a list\\n r_score = rouge.calc_score([sentence], gold_string_list)\\n\\n sents_scores_secs.append((sentence.split(\\\" \\\"), r_score, section))\\n\\n # Sort the sentences, scores and sections into descending order\\n sents_scores_secs = sorted(sents_scores_secs, key=itemgetter(1), reverse=True)\\n\\n pos_sents_scores_secs = sents_scores_secs[:num_summary]\\n neg_sents_scores_secs = sents_scores_secs[num_summary:]\\n\\n if len(neg_sents_scores_secs) < len(pos_sents_scores_secs):\\n print(\\\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\\\".format(\\n Color.RED, filename, Color.END))\\n return\\n\\n # Positive sentences\\n positive_sents_secs_class = [(sent, sec, 1) for sent, _, sec in pos_sents_scores_secs]\\n\\n # Negative sentences\\n\\n # Take the sentences not used as positive and reverse it to have worst scores first then take an equal number\\n neg_sents_scores_secs = [x for x in reversed(neg_sents_scores_secs)][:len(positive_sents_secs_class)]\\n negative_sents_secs_class = [(sent, sec, 0) for sent, _, sec in neg_sents_scores_secs]\\n\\n # Don't create data from this paper if it's less than 40 sentences - i.e. there would be more positive than\\n # negative data. The data needs to be balanced.\\n #if len(positive_sents_secs_class) != len(negative_sents_secs_class):\\n # print(\\\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\\\".format(\\n # Color.RED, filename, Color.END))\\n # return\\n\\n # Concatenate the positive and negative sentences into a single data item and shuffle it\\n data = positive_sents_secs_class + negative_sents_secs_class\\n random.shuffle(data)\\n\\n # Average word vectors of each sentence and convert to list for JSON serialisation\\n sentvecs_secs_class = [(useful_functions.sentence2vec(sent).tolist(), sec, y) for sent, sec, y in data]\\n\\n # Calculate features for each sentence\\n features = [useful_functions.calculate_features(sent, bag_of_words, document_wordcount, keyphrases,\\n abstract_string_list, title_string, sec)\\n for sent, sec, y in data]\\n\\n # Calculate abstract vector\\n abs_vector = useful_functions.abstract2vector(abstract_string_list).tolist()\\n\\n # Description of the data\\n description_text = \\\"All text is of the form of a list of lists, where each sentence is a list of words. The\\\" \\\\\\n \\\" sentences are of the form [(sentence (as a list of words), section in paper,\\\" \\\\\\n \\\" classification)]. The sentence vectors are of a similar form, except the sentence text is\\\" \\\\\\n \\\" replaced with the vector representation of the sentence. The features are of the form \\\" \\\\\\n \\\"[(AbstractROUGE, TF-IDF, Document_TF-IDF, keyphrase_score, title_score, numeric_score,\\\" \\\\\\n \\\" sentence_length, section)]. The dimensions of each sentence vector are [1x100]. The \\\" \\\\\\n \\\"abstract vector is a single [1x100] vector also.\\\"\\n\\n # The data item that will be written for this paper\\n data_item = {\\n \\\"filename\\\": filename,\\n \\\"gold\\\": gold,\\n \\\"title\\\": paper[\\\"MAIN-TITLE\\\"],\\n \\\"abstract\\\": abstract,\\n \\\"abstract_vec\\\": abs_vector,\\n \\\"sentences\\\": data,\\n \\\"sentence_vecs\\\": sentvecs_secs_class,\\n \\\"sentence_features\\\": features,\\n \\\"description\\\": description_text\\n }\\n\\n # Write the data out\\n with open(TRAINING_DATA_WRITE_LOC + filename.strip(\\\".txt\\\") + \\\".json\\\", \\\"wb\\\") as f:\\n json.dump(data_item, f)\\n\\n print(\\\"--> Finished processing {}, took {} seconds, data length: {}.\\\".format(\\n filename, (time.time() - start_time), len(data)))\",\n \"def parse(self, is_president):\\n mp = {}\\n self.content = self.page.find(id=\\\"content\\\")\\n\\n salutation = self.content.find(id=\\\"inhalt\\\").text.strip()\\n if is_president:\\n salutation = salutation[: salutation.rfind(\\\" - \\\")]\\n mp[\\\"is_president\\\"] = is_president\\n mp[\\\"salutation\\\"] = salutation\\n mp[\\\"in_committees\\\"] = self.page.find(\\\"a\\\", href=\\\"#tab-Ausschuesse\\\") is not None\\n mp.update(self._parse_picture())\\n mp.update(self._parse_contact_information())\\n mp.update(self._parse_biography())\\n return mp\",\n \"def get_plotting_data(each_misfit_windows_collection, iterations_list, snr_threshold, event_depth_dict):\\n result = {}\\n phases_zr = [\\\"P\\\", \\\"pP\\\", \\\"sP\\\", \\\"PP\\\", \\\"S\\\", \\\"sS\\\", \\\"SS\\\"]\\n phases_t = [\\\"ScS\\\", \\\"S\\\", \\\"sS\\\", \\\"SS\\\"]\\n conditions = {\\n \\\"P\\\": {\\n \\\"exclude_p\\\": False,\\n \\\"exclude_s\\\": True\\n },\\n \\\"pP\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"sP\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"PP\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"S\\\": {\\n \\\"exclude_p\\\": False,\\n \\\"exclude_s\\\": False\\n },\\n \\\"sS\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"SS\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"ScS\\\": {\\n \\\"exclude_p\\\": True,\\n \\\"exclude_s\\\": True\\n },\\n \\\"surface_z\\\": {\\n \\\"exclude_p\\\": False,\\n \\\"exclude_s\\\": False\\n },\\n \\\"surface_r\\\": {\\n \\\"exclude_p\\\": False,\\n \\\"exclude_s\\\": False\\n },\\n \\\"surface_t\\\": {\\n \\\"exclude_p\\\": False,\\n \\\"exclude_s\\\": False\\n },\\n }\\n # we can exrtact the information from the misfit_windows in the order of the pdf output.\\n # order will be z,r,t[,surface_z,surface_r,surface_t]\\n rep_net_sta = sorted(event_depth_dict.keys())[0]\\n event_depth_this_event = event_depth_dict[rep_net_sta]\\n if (event_depth_this_event > SURFACE_THRESHOLD):\\n category_list = [\\\"z\\\", \\\"r\\\", \\\"t\\\"]\\n category_phases = [phases_zr, phases_zr, phases_t]\\n else:\\n category_list = [\\\"z\\\", \\\"r\\\", \\\"t\\\", \\\"surface_z\\\", \\\"surface_r\\\", \\\"surface_t\\\"]\\n category_phases = [phases_zr, phases_zr, phases_t,\\n [\\\"surface_z\\\"], [\\\"surface_r\\\"], [\\\"surface_t\\\"]]\\n for each_iteration in iterations_list:\\n result[each_iteration] = {}\\n for each_category, each_category_phases in zip(category_list, category_phases):\\n result[each_iteration][each_category] = []\\n for each_category_phase in each_category_phases:\\n phase_condition = conditions[each_category_phase]\\n cc = get_windows_cc(\\n each_misfit_windows_collection[each_iteration], phase_condition[\\n \\\"exclude_p\\\"], phase_condition[\\\"exclude_s\\\"],\\n each_category, snr_threshold, each_category_phase)\\n cc = cc[cc >= 0]\\n deltat = get_windows_deltat(\\n each_misfit_windows_collection[each_iteration], phase_condition[\\n \\\"exclude_p\\\"], phase_condition[\\\"exclude_s\\\"],\\n each_category, snr_threshold, each_category_phase)\\n deltat = deltat[np.abs(deltat) <= 10]\\n similarity = get_windows_similarity(\\n each_misfit_windows_collection[each_iteration], phase_condition[\\n \\\"exclude_p\\\"], phase_condition[\\\"exclude_s\\\"],\\n each_category, snr_threshold, each_category_phase)\\n similarity = similarity[similarity >= 0]\\n result[each_iteration][each_category].append(\\n {\\\"net_sta\\\": get_windows_net_sta(\\n each_misfit_windows_collection[each_iteration], phase_condition[\\n \\\"exclude_p\\\"], phase_condition[\\\"exclude_s\\\"],\\n each_category, snr_threshold, each_category_phase),\\n \\\"cc\\\": cc,\\n \\\"deltat\\\": deltat,\\n \\\"similarity\\\": similarity,\\n }\\n )\\n # result:dict->each_iteration:dict->each_category:list as the dict showed before, we should return the category_phases\\n # we should combine the surface wave phases to one page\\n if (len(category_phases) == 6):\\n for each_iteration in iterations_list:\\n category_phases = [phases_zr, phases_zr, phases_t,\\n [\\\"surface_z\\\", \\\"surface_r\\\", \\\"surface_t\\\"]]\\n category_list = [\\\"z\\\", \\\"r\\\", \\\"t\\\", \\\"surface\\\"]\\n result[each_iteration][\\\"surface\\\"] = []\\n result[each_iteration][\\\"surface\\\"].append(\\n result[each_iteration][\\\"surface_z\\\"][0])\\n result[each_iteration][\\\"surface\\\"].append(\\n result[each_iteration][\\\"surface_r\\\"][0])\\n result[each_iteration][\\\"surface\\\"].append(\\n result[each_iteration][\\\"surface_t\\\"][0])\\n del result[each_iteration][\\\"surface_z\\\"]\\n del result[each_iteration][\\\"surface_r\\\"]\\n del result[each_iteration][\\\"surface_t\\\"]\\n\\n return result, category_phases, category_list\",\n \"def get_illustrations(self):\\n \\n temp=[[\\\"middle\\\",[],0,0],[\\\"middle\\\",[],0,0],[\\\"center\\\",[],0,0]]\\n for pic in self.illustrations.all():\\n \\n if pic.position==\\\"L\\\":\\n temp[0][1].append(pic)\\n temp[0][2]=max(temp[0][2],pic.width)\\n temp[0][3]+=pic.height\\n elif pic.position==\\\"R\\\":\\n temp[1][1].append(pic)\\n temp[1][2]=max(temp[1][2],pic.width)\\n temp[1][3]+=pic.height\\n else:\\n temp[2][1].append(pic)\\n temp[2][2]+=pic.width\\n temp[2][3]=max(temp[2][3],pic.height)\\n temp[0][3]=max(temp[0][3],temp[1][3])\\n temp[1][3]=temp[0][3]\\n if len(temp[2][1])>0:\\n pos = temp[2][1][0].position\\n if pos == \\\"BR\\\":\\n temp[2][0] = \\\"right\\\"\\n elif pos == \\\"BL\\\":\\n temp[2][0] = \\\"left\\\"\\n for i in range(2):\\n if len(temp[i][1])>0:\\n pos = temp[i][1][0].position\\n if pos in [\\\"RT\\\",\\\"LT\\\"]:\\n temp[i][0] = \\\"top\\\"\\n elif pos in [\\\"RB\\\",\\\"LB\\\"]:\\n temp[i][0] = \\\"bottom\\\"\\n self.text_size=(-temp[0][2]-temp[1][2],-temp[2][3])\\n print(temp)\\n return temp\",\n \"def parse_layout(input_filename):\\n with open(input_filename, 'r') as layout_file:\\n height = int(layout_file.next().strip()) # = height\\n layout_file.next() # = width\\n n_info = int(layout_file.next().strip()) # = number of associated info pieces\\n layout = \\\"\\\"\\n for i in xrange(height):\\n layout += layout_file.next()\\n patt_info = \\\\\\n re.compile(r\\\"^\\\\s*(?P<row>\\\\d+)\\\\s+(?P<col>\\\\d+)\\\\s+(?P<word>[\\\\w']+).*\\\")\\n info_dict = {}\\n for i in xrange(n_info):\\n match_info = patt_info.match(layout_file.next())\\n loc = ( int(match_info.group('row')), int(match_info.group('col')) )\\n info_dict[loc] = match_info.group('word')\\n return (layout, info_dict)\",\n \"def get_presentations(self):\\r\\n raise NotImplementedError\",\n \"def info_about_petrol_kinds(petrol_stations):\\n info_about_petrol_kinds = {}\\n info_about_petrol_kinds['total amount of petrol'] = 0\\n\\n for number_of_petrol in petrol_stations:\\n for petrol_name in petrol_stations[number_of_petrol]['kinds']:\\n if petrol_name not in info_about_petrol_kinds:\\n info = {}\\n if petrol_name == 'АИ-80':\\n price = 38.95\\n elif petrol_name == 'АИ-92':\\n price = 43.01\\n elif petrol_name == 'АИ-95':\\n price = 45.69\\n elif petrol_name == 'АИ-98':\\n price = 49.2\\n info['price'] = price\\n info['stations'] = [number_of_petrol]\\n info['amount of petrol'] = 0\\n info_about_petrol_kinds[petrol_name] = info\\n else:\\n info = info_about_petrol_kinds[petrol_name]\\n info['stations'] = info['stations'] + [number_of_petrol]\\n return info_about_petrol_kinds\",\n \"def get_stim_onset_times(sessions, metadata_dict):\\n if not isinstance(sessions, list):\\n sessions = list(sessions)\\n\\n for line in sessions:\\n session_id = line['Sess.ID']\\n if session_id: # we loaded a line with session info\\n session_name = '{}_{}'.format(line['Experiment'], line['Sess.ID'])\\n\\n # Check if session is already in database\\n if database is not None and session_name in database.index:\\n continue\\n session_stimuli = {}\\n session_stimuli['session_id'] = session_id\\n session_stimuli['stimuli'] = {}\\n session_stimuli['stimuli']['visual'] = []\\n session_stimuli['stimuli']['audio'] = []\\n session_stimuli['stimuli']['digital'] = []\\n videopaths = []\\n # load data from .tdms and .avi fils\\n for recording in line['Recordings']:\\n path = os.path.join(line['Base fld'], line['Exp fld'], recording)\\n for f in os.listdir(path):\\n if '.avi' in f:\\n videopaths.append(os.path.join(path, f))\\n print(videopaths)\\n elif '.tdms' == f[-5:]:\\n tdmspath = os.path.join(path, f)\\n # Loop over each .tdms file and extract stimuli frames\\n print(colored('Loading {}: {}'.format(session_name,os.path.basename(tdmspath)),'yellow'))\\n tdms = TdmsFile(tdmspath)\\n if metadata_dict[session_name]['software'] == 'behaviour':\\n visual_rec_stims, audio_rec_stims, digital_rec_stims = [], [], []\\n for group in tdms.groups():\\n for obj in tdms.group_channels(group):\\n if 'stimulis' in str(obj).lower():\\n for idx in obj.as_dataframe().loc[0].index:\\n if \\\"/' \\\" in idx:\\n framen = int(idx.split(\\\"/' \\\")[1].split('-')[0])\\n elif \\\"/' \\\" in idx:\\n framen = int(idx.split(\\\"/' \\\")[1].split('-')[0])\\n else:\\n framen = int(idx.split(\\\"/'\\\")[2].split('-')[0])\\n if 'visual' in str(obj).lower():\\n visual_rec_stims.append(framen)\\n elif 'audio' in str(obj).lower():\\n audio_rec_stims.append(framen)\\n elif 'digital' in str(obj).lower():\\n digital_rec_stims.append(framen)\\n else:\\n print(colored('Couldnt load stim correctly','yellow'))\\n # Now use the AI channels to find the *real* stimulus onset times and replace them\\n if audio_rec_stims:\\n stimulus_on_idx = np.where(tdms.group_channels('AI')[3].data > .55)[0] #in first data sets this is AI 1, later AI 2\\n idx_since_last_stimulus_on = np.diff(stimulus_on_idx)\\n if stimulus_on_idx.size:\\n stimulus_start_idx = stimulus_on_idx[np.append(np.ones(1).astype(bool),idx_since_last_stimulus_on>2*10000)] #usually 10 or 30\\n stimulus_start_frame = np.ceil(stimulus_start_idx / 10000 / (33 + 1 / 3) * 1000).astype(int)\\n stimulus_start_frame = stimulus_start_frame[stimulus_start_frame > 300]\\n else:\\n stimulus_start_frame = np.array(audio_rec_stims)\\n print('NO STIMULI FOUND!!')\\n\\n if len(stimulus_start_frame) != len(audio_rec_stims):\\n print('audio AI channel does not match number of timestamps by ' + str(len(audio_rec_stims)-len(stimulus_start_frame)) )\\n else:\\n discrepancy = stimulus_start_frame - audio_rec_stims\\n if sum(discrepancy>8):\\n print('audio AI channel does not match values of timestamps')\\n else:\\n print(discrepancy)\\n # for conditioning experiment, just use what the tdms says\\n # if 'food' in line['Experiment']:\\n # stimulus_start_frame = np.array(audio_rec_stims)\\n audio_rec_stims = list(stimulus_start_frame)\\n\\n session_stimuli['stimuli']['visual'].append(visual_rec_stims)\\n session_stimuli['stimuli']['audio'].append(audio_rec_stims)\\n session_stimuli['stimuli']['digital'].append(digital_rec_stims)\\n\\n else:\\n \\\"\\\"\\\" HERE IS WHERE THE CODE TO GET THE STIM TIMES IN MANTIS WILL HAVE TO BE ADDEDD \\\"\\\"\\\"\\n pass\\n\\n # Add to dictionary (or update entry)\\n stimulus_dict[session_name] = session_stimuli\\n return stimulus_dict\",\n \"def featurize_1(list_of_demonstrations, kinematics, sr):\\n\\tprint \\\"FEATURIZATION 1\\\"\\n\\n\\tdata_X_1 = {}\\n\\tdata_X_2 = {}\\n\\tfor demonstration in list_of_demonstrations:\\n\\t\\tprint \\\"SIFT for \\\", demonstration\\n\\t\\tstart, end = parser.get_start_end_annotations(constants.PATH_TO_DATA + constants.ANNOTATIONS_FOLDER\\n\\t\\t\\t\\t\\t\\t+ demonstration + \\\"_\\\" + constants.CAMERA +\\\".p\\\")\\n\\n\\t\\tW = kinematics[demonstration]\\n\\t\\tW_sampled = utils.sample_matrix(W, sampling_rate = sr)\\n\\n\\n\\t\\tPATH_TO_SIFT = constants.PATH_TO_DATA + \\\"sift_FCED/SIFT_\\\"+ demonstration\\n\\t\\tZ = pickle.load(open(PATH_TO_SIFT + \\\"_1.p\\\", \\\"rb\\\"))\\n\\t\\tZ = Z[start:end + 1]\\n\\t\\tZ_sampled_1 = utils.sample_matrix(Z, sampling_rate = sr)\\n\\n\\t\\tZ = pickle.load(open(PATH_TO_SIFT + \\\"_2.p\\\", \\\"rb\\\"))\\n\\t\\tZ = Z[start:end + 1]\\n\\t\\tZ_sampled_2 = utils.sample_matrix(Z, sampling_rate = sr)\\n\\n\\t\\tassert Z_sampled_1.shape[0] == W_sampled.shape[0]\\n\\t\\tassert Z_sampled_2.shape[0] == W_sampled.shape[0]\\n\\n\\t\\tdata_X_1[demonstration] = np.concatenate((W_sampled, Z_sampled_1), axis = 1)\\n\\t\\tdata_X_2[demonstration] = np.concatenate((W_sampled, Z_sampled_2), axis = 1)\\n\\n\\tpickle.dump(data_X_1, open(PATH_TO_FEATURES + \\\"SIFT_1.p\\\", \\\"wb\\\"))\\n\\tpickle.dump(data_X_2, open(PATH_TO_FEATURES + \\\"SIFT_2.p\\\", \\\"wb\\\"))\",\n \"def read_documents(file_path: str) -> List[Tuple[str, List[Tuple[str, List[str]]]]]:\\n print(f'Reading SciREX documents from {file_path}')\\n with open(file_path, 'r') as json_file:\\n json_list = list(json_file)\\n\\n papers = []\\n for json_str in json_list:\\n papers.append(json.loads(json_str))\\n\\n def find_index_in_array(index, array):\\n for array_index, (start, end) in enumerate(array):\\n if end > index:\\n return array_index\\n\\n result = []\\n for paper in papers:\\n result_sections = []\\n\\n # Populate the sentences list with section information.\\n for index, section in enumerate(paper['sections']):\\n # Get the first sentence of the section.\\n index = find_index_in_array(section[0], paper['sentences'])\\n sentence = paper['sentences'][index]\\n # The section name is the first sentence of the section.\\n section_name = paper['words'][sentence[0]:sentence[1]]\\n\\n # Example for the first sentence on a section:\\n # [\\\"section\\\", \\\":\\\", \\\"Abstract\\\"]\\n # If the first sentence starts with [\\\"section\\\", \\\":\\\"], we are only interested in the words after that prefix.\\n if len(section_name) >= 2 and section_name[1] == \\\":\\\":\\n section_name_length = len(section_name)\\n section_name = section_name[2:]\\n else:\\n section_name_length = 0\\n if index == 0:\\n # First section will always be labled as 'Title'\\n section_name = ['Title']\\n else:\\n section_name = []\\n\\n result_sections.append((\\\" \\\".join(section_name), []))\\n\\n words = paper['words']\\n for info in paper['sentences']:\\n sentence = words[info[0]:info[1]]\\n section_index = find_index_in_array(info[0], paper['sections'])\\n\\n result_sections[section_index][1].append(\\\" \\\".join(sentence))\\n\\n result.append((str(paper['doc_id']), result_sections))\\n\\n return result\",\n \"def organize_data(self, data):\\n presentation = \\\"\\\"\\n\\n offices = data['offices']\\n living = data['living']\\n\\n presentation += \\\"OFFICE \\\\n\\\\n\\\"\\n if len(offices) == 0:\\n presentation += \\\"No Office allocations\\\\n\\\"\\n\\n else:\\n presentation += \\\"Office Allocations\\\\n\\\"\\n for office in offices:\\n presentation += office['room'].capitalize() + \\\"\\\\n\\\"\\n presentation += \\\"Members: \\\\n\\\"\\n presentation += ','.join(office['names'])\\n\\n presentation += \\\"LIVING SPACES \\\\n\\\\n\\\"\\n if len(offices) == 0:\\n presentation += \\\"No Living space allocations\\\\n\\\"\\n\\n else:\\n presentation += \\\"Office Allocations\\\\n\\\"\\n for space in living:\\n presentation += living['room'].capitalize() + \\\"\\\\n\\\"\\n presentation += ','.join(living['names'])\\n\\n return presentation\",\n \"def extract_data(filename: str, directory: str) -> Dict:\\n with open(filename) as f:\\n lines = f.readlines()\\n\\n # Split data by :\\n annotations = [line.replace(\\\" \\\", \\\"\\\").split(\\\":\\\") for line in lines]\\n\\n # Split data by ;\\n for annotation in annotations:\\n annotation[1] = annotation[1].split(\\\";\\\")\\n\\n # Loop for saving metadata into dictionary\\n annot_dict = dict()\\n for annotation in annotations:\\n img = annotation[0]\\n bbox_metadata = annotation[1]\\n bbox = list()\\n \\n # Path to images\\n img_path = os.path.join(directory, img)\\n im = Image.open(img_path)\\n width, height = im.size\\n\\n # Iterate over each bounding box\\n for annot in bbox_metadata:\\n \\n if \\\"MISC_SIGNS\\\" == annot:\\n signStatus = 'N/A'\\n signTypes = \\\"MISC_SIGNS\\\"\\n signPurpose = 'N/A'\\n\\n signBB = (-1, -1, -1, -1)\\n signC = (-1, -1)\\n signSize = 0\\n aspectRatio = 0\\n\\n bbox.append({\\\"signStatus\\\": signStatus, \\n \\\"signTypes\\\": signTypes, \\n \\\"signPurpose\\\": signPurpose, \\n \\\"signBB\\\": signBB, \\n \\\"signC\\\": signC, \\n \\\"signSize\\\": signSize, \\n \\\"aspectRatio\\\": aspectRatio})\\n elif \\\"\\\\n\\\" in annot:\\n pass\\n else:\\n data = annot.split(\\\",\\\")\\n \\n signStatus = data[0] # signStatus\\n signTypes = data[6] # signTypes\\n signPurpose = data[5] # PROHIBITORY, WARNING, OTHER, INFORMATION\\n tl_x, tl_y, br_x, br_y = data[3], data[4], data[1], data[2]\\n \\n if is_valid_decimal(tl_x):\\n tl_x = float(tl_x)\\n else:\\n tl_x = float(cutoff_letter(tl_x))\\n\\n if is_valid_decimal(tl_y):\\n tl_y = float(tl_y)\\n else:\\n tl_y = float(cutoff_letter(tl_y))\\n\\n if is_valid_decimal(br_x):\\n br_x = float(br_x)\\n else:\\n br_x = float(cutoff_letter(br_x))\\n\\n if is_valid_decimal(br_y):\\n br_y = float(br_y)\\n else:\\n br_y = float(cutoff_letter(br_y))\\n\\n if tl_x < 0:\\n tl_x = 0\\n elif tl_x > width:\\n tl_x = width\\n \\n if tl_y < 0:\\n tl_y = 0\\n elif tl_y > height:\\n tl_y = height\\n \\n if br_x < 0:\\n br_x = 0\\n elif br_x > width:\\n br_x = width\\n \\n if br_y < 0:\\n br_y = 0\\n elif br_y > height:\\n br_y = height\\n\\n signBB = (tl_x, tl_y, br_x, br_y)\\n signC = (br_x + tl_x)/2, (br_y + tl_y)/2\\n signSize = (br_x - tl_x) * (br_y - tl_y)\\n aspectRatio = (br_x - tl_x) / (br_y - tl_y)\\n\\n bbox.append({\\\"signStatus\\\": signStatus, \\n \\\"signTypes\\\": signTypes, \\n \\\"signPurpose\\\": signPurpose, \\n \\\"signBB\\\": signBB, \\n \\\"signC\\\": signC, \\n \\\"signSize\\\": signSize, \\n \\\"aspectRatio\\\": aspectRatio})\\n \\n \\n annot_dict[img_path] = bbox\\n return annot_dict\",\n \"def get_style_features(text, nlp):\\n doc = nlp(text)\\n \\n final_data = {f'mpqa_{k}': v for k, v in doc._.total_argument_types.items()}\\n final_data['tb_sentiment'] = doc.sentiment\\n final_data['tb_subjectivity'] = doc._.subjectivity\\n \\n # Return avg for emotions\\n emotion_data = doc._.emotions\\n emotion_data = {k: v / len(doc) for k, v in emotion_data.items()}\\n \\n final_data.update(emotion_data)\\n \\n cur_lemmas = list(set(w.lemma_ for w in doc))\\n final_data['lemmas'] = cur_lemmas\\n \\n return final_data\",\n \"def overview(game_id):\\n output = {}\\n # get data\\n overview = mlbgame.data.get_overview(game_id)\\n # parse data\\n overview_root = etree.parse(overview).getroot()\\n\\n try:\\n output = add_raw_box_score_attributes(output, game_id)\\n except ValueError:\\n pass\\n\\n # get overview attributes\\n for x in overview_root.attrib:\\n output[x] = overview_root.attrib[x]\\n\\n # Get probable starter attributes if they exist\\n home_pitcher_tree = overview_root.find('home_probable_pitcher')\\n if home_pitcher_tree is not None:\\n output.update(build_namespaced_attributes(\\n 'home_probable_pitcher', home_pitcher_tree))\\n else:\\n output.update(build_probable_starter_defaults('home'))\\n\\n away_pitcher_tree = overview_root.find('away_probable_pitcher')\\n if away_pitcher_tree is not None:\\n output.update(build_namespaced_attributes(\\n 'away_probable_pitcher', away_pitcher_tree))\\n else:\\n output.update(build_probable_starter_defaults('away'))\\n\\n return output\",\n \"def studio_state(self):\\n submission = self.get_question()\\n if submission:\\n uploaded_submission = submission.get(\\\"question\\\").get(\\\"filename\\\", None)\\n if uploaded_submission:\\n quploaded = {\\\"filename\\\": submission['question']['filename']}\\n else:\\n quploaded = None\\n else:\\n quploaded = None\\n \\n submission = self.get_solution()\\n if submission:\\n uploaded_submission = submission.get(\\\"solution\\\").get(\\\"filename\\\", None)\\n if uploaded_submission:\\n suploaded = {\\\"filename\\\": submission['solution']['filename']}\\n else:\\n suploaded = None\\n else:\\n suploaded = None\\n\\n\\n return {\\n \\\"display_name\\\": self.title,\\n \\\"question\\\":self.question,\\n \\\"uploaded\\\": quploaded,\\n \\\"suploaded\\\":suploaded,\\n \\\"raw_question\\\" : self.raw_question,\\n \\\"solutionUploaded\\\": suploaded,\\n \\\"raw_soluion\\\": self.raw_solution,\\n \\\"weight\\\":self.weight\\n }\",\n \"def _presets(self, hdr):\\n # presput/slit = 1080\\n # presput/lens = 3640\\n # measure/slit = 1080\\n # measure/lens = 3640\\n # 2 x 1080 padding\\n # padding can be before presput, inbetween presput and measure,\\n # and after measure.\\n\\n d = {}\\n d['Presputter'] = {}\\n padding = 0\\n if not self._preset_start(hdr):\\n hdr.seek(1080, 1)\\n padding += 1\\n d['Presputter']['Slits'] = self._preset(hdr, group='slit')\\n d['Presputter']['Lenses'] = self._preset(hdr, group='lens')\\n d['Measure'] = {}\\n if not self._preset_start(hdr):\\n hdr.seek(1080, 1)\\n padding += 1\\n d['Measure']['Slits'] = self._preset(hdr, group='slit')\\n d['Measure']['Lenses'] = self._preset(hdr, group='lens')\\n hdr.seek(1080 * (2 - padding), 1)\\n return d\",\n \"def get_hole_dicts(sketch):\\n return {\\n name: bits\\n for name, bits in findall(r'(\\\\w+)= \\\\?\\\\?\\\\((\\\\d+)\\\\);', sketch)\\n }\",\n \"def proc_education_summary( summary: Tag ) -> Dict[str, str]:\\n edu_record = dict()\\n edu_record['school'] = summary.find('h3').text.strip()\\n edu_record['is_abroad_school'] = _is_abroad_school( edu_record['school'] )\\n\\n for parag in summary.find_all('p'):\\n spans = [span.text.strip() for span in parag.find_all('span')]\\n if len( spans ) == 2:\\n fld_name, value = spans\\n value = value.strip()\\n elif len(spans) == 0:\\n # print( 'education parag: ', parag )\\n edu_record['description'] = parag.text.strip()\\n continue\\n else:\\n print( 'education spans: ', spans )\\n continue\\n\\n if fld_name == 'Nombre de la titulación':\\n edu_record['degree_raw'] = value\\n edu_record['degree'] = _classify_degree( value )\\n # print( 'degree: ', value, _classify_degree(value) )\\n elif fld_name == 'Disciplina académica':\\n edu_record['field_raw'] = value\\n elif fld_name == 'Nota':\\n edu_record['grade_raw'] = value\\n elif fld_name.startswith('Fechas de estudios'):\\n edu_record['period_raw'] = value\\n elif fld_name.startswith('Actividades y asociaciones'):\\n edu_record['activities_raw'] = value\\n else:\\n print(\\\"proc_education_summary: \\\", fld_name, ' :: ', value)\\n\\n if edu_record.get('degree', 'Unknown') == 'Unknown':\\n if re.search( 'Ingenier|Engineering', edu_record.get('field_raw', '') ):\\n edu_record['degree'] = 'University'\\n\\n return edu_record\\n # %%\",\n \"def structure_anslysis(text, display = None):\\n st.write('Text Size Exceeded! Truncating...')\\n doc = nlp(text[:100000])\\n pos_freq = pos_tag_counts(doc)\\n ent_freq = entity_counts(doc)\\n \\n fig, axs = plt.subplots(1, 2, figsize = (15, 6))\\n \\n sns.barplot(list(pos_freq.keys()), list(pos_freq.values()), color='#e84118', ax = axs[0])\\n axs[0].set_title('POS COUNTS')\\n axs[0].set_xticklabels(labels = list(pos_freq.keys()), rotation = 90)\\n \\n sns.barplot(list(ent_freq.keys()), list(ent_freq.values()), color='#273c75', ax = axs[1])\\n axs[1].set_title('ENTITY COUNTS')\\n axs[1].set_xticklabels(labels = list(ent_freq.keys()), rotation = 90) \\n \\n plt.show()\\n \\n if display:\\n spacy_streamlit.visualize_ner(doc, labels = nlp.get_pipe('ner').labels)\\n \\n \\n return pos_freq, ent_freq\",\n \"def get_slide_analytics_new(slides) -> List[int]:\\n word_count = []\\n for slide in slides:\\n print(slide)\\n words = 0\\n for shape in slide.shapes:\\n if not shape.has_text_frame:\\n continue\\n print(shape.name)\\n for paragraph in shape.text_frame.paragraphs:\\n for run in paragraph.runs:\\n print(\\\" \\\" + run.text)\\n words += len(run.text.split())\\n word_count.append(words)\\n return word_count\",\n \"def analyze(self):\\n result = []\\n for frame_no, frame in enumerate(self.work.files('frames')):\\n areas = self.blur.check_image(frame, self.work.files('templates'))\\n for area in areas:\\n index = find_area(result, area)\\n if index == -1:\\n result.append({'area': area, 'frames': [frame_no]})\\n else:\\n result[index]['frames'].append(frame_no)\\n\\n for values in result:\\n sectors = [[values['frames'][0], values['frames'][0]]]\\n for index in range(1, len(values['frames'])):\\n if (values['frames'][index] - sectors[-1][1]) == 1:\\n sectors[-1][1] = values['frames'][index]\\n else:\\n sectors.append([values['frames'][index], values['frames'][index]])\\n values['sectors'] = sectors\\n return result\",\n \"def extract_structural_profile(merged_path, num_seq, window):\\n\\n # parse further and load structural profile as np.array\\n f = open(merged_path, 'r')\\n structure = []\\n for i in range(num_seq):\\n seq = f.readline()\\n paired = f.readline().strip().split('\\\\t')\\n hairpin = f.readline().strip().split('\\\\t')\\n internal = f.readline().strip().split('\\\\t')\\n multi = f.readline().strip().split('\\\\t')\\n external = f.readline().strip().split('\\\\t')\\n\\n paired = np.array(paired).astype(np.float32)\\n hairpin = np.array(hairpin).astype(np.float32)\\n internal = np.array(internal).astype(np.float32)\\n multi = np.array(multi).astype(np.float32)\\n external = np.array(external).astype(np.float32)\\n\\n # pad sequences\\n seq_length = len(paired)\\n offset1 = int((window - seq_length)/2)\\n offset2 = window - seq_length - offset1\\n struct = np.array([paired, hairpin, internal, multi, external])\\n num_dims = struct.shape[0]\\n if offset1:\\n struct = np.hstack([np.zeros((num_dims,offset1)), struct])\\n if offset2:\\n struct = np.hstack([struct, np.zeros((num_dims,offset2))])\\n structure.append(struct)\\n\\n return np.array(structure)\",\n \"def ppt_file_to_dict(self, file_path):\\n try:\\n file = open(file_path, \\\"rb\\\")\\n\\n except IOError as e:\\n print(e)\\n return\\n\\n pres = Presentation(file)\\n file.close()\\n\\n for i in range(len(pres.slides)):\\n self.process_slide(pres.slides[i], i + 1, file_path)\",\n \"def infotodict(seqinfo):\\n \\n \\\"\\\"\\\"\\n MCF Pilot Protocol acquired on Friday April 13th\\n \\n >>> hdc_look.py -s mfc001 -ss 1\\n series_id sequence_name series_description dim1 dim2 dim3 dim4 TR TE is_derived is_motion_corrected\\n 0 1-localizer *fl2d1 localizer 192 192 3 1 0.020 5.00 False False\\n 1 2-pre_Neutral1_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral1_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 2 3-pre_topup_A>>P *epse2d1_64 pre_topup_A>>P 64 64 140 1 2.400 38.00 False False\\n 3 4-pre_topup_P>>A *epse2d1_64 pre_topup_P>>A 64 64 140 1 2.400 38.00 False False\\n 4 5-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 4.92 False False\\n 5 6-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 7.38 False False\\n 6 7-pre+heat1_A>>P 4X4X4 *epfid2d1_64 pre+heat1_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 7 8-pre_Neutral2_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral2_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 8 9-pre+heat2_A>>P 4X4X4 *epfid2d1_64 pre+heat2_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 9 10-MPRAGE_GRAPPA2 *tfl3d1_16ns MPRAGE_GRAPPA2 256 240 192 1 2.300 2.98 False False\\n 10 11-post_Neutral3_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral3_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 11 12-post+heat3_A>>P 4X4X4 *epfid2d1_64 post+heat3_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 12 13-post_Neutral4_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral4_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 13 14-post+heat4_A>>P 4X4X4 *epfid2d1_64 post+heat4_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 14 15-post_topup_A>>P *epse2d1_64 post_topup_A>>P 64 64 140 1 2.400 38.00 False False\\n 15 16-post_topup_P>>A *epse2d1_64 post_topup_P>>A 64 64 140 1 2.400 38.00 False False\\n \\n \\\"\\\"\\\"\\n\\n bids_prefix = 'sub-{subject}/{session}/'\\n\\n pre_neutral1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_heat1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_heat2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_neutral2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-fmap_bold.{item:01d}')\\n\\n pre_neutral1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-topup_bold.{item:01d}')\\n pre_heat1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-topup_bold.{item:01d}')\\n pre_heat2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-topup_bold.{item:01d}')\\n pre_neutral2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-topup_bold.{item:01d}')\\n\\n pre_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-ap_epi.{item:01d}')\\n pre_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-pa_epi.{item:01d}')\\n\\n # The item was commented out for Phase Difference field maps. Conversion did not work correctly. I removed the item number to try to\\n # isolate the problem.\\n\\n pre_fmap_magnitude1 = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_magnitude1.{item:01d}')\\n pre_fmap_phasediff = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_phasediff.{item:01d}')\\n\\n t1w = create_key(bids_prefix + 'anat/sub-{subject}_{session}_T1w')\\n\\n post_neutral3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-fmap_bold.{item:01d}')\\n post_heat3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-fmap_bold.{item:01d}')\\n post_heat4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-fmap_bold.{item:01d}')\\n post_neutral4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-fmap_bold.{item:01d}')\\n\\n post_neutral3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-topup_bold.{item:01d}')\\n post_heat3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-topup_bold.{item:01d}')\\n post_heat4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-topup_bold.{item:01d}')\\n post_neutral4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-topup_bold.{item:01d}')\\n\\n post_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-ap_epi.{item:01d}')\\n post_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-pa_epi.{item:01d}')\\n\\n # Create an empty dictionary called info for each key\\n\\n info = {pre_neutral1_ap_fmap: [],\\n pre_heat1_ap_fmap: [],\\n pre_heat2_ap_fmap: [],\\n pre_neutral2_ap_fmap: [],\\n\\n pre_neutral1_ap_topup: [],\\n pre_heat1_ap_topup: [],\\n pre_heat2_ap_topup: [],\\n pre_neutral2_ap_topup: [],\\n\\n pre_topup_ap: [],\\n pre_topup_pa: [],\\n\\n pre_fmap_magnitude1: [],\\n pre_fmap_phasediff: [],\\n\\n t1w: [],\\n\\n post_neutral3_ap_fmap: [],\\n post_heat3_ap_fmap: [],\\n post_heat4_ap_fmap: [],\\n post_neutral4_ap_fmap: [],\\n\\n post_neutral3_ap_topup: [],\\n post_heat3_ap_topup: [],\\n post_heat4_ap_topup: [],\\n post_neutral4_ap_topup: [],\\n\\n post_topup_ap: [],\\n post_topup_pa: [],\\n\\n }\\n\\n # Loop over each sequence. Use if statements to determine which sequences should be linked to which key\\n\\n for idx, s in enumerate(seqinfo):\\n\\n if 'pre_Neutral1' in s.series_id:\\n info[pre_neutral1_ap_fmap].append([s.series_id])\\n info[pre_neutral1_ap_topup].append([s.series_id])\\n\\n if 'pre+heat1' in s.series_id:\\n info[pre_heat1_ap_fmap].append([s.series_id])\\n info[pre_heat1_ap_topup].append([s.series_id])\\n\\n if 'pre+heat2' in s.series_id:\\n info[pre_heat2_ap_fmap].append([s.series_id])\\n info[pre_heat2_ap_topup].append([s.series_id])\\n\\n if 'pre_Neutral2' in s.series_id:\\n info[pre_neutral2_ap_fmap].append([s.series_id])\\n info[pre_neutral2_ap_topup].append([s.series_id])\\n\\n if 'pre_topup_A>>P' in s.series_id:\\n info[pre_topup_ap].append([s.series_id])\\n\\n if 'pre_topup_P>>A' in s.series_id:\\n info[pre_topup_pa].append([s.series_id])\\n\\n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\\n (s.TE == 4.92)):\\n info[pre_fmap_magnitude1].append([s.series_id])\\n \\n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\\n (s.TE == 7.38)):\\n info[pre_fmap_phasediff].append([s.series_id])\\n\\n if 'MPRAGE_GRAPPA2' in s.series_id:\\n info[t1w].append([s.series_id])\\n\\n if 'post_Neutral3' in s.series_id:\\n info[post_neutral3_ap_fmap].append([s.series_id])\\n info[post_neutral3_ap_topup].append([s.series_id])\\n\\n if 'post+heat3' in s.series_id:\\n info[post_heat3_ap_fmap].append([s.series_id])\\n info[post_heat3_ap_topup].append([s.series_id])\\n\\n if 'post+heat4' in s.series_id:\\n info[post_heat4_ap_fmap].append([s.series_id])\\n info[post_heat4_ap_topup].append([s.series_id])\\n\\n if 'post_Neutral4' in s.series_id:\\n info[post_neutral4_ap_fmap].append([s.series_id])\\n info[post_neutral4_ap_topup].append([s.series_id])\\n\\n if 'post_topup_A>>P' in s.series_id:\\n info[post_topup_ap].append([s.series_id])\\n\\n if 'post_topup_P>>A' in s.series_id:\\n info[post_topup_pa].append([s.series_id])\\n\\n return info\",\n \"def test_reviewData():\\n starttime = UTCDateTime('2018-06-18T02:34:20')\\n endtime = UTCDateTime('2018-06-18T02:37:20')\\n st = rd.getdata('IU', 'TEIG,PAYG', '00', 'BHZ', starttime, endtime, savedat=True,\\n filenamepref='Test1_', loadfromfile=True, reloadfile=False)\\n\\n event_lat = 14.178\\n event_lon = -90.670\\n\\n rd.attach_coords_IRIS(st)\\n rd.attach_distaz_IRIS(st, event_lat, event_lon)\\n\\n fig = rd.recsec(st)\\n\\n freqs, amps, fig2 = rd.make_multitaper(st, render=False)\\n\\n fig3 = rd.make_spectrogram(st)\\n\\n rd.nextpow2(7)\\n\\n stacc, stvel = rd.getpeaks(st)\\n\\n rd.fourier_spectra(st)\",\n \"def parse_design(self, detailed_design_file):\",\n \"def _extract_dictionary_information(self, entry):\\n # Clean up the furigana for the result\\n furigana = \\\"\\\".join([f.text for f in entry.select(\\\".kanji\\\")])\\n\\n # Cleans the vocabulary word for the result\\n vocabulary = self._get_full_vocabulary_string(entry) if not entry.select(\\\".concept_light-representation .furigana rt\\\") else entry.select_one(\\\".concept_light-representation .furigana rt\\\").text\\n\\n # The fact that this needs to exist is really annoying.\\n # If you go to a page like this: https://jisho.org/word/%E5%8D%B0%E5%BA%A6\\n # you'll see that this is a word whose furigana is actually in katakana\\n # I didn't realize this happens (it makes sense now), and the huge issue\\n # is that there's different HTML in this case, so the previous parsing method\\n # doesn't work, so we need a new method...\\n\\n # Now there could be *really* weird cases where there's a word with both\\n # katakana furigana and hiragana furigana (which would be cool), but tbh this\\n # I'm satisfied with assuming the whole word corresponds with the whole furigana.\\n\\n # Grab the difficulty tags for the result\\n diff_tags = [m.text for m in entry.select(\\\".concept_light-tag.label\\\")]\\n\\n # Grab each of the meanings associated with the result\\n cleaned_meanings = self._isolate_meanings(entry.select_one(\\\".meanings-wrapper\\\"))\\n meanings = [m.select_one(\\\".meaning-meaning\\\") for m in cleaned_meanings]\\n meanings_texts = [m.text for m in meanings if m != None]\\n\\n # Romanize the furigana\\n halpern = kana_to_halpern(furigana)\\n\\n information = {\\n \\\"furigana\\\": furigana,\\n \\\"vocabulary\\\": vocabulary,\\n \\\"difficulty_tags\\\": diff_tags,\\n \\\"meanings\\\": dict(zip(range(1, len(meanings_texts) + 1), meanings_texts)),\\n \\\"n_meanings\\\": len(meanings_texts),\\n \\\"halpern\\\": halpern\\n }\\n\\n return information\",\n \"def _get_summary_struct(self):\\n\\n model_fields = [\\n (\\\"Number of reference examples\\\", 'num_examples')]\\n\\n training_fields = [\\n (\\\"Method\\\", 'method'),\\n (\\\"Total training time (seconds)\\\", 'training_time')]\\n\\n sections = [model_fields, training_fields]\\n section_titles = ['Schema', 'Training']\\n\\n return (sections, section_titles)\",\n \"def storefront_annotate():\\n\\n\\tprint \\\"CREATING ANNOTATIONS\\\"\\n\\tPrintBreakLine()\\n\\n\\tcurrentView = uidoc.ActiveView\\n\\tstorefrontFrames = []\\n\\tannotationNotes = []\\n\\n\\tstandardTol = 0.01\\n\\n\\n\\t#Form input\\n\\tfrom rpw.ui.forms import Label, ComboBox, Separator, Button, FlexForm\\n\\n\\tcomponents = [Label('Select System'),\\n\\t\\t\\t\\t\\tComboBox(\\\"combobox1\\\", {\\\"Elite\\\": \\\"Elite\\\", \\\"MODE\\\": \\\"MODE\\\", \\\"Extravega\\\": \\\"Extravega\\\"}),\\n\\t\\t\\t\\t\\tComboBox(\\\"combobox2\\\", {\\\"Custom/Standard\\\": \\\"CS\\\", \\\"Glass Sizes\\\": \\\"GS\\\"}),\\n\\t\\t\\t\\t\\tSeparator(),\\n\\t\\t\\t\\t\\tButton('Go')]\\n\\n\\tform = FlexForm(\\\"Storefront Annotate\\\", components)\\n\\tform.show()\\n\\n\\tif not form.values:\\n\\t\\tsys.exit()\\n\\telse: \\n\\t\\tsystemName = form.values[\\\"combobox1\\\"]\\n\\t\\tannoType = form.values[\\\"combobox2\\\"]\\n\\n\\n\\t#Load config\\n\\tstorefrontConfig = storefront_options()\\n\\n\\tif not systemName.lower() in storefrontConfig.currentConfig[\\\"currentSystem\\\"].lower():\\n\\t\\tstorefrontConfig.storefront_set_config()\\n\\t\\tsystemName = storefrontConfig.currentConfig[\\\"currentSystem\\\"]\\n\\t\\tstorefrontConfig.storefront_save_config()\\n\\t\\n\\tfamTypeDict = GetFamilyTypeDict(\\\"Panel-Symbol-Custom\\\")\\n\\tfamTypeDict.update(GetFamilyTypeDict(\\\"Panel-Symbol-Standard\\\"))\\n\\n\\t#Load standard sizes\\n\\tsystemStandardHorizontals = storefrontConfig.currentConfig[\\\"systemStandardHorizontals\\\"]\\n\\tsillStandards = systemStandardHorizontals[\\\"sill\\\"]\\n\\t\\n\\n\\n\\t#collect notest in the view if there are any\\n\\tannotationNotes = list(GetElementsInView(BuiltInCategory.OST_GenericAnnotation, Autodesk.Revit.DB.FamilyInstance, currentView.Id))\\n\\tannotationNotes = FilterElementsByName(doc, annotationNotes,[\\\"Panel\\\",\\\"Symbol\\\"], False)\\n\\n\\t#collect walls and mullions\\n\\tallStorefrontWalls = rpw.db.Collector(of_class='Wall', \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tview=currentView, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\twhere=lambda x: (str(x.WallType.Kind) == \\\"Curtain\\\") and (systemName.lower() in x.Name.lower()))\\n\\n\\tallStorefrontMullions = []\\n\\n\\t#Collect mullions\\n\\tfor sfwall in allStorefrontWalls:\\n\\t\\tfor sfMullionsId in sfwall.CurtainGrid.GetMullionIds():\\n\\t\\t\\tallStorefrontMullions.append(doc.GetElement(sfMullionsId))\\n\\n\\tannotationsList = []\\n\\n\\t# Toggle: if theres annotations in the view already, then delete them.\\n\\n\\tif annoType == \\\"CS\\\":\\n\\n\\t\\tif annotationNotes:\\n\\t\\t\\twith rpw.db.Transaction(\\\"Clear Annotations\\\"):\\n\\t\\t\\t\\tDeleteElementsInView(currentView.Id, BuiltInCategory.OST_GenericAnnotation, Autodesk.Revit.DB.FamilyInstance, \\\"Panel-Symbol-Custom\\\")\\n\\t\\t\\t\\tDeleteElementsInView(currentView.Id, BuiltInCategory.OST_GenericAnnotation, Autodesk.Revit.DB.FamilyInstance, \\\"Panel-Symbol-Standard\\\")\\n\\n\\n\\t\\t# Toggle: if there is NOT annotations in the view, then create them\\n\\t\\telse:\\n\\n\\t\\t\\tfor sfMullion in allStorefrontMullions:\\n\\n\\t\\t\\t\\tsfMullionName = sfMullion.Name\\n\\n\\t\\t\\t\\tif sfMullion.LocationCurve:\\n\\n\\t\\t\\t\\t\\tsfMullionLength = sfMullion.LocationCurve.Length\\n\\n\\t\\t\\t\\t\\tif \\\"sill\\\" in sfMullionName.lower():\\n\\t\\t\\t\\t\\t\\tplacementPoint = sfMullion.LocationCurve.Evaluate(0.5, True)\\n\\t\\t\\t\\t\\t\\ttext = \\\"\\\"\\n\\t\\t\\t\\t\\t\\tnotesymbol = None\\n\\n\\t\\t\\t\\t\\t\\tfor key, standardLength in sillStandards.items():\\n\\t\\t\\t\\t\\t\\t\\tif abs(sfMullionLength - standardLength) < standardTol:\\n\\t\\t\\t\\t\\t\\t\\t\\ttext = \\\"STANDARD\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tnotesymbol = doc.GetElement(famTypeDict[\\\"Panel-Symbol-Standard\\\"])\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\ttext = \\\"CUSTOM\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tnotesymbol = doc.GetElement(famTypeDict[\\\"Panel-Symbol-Custom\\\"])\\n\\n\\t\\t\\t\\t\\t\\tannotationsList.append([placementPoint, text, notesymbol])\\n\\t\\t\\t\\t\\n\\t\\t\\t#Place annotations\\t\\n\\t\\t\\twith rpw.db.Transaction(\\\"Clear Annotations\\\"):\\n\\t\\t\\t\\tfor annot in annotationsList:\\n\\t\\t\\t\\t\\tpoint = annot[0]\\n\\t\\t\\t\\t\\tsym = annot[2]\\n\\t\\t\\t\\t\\tannotInst = doc.Create.NewFamilyInstance(point, sym, currentView)\\n\\t\\t\\t\\t\\tfor p in annotInst.Parameters:\\n\\t\\t\\t\\t\\t\\tif p.Definition.Name == \\\"label_text\\\":\\n\\t\\t\\t\\t\\t\\t\\tp.Set(annot[1])\\n\\n\\n\\t#Creates glass width tags on a plan\\n\\tif annoType == \\\"GS\\\":\\n\\n\\t\\tjunctionPoints = []\\n\\t\\tintermediatePoints = []\\n\\n\\t\\tglassTagList = []\\n\\n\\n\\t\\tfor mullion in allStorefrontMullions:\\n\\n\\t\\t\\tmullionLength = mullion.get_Parameter(BuiltInParameter.CURVE_ELEM_LENGTH).AsDouble()\\n\\n\\t\\t\\tif mullionLength > 0 and mullion.LocationCurve:\\n\\n\\t\\t\\t\\tmullionName = mullion.Name.lower()\\n\\t\\t\\t\\tmullionRoom = mullion.get_Parameter(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).AsString()\\n\\t\\t\\t\\tmullionPoint = mullion.Location.Point\\n\\t\\t\\t\\tmullionPoint = XYZ(mullionPoint.X,mullionPoint.Y, 0)\\n\\n\\t\\t\\t\\tif \\\"post\\\" in mullionName:\\n\\t\\t\\t\\t\\tjunctionPoints.append([mullionPoint, mullionName])\\n\\n\\t\\t\\t\\tif \\\"wallstart\\\" in mullionName:\\n\\t\\t\\t\\t\\tjunctionPoints.append([mullionPoint, mullionName])\\n\\n\\t\\t\\t\\tif \\\"door\\\" in mullionName:\\n\\t\\t\\t\\t\\tjunctionPoints.append([mullionPoint, mullionName])\\n\\n\\t\\t\\t\\tif \\\"intermediate\\\" in mullionName:\\n\\t\\t\\t\\t\\tintermediatePoints.append([mullionPoint, mullionName])\\n\\n\\n\\n\\t\\tfor storefrontElevation in allStorefrontWalls:\\n\\n\\t\\t\\tpanelIds = storefrontElevation.CurtainGrid.GetPanelIds()\\n\\n\\t\\t\\tlinearGlass = storefrontElevation.Location.Curve.Length\\n\\n\\t\\t\\tstorefrontElevationID = storefrontElevation.get_Parameter(BuiltInParameter.ALL_MODEL_MARK).AsString()\\n\\t\\t\\tstorefrontSuperType = storefrontElevation.get_Parameter(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).AsString()\\n\\n\\t\\t\\t#Panels\\n\\t\\t\\tfor panelId in panelIds:\\n\\n\\t\\t\\t\\tpanel = doc.GetElement(panelId)\\n\\t\\t\\t\\tpanelWidth = panel.get_Parameter(BuiltInParameter.WINDOW_WIDTH).AsDouble()\\n\\t\\t\\t\\tpanelHeight = panel.get_Parameter(BuiltInParameter.WINDOW_HEIGHT).AsDouble()\\n\\n\\t\\t\\t\\tif (panelWidth > 0) and (panelHeight > 0):\\n\\n\\t\\t\\t\\t\\tcondition = None\\n\\t\\t\\t\\t\\tvarient01 = None\\n\\t\\t\\t\\t\\tvarient02 = None\\n\\n\\t\\t\\t\\t\\tpanelFamily = panel.get_Parameter(BuiltInParameter.ELEM_FAMILY_PARAM).AsValueString()\\n\\t\\t\\t\\t\\tpanelType = panel.get_Parameter(BuiltInParameter.ELEM_TYPE_PARAM).AsValueString()\\n\\t\\t\\t\\t\\tpanelSF = panelWidth * panelHeight\\n\\t\\t\\t\\t\\tpanelSizeName = str(panelWidth) + \\\" x \\\" + str(panelHeight)\\n\\n\\t\\t\\t\\t\\t#Get panel point and flatten\\n\\t\\t\\t\\t\\tpanelPoint = panel.GetTransform().Origin\\n\\t\\t\\t\\t\\tpanelPoint = XYZ(panelPoint.X, panelPoint.Y, 0)\\n\\n\\t\\t\\t\\t\\tpanelRoomID = panel.get_Parameter(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS).AsString()\\n\\n\\t\\t\\t\\t\\t#Default panel position\\n\\t\\t\\t\\t\\tpanelPositions = []\\n\\n\\t\\t\\t\\t\\t# Checking end conditions against junctions (post, wallstart, and door frames)\\n\\t\\t\\t\\t\\tjuntionsAndDoorFrames = junctionPoints\\n\\n\\n\\t\\t\\t\\t\\tif \\\"glazed\\\" in panelFamily.lower():\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tnumFoundEndConditions = 0\\n\\n\\t\\t\\t\\t\\t\\t#CORRECT PANEL WIDTH + HEIGHT FOR ACTUAL SIZES\\n\\t\\t\\t\\t\\t\\t# Add correction for differences between modeling and reality\\n\\n\\t\\t\\t\\t\\t\\tglassWidthCorrection = 0\\n\\t\\t\\t\\t\\t\\tglassHeightCorrection = 0\\n\\n\\t\\t\\t\\t\\t\\t#Ends\\n\\t\\t\\t\\t\\t\\tfor i in range(len(juntionsAndDoorFrames)):\\n\\t\\t\\t\\t\\t\\t\\ttestPoint = juntionsAndDoorFrames[i][0]\\n\\t\\t\\t\\t\\t\\t\\ttestMullionName = juntionsAndDoorFrames[i][1]\\n\\t\\t\\t\\t\\t\\t\\ttestDist1 = testPoint.DistanceTo(panelPoint)\\n\\n\\t\\t\\t\\t\\t\\t\\tif testDist1 < ((panelWidth/2) + (2.1/12)):\\n\\t\\t\\t\\t\\t\\t\\t\\tglassWidthCorrection += storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"horizontalEnd\\\"]\\n\\t\\t\\t\\t\\t\\t\\t\\tnumFoundEndConditions += 1 #Found an end condition\\n\\t\\t\\t\\t\\t\\t\\t\\t#print storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"horizontalEnd\\\"]\\n\\n\\t\\t\\t\\t\\t\\t#Intermediates\\n\\t\\t\\t\\t\\t\\tfor i in range(len(intermediatePoints)):\\n\\t\\t\\t\\t\\t\\t\\ttestPoint = intermediatePoints[i][0]\\n\\t\\t\\t\\t\\t\\t\\ttestMullionName = intermediatePoints[i][1]\\n\\t\\t\\t\\t\\t\\t\\ttestDist2 = testPoint.DistanceTo(panelPoint)\\n\\n\\t\\t\\t\\t\\t\\t\\tif testDist2 < ((panelWidth/2) + (1.8/2)):\\n\\t\\t\\t\\t\\t\\t\\t\\tglassWidthCorrection += storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"horizontalIntermediate\\\"]\\n\\t\\t\\t\\t\\t\\t\\t\\tnumFoundEndConditions += 1 #Found an end condition\\n\\t\\t\\t\\t\\t\\t\\t\\t#print storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"horizontalIntermediate\\\"]\\n\\n\\t\\t\\t\\t\\t\\t#Butt joints\\n\\t\\t\\t\\t\\t\\tnumButtJoints = 2 - numFoundEndConditions #Glass has 2 ends, if above conditions arent detected, its assumed a butt joint is found\\n\\t\\t\\t\\t\\t\\tglassWidthCorrection += (numButtJoints * storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"horizontalButtJoint\\\"])\\n\\n\\t\\t\\t\\t\\t\\t#print numButtJoints\\n\\n\\n\\t\\t\\t\\t\\t\\t#Head and Sill pockets\\n\\t\\t\\t\\t\\t\\tglassHeightCorrection += storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"verticalSill\\\"]\\n\\t\\t\\t\\t\\t\\tglassHeightCorrection += storefrontConfig.currentConfig[\\\"panelCorrections\\\"][\\\"verticalHead\\\"]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t#create list of glass size tags\\n\\t\\t\\t\\t\\t\\tglassTagList.append([panelPoint,(panelWidth + glassWidthCorrection)])\\n\\n\\t\\t\\n\\t\\t#place glass tags\\n\\t\\ttagFamTypeDict = GetFamilyTypeDict(\\\"Panel-Symbol-Standard\\\")\\n\\t\\ttagSym = doc.GetElement(tagFamTypeDict[\\\"Panel-Symbol-Standard\\\"])\\n\\n\\n\\t\\t#Set units and format options to convert decimal feet to inche fractional\\n\\t\\tformatUnits = doc.GetUnits()\\n\\t\\tfvo = FormatValueOptions()\\n\\t\\tfo = FormatOptions(DisplayUnitType.DUT_FRACTIONAL_INCHES)\\n\\t\\tfo.Accuracy = .0625\\n\\t\\tfvo.SetFormatOptions(fo)\\n\\n\\t\\t#Place annotations\\t\\n\\t\\twith rpw.db.Transaction(\\\"Tag Glass\\\"):\\n\\t\\t\\tfor tag in glassTagList:\\n\\t\\t\\t\\tpoint = tag[0]\\n\\t\\t\\t\\t#tag = size[2]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tsizeInches = UnitFormatUtils.Format(formatUnits, UnitType.UT_Length, tag[1], False, False, fvo)\\n\\n\\t\\t\\t\\tannotInst = doc.Create.NewFamilyInstance(point, tagSym, currentView)\\n\\t\\t\\t\\tfor p in annotInst.Parameters:\\n\\t\\t\\t\\t\\tif p.Definition.Name == \\\"label_text\\\":\\n\\t\\t\\t\\t\\t\\tp.Set(sizeInches)\\n\\n\\n\\n\\tprint \\\"FINISHED\\\"\",\n \"def FetchLayoutsData(client):\\n layout_names = ['U_layout', 'J_layout', 'E_layout', 'B_layout']\\n cols = ['scancode', 'x', 'y', 'w', 'h']\\n layouts = FetchSpreadsheetFeeds(client, KEYBOARD_GLYPH_SPREADSHEET_KEY,\\n layout_names, cols)\\n ret = {}\\n for layout_name, layout in layouts.items():\\n ret[layout_name[0]] = []\\n for row in layout:\\n line = []\\n for col in cols:\\n value = row.get(col)\\n if not value:\\n line.append('')\\n else:\\n if col != 'scancode':\\n value = float(value)\\n line.append(value)\\n ret[layout_name[0]].append(line)\\n return ret\",\n \"def detail_matching(self):\\n paradic = self.cfg['param']['paradic']\\n work_dir = self.work_dir\\n \\n x = float(self.cfg['param']['x']) # selected pixel in the first image\\n y = float(self.cfg['param']['y'])\\n \\n # sift parameters\\n # number of bins in the orientation histogram\\n n_bins = int(paradic['n_bins']) \\n n_hist = int(paradic['n_hist']) \\n # descriptor of n_hist X n_hist weighted histograms with n_ori\\n n_ori = int(paradic['n_ori']) \\n delta_min = float(paradic['delta_min'])\\n sigma_min = float(paradic['sigma_min'])\\n sigma_in = float(paradic['sigma_in'])\\n lambda_ori = float(paradic['lambda_ori'])\\n lambda_descr = float(paradic['lambda_descr'])\\n #threshold defining reference orientations\\n n_spo = int(paradic['n_spo'])\\n \\n # Read feature vectors from output files\\n if (os.path.getsize(work_dir+'OUTmatches.txt') > 0 ):\\n pairdata = find_nearest_keypoint(work_dir+'OUTmatches.txt', y, x)\\n \\n illustrate_pair(pairdata, n_bins, n_hist, n_ori, work_dir)\\n\\n \\n # Read keys coordinates.\\n d = 6+n_bins+n_hist*n_hist*n_ori # size of keydata inside pairdata\\n v = n_hist*n_hist*n_ori\\n [x1, y1, sigma1, theta1] = [float(x) for x in pairdata[0:4]]\\n [o1, s1] = [float(x) for x in pairdata[4+v:4+v+2]]\\n [x2a, y2a, sigma2a, theta2a] = [float(x) for x in pairdata[d:d+4]]\\n [o2a, s2a] = [float(x) for x in pairdata[d+4+v:d+4+v+2]]\\n [x2b, y2b, sigma2b, theta2b] = \\\\\\n [float(x) for x in pairdata[2*d:2*d+4]]\\n [o2b, s2b] = [float(x) for x in pairdata[2*d+4+v:2*d+4+v+2]]\\n \\n draw_one_match(pairdata,\\n work_dir+'input_0.png',\\n work_dir+'input_1.png',\\n d,\\n lambda_ori,\\n lambda_descr,\\n n_hist,\\n work_dir+'OUTonepair.png')\\n \\n \\n # Extract thumbnails.\\n # keypoint 1 (image 1)\\n print ' '.join(['demo_extract_patch', work_dir+'input_0.png',\\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im1\\\"])\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_0.png',\\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im1\\\"])\\n self.wait_proc(proc, timeout=self.timeout)\\n \\n # keypoint 2a (nearest neighbor in image 2)\\n print ' '.join(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2a\\\"])\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2a\\\"])\\n self.wait_proc(proc, timeout=self.timeout) \\n \\n # keypoint 2b (second nearest neighbor in image 2)\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2b), str(y2b), str(sigma2b), str(theta2b), str(o2b), str(s2b),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2b\\\"])\\n self.wait_proc(proc, timeout=self.timeout) \\n \\n \\n return 1\",\n \"def record(aline):\\n # delect the Illustration\\n bodylst = aline.split('[Illustration]') \\n linestr = functools.reduce(lambda x, y : x + y, bodylst) \\n \\n # handle punctuation & capitalization\\n punclst = [i for i in string.punctuation]\\n punclst.remove(\\\"'\\\") \\n punclst.remove('-')\\n for i in punclst:\\n linestr = linestr.replace(i,' ')\\n alst = linestr.split()\\n txtlst = [i.lower() for i in alst]\\n # Considering the capitalization\\n \\n # record the words found and update worddict\\n for j in txtlst:\\n if j not in worddict:\\n worddict.update({j:1})\\n else:\\n worddict[j] += 1\",\n \"def panelist_info(rs, screen_name, idmap, missing_info):\\n\\n try:\\n info = rs.panelist_info(screen_name)\\n if screen_name.lower() in idmap:\\n yougov_id = idmap[screen_name.lower()]\\n info['yougov'] = {'id': yougov_id}\\n panoptic = data.us_panoptic_data(yougov_id)\\n if panoptic:\\n info['panoptic'] = panoptic\\n return json.dumps(info)\\n except KeyError:\\n missing_info.add(screen_name)\",\n \"def study():\\n return render_template('study.html')\",\n \"def stats_preprocessing(self):\\n output = {'before_tot':[],\\n 'before_unique':[],\\n 'after_tot':[],\\n 'after_unique':[]}\\n for i in range(len(self.table)):\\n description_raw = self.table.description.iloc[i].split(' ')\\n clean_txt = self.table.clean_text.iloc[i].split(' ')\\n\\n output['before_tot'].append(len(description_raw))\\n output['before_unique'].append(len(set(description_raw)))\\n output['after_tot'].append(len(clean_txt))\\n output['after_unique'].append(len(set(clean_txt)))\\n \\n print(\\\"\\\"\\\"Before preprocessing a description had on average {0} words with standard deviation {1}. \\\\n\\nMoreover, the average of unique words was {2} and the standard deviation {3}.\\\"\\\"\\\"\\\\\\n .format(round(mean(output['before_tot']), 2), round(stdev(output['before_tot']), 2), \\n round(mean(output['before_unique']), 2), round(stdev(output['before_unique'])), 2))\\n \\n print(\\\"\\\"\\\"\\\\nAfter preprocessing a description has on average {0} words with standard deviation {1}. \\\\n \\nThe average of unique words is now {2} and the standard deviation {3}.\\\"\\\"\\\"\\\\\\n .format(round(mean(output['after_tot']), 2), round(stdev(output['after_tot']), 2), \\n round(mean(output['after_unique']),2), round(stdev(output['after_unique']), 2)))\\n\\n return output\",\n \"def find_mentioned_pol_figures_legacy(data):\\n figures_mentioned = {}\\n figures = get_political_figures_legacy()\\n\\n for ind, row in data.iterrows():\\n subject_words = row[\\\"MetadataSubject\\\"].lower()\\n message_words = row[\\\"RawText\\\"].lower()\\n\\n for figure in figures:\\n if figure + \\\" \\\" in (subject_words + message_words):\\n if figure in figures_mentioned:\\n figures_mentioned[figure][0].append(ind)\\n else:\\n figures_mentioned[figure] = [[ind]]\\n\\n return pd.DataFrame(figures_mentioned)\",\n \"def get_results(self) -> dict:\\n # do not call super() as this subclasses panos and not base directly\\n results = dict()\\n results['snippets'] = dict()\\n results['pan_validation'] = dict()\\n context = self.context\\n\\n for s in self.get_snippets():\\n snippet_name = s.name\\n cmd = s.cmd\\n # handle both validate and validate_xml here\\n if snippet_name in context and 'validate' in cmd:\\n if 'results' in context[snippet_name]:\\n result = context[snippet_name]['results']\\n label_template = context[snippet_name].get('label', '')\\n # attempt to render the label using supplied context\\n context[snippet_name]['label'] = s.render(label_template, context)\\n if not result:\\n fail_message = s.metadata.get('fail_message', 'Snippet Validation results were {{ result }}')\\n context[snippet_name]['output_message'] = s.render(fail_message, context)\\n elif result:\\n pass_message = s.metadata.get('pass_message', 'Snippet Validation results were {{ result }}')\\n context[snippet_name]['output_message'] = s.render(pass_message, context)\\n else:\\n context[snippet_name]['output_message'] = 'Unknown results from Snippet Validation'\\n\\n results['snippets'][snippet_name] = result\\n\\n results['pan_validation'][snippet_name] = context[snippet_name]\\n\\n return self._parse_output_template(results)\",\n \"def lf_findall_interp_with_sharps(report):\\n\\n if 'interpretation' in report.sections.keys():\\n interpretation = report.sections['interpretation']\\n interp_text = interpretation['text']\\n return abnormal_interp_with_sharps(interp_text)\\n else:\\n candtext = get_section_with_name(SEIZURE_SECTION_NAMES_LOWER, report)\\n if candtext:\\n return abnormal_interp_with_sharps(candtext)\\n else:\\n return ABSTAIN_VAL\",\n \"def figures_layout(figures_dict: Dict[str, go.Figure]):\\n return [\\n html.Div(className='cardlive-figures', children=[\\n single_figure_layout(title='Map',\\n description=['Geographic distribution of the submitted genomic samples.'],\\n id='figure-geographic-map-id',\\n fig=figures_dict['map']\\n ),\\n single_figure_layout(title='Samples timeline',\\n description=['Submission dates for genomic samples.'],\\n id='figure-timeline-id',\\n fig=figures_dict['timeline'],\\n dropdowns=figure_menus_layout(\\n id_type='timeline-type-select',\\n options_type=[\\n {'label': 'Cumulative counts', 'value': 'cumulative_counts'},\\n {'label': 'Cumulative percent', 'value': 'cumulative_percent'},\\n {'label': 'Counts', 'value': 'counts'},\\n {'label': 'Percent', 'value': 'percent'},\\n ],\\n value_type='cumulative_counts',\\n id_color='timeline-color-select',\\n options_color=[\\n {'label': 'Default', 'value': 'default'},\\n {'label': 'Geographic region', 'value': 'geographic'},\\n {'label': 'Organism', 'value': 'organism'},\\n ],\\n value_color='default'\\n ),\\n ),\\n single_figure_layout(title='Samples total',\\n description=['Count of samples matching selection.'],\\n id='figure-totals-id',\\n fig=figures_dict['totals'],\\n dropdowns=figure_menus_layout(\\n id_type='totals-type-select',\\n options_type=[\\n {'label': 'Geographic region', 'value': 'geographic'},\\n {'label': 'Organism', 'value': 'organism'},\\n ],\\n value_type='geographic',\\n id_color='totals-color-select',\\n options_color=[\\n {'label': 'Default', 'value': 'default'},\\n {'label': 'Geographic region', 'value': 'geographic'},\\n {'label': 'Organism', 'value': 'organism'},\\n ],\\n value_color='default'\\n ),\\n ),\\n single_figure_layout(title='RGI results',\\n description=['Percent of selected samples (',\\n html.Span(id='sample-count-figure', children=[LOADING]),\\n ') with the chosen type of RGI results.'\\n ],\\n id='figure-rgi-id',\\n fig=figures_dict['rgi'],\\n dropdowns=figure_menus_layout(\\n id_type='rgi-type-select',\\n options_type=[\\n {'label': 'Drug class', 'value': 'drug_class'},\\n {'label': 'AMR gene', 'value': 'amr_gene'},\\n {'label': 'AMR gene family', 'value': 'amr_gene_family'},\\n {'label': 'Resistance mechanism', 'value': 'resistance_mechanism'},\\n ],\\n value_type='drug_class',\\n id_color='rgi-color-select',\\n options_color=[\\n {'label': 'Default', 'value': 'default'},\\n {'label': 'Geographic region', 'value': 'geographic'},\\n {'label': 'Organism', 'value': 'organism'},\\n ],\\n value_color='default'\\n ),\\n ),\\n single_figure_layout(title='RGI intersections',\\n description=['Patterns of co-occurrence of the selected RGI result type across genome subset'],\\n id='figure-rgi-intersections',\\n fig=figures_dict['rgi'],\\n dropdowns=figure_menus_layout(\\n id_type='rgi-intersection-type-select',\\n options_type=[\\n {'label': 'Drug class', 'value': 'drug_class'},\\n {'label': 'AMR gene', 'value': 'amr_gene'},\\n {'label': 'AMR gene family', 'value': 'amr_gene_family'},\\n {'label': 'Resistance mechanism', 'value': 'resistance_mechanism'},\\n ],\\n value_type='drug_class',\\n )\\n ),\\n ])\\n ]\",\n \"def samsemPlots29and30(samsem_data,path,dict):\\n \\n telleoevelse = dict['telleoevelse'] if 'telleoevelse' in dict else 0\\n \\n # Retrieving input data for the analysis\\n path_res = path \\n if 'subfolder' in dict:\\n subfolder = dict['subfolder']\\n path_res = os.path.join(path,subfolder)\\n if not os.path.exists(path_res): os.makedirs(path_res)\\n \\n filename_orig = dict['filename']\\n coldef_type = dict['coldef_type']\\n observer_groups = dict['observer_groups']\\n dict.update({'investigated-item': 'observer groups'})\\n \\n method_ids = dict['method_ids'] if 'method_ids' in dict else sorted(set(samsem_data['sim_id'].values.astype(int)))\\n \\n print(\\\"Starting SAMSEM_RES#29+30: Analyzing data of observer groups \\\"+ str(keys2values(observer_groups,settings.id2ColDefShort))+\\\" for \\\" + str(settings.id2ColDefLong[dict['coldef_type']]) + \\\" simulation methods: \\\"+str(keys2values(method_ids,settings.id2Sim))+\\\".\\\")\\n \\n # Restricting input data to only include the simulation methods that have been chosen for the analysis\\n rel_data = pandas.DataFrame()\\n for method_id in method_ids:\\n if (method_id != 3) and (method_id != 99): \\n whatArr_tmp = [['sim_id',operator.eq,method_id],['coldef_type',operator.eq,coldef_type]]\\n else:\\n whatArr_tmp = [['sim_id',operator.eq,method_id]] # For the kotera and the dummy method, both protanopia and deuteranopia variants are identical. Thus, no distinction of coldef_type is necessary.\\n rel_data_tmp = organizeArray(samsem_data,whatArr_tmp)\\n rel_data = pandas.concat([rel_data_tmp, rel_data])\\n samsem_data_adj = rel_data.reset_index()\\n \\n # Retrieving data for each of the observation groups\\n i = 0; pandas_dict = {}; order_dict = {}\\n for observer_group in observer_groups:\\n observer_coldef_type = observer_group\\n observer_coldef_type_short = settings.id2ColDefShort[observer_coldef_type]\\n \\n whatArr_tmp = [['observer_coldef_type',operator.eq,observer_coldef_type]]\\n obs_group_data_tmp = organizeArray(samsem_data_adj,whatArr_tmp)\\n \\n pandas_dict.update({observer_coldef_type_short:obs_group_data_tmp})\\n order_dict.update({i:observer_coldef_type_short}) ; i += 1\\n \\n # Plot response time data as boxplots\\n if telleoevelse: print(\\\"Observations RT plots\\\")\\n boxes, labels = preparePandas4RTPlots(pandas_dict, order_dict)\\n plotRTGraphs(boxes,labels,path_res, dict)\\n \\n # Plot accuracy with confidence intervals\\n c = 1.96; type = 'wilson-score'\\n if telleoevelse: print(\\\"Observations ACC plots\\\")\\n accuracies = preparePandas4AccuracyPlots(pandas_dict,order_dict,c,type)\\n plotAccuracyGraphs(accuracies,path_res,dict,order_dict)\\n \\n # Make median test as csv file\\n dict.update({'filename': filename_orig+\\\"-RT\\\"})\\n makeMedianTest(boxes, path_res, labels, dict)\\n \\n # Make Chi2 contingency test as txt file\\n obs_array, obs_pandas = preparePandas4Chi2(pandas_dict, order_dict)\\n dict.update({'filename': filename_orig+'-ACC'})\\n makePearsonChi2Contingency(obs_array, obs_pandas, labels, path_res, dict)\\n \\n # Make Chi2 contingency test matrix as csv file\\n makePearsonChi2Contingency2x2Test(obs_array, path_res, labels, dict)\\n \\n # Make normality plots as Q-Q and log-Q-Q plots\\n for i in range(numpy.shape(boxes)[0]):\\n distribution_tmp = boxes[i]\\n label_tmp = labels[i]\\n dict.update({'filename': filename_orig+'-RT-'+label_tmp})\\n plotQQPlot(distribution_tmp, path_res, dict)\\n \\n distribution_log_tmp = numpy.log(distribution_tmp)\\n distribution_log_tmp = distribution_log_tmp[~numpy.isnan(distribution_log_tmp)]\\n dict.update({'filename': filename_orig+'-RT-'+label_tmp+'-log'})\\n plotQQPlot(distribution_log_tmp, path_res, dict)\",\n \"def get_info_game(soup):\\n info = []\\n\\n content = soup.select(\\\"div.fftit.s20.b\\\").pop()\\n info.append(content.span.text)\\n info.append(re.search(r'\\\\((.*?)\\\\)', content.text).group(1))\\n\\n for dt, dd in zip(soup.findAll(\\\"dt\\\"), soup.findAll(\\\"dd\\\")):\\n if dt.text == \\\"Desarrollador:\\\":\\n info.append(dd.text)\\n elif dt.text == \\\"Editor:\\\":\\n info.append(dd.text)\\n elif dt.text == \\\"Género:\\\":\\n info.append(dd.text)\\n\\n info.append(soup.find(\\\"span\\\", {\\\"itemprop\\\": \\\"releaseDate\\\"}).attrs['content'])\\n\\n info.extend([div.span.text for div in soup.select(\\\"div.dtc.wi36\\\")])\\n\\n return zip([\\\"name\\\", \\\"platform\\\", \\\"study\\\", \\\"publisher\\\", \\\"genre\\\", \\\"releaseDate\\\", \\\"3DJuegosScore\\\", \\\"userScore\\\"], info)\",\n \"def get_summary(page):\\n stop_words = stopwords.words('english')\\n sentences = sent_tokenize(page[\\\"text\\\"])\\n S = ts.build_similarity_matrix(sentences, stop_words)\\n sentence_ranks = ts.pagerank(S)\\n ranked_sentence_indexes = [item[0] for item in sorted(enumerate(sentence_ranks), key=lambda item: -item[1])]\\n SUMMARY_SIZE = 4\\n SELECTED_SENTENCES = sorted(ranked_sentence_indexes[:SUMMARY_SIZE])\\n summary = itemgetter(*SELECTED_SENTENCES)(sentences)\\n temp = ''\\n for sentence in summary:\\n temp += ''.join(sentence)\\n return {\\\"summary\\\": temp}\",\n \"def get_structure_recording_vars(st3d, with_props=False):\\n recording_vars = []\\n s = st3d['s']\\n nsec = s.shape[0]\\n nDP = st3d['DPs'].shape[1]\\n\\n DPs = ['DP%02d' % i for i in range(nDP)]\\n\\n regions = []\\n webs = []\\n for ireg, reg in enumerate(st3d['regions']):\\n layers = []\\n for i, lname in enumerate(reg['layers']):\\n varname = 'r%02d%s' % (ireg, lname)\\n layers.extend([varname + 'T', varname + 'A'])\\n regions.extend(layers)\\n if with_props:\\n regions.append('r%02d_thickness')\\n regions.append('r%02d_width')\\n for ireg, reg in enumerate(st3d['webs']):\\n layers = []\\n for i, lname in enumerate(reg['layers']):\\n varname = 'w%02d%s' % (ireg, lname)\\n layers.extend([varname + 'T', varname + 'A'])\\n if with_props:\\n regions.append('r%02d_thickness')\\n regions.append('r%02d_width')\\n webs.extend(layers)\\n\\n recording_vars.extend(DPs)\\n recording_vars.extend(regions)\\n recording_vars.extend(webs)\\n recording_vars.append('matprops')\\n recording_vars.append('failmat')\\n recording_vars.append('s_st')\\n\\n if with_props:\\n recording_vars.extend(['web_angle',\\n 'web_offset',\\n 'pacc_u',\\n 'pacc_l',\\n 'pacc_u_curv',\\n 'pacc_l_curv'])\\n\\n return recording_vars\",\n \"def extract_ppt(self, filename):\\n prs = Presentation(filename)\\n\\n sents = []\\n for slide in prs.slides:\\n for shape in slide.shapes:\\n sents.append(shape.text)\\n\\n text = \\\"\\\"\\n for sent in sents:\\n for bullet in sent.split('\\\\n'):\\n bullstr = bullet.strip()\\n if len(bullstr) > 0:\\n text += bullstr\\n if bullstr[-1] != '.' and bullstr[-1] != '!' and bullstr[-1] != '?':\\n text += '.'\\n text += ' '\\n\\n return text\",\n \"def parse(filepath):\\n wos_list = []\\n\\n paper_start_key = 'PT'\\n paper_end_key = 'ER'\\n\\n\\n #\\n line_list = []\\n try:\\n with open(filepath, 'r') as f:\\n line_list = f.read().splitlines()\\n except IOError: # File does not exist, or couldn't be read.\\n raise IOError(\\\"File does not exist, or cannot be read.\\\")\\n\\n if len(line_list) is 0:\\n raise IOError(\\\"Unable to read filepath or filepath is empty.\\\")\\n # Convert the data in the file to a usable list of dictionaries.\\n # Note: first two lines of file are not related to any paper therein.\\n last_field_tag = paper_start_key # initialize to something.\\n for line in line_list[2:]:\\n\\n field_tag = line[:2]\\n\\n if field_tag == ' ':\\n pass\\n\\n if field_tag == paper_start_key:\\n # Then prepare for next paper.\\n wos_dict = _new_wos_dict()\\n\\n if field_tag == paper_end_key:\\n # Then add paper to our list.\\n wos_list.append(wos_dict)\\n\\n # Handle keys like AU,AF,CR that continue over many lines.\\n if field_tag == ' ':\\n field_tag = last_field_tag\\n\\n # Add value for the key to the wos_dict: only for the five tags.\\n try:\\n if field_tag in ['DE', 'DI', 'TI', 'SO', 'UT','PY']:\\n wos_dict[field_tag] += ' ' + str(line[3:])\\n # Rest all will just get passed\\n else:\\n pass\\n\\n except (KeyError, TypeError, UnboundLocalError):\\n wos_dict[field_tag] = str(line[3:])\\n\\n last_field_tag = field_tag\\n # End line loop.\\n\\n # Define keys that should be lists instead of default string.\\n list_keys = ['DE']\\n delims = {'DE': ';'}\\n\\n # And convert the data at those keys into lists.\\n for wos_dict in wos_list:\\n for key in list_keys:\\n delim = delims[key]\\n try:\\n key_contents = wos_dict[key]\\n if delim != '\\\\n':\\n wos_dict[key] = key_contents.split(delim)\\n else:\\n wos_dict[key] = key_contents.splitlines()\\n except KeyError:\\n # One of the keys to be converted to a list didn't exist.\\n pass\\n except AttributeError:\\n # Again a key didn't exist but it belonged to the wos\\n # data_struct set of keys; can't split a None.\\n pass\\n\\n return wos_list\",\n \"def make_jwst_spec_previews(input_file, flux_scale_factor=\\n FLUX_SCALE_FACTOR_DEFAULT, fluxerr_scale_factor=\\n FLUXERR_SCALE_FACTOR_DEFAULT, n_consecutive=\\n N_CONSECUTIVE_DEFAULT,\\n output_path=OUTPUT_PATH_DEFAULT,\\n output_type=OUTPUT_TYPE_DEFAULT,\\n dpi_val=DPI_VAL_DEFAULT, debug=DEBUG_DEFAULT,\\n full_ylabels=FULL_YLABELS_DEFAULT, optimize=\\n not NOOPTIMIZE_DEFAULT, verbose=VERBOSE_DEFAULT):\\n\\n # Print file name, if verbose is turned on.\\n if verbose:\\n print(\\\"Input file: \\\" + input_file)\\n\\n # Derive output file name from input file name.\\n output_files = []\\n for out_type in output_type:\\n if out_type != \\\"screen\\\":\\n if out_type != 'fits':\\n output_file = (path.join(output_path, \\\"\\\") +\\n path.basename(input_file).split(\\\".fits\\\")[0] +\\n \\\".\\\" + out_type)\\n else:\\n output_file = (path.join(output_path, \\\"\\\") +\\n path.basename(input_file).split(\\\".fits\\\")[0] +\\n \\\"_prev.\\\" + out_type)\\n else:\\n output_file = None\\n\\n output_files.append(output_file)\\n\\n # Print name of output file.\\n if verbose:\\n print(\\\"Output file names are:\\\")\\n for ofile in output_files:\\n if ofile is not None:\\n if ofile[-4:] == '.png':\\n print(\\\" Output file: \\\" + ofile)\\n print(\\\" Output file: \\\" + ofile.strip('\\\\.png') +\\n '_thumb.png')\\n else:\\n print(\\\" Output file: \\\" + ofile)\\n else:\\n print(\\\" Plotting to screen.\\\")\\n\\n # Read in the FITS file to determine which instrument it comes from.\\n # Print the name of the instrument found in the header if verbose is turned\\n # on.\\n this_instrument = get_instrument_name(input_file)\\n if verbose:\\n print(\\\"Instrument: \\\" + this_instrument)\\n\\n # Read in the FITS files and create plots using the local package\\n # appropriate for the instrument used in the input file.\\n if this_instrument in [\\\"MIRI\\\", \\\"NIRSPEC\\\", \\\"NIRISS\\\"]:\\n # Get wavelengths, fluxes, flux uncertainties.\\n jwst_spectrum = readspec(input_file)\\n\\n # Calculate plot metrics.\\n spec_plot_metrics = calc_plot_metrics(this_instrument.lower(),\\n jwst_spectrum.wavelengths,\\n jwst_spectrum.fluxes,\\n jwst_spectrum.fluxerrs,\\n jwst_spectrum.dqs,\\n n_consecutive, flux_scale_factor,\\n fluxerr_scale_factor)\\n\\n # Make \\\"large-size\\\" plot.\\n for out_type, out_file in zip(output_type, output_files):\\n if out_type != \\\"fits\\\":\\n plotspec(jwst_spectrum, out_type, out_file,\\n flux_scale_factor,\\n fluxerr_scale_factor, spec_plot_metrics,\\n dpi_val=dpi_val, output_size=1024, debug=debug,\\n full_ylabels=full_ylabels,\\n optimize=optimize)\\n\\n if not debug:\\n # Make \\\"thumbnail-size\\\" plot, if requested.\\n plotspec(jwst_spectrum, out_type, out_file,\\n flux_scale_factor,\\n fluxerr_scale_factor, spec_plot_metrics,\\n dpi_val=dpi_val, output_size=128,\\n optimize=optimize)\\n else:\\n raise JWSTSpecPrevError(\\\"'INSTRUME' keyword not understood: \\\" +\\n this_instrument)\",\n \"def phonology(request):\\n\\n perspective_cid = request.params.get('perspective_client_id')\\n perspective_oid = request.params.get('perspective_object_id')\\n\\n # Checking if we have limits on number of computed results.\\n\\n limit = (None if 'limit' not in request.params else\\n int(request.params.get('limit')))\\n\\n limit_exception = (None if 'limit_exception' not in request.params else\\n int(request.params.get('limit_exception')))\\n\\n limit_no_vowel = (None if 'limit_no_vowel' not in request.params else\\n int(request.params.get('limit_no_vowel')))\\n\\n limit_result = (None if 'limit_result' not in request.params else\\n int(request.params.get('limit_result')))\\n\\n # TODO: get perspective's translation and language it belongs to.\\n\\n # We get lexical entries of this perspective with markup'ed sounds.\\n\\n Sound = aliased(Entity, name = \\\"Sound\\\")\\n PublishingSound = aliased(PublishingEntity, name = \\\"PublishingSound\\\")\\n\\n query = DBSession.query(LexicalEntry, Entity, Sound, PublishingEntity, PublishingSound).filter(and_(\\n LexicalEntry.parent_client_id == perspective_cid,\\n LexicalEntry.parent_object_id == perspective_oid,\\n LexicalEntry.marked_for_deletion == False,\\n Entity.parent_client_id == LexicalEntry.client_id,\\n Entity.parent_object_id == LexicalEntry.object_id,\\n Entity.marked_for_deletion == False,\\n Entity.additional_metadata.contains({\\\"data_type\\\": \\\"praat markup\\\"}),\\n PublishingEntity.client_id == Entity.client_id,\\n PublishingEntity.object_id == Entity.object_id,\\n PublishingEntity.published == True,\\n PublishingEntity.accepted == True,\\n Sound.client_id == Entity.self_client_id,\\n Sound.object_id == Entity.self_object_id,\\n Sound.marked_for_deletion == False,\\n PublishingSound.client_id == Sound.client_id,\\n PublishingSound.object_id == Sound.object_id,\\n PublishingSound.published == True,\\n PublishingSound.accepted == True))\\n\\n # We process these lexical entries in batches. Just in case, it seems that perspectives rarely have more\\n # then several hundred such lexical entries.\\n\\n exception_counter = 0\\n no_vowel_counter = 0\\n result_list = list()\\n\\n for index, row in enumerate(query.yield_per(100)):\\n\\n markup_url = row.Entity.content\\n sound_url = row.Sound.content\\n\\n cache_key = 'phonology:{0}:{1}:{2}:{3}'.format(\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id)\\n\\n # Checking if we have cached result for this pair of sound/markup.\\n\\n cache_result = CACHE.get(cache_key)\\n\\n if cache_result == 'no_vowel':\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}) '\\n '[CACHE {7}]: no vowels\\\\n{8}\\\\n{9}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n cache_key, markup_url, sound_url))\\n\\n no_vowel_counter += 1\\n\\n if (limit_no_vowel and no_vowel_counter >= limit_no_vowel or\\n limit and index + 1 >= limit):\\n break\\n\\n continue\\n\\n # If we have cached exception, we do the same as with absence of vowels, show its info and\\n # continue.\\n\\n elif isinstance(cache_result, tuple) and cache_result[0] == 'exception':\\n exception, traceback_string = cache_result[1:3]\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): '\\n '[CACHE {7}]: exception\\\\n{8}\\\\n{9}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n cache_key, markup_url, sound_url))\\n\\n log.debug(traceback_string)\\n\\n exception_counter += 1\\n\\n if (limit_exception and exception_counter >= limit_exception or\\n limit and index + 1 >= limit):\\n break\\n\\n continue\\n\\n # If we actually have the result, we use it and continue.\\n\\n elif cache_result:\\n\\n result_string = '\\\\n'.join(\\n 'tier {0} \\\\'{1}\\\\': {2}'.format(tier_number, tier_name,\\n \\n tier_result_seq_list if not isinstance(tier_result_seq_list, list) else\\n tier_result_seq_list[0] if len(tier_result_seq_list) <= 1 else\\n ''.join('\\\\n {0}'.format(tier_result) for tier_result in tier_result_seq_list))\\n\\n for tier_number, tier_name, tier_result_seq_list in cache_result)\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}) '\\n '[CACHE {7}]:\\\\n{8}\\\\n{9}\\\\n{10}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n cache_key, markup_url, sound_url, result_string))\\n\\n result_list.append(cache_result)\\n\\n if (limit_result and len(result_list) >= limit_result or\\n limit and index + 1 >= limit):\\n break\\n\\n continue\\n\\n try:\\n # Getting markup, checking for each tier if it needs to be processed.\\n\\n markup_bytes = urllib.request.urlopen(urllib.parse.quote(markup_url, safe = '/:')).read()\\n\\n textgrid = pympi.Praat.TextGrid(xmax = 0)\\n textgrid.from_file(\\n io.BytesIO(markup_bytes),\\n codec = chardet.detect(markup_bytes)['encoding'])\\n\\n tier_data_list = []\\n vowel_flag = False\\n\\n for tier_number, tier_name in textgrid.get_tier_name_num():\\n\\n raw_interval_list = textgrid.get_tier(tier_number).get_all_intervals()\\n raw_interval_seq_list = [[]]\\n\\n # Splitting interval sequence on empty intervals.\\n\\n for raw_index, interval in enumerate(raw_interval_list):\\n\\n if len(interval[2].strip()) <= 0:\\n if len(raw_interval_seq_list[-1]) > 0:\\n raw_interval_seq_list.append([])\\n\\n else:\\n raw_interval_seq_list[-1].append((raw_index, interval))\\n\\n if len(raw_interval_seq_list[-1]) <= 0:\\n del raw_interval_seq_list[-1]\\n\\n # Selecting interval sequences for analysis, checking if we have unusual markup.\\n \\n interval_seq_list = []\\n interval_idx_to_raw_idx = dict()\\n\\n unusual_markup_flag = False\\n unusual_markup_list = []\\n\\n for raw_interval_seq in raw_interval_seq_list:\\n\\n interval_seq_list.append([])\\n interval_idx_to_raw_idx[len(interval_seq_list) - 1] = {}\\n\\n for partial_raw_index, (raw_index, interval) in enumerate(raw_interval_seq):\\n\\n interval_text = interval[2].strip()\\n\\n # Accepting interval if its text contains at least one vowel, and is short enough or\\n # is a valid phonetic transcription.\\n\\n transcription_check = re.fullmatch(transcription_re, interval_text)\\n\\n if (len(interval_text) > 0 and\\n any(character in vowel_set for character in interval_text) and\\n (len(interval_text) <= 2 or transcription_check)):\\n\\n interval_seq_list[-1].append(interval)\\n\\n sequence_index = len(interval_seq_list) - 1\\n interval_index = len(interval_seq_list[-1]) - 1\\n\\n interval_idx_to_raw_idx[(sequence_index, interval_index)] = raw_index\\n interval_idx_to_raw_idx[sequence_index][interval_index] = partial_raw_index\\n\\n # Noting if the interval contains unusual (i.e. non-transcription) markup.\\n\\n elif not transcription_check:\\n\\n unusual_markup_flag = True\\n unusual_markup_list.append((raw_index, interval))\\n\\n transcription_list = [text for begin, end, text in raw_interval_list]\\n transcription = ''.join(transcription_list)\\n\\n selected_list = [text\\n for interval_list in interval_seq_list\\n for begin, end, text in interval_list]\\n\\n selected = ''.join(selected_list)\\n\\n # If we have intervals with unusual markup, we report them.\\n\\n if unusual_markup_flag:\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): '\\n 'tier {7} \\\\'{8}\\\\' has interval(s) with unusual transcription text: '\\n '{9} / {10}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n tier_number, tier_name, transcription, dict(unusual_markup_list)))\\n\\n # If the markup does not have any vowels, we note it and also report it.\\n\\n if all(character not in vowel_set for character in transcription):\\n\\n tier_data_list.append((tier_number, tier_name, 'no_vowel'))\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): '\\n 'tier {7} \\\\'{8}\\\\' doesn\\\\'t have any vowel markup: {9}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n tier_number, tier_name, transcription_list))\\n\\n # It is also possible that while full transcription has vowels, intervals selected for\\n # analysis do not. In that case we also note it and report it.\\n\\n elif not any(character in vowel_set for character in selected):\\n\\n tier_data_list.append((tier_number, tier_name, 'no_vowel_selected'))\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): '\\n 'tier {7} \\\\'{8}\\\\' intervals to be processed don\\\\'t have any vowel markup: '\\n 'markup {9}, selected {10}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n tier_number, tier_name,\\n transcription_list, selected_list))\\n\\n # Otherwise we store tier data to be used during processing of the sound file.\\n\\n else:\\n tier_data_list.append((tier_number, tier_name,\\n (raw_interval_list, raw_interval_seq_list, interval_seq_list,\\n interval_idx_to_raw_idx, transcription)))\\n\\n vowel_flag = True\\n\\n # If there are no tiers with vowel markup, we skip this sound-markup file altogether.\\n\\n if not vowel_flag:\\n\\n CACHE.set(cache_key, 'no_vowel')\\n no_vowel_counter += 1\\n\\n if (limit_no_vowel and no_vowel_counter >= limit_no_vowel or\\n limit and index + 1 >= limit):\\n break\\n\\n continue\\n\\n # Otherwise we retrieve the sound file and analyse each vowel-containing markup.\\n # Partially inspired by source code at scripts/convert_five_tiers.py:307.\\n\\n sound = None\\n with tempfile.NamedTemporaryFile() as temp_file:\\n\\n sound_file = urllib.request.urlopen(urllib.parse.quote(sound_url, safe = '/:'))\\n temp_file.write(sound_file.read())\\n temp_file.flush()\\n\\n sound = AudioPraatLike(pydub.AudioSegment.from_wav(temp_file.name))\\n\\n tier_result_list = []\\n\\n for tier_number, tier_name, tier_data in tier_data_list:\\n\\n if tier_data == 'no_vowel' or tier_data == 'no_vowel_selected':\\n tier_result_list.append((tier_number, tier_name, tier_data))\\n continue\\n\\n # Analyzing vowel sounds of each interval sequence.\\n\\n (raw_interval_list, raw_interval_seq_list, interval_seq_list, interval_idx_to_raw_idx,\\n transcription) = tier_data\\n\\n tier_result_list.append((tier_number, tier_name, []))\\n\\n for seq_index, (raw_interval_list, interval_list) in enumerate(zip(\\n raw_interval_seq_list, interval_seq_list)):\\n\\n if len(interval_list) <= 0:\\n continue\\n\\n (max_intensity_index, max_intensity, max_length_index, max_length) = \\\\\\n find_max_interval_praat(sound, interval_list)\\n\\n max_intensity_interval = interval_list[max_intensity_index]\\n max_length_interval = interval_list[max_length_index]\\n\\n max_intensity_f1_f2 = sound.get_interval_formants(*max_intensity_interval[:2])\\n max_length_f1_f2 = sound.get_interval_formants(*max_length_interval[:2])\\n\\n # Compiling results.\\n\\n max_length_str = '{0} {1:.3f} [{2}]'.format(\\n max_length_interval[2], max_length,\\n len(''.join(text for index, (begin, end, text) in\\n raw_interval_list[:interval_idx_to_raw_idx[seq_index][max_length_index]])))\\n\\n max_intensity_str = '{0} {1:.3f} [{2}]'.format(\\n max_intensity_interval[2],\\n max_intensity,\\n len(''.join(text for index, (begin, end, text) in\\n raw_interval_list[:interval_idx_to_raw_idx[seq_index][max_intensity_index]])))\\n\\n tier_result_list[-1][2].append([\\n ''.join(text for index, (begin, end, text) in raw_interval_list),\\n max_length_str,\\n '{0:.3f}'.format(max_length_f1_f2[0]),\\n '{0:.3f}'.format(max_length_f1_f2[1]),\\n max_intensity_str,\\n '{0:.3f}'.format(max_intensity_f1_f2[0]),\\n '{0:.3f}'.format(max_intensity_f1_f2[1]),\\n '+' if max_intensity_index == max_length_index else '-'])\\n\\n # Saving result.\\n\\n result_list.append(tier_result_list)\\n CACHE.set(cache_key, tier_result_list)\\n\\n result_string = '\\\\n'.join(\\n 'tier {0} \\\\'{1}\\\\': {2}'.format(tier_number, tier_name,\\n \\n tier_result_seq_list if not isinstance(tier_result_seq_list, list) else\\n tier_result_seq_list[0] if len(tier_result_seq_list) <= 1 else\\n ''.join('\\\\n {0}'.format(tier_result) for tier_result in tier_result_seq_list))\\n\\n for tier_number, tier_name, tier_result_seq_list in tier_result_list)\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}):'\\n '\\\\n{7}\\\\n{8}\\\\n{9}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n markup_url, sound_url, result_string))\\n\\n # Stopping earlier, if required.\\n\\n if (limit_result and len(result_list) >= limit_result or\\n limit and index + 1 >= limit):\\n break\\n\\n except Exception as exception:\\n\\n #\\n # NOTE\\n #\\n # Exceptional situations encountered so far:\\n #\\n # 1. TextGrid file actually contains sound, and wav file actually contains textgrid markup.\\n #\\n # Perspective 330/4, LexicalEntry 330/7, sound-Entity 330/2328, markup-Entity 330/6934\\n #\\n # 2. Markup for one of the intervals contains a newline \\\"\\\\n\\\", and pympi fails to parse it.\\n # Praat parses such files without problems.\\n #\\n # Perspective 330/4, LexicalEntry 330/20, sound-Entity 330/6297, markup-Entity 330/6967\\n #\\n\\n log.debug(\\n '{0} (LexicalEntry {1}/{2}, sound-Entity {3}/{4}, markup-Entity {5}/{6}): '\\n 'exception\\\\n{7}\\\\n{8}'.format(\\n index,\\n row.LexicalEntry.client_id, row.LexicalEntry.object_id,\\n row.Sound.client_id, row.Sound.object_id,\\n row.Entity.client_id, row.Entity.object_id,\\n markup_url, sound_url))\\n\\n # if we encountered an exception, we show its info and remember not to try offending\\n # sound/markup pair again.\\n\\n traceback_string = ''.join(traceback.format_exception(\\n exception, exception, exception.__traceback__))[:-1]\\n\\n log.debug(traceback_string)\\n\\n CACHE.set(cache_key, ('exception', exception,\\n traceback_string.replace('Traceback', 'CACHEd traceback')))\\n\\n exception_counter += 1\\n\\n if (limit_exception and exception_counter >= limit_exception or\\n limit and index + 1 >= limit):\\n break\\n\\n log.debug('phonology {0}/{1}: {2} result{3}, {4} no vowels, {5} exceptions'.format(\\n perspective_cid, perspective_oid,\\n len(result_list), '' if len(result_list) == 1 else 's',\\n no_vowel_counter, exception_counter))\\n\\n # If we have no results, we indicate the situation and also show number of failures and number of\\n # markups with no vowels.\\n\\n if not result_list:\\n request.response.status = HTTPPreconditionFailed.code\\n\\n return {\\n \\\"error\\\": \\\"no markups for this query\\\",\\n \\\"exception_counter\\\": exception_counter,\\n \\\"no_vowel_counter\\\": no_vowel_counter}\\n\\n # Otherwise we create and then serve Excel file.\\n\\n excel_book = xlwt.Workbook(encoding = \\\"utf-8\\\")\\n sheet = excel_book.add_sheet(\\\"Sheet 1\\\")\\n\\n sheet.write(0, 0, 'Transcription')\\n sheet.write(0, 1, 'Longest (seconds) interval')\\n sheet.write(0, 2, 'F1 (Hz)')\\n sheet.write(0, 3, 'F2 (Hz)')\\n sheet.write(0, 4, 'Highest intensity (dB) interval')\\n sheet.write(0, 5, 'F1 (Hz)')\\n sheet.write(0, 6, 'F2 (Hz)')\\n sheet.write(0, 7, 'Coincidence')\\n\\n row_counter = 1\\n\\n for tier_result_list in result_list:\\n for tier_number, tier_name, tier_result_seq_list in tier_result_list:\\n\\n if tier_result_seq_list == 'no_vowel':\\n continue\\n\\n for tier_data in tier_result_seq_list:\\n for index, tier_data_str in enumerate(tier_data):\\n sheet.write(row_counter, index, tier_data_str)\\n\\n row_counter += 1\\n\\n # Formatting column widths.\\n\\n sheet.col(0).width = 24 * 256\\n sheet.col(1).width = 24 * 256\\n sheet.col(2).width = 12 * 256\\n sheet.col(3).width = 12 * 256\\n sheet.col(4).width = 24 * 256\\n sheet.col(5).width = 12 * 256\\n sheet.col(6).width = 12 * 256\\n sheet.col(7).width = 12 * 256\\n\\n excel_stream = io.BytesIO()\\n excel_book.save(excel_stream)\\n excel_stream.seek(0)\\n\\n # See http://stackoverflow.com/questions/2937465/what-is-correct-content-type-for-excel-files for Excel\\n # content-type.\\n\\n response = Response(content_type = 'application/vnd.ms-excel')\\n\\n response.app_iter = FileIter(excel_stream)\\n response.headers['Content-Disposition'] = \\\"attachment; filename=phonology.xls\\\"\\n\\n return response\",\n \"def app_view(request):\\n prior_queries = (request.dbsession.query(Sentiments, User)\\n .join(User)\\n .filter(User.username == request.authenticated_userid)\\n .order_by(Sentiments.id.desc())\\n .all())\\n sentient_bodies = (query[0].body for query in prior_queries)\\n sentimental_parts = (percentage(query[0].negative_sentiment) for query in prior_queries)\\n logical_bits = (percentage(query[0].positive_sentiment) for query in prior_queries)\\n sublime_insight = zip(sentient_bodies, sentimental_parts, logical_bits)\\n if request.method == \\\"POST\\\":\\n text_body = request.POST['body']\\n url = \\\"http://text-processing.com/api/sentiment/\\\"\\n payload = {'text': text_body}\\n response = requests.request('POST', url, data=payload, headers=None)\\n response_dict = json.loads(response.text)\\n user_query = request.dbsession.query(User).filter(User.username == request.authenticated_userid).one().id\\n sentiment_entry = Sentiments(\\n body=text_body,\\n negative_sentiment=response_dict['probability']['neg'],\\n positive_sentiment=response_dict['probability']['pos'],\\n user_id=user_query\\n )\\n request.dbsession.add(sentiment_entry)\\n response_dict['probability']['neg'] = percentage(response_dict['probability']['neg'])\\n response_dict['probability']['pos'] = percentage(response_dict['probability']['pos'])\\n return {'response_dict': response_dict,\\n 'text_body': text_body,\\n 'consummate_awareness': sentient_bodies,\\n 'conscious whole': sentimental_parts,\\n 'divine oneness': logical_bits,\\n 'hallowed_provenance': sublime_insight}\\n return {'consummate_awareness': sentient_bodies,\\n 'conscious whole': sentimental_parts,\\n 'divine oneness': logical_bits,\\n 'hallowed_provenance': sublime_insight}\",\n \"def index2well(self, layout_name: str) -> dict:\\n return {v:k for k,v in self['well2index'][self['layout_format'][layout_name]].items() }\",\n \"def annual_summary(self):\\n \\n #Initialize dict with info about all of year's storms\\n hurdat_year = {'id':[],'operational_id':[],'name':[],'max_wspd':[],'min_mslp':[],'category':[],'ace':[]}\\n \\n #Search for corresponding entry in keys\\n count_ss_pure = 0\\n count_ss_partial = 0\\n iterate_id = 1\\n for key in self.dict.keys():\\n\\n #Retrieve info about storm\\n temp_name = self.dict[key]['name']\\n temp_vmax = np.array(self.dict[key]['vmax'])\\n temp_mslp = np.array(self.dict[key]['mslp'])\\n temp_type = np.array(self.dict[key]['type'])\\n temp_time = np.array(self.dict[key]['date'])\\n temp_ace = self.dict[key]['ace']\\n\\n #Get indices of all tropical/subtropical time steps\\n idx = np.where((temp_type == 'SS') | (temp_type == 'SD') | (temp_type == 'TD') | (temp_type == 'TS') | (temp_type == 'HU'))\\n\\n #Get times during existence of trop/subtrop storms\\n if len(idx[0]) == 0: continue\\n trop_time = temp_time[idx]\\n if 'season_start' not in hurdat_year.keys():\\n hurdat_year['season_start'] = trop_time[0]\\n hurdat_year['season_end'] = trop_time[-1]\\n\\n #Get max/min values and check for nan's\\n np_wnd = np.array(temp_vmax[idx])\\n np_slp = np.array(temp_mslp[idx])\\n if len(np_wnd[~np.isnan(np_wnd)]) == 0:\\n max_wnd = np.nan\\n max_cat = -1\\n else:\\n max_wnd = int(np.nanmax(temp_vmax[idx]))\\n max_cat = convert_category(np.nanmax(temp_vmax[idx]))\\n if len(np_slp[~np.isnan(np_slp)]) == 0:\\n min_slp = np.nan\\n else:\\n min_slp = int(np.nanmin(temp_mslp[idx]))\\n\\n #Append to dict\\n hurdat_year['id'].append(key)\\n hurdat_year['name'].append(temp_name)\\n hurdat_year['max_wspd'].append(max_wnd)\\n hurdat_year['min_mslp'].append(min_slp)\\n hurdat_year['category'].append(max_cat)\\n hurdat_year['ace'].append(temp_ace)\\n hurdat_year['operational_id'].append(self.dict[key]['operational_id'])\\n \\n #Handle operational vs. non-operational storms\\n\\n #Check for purely subtropical storms\\n if 'SS' in temp_type and True not in np.isin(temp_type,['TD','TS','HU']):\\n count_ss_pure += 1\\n\\n #Check for partially subtropical storms\\n if 'SS' in temp_type:\\n count_ss_partial += 1\\n\\n #Add generic season info\\n hurdat_year['season_storms'] = len(hurdat_year['name'])\\n narray = np.array(hurdat_year['max_wspd'])\\n narray = narray[~np.isnan(narray)]\\n hurdat_year['season_named'] = len(narray[narray>=34])\\n hurdat_year['season_hurricane'] = len(narray[narray>=65])\\n hurdat_year['season_major'] = len(narray[narray>=100])\\n hurdat_year['season_ace'] = np.sum(hurdat_year['ace'])\\n hurdat_year['season_subtrop_pure'] = count_ss_pure\\n hurdat_year['season_subtrop_partial'] = count_ss_partial\\n \\n #Return object\\n return hurdat_year\",\n \"def generate_explore_views(self):\\n views = []\\n if self._safety_surface[\\\"type\\\"] == \\\"circle\\\":\\n # Generate points evently distributed on the circle\\n center = self._safety_surface[\\\"center\\\"]\\n center = Vector3r(center[0], center[1], center[2])\\n x0 = center.x_val\\n y0 = center.y_val\\n z0 = center.z_val\\n radius = self._safety_surface[\\\"radius\\\"]\\n TOTAL_NUM = self._config[\\\"point_num\\\"]\\n ROUND_NUM = self._config.get(\\\"round_num\\\", 1)\\n delta_theta = 2 * math.pi / (TOTAL_NUM / ROUND_NUM)\\n\\n for i in range(TOTAL_NUM):\\n theta = delta_theta * i\\n x = x0 + radius * math.sin(theta)\\n y = y0 + radius * math.cos(theta)\\n pitch = -45\\n views.append(\\n {\\n \\\"position\\\": Vector3r(x, y, z0),\\n \\\"yaw\\\": -1 * (0.5 * math.pi + theta),\\n \\\"pitch\\\": pitch,\\n }\\n )\\n elif self._safety_surface[\\\"type\\\"] == \\\"cylinder\\\":\\n # Generate points spiral the cylinder\\n top_center = self._safety_surface[\\\"top_center\\\"]\\n top_center = Vector3r(top_center[0], top_center[1], top_center[2])\\n x0 = top_center.x_val\\n y0 = top_center.y_val\\n bottom = self._safety_surface.get(\\\"bottom\\\", 0)\\n height = top_center.z_val - bottom\\n radius = self._safety_surface[\\\"radius\\\"]\\n TOTAL_NUM = self._config[\\\"point_num\\\"]\\n ROUND_NUM = self._config.get(\\\"round_num\\\", 1)\\n START_PITCH = self._config.get(\\\"start_pitch\\\", -45)\\n END_PITCH = self._config.get(\\\"end_pitch\\\", 45)\\n delta_theta = 2 * math.pi / (TOTAL_NUM / ROUND_NUM)\\n delta_height = height / (TOTAL_NUM - 1)\\n delta_pitch = (END_PITCH - START_PITCH) / TOTAL_NUM\\n for i in range(TOTAL_NUM):\\n theta = delta_theta * i\\n x = x0 + radius * math.sin(theta)\\n y = y0 + radius * math.cos(theta)\\n z = bottom + i * delta_height\\n pitch = START_PITCH + i * delta_pitch\\n views.append(\\n {\\n \\\"position\\\": Vector3r(x, y, z),\\n \\\"yaw\\\": -1 * (0.5 * math.pi + theta),\\n \\\"pitch\\\": pitch / 180 * math.pi,\\n }\\n )\\n else:\\n print(\\n \\\"OfflineNavigator: unknown type of safety_surface (%s)\\\"\\n % self._safety_surface[\\\"type\\\"]\\n )\\n\\n return views\",\n \"def proc_employment_summary(summary: Tag) -> Dict:\\n\\n xp_record = dict()\\n xp_record['position'] = summary.find('h3').text.strip()\\n company = summary.find_all('p', {'class': 'pv-entity__secondary-title'})[0]\\n xp_record['company'] = \\\"; \\\".join( [ line.strip() for line in company.text.split('\\\\n')\\n if line.strip() != ''] )\\n # %%\\n for xp_line in summary.find_all('h4'):\\n fld_name, value = [span.text.strip() for span in xp_line.find_all('span') ]\\n if fld_name == 'Fechas de empleo':\\n xp_record['period_raw'] = value\\n period = _extract_period( value )\\n xp_record['period'] = period\\n # print( period )\\n xp_record['duration'] = np.round( (period[1] - period[0]).total_seconds()\\n / SECS_IN_YEAR, 2)\\n elif fld_name == 'Duración del empleo':\\n xp_record['duration_raw'] = value\\n elif fld_name == 'Ubicación':\\n xp_record['location_raw'] = value\\n # print( f'location: {value}')\\n elif fld_name.startswith('LinkedIn me ayud'):\\n continue\\n else:\\n print( \\\"proc_employment_summary: \\\", fld_name, value )\\n # %%\\n # pprint( xp_record )\\n # %%\\n return xp_record\\n # %%\",\n \"def treatments_dict():\\n treats = 2\\n data = pd.DataFrame(\\n data={\\\"id\\\": np.arange(100), \\\"block\\\": [0] * 40 + [1] * 30 + [2] * 30}\\n )\\n idx_col = \\\"id\\\"\\n size = 90\\n\\n treatments = stochatreat(\\n data=data,\\n block_cols=[\\\"block\\\"],\\n treats=treats,\\n idx_col=idx_col,\\n size=size,\\n random_state=42,\\n )\\n\\n treatments_dict = {\\n \\\"data\\\": data,\\n \\\"idx_col\\\": idx_col,\\n \\\"size\\\": size,\\n \\\"treatments\\\": treatments,\\n }\\n\\n return treatments_dict\",\n \"def lf_findall_interp_with_spikes(report):\\n\\n if 'interpretation' in report.sections.keys():\\n interpretation = report.sections['interpretation']\\n interp_text = interpretation['text']\\n return abnormal_interp_with_spikes(interp_text)\\n else:\\n candtext = get_section_with_name(SEIZURE_SECTION_NAMES_LOWER, report)\\n if candtext:\\n return abnormal_interp_with_spikes(candtext)\\n else:\\n return ABSTAIN_VAL\",\n \"def get_hotspot_provenance(self, suptitle, scenario, ancestor_files):\\n caption = (f\\\"{suptitle}. Calculated for seasons \\\"\\n f\\\"{self.seasons[0].upper()}, \\\"\\n f\\\"{self.seasons[1].upper()} and {self.seasons[2].upper()} \\\"\\n f\\\"in the future periods {self.cfg['future_periods'][0]} \\\"\\n f\\\"and {self.cfg['future_periods'][1]} \\\"\\n f\\\"for CMIP5 {self.formatter(f'cmip5-{scenario}')} \\\"\\n f\\\"and CMIP6 {self.formatter(f'cmip6-{scenario}')}\\\")\\n\\n record = {\\n 'caption': caption,\\n 'statistics': ['anomaly', 'diff'],\\n 'domains': ['reg'],\\n 'plot_types': ['map'],\\n 'authors': [\\n 'cos_josep',\\n ],\\n 'references': [\\n 'cos22esd',\\n ],\\n 'ancestors': ancestor_files,\\n }\\n return record\",\n \"def getDictWells(self):\\n #Method begins here\\n #nx=self.__grid['nx'] #From the geometry in grid\\n ny=self.__grid['ny']\\n nz=self.__grid['nz']\\n minx=self.__grid['ox']\\n miny=self.__grid['oy']\\n minz=self.__grid['oz']\\n rx=self.__grid['dx']\\n ry=self.__grid['dy']\\n rz=self.__grid['dz']\\n \\n # well package\\n # Remember to use zero-based layer, row, column indices!\\n lcoordw=np.zeros((self.__nwells,3),dtype=np.int32)\\n for i in range (self.__nwells):\\n lcoordw[i,0]=floor((self.__dflst.iloc[i,3]-minx)/rx)\\n #In MODFLOW y ans z coordinates are inverted\\n lcoordw[i,1]=floor((miny+ry*ny-self.__dflst.iloc[i,4])/ry)\\n lcoordw[i,2]=floor((minz+rz*nz-self.__dflst.iloc[i,5])/rz)\\n \\n nper=self.__df.getForcPer()\\n wel_sp = {} \\n for i in range(nper):\\n lst=[]\\n for j in range(self.__nwells):\\n pumping_rate=self.__dfwells.iloc[i+1,j+1]\\n lst.append( [lcoordw[j,2], lcoordw[j,1], lcoordw[j,0], pumping_rate] )\\n wel_sp[i]=lst\\n print(wel_sp)\\n \\n print('*--- Succesfull reading of wells ---*')\\n \\n return wel_sp\",\n \"def intro_slide(prs):\\n # pylint: disable=too-many-locals\\n slide = prs.slides.add_slide(prs.slide_layouts[BLANK_SLIDE])\\n slide = slide_title_header(\\n slide, 'Explanation of Analysis', include_time=False)\\n\\n explanation_file_path = os.path.join(\\\"resources\\\", \\\"metric_explanation.txt\\\")\\n\\n if os.path.exists(explanation_file_path):\\n with open(explanation_file_path, 'r', encoding='utf-8') as filer:\\n content = filer.readlines()\\n\\n content2 = []\\n for cont in content:\\n cropped = cont.split('\\\\r\\\\n')[0]\\n content2.append(cropped)\\n content = content2\\n filer.close()\\n\\n top = Inches(0.81)\\n left = Inches(0.42)\\n width = Inches(11)\\n height = Inches(6)\\n txt_box = slide.shapes.add_textbox(left, top, width, height)\\n text_frame = txt_box.text_frame\\n text_frame.word_wrap = True\\n\\n paragraph = text_frame.paragraphs[0]\\n paragraph.text = content[0]\\n paragraph.font.size = Pt(12)\\n paragraph.font.bold = True\\n\\n for i in range(1, len(content)):\\n paragraph = text_frame.add_paragraph()\\n paragraph.text = content[i]\\n\\n if i == 5:\\n paragraph.font.size = Pt(12)\\n paragraph.font.bold = True\\n else:\\n paragraph.font.size = Pt(10)\\n paragraph.font.bold = False\\n\\n else:\\n print(f\\\"{WARNING}WARNING - file 'metric_explanation.txt' not found.{NORMAL}\\\")\\n\\n return prs\",\n \"def lf_abnormal_interp_with_sharps(report):\\n if 'interpretation' in report.sections.keys():\\n interpretation = report.sections['interpretation']\\n interp_text = interpretation['text']\\n return abnormal_interp_with_sharps(interp_text)\\n elif 'summary' in report.sections:\\n return abnormal_interp_with_sharps(report.sections['summary']['text'])\\n elif 'findings' in report.sections: # fall back to look in the findings \\n if 'summary' in report.sections['findings']: # fall back to look for a summary instead\\n return abnormal_interp_with_sharps(report.sections['findings']['summary'])\\n if 'impression' in report.sections['findings']:\\n return abnormal_interp_with_sharps(report.sections['findings']['impression'])\\n return ABSTAIN_VAL\\n elif 'narrative' in report.sections: # fall back to look in the findings \\n ky = 'narrative'\\n if 'summary' in report.sections[ky]: # fall back to look for a summary instead\\n return abnormal_interp_with_sharps(report.sections[ky]['summary'])\\n if 'impression' in report.sections[ky]:\\n return abnormal_interp_with_sharps(report.sections[ky]['impression']) \\n return ABSTAIN_VAL \\n else:\\n return ABSTAIN_VAL\",\n \"def _read_stix_spec_file(spec_file):\\n sdict = {}\\n with fits.open(spec_file) as hdul:\\n for i in range(5):\\n sdict[str(i)] = [hdul[i].header, hdul[i].data]\\n return sdict\",\n \"def extract_summary(self):\\n metadata = {}\\n\\n ## document Id\\n documentId = self.tree.find(\\\"./id\\\")\\n documentId = documentId.attrib['root'] if documentId is not None and \\\"root\\\" in documentId.attrib else \\\"\\\"\\n metadata[\\\"documentId\\\"] = documentId\\n\\n ## setId\\n setid = self.tree.find(\\\"./setId\\\")\\n setid = setid.attrib['root'] if setid is not None and \\\"root\\\" in setid.attrib else \\\"\\\"\\n metadata[\\\"setId\\\"] = setid\\n\\n ## version number\\n splversion = self.tree.find(\\\"./versionNumber\\\")\\n versionNumber = \\\"\\\"\\n if splversion is not None:\\n if \\\"value\\\" in splversion.attrib:\\n versionNumber = splversion.attrib[\\\"value\\\"]\\n metadata[\\\"versionNumber\\\"] = versionNumber\\n\\n ## product type \\n code = self.tree.find(\\\"./code\\\")\\n check_if_attrib_exists = lambda x, key: x[key] if key in x else ''\\n product_type = check_if_attrib_exists(code.attrib, \\\"displayName\\\")\\n metadata[\\\"productType\\\"] = product_type\\n\\n ## title\\n title_text = self.tree_et.xpath(\\\"./title//text()\\\")\\n title = (\\\" \\\".join([self.strip_newline_tab(t) for t in title_text]) if len(title_text) > 0 else \\\"\\\")\\n metadata[\\\"title\\\"] = title\\n\\n ## manufacturer\\n manufacturer = self.tree.find(\\\"./author//representedOrganization/name\\\")\\n if manufacturer != None and manufacturer.text != None:\\n manufacturer = self.strip_newline_tab(manufacturer.text)\\n else:\\n manufacturer = \\\"\\\"\\n metadata[\\\"manufacturer\\\"] = manufacturer\\n\\n ## effectivetime\\n effectiveTime = self.tree_et.xpath(\\\"./effectiveTime/@value\\\")\\n effectiveTime = self.__normalize_date(effectiveTime)\\n\\n metadata[\\\"effectiveTime\\\"] = effectiveTime\\n metadata[\\\"publishedDate\\\"] = effectiveTime\\n\\n ## From manufacturedProduct section\\n brand_name = self.tree_et.xpath(\\\".//manufacturedProduct//name\\\")\\n brand_name = self.strip_newline_tab(brand_name[0].text) if len(brand_name) > 0 else \\\"\\\"\\n metadata[\\\"drugName\\\"] = brand_name\\n\\n route = self.tree_et.xpath(\\\".//manufacturedProduct//formCode/@code\\\")\\n route = self.strip_newline_tab(route[0]) if len(route) > 0 else \\\"\\\"\\n metadata[\\\"routeOfAdministration\\\"] = route\\n\\n product_ndc = self.tree_et.xpath(\\\".//manufacturedProduct//code/@code\\\")\\n product_ndc = self.strip_newline_tab(product_ndc[0]) if len(product_ndc) > 0 else \\\"\\\"\\n metadata[\\\"ndcCode\\\"] = product_ndc\\n\\n generic_name = self.tree_et.xpath(\\\".//manufacturedProduct//asEntityWithGeneric//genericMedicine/name\\\")\\n generic_name = self.strip_newline_tab(generic_name[0].text) if len(generic_name) > 0 else \\\"\\\"\\n metadata[\\\"genericName\\\"] = generic_name\\n\\n ## dosage form\\n dosage_form = self.tree_et.xpath(\\\".//manufacturedProduct//formCode/@displayName\\\")\\n dosage_form = dosage_form[0] if len(dosage_form) > 0 else \\\"\\\"\\n metadata[\\\"dosageForm\\\"] = dosage_form\\n\\n # active ingredients\\n substance_name = sorted([self.strip_newline_tab(a.text) for a in\\n self.tree_et.xpath(\\\".//.//manufacturedProduct//activeMoiety/activeMoiety/name\\\")])\\n substance_name = \\\", \\\".join(set(substance_name))\\n metadata[\\\"substanceName\\\"] = substance_name\\n\\n ## inactive ingredients\\n inactive_ingredients = sorted([self.strip_newline_tab(inactive.text) for inactive in self.tree_et.xpath(\\n \\\".//manufacturedProduct//inactiveIngredient/inactiveIngredientSubstance/name\\\")])\\n\\n if len(inactive_ingredients) == 0:\\n inactive_ingredients = \\\"\\\"\\n else:\\n inactive_ingredients = \\\",\\\".join(set(inactive_ingredients))\\n\\n metadata[\\\"inactiveIngredients\\\"] = inactive_ingredients\\n\\n ## other ingredients\\n ingredients = sorted([self.strip_newline_tab(ingredient.text) for ingredient in\\n self.tree_et.xpath(\\\".//manufacturedProduct//ingredient/ingredientSubstance/name\\\")])\\n\\n if len(ingredients) == 0:\\n ingredients = \\\"\\\"\\n else:\\n ingredients = \\\", \\\".join(set(ingredients))\\n metadata[\\\"ingredients\\\"] = ingredients\\n\\n # marketing_category\\n marketing_category = self.tree_et.xpath(\\\".//manufacturedProduct/subjectOf/approval/code/@displayName\\\")\\n marketing_category = self.strip_newline_tab(marketing_category[0]) if len(marketing_category) > 0 else \\\"\\\"\\n metadata[\\\"marketingCategory\\\"] = marketing_category\\n\\n # consumed in\\n consumed_in = self.tree_et.xpath(\\n \\\".//manufacturedProduct//consumedIn/substanceAdministration/routeCode/@displayName\\\")\\n consumed_in = consumed_in[0] if len(consumed_in) > 0 else \\\"\\\"\\n metadata[\\\"consumedIn\\\"] = consumed_in\\n\\n # revision date\\n marketing_date = self.tree_et.xpath(\\\".//manufacturedProduct//marketingAct/effectiveTime/low/@value\\\")\\n marketing_date = self.__normalize_date(marketing_date)\\n metadata[\\\"marketingDate\\\"] = marketing_date\\n\\n return metadata\",\n \"def drawsheet_parse(text):\\n logging.debug(\\\"################ PARSING DRAW ##################\\\")\\n\\n month = \\\"({})\\\".format('|'.join(RE_MONTHS))\\n\\n patterns = (\\n ('surface', r\\\"Hard|Outdoor Hard|Red Clay|Green Clay|Clay|\\\"\\n r\\\"Grass|Indoor Hard|Carpet|Indoor Carpet\\\"),\\n ('date', r\\\"\\\\d{1,2}(th)? ?- ?\\\\d{1,2}(th)? \\\" + month + r\\\",? \\\\d{4}|\\\" +\\n month + r\\\" \\\\d{1,2}(th)? ?- ?\\\\d{1,2}(th)?,? \\\\d{4}\\\"),\\n ('year', r\\\"\\\\d{4}\\\"),\\n ('seed', r\\\"(?<=\\\\[)\\\\d+(?=\\\\])|(?<=\\\\[ )\\\\d+(?=\\\\ ])\\\"),\\n ('round', r\\\"(1st|2nd|3rd) Round|1/8|1/4|1/2\\\"),\\n ('class', r\\\"WTA( [A-Za-z0-9]+)*|US Open|\\\"\\n r\\\"French Open|Australian Open|Wimbledon\\\"),\\n ('orderedname', r\\\"[A-Z][a-z]+(( |-)[A-Z][a-z]+)*\\\"\\n r\\\" ([A-Z]+(( |-)[A-Z]+)*)(?= |$)\\\"),\\n ('fullname', r\\\"(?:^| )[Bb][Yy][Ee](?:$| )|([A-Z]+(( |-)[A-Z]+)*,\\\\s\\\"\\n r\\\"[A-Z][a-zA-Z]*(( |-)([A-Z][a-zA-Z]*[a-z]))*)\\\"),\\n #('shortname', r\\\"[A-Z]\\\\. ?[A-Z]+(( |-)[A-Z]+)*\\\"),\\n ('shortname', r\\\"[A-Z]\\\\. ?[A-Za-z]+(( |-)[A-Za-z]+)*\\\"),\\n ('country', r\\\"(?:(?!RET)[A-Z]{3}|\\\\([A-Z]{3}\\\\))(?= |$)\\\"),\\n ('score',\\n r\\\"([0-7][/-]?[0-7](\\\\(\\\\d+\\\\))?)( [0-7][/-]?[0-7](\\\\(\\\\d+\\\\))?){0,2}\\\"\\n r\\\" ([Rr]et\\\\.|[Rr]et'd|[Rr]etired|[Rr]et)\\\"\\n r\\\"|([0-7][/-]?[0-7](\\\\(\\\\d+\\\\))?)( [0-7][/-]?[0-7](\\\\(\\\\d+\\\\))?){1,2}\\\"\\n r\\\"|([0-7]/?[0-7](\\\\(\\\\d+\\\\))? ){2}[\\\\d+]/[\\\\d+]\\\"\\n r\\\"|(wo.|[Ww]alkover)\\\"),\\n ('prize', r\\\"\\\\$[0-9,]+(?= |$)\\\"),\\n ('number', r\\\"\\\\d{1,3}\\\\.?(?= |$)\\\"),\\n ('city', r\\\"[A-Z][A-Za-z]*( [A-Z][A-Za-z]+)*,\\\"\\n r\\\"( [A-Z][A-Z],)? (USA|[A-Z][a-z]*)\\\"),\\n ('status', r\\\"(^|(?<=\\\\[|\\\\(| ))(Q|LL|W|WC)((?=\\\\]|\\\\)| )|$)\\\"),\\n ('string', r\\\"([A-Za-z&,\\\\']+)( [A-Z&a-z$,]+)*\\\"),\\n )\\n \\n pattern = re.compile('|'.join([\\\"(?P<{}>{})\\\".format(k, v) \\n for k, v in patterns]))\\n data = { k: [] for k, v in patterns}\\n\\n short_to_fullnames = {}\\n ordered_to_fullnames = {}\\n def add_to_fullname_conversion_table(fullname, x, y):\\n nm = re.match('(.*), (.)', fullname)\\n name = nm.group(2) + \\\". \\\" + nm.group(1)\\n if name not in short_to_fullnames:\\n short_to_fullnames[name] = []\\n\\n short_to_fullnames[name] += [(fullname, (x,y))]\\n\\n nm = re.match('(.*), (.*)', fullname)\\n name = nm.group(2) + \\\" \\\" + nm.group(1)\\n ordered_to_fullnames[name] = fullname\\n\\n\\n re_skip = re.compile(r'Seeded +Players')\\n # Find scores, names, etc\\n y = 0\\n skipping_page = False\\n\\n # collect the data\\n width = 0\\n lines = text.split('\\\\n');\\n for line in lines:\\n if skipping_page:\\n if chr(12) in line:\\n skipping_page = False\\n else:\\n continue\\n\\n if (re_skip.search(line)):\\n # skip the seeding/info section, it's useless\\n skipping_page = True\\n continue;\\n\\n for m in pattern.finditer(line):\\n for group, match in m.groupdict().items():\\n if match is not None:\\n match = match.strip()\\n x1 = m.start(group)\\n x2 = m.end(group)\\n\\n if x2 > width:\\n width = x2\\n\\n data[group] += [(match, ((x1, x2), y))]\\n\\n if group == 'fullname' and match.upper() != \\\"BYE\\\":\\n add_to_fullname_conversion_table(match, (x1, x2), y)\\n\\n y += 1\\n\\n # hack to catch country codes that got attached to fullnames\\n if len(data['country']) > 0:\\n cc_re = re.compile(r'^([A-Z]{3}) (.*)')\\n # find known country codes\\n countries = set(list(zip(*data['country']))[0])\\n if len(data['fullname']) > len(data['country']):\\n for n, point in data['fullname']:\\n m = cc_re.match(n)\\n if m and m.group(1) in countries:\\n country = m.group(1)\\n name = m.group(2)\\n idx = data['fullname'].index((n, point))\\n del data['fullname'][idx]\\n (x1, x2), y = point\\n data['fullname'].insert(idx, (name, ((x1 + 4), x2, y)))\\n data['country'].append((country, ((x1, x1 + 3), y)))\\n add_to_fullname_conversion_table(name)\\n if len(data['fullname']) == len(data['country']):\\n # we're done\\n break\\n\\n # find any possible country codes\\n if len(data['fullname']) > len(data['country']):\\n for n, point in data['fullname']:\\n m = cc_re.match(n)\\n if m:\\n country = m.group(1)\\n name = m.group(2)\\n idx = data['fullname'].index((n, point))\\n del data['fullname'][idx]\\n (x1, x2), y = point\\n data['fullname'].insert(idx, (name, ((x1 + 4, x2), y)))\\n data['country'].append((country, ((x1, x1 + 3), y)))\\n add_to_fullname_conversion_table(name)\\n if len(data['fullname']) == len(data['country']):\\n # we're done\\n break\\n\\n orderednames = []\\n for n, point in data['orderedname']:\\n try:\\n n = ordered_to_fullnames[n]\\n orderednames += [(n, point)]\\n except KeyError:\\n data['string'] += [(n, point)]\\n\\n data['orderedname'] = orderednames\\n\\n def distance(a, b):\\n ax1, ax2 = a[0]\\n bx1, bx2 = b[0]\\n ax = (ax1 + ax2) / 2\\n bx = (bx1 + bx2) / 2\\n dx = float(ax - bx) / 10\\n dy = float(a[1] - b[1])\\n\\n return math.sqrt(dx * dx + dy * dy)\\n\\n # assign shortnames to longnames\\n # some people share a shortname, so assign to \\n # the longname that is closest\\n shortnames = []\\n for n, point in data['shortname']:\\n n = n.upper()\\n if n[2] != ' ':\\n short = n[0:2] + ' ' + n[2:]\\n else:\\n short = n\\n\\n try:\\n shorts = short_to_fullnames[short]\\n\\n short = min(shorts, key=lambda s: distance(s[1], point))\\n shortnames += [(short[0], point)]\\n except KeyError:\\n data['string'] += [(n, point)]\\n\\n data['shortname'] = shortnames\\n\\n logging.debug(pprint.pformat(data))\\n\\n return data, width;\",\n \"def processSlideInfo(extractionCtx: ExtractionContext) -> None:\\n\\n\\tlogger = extractionCtx.logger\\n\\n\\t# get a list of mapping and slide info\\n\\tmappingInfo = _getMappingInfo(extractionCtx)\\n\\tif not mappingInfo:\\n\\t\\treturn\\n\\n\\t# Process each pair\\n\\tfor info in mappingInfo:\\n\\t\\tif info.slideInfo.version == 2:\\n\\t\\t\\t_V2Rebaser(extractionCtx, info).run()\\n\\t\\telif info.slideInfo.version == 3:\\n\\t\\t\\t_V3Rebaser(extractionCtx, info).run()\\n\\t\\telse:\\n\\t\\t\\tlogger.error(\\\"Unknown slide version.\\\")\",\n \"def find_patches_from_slide(slide_path, filter_non_tissue=True):\\n\\n #sampletotal = pd.DataFrame([])\\n #base_truth_dir = Path(BASE_TRUTH_DIR)\\n #anno_path = Path(anno_path)\\n #slide_contains_tumor = osp.basename(slide_paths[i]).startswith('tumor_')\\n print (slide_path)\\n\\n dimensions = []\\n \\n with openslide.open_slide(slide_path) as slide:\\n dtotal = (slide.dimensions[0] / 224, slide.dimensions[1] / 224)\\n thumbnail = slide.get_thumbnail((dtotal[0], dtotal[1]))\\n thum = np.array(thumbnail)\\n ddtotal = thum.shape\\n dimensions.extend(ddtotal)\\n hsv_image = cv2.cvtColor(thum, cv2.COLOR_BGR2HSV)\\n h, s, v = cv2.split(hsv_image)\\n hthresh = threshold_otsu(h)\\n sthresh = threshold_otsu(s)\\n vthresh = threshold_otsu(v)\\n # be min value for v can be changed later\\n minhsv = np.array([hthresh, sthresh, 70], np.uint8)\\n maxhsv = np.array([180, 255, vthresh], np.uint8)\\n thresh = [minhsv, maxhsv]\\n #extraction the countor for tissue\\n\\n rgbbinary = cv2.inRange(hsv_image, thresh[0], thresh[1])\\n _, contours, _ = cv2.findContours(rgbbinary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n bboxtcols = ['xmin', 'xmax', 'ymin', 'ymax']\\n bboxt = pd.DataFrame(columns=bboxtcols)\\n for c in contours:\\n (x, y, w, h) = cv2.boundingRect(c)\\n bboxt = bboxt.append(pd.Series([x, x+w, y, y+h], index = bboxtcols), ignore_index=True)\\n bboxt = pd.DataFrame(bboxt)\\n \\n xxmin = list(bboxt['xmin'].get_values())\\n xxmax = list(bboxt['xmax'].get_values())\\n yymin = list(bboxt['ymin'].get_values())\\n yymax = list(bboxt['ymax'].get_values())\\n\\n xxxmin = np.min(xxmin)\\n xxxmax = np.max(xxmax)\\n yyymin = np.min(yymin)\\n yyymax = np.max(yymax)\\n\\n dcoord = (xxxmin, xxxmax, yyymin, yyymax)\\n\\n dimensions.extend(dcoord)\\n\\n # bboxt = math.floor(np.min(xxmin)*256), math.floor(np.max(xxmax)*256), math.floor(np.min(yymin)*256), math.floor(np.max(yymax)*256)\\n \\n samplesnew = pd.DataFrame(pd.DataFrame(np.array(thumbnail.convert('L'))))\\n print(samplesnew)\\n # very critical: y value is for row, x is for column\\n samplesforpred = samplesnew.loc[yyymin:yyymax, xxxmin:xxxmax]\\n\\n dsample = samplesforpred.shape\\n\\n dimensions.extend(dsample)\\n\\n np.save ('dimensions_%s' % (osp.splitext(osp.basename(slide_paths[i]))[0]), dimensions)\\n\\n print(samplesforpred)\\n\\n samplesforpredfinal = pd.DataFrame(samplesforpred.stack())\\n\\n print(samplesforpredfinal)\\n\\n samplesforpredfinal['tile_loc'] = list(samplesforpredfinal.index)\\n\\n samplesforpredfinal.reset_index(inplace=True, drop=True)\\n\\n\\n samplesforpredfinal['slide_path'] = slide_paths[i]\\n\\n\\n print(samplesforpredfinal)\\n\\n\\n return samplesforpredfinal\",\n \"def __local_sp(soup):\\n news = []\\n titles = soup.find('section', class_='col-xs-12 maislidas-interno').find_all('h3', class_='fifth')\\n\\n for title in titles:\\n news.append(dict(title=title.string, link=title.parent['href']))\\n return news\",\n \"def parse(self):\\n result = {}\\n if self.detail_statu:\\n sel = Selector(text=self.driver.page_source)\\n\\n fact_table = sel.xpath(\\n '//div[@class=\\\"facts-table\\\"]//text()').extract()\\n result['facts'] = [list(i)\\n for i in zip(fact_table[:: 2],\\n fact_table[1:: 2])]\\n\\n tax_table = sel.xpath(\\n '//div[@class=\\\"tax-values\\\"]//text()').extract()\\n result['taxs'] = [list(i)\\n for i in zip(tax_table[:: 2],\\n tax_table[1:: 2])]\\n\\n listing_detail = sel.xpath(\\n '//div[@class=\\\"amenities-container\\\"]//text()').extract()\\n result['detail'] = listing_detail\\n result['page_source'] = self.driver.page_source\\n self.detail_statu = False\\n else:\\n self.log.warning(\\n '---- Detail page url out of reach, use .search() first to get the detail page')\\n return result\",\n \"def get_annotation(file, pos_dict, ex_dict, tag):\\n results = {}\\n with open(file, 'r', encoding='utf-8') as f:\\n par = 0\\n par_results = []\\n for line in f:\\n if line is \\\"\\\\n\\\":\\n if par_results:\\n if \\\"paragraph\\\" + str(par) in results:\\n results[\\\"paragraph\\\" + str(par)].append(par_results)\\n else:\\n results[\\\"paragraph\\\" + str(par)] = par_results\\n par += 1\\n par_results = []\\n continue\\n for q in pos_dict:\\n qmatches = re.finditer(q, line, re.I)\\n for qmatch in qmatches:\\n exclude = 0\\n for exItem in ex_dict:\\n exMatches = re.finditer(exItem.rstrip('\\\\n'), line, re.I)\\n for exMatch in exMatches:\\n if exMatch and qmatch.start(1) is exMatch.start(1):\\n exclude = 1\\n # Save result to list of results with appropriate tag\\n if (qmatch and exclude is 0):\\n try:\\n #results.append((int(qmatch.group(1)),int(qmatch.group(2)), int(qmatch.group(len(qmatch.groups()))), tag))\\n par_results.append({\\\"sentID\\\": int(qmatch.group(1)), \\\"spanStart\\\":int(qmatch.group(2)), \\\"spanEnd\\\":int(qmatch.group(len(qmatch.groups()))), \\\"tag\\\": tag})\\n except TypeError:\\n # TypeErrors are usually raised when one of the capture groups of fields is empty (NoneType)\\n # Simply throw a warning message and keep going\\n print(\\\"Warning! Something went wrong while matching expression'\\\" + q + \\\"' in line '\\\" + line[0:50] + \\\"...'\\\")\\n return results\",\n \"def return_figures():\\n # Add New York Times API Key\\n nyt = NYTAPI(\\\"AsjeHhqDYrePA2GMPpYoY1KAKAdG7P99\\\")\\n\\n # Select Year and Month of articles\\n data = nyt.archive_metadata(\\n date = datetime.datetime(2020, 7, 1)\\n )\\n\\n def data_to_df(data):\\n # Initiate list for restructured information\\n data_list = []\\n\\n # Collect Data from API dictionary\\n for article in data:\\n new_data = [article.get(\\\"section_name\\\"),\\n article.get(\\\"news_desk\\\"),\\n article.get(\\\"pub_date\\\"),\\n article.get(\\\"headline\\\").get(\\\"main\\\"),\\n article.get(\\\"abstract\\\"),\\n article.get(\\\"lead_paragraph\\\"),\\n article.get(\\\"type_of_material\\\"),\\n article.get(\\\"word_count\\\")]\\n # Append list of information from article to data list\\n data_list.append(new_data)\\n\\n # Convert data list to DataFrame\\n df = pd.DataFrame(data_list, columns=[\\\"section_name\\\",\\\"news_desk\\\", \\\"pub_date\\\", \\\"headline\\\", \\\"abstract\\\", \\\"lead_paragraph\\\", \\\"type_of_material\\\", \\\"word_count\\\"])\\n\\n return df\\n\\n df = data_to_df(data)\\n\\n # first chart plots section distribution\\n # as a pie chart\\n graph_one = []\\n df_one = df.copy()\\n\\n # filter and sort values for the visualization\\n # filtering plots the articles in decreasing order by their values\\n labels = df_one.section_name.value_counts().index\\n values = df_one.section_name.value_counts().values\\n\\n graph_one.append(\\n go.Pie(\\n labels=labels,\\n values=values,\\n hole=.6,\\n textposition=\\\"inside\\\"\\n )\\n )\\n\\n layout_one = dict(title = 'Distribution of sections of this months New York Times articles')\\n\\n # second chart plots section distribution\\n # as a pie chart\\n graph_two = []\\n df_two = df.copy()\\n\\n # filter and sort values for the visualization\\n # filtering plots the articles in decreasing order by their values\\n labels = df_two.news_desk.value_counts().index\\n values = df_two.news_desk.value_counts().values\\n\\n graph_two.append(\\n go.Pie(\\n labels=labels,\\n values=values,\\n hole=.6,\\n textposition=\\\"inside\\\"\\n )\\n )\\n\\n layout_two = dict(title = 'Distribution of news desk of this months articles')\\n\\n # third chart plots section distribution\\n # as a pie chart\\n graph_three = []\\n df_three = df.copy()\\n\\n # filter and sort values for the visualization\\n # filtering plots the articles in decreasing order by their values\\n labels = df_three.type_of_material.value_counts().index\\n values = df_three.type_of_material.value_counts().values\\n\\n graph_three.append(\\n go.Pie(\\n labels=labels,\\n values=values,\\n hole=.6,\\n textposition=\\\"inside\\\"\\n )\\n )\\n\\n layout_three = dict(title = 'Distribution for type of material of this months articles')\\n\\n # fourth chart plots section distribution\\n # as a pie chart\\n graph_four = []\\n\\n # Convert publishing date columns to datetime format\\n df[\\\"pub_date\\\"] = pd.to_datetime(df[\\\"pub_date\\\"]).dt.date\\n\\n df_four = df.copy()\\n df_four = df_four.pub_date.value_counts().to_frame().sort_index()\\n\\n # filter and sort values for the visualization\\n # filtering plots the articles in decreasing order by their values\\n x_val = df_four.index\\n y_val = df_four.values\\n\\n graph_four.append(\\n go.Scatter(\\n x=df_four.index,\\n y=df_four[\\\"pub_date\\\"],\\n mode=\\\"lines\\\",\\n name=\\\"Articles\\\"\\n )\\n )\\n\\n layout_four = dict(title = 'Number of articles published by days')\\n\\n # fourth chart plots section distribution\\n # as a pie chart\\n graph_five = []\\n\\n # Calculate average number of words for this months articles\\n avg_word_count = round(df.word_count.mean(),0)\\n\\n graph_five.append(\\n go.Table(\\n header=dict(values=['Average Word Count']),\\n cells=dict(values=[avg_word_count])\\n )\\n )\\n\\n layout_five = dict(title = '')\\n\\n # append all charts\\n figures = []\\n figures.append(dict(data=graph_one, layout=layout_one))\\n figures.append(dict(data=graph_two, layout=layout_two))\\n figures.append(dict(data=graph_three, layout=layout_three))\\n figures.append(dict(data=graph_four, layout=layout_four))\\n figures.append(dict(data=graph_five, layout=layout_five))\\n\\n return figures\",\n \"def import_landscape_section(self, filename_suffix='lan', ti_offset=0):\\n with open('%s/%s.%s' % (self.model_path, self.model_name, filename_suffix)) as f:\\n data = f.read()\\n _data = re.search(r'\\\\*THEME.*', data, re.M|re.S).group(0) # strip leading junk\\n t_data = re.split(r'\\\\*THEME.*\\\\n', _data)[1:] # split into theme-wise chunks\\n for ti, t in enumerate(t_data, start=ti_offset):\\n self._themes.append({})\\n self._theme_basecodes.append([])\\n defining_aggregates = False\\n for l in [l for l in t.split('\\\\n') if not re.match('^\\\\s*(;|{|$)', l)]: \\n if re.match('^\\\\s*\\\\*AGGREGATE', l): # aggregate theme attribute code\\n tac = re.split('\\\\s+', l.strip())[1].lower()\\n self._themes[ti][tac] = []\\n defining_aggregates = True\\n continue\\n if not defining_aggregates: # line defines basic theme attribute code\\n tac = re.search('\\\\S+', l.strip()).group(0).lower()\\n self._themes[ti][tac] = tac\\n self._theme_basecodes[ti].append(tac)\\n else: # line defines aggregate values (parse out multiple values before comment)\\n _tacs = [_tac.lower() for _tac in re.split('\\\\s+', l.strip().partition(';')[0].strip())]\\n self._themes[ti][tac].extend(_tacs)\\n self.nthemes = len(self._themes)\",\n \"def variable_dicts(self):\\n \\n def get_variable_text(rtf_file):\\n \\\"Returns a list of variable_texts for each variable\\\"\\n st='Pos. = '\\n return rtf_file.split(st)[1:]\\n \\n def get_variable_name(variable_text):\\n st='Variable = '\\n b=variable_text.split(st)[1]\\n return b[b.find(' ')+1:b.find('\\\\t')]\\n \\n def find_pos(rtf):\\n a=rtf\\n b=a\\n return b[b.find(' ')+1:b.find('\\\\t')]\\n \\n def find_variable_label(rtf):\\n try:\\n a=rtf\\n b=a.split('Variable label = ')[1]\\n return b[b.find(' ')+1:b.find('\\\\\\\\par')]\\n except IndexError:\\n return None\\n \\n def find_variable_type(rtf):\\n if not 'This variable is ' in rtf: return ''\\n a=rtf\\n b=a.split('This variable is ')[1]\\n i1=b.find(' ')+1\\n i2=i1+b[i1:].find('}')\\n return b[i1:i2]\\n \\n def find_SPSS_measurement_level(rtf):\\n if not 'the SPSS measurement level is ' in rtf: return ''\\n a=rtf\\n b=a.split('the SPSS measurement level is ')[1]\\n i1=b.find(' ')+1\\n i2=i1+b[i1:].find('\\\\\\\\par')\\n return b[i1:i2]\\n \\n def find_SPSS_user_missing_values(rtf):\\n if not 'SPSS user missing values = ' in rtf: return dict()\\n a=rtf\\n d=a.split('SPSS user missing values = ')\\n if len(d)<2: return None\\n e=d[1]\\n i1=e.find(' ')+1\\n i2=i1+e[i1:].find('\\\\\\\\par')\\n f=e[i1:i2]\\n g=f.split(' ')\\n i=' '.join([g[0],g[2],g[4]])\\n return i\\n \\n def find_value_labels(rtf):\\n if not 'Value = ' in rtf: return dict()\\n a=rtf\\n d=a.split('Value = ')[1:]\\n z={}\\n for e in d:\\n value=e[e.find(' ')+1:e.find('\\\\t')]\\n value=float(value)\\n f=e.split('Label = ')[1]\\n label=f[f.find(' ')+1:f.find('\\\\\\\\par')]\\n z[value]=label\\n #print(z)\\n return z\\n \\n variable_texts=get_variable_text(self.rtf)\\n #pprint(variable_texts[0:2])\\n \\n result=[]\\n for variable_text in variable_texts:\\n d={'pos':find_pos(variable_text),\\n 'variable':get_variable_name(variable_text),\\n 'variable_label':find_variable_label(variable_text),\\n 'variable_type':find_variable_type(variable_text),\\n 'SPSS_measurement_level':find_SPSS_measurement_level(variable_text),\\n 'SPSS_user_missing_values':find_SPSS_user_missing_values(variable_text),\\n 'value_labels':find_value_labels(variable_text) \\n }\\n result.append(d)\\n \\n return result\",\n \"def pose_structure(pose, display_residues = []):\\n # store the pose's number of residues, example Python syntax\\n nres = pose.total_residue()\\n\\n # 1. obtain the pose's sequence\\n sequence = pose.sequence()\\n\\n # 2. obtain a list of PDB numbering and icode as a single string\\n pdb_info = pose.pdb_info()\\n PDB_nums = [(str( pdb_info.number(i)) + pdb_info.icode(i)).strip()\\n for i in range(1, nres + 1)]\\n # 3. obtains a list of the chains organized by residue\\n chains = [pdb_info.chain(i) for i in range(1, nres + 1)]\\n # 4. extracts a list of the unique chain IDs\\n unique_chains = []\\n for c in chains:\\n if c not in unique_chains:\\n unique_chains.append(c)\\n\\n # start outputting information to screen\\n print('\\\\n' + '='*80)\\n print('Loaded from' , pdb_info.name())\\n print(nres , 'residues')\\n print(len(unique_chains), 'chain(s) ('+ str(unique_chains)[1:-1] + ')')\\n print('Sequence:\\\\n' + sequence)\\n\\n # this object is contained in PyRosetta v2.0 and above\\n # 5. obtain the pose's secondary structure as predicted by PyRosetta's\\n # built-in DSSP algorithm\\n DSSP = protocols.moves.DsspMover()\\n DSSP.apply(pose) # populates the pose's Pose.secstruct\\n ss = pose.secstruct()\\n print( 'Secondary Structure:\\\\n' + ss )\\n print( '\\\\t' + str(100. * ss.count('H') / len(ss))[:4] + '% Helical' )\\n print( '\\\\t' + str(100. * ss.count('E') / len(ss))[:4] + '% Sheet' )\\n print( '\\\\t' + str(100. * ss.count('L') / len(ss))[:4] + '% Loop' )\\n\\n # 6. obtain the phi, psi, and omega torsion angles\\n phis = [pose.phi(i) for i in range(1, nres + 1)]\\n psis = [pose.psi(i) for i in range(1, nres + 1)]\\n omegas = [pose.omega(i) for i in range(1, nres + 1)]\\n\\n # this object is contained in PyRosetta v2.0 and above\\n # create a PyMOLMover for exporting structures directly to PyMOL\\n pymover = PyMOLMover()\\n pymover.apply(pose) # export the structure to PyMOL (optional)\\n\\n # 7. output information on the requested residues\\n # use a simple dictionary to make output nicer\\n ss_dict = {'L':'Loop', 'H':'Helix', 'E':'Strand'}\\n for i in display_residues:\\n print( '='*80 )\\n print( 'Pose numbered Residue', i )\\n print( 'PDB numbered Residue', PDB_nums[i-1] )\\n print( 'Single Letter:', sequence[i-1] )\\n print( 'Chain:', chains[i-1] )\\n print( 'Secondary Structure:', ss_dict[ss[i-1]] )\\n print( 'Phi:', phis[i-1] )\\n print( 'Psi:', psis[i-1] )\\n print( 'Omega:', omegas[i-1] )\\n # extract the chis\\n chis = [pose.chi(j + 1, i) for j in range(pose.residue(i).nchi() )]\\n for chi_no in range(len(chis)):\\n print( 'Chi ' + str(chi_no + 1) + ':', chis[chi_no] )\\n print( '='*80 )\",\n \"def samsemPlots17thru20(samsem_data, path, dict):\\n \\n path_res = path\\n \\n if 'subfolder' in dict:\\n subfolder = dict['subfolder']\\n path_res = os.path.join(path,subfolder)\\n if not os.path.exists(path_res): os.makedirs(path_res)\\n \\n coldef_type = dict['coldef_type']\\n print(\\\"Starting SAMSEM_RES#17+20: Analyzing data of all images for \\\" + str(settings.id2ColDefLong[dict['coldef_type']]) + \\\" simulation methods.\\\")\\n \\n if 'plot_types' in dict:\\n plot_types = dict['plot_types']\\n else:\\n plot_types = ['RT_boxplots', 'RT_means', 'ACC_CIs', 'median']\\n \\n method_ids = sorted(set(samsem_data['sim_id'].values.astype(int)))\\n image_ids = sorted(set(samsem_data['image_id'].values.astype(int)))\\n #print method_ids\\n \\n for method_id in method_ids:\\n if (method_id != 3) and (method_id != 99):\\n whatArr_sim = [['sim_id',operator.eq,method_id],['coldef_type',operator.eq,coldef_type],['observer_coldef_type',operator.eq, coldef_type]]\\n else:\\n whatArr_sim = [['sim_id',operator.eq,method_id],['observer_coldef_type',operator.eq,coldef_type]]\\n samsem_data_sim = organizeArray(samsem_data, whatArr_sim)\\n \\n boxes = []; labels = []; accuracies = {}; mean_cis = {}; order = {}; i=1\\n \\n for image_id in image_ids:\\n whatArr_image = [['image_id', operator.eq, image_id]]\\n samsem_data_image = organizeArray(samsem_data_sim,whatArr_image)\\n \\n dict.update({'filename':str(settings.id2ColDef[coldef_type])+'-simulation-method-'+str(settings.id2Sim[method_id])+'_images'})\\n \\n # 3. Get response time data\\n alg_values = samsem_data_image[samsem_data_image['is_correct']==True]['resp_time'].values*1000; \\n if ('RT_boxplots' in plot_types) or ('median-test' in plot_types):\\n boxes.append(alg_values)\\n labels.append(image_id) if alg_values.size else labels.append(str(image_id) + ' - No data'); \\n \\n # 4. Get CI of RT means\\n if 'RT_means' in plot_types:\\n alg_mean = getCIAverage(alg_values);\\n alg_mean.append(labels[i-1])\\n mean_cis.update({image_id: alg_mean})\\n \\n # 5. Get accuracy data\\n if 'ACC_CIs' in plot_types:\\n alg_acc = getAccuracy(samsem_data_image)\\n alg_acc.append(labels[i-1])\\n accuracies.update({image_id: alg_acc})\\n \\n order.update({i:image_id})\\n i += 1\\n if 'RT_boxplots' in plot_types:\\n # 6. Plot response time data\\n plotRTGraphs(boxes,labels,path_res,dict,order)\\n \\n if 'RT_means' in plot_types:\\n # 7. Plot CI means of RT data\\n plotCIAverageGraphs(mean_cis,path_res,dict,order)\\n \\n if 'ACC_CIs' in plot_types:\\n # 8. Plot accuracy data\\n plotAccuracyGraphs(accuracies,path_res,dict,order)\\n \\n if 'median-test' in plot_types:\\n # 9. Make median test\\n dict.update({'filename': dict['filename']+\\\"-RT\\\"})\\n makeMedianTest(numpy.array(boxes), path_res, image_ids,dict)\",\n \"def break_up_pt_and_passage_comparisons(discordance_by_cohort_dict):\\n pt_passage_dict = dict()\\n early_late_dict = dict()\\n for cohort in discordance_by_cohort_dict:\\n discordance_dictionary = discordance_by_cohort_dict[cohort]\\n pt_passage_discordance = []\\n early_late_discordance = []\\n for key in discordance_dictionary:\\n if \\\"PT\\\" in key:\\n pt_passage_discordance += discordance_dictionary[key]\\n else:\\n early_late_discordance += discordance_dictionary[key]\\n pt_passage_dict[cohort] = pt_passage_discordance\\n early_late_dict[cohort] = early_late_discordance\\n return pt_passage_dict, early_late_dict\",\n \"def test_display_presentation(self):\\n response = self._speaker_profile(True)\\n self.assertContains(response, FIRST_PRESENTATION_TITLE)\\n self.assertContains(response, SECOND_PRESENTATION_TITLE)\",\n \"def _parse_result(cls, design_folder: str) -> Dict[str, Any]:\\n _, folder_name = os.path.split(design_folder)\\n raw_folder = os.path.join(design_folder, '{}.raw'.format(folder_name))\\n res = SpectreParser.parse(raw_folder)\\n return res\",\n \"def overlay(self):\\n # retrieve header for photometry keywords\\n # from current frame only\\n hdr_str = self.run('fits header', via='get')\\n\\n # read it in to a fits header\\n phdr = fits.Header()\\n hdr = phdr.fromstring(hdr_str, sep='\\\\n')\\n\\n try:\\n srcposx = hdr['SRCPOSX'] + 1\\n srcposy = hdr['SRCPOSY'] + 1\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=blue tag={{srcpos}} '\\\\\\n 'text=SRCPOS'.format(srcposx, srcposy)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n photaper = hdr['PHOTAPER']\\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\\n self.run('regions', s1)\\n s2 = 'circle({:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(\\n stcentx, stcenty, photaper)\\n self.run('regions', s2)\\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\\n stcentx, stcenty, photskap[0], photskap[1])\\n self.run('regions', s3)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n flux = hdr['STAPFLX']\\n sky = hdr['STAPSKY']\\n s1 = 'text({:f} {:f}) # color=cyan ' \\\\\\n 'text=\\\"Flux={:.2f}, Sky={:.2f}\\\"'.format(\\n stcentx, stcenty - 40, flux, sky)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n\\n # try overlaying apertures as well\\n try:\\n self.overlay_aperture(hdr)\\n except ValueError: # pragma: no cover\\n # may be encountered with extensions with\\n # unexpected WCSs\\n pass\",\n \"def process_sentiment(self, sentiment_data):\\n new_utts_dict = {'1':[], '2':[], '3':[], '4':[], '5':[]}\\n for l in sentiment_data:\\n title = [\\\"<s>\\\"] + l[0] + [\\\"</s>\\\"]\\n context = [\\\"<s>\\\"] + l[1] + [\\\"</s>\\\"]\\n target = [\\\"<s>\\\"] + l[2] + [\\\"</s>\\\"]\\n sentiment = l[3][0]\\n new_utts_dict[sentiment].append([title, context, target, sentiment])\\n return new_utts_dict\",\n \"def CreatePresentation(self, event):\\n pass\",\n \"def population_text_parser():\\n h = 480\\n w = 640\\n filenames = []\\n # get corrispondence ppoints for all faces\\n all_face_verticies = []\\n for i in range(1, 41):\\n if i == 2 or i == 3 or i == 4:\\n # not in data set\\n continue\\n # get file name\\n file_name = \\\"data/\\\"\\n if i < 10:\\n file_name += \\\"0\\\" + str(i)\\n else:\\n file_name += str(i)\\n if i == 8 or i == 22 or i == 30 or i == 35 or i == 12 or i ==14 or i == 15:\\n # female faces\\n file_name += \\\"-1f.asf\\\"\\n else:\\n file_name += \\\"-1m.asf\\\"\\n filenames.append(file_name[:-3] + \\\"bmp\\\")\\n # Parse corrispondence points\\n face_vertices = file_parser(file_name)\\n all_face_verticies.append(np.array(face_vertices))\\n\\n # adding my face to the set\\n # all_face_verticies.append(get_will_points())\\n mean_vertices = np.array(sum(all_face_verticies)) / len(all_face_verticies)\\n\\n # face = plt.imread(filenames[0])\\n # mean_vertices = ginput_to_array(appendCorners_other(face, mean_vertices))\\n # Morph each of the faces in the dataset into the average shape.\\n morphs = []\\n for i in range(len(all_face_verticies)):\\n # Read in src img\\n print(\\\"Morphing face \\\" + str(i) + \\\" into the average shape.\\\")\\n if i == len(all_face_verticies)-1:\\n face = plt.imread(\\\"will_population.jpeg\\\")/255\\n else:\\n face = plt.imread(filenames[i])/255\\n # print(face.shape)\\n # print(mean_vertices)\\n im_src_vertices = all_face_verticies[i]\\n\\n # Create Dalaunay triangulation for the ith morph set\\n print(\\\"Computing Delaunay triangulation.\\\")\\n # morph_verticies = morphPointSet(tri0_vertices, tri1_vertices, i/45)\\n t = Delaunay(mean_vertices)\\n trianguations = t.simplices\\n\\n # Compute Affine Transformation matrices for both transformations (src-->mid; dst-->mid)\\n print(\\\"Computing Affine Transformation.\\\")\\n affine_matrices_0 = computeAffines(trianguations, im_src_vertices, mean_vertices)\\n affine_matrices_inv_0 = [linalg.inv(A) for A in affine_matrices_0]\\n\\n morph = warp(h, w, t, affine_matrices_inv_0, face)\\n # if i == len(all_face_verticies) -1:\\n # plt.imsave(\\\"will_in_danish_pop.png\\\", morph)\\n morphs.append(morph)\\n\\n out = sum(morphs) * (1/len(morphs))\\n return out\",\n \"def osp2():\\n return dict(\\n kloc= range(75,125),\\n docu = [3,4], ltex = [2,5],\\n sced = [2,3,4], Pmat = [4,5],\\n Prec = [3,4, 5],\\n Resl = [4], Team = [3],\\n acap = [4], aexp = [4],\\n cplx = [4], data = [4],\\n Flex = [3], pcap = [3],\\n pcon = [3], pexp = [4],\\n pvol = [3], rely = [5],\\n ruse = [4], site = [6],\\n stor = [3], time = [3],\\n tool = [5])\",\n \"def test_extract():\\n print(\\\"Executing test_extract:\\\")\\n\\n theory_1=[\\n (14,),\\n (15,),\\n (14,),\\n (16,)\\n ]\\n theory_2=[\\n (14,),\\n (15,),\\n (14,),\\n (17,)\\n ]\\n theory_3=[\\n (15,),\\n (14,)\\n ]\\n\\n mind=minds.new_mind(theories=[theory_1,theory_2,theory_3])\\n\\n print(\\\"Mind initial state:\\\")\\n print(minds.mind_string(mind, show_claims=False, show_problems=False))\\n\\n minds.extract_new_routines(mind,1)\\n print(\\\"Mind after 1 step of extraction:\\\")\\n print(minds.mind_string(mind, show_claims=False, show_problems=False))\\n\\n minds.extract_new_routines(mind,1)\\n print(\\\"Mind after 2 steps of extraction:\\\")\\n print(minds.mind_string(mind, show_claims=False, show_problems=False))\",\n \"def save_annotations(self):\\n for fp in self.ris_widget.flipbook_pages:\\n if len(fp) == 0:\\n # skip empty flipbook pages\\n continue\\n annotations = getattr(fp, 'annotations', {})\\n pose = annotations.get('pose', (None, None))\\n if pose is not None:\\n center_tck, width_tck = pose\\n if center_tck is not None:\\n path = pathlib.Path(fp[0].name)\\n with path.with_suffix('.pickle').open('wb') as f:\\n pickle.dump(dict(pose=pose), f)\\n\\n # warp and save images from all flipbook pages\\n for lab_frame in fp:\\n lab_frame_image = lab_frame.data\\n path = pathlib.Path(lab_frame.name)\\n warp = worm_spline.to_worm_frame(lab_frame_image, center_tck, width_tck)\\n warp_save_path = path.parent / (path.stem + '-straight.png')\\n freeimage.write(warp, warp_save_path)\\n\\n # If the widths are drawn, then create a mask that allows the user to make an alpha channel later.\\n # We create one mask for each flipbook page, in case the images were saved in different places.\\n # If we wind up redundantly writing the same mask a few times, so be it.\\n if width_tck is not None:\\n mask = worm_spline.worm_frame_mask(width_tck, warp.shape)\\n mask_save_path = path.parent / (path.stem + '-mask.png')\\n freeimage.write(mask, mask_save_path)\",\n \"def get_soup_general_data(soup):\\n data_dict = {}\\n\\n name = soup.find(class_='product_title')\\n if name:\\n data_dict['name_of_game'] = name.h1.text\\n\\n pub = soup.find('li', class_='summary_detail publisher')\\n if pub:\\n data_dict['publisher'] = pub.a.text.strip()\\n\\n rel_date = soup.find('li', class_='summary_detail release_data')\\n if rel_date:\\n rel_date = rel_date.find('span', class_='data')\\n if rel_date:\\n data_dict['release_date'] = rel_date.text.strip()\\n\\n num_p = soup.find(\\\"li\\\", class_=\\\"summary_detail product_players\\\")\\n if num_p:\\n data_dict['num_players'] = num_p.find(class_=\\\"data\\\").text\\n\\n genres = soup.find(\\\"li\\\", class_='summary_detail product_genre')\\n if genres:\\n genres = genres.find_all('span', class_='data')\\n data_dict['genres'] = [genre.text for genre in genres]\\n\\n age = soup.find(\\\"li\\\", class_=\\\"summary_detail product_rating\\\")\\n if age:\\n data_dict['age_rating'] = age.find('span', class_=\\\"data\\\").text\\n\\n return data_dict\",\n \"def _build_study_info(user, study_proc=None, proc_samples=None):\\n # Logic check to make sure both needed parts passed\\n if study_proc is not None and proc_samples is None:\\n raise IncompetentQiitaDeveloperError(\\n 'Must pass proc_samples when study_proc given')\\n elif proc_samples is not None and study_proc is None:\\n raise IncompetentQiitaDeveloperError(\\n 'Must pass study_proc when proc_samples given')\\n\\n # get list of studies for table\",\n \"def extract_spacy(self, text: str)->dict:\\n ners=None\\n try:\\n persons=[]\\n locations=[]\\n orgs=[]\\n misc=[]\\n docs=[]\\n if len(text)>1000000:\\n docs=self._splitCount(text,1000000)\\n else:\\n docs.append(text)\\n for doc in docs:\\n doc_spacy = self.recognizer(doc)\\n for token in doc_spacy:\\n if token.ent_type_ == \\\"PER\\\":\\n persons.append(token.text)\\n if token.ent_type_ == \\\"LOC\\\":\\n locations.append(token.text)\\n if token.ent_type_ == \\\"ORG\\\":\\n orgs.append(token.text)\\n if token.ent_type_ == \\\"MISC\\\":\\n misc.append(token.text)\\n ners={\\\"persons\\\":list(set(persons)), \\\"locations\\\":list(set(locations)),\\\"orgs\\\":list(set(orgs)), \\\"misc\\\":list(set(misc))}\\n except Exception as ex:\\n print('Exception while extracting NERs')\\n print(str(ex))\\n finally:\\n return ners\",\n \"def study(user_preferences: dict, matcher: NodeMatcher):\\r\\n studysame = user_preferences[\\\"importancia_estudios\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", imp = studysame))\\r\\n return equal_styles\",\n \"def _get_summary_struct(self):\\n model_fields = [\\n ('Number of classes', 'num_classes'),\\n ('Number of feature columns', 'num_features'),\\n ('Input image shape', 'input_image_shape'),\\n ]\\n training_fields = [\\n ('Number of examples', 'num_examples'),\\n (\\\"Training loss\\\", 'training_loss'),\\n (\\\"Training time (sec)\\\", 'training_time'),\\n ]\\n\\n section_titles = ['Schema', 'Training summary']\\n return([model_fields, training_fields], section_titles)\",\n \"def extract_relevant(self):\\n item_extraction = self.data\\n my_dict = {'tweeted_time': item_extraction['created_at'],\\n 'tweet_id': item_extraction['id'],\\n # If the time comes when the below becomes more significant, it will be no trouble at all to make an\\n # additional column for it, but delimiting it with a ` creates less clutter in the Database\\n 'in_reply_to':\\n \\\"NAME/\\\" + str(item_extraction['in_reply_to_screen_name']) + \\\"`\\\" +\\n \\\"STATUSID/\\\" + str(item_extraction['in_reply_to_status_id_str']) + \\\"`\\\" +\\n \\\"USERID/\\\" + str(item_extraction['in_reply_to_user_id_str']),\\n 'lang': item_extraction['lang'],\\n 'place': item_extraction['place'], 'source': item_extraction['source']}\\n if item_extraction['place'] is not None:\\n my_dict['place'] = item_extraction['place']['full_name']\\n if 'retweeted_status' in item_extraction.keys():\\n my_dict['original_author_id'] = item_extraction['retweeted_status']['user']['id']\\n my_dict['original_author_handle'] = item_extraction['retweeted_status']['user']['screen_name']\\n tester = item_extraction['retweeted_status']['text']\\n cleaned = ' '.join(re.sub(\\\"(RT : )|(@[\\\\S]+)|(&\\\\S+)|(http\\\\S+)\\\", \\\" \\\", tester).split())\\n removed_others = \\\" \\\".join(re.sub(\\\"(#\\\\S+)\\\", ' ', cleaned).split())\\n final_text = ''.join(list(filter(lambda x: x.isalpha() or x is ' ', removed_others)))\\n # This final text will make it a lot easier to run NLP\\n final_text = final_text.strip().replace(' ', ' ').replace(' ', ' ')\\n my_dict['plain_text'] = final_text.lower()\\n my_dict['tweet'] = cleaned\\n else:\\n my_dict['original_author_id'] = item_extraction['user']['id']\\n my_dict['original_author_handle'] = item_extraction['user']['screen_name']\\n cleaned = ' '.join(re.sub(\\\"(@[\\\\S]+)|(&\\\\S+)|(http\\\\S+)\\\", \\\" \\\", item_extraction['text']).split())\\n removed_others = \\\" \\\".join(re.sub(\\\"(#\\\\S+)\\\", ' ', cleaned).split())\\n final_text = ''.join(list(filter(lambda x: x.isalpha() or x is ' ', removed_others)))\\n final_text = final_text.strip().replace(' ', ' ').replace(' ', ' ')\\n my_dict['plain_text'] = final_text.lower()\\n my_dict['tweet'] = cleaned\\n return my_dict\",\n \"def playerStandings(t_name):\\n t_id = getTournamentID(t_name, False)\\n if t_id == -1:\\n return []\\n conn, cur = connect()\\n cur.execute(\\\"SELECT create_summary();\\\")\\n conn.commit()\\n query = \\\"SELECT P_ID, P_NAME, WIN, MATCH FROM SUMMARY WHERE T_ID = %s\\\"\\n param = (t_id, )\\n cur.execute(query, param)\\n ps = [(int(row[0]), str(row[1]), int(row[2]), int(row[3]))\\n for row in cur.fetchall()]\\n return ps\",\n \"def make_hst_spec_previews(input_file, flux_scale_factor=\\n FLUX_SCALE_FACTOR_DEFAULT, fluxerr_scale_factor=\\n FLUXERR_SCALE_FACTOR_DEFAULT, n_consecutive=\\n N_CONSECUTIVE_DEFAULT, output_path=\\n OUTPUT_PATH_DEFAULT, output_type=OUTPUT_TYPE_DEFAULT,\\n dpi_val=DPI_VAL_DEFAULT, debug=DEBUG_DEFAULT,\\n full_ylabels=FULL_YLABELS_DEFAULT, optimize=\\n not NOOPTIMIZE_DEFAULT, verbose=VERBOSE_DEFAULT):\\n\\n # Print file name, if verbose is turned on.\\n if verbose:\\n print(\\\"Input file: \\\" + input_file)\\n\\n # Derive output file names from input file name.\\n output_files = []\\n for out_type in output_type:\\n if out_type != \\\"screen\\\":\\n if out_type != \\\"fits\\\":\\n output_file = (path.join(output_path, \\\"\\\") +\\n path.basename(input_file).split(\\\".fits\\\")[0] +\\n \\\".\\\" + out_type)\\n else:\\n output_file = (path.join(output_path, \\\"\\\") +\\n path.basename(input_file).split(\\\".fits\\\")[0] +\\n \\\"_prev.\\\" + out_type)\\n else:\\n output_file = None\\n\\n output_files.append(output_file)\\n\\n # Print name of output file.\\n if verbose:\\n print(\\\"Output file names are:\\\")\\n for ofile in output_files:\\n if ofile is not None:\\n if ofile[-4:] == '.png':\\n print(\\\" Output file: \\\" + ofile)\\n print(\\\" Output file: \\\" + ofile.strip('\\\\.png') +\\n '_thumb.png')\\n else:\\n print(\\\" Output file: \\\" + ofile)\\n else:\\n print(\\\" Plotting to screen.\\\")\\n\\n # Read in the FITS file to determine which instrument it comes from.\\n # Print the name of the instrument found in the header if verbose is turned\\n # on.\\n this_instrument = get_instrument_name(input_file)\\n if verbose:\\n print(\\\"Instrument: \\\" + this_instrument)\\n\\n # Read in the FITS files and create plots using the local package\\n # appropriate for the instrument used in the input file.\\n if this_instrument == \\\"COS\\\":\\n # Get wavelengths, fluxes, flux uncertainties.\\n cos_spectrum = specutils_cos.readspec(input_file)\\n\\n # Get a list of segment names sorted such that the bluest segment is\\n # first.\\n cos_segment_names = specutils_cos.get_segment_names(cos_spectrum)\\n\\n # Trim the wavelengths < 900 Angstroms for FUVB segment if optical\\n # element used is G140L.\\n if (\\\"FUVB\\\" in cos_spectrum.segments and cos_spectrum.optical_element ==\\n \\\"G140L\\\"):\\n specutils_cos.extract_subspec(cos_spectrum, \\\"FUVB\\\", min_wl=900.)\\n\\n # Create a stitched spectrum for use when making thumb-size plots.\\n stitched_spectrum = specutils.stitch_components(cos_spectrum,\\n n_consecutive,\\n flux_scale_factor,\\n fluxerr_scale_factor,\\n segment_names=\\n cos_segment_names)\\n\\n # Calculate plot metrics for the each segment.\\n segment_plot_metrics = [\\n specutils.calc_plot_metrics(\\\"cos\\\",\\n cos_spectrum.segments[x].wavelengths,\\n cos_spectrum.segments[x].fluxes,\\n cos_spectrum.segments[x].fluxerrs,\\n cos_spectrum.segments[x].dqs,\\n n_consecutive, flux_scale_factor,\\n fluxerr_scale_factor)\\n for x in cos_segment_names]\\n\\n # Make \\\"large-size\\\" plot.\\n for out_type, out_file in zip(output_type, output_files):\\n if out_type != \\\"fits\\\":\\n specutils_cos.plotspec(cos_spectrum, out_type, out_file,\\n flux_scale_factor,\\n fluxerr_scale_factor,\\n segment_plot_metrics,\\n dpi_val=dpi_val, output_size=1024,\\n debug=debug, full_ylabels=full_ylabels,\\n title_addendum=stitched_spectrum[\\\"title\\\"],\\n optimize=optimize)\\n else:\\n # Write the spectrum that would be plotted to a binary FITS\\n # table.\\n specutils_cos.make_fits(cos_spectrum, out_file,\\n segment_plot_metrics, input_file)\\n\\n if not debug and output_type != [\\\"fits\\\"]:\\n # Calculate plot metrics for the stitched spectrum.\\n stitched_plot_metrics = [\\n specutils.calc_plot_metrics(\\\"cos\\\", stitched_spectrum[\\\"wls\\\"],\\n stitched_spectrum[\\\"fls\\\"],\\n stitched_spectrum[\\\"flerrs\\\"],\\n stitched_spectrum[\\\"dqs\\\"],\\n n_consecutive, flux_scale_factor,\\n fluxerr_scale_factor)]\\n\\n # Make \\\"thumbnail-size\\\" plot, if requested.\\n for out_type, out_file in zip(output_type, output_files):\\n if out_type != 'fits':\\n specutils_cos.plotspec(cos_spectrum, out_type,\\n out_file, flux_scale_factor,\\n fluxerr_scale_factor,\\n stitched_plot_metrics,\\n dpi_val=dpi_val, output_size=128,\\n stitched_spectrum=stitched_spectrum,\\n optimize=optimize)\\n\\n elif this_instrument == \\\"STIS\\\":\\n # Get wavelengths, fluxes, flux uncertainties.\\n stis_spectrum = specutils_stis.readspec(input_file)\\n\\n # Get the indices to plot. If the number of associations is <=3 then\\n # we will plot all of them, but if >3 then only the first, middle, and\\n # last association will be plotted, so it's not necessary to stitch or\\n # calculate plot metrics for any of the others.\\n indices_to_plot = specutils_stis.get_association_indices(\\n stis_spectrum.associations)\\n\\n # Create a stitched spectrum for each association, used when making\\n # thumb-size plots. The stitched spectrum joins the orders together (if\\n # there is more than one). The length of the returned list is equal to\\n # the number of associations that will be plotted.\\n stitched_spectra = [\\n specutils.stitch_components(x, n_consecutive, flux_scale_factor,\\n fluxerr_scale_factor)\\n for x in numpy.asarray(stis_spectrum.associations)[indices_to_plot]]\\n\\n # Calculate plot metrics for the each association that will be\\n # plotted. The length of the returned list is equal to the number of\\n # associations that will be plotted.\\n association_plot_metrics = [\\n specutils.calc_plot_metrics(\\\"stis\\\", x[\\\"wls\\\"], x[\\\"fls\\\"], x[\\\"flerrs\\\"],\\n x[\\\"dqs\\\"], n_consecutive,\\n flux_scale_factor, fluxerr_scale_factor)\\n for x in stitched_spectra]\\n\\n # Make \\\"large-size\\\" plot.\\n for out_type, out_file in zip(output_type, output_files):\\n if out_type != 'fits':\\n specutils_stis.plotspec(stis_spectrum, indices_to_plot,\\n stitched_spectra, out_type, out_file,\\n flux_scale_factor, fluxerr_scale_factor,\\n association_plot_metrics,\\n dpi_val=dpi_val, output_size=1024,\\n debug=debug, full_ylabels=full_ylabels,\\n optimize=optimize)\\n\\n # Make \\\"thumbnail-size\\\" plot, if requested. Notice that in this\\n # case we always plot just the first association, by passing only\\n # `stitched_spectra[0]`.\\n if not debug:\\n specutils_stis.plotspec(stis_spectrum, indices_to_plot,\\n [stitched_spectra[0]], out_type,\\n out_file, flux_scale_factor,\\n fluxerr_scale_factor,\\n association_plot_metrics,\\n dpi_val=dpi_val,\\n output_size=128, optimize=optimize)\\n\\n else:\\n raise HSTSpecPrevError(\\\"'INSTRUME' keyword not understood: \\\" +\\n this_instrument)\",\n \"def get_general(soup):\\n \\n general_info = {}\\n general_info.update(get_route_name(soup))\\n general_info.update(get_box_data(soup))\\n general_info.update(get_description(soup))\\n general_info.update(get_hierarchy(soup))\\n general_info.update(get_first_img_source(soup))\\n\\n return general_info\",\n \"def get_sentiment_lexicon(datafile):\\n user_dict = {}\\n item_dict = {}\\n feature_dict ={}\\n aspect_index = 0\\n\\n for tupel in datafile.iterrows():\\n line = tupel[0]\\n user_id = datafile[\\\"user_id\\\"][line]\\n item_id = datafile[\\\"business_id\\\"][line]\\n list_len = len(datafile['absa'][line])\\n if user_id not in user_dict:\\n user_dict[user_id] = []\\n if item_id not in item_dict:\\n item_dict[item_id] = []\\n for i in range(0, list_len):\\n feature = datafile['absa'][line][i]['aspect']\\n fetaure_confidence = datafile['absa'][line][i]['aspect_confidence']\\n polarity = datafile['absa'][line][i]['polarity']\\n polarity_confidence = datafile['absa'][line][i]['polarity_confidence']\\n if feature not in feature_dict:\\n feature_dict[feature] = aspect_index\\n aspect_index = aspect_index+1\\n user_dict[user_id].append([feature, fetaure_confidence, polarity, polarity_confidence])\\n item_dict[item_id].append([feature, fetaure_confidence, polarity, polarity_confidence])\\n return [feature_dict, user_dict, item_dict]\",\n \"def parse(u):\\n rec = {}\\n\\n try:\\n r = requests.get(u, headers=headers)\\n\\n if r.status_code == 200:\\n html = r.text\\n soup = BeautifulSoup(html, 'lxml')\\n overview_section = soup.select('.Raw-s14xcvr1-0 gXqFYO')\\n full_name_section = soup.select('.sc-iwsKbI kjxnCg')\\n years_of_practice_section = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\\n language_section = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\\n office_location_section = soup.select('.Paragraph-fqygwe-0 cojhks')\\n hospital_affiliation_section = soup.select('.Paragraph-fqygwe-0 fwayNy')\\n specialties = soup.select('.DataField__Data-c3wc7f-1 gLHSHx')\\n education_and_medical_training_section = soup.select('.EducationAndExperience__Item-xn5fll-0 bzYYRk')\\n certification_and_licensure_section = soup.select('.Paragraph-fqygwe-0 bQPwuv')\\n\\n if overview_section:\\n overview = overview_section[0].text.replace('\\\"', '')\\n if full_name_section:\\n full_name = full_name_section[0].text\\n if years_of_practice_section:\\n years_of_practice = years_of_practice_section[0].text.strip().replace('\\\"', '')\\n if language_section:\\n language = language_section[0].text.strip().replace('\\\"', '')\\n if office_location_section:\\n office_location = office_location_section[0].text\\n if hospital_affiliation_section:\\n hospital_affiliation = hospital_affiliation_section[0].text.strip().replace('\\\"', '')\\n if specialties_section:\\n specialties = specialties_section[0].text.replace('\\\"', '')\\n if education_and_medical_training_section:\\n education_and_medical_training = education_and_medical_training_section[0].text\\n if certification_and_licensure_section:\\n certification_and_licensure = certification_and_licensure_section[0].text\\n\\n\\n rec = {'overview': overview, 'full_name': full_name, 'years_of_practice': years_of_practice, 'language': language,\\n 'office_location': office_location, 'hospital_affiliation': hospital_affiliation, 'specialties':specialties,\\n 'education_and_medical_training': education_and_medical_training,\\n 'certification_and_licensure': certification_and_licensure}\\n except Exception as ex:\\n print('Exception while parsing')\\n print(str(ex))\\n finally:\\n return json.dumps(rec)\",\n \"def processing_function(raw):\\r\\n\\r\\n # Sort stewarded & unstewarded depts\\r\\n STEWARDED_DEPTS = set(stewards.keys()) & kt.ALL_DEPTS\\r\\n UNSTEWARDED_DEPTS = kt.ALL_DEPTS - STEWARDED_DEPTS\\r\\n\\r\\n ##############################\\r\\n # Filter data in all the ways\\r\\n ##############################\\r\\n actives = kt.filterdata(raw, kt.selectors.allactives)\\r\\n nc = kt.filterdata(actives, kt.selectors.northcampus)\\r\\n\\r\\n # International Students\\r\\n itnl = kt.filterdata(actives, kt.selectors.itnl)\\r\\n permres = kt.filterdata(actives, kt.selectors.permres)\\r\\n\\r\\n # Stewarded / Unstewarded\\r\\n stewarded= kt.filterdata(\\r\\n actives,\\r\\n lambda person: kt.selectors.bydept(person,STEWARDED_DEPTS)\\r\\n )\\r\\n unstewarded= kt.filterdata(\\r\\n actives,\\r\\n lambda person: kt.selectors.bydept(person,UNSTEWARDED_DEPTS)\\r\\n )\\r\\n\\r\\n # Hire Date\\r\\n newhires = kt.filterdata(\\r\\n actives, \\r\\n lambda person: kt.selectors.hiredafter(person,NEW_HIRE_DATE)\\r\\n )\\r\\n\\r\\n oldhires = kt.filterdata(\\r\\n actives, \\r\\n lambda person: kt.selectors.hiredbefore(person,NEW_HIRE_DATE)\\r\\n )\\r\\n\\r\\n nohiredate = kt.filterdata(actives, kt.selectors.nohiredate)\\r\\n\\r\\n # Degree Program\\r\\n phd = kt.filterdata(\\r\\n actives, \\r\\n lambda person: kt.selectors.bydegree(person,['PhD'])\\r\\n )\\r\\n masters = kt.filterdata(\\r\\n actives, \\r\\n lambda person: kt.selectors.bydegree(person, kt.MASTERS)\\r\\n )\\r\\n\\r\\n ###############\\r\\n # Count things\\r\\n ###############\\r\\n\\r\\n # Unit sizes\\r\\n bargaining_unit_size = len(actives)\\r\\n overall_members = kt.count_duespayers(actives)\\r\\n\\r\\n # Number of actives currently stewarded\\r\\n total_stewarded = len(stewarded)\\r\\n total_unstewarded = len(unstewarded)\\r\\n stewarded_members = kt.count_duespayers(stewarded)\\r\\n unstewarded_members = kt.count_duespayers(unstewarded)\\r\\n\\r\\n # International students\\r\\n total_intl = len(itnl)\\r\\n total_permres = len(permres)\\r\\n intl_members = kt.count_duespayers(itnl)\\r\\n permres_members = kt.count_duespayers(permres)\\r\\n\\r\\n # New Hires\\r\\n total_newhires = len(newhires)\\r\\n total_oldhires = len(oldhires)\\r\\n total_nohiredate= len(nohiredate)\\r\\n newhire_members = kt.count_duespayers(newhires)\\r\\n oldhire_members = kt.count_duespayers(oldhires)\\r\\n\\r\\n\\r\\n # Degree Program\\r\\n total_phd = len(phd)\\r\\n total_masters = len(masters)\\r\\n phd_members = kt.count_duespayers(phd)\\r\\n masters_members = kt.count_duespayers(masters)\\r\\n \\r\\n\\r\\n ######################################\\r\\n # Derived Results\\r\\n ######################################\\r\\n labels = []\\r\\n results= []\\r\\n\\r\\n labels += ['Current Bargaining Unit Size']\\r\\n results+= [bargaining_unit_size]\\r\\n\\r\\n labels += ['Relative Number of GSIs with >1 Steward (%)']\\r\\n results+= [(100.0*total_stewarded)/bargaining_unit_size]\\r\\n\\r\\n labels += ['Relative Number of International Students (%)']\\r\\n results+= [(100.0*total_intl)/bargaining_unit_size]\\r\\n\\r\\n # labels += ['Relative Number of NC Permanent Resident Students (%)']\\r\\n # results+= [(100.0*total_permres)/bargaining_unit_size]\\r\\n\\r\\n labels += ['']\\r\\n results+= ['']\\r\\n\\r\\n labels += ['Overall GEO Membership (%)']\\r\\n results+= [(100.0*overall_members)/bargaining_unit_size]\\r\\n\\r\\n labels += ['Membership Among Stewarded Depts (%)']\\r\\n results+= [(100.0*stewarded_members)/total_stewarded]\\r\\n\\r\\n labels += ['Membership Among Unstewarded Depts (%)']\\r\\n results+= [(100.0*unstewarded_members)/total_unstewarded]\\r\\n\\r\\n labels += ['']\\r\\n results+= ['']\\r\\n\\r\\n labels += ['Relative # of International Students (%)']\\r\\n results+= [(100.0*total_intl)/bargaining_unit_size]\\r\\n\\r\\n labels += ['Membership Among International Students (%)']\\r\\n results+= [(100.0*intl_members)/total_intl]\\r\\n\\r\\n # labels += ['Membership Among Permanent Residents (%)']\\r\\n # results+= [(100.0*permres_members)/total_permres]\\r\\n\\r\\n labels += ['']\\r\\n results+= ['']\\r\\n\\r\\n labels += ['Relative # of New Hires (%)']\\r\\n results+= [(100.0*total_newhires)/bargaining_unit_size]\\r\\n\\r\\n labels += ['Membership Among New Hires (%)']\\r\\n results+= [(100.0*newhire_members)/total_newhires]\\r\\n\\r\\n labels += ['Membership Among Old Hires (%)']\\r\\n results+= [(100.0*oldhire_members)/total_oldhires]\\r\\n\\r\\n labels += ['Number of People w/o Known Hire Dates']\\r\\n results+= [total_nohiredate]\\r\\n\\r\\n labels += ['']\\r\\n results+= ['']\\r\\n\\r\\n labels += ['Relative # of Masters Students (%)']\\r\\n results+= [(100.0*total_masters)/bargaining_unit_size]\\r\\n\\r\\n labels += ['Membership Among Masters Students (%)']\\r\\n results+= [(100.0*masters_members)/total_masters]\\r\\n\\r\\n labels += ['Membership Among PhD Students (%)']\\r\\n results+= [(100.0*phd_members)/total_phd]\\r\\n\\r\\n labels += ['']\\r\\n results+= ['']\\r\\n\\r\\n\\r\\n\\r\\n # Display summary results\\r\\n print('\\\\n')\\r\\n display_results(labels,results)\\r\\n\\r\\n print('Unstewarded Departments:')\\r\\n for d in UNSTEWARDED_DEPTS: print(d)\\r\\n\\r\\n print('\\\\n')\\r\\n\\r\\n\\r\\n\\r\\n # Print summary results to csv\\r\\n kt.writecsv_summary(zip(labels,results), OUT_FILE)\\r\\n\\r\\n\\r\\n\\r\\n # dump all local variables to file\\r\\n # v = locals()\\r\\n\\r\\n\\r\\n\\r\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57579595","0.5754335","0.55619776","0.545294","0.5446325","0.51942104","0.51507777","0.51323617","0.5105886","0.5052227","0.5037823","0.49726292","0.4881835","0.4851375","0.48495308","0.48304343","0.48082933","0.47642702","0.4755273","0.47469255","0.47447446","0.47133496","0.46433732","0.46357328","0.46329084","0.4603979","0.45964986","0.45959252","0.45818478","0.45591724","0.4555059","0.45512167","0.45434","0.4537788","0.4531281","0.4528349","0.45185888","0.45160326","0.44937423","0.4486711","0.44865462","0.44800955","0.44783604","0.44681746","0.44622734","0.4454868","0.44529885","0.44459757","0.44457835","0.4441328","0.4440596","0.4435347","0.44337818","0.44314295","0.44213167","0.4412668","0.44091672","0.44081798","0.4404994","0.44041163","0.44038698","0.4401886","0.4401223","0.43871608","0.4387082","0.4378438","0.4372773","0.4371993","0.4370425","0.43682024","0.43658337","0.43596742","0.4353401","0.4349448","0.43488747","0.43488744","0.43460852","0.43416244","0.43415275","0.4339209","0.43301272","0.43263757","0.43241414","0.43238935","0.43218496","0.43142238","0.43141845","0.43033308","0.42981333","0.42948568","0.4292998","0.42911696","0.4283256","0.42824557","0.42808002","0.42764026","0.42735225","0.42691842","0.42672002","0.42659274"],"string":"[\n \"0.57579595\",\n \"0.5754335\",\n \"0.55619776\",\n \"0.545294\",\n \"0.5446325\",\n \"0.51942104\",\n \"0.51507777\",\n \"0.51323617\",\n \"0.5105886\",\n \"0.5052227\",\n \"0.5037823\",\n \"0.49726292\",\n \"0.4881835\",\n \"0.4851375\",\n \"0.48495308\",\n \"0.48304343\",\n \"0.48082933\",\n \"0.47642702\",\n \"0.4755273\",\n \"0.47469255\",\n \"0.47447446\",\n \"0.47133496\",\n \"0.46433732\",\n \"0.46357328\",\n \"0.46329084\",\n \"0.4603979\",\n \"0.45964986\",\n \"0.45959252\",\n \"0.45818478\",\n \"0.45591724\",\n \"0.4555059\",\n \"0.45512167\",\n \"0.45434\",\n \"0.4537788\",\n \"0.4531281\",\n \"0.4528349\",\n \"0.45185888\",\n \"0.45160326\",\n \"0.44937423\",\n \"0.4486711\",\n \"0.44865462\",\n \"0.44800955\",\n \"0.44783604\",\n \"0.44681746\",\n \"0.44622734\",\n \"0.4454868\",\n \"0.44529885\",\n \"0.44459757\",\n \"0.44457835\",\n \"0.4441328\",\n \"0.4440596\",\n \"0.4435347\",\n \"0.44337818\",\n \"0.44314295\",\n \"0.44213167\",\n \"0.4412668\",\n \"0.44091672\",\n \"0.44081798\",\n \"0.4404994\",\n \"0.44041163\",\n \"0.44038698\",\n \"0.4401886\",\n \"0.4401223\",\n \"0.43871608\",\n \"0.4387082\",\n \"0.4378438\",\n \"0.4372773\",\n \"0.4371993\",\n \"0.4370425\",\n \"0.43682024\",\n \"0.43658337\",\n \"0.43596742\",\n \"0.4353401\",\n \"0.4349448\",\n \"0.43488747\",\n \"0.43488744\",\n \"0.43460852\",\n \"0.43416244\",\n \"0.43415275\",\n \"0.4339209\",\n \"0.43301272\",\n \"0.43263757\",\n \"0.43241414\",\n \"0.43238935\",\n \"0.43218496\",\n \"0.43142238\",\n \"0.43141845\",\n \"0.43033308\",\n \"0.42981333\",\n \"0.42948568\",\n \"0.4292998\",\n \"0.42911696\",\n \"0.4283256\",\n \"0.42824557\",\n \"0.42808002\",\n \"0.42764026\",\n \"0.42735225\",\n \"0.42691842\",\n \"0.42672002\",\n \"0.42659274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74647856"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":95586,"cells":{"query":{"kind":"string","value":"Return size of the dataset"},"document":{"kind":"string","value":"def __len__(self):\n return self.get_num_sequence()"},"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 dataset_size(self):\n return self.dataset.size","def __len__(self):\n return self._dataset.size(dirs=self._dirs)","def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n self._hparams.source_dataset.files)\n return self._dataset_size","def __len__(self):\n return self.dataset.shape[0]","def size(self):\r\n return len(self._train_datas)","def size(self, index):\n return self.base_dataset.size(index)","def __len__(self):\n\t\treturn min(len(self.dataset), self.opt.max_dataset_size)","def size(self) -> int:\r\n return self.da.length()","def size(self) -> int:\n size = self.da.length()\n return size","def data_size(self) -> int:\n return len(self.__labels)","def size(self):\n return self.data.size","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def __len__(self):\n return len(self.dataset)","def size(self):\n return len(self.data)","def size(self):\n return len(self.data)","def size(self):\n return len(self.data)","def size(self):\n return len(self.data)","def size(self):\n return len(self.data)","def _get_dataset_size(loader):\n if isinstance(loader, (tuple, list)):\n return len(loader[0].dataset)\n else:\n return len(loader.dataset)","def get_size(self):\n return self._data_size","def __len__(self):\n if not self.opt.union:\n return min(len(self.dataset), self.opt.max_dataset_size)\n else:\n return len(self.batch_sampler)","def size(self):\n return len(self._data)","def size(self):\n ret = 0\n for ii in self.__data:\n ret += int(ii.get_size())\n return ret","def count(self):\r\n return self.data_array.size","def data_count(self):\n return(len(self.data))","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def __len__(self):\n return self.data.num_samples","def __len__(self):\n return int(np.floor(len(self.dataset_df) / self.batch_size))","def size(self):\n\t\t# Better to have this as a method rather than property, as self._dataframe may change\n\t\treturn self._dataframe.shape[0]","def __len__(self):\n ret = self.data.shape[0]\n return ret","def get_size(self):\n return (\n sys.getsizeof(self.children) +\n sys.getsizeof(self.parent) +\n sys.getsizeof(self.dataset_id) +\n sys.getsizeof(self.k) +\n self.filter.get_size()\n )","def __len__(self):\r\n if self.is_superset:\r\n length = 0\r\n for ds in self.data:\r\n length += len(ds)\r\n return length\r\n else:\r\n return len(self.data)","def __get_dataset_size(input_):\n in_type = __get_input_type(input_)\n b_unit = 1024.0 * 1024.0\n if in_type == \"numpy_array\":\n size_in_MB = input_.nbytes / b_unit\n elif in_type == \"hdf\":\n size_in_MB = os.path.getsize(input_) / b_unit\n else:\n list_file = losa.find_file(input_ + \"/*.tif*\")\n if list_file:\n size_1_file = np.asarray(Image.open(list_file[0])).nbytes / b_unit\n else:\n size_1_file = 0.0\n size_in_MB = len(list_file) * size_1_file\n return size_in_MB","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def __len__(self):\n if self.mode.lower() == 'train':\n return len(self.train_data)\n elif self.mode.lower() == 'val':\n return len(self.val_data)\n elif self.mode.lower() == 'test':\n return len(self.test_data)\n else:\n raise RuntimeError(\"Unexpected dataset mode. \"\n \"Supported modes are: train, val and test\")","def __len__(self):\n return len(self.dataset) * self.samples_per_pair","def dataSize(self) -> int:\n return self._dataSize","def get_train_data_size(self):\n return len(self.pipeline.data['train'])","def get_nbytes(dset):\n if 'nbytes' in dset.attrs:\n # look if the dataset has an attribute nbytes\n return dset.attrs['nbytes']\n elif hasattr(dset, 'value'):\n # else extract nbytes from the underlying array\n return dset.size * numpy.zeros(1, dset.dtype).nbytes","def get_data_size(self):\n if self.doc_ftrs is not None:\n data = self.doc_ftrs\n elif self.query_ftrs:\n data = self.query_ftrs\n elif self.usr_ftrs:\n data = self.usr_ftrs\n else:\n raise ValueError('Cannot infer data size.')\n data_shape = tf.shape(data)\n return data_shape[0], data_shape[1]","def size(self):\n return self.dtype.itemsize","def __len__(self):\n if self.mode.lower() == 'train':\n return len(self.train_data)\n if self.mode.lower() == 'val':\n return len(self.val_data)\n if self.mode.lower() == 'test':\n return len(self.test_data)\n\n raise RuntimeError(\"Unexpected dataset mode. \"\n \"Supported modes are: train, val and test\")","def get_total_item_size(dataset):\n total_items = 0\n for element in dataset:\n total_items += 1\n return total_items","def training_dataset_size(self):\n\n if not self.cs_learning and hasattr(FLAGS, 'orig_size'):\n return FLAGS.orig_size\n\n traindata_size_dir = os.path.join(self.cache_path, 'ds_sizes')\n ensure_dir(traindata_size_dir)\n if not hasattr(FLAGS, 'train_split'):\n setattr(FLAGS, 'train_split', 'train')\n\n size_cache_file = os.path.join(traindata_size_dir, '{}_{}'.format(FLAGS.dataset.lower(), FLAGS.train_split))\n\n if os.path.exists(size_cache_file):\n with open(size_cache_file) as f:\n ds_size = int(f.readline().strip())\n else:\n ds = load_ds() # Loads the dataset.\n [data_X, _, _] = ds.load()\n ds_size = len(data_X)\n with open(size_cache_file, 'w') as f:\n f.write(str(ds_size))\n\n return ds_size","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def size(self) -> Tuple[groupable, pdarray]:\n return self.count()","def size(self):\n\t\treturn self.dims","def ndarray_size(self) -> int:\n pass","def nbytes(self):\n\n return self.data.type.datasize","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def size(self):\n return self.N","def __len__(self):\n return len(self.rimgdataset)","def __len__(self):\r\n return len(self.train_data)","def size(self):\n size = 0\n size += self.data.size * sys.getsizeof(self.data)\n return size / 1024.0 / 1024.0 / 1024.0","def size(self):\r\n return self.info().size","def graph_data_size(self) -> int:\n return int(self.graph_tuple_stats.graph_data_size or 0)","def size(self) -> int:","def size() -> int:\n ...","def len (self):\n\t\treturn len (self.data)","def dataDimensions(data):\n logging.info('Number of rows of data: %s' % len(data))\n logging.info('Number of columns of data: %s' % len(data[1]))","def __len__(self) -> int:\n if self.preload:\n return len(self.data_ram)\n else:\n return len(self.data)","def size(self):\n return len(self.records)","def size(self):\r\n return self.__length","def get_valid_data_size(self):\n return len(self.pipeline.data['test'])","def nbytes(self) -> int:\n\n return self.data.nbytes + self.shape.nbytes","def return_size(df):\n return round(sys.getsizeof(df) / 1e9, 2)","def size(self):\n return self.__length","def size(self) -> int:\n num_columns = len(self._internal.data_spark_columns)\n if num_columns == 0:\n return 0\n else:\n return len(self) * num_columns # type: ignore[arg-type]","def dataset_length(data_loader):\n sample = next(iter(data_loader))\n batch_size = None\n\n if isinstance(sample, dict):\n try:\n if isinstance(sample[\"label\"], torch.Tensor):\n batch_size = sample[\"label\"].shape[0]\n else:\n # in case of sequence of inputs use first input\n batch_size = sample[\"label\"][0].shape[0]\n except:\n KeyError(\"Expects key to be 'label'.\")\n else:\n if isinstance(sample[1], torch.Tensor):\n batch_size = sample[1].shape[0]\n else:\n # in case of sequence of inputs use first input\n batch_size = sample[1][0].shape[0]\n return len(data_loader) * batch_size","def size(self):\n pass","def size(self):\n pass","def size(self):\n pass","def length(self, data: Sequence[Sequence[torch.Tensor]]) -> int:\n return self.n_batch","def size(self):\r\n return self.size.data","def size(self):\n return self._N","def __len__(self):\n _, timesteps, height, width = self.data.shape\n height //= self.size\n width //= self.size\n\n if self.subset == 'train':\n out = self.length\n elif self.subset == 'all':\n out = height * width\n else:\n out = (height // 2) * (width // 2)\n\n if not self.time:\n out *= timesteps\n\n return out","def size(self) -> int:\n return self.stat().size","def get_size(self):\n # return the size along the index dimension\n size = 0\n if self._data is not None:\n size = shape(self._data)[self.index_dimension]\n\n return size","def size(self):\n return self._length","def shape(self):\n return self.dataset.shape","def size(self) -> int:\n raise NotImplementedError","def size(self):\n\t\treturn self._size","def __len__(self):\n # type: () -> int\n return len(self.data)","def size(self):\n raise NotImplementedError","def size(self):\n return self.__size","def GetDataSetSize(ds_type, name_len, num_elements, element_multipler):\n\n # Number of bytes in the data type\n datatype_size = 4\n if ds_type == 50: # Byte Datatype\n datatype_size = 1\n elif ds_type == 20: # Int Datatype\n datatype_size = 4\n elif ds_type == 10: # Float Datatype\n datatype_size = 4\n\n return ((num_elements * element_multipler) * datatype_size) + Ensemble.GetBaseDataSize(name_len)","def get_size(self):\n return len(self.table)","def __len__(self):\n return self.sample_df.shape[0]","def __len__(self):\n return self.sample_df.shape[0]","def size(self) -> int:\n return self.length","def __len__(self): \r\n length = len(self.data) - 2* self.skip_window\r\n #print ('length', length)\r\n return length\r\n #raise NotImplementedError('Implement the __len__ method of the dataset')\r","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def __len__(self) -> int:\n return len(self.data)","def length(self):\n return len(self.data)","def length(self):\n return len(self.data)","def length(self):\n return len(self.data)"],"string":"[\n \"def dataset_size(self):\\n return self.dataset.size\",\n \"def __len__(self):\\n return self._dataset.size(dirs=self._dirs)\",\n \"def dataset_size(self):\\n if not self._dataset_size:\\n # pylint: disable=attribute-defined-outside-init\\n self._dataset_size = count_file_lines(\\n self._hparams.source_dataset.files)\\n return self._dataset_size\",\n \"def __len__(self):\\n return self.dataset.shape[0]\",\n \"def size(self):\\r\\n return len(self._train_datas)\",\n \"def size(self, index):\\n return self.base_dataset.size(index)\",\n \"def __len__(self):\\n\\t\\treturn min(len(self.dataset), self.opt.max_dataset_size)\",\n \"def size(self) -> int:\\r\\n return self.da.length()\",\n \"def size(self) -> int:\\n size = self.da.length()\\n return size\",\n \"def data_size(self) -> int:\\n return len(self.__labels)\",\n \"def size(self):\\n return self.data.size\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def __len__(self):\\n return len(self.dataset)\",\n \"def size(self):\\n return len(self.data)\",\n \"def size(self):\\n return len(self.data)\",\n \"def size(self):\\n return len(self.data)\",\n \"def size(self):\\n return len(self.data)\",\n \"def size(self):\\n return len(self.data)\",\n \"def _get_dataset_size(loader):\\n if isinstance(loader, (tuple, list)):\\n return len(loader[0].dataset)\\n else:\\n return len(loader.dataset)\",\n \"def get_size(self):\\n return self._data_size\",\n \"def __len__(self):\\n if not self.opt.union:\\n return min(len(self.dataset), self.opt.max_dataset_size)\\n else:\\n return len(self.batch_sampler)\",\n \"def size(self):\\n return len(self._data)\",\n \"def size(self):\\n ret = 0\\n for ii in self.__data:\\n ret += int(ii.get_size())\\n return ret\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def data_count(self):\\n return(len(self.data))\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def __len__(self):\\n return self.data.num_samples\",\n \"def __len__(self):\\n return int(np.floor(len(self.dataset_df) / self.batch_size))\",\n \"def size(self):\\n\\t\\t# Better to have this as a method rather than property, as self._dataframe may change\\n\\t\\treturn self._dataframe.shape[0]\",\n \"def __len__(self):\\n ret = self.data.shape[0]\\n return ret\",\n \"def get_size(self):\\n return (\\n sys.getsizeof(self.children) +\\n sys.getsizeof(self.parent) +\\n sys.getsizeof(self.dataset_id) +\\n sys.getsizeof(self.k) +\\n self.filter.get_size()\\n )\",\n \"def __len__(self):\\r\\n if self.is_superset:\\r\\n length = 0\\r\\n for ds in self.data:\\r\\n length += len(ds)\\r\\n return length\\r\\n else:\\r\\n return len(self.data)\",\n \"def __get_dataset_size(input_):\\n in_type = __get_input_type(input_)\\n b_unit = 1024.0 * 1024.0\\n if in_type == \\\"numpy_array\\\":\\n size_in_MB = input_.nbytes / b_unit\\n elif in_type == \\\"hdf\\\":\\n size_in_MB = os.path.getsize(input_) / b_unit\\n else:\\n list_file = losa.find_file(input_ + \\\"/*.tif*\\\")\\n if list_file:\\n size_1_file = np.asarray(Image.open(list_file[0])).nbytes / b_unit\\n else:\\n size_1_file = 0.0\\n size_in_MB = len(list_file) * size_1_file\\n return size_in_MB\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def __len__(self):\\n if self.mode.lower() == 'train':\\n return len(self.train_data)\\n elif self.mode.lower() == 'val':\\n return len(self.val_data)\\n elif self.mode.lower() == 'test':\\n return len(self.test_data)\\n else:\\n raise RuntimeError(\\\"Unexpected dataset mode. \\\"\\n \\\"Supported modes are: train, val and test\\\")\",\n \"def __len__(self):\\n return len(self.dataset) * self.samples_per_pair\",\n \"def dataSize(self) -> int:\\n return self._dataSize\",\n \"def get_train_data_size(self):\\n return len(self.pipeline.data['train'])\",\n \"def get_nbytes(dset):\\n if 'nbytes' in dset.attrs:\\n # look if the dataset has an attribute nbytes\\n return dset.attrs['nbytes']\\n elif hasattr(dset, 'value'):\\n # else extract nbytes from the underlying array\\n return dset.size * numpy.zeros(1, dset.dtype).nbytes\",\n \"def get_data_size(self):\\n if self.doc_ftrs is not None:\\n data = self.doc_ftrs\\n elif self.query_ftrs:\\n data = self.query_ftrs\\n elif self.usr_ftrs:\\n data = self.usr_ftrs\\n else:\\n raise ValueError('Cannot infer data size.')\\n data_shape = tf.shape(data)\\n return data_shape[0], data_shape[1]\",\n \"def size(self):\\n return self.dtype.itemsize\",\n \"def __len__(self):\\n if self.mode.lower() == 'train':\\n return len(self.train_data)\\n if self.mode.lower() == 'val':\\n return len(self.val_data)\\n if self.mode.lower() == 'test':\\n return len(self.test_data)\\n\\n raise RuntimeError(\\\"Unexpected dataset mode. \\\"\\n \\\"Supported modes are: train, val and test\\\")\",\n \"def get_total_item_size(dataset):\\n total_items = 0\\n for element in dataset:\\n total_items += 1\\n return total_items\",\n \"def training_dataset_size(self):\\n\\n if not self.cs_learning and hasattr(FLAGS, 'orig_size'):\\n return FLAGS.orig_size\\n\\n traindata_size_dir = os.path.join(self.cache_path, 'ds_sizes')\\n ensure_dir(traindata_size_dir)\\n if not hasattr(FLAGS, 'train_split'):\\n setattr(FLAGS, 'train_split', 'train')\\n\\n size_cache_file = os.path.join(traindata_size_dir, '{}_{}'.format(FLAGS.dataset.lower(), FLAGS.train_split))\\n\\n if os.path.exists(size_cache_file):\\n with open(size_cache_file) as f:\\n ds_size = int(f.readline().strip())\\n else:\\n ds = load_ds() # Loads the dataset.\\n [data_X, _, _] = ds.load()\\n ds_size = len(data_X)\\n with open(size_cache_file, 'w') as f:\\n f.write(str(ds_size))\\n\\n return ds_size\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def size(self) -> Tuple[groupable, pdarray]:\\n return self.count()\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def ndarray_size(self) -> int:\\n pass\",\n \"def nbytes(self):\\n\\n return self.data.type.datasize\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def size(self):\\n return self.N\",\n \"def __len__(self):\\n return len(self.rimgdataset)\",\n \"def __len__(self):\\r\\n return len(self.train_data)\",\n \"def size(self):\\n size = 0\\n size += self.data.size * sys.getsizeof(self.data)\\n return size / 1024.0 / 1024.0 / 1024.0\",\n \"def size(self):\\r\\n return self.info().size\",\n \"def graph_data_size(self) -> int:\\n return int(self.graph_tuple_stats.graph_data_size or 0)\",\n \"def size(self) -> int:\",\n \"def size() -> int:\\n ...\",\n \"def len (self):\\n\\t\\treturn len (self.data)\",\n \"def dataDimensions(data):\\n logging.info('Number of rows of data: %s' % len(data))\\n logging.info('Number of columns of data: %s' % len(data[1]))\",\n \"def __len__(self) -> int:\\n if self.preload:\\n return len(self.data_ram)\\n else:\\n return len(self.data)\",\n \"def size(self):\\n return len(self.records)\",\n \"def size(self):\\r\\n return self.__length\",\n \"def get_valid_data_size(self):\\n return len(self.pipeline.data['test'])\",\n \"def nbytes(self) -> int:\\n\\n return self.data.nbytes + self.shape.nbytes\",\n \"def return_size(df):\\n return round(sys.getsizeof(df) / 1e9, 2)\",\n \"def size(self):\\n return self.__length\",\n \"def size(self) -> int:\\n num_columns = len(self._internal.data_spark_columns)\\n if num_columns == 0:\\n return 0\\n else:\\n return len(self) * num_columns # type: ignore[arg-type]\",\n \"def dataset_length(data_loader):\\n sample = next(iter(data_loader))\\n batch_size = None\\n\\n if isinstance(sample, dict):\\n try:\\n if isinstance(sample[\\\"label\\\"], torch.Tensor):\\n batch_size = sample[\\\"label\\\"].shape[0]\\n else:\\n # in case of sequence of inputs use first input\\n batch_size = sample[\\\"label\\\"][0].shape[0]\\n except:\\n KeyError(\\\"Expects key to be 'label'.\\\")\\n else:\\n if isinstance(sample[1], torch.Tensor):\\n batch_size = sample[1].shape[0]\\n else:\\n # in case of sequence of inputs use first input\\n batch_size = sample[1][0].shape[0]\\n return len(data_loader) * batch_size\",\n \"def size(self):\\n pass\",\n \"def size(self):\\n pass\",\n \"def size(self):\\n pass\",\n \"def length(self, data: Sequence[Sequence[torch.Tensor]]) -> int:\\n return self.n_batch\",\n \"def size(self):\\r\\n return self.size.data\",\n \"def size(self):\\n return self._N\",\n \"def __len__(self):\\n _, timesteps, height, width = self.data.shape\\n height //= self.size\\n width //= self.size\\n\\n if self.subset == 'train':\\n out = self.length\\n elif self.subset == 'all':\\n out = height * width\\n else:\\n out = (height // 2) * (width // 2)\\n\\n if not self.time:\\n out *= timesteps\\n\\n return out\",\n \"def size(self) -> int:\\n return self.stat().size\",\n \"def get_size(self):\\n # return the size along the index dimension\\n size = 0\\n if self._data is not None:\\n size = shape(self._data)[self.index_dimension]\\n\\n return size\",\n \"def size(self):\\n return self._length\",\n \"def shape(self):\\n return self.dataset.shape\",\n \"def size(self) -> int:\\n raise NotImplementedError\",\n \"def size(self):\\n\\t\\treturn self._size\",\n \"def __len__(self):\\n # type: () -> int\\n return len(self.data)\",\n \"def size(self):\\n raise NotImplementedError\",\n \"def size(self):\\n return self.__size\",\n \"def GetDataSetSize(ds_type, name_len, num_elements, element_multipler):\\n\\n # Number of bytes in the data type\\n datatype_size = 4\\n if ds_type == 50: # Byte Datatype\\n datatype_size = 1\\n elif ds_type == 20: # Int Datatype\\n datatype_size = 4\\n elif ds_type == 10: # Float Datatype\\n datatype_size = 4\\n\\n return ((num_elements * element_multipler) * datatype_size) + Ensemble.GetBaseDataSize(name_len)\",\n \"def get_size(self):\\n return len(self.table)\",\n \"def __len__(self):\\n return self.sample_df.shape[0]\",\n \"def __len__(self):\\n return self.sample_df.shape[0]\",\n \"def size(self) -> int:\\n return self.length\",\n \"def __len__(self): \\r\\n length = len(self.data) - 2* self.skip_window\\r\\n #print ('length', length)\\r\\n return length\\r\\n #raise NotImplementedError('Implement the __len__ method of the dataset')\\r\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def __len__(self) -> int:\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\",\n \"def length(self):\\n return len(self.data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8979698","0.8526949","0.82585645","0.81426746","0.8124066","0.81118333","0.8078935","0.80428666","0.8037988","0.8028507","0.8013156","0.80074346","0.80074346","0.80074346","0.80074346","0.7973197","0.7925562","0.7925562","0.7925562","0.7925562","0.7925562","0.79165906","0.7871422","0.7866867","0.78506833","0.78419423","0.7783012","0.77493614","0.7732343","0.76998043","0.76814306","0.7636382","0.7626852","0.7621517","0.7604528","0.7592284","0.7581702","0.75778383","0.75713325","0.75685847","0.75637156","0.753051","0.7523375","0.75054306","0.748043","0.74688375","0.74596196","0.74427867","0.74427867","0.74415475","0.74174124","0.7413286","0.74091834","0.74024034","0.7386499","0.7375304","0.73683214","0.735782","0.7354785","0.7352165","0.73517495","0.73486227","0.7346073","0.73204917","0.7312012","0.73072386","0.730197","0.73018533","0.72806895","0.7279244","0.72775817","0.7276669","0.7272834","0.72649026","0.72649026","0.72649026","0.7259475","0.7243757","0.7239879","0.7235242","0.7230251","0.7227965","0.7226957","0.72254926","0.7218193","0.72177404","0.7217473","0.72159976","0.72117305","0.72080153","0.7205657","0.72025245","0.72025245","0.72000295","0.7198731","0.71976596","0.71976596","0.71976596","0.7196381","0.7196381","0.7196381"],"string":"[\n \"0.8979698\",\n \"0.8526949\",\n \"0.82585645\",\n \"0.81426746\",\n \"0.8124066\",\n \"0.81118333\",\n \"0.8078935\",\n \"0.80428666\",\n \"0.8037988\",\n \"0.8028507\",\n \"0.8013156\",\n \"0.80074346\",\n \"0.80074346\",\n \"0.80074346\",\n \"0.80074346\",\n \"0.7973197\",\n \"0.7925562\",\n \"0.7925562\",\n \"0.7925562\",\n \"0.7925562\",\n \"0.7925562\",\n \"0.79165906\",\n \"0.7871422\",\n \"0.7866867\",\n \"0.78506833\",\n \"0.78419423\",\n \"0.7783012\",\n \"0.77493614\",\n \"0.7732343\",\n \"0.76998043\",\n \"0.76814306\",\n \"0.7636382\",\n \"0.7626852\",\n \"0.7621517\",\n \"0.7604528\",\n \"0.7592284\",\n \"0.7581702\",\n \"0.75778383\",\n \"0.75713325\",\n \"0.75685847\",\n \"0.75637156\",\n \"0.753051\",\n \"0.7523375\",\n \"0.75054306\",\n \"0.748043\",\n \"0.74688375\",\n \"0.74596196\",\n \"0.74427867\",\n \"0.74427867\",\n \"0.74415475\",\n \"0.74174124\",\n \"0.7413286\",\n \"0.74091834\",\n \"0.74024034\",\n \"0.7386499\",\n \"0.7375304\",\n \"0.73683214\",\n \"0.735782\",\n \"0.7354785\",\n \"0.7352165\",\n \"0.73517495\",\n \"0.73486227\",\n \"0.7346073\",\n \"0.73204917\",\n \"0.7312012\",\n \"0.73072386\",\n \"0.730197\",\n \"0.73018533\",\n \"0.72806895\",\n \"0.7279244\",\n \"0.72775817\",\n \"0.7276669\",\n \"0.7272834\",\n \"0.72649026\",\n \"0.72649026\",\n \"0.72649026\",\n \"0.7259475\",\n \"0.7243757\",\n \"0.7239879\",\n \"0.7235242\",\n \"0.7230251\",\n \"0.7227965\",\n \"0.7226957\",\n \"0.72254926\",\n \"0.7218193\",\n \"0.72177404\",\n \"0.7217473\",\n \"0.72159976\",\n \"0.72117305\",\n \"0.72080153\",\n \"0.7205657\",\n \"0.72025245\",\n \"0.72025245\",\n \"0.72000295\",\n \"0.7198731\",\n \"0.71976596\",\n \"0.71976596\",\n \"0.71976596\",\n \"0.7196381\",\n \"0.7196381\",\n \"0.7196381\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95587,"cells":{"query":{"kind":"string","value":"Number of studies in a dataset."},"document":{"kind":"string","value":"def get_num_sequence(self):\n return len(self.study_list)"},"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_num_datasets(self, data):\n dsets = set()\n for items in data:\n dsetid = items[3]\n dsets.add(dsetid)\n return len(dsets)","def count_elements_in_dataset(dataset):\n return dataset.count()","def num_students(self,dd=\"\"):\n\t\tif dd==\"\":\n\t\t\tdd=datadrop.objects.all().filter(cohort=self.cohort)\\\n\t\t\t\t.order_by('-date')[0]\n\t\telif isinstance(dd,str):\n\t\t\tdd=datadrop.objects.get(name=dd,cohort=self.cohort)\n\t\treturn len(grade.objects.filter(subject=self).distinct()\\\n\t\t\t.values_list('upn'))","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def studNumber(self):\n return len(self.students)","def num_test_samples(self):\n if self._num_test_samples is None:\n for key, value in self._test_data.items():\n self._num_test_samples[key] = len(value[0])\n return self._num_test_samples","def get_n_trials(self, study_id: int, state: Optional[TrialState] = None) -> int:\n raise NotImplementedError","def count_samples(self):\n return sum(SEQ_LENGTHS)","def number_of_variables(dataset, name_of_variable):\r\n first_row = dataset[0].keys()\r\n num = 0\r\n for variable in first_row:\r\n if name_of_variable in variable:\r\n num += 1 \r\n return num","def test_set_count(self) -> int:\n return pulumi.get(self, \"test_set_count\")","def _number_of_samples(self):\n return len(self._raw_data.samples)","def _num_samples(x: npt.ArrayLike) -> int:\n if not hasattr(x, \"__len__\") and not hasattr(x, \"shape\"):\n if hasattr(x, \"__array__\"):\n x = np.asarray(x)\n else:\n raise TypeError(\"Expected sequence or array-like, got %s\" % type(x))\n if hasattr(x, \"shape\"):\n if len(x.shape) == 0:\n raise TypeError(\"Singleton array %r cannot be considered\" \" a valid collection.\" % x)\n # Check that shape is returning an integer or default to len\n # Dask dataframes may not return numeric shape[0] value\n if isinstance(x.shape[0], numbers.Integral):\n return x.shape[0]\n else:\n return len(x)\n else:\n return len(x)","def get_number_of_unique_students(self):\n unique_students = set()\n for row in self.responses:\n unique_students.add(row.student)\n return len(unique_students)","def n(self):\n return len(self.data.sites)","def count_scientists(project):\n return project.experiment_set.all().distinct('user').count()","def countSites(self):\n self.ni = len(self.sites)\n return self.ni","def getSampleCount(self,study_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n count=0\n results=con.cursor().callproc('get_sample_count', [study_id,\\\n count])\n \n return results[1]\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def training_set_count(self) -> int:\n return pulumi.get(self, \"training_set_count\")","def getNrStations(self):\n return len(self.stationData)","def count(self):\n return self.data_container.count","def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ndata = 0\n return ndata","def count(self,value = 1):\n n = 0\n for s in self.sample:\n if s == value:\n n += 1\n return n","def getNbStations(self) :\n return len(self._stations)","def num_train_samples(self):\n if self._num_training_samples is None:\n for key, value in self._training_data.items():\n self._num_training_samples[key] = len(value[0])\n return self._num_training_samples","def num_sampled(self):\n return self._historical_data.num_sampled","def getSampleCount(self):\r\n return len(self._data)","def get_num_train_samples(self):\n raise NotImplementedError","def num_samples(self):\n raise NotImplementedError()","def num_classes(self,dd=\"\"):\n\t\tif dd==\"\":\n\t\t\tdd=datadrop.objects.all().filter(cohort=self.cohort)\\\n\t\t\t\t.order_by('-date')[0]\n\t\telif isinstance(dd,str):\n\t\t\tdd=datadrop.objects.get(name=dd,cohort=self.cohort)\n\t\treturn self.classgroup_set.all().count()","def get_number_files(dataset):\n HOME = os.environ['HOME']\n # cmds = ['das_client.py', '--query', 'summary dataset=%s' % dataset, '--format=json',\n # '--key=%s/.globus/userkey.pem' % HOME, '--cert=%s/.globus/usercert.pem' % HOME]\n cmds = ['das_client.py', '--query', 'summary dataset=%s' % dataset, '--format=json']\n output = subprocess.check_output(cmds, stderr=subprocess.STDOUT)\n summary_dict = json.loads(output)\n return int(summary_dict['data'][0]['summary'][0]['nfiles'])","def count_indications(self) -> int:\n return self._count_model(Indication)","def well_count(self):\n return(len(self.wells))","def get_number_of_stools(self):\n return len(self._stools)","def getNumberOfTraces(self) -> int:\n\n if not self.debug:\n self.myFieldFox.write(\"CALC:PAR:COUN?\")\n ret = self.myFieldFox.read()\n else:\n ret = 4\n return ret","def number_of_sites(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"number_of_sites\")","def number_of_sites(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"number_of_sites\")","def get_count(cls):\n total = 0\n for counter in SimpleCounterShard.objects.all():\n total += counter.count\n return total","def get_number_samples(self):\n return self.samples.shape[0]","def count(self):\n\n raise NotImplementedError","def get_num_samples(self):\n return self._num_samples","def data_count(self):\n return(len(self.data))","def get_datasets_count(request):\n organization_id = request.GET.get('organization_id', '')\n datasets_count = Organization.objects.get(\n pk=organization_id).import_records.all().distinct().count()\n\n return {'status': 'success', 'datasets_count': datasets_count}","def get_num_samples(self) -> int:\n # must be implemented in subclass\n raise NotImplementedError","def num_samples(self):\n return self._ll_tree_sequence.get_num_samples()","def __len__(self):\n\n if self.is_finite_set:\n size = 0\n for set in self.sets:\n size += len(set)\n return size\n else:\n raise ValueError(\"'%s' is not a finite set.\" % self)","def __len__(self):\n return self._dataset.size(dirs=self._dirs)","def count():","def datacounts(self):\n return self._properties[\"datacounts\"]","def count_standard_residues(self):\n n = 0\n for na in self.iter_standard_residues():\n n += 1\n return n","def count(self):\r\n return self.data_array.size","def test_count(self):\n return len(self.tests) + sum(suite.test_count for suite in self.suites)","def getSampleCount(self):\r\n return len(self._biom_table.SampleIds)","def count_measurements(database: Database) -> int:\n return int(database.measurements.count_documents(filter={}))","def get_number_of_cheeses(self):\n number = 0\n for i in range(len(self._stools)):\n number += len(self._stools[i])\n return number","def getNumEvents(dbsApi, dset):\n summary = getDsetSummary(dbsApi, dset)\n # it means the dataset was not produced\n if summary[0]['num_file'] == 0:\n return -1\n return summary[0]['num_event']","def __len__(self):\n return self.data.num_samples","def get_location_count_from_studies(cls, studies):\n\n activations = db.session.query(cls.location_id, func.count(cls.pmid\n )).filter(cls.pmid.in_(studies), cls.location_id < 81925\n ).group_by(cls.pmid).all()\n\n return activations","def data_count(self):\r\n\r\n shp = self.df.shape\r\n row_count = shp[0]\r\n return row_count","def GetTrainSampleCount(self) :\r\n\t\ttry :\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['SampleSetCount'],(0,))\r\n\t\t\tCurSampleCount = self.DB_Cursor.fetchone()[0]\r\n\t\texcept Exception as detail:\r\n\t\t\tlogging.error(\"Failed to get count of training samples in database: %s\"%detail)\r\n\t\treturn CurSampleCount","def num_tracked_samples(self, u=None):\n u = self.virtual_root if u is None else u\n return self._ll_tree.get_num_tracked_samples(u)","def N_genes_in_dataset(self):\n return len(self.all_genes_in_dataset)","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def varCount(self, aKind):\n return self.counts[aKind]","def num_streams(self):\n self._num_streams = self.lib.iperf_get_test_num_streams(self._test)\n return self._num_streams","def num_training_examples(self):","def get_num_classes(dataset: str):\n if dataset == \"imagenet\" or dataset == \"kitti\":\n return 1000\n elif dataset == \"cifar10\" or dataset == \"mnist\" or dataset == \"fashion_mnist\":\n return 10","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def studies(self):\n return self._study_queryset","def count_sonata(self):\n return self.run_query(\"count( /mediawiki/page[starts-with (title, 'Sonata') ] )\")","def total_exs(dataset):\n total = 0\n for article in dataset['data']:\n for para in article['paragraphs']:\n total += len(para['qas'])\n return total","def count(self):\n # TODO not implemented yet\n return 0","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def dataCount(self, collectionName):\n count = collectionName.find().count()\n return count","def size(self):\r\n return len(self._train_datas)","def get_num_cams(self, data):\n cams = set()\n for items in data:\n camid = items[2]\n cams.add(camid)\n return len(cams)","def num_samples(self, u=None):\n u = self.virtual_root if u is None else u\n return self._ll_tree.get_num_samples(u)","def num_wells(self):\n return self.info_wells['well'].nunique()","def count(self):\n return self._reduce_for_stat_function(F.count, only_numeric=False)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def file_count(self) -> int:\n if self.dataset is None:\n raise ValueError('No known dataset found!')\n return self._max_file_count","def numPostings(years):\n\tcount = []\n\tfor year in years:\n\t\tfilename = \"SmartEnergy\" +str(year) +\".xlsx\"\n\t\tDB = pd.read_excel(filename, sheet_name = 'Filters')\n\t\tcount.append(DB.iloc[10][1])\n\treturn count","def num_injectors(self):\n injectors = self.info_wells.groupby('well_type').get_group('inj')\n return injectors['well'].nunique()","def n_facets(self):\n return self.n_inequalities()","def count_data_items(fileids, train=True):\n sizes = 28000 if train else 22500\n return len(fileids) * sizes","def getNumStatDataFiles(self):\n return self.nStatDataFiles","def getSegmentCount(self) -> int:\n ...","def size(self, index):\n return self.base_dataset.size(index)","def num_examples(self):\r\n raise NotImplementedError","def getNrSamples(self): \r\n return self.numSamples","def __len__(self):\n if self.mode.lower() == 'train':\n return len(self.train_data)\n elif self.mode.lower() == 'val':\n return len(self.val_data)\n elif self.mode.lower() == 'test':\n return len(self.test_data)\n else:\n raise RuntimeError(\"Unexpected dataset mode. \"\n \"Supported modes are: train, val and test\")","def count(self, value: object) -> int:\n count = 0\n for _ in range(self.da.length()):\n if self.da[_] == value:\n count += 1\n return count","def generic_record_count(data_df: Optional[DataFrame]) -> int:\n return len(data_df)","def count_statements(self):\n query = read_query('content exploration/count_statements')\n response = self._submit_query(query)\n return response[0]['count']['value']","def count(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"count\")","def _count_parties(data_set): #DEMOCRATS, THEN REPUBLICANS\r\n reps = 0\r\n dems = 0\r\n for data_point in data_set:\r\n if data_point.dat_party == \"R\": reps+=1\r\n if data_point.dat_party == \"D\": dems+=1\r\n\r\n return (dems, reps)","def n_replicates(self):\n return self.data.n_replicates.values"],"string":"[\n \"def get_num_datasets(self, data):\\n dsets = set()\\n for items in data:\\n dsetid = items[3]\\n dsets.add(dsetid)\\n return len(dsets)\",\n \"def count_elements_in_dataset(dataset):\\n return dataset.count()\",\n \"def num_students(self,dd=\\\"\\\"):\\n\\t\\tif dd==\\\"\\\":\\n\\t\\t\\tdd=datadrop.objects.all().filter(cohort=self.cohort)\\\\\\n\\t\\t\\t\\t.order_by('-date')[0]\\n\\t\\telif isinstance(dd,str):\\n\\t\\t\\tdd=datadrop.objects.get(name=dd,cohort=self.cohort)\\n\\t\\treturn len(grade.objects.filter(subject=self).distinct()\\\\\\n\\t\\t\\t.values_list('upn'))\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def studNumber(self):\\n return len(self.students)\",\n \"def num_test_samples(self):\\n if self._num_test_samples is None:\\n for key, value in self._test_data.items():\\n self._num_test_samples[key] = len(value[0])\\n return self._num_test_samples\",\n \"def get_n_trials(self, study_id: int, state: Optional[TrialState] = None) -> int:\\n raise NotImplementedError\",\n \"def count_samples(self):\\n return sum(SEQ_LENGTHS)\",\n \"def number_of_variables(dataset, name_of_variable):\\r\\n first_row = dataset[0].keys()\\r\\n num = 0\\r\\n for variable in first_row:\\r\\n if name_of_variable in variable:\\r\\n num += 1 \\r\\n return num\",\n \"def test_set_count(self) -> int:\\n return pulumi.get(self, \\\"test_set_count\\\")\",\n \"def _number_of_samples(self):\\n return len(self._raw_data.samples)\",\n \"def _num_samples(x: npt.ArrayLike) -> int:\\n if not hasattr(x, \\\"__len__\\\") and not hasattr(x, \\\"shape\\\"):\\n if hasattr(x, \\\"__array__\\\"):\\n x = np.asarray(x)\\n else:\\n raise TypeError(\\\"Expected sequence or array-like, got %s\\\" % type(x))\\n if hasattr(x, \\\"shape\\\"):\\n if len(x.shape) == 0:\\n raise TypeError(\\\"Singleton array %r cannot be considered\\\" \\\" a valid collection.\\\" % x)\\n # Check that shape is returning an integer or default to len\\n # Dask dataframes may not return numeric shape[0] value\\n if isinstance(x.shape[0], numbers.Integral):\\n return x.shape[0]\\n else:\\n return len(x)\\n else:\\n return len(x)\",\n \"def get_number_of_unique_students(self):\\n unique_students = set()\\n for row in self.responses:\\n unique_students.add(row.student)\\n return len(unique_students)\",\n \"def n(self):\\n return len(self.data.sites)\",\n \"def count_scientists(project):\\n return project.experiment_set.all().distinct('user').count()\",\n \"def countSites(self):\\n self.ni = len(self.sites)\\n return self.ni\",\n \"def getSampleCount(self,study_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n count=0\\n results=con.cursor().callproc('get_sample_count', [study_id,\\\\\\n count])\\n \\n return results[1]\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def training_set_count(self) -> int:\\n return pulumi.get(self, \\\"training_set_count\\\")\",\n \"def getNrStations(self):\\n return len(self.stationData)\",\n \"def count(self):\\n return self.data_container.count\",\n \"def count_data(self):\\n try:\\n ndata = len(self.x)\\n logger.info(\\\"Number of data points: {0}\\\".format(ndata))\\n except AttributeError:\\n logger.error(\\\"Data object has not been defined\\\")\\n ndata = 0\\n return ndata\",\n \"def count(self,value = 1):\\n n = 0\\n for s in self.sample:\\n if s == value:\\n n += 1\\n return n\",\n \"def getNbStations(self) :\\n return len(self._stations)\",\n \"def num_train_samples(self):\\n if self._num_training_samples is None:\\n for key, value in self._training_data.items():\\n self._num_training_samples[key] = len(value[0])\\n return self._num_training_samples\",\n \"def num_sampled(self):\\n return self._historical_data.num_sampled\",\n \"def getSampleCount(self):\\r\\n return len(self._data)\",\n \"def get_num_train_samples(self):\\n raise NotImplementedError\",\n \"def num_samples(self):\\n raise NotImplementedError()\",\n \"def num_classes(self,dd=\\\"\\\"):\\n\\t\\tif dd==\\\"\\\":\\n\\t\\t\\tdd=datadrop.objects.all().filter(cohort=self.cohort)\\\\\\n\\t\\t\\t\\t.order_by('-date')[0]\\n\\t\\telif isinstance(dd,str):\\n\\t\\t\\tdd=datadrop.objects.get(name=dd,cohort=self.cohort)\\n\\t\\treturn self.classgroup_set.all().count()\",\n \"def get_number_files(dataset):\\n HOME = os.environ['HOME']\\n # cmds = ['das_client.py', '--query', 'summary dataset=%s' % dataset, '--format=json',\\n # '--key=%s/.globus/userkey.pem' % HOME, '--cert=%s/.globus/usercert.pem' % HOME]\\n cmds = ['das_client.py', '--query', 'summary dataset=%s' % dataset, '--format=json']\\n output = subprocess.check_output(cmds, stderr=subprocess.STDOUT)\\n summary_dict = json.loads(output)\\n return int(summary_dict['data'][0]['summary'][0]['nfiles'])\",\n \"def count_indications(self) -> int:\\n return self._count_model(Indication)\",\n \"def well_count(self):\\n return(len(self.wells))\",\n \"def get_number_of_stools(self):\\n return len(self._stools)\",\n \"def getNumberOfTraces(self) -> int:\\n\\n if not self.debug:\\n self.myFieldFox.write(\\\"CALC:PAR:COUN?\\\")\\n ret = self.myFieldFox.read()\\n else:\\n ret = 4\\n return ret\",\n \"def number_of_sites(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"number_of_sites\\\")\",\n \"def number_of_sites(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"number_of_sites\\\")\",\n \"def get_count(cls):\\n total = 0\\n for counter in SimpleCounterShard.objects.all():\\n total += counter.count\\n return total\",\n \"def get_number_samples(self):\\n return self.samples.shape[0]\",\n \"def count(self):\\n\\n raise NotImplementedError\",\n \"def get_num_samples(self):\\n return self._num_samples\",\n \"def data_count(self):\\n return(len(self.data))\",\n \"def get_datasets_count(request):\\n organization_id = request.GET.get('organization_id', '')\\n datasets_count = Organization.objects.get(\\n pk=organization_id).import_records.all().distinct().count()\\n\\n return {'status': 'success', 'datasets_count': datasets_count}\",\n \"def get_num_samples(self) -> int:\\n # must be implemented in subclass\\n raise NotImplementedError\",\n \"def num_samples(self):\\n return self._ll_tree_sequence.get_num_samples()\",\n \"def __len__(self):\\n\\n if self.is_finite_set:\\n size = 0\\n for set in self.sets:\\n size += len(set)\\n return size\\n else:\\n raise ValueError(\\\"'%s' is not a finite set.\\\" % self)\",\n \"def __len__(self):\\n return self._dataset.size(dirs=self._dirs)\",\n \"def count():\",\n \"def datacounts(self):\\n return self._properties[\\\"datacounts\\\"]\",\n \"def count_standard_residues(self):\\n n = 0\\n for na in self.iter_standard_residues():\\n n += 1\\n return n\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def test_count(self):\\n return len(self.tests) + sum(suite.test_count for suite in self.suites)\",\n \"def getSampleCount(self):\\r\\n return len(self._biom_table.SampleIds)\",\n \"def count_measurements(database: Database) -> int:\\n return int(database.measurements.count_documents(filter={}))\",\n \"def get_number_of_cheeses(self):\\n number = 0\\n for i in range(len(self._stools)):\\n number += len(self._stools[i])\\n return number\",\n \"def getNumEvents(dbsApi, dset):\\n summary = getDsetSummary(dbsApi, dset)\\n # it means the dataset was not produced\\n if summary[0]['num_file'] == 0:\\n return -1\\n return summary[0]['num_event']\",\n \"def __len__(self):\\n return self.data.num_samples\",\n \"def get_location_count_from_studies(cls, studies):\\n\\n activations = db.session.query(cls.location_id, func.count(cls.pmid\\n )).filter(cls.pmid.in_(studies), cls.location_id < 81925\\n ).group_by(cls.pmid).all()\\n\\n return activations\",\n \"def data_count(self):\\r\\n\\r\\n shp = self.df.shape\\r\\n row_count = shp[0]\\r\\n return row_count\",\n \"def GetTrainSampleCount(self) :\\r\\n\\t\\ttry :\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['SampleSetCount'],(0,))\\r\\n\\t\\t\\tCurSampleCount = self.DB_Cursor.fetchone()[0]\\r\\n\\t\\texcept Exception as detail:\\r\\n\\t\\t\\tlogging.error(\\\"Failed to get count of training samples in database: %s\\\"%detail)\\r\\n\\t\\treturn CurSampleCount\",\n \"def num_tracked_samples(self, u=None):\\n u = self.virtual_root if u is None else u\\n return self._ll_tree.get_num_tracked_samples(u)\",\n \"def N_genes_in_dataset(self):\\n return len(self.all_genes_in_dataset)\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def varCount(self, aKind):\\n return self.counts[aKind]\",\n \"def num_streams(self):\\n self._num_streams = self.lib.iperf_get_test_num_streams(self._test)\\n return self._num_streams\",\n \"def num_training_examples(self):\",\n \"def get_num_classes(dataset: str):\\n if dataset == \\\"imagenet\\\" or dataset == \\\"kitti\\\":\\n return 1000\\n elif dataset == \\\"cifar10\\\" or dataset == \\\"mnist\\\" or dataset == \\\"fashion_mnist\\\":\\n return 10\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def studies(self):\\n return self._study_queryset\",\n \"def count_sonata(self):\\n return self.run_query(\\\"count( /mediawiki/page[starts-with (title, 'Sonata') ] )\\\")\",\n \"def total_exs(dataset):\\n total = 0\\n for article in dataset['data']:\\n for para in article['paragraphs']:\\n total += len(para['qas'])\\n return total\",\n \"def count(self):\\n # TODO not implemented yet\\n return 0\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def dataCount(self, collectionName):\\n count = collectionName.find().count()\\n return count\",\n \"def size(self):\\r\\n return len(self._train_datas)\",\n \"def get_num_cams(self, data):\\n cams = set()\\n for items in data:\\n camid = items[2]\\n cams.add(camid)\\n return len(cams)\",\n \"def num_samples(self, u=None):\\n u = self.virtual_root if u is None else u\\n return self._ll_tree.get_num_samples(u)\",\n \"def num_wells(self):\\n return self.info_wells['well'].nunique()\",\n \"def count(self):\\n return self._reduce_for_stat_function(F.count, only_numeric=False)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def file_count(self) -> int:\\n if self.dataset is None:\\n raise ValueError('No known dataset found!')\\n return self._max_file_count\",\n \"def numPostings(years):\\n\\tcount = []\\n\\tfor year in years:\\n\\t\\tfilename = \\\"SmartEnergy\\\" +str(year) +\\\".xlsx\\\"\\n\\t\\tDB = pd.read_excel(filename, sheet_name = 'Filters')\\n\\t\\tcount.append(DB.iloc[10][1])\\n\\treturn count\",\n \"def num_injectors(self):\\n injectors = self.info_wells.groupby('well_type').get_group('inj')\\n return injectors['well'].nunique()\",\n \"def n_facets(self):\\n return self.n_inequalities()\",\n \"def count_data_items(fileids, train=True):\\n sizes = 28000 if train else 22500\\n return len(fileids) * sizes\",\n \"def getNumStatDataFiles(self):\\n return self.nStatDataFiles\",\n \"def getSegmentCount(self) -> int:\\n ...\",\n \"def size(self, index):\\n return self.base_dataset.size(index)\",\n \"def num_examples(self):\\r\\n raise NotImplementedError\",\n \"def getNrSamples(self): \\r\\n return self.numSamples\",\n \"def __len__(self):\\n if self.mode.lower() == 'train':\\n return len(self.train_data)\\n elif self.mode.lower() == 'val':\\n return len(self.val_data)\\n elif self.mode.lower() == 'test':\\n return len(self.test_data)\\n else:\\n raise RuntimeError(\\\"Unexpected dataset mode. \\\"\\n \\\"Supported modes are: train, val and test\\\")\",\n \"def count(self, value: object) -> int:\\n count = 0\\n for _ in range(self.da.length()):\\n if self.da[_] == value:\\n count += 1\\n return count\",\n \"def generic_record_count(data_df: Optional[DataFrame]) -> int:\\n return len(data_df)\",\n \"def count_statements(self):\\n query = read_query('content exploration/count_statements')\\n response = self._submit_query(query)\\n return response[0]['count']['value']\",\n \"def count(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"count\\\")\",\n \"def _count_parties(data_set): #DEMOCRATS, THEN REPUBLICANS\\r\\n reps = 0\\r\\n dems = 0\\r\\n for data_point in data_set:\\r\\n if data_point.dat_party == \\\"R\\\": reps+=1\\r\\n if data_point.dat_party == \\\"D\\\": dems+=1\\r\\n\\r\\n return (dems, reps)\",\n \"def n_replicates(self):\\n return self.data.n_replicates.values\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6843366","0.67893463","0.6728229","0.64195675","0.62901825","0.6255575","0.6206059","0.6124002","0.61171126","0.6110871","0.6106557","0.6096237","0.607423","0.60537356","0.6051849","0.60323846","0.6030147","0.60260516","0.5990028","0.59870434","0.5966542","0.59301263","0.5929231","0.59264326","0.5924072","0.59232503","0.59170884","0.5909757","0.59087133","0.58707654","0.58639145","0.5838329","0.5830604","0.5825748","0.58236796","0.58236796","0.581947","0.5813168","0.5812991","0.581176","0.5810716","0.579176","0.5789328","0.57783586","0.5777259","0.57734346","0.5768192","0.57652175","0.5763228","0.5762","0.5760115","0.5749804","0.5736761","0.57253957","0.57211304","0.57150424","0.56988484","0.5678725","0.5677924","0.56739366","0.5666858","0.56617445","0.56469136","0.56468403","0.5643477","0.56390226","0.5639004","0.5639004","0.5639004","0.5639004","0.5638628","0.5637878","0.5631459","0.56283975","0.5628013","0.56242687","0.562272","0.5621303","0.56212354","0.56204736","0.56096065","0.5594964","0.5594964","0.55898833","0.5582909","0.5580671","0.55763626","0.5574547","0.55739397","0.5566914","0.55475193","0.55459744","0.5543035","0.55397576","0.55382884","0.5537173","0.5536857","0.55340225","0.5530099","0.552877"],"string":"[\n \"0.6843366\",\n \"0.67893463\",\n \"0.6728229\",\n \"0.64195675\",\n \"0.62901825\",\n \"0.6255575\",\n \"0.6206059\",\n \"0.6124002\",\n \"0.61171126\",\n \"0.6110871\",\n \"0.6106557\",\n \"0.6096237\",\n \"0.607423\",\n \"0.60537356\",\n \"0.6051849\",\n \"0.60323846\",\n \"0.6030147\",\n \"0.60260516\",\n \"0.5990028\",\n \"0.59870434\",\n \"0.5966542\",\n \"0.59301263\",\n \"0.5929231\",\n \"0.59264326\",\n \"0.5924072\",\n \"0.59232503\",\n \"0.59170884\",\n \"0.5909757\",\n \"0.59087133\",\n \"0.58707654\",\n \"0.58639145\",\n \"0.5838329\",\n \"0.5830604\",\n \"0.5825748\",\n \"0.58236796\",\n \"0.58236796\",\n \"0.581947\",\n \"0.5813168\",\n \"0.5812991\",\n \"0.581176\",\n \"0.5810716\",\n \"0.579176\",\n \"0.5789328\",\n \"0.57783586\",\n \"0.5777259\",\n \"0.57734346\",\n \"0.5768192\",\n \"0.57652175\",\n \"0.5763228\",\n \"0.5762\",\n \"0.5760115\",\n \"0.5749804\",\n \"0.5736761\",\n \"0.57253957\",\n \"0.57211304\",\n \"0.57150424\",\n \"0.56988484\",\n \"0.5678725\",\n \"0.5677924\",\n \"0.56739366\",\n \"0.5666858\",\n \"0.56617445\",\n \"0.56469136\",\n \"0.56468403\",\n \"0.5643477\",\n \"0.56390226\",\n \"0.5639004\",\n \"0.5639004\",\n \"0.5639004\",\n \"0.5639004\",\n \"0.5638628\",\n \"0.5637878\",\n \"0.5631459\",\n \"0.56283975\",\n \"0.5628013\",\n \"0.56242687\",\n \"0.562272\",\n \"0.5621303\",\n \"0.56212354\",\n \"0.56204736\",\n \"0.56096065\",\n \"0.5594964\",\n \"0.5594964\",\n \"0.55898833\",\n \"0.5582909\",\n \"0.5580671\",\n \"0.55763626\",\n \"0.5574547\",\n \"0.55739397\",\n \"0.5566914\",\n \"0.55475193\",\n \"0.55459744\",\n \"0.5543035\",\n \"0.55397576\",\n \"0.55382884\",\n \"0.5537173\",\n \"0.5536857\",\n \"0.55340225\",\n \"0.5530099\",\n \"0.552877\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55716085"},"document_rank":{"kind":"string","value":"89"}}},{"rowIdx":95588,"cells":{"query":{"kind":"string","value":"Name of the dataset."},"document":{"kind":"string","value":"def get_name(self):\n raise NotImplementedError"},"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 dataset_name(self):\n return self.dataset.name","def dataset_name(self):\n return self._dataset_name","def get_dataset_name(self):\n raise NotImplementedError","def get_dataset_name(self):\n return self.dataset_name","def __get_dataset_name(self):\n d = gdal.Open(self.fname)\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n\n if 'data_var' in md:\n return md['data_var']\n else:\n fnames = d.GetFileList()\n if len(fnames) > 2:\n d = gdal.Open(fnames[1])\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n if 'data_var' in md:\n return md['data_var']\n else:\n return 'data'\n else:\n return 'data'","def _dataset_name(self):\n return f'Libri{self.task}Mix'","def construct_dataset_name(self, *args):\n raise NotImplementedError","def get_archive_name(self) -> str:\n # TODO: Support for user-defined or metadata-based (e.g. title) name\n return \"dataset\"","def get_dataset_name():\n return os.getenv(\"AICROWD_DATASET_NAME\", \"cars3d\")","def name(self):\n return 'data_extraction_for_' + '_'.join(self.names).lower()","def dataset_id(self) -> str:\n return self._dataset_id","def dataset_id(self) -> str:\n return pulumi.get(self, \"dataset_id\")","def dataset_id(self) -> str:\n return pulumi.get(self, \"dataset_id\")","def dataset_id(self) -> str:\n return pulumi.get(self, \"dataset_id\")","def get_data_name(self, idx):\n name = None\n if type(idx) is int:\n n = self.data_count()\n assert 0 <= idx <= n - 1, \"Bad data index\"\n name = self.data[idx].name\n return(name)","def dataset_names(self) -> List[str]:\n return list(self._datasets.keys())","def data_name(self):\n return \"Bispectrum\"","def get_datasetID(self):\n\t\treturn self.dsDoc['about']['datasetID']","def data_filename(self) -> str: # type: ignore[return-value]\n return os.path.abspath(self.name) # type: ignore","def name(self) -> str:\n return self.data['name']","def dataName(self, role):\n return None","def name(self):\n return self._data.get('name')","def name(self):\n return self._data.get('name')","def name(self):\n pass","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self) -> str:\n pass","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self) -> str:\n return self._id_data.get(\"name\", \"\")","def unique_dataset_name(prefix: str = \"selenium-dataset\"):\n return f'{prefix}-{uuid.uuid4().hex[:8]}'","def name(self):\n raise NotImplementedError # pragma: no cover","def name(self):\r\n return self._data['name']","def getCoaddDatasetName(self):\n warpType = self.config.warpType\n suffix = \"\" if warpType == \"direct\" else warpType[0].upper() + warpType[1:]\n return self.config.coaddName + \"Coadd\" + suffix","def dataset_by_name(name):\n return _datasets[name.lower()]","def get_datasetID(self):\n\t\treturn self.prDoc['inputs']['data'][0]['datasetID']","def Name(self, default=None):\n return self.data.get('name', default)","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self) -> str:\n raise NotImplementedError","def set_filename(self, name):\n self.ds_filename = name","def data_center_name(self) -> str:\n return pulumi.get(self, \"data_center_name\")","def name(self):\r\n pass","def get_dataset(name):\n if name == 'cityscapes':\n return Cityscapes","def name(self):\n return self.NAME","def name(self):\n raise NotImplementedError()","def name(self):\n raise NotImplementedError()","def get_dataset_names(self, include = ['*'], exclude = []):\n \n raise NotImplementedError('get_dataset_names')","def name (self):\n return self._name","def get_filename(self):\n return self.ds_filename","def name(self):\n return self._filename","def name(self):\n\t\treturn self._name","def name(self):\n\t\treturn self._name","def name(self):\r\n return self.data[\"name\"]","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def dataset_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"dataset_id\")","def name(self) -> str:\n raise NotImplementedError()","def get_name(self):\n pass","def get_name(self):\n pass","def get_dataset(self):\n return","def name(self, the_name):\n if (len(the_name) < TempDataset.MIN_LEN\n or len(the_name) > TempDataset.MAX_LEN):\n raise ValueError\n self._name = the_name","def name(self):\n return None","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name","def name(self):\n return self._name"],"string":"[\n \"def dataset_name(self):\\n return self.dataset.name\",\n \"def dataset_name(self):\\n return self._dataset_name\",\n \"def get_dataset_name(self):\\n raise NotImplementedError\",\n \"def get_dataset_name(self):\\n return self.dataset_name\",\n \"def __get_dataset_name(self):\\n d = gdal.Open(self.fname)\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n fnames = d.GetFileList()\\n if len(fnames) > 2:\\n d = gdal.Open(fnames[1])\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n return 'data'\\n else:\\n return 'data'\",\n \"def _dataset_name(self):\\n return f'Libri{self.task}Mix'\",\n \"def construct_dataset_name(self, *args):\\n raise NotImplementedError\",\n \"def get_archive_name(self) -> str:\\n # TODO: Support for user-defined or metadata-based (e.g. title) name\\n return \\\"dataset\\\"\",\n \"def get_dataset_name():\\n return os.getenv(\\\"AICROWD_DATASET_NAME\\\", \\\"cars3d\\\")\",\n \"def name(self):\\n return 'data_extraction_for_' + '_'.join(self.names).lower()\",\n \"def dataset_id(self) -> str:\\n return self._dataset_id\",\n \"def dataset_id(self) -> str:\\n return pulumi.get(self, \\\"dataset_id\\\")\",\n \"def dataset_id(self) -> str:\\n return pulumi.get(self, \\\"dataset_id\\\")\",\n \"def dataset_id(self) -> str:\\n return pulumi.get(self, \\\"dataset_id\\\")\",\n \"def get_data_name(self, idx):\\n name = None\\n if type(idx) is int:\\n n = self.data_count()\\n assert 0 <= idx <= n - 1, \\\"Bad data index\\\"\\n name = self.data[idx].name\\n return(name)\",\n \"def dataset_names(self) -> List[str]:\\n return list(self._datasets.keys())\",\n \"def data_name(self):\\n return \\\"Bispectrum\\\"\",\n \"def get_datasetID(self):\\n\\t\\treturn self.dsDoc['about']['datasetID']\",\n \"def data_filename(self) -> str: # type: ignore[return-value]\\n return os.path.abspath(self.name) # type: ignore\",\n \"def name(self) -> str:\\n return self.data['name']\",\n \"def dataName(self, role):\\n return None\",\n \"def name(self):\\n return self._data.get('name')\",\n \"def name(self):\\n return self._data.get('name')\",\n \"def name(self):\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self) -> str:\\n pass\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self) -> str:\\n return self._id_data.get(\\\"name\\\", \\\"\\\")\",\n \"def unique_dataset_name(prefix: str = \\\"selenium-dataset\\\"):\\n return f'{prefix}-{uuid.uuid4().hex[:8]}'\",\n \"def name(self):\\n raise NotImplementedError # pragma: no cover\",\n \"def name(self):\\r\\n return self._data['name']\",\n \"def getCoaddDatasetName(self):\\n warpType = self.config.warpType\\n suffix = \\\"\\\" if warpType == \\\"direct\\\" else warpType[0].upper() + warpType[1:]\\n return self.config.coaddName + \\\"Coadd\\\" + suffix\",\n \"def dataset_by_name(name):\\n return _datasets[name.lower()]\",\n \"def get_datasetID(self):\\n\\t\\treturn self.prDoc['inputs']['data'][0]['datasetID']\",\n \"def Name(self, default=None):\\n return self.data.get('name', default)\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self) -> str:\\n raise NotImplementedError\",\n \"def set_filename(self, name):\\n self.ds_filename = name\",\n \"def data_center_name(self) -> str:\\n return pulumi.get(self, \\\"data_center_name\\\")\",\n \"def name(self):\\r\\n pass\",\n \"def get_dataset(name):\\n if name == 'cityscapes':\\n return Cityscapes\",\n \"def name(self):\\n return self.NAME\",\n \"def name(self):\\n raise NotImplementedError()\",\n \"def name(self):\\n raise NotImplementedError()\",\n \"def get_dataset_names(self, include = ['*'], exclude = []):\\n \\n raise NotImplementedError('get_dataset_names')\",\n \"def name (self):\\n return self._name\",\n \"def get_filename(self):\\n return self.ds_filename\",\n \"def name(self):\\n return self._filename\",\n \"def name(self):\\n\\t\\treturn self._name\",\n \"def name(self):\\n\\t\\treturn self._name\",\n \"def name(self):\\r\\n return self.data[\\\"name\\\"]\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def dataset_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"dataset_id\\\")\",\n \"def name(self) -> str:\\n raise NotImplementedError()\",\n \"def get_name(self):\\n pass\",\n \"def get_name(self):\\n pass\",\n \"def get_dataset(self):\\n return\",\n \"def name(self, the_name):\\n if (len(the_name) < TempDataset.MIN_LEN\\n or len(the_name) > TempDataset.MAX_LEN):\\n raise ValueError\\n self._name = the_name\",\n \"def name(self):\\n return None\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\",\n \"def name(self):\\n return self._name\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.919469","0.8976905","0.87083614","0.8686752","0.7850114","0.7471211","0.7451666","0.74262846","0.7378664","0.73779565","0.7199527","0.70992815","0.70992815","0.70992815","0.6962095","0.6886322","0.6757635","0.6693697","0.667641","0.6673114","0.6660524","0.6659455","0.6659455","0.66143054","0.6558511","0.6558511","0.6558511","0.6558511","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.6557192","0.65350753","0.65318155","0.6513573","0.65109646","0.6504513","0.6493975","0.64806944","0.6479034","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6477732","0.6469988","0.6446719","0.64436626","0.64417636","0.64365053","0.64120686","0.64061016","0.64061016","0.6403698","0.6403677","0.6396787","0.6395468","0.6389454","0.6389454","0.6386928","0.6381647","0.6381647","0.6381647","0.6381647","0.6381647","0.6381647","0.6381647","0.6377967","0.63692284","0.6368052","0.6368052","0.6364419","0.63530654","0.6351876","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074","0.63485074"],"string":"[\n \"0.919469\",\n \"0.8976905\",\n \"0.87083614\",\n \"0.8686752\",\n \"0.7850114\",\n \"0.7471211\",\n \"0.7451666\",\n \"0.74262846\",\n \"0.7378664\",\n \"0.73779565\",\n \"0.7199527\",\n \"0.70992815\",\n \"0.70992815\",\n \"0.70992815\",\n \"0.6962095\",\n \"0.6886322\",\n \"0.6757635\",\n \"0.6693697\",\n \"0.667641\",\n \"0.6673114\",\n \"0.6660524\",\n \"0.6659455\",\n \"0.6659455\",\n \"0.66143054\",\n \"0.6558511\",\n \"0.6558511\",\n \"0.6558511\",\n \"0.6558511\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.6557192\",\n \"0.65350753\",\n \"0.65318155\",\n \"0.6513573\",\n \"0.65109646\",\n \"0.6504513\",\n \"0.6493975\",\n \"0.64806944\",\n \"0.6479034\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6477732\",\n \"0.6469988\",\n \"0.6446719\",\n \"0.64436626\",\n \"0.64417636\",\n \"0.64365053\",\n \"0.64120686\",\n \"0.64061016\",\n \"0.64061016\",\n \"0.6403698\",\n \"0.6403677\",\n \"0.6396787\",\n \"0.6395468\",\n \"0.6389454\",\n \"0.6389454\",\n \"0.6386928\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6381647\",\n \"0.6377967\",\n \"0.63692284\",\n \"0.6368052\",\n \"0.6368052\",\n \"0.6364419\",\n \"0.63530654\",\n \"0.6351876\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\",\n \"0.63485074\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95589,"cells":{"query":{"kind":"string","value":"Not to be used! Check get_frames() instead."},"document":{"kind":"string","value":"def __getitem__(self, item):\n return None"},"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 frames():\n raise RuntimeError('Must be implemented by subclasses.')","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def process_frames(self, data):\n pass","def dispatch_frame(self, frame):","def frame(self):","def onFrameUpdated(self):\n pass","def __init__(self, frames):\n self._frames = frames","def __init__(self, frames):\n self._frames = frames","def __init__(self, frames):\n self._frames = frames","def __init__(self, frames):\n self._frames = frames","def get_frame(self):\n\t\tframe = None\n\t\twhile not frame:","def process_frame(self, frame):\n\t\treturn frame","def _get_frame(self, key):\n pass","def _getframe(depth=None): # real signature unknown; restored from __doc__\n pass","def get_frame(self, ind):\n pass","def __init__(self, frames):\n self._frames = frames\n self._out = None","def __init__(self, frames):\n self._frames = frames\n self._out = None","def __init__(self, frames):\n self._frames = frames\n self._out = None","def __init__(self, frames):\n self._frames = frames\n self._out = None","def __init__(self, frames):\n self._frames = frames\n self._out = None","def __init__(self, frames):\n self._frames = frames\n self._out = None","def process_frame():\n return \"OK\"","def onMessageFrameEnd(self):","def onMessageFrameBegin(self, length):","def _current_frames(): # real signature unknown; restored from __doc__\n return {}","def hasCurrentFrame(self):\n if self.currentFrame == []:\n return False\n return True","def parse_frames(self):\r\n done = False\r\n self._ip = 13 + self.ct_len\r\n while not done:\r\n code = self.next_byte()\r\n if not code:\r\n raise ValueError(\"Unexcepted end of file\")\r\n if code == b\"\\x2C\":\r\n self.parse_frame()\r\n elif code == b\"\\x21\":\r\n code = self.next_byte()\r\n if code == b\"\\xF9\":\r\n self.g_ext.append(self.parse_gce())\r\n elif code == b\"\\xFF\":\r\n self.next_byte()\r\n app = self.next_bytes(11)\r\n if app == b\"NETSCAPE2.0\":\r\n self.parse_ne()\r\n else:\r\n self.skip()\r\n elif code == b\"\\xFE\":\r\n self.comments.append(self.parse_ce())\r\n else:\r\n self.next_bytes(13)\r\n self.skip()\r\n elif code == b\"\\x3B\":\r\n done = True","def __init__(self, frame):\n super().__init__(frame)\n self.frames = None\n self.delay = None","def init_all_frames(self) -> bool:\n raise NotImplementedError","def inspect_frame(self, frame):\n while frame:\n self.inspect_single_frame(frame)\n frame = frame.f_back","def frames(self) -> Optional[Tuple[int, ...]]:\n return self._frames","def available_frames(self):\n if self._pipeline:\n #return [getattr(frame[0], \"name\", frame[0]) for frame in self._pipeline]\n return [step.frame if isinstance(step.frame, str) else step.frame.name for step in self._pipeline ]\n else:\n return None","def frame_available(self):\n return type(self._frame) != type(None)","def change_frame(self, frame):\r\n pass","def _request_frame(self):\n self._send_command('GET_FRAME')","def frames(self):\n return self._frames","def testAnimationBFrames(self):\n try:\n bFramesValue = int(self.bFrames)\n except ValueError:\n self.assertNotEqual(\n self.bFrames,\n self.config.bFrames\n )\n self.assertEqual(\n None,\n self.config.bFrames\n )\n else:\n self.assertEqual(\n bFramesValue,\n self.config.bFrames\n )","def frames(self) -> Set[int]:\n return self._frames","def get_frame(self):\n return self.frames.get()","def isGoodFrame(self, frame):\n if max(frame)<0.1:\n return False\n return True","def __init__(self, frames=[], loop = 0):\n\t\t\n\t\tif isinstance(frames, (list, tuple)):\n\t\t\tself.frames = frames\n\t\telse:\n\t\t\traise TypeError\n\t\t\t\n\t\tif not loop:\n\t\t\tself.loop = 0\n\t\telse:\n\t\t\tself.loop = 1\n\t\t\t\n\t\tself.present_frame = None","def count_frames():\n frames = sentence.sem.frames.find_all('frame', {'name' : NEGATION_FRAME_NAME})\n frame_count = []\n for f_r in frames:\n frame_count.append(f_r)\n return len(frame_count)","def _test_for_playback_frame_errors(self):\n steps = self.program.steps\n for s in steps:\n for index, pb_frame in enumerate(s.playback_frames):\n self.assertEqual(pb_frame.error, 0,\n f\"Step {s.name} frame number {index} has a simulation error: {pb_frame.error_string}\")","def _process(self, frame, **kwargs):\n raise NotImplementedError()","def __init__(self, frame):\n self.frame = frame","def EventFrame (self):\n pass","def get(self):\n return self.frames","def check_queues(self) -> int:\r\n\r\n nframes = 0\r\n\r\n for queue in self.receive_queues:\r\n if not queue.empty():\r\n nframes += 1\r\n frame, img_bytes = queue.get_nowait()\r\n\r\n if frame < self.next_frame:\r\n raise ValueError('received frame we already processed! '\r\n + f'got {frame}, at {self.next_frame}')\r\n if frame in self.ooo_frames:\r\n raise ValueError(f'received duplicate frame: {frame}')\r\n\r\n self.ooo_frames[frame] = img_bytes\r\n if len(self.ooo_frames) > self.max_ooo_frames:\r\n raise ValueError('exceeded maximum frame cache (now have '\r\n + f'{len(self.ooo_frames)} frames waiting)')\r\n\r\n return nframes","def captured_frames(self):\n return self._captured_frames","def CHECK_transition_frames(self):\n tr_frames = []\n for i, frame in enumerate(self.y):\n if not np.all(frame == frame[0]):\n tr_frames.append(frame)\n\n print('there are ', len(tr_frames), ' frames containing a transition')\n return tr_frames","def frames(self):\n return list(self._frames)","def get_frame(self, frame):\n return self.frames[frame]","def num_frames(self):\n return len(self.video)","def getFrames():\n\t\tfor cam in Camera.CAMERAS: cam.getFrame()","def get_frame_list(self):\r\n\r\n logger.debug('Executing frame extraction')\r\n\r\n frames_loaded = False\r\n\r\n # Try to load YAML file with frame list\r\n if os.path.exists(self.frames_file_path):\r\n\r\n print 'Loading YAML file with frame list'\r\n logger.debug('Loading YAML file with frame list')\r\n\r\n f_list = utils.load_YAML_file(self.frames_file_path)\r\n\r\n if f_list:\r\n self.frame_list = f_list\r\n\r\n print 'YAML file with frame_list loaded'\r\n logger.debug('YAML file with frame_list loaded')\r\n\r\n frames_loaded = True\r\n\r\n if not frames_loaded:\r\n\r\n print '\\n\\n### Frame extraction ###\\n'\r\n logger.debug('\\n\\n### Frame extraction ###\\n')\r\n\r\n # Save processing time\r\n start_time = cv2.getTickCount()\r\n\r\n if not (os.path.exists(self.frames_path)):\r\n os.makedirs(self.frames_path)\r\n\r\n # Counter for all frames\r\n frame_counter = 0\r\n\r\n # Value of frame_counter for last analyzed frame\r\n last_anal_frame = 0\r\n\r\n # Open video file\r\n capture = cv2.VideoCapture(self.resource_path)\r\n\r\n self.frame_list = []\r\n\r\n # Save parameters for this video\r\n param_dict = {}\r\n\r\n if capture is None or not capture.isOpened():\r\n\r\n error = 'Error in opening video file'\r\n\r\n print error\r\n logger.debug(error)\r\n\r\n return\r\n\r\n else:\r\n\r\n video_fps = capture.get(cv2.cv.CV_CAP_PROP_FPS)\r\n\r\n param_dict[c.VIDEO_FPS_KEY] = video_fps\r\n\r\n # Original number of frames\r\n tot_frames = capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)\r\n\r\n param_dict[c.VIDEO_TOT_FRAMES_KEY] = tot_frames\r\n\r\n self.fps = video_fps\r\n\r\n self.video_frames = float(tot_frames)\r\n\r\n # Saved frames\r\n saved_frames = 0\r\n\r\n while True:\r\n\r\n # Read frame\r\n ret, frame = capture.read()\r\n\r\n # If no frame is read, abort\r\n if not ret:\r\n break\r\n\r\n used_fps = c.USED_FPS\r\n use_or_fps = c.USE_ORIGINAL_FPS\r\n use_or_res = c.USE_ORIGINAL_RES\r\n used_res_scale_factor = c.USED_RES_SCALE_FACTOR\r\n\r\n if self.params is not None:\r\n\r\n if c.USED_FPS_KEY in self.params:\r\n used_fps = self.params[c.USED_FPS_KEY]\r\n\r\n if c.USE_ORIGINAL_FPS_KEY in self.params:\r\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\r\n\r\n if c.USE_ORIGINAL_RES_KEY in self.params:\r\n use_or_res = self.params[c.USE_ORIGINAL_RES_KEY]\r\n\r\n if c.USED_RES_SCALE_FACTOR_KEY in self.params:\r\n used_res_scale_factor = self.params[\r\n c.USED_RES_SCALE_FACTOR_KEY]\r\n\r\n # Next frame to be analyzed\r\n next_frame = last_anal_frame + (video_fps / used_fps) - 1\r\n\r\n if use_or_fps or (frame_counter > next_frame):\r\n\r\n # Frame position in video in milliseconds\r\n elapsed_ms = capture.get(cv2.cv.CV_CAP_PROP_POS_MSEC)\r\n\r\n # print 'elapsed video s =', elapsed_video_s\r\n\r\n fr_name = '%07d.png' % frame_counter\r\n\r\n frame_path = os.path.join(self.frames_path, fr_name)\r\n\r\n # Resize frame\r\n if not use_or_res:\r\n fx = used_res_scale_factor\r\n\r\n fy = used_res_scale_factor\r\n\r\n interp = cv2.INTER_AREA\r\n\r\n frame = cv2.resize(src=frame, dsize=(0, 0),\r\n fx=fx, fy=fy,\r\n interpolation=interp)\r\n\r\n cv2.imwrite(frame_path, frame,\r\n [cv.CV_IMWRITE_PNG_COMPRESSION, 0])\r\n\r\n frame_dict = {c.SAVED_FRAME_NAME_KEY: fr_name,\r\n c.ELAPSED_VIDEO_TIME_KEY: int(elapsed_ms)}\r\n\r\n self.frame_list.append(frame_dict)\r\n\r\n last_anal_frame = frame_counter\r\n\r\n saved_frames += 1\r\n\r\n frame_counter += 1\r\n\r\n self.progress = 100 * (frame_counter / self.video_frames)\r\n\r\n print('progress: ' + str(self.progress) + ' % \\r'),\r\n\r\n del capture\r\n\r\n self.saved_frames = float(saved_frames)\r\n\r\n param_dict[c.VIDEO_SAVED_FRAMES_KEY] = self.saved_frames\r\n\r\n # Save frame list in YAML file\r\n utils.save_YAML_file(self.frames_file_path, self.frame_list)\r\n\r\n # Save video parameters in YAML file\r\n\r\n utils.save_YAML_file(self.params_file_path, param_dict)\r\n\r\n # Save processing time\r\n time_in_clocks = cv2.getTickCount() - start_time\r\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\r\n\r\n print 'Time for frame extraction:', str(time_in_seconds), 's\\n'\r\n logger.debug(\r\n 'Time for frame extraction:', str(time_in_seconds), 's\\n')\r\n\r\n self.anal_times[c.FRAME_EXTRACTION_TIME_KEY] = time_in_seconds\r\n\r\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)","def half_frame(self) -> None:\n pass","def half_frame(self) -> None:\n pass","def frame_idx(self) -> int:\n pass","def dummy_videoframe_handler(frame, userdata=None):\n sys.stdout.write('Got frame %d\\r' % userdata.count())\n sys.stdout.flush()\n userdata.increment()","def run_frame(self, ti, img):\n pass","def get_frame(self):\n return self.frame","def store_frames(self):\n self.stored_frames = (self.active_call, self.active_frame)","def get_still(self):\n _, frame = self.client.read()\n return frame","def _next_frame(self):\n ret, self.frame = self.capture.read()\n if not ret:\n self.logger.warning('Failed to read frame')\n if self.show_video:\n cv2.imshow('frame', self.frame)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n exit(0)\n return ret","def isframe(object):\r\n return isinstance(object, types.FrameType)","def __init__(self):\n Frame.__init__(self, spec.FRAME_HEARTBEAT, 0)","def on_delivered(self, frame):\n pass","def exitFrame(self):\n #check whether any grabbed frame is retrievable\n #The getter may retrieve and cacha the frame.\n if self.frame is None:\n self._enteredFrame = False\n return\n #update the FPS estimate and related variables.\n if self._framesElapsed == 0:\n self._startTime = time.time()\n else:\n timeElapsed = time.time() - self._startTime\n self._fpsEstimate = self._frameElapsed / timeElapsed","def _select_frames(self, frames):\n converted_frames = list()\n # Ignore some frame at begin and end.\n for i in np.linspace(0, self.video_size, self.frame_num + 2)[1:self.frame_num + 1]:\n img = frames[int(i)]\n img = img.resize((224, 224), Image.BILINEAR)\n frame_data = np.array(img)\n converted_frames.append(frame_data)\n return converted_frames","def get_frames(self):\n\n log(\"Getting frames for {} at {}\".format(self._location, self._t0))\n fn_get = lambda time_str: self.get_wximg(time_str)\n pool0 = multiprocessing.dummy.Pool(self._frames)\n raw = pool0.map(fn_get, self.get_time_strs())\n wximages = [x for x in raw if x is not None]\n if not wximages:\n return None\n pool1 = multiprocessing.dummy.Pool(len(wximages))\n background = self.get_background()\n if background is None:\n return None\n fn_composite = lambda x: self._pilimg.alpha_composite(background, x)\n composites = pool1.map(fn_composite, wximages)\n legend = self.get_legend()\n if legend is None:\n return None\n loop_frames = pool1.map(lambda _: legend.copy(), composites)\n fn_paste = lambda x: x[0].paste(x[1], (0, 0))\n pool1.map(fn_paste, zip(loop_frames, composites))\n return loop_frames","def get_frame(self, i: int):\r\n try:\r\n return self.frames[i]\r\n except IndexError:\r\n return None","def stream_frames(video_capture):","def getouterframes(frame, context=1):\r\n framelist = []\r\n while frame:\r\n framelist.append((frame,) + getframeinfo(frame, context))\r\n frame = frame.f_back\r\n return framelist","def get_frames(self):\n if not self.video:\n return []\n # We cannot validate shape on construction as that happens inside graph\n # mode as we construct from a tf.data.Dataset, so we validate here.\n self.video[0].validate_shape_and_dtype()\n return self.video","def dropped_frames(self):\n # type: () -> int\n return self._dropped_frames","def _read_frames(self):\n cap = self._read_file()\n\n frame_list = []\n ret_list = []\n\n while True:\n ret, frame = cap.read()\n if ret:\n frame_list.append(np.array(frame))\n ret_list.append(ret)\n else:\n break\n if self.mode==\"np\":\n frame_list = np.array(frame_list)\n return frame_list","def captureNextFrame(self):\r\n mainls = []\r\n\r\n\r\n ret, readFrame = self.capture.read()\r\n\r\n if (ret == True):\r\n self.currentFrame = cv2.cvtColor(readFrame, cv2.COLOR_BGR2RGB)\r\n self.faceDetection(self.currentFrame)\r\n self.currentFrame = self.bbFrame","def get_frames(self,std_id, frame_ids, anno=None):\n raise","def resent_frames(self):\n try:\n for k,f in self.frames.items():\n if time.time() - f['time'] > 0.500:\n self.log.warning(\"resend frame %d:%s\" % (k, f['msg']))\n self.__send_frame(k, f['msg'])\n except RuntimeError:\n pass # dictionary changed size during iteration","def get_max_frames(self):\n return 8","def switch_frames(self, new_frameName):\n\n if new_frameName in self.__frame_names:\n\n #Give rise to a new frame\n\n if new_frameName == \"image_frame\":\n image_frame= ImageFrame.Image_Frame(self.master,\n self.width,\n self.height)\n image_frame.place(x = 0, y = 0)\n \n\n elif new_frameName == \"audio_frame\":\n audio_frame = AudioFrame.Audio_Frame(self.master,\n self.width,\n self.height)\n audio_frame.place(x = 0, y = 0)\n\n elif new_frameName == \"doc_frame\":\n not_yet = notReadyYetFrame.Not_Ready_Yet_Frame(self.master,\n self.width,\n self.height)\n not_yet.place(x = 0, y = 0)\n\n else:\n not_yet = notReadyYetFrame.Not_Ready_Yet_Frame(self.master,\n self.width,\n self.height)\n not_yet.place(x = 0, y = 0)\n\n #Destroy the current frame\n self.place_forget()\n self.destroy()","def frames(self):\n if self.integration is None:\n return None\n return self.integration.frames","def is_full_frame(self):\n return self['application'] == 'ap3_250_fullframe' or self['application'] == 'ap9_250_fullframe_mindead'","def remaining_frames(self):\n return self.sound.nframes - self.current_frame","def prepareFrameCache(self, frame, cacheType): # real signature unknown; restored from __doc__\n pass","def extract_frames():\n vc = cv2.VideoCapture(INPUT_FILE)\n c=1\n\n if vc.isOpened():\n rval , frame = vc.read()\n else:\n rval, frame = False, False\n\n while rval:\n # cv2.imwrite((MODIFIED_FRAMES_DIR + 'img' + str(c) + '.jpg'),frame)\n cv2.imwrite((MODIFIED_FRAMES_DIR + str(c) + '.jpg'),frame)\n c = c + 1\n cv2.waitKey(1)\n rval, frame = vc.read()\n vc.release()\n print(\"All frames extracted successfully...\")","def get_frame(self, frame: int) -> BaseImage:\n return self.sequence[frame]","def get_all_frames(self) -> List[str]:\n frames = self.allFramesAsString().split(\"\\n\")\n frames.remove(\"\")\n return frames","def validate_timecode_input(self):\n frame = self.file_buffer.get_image(self.frame_offset)\n try:\n test = frame.shape\n except Exception as e:\n print(e)\n return False\n else:\n return True\n finally:\n test = None\n frame = None","def validate_frame(frame):\n if frame not in TIME_FRAMES:\n raise ValueError(\"Time frame must be one of {0}, not '{1}'\"\n .format('|'.join(TIME_FRAMES), frame))","def _postprocess_frames(self, frames):\n num_frames = frames.shape[0]\n if num_frames > 0:\n first_frame = self._frames[0]\n pos_start = self.get_frame_root_pos(first_frame)\n\n for f in range(num_frames):\n curr_frame = frames[f]\n\n root_pos = self.get_frame_root_pos(curr_frame)\n root_pos[0] -= pos_start[0]\n root_pos[1] -= pos_start[1]\n\n root_rot = self.get_frame_root_rot(curr_frame)\n root_rot = pose3d.QuaternionNormalize(root_rot)\n root_rot = motion_util.standardize_quaternion(root_rot)\n\n self.set_frame_root_pos(root_pos, curr_frame)\n self.set_frame_root_rot(root_rot, curr_frame)\n\n return","def frame_forward(self):\n if self.playMode == FFMPEG:\n self.ffmpegTimerOut()","def _collectFrames(self):\n self._sources = sources = self._resolveFramePaths(self._info['sources'])\n self.logger.debug('Sources: %r', sources)\n\n frameDict = {'byFrame': {}, 'byAxes': {}, 'axesAllowed': True}\n numChecked = 0\n\n self._associatedImages = {}\n self._sourcePaths = {}\n self._channels = self._info.get('channels') or []\n\n absLargeImagePath = os.path.abspath(self._largeImagePath)\n computedWidth = computedHeight = 0\n self.tileWidth = self._info.get('tileWidth')\n self.tileHeight = self._info.get('tileHeight')\n self._nativeMagnification = {\n 'mm_x': self._info.get('scale', {}).get('mm_x') or None,\n 'mm_y': self._info.get('scale', {}).get('mm_y') or None,\n 'magnification': self._info.get('scale', {}).get('magnification') or None,\n }\n # Walk through the sources, opening at least the first two, and\n # construct a frame list. Each frame is a list of sources that affect\n # it along with the frame number from that source.\n lastSource = None\n for sourceIdx, source in enumerate(sources):\n path = source['path']\n if os.path.abspath(path) == absLargeImagePath:\n msg = 'Multi source specification is self-referential'\n raise TileSourceError(msg)\n similar = False\n if (lastSource and source['path'] == lastSource['path'] and\n source.get('params') == lastSource.get('params')):\n similar = True\n if not similar and (numChecked < 2 or not self._info.get('uniformSources')):\n # need kwargs of frame, style?\n ts = self._openSource(source)\n self.tileWidth = self.tileWidth or ts.tileWidth\n self.tileHeight = self.tileHeight or ts.tileHeight\n if not numChecked:\n tsMag = ts.getNativeMagnification()\n for key in self._nativeMagnification:\n self._nativeMagnification[key] = (\n self._nativeMagnification[key] or tsMag.get(key))\n numChecked += 1\n tsMeta = ts.getMetadata()\n if 'bands' in tsMeta:\n if not hasattr(self, '_bands'):\n self._bands = {}\n self._bands.update(tsMeta['bands'])\n lastSource = source\n bbox = self._sourceBoundingBox(source, tsMeta['sizeX'], tsMeta['sizeY'])\n computedWidth = max(computedWidth, int(math.ceil(bbox['right'])))\n computedHeight = max(computedHeight, int(math.ceil(bbox['bottom'])))\n # Record this path\n if path not in self._sourcePaths:\n self._sourcePaths[path] = {\n 'frames': set(),\n 'sourcenum': set(),\n }\n # collect associated images\n for basekey in ts.getAssociatedImagesList():\n key = basekey\n keyidx = 0\n while key in self._associatedImages:\n keyidx += 1\n key = '%s-%d' % (basekey, keyidx)\n self._associatedImages[key] = {\n 'sourcenum': sourceIdx,\n 'key': key,\n }\n source['metadata'] = tsMeta\n source['bbox'] = bbox\n self._sourcePaths[path]['sourcenum'].add(sourceIdx)\n # process metadata to determine what frames are used, etc.\n self._addSourceToFrames(tsMeta, source, sourceIdx, frameDict)\n # Check frameDict and create frame record\n self._frames = self._frameDictToFrames(frameDict)\n self.tileWidth = min(max(self.tileWidth, self._minTileSize), self._maxTileSize)\n self.tileHeight = min(max(self.tileHeight, self._minTileSize), self._maxTileSize)\n self.sizeX = self._info.get('width') or computedWidth\n self.sizeY = self._info.get('height') or computedHeight\n self.levels = int(max(1, math.ceil(math.log(\n max(self.sizeX / self.tileWidth, self.sizeY / self.tileHeight)) / math.log(2)) + 1))","def get_frame_clock(self): # real signature unknown; restored from __doc__\n pass","def _validate_frames(frames: Sequence[int]) -> None:\n if not frames:\n raise ValueError('`frames` cannot be empty.')\n\n non_positive_frame_numbers = tuple(\n frame_number for frame_number in frames if frame_number < 1)\n if non_positive_frame_numbers:\n raise ValueError('Frame numbers must be positive. Found violations: '\n f'{non_positive_frame_numbers!r}')\n\n # Python uses Timsort which is `O(n)` in the best case, i.e., the overhead\n # is negligible assuming most inputs meet this specification. If the\n # specification is violated, `n` is small in case of DICOMs (few hundreds\n # in the worst case?). Here, the simplicity of the implementation outweighs\n # the (roughly constant time) overhead.\n if tuple(sorted(frames)) != tuple(frames):\n raise ValueError('Frame numbers must be in ascending order. Actual '\n f'order: {frames!r}')","def clean_frames(self):\n for fn in os.listdir(self.frame_directory):\n if fn.endswith(\".png\") and fn in self.frame_fns:\n os.remove(fn)","def process_frame(self) -> bool:\r\n if self.next_frame not in self.ooo_frames:\r\n return False\r\n\r\n img_bytes = self.ooo_frames.pop(self.next_frame)\r\n\r\n for kb_start in range(0, len(img_bytes), self.block_size):\r\n self.ffmpeg_proc.stdin.write(\r\n img_bytes[kb_start:kb_start + self.block_size])\r\n\r\n self.next_frame += 1\r\n return True","def getinnerframes(tb, context=1):\r\n framelist = []\r\n while tb:\r\n framelist.append((tb.tb_frame,) + getframeinfo(tb, context))\r\n tb = tb.tb_next\r\n return framelist"],"string":"[\n \"def frames():\\n raise RuntimeError('Must be implemented by subclasses.')\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def process_frames(self, data):\\n pass\",\n \"def dispatch_frame(self, frame):\",\n \"def frame(self):\",\n \"def onFrameUpdated(self):\\n pass\",\n \"def __init__(self, frames):\\n self._frames = frames\",\n \"def __init__(self, frames):\\n self._frames = frames\",\n \"def __init__(self, frames):\\n self._frames = frames\",\n \"def __init__(self, frames):\\n self._frames = frames\",\n \"def get_frame(self):\\n\\t\\tframe = None\\n\\t\\twhile not frame:\",\n \"def process_frame(self, frame):\\n\\t\\treturn frame\",\n \"def _get_frame(self, key):\\n pass\",\n \"def _getframe(depth=None): # real signature unknown; restored from __doc__\\n pass\",\n \"def get_frame(self, ind):\\n pass\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def __init__(self, frames):\\n self._frames = frames\\n self._out = None\",\n \"def process_frame():\\n return \\\"OK\\\"\",\n \"def onMessageFrameEnd(self):\",\n \"def onMessageFrameBegin(self, length):\",\n \"def _current_frames(): # real signature unknown; restored from __doc__\\n return {}\",\n \"def hasCurrentFrame(self):\\n if self.currentFrame == []:\\n return False\\n return True\",\n \"def parse_frames(self):\\r\\n done = False\\r\\n self._ip = 13 + self.ct_len\\r\\n while not done:\\r\\n code = self.next_byte()\\r\\n if not code:\\r\\n raise ValueError(\\\"Unexcepted end of file\\\")\\r\\n if code == b\\\"\\\\x2C\\\":\\r\\n self.parse_frame()\\r\\n elif code == b\\\"\\\\x21\\\":\\r\\n code = self.next_byte()\\r\\n if code == b\\\"\\\\xF9\\\":\\r\\n self.g_ext.append(self.parse_gce())\\r\\n elif code == b\\\"\\\\xFF\\\":\\r\\n self.next_byte()\\r\\n app = self.next_bytes(11)\\r\\n if app == b\\\"NETSCAPE2.0\\\":\\r\\n self.parse_ne()\\r\\n else:\\r\\n self.skip()\\r\\n elif code == b\\\"\\\\xFE\\\":\\r\\n self.comments.append(self.parse_ce())\\r\\n else:\\r\\n self.next_bytes(13)\\r\\n self.skip()\\r\\n elif code == b\\\"\\\\x3B\\\":\\r\\n done = True\",\n \"def __init__(self, frame):\\n super().__init__(frame)\\n self.frames = None\\n self.delay = None\",\n \"def init_all_frames(self) -> bool:\\n raise NotImplementedError\",\n \"def inspect_frame(self, frame):\\n while frame:\\n self.inspect_single_frame(frame)\\n frame = frame.f_back\",\n \"def frames(self) -> Optional[Tuple[int, ...]]:\\n return self._frames\",\n \"def available_frames(self):\\n if self._pipeline:\\n #return [getattr(frame[0], \\\"name\\\", frame[0]) for frame in self._pipeline]\\n return [step.frame if isinstance(step.frame, str) else step.frame.name for step in self._pipeline ]\\n else:\\n return None\",\n \"def frame_available(self):\\n return type(self._frame) != type(None)\",\n \"def change_frame(self, frame):\\r\\n pass\",\n \"def _request_frame(self):\\n self._send_command('GET_FRAME')\",\n \"def frames(self):\\n return self._frames\",\n \"def testAnimationBFrames(self):\\n try:\\n bFramesValue = int(self.bFrames)\\n except ValueError:\\n self.assertNotEqual(\\n self.bFrames,\\n self.config.bFrames\\n )\\n self.assertEqual(\\n None,\\n self.config.bFrames\\n )\\n else:\\n self.assertEqual(\\n bFramesValue,\\n self.config.bFrames\\n )\",\n \"def frames(self) -> Set[int]:\\n return self._frames\",\n \"def get_frame(self):\\n return self.frames.get()\",\n \"def isGoodFrame(self, frame):\\n if max(frame)<0.1:\\n return False\\n return True\",\n \"def __init__(self, frames=[], loop = 0):\\n\\t\\t\\n\\t\\tif isinstance(frames, (list, tuple)):\\n\\t\\t\\tself.frames = frames\\n\\t\\telse:\\n\\t\\t\\traise TypeError\\n\\t\\t\\t\\n\\t\\tif not loop:\\n\\t\\t\\tself.loop = 0\\n\\t\\telse:\\n\\t\\t\\tself.loop = 1\\n\\t\\t\\t\\n\\t\\tself.present_frame = None\",\n \"def count_frames():\\n frames = sentence.sem.frames.find_all('frame', {'name' : NEGATION_FRAME_NAME})\\n frame_count = []\\n for f_r in frames:\\n frame_count.append(f_r)\\n return len(frame_count)\",\n \"def _test_for_playback_frame_errors(self):\\n steps = self.program.steps\\n for s in steps:\\n for index, pb_frame in enumerate(s.playback_frames):\\n self.assertEqual(pb_frame.error, 0,\\n f\\\"Step {s.name} frame number {index} has a simulation error: {pb_frame.error_string}\\\")\",\n \"def _process(self, frame, **kwargs):\\n raise NotImplementedError()\",\n \"def __init__(self, frame):\\n self.frame = frame\",\n \"def EventFrame (self):\\n pass\",\n \"def get(self):\\n return self.frames\",\n \"def check_queues(self) -> int:\\r\\n\\r\\n nframes = 0\\r\\n\\r\\n for queue in self.receive_queues:\\r\\n if not queue.empty():\\r\\n nframes += 1\\r\\n frame, img_bytes = queue.get_nowait()\\r\\n\\r\\n if frame < self.next_frame:\\r\\n raise ValueError('received frame we already processed! '\\r\\n + f'got {frame}, at {self.next_frame}')\\r\\n if frame in self.ooo_frames:\\r\\n raise ValueError(f'received duplicate frame: {frame}')\\r\\n\\r\\n self.ooo_frames[frame] = img_bytes\\r\\n if len(self.ooo_frames) > self.max_ooo_frames:\\r\\n raise ValueError('exceeded maximum frame cache (now have '\\r\\n + f'{len(self.ooo_frames)} frames waiting)')\\r\\n\\r\\n return nframes\",\n \"def captured_frames(self):\\n return self._captured_frames\",\n \"def CHECK_transition_frames(self):\\n tr_frames = []\\n for i, frame in enumerate(self.y):\\n if not np.all(frame == frame[0]):\\n tr_frames.append(frame)\\n\\n print('there are ', len(tr_frames), ' frames containing a transition')\\n return tr_frames\",\n \"def frames(self):\\n return list(self._frames)\",\n \"def get_frame(self, frame):\\n return self.frames[frame]\",\n \"def num_frames(self):\\n return len(self.video)\",\n \"def getFrames():\\n\\t\\tfor cam in Camera.CAMERAS: cam.getFrame()\",\n \"def get_frame_list(self):\\r\\n\\r\\n logger.debug('Executing frame extraction')\\r\\n\\r\\n frames_loaded = False\\r\\n\\r\\n # Try to load YAML file with frame list\\r\\n if os.path.exists(self.frames_file_path):\\r\\n\\r\\n print 'Loading YAML file with frame list'\\r\\n logger.debug('Loading YAML file with frame list')\\r\\n\\r\\n f_list = utils.load_YAML_file(self.frames_file_path)\\r\\n\\r\\n if f_list:\\r\\n self.frame_list = f_list\\r\\n\\r\\n print 'YAML file with frame_list loaded'\\r\\n logger.debug('YAML file with frame_list loaded')\\r\\n\\r\\n frames_loaded = True\\r\\n\\r\\n if not frames_loaded:\\r\\n\\r\\n print '\\\\n\\\\n### Frame extraction ###\\\\n'\\r\\n logger.debug('\\\\n\\\\n### Frame extraction ###\\\\n')\\r\\n\\r\\n # Save processing time\\r\\n start_time = cv2.getTickCount()\\r\\n\\r\\n if not (os.path.exists(self.frames_path)):\\r\\n os.makedirs(self.frames_path)\\r\\n\\r\\n # Counter for all frames\\r\\n frame_counter = 0\\r\\n\\r\\n # Value of frame_counter for last analyzed frame\\r\\n last_anal_frame = 0\\r\\n\\r\\n # Open video file\\r\\n capture = cv2.VideoCapture(self.resource_path)\\r\\n\\r\\n self.frame_list = []\\r\\n\\r\\n # Save parameters for this video\\r\\n param_dict = {}\\r\\n\\r\\n if capture is None or not capture.isOpened():\\r\\n\\r\\n error = 'Error in opening video file'\\r\\n\\r\\n print error\\r\\n logger.debug(error)\\r\\n\\r\\n return\\r\\n\\r\\n else:\\r\\n\\r\\n video_fps = capture.get(cv2.cv.CV_CAP_PROP_FPS)\\r\\n\\r\\n param_dict[c.VIDEO_FPS_KEY] = video_fps\\r\\n\\r\\n # Original number of frames\\r\\n tot_frames = capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)\\r\\n\\r\\n param_dict[c.VIDEO_TOT_FRAMES_KEY] = tot_frames\\r\\n\\r\\n self.fps = video_fps\\r\\n\\r\\n self.video_frames = float(tot_frames)\\r\\n\\r\\n # Saved frames\\r\\n saved_frames = 0\\r\\n\\r\\n while True:\\r\\n\\r\\n # Read frame\\r\\n ret, frame = capture.read()\\r\\n\\r\\n # If no frame is read, abort\\r\\n if not ret:\\r\\n break\\r\\n\\r\\n used_fps = c.USED_FPS\\r\\n use_or_fps = c.USE_ORIGINAL_FPS\\r\\n use_or_res = c.USE_ORIGINAL_RES\\r\\n used_res_scale_factor = c.USED_RES_SCALE_FACTOR\\r\\n\\r\\n if self.params is not None:\\r\\n\\r\\n if c.USED_FPS_KEY in self.params:\\r\\n used_fps = self.params[c.USED_FPS_KEY]\\r\\n\\r\\n if c.USE_ORIGINAL_FPS_KEY in self.params:\\r\\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\\r\\n\\r\\n if c.USE_ORIGINAL_RES_KEY in self.params:\\r\\n use_or_res = self.params[c.USE_ORIGINAL_RES_KEY]\\r\\n\\r\\n if c.USED_RES_SCALE_FACTOR_KEY in self.params:\\r\\n used_res_scale_factor = self.params[\\r\\n c.USED_RES_SCALE_FACTOR_KEY]\\r\\n\\r\\n # Next frame to be analyzed\\r\\n next_frame = last_anal_frame + (video_fps / used_fps) - 1\\r\\n\\r\\n if use_or_fps or (frame_counter > next_frame):\\r\\n\\r\\n # Frame position in video in milliseconds\\r\\n elapsed_ms = capture.get(cv2.cv.CV_CAP_PROP_POS_MSEC)\\r\\n\\r\\n # print 'elapsed video s =', elapsed_video_s\\r\\n\\r\\n fr_name = '%07d.png' % frame_counter\\r\\n\\r\\n frame_path = os.path.join(self.frames_path, fr_name)\\r\\n\\r\\n # Resize frame\\r\\n if not use_or_res:\\r\\n fx = used_res_scale_factor\\r\\n\\r\\n fy = used_res_scale_factor\\r\\n\\r\\n interp = cv2.INTER_AREA\\r\\n\\r\\n frame = cv2.resize(src=frame, dsize=(0, 0),\\r\\n fx=fx, fy=fy,\\r\\n interpolation=interp)\\r\\n\\r\\n cv2.imwrite(frame_path, frame,\\r\\n [cv.CV_IMWRITE_PNG_COMPRESSION, 0])\\r\\n\\r\\n frame_dict = {c.SAVED_FRAME_NAME_KEY: fr_name,\\r\\n c.ELAPSED_VIDEO_TIME_KEY: int(elapsed_ms)}\\r\\n\\r\\n self.frame_list.append(frame_dict)\\r\\n\\r\\n last_anal_frame = frame_counter\\r\\n\\r\\n saved_frames += 1\\r\\n\\r\\n frame_counter += 1\\r\\n\\r\\n self.progress = 100 * (frame_counter / self.video_frames)\\r\\n\\r\\n print('progress: ' + str(self.progress) + ' % \\\\r'),\\r\\n\\r\\n del capture\\r\\n\\r\\n self.saved_frames = float(saved_frames)\\r\\n\\r\\n param_dict[c.VIDEO_SAVED_FRAMES_KEY] = self.saved_frames\\r\\n\\r\\n # Save frame list in YAML file\\r\\n utils.save_YAML_file(self.frames_file_path, self.frame_list)\\r\\n\\r\\n # Save video parameters in YAML file\\r\\n\\r\\n utils.save_YAML_file(self.params_file_path, param_dict)\\r\\n\\r\\n # Save processing time\\r\\n time_in_clocks = cv2.getTickCount() - start_time\\r\\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\\r\\n\\r\\n print 'Time for frame extraction:', str(time_in_seconds), 's\\\\n'\\r\\n logger.debug(\\r\\n 'Time for frame extraction:', str(time_in_seconds), 's\\\\n')\\r\\n\\r\\n self.anal_times[c.FRAME_EXTRACTION_TIME_KEY] = time_in_seconds\\r\\n\\r\\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)\",\n \"def half_frame(self) -> None:\\n pass\",\n \"def half_frame(self) -> None:\\n pass\",\n \"def frame_idx(self) -> int:\\n pass\",\n \"def dummy_videoframe_handler(frame, userdata=None):\\n sys.stdout.write('Got frame %d\\\\r' % userdata.count())\\n sys.stdout.flush()\\n userdata.increment()\",\n \"def run_frame(self, ti, img):\\n pass\",\n \"def get_frame(self):\\n return self.frame\",\n \"def store_frames(self):\\n self.stored_frames = (self.active_call, self.active_frame)\",\n \"def get_still(self):\\n _, frame = self.client.read()\\n return frame\",\n \"def _next_frame(self):\\n ret, self.frame = self.capture.read()\\n if not ret:\\n self.logger.warning('Failed to read frame')\\n if self.show_video:\\n cv2.imshow('frame', self.frame)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n exit(0)\\n return ret\",\n \"def isframe(object):\\r\\n return isinstance(object, types.FrameType)\",\n \"def __init__(self):\\n Frame.__init__(self, spec.FRAME_HEARTBEAT, 0)\",\n \"def on_delivered(self, frame):\\n pass\",\n \"def exitFrame(self):\\n #check whether any grabbed frame is retrievable\\n #The getter may retrieve and cacha the frame.\\n if self.frame is None:\\n self._enteredFrame = False\\n return\\n #update the FPS estimate and related variables.\\n if self._framesElapsed == 0:\\n self._startTime = time.time()\\n else:\\n timeElapsed = time.time() - self._startTime\\n self._fpsEstimate = self._frameElapsed / timeElapsed\",\n \"def _select_frames(self, frames):\\n converted_frames = list()\\n # Ignore some frame at begin and end.\\n for i in np.linspace(0, self.video_size, self.frame_num + 2)[1:self.frame_num + 1]:\\n img = frames[int(i)]\\n img = img.resize((224, 224), Image.BILINEAR)\\n frame_data = np.array(img)\\n converted_frames.append(frame_data)\\n return converted_frames\",\n \"def get_frames(self):\\n\\n log(\\\"Getting frames for {} at {}\\\".format(self._location, self._t0))\\n fn_get = lambda time_str: self.get_wximg(time_str)\\n pool0 = multiprocessing.dummy.Pool(self._frames)\\n raw = pool0.map(fn_get, self.get_time_strs())\\n wximages = [x for x in raw if x is not None]\\n if not wximages:\\n return None\\n pool1 = multiprocessing.dummy.Pool(len(wximages))\\n background = self.get_background()\\n if background is None:\\n return None\\n fn_composite = lambda x: self._pilimg.alpha_composite(background, x)\\n composites = pool1.map(fn_composite, wximages)\\n legend = self.get_legend()\\n if legend is None:\\n return None\\n loop_frames = pool1.map(lambda _: legend.copy(), composites)\\n fn_paste = lambda x: x[0].paste(x[1], (0, 0))\\n pool1.map(fn_paste, zip(loop_frames, composites))\\n return loop_frames\",\n \"def get_frame(self, i: int):\\r\\n try:\\r\\n return self.frames[i]\\r\\n except IndexError:\\r\\n return None\",\n \"def stream_frames(video_capture):\",\n \"def getouterframes(frame, context=1):\\r\\n framelist = []\\r\\n while frame:\\r\\n framelist.append((frame,) + getframeinfo(frame, context))\\r\\n frame = frame.f_back\\r\\n return framelist\",\n \"def get_frames(self):\\n if not self.video:\\n return []\\n # We cannot validate shape on construction as that happens inside graph\\n # mode as we construct from a tf.data.Dataset, so we validate here.\\n self.video[0].validate_shape_and_dtype()\\n return self.video\",\n \"def dropped_frames(self):\\n # type: () -> int\\n return self._dropped_frames\",\n \"def _read_frames(self):\\n cap = self._read_file()\\n\\n frame_list = []\\n ret_list = []\\n\\n while True:\\n ret, frame = cap.read()\\n if ret:\\n frame_list.append(np.array(frame))\\n ret_list.append(ret)\\n else:\\n break\\n if self.mode==\\\"np\\\":\\n frame_list = np.array(frame_list)\\n return frame_list\",\n \"def captureNextFrame(self):\\r\\n mainls = []\\r\\n\\r\\n\\r\\n ret, readFrame = self.capture.read()\\r\\n\\r\\n if (ret == True):\\r\\n self.currentFrame = cv2.cvtColor(readFrame, cv2.COLOR_BGR2RGB)\\r\\n self.faceDetection(self.currentFrame)\\r\\n self.currentFrame = self.bbFrame\",\n \"def get_frames(self,std_id, frame_ids, anno=None):\\n raise\",\n \"def resent_frames(self):\\n try:\\n for k,f in self.frames.items():\\n if time.time() - f['time'] > 0.500:\\n self.log.warning(\\\"resend frame %d:%s\\\" % (k, f['msg']))\\n self.__send_frame(k, f['msg'])\\n except RuntimeError:\\n pass # dictionary changed size during iteration\",\n \"def get_max_frames(self):\\n return 8\",\n \"def switch_frames(self, new_frameName):\\n\\n if new_frameName in self.__frame_names:\\n\\n #Give rise to a new frame\\n\\n if new_frameName == \\\"image_frame\\\":\\n image_frame= ImageFrame.Image_Frame(self.master,\\n self.width,\\n self.height)\\n image_frame.place(x = 0, y = 0)\\n \\n\\n elif new_frameName == \\\"audio_frame\\\":\\n audio_frame = AudioFrame.Audio_Frame(self.master,\\n self.width,\\n self.height)\\n audio_frame.place(x = 0, y = 0)\\n\\n elif new_frameName == \\\"doc_frame\\\":\\n not_yet = notReadyYetFrame.Not_Ready_Yet_Frame(self.master,\\n self.width,\\n self.height)\\n not_yet.place(x = 0, y = 0)\\n\\n else:\\n not_yet = notReadyYetFrame.Not_Ready_Yet_Frame(self.master,\\n self.width,\\n self.height)\\n not_yet.place(x = 0, y = 0)\\n\\n #Destroy the current frame\\n self.place_forget()\\n self.destroy()\",\n \"def frames(self):\\n if self.integration is None:\\n return None\\n return self.integration.frames\",\n \"def is_full_frame(self):\\n return self['application'] == 'ap3_250_fullframe' or self['application'] == 'ap9_250_fullframe_mindead'\",\n \"def remaining_frames(self):\\n return self.sound.nframes - self.current_frame\",\n \"def prepareFrameCache(self, frame, cacheType): # real signature unknown; restored from __doc__\\n pass\",\n \"def extract_frames():\\n vc = cv2.VideoCapture(INPUT_FILE)\\n c=1\\n\\n if vc.isOpened():\\n rval , frame = vc.read()\\n else:\\n rval, frame = False, False\\n\\n while rval:\\n # cv2.imwrite((MODIFIED_FRAMES_DIR + 'img' + str(c) + '.jpg'),frame)\\n cv2.imwrite((MODIFIED_FRAMES_DIR + str(c) + '.jpg'),frame)\\n c = c + 1\\n cv2.waitKey(1)\\n rval, frame = vc.read()\\n vc.release()\\n print(\\\"All frames extracted successfully...\\\")\",\n \"def get_frame(self, frame: int) -> BaseImage:\\n return self.sequence[frame]\",\n \"def get_all_frames(self) -> List[str]:\\n frames = self.allFramesAsString().split(\\\"\\\\n\\\")\\n frames.remove(\\\"\\\")\\n return frames\",\n \"def validate_timecode_input(self):\\n frame = self.file_buffer.get_image(self.frame_offset)\\n try:\\n test = frame.shape\\n except Exception as e:\\n print(e)\\n return False\\n else:\\n return True\\n finally:\\n test = None\\n frame = None\",\n \"def validate_frame(frame):\\n if frame not in TIME_FRAMES:\\n raise ValueError(\\\"Time frame must be one of {0}, not '{1}'\\\"\\n .format('|'.join(TIME_FRAMES), frame))\",\n \"def _postprocess_frames(self, frames):\\n num_frames = frames.shape[0]\\n if num_frames > 0:\\n first_frame = self._frames[0]\\n pos_start = self.get_frame_root_pos(first_frame)\\n\\n for f in range(num_frames):\\n curr_frame = frames[f]\\n\\n root_pos = self.get_frame_root_pos(curr_frame)\\n root_pos[0] -= pos_start[0]\\n root_pos[1] -= pos_start[1]\\n\\n root_rot = self.get_frame_root_rot(curr_frame)\\n root_rot = pose3d.QuaternionNormalize(root_rot)\\n root_rot = motion_util.standardize_quaternion(root_rot)\\n\\n self.set_frame_root_pos(root_pos, curr_frame)\\n self.set_frame_root_rot(root_rot, curr_frame)\\n\\n return\",\n \"def frame_forward(self):\\n if self.playMode == FFMPEG:\\n self.ffmpegTimerOut()\",\n \"def _collectFrames(self):\\n self._sources = sources = self._resolveFramePaths(self._info['sources'])\\n self.logger.debug('Sources: %r', sources)\\n\\n frameDict = {'byFrame': {}, 'byAxes': {}, 'axesAllowed': True}\\n numChecked = 0\\n\\n self._associatedImages = {}\\n self._sourcePaths = {}\\n self._channels = self._info.get('channels') or []\\n\\n absLargeImagePath = os.path.abspath(self._largeImagePath)\\n computedWidth = computedHeight = 0\\n self.tileWidth = self._info.get('tileWidth')\\n self.tileHeight = self._info.get('tileHeight')\\n self._nativeMagnification = {\\n 'mm_x': self._info.get('scale', {}).get('mm_x') or None,\\n 'mm_y': self._info.get('scale', {}).get('mm_y') or None,\\n 'magnification': self._info.get('scale', {}).get('magnification') or None,\\n }\\n # Walk through the sources, opening at least the first two, and\\n # construct a frame list. Each frame is a list of sources that affect\\n # it along with the frame number from that source.\\n lastSource = None\\n for sourceIdx, source in enumerate(sources):\\n path = source['path']\\n if os.path.abspath(path) == absLargeImagePath:\\n msg = 'Multi source specification is self-referential'\\n raise TileSourceError(msg)\\n similar = False\\n if (lastSource and source['path'] == lastSource['path'] and\\n source.get('params') == lastSource.get('params')):\\n similar = True\\n if not similar and (numChecked < 2 or not self._info.get('uniformSources')):\\n # need kwargs of frame, style?\\n ts = self._openSource(source)\\n self.tileWidth = self.tileWidth or ts.tileWidth\\n self.tileHeight = self.tileHeight or ts.tileHeight\\n if not numChecked:\\n tsMag = ts.getNativeMagnification()\\n for key in self._nativeMagnification:\\n self._nativeMagnification[key] = (\\n self._nativeMagnification[key] or tsMag.get(key))\\n numChecked += 1\\n tsMeta = ts.getMetadata()\\n if 'bands' in tsMeta:\\n if not hasattr(self, '_bands'):\\n self._bands = {}\\n self._bands.update(tsMeta['bands'])\\n lastSource = source\\n bbox = self._sourceBoundingBox(source, tsMeta['sizeX'], tsMeta['sizeY'])\\n computedWidth = max(computedWidth, int(math.ceil(bbox['right'])))\\n computedHeight = max(computedHeight, int(math.ceil(bbox['bottom'])))\\n # Record this path\\n if path not in self._sourcePaths:\\n self._sourcePaths[path] = {\\n 'frames': set(),\\n 'sourcenum': set(),\\n }\\n # collect associated images\\n for basekey in ts.getAssociatedImagesList():\\n key = basekey\\n keyidx = 0\\n while key in self._associatedImages:\\n keyidx += 1\\n key = '%s-%d' % (basekey, keyidx)\\n self._associatedImages[key] = {\\n 'sourcenum': sourceIdx,\\n 'key': key,\\n }\\n source['metadata'] = tsMeta\\n source['bbox'] = bbox\\n self._sourcePaths[path]['sourcenum'].add(sourceIdx)\\n # process metadata to determine what frames are used, etc.\\n self._addSourceToFrames(tsMeta, source, sourceIdx, frameDict)\\n # Check frameDict and create frame record\\n self._frames = self._frameDictToFrames(frameDict)\\n self.tileWidth = min(max(self.tileWidth, self._minTileSize), self._maxTileSize)\\n self.tileHeight = min(max(self.tileHeight, self._minTileSize), self._maxTileSize)\\n self.sizeX = self._info.get('width') or computedWidth\\n self.sizeY = self._info.get('height') or computedHeight\\n self.levels = int(max(1, math.ceil(math.log(\\n max(self.sizeX / self.tileWidth, self.sizeY / self.tileHeight)) / math.log(2)) + 1))\",\n \"def get_frame_clock(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def _validate_frames(frames: Sequence[int]) -> None:\\n if not frames:\\n raise ValueError('`frames` cannot be empty.')\\n\\n non_positive_frame_numbers = tuple(\\n frame_number for frame_number in frames if frame_number < 1)\\n if non_positive_frame_numbers:\\n raise ValueError('Frame numbers must be positive. Found violations: '\\n f'{non_positive_frame_numbers!r}')\\n\\n # Python uses Timsort which is `O(n)` in the best case, i.e., the overhead\\n # is negligible assuming most inputs meet this specification. If the\\n # specification is violated, `n` is small in case of DICOMs (few hundreds\\n # in the worst case?). Here, the simplicity of the implementation outweighs\\n # the (roughly constant time) overhead.\\n if tuple(sorted(frames)) != tuple(frames):\\n raise ValueError('Frame numbers must be in ascending order. Actual '\\n f'order: {frames!r}')\",\n \"def clean_frames(self):\\n for fn in os.listdir(self.frame_directory):\\n if fn.endswith(\\\".png\\\") and fn in self.frame_fns:\\n os.remove(fn)\",\n \"def process_frame(self) -> bool:\\r\\n if self.next_frame not in self.ooo_frames:\\r\\n return False\\r\\n\\r\\n img_bytes = self.ooo_frames.pop(self.next_frame)\\r\\n\\r\\n for kb_start in range(0, len(img_bytes), self.block_size):\\r\\n self.ffmpeg_proc.stdin.write(\\r\\n img_bytes[kb_start:kb_start + self.block_size])\\r\\n\\r\\n self.next_frame += 1\\r\\n return True\",\n \"def getinnerframes(tb, context=1):\\r\\n framelist = []\\r\\n while tb:\\r\\n framelist.append((tb.tb_frame,) + getframeinfo(tb, context))\\r\\n tb = tb.tb_next\\r\\n return framelist\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7640561","0.69378716","0.69378716","0.69378716","0.69378716","0.69378716","0.69195557","0.67941016","0.67867607","0.6755174","0.6755174","0.6755174","0.6755174","0.6722964","0.6581867","0.6483949","0.6414792","0.6398254","0.63598907","0.63598907","0.63598907","0.63598907","0.63598907","0.63598907","0.6322751","0.6307869","0.6305777","0.6301942","0.6261233","0.6187161","0.6180312","0.61780745","0.6155257","0.6151303","0.61455387","0.6130367","0.6128891","0.61150837","0.6107453","0.60829455","0.60518783","0.6021739","0.6018323","0.59724","0.59704894","0.5941176","0.59248114","0.5919355","0.5907409","0.5904859","0.59027016","0.58991843","0.58969307","0.5894568","0.5883093","0.58597237","0.5810989","0.5802099","0.579829","0.579829","0.5767862","0.5761386","0.5749332","0.57490814","0.5748556","0.5739464","0.57277495","0.57262045","0.5718457","0.570355","0.5691906","0.56888324","0.5684109","0.5669693","0.5645044","0.56390214","0.563588","0.5632126","0.5632016","0.5627276","0.562713","0.5624126","0.56237334","0.5618805","0.5597357","0.55844337","0.5560488","0.5560268","0.5558785","0.555625","0.55481374","0.5544944","0.55415845","0.55345964","0.55275005","0.5521124","0.54948336","0.5484428","0.5476553","0.54700446","0.5463382"],"string":"[\n \"0.7640561\",\n \"0.69378716\",\n \"0.69378716\",\n \"0.69378716\",\n \"0.69378716\",\n \"0.69378716\",\n \"0.69195557\",\n \"0.67941016\",\n \"0.67867607\",\n \"0.6755174\",\n \"0.6755174\",\n \"0.6755174\",\n \"0.6755174\",\n \"0.6722964\",\n \"0.6581867\",\n \"0.6483949\",\n \"0.6414792\",\n \"0.6398254\",\n \"0.63598907\",\n \"0.63598907\",\n \"0.63598907\",\n \"0.63598907\",\n \"0.63598907\",\n \"0.63598907\",\n \"0.6322751\",\n \"0.6307869\",\n \"0.6305777\",\n \"0.6301942\",\n \"0.6261233\",\n \"0.6187161\",\n \"0.6180312\",\n \"0.61780745\",\n \"0.6155257\",\n \"0.6151303\",\n \"0.61455387\",\n \"0.6130367\",\n \"0.6128891\",\n \"0.61150837\",\n \"0.6107453\",\n \"0.60829455\",\n \"0.60518783\",\n \"0.6021739\",\n \"0.6018323\",\n \"0.59724\",\n \"0.59704894\",\n \"0.5941176\",\n \"0.59248114\",\n \"0.5919355\",\n \"0.5907409\",\n \"0.5904859\",\n \"0.59027016\",\n \"0.58991843\",\n \"0.58969307\",\n \"0.5894568\",\n \"0.5883093\",\n \"0.58597237\",\n \"0.5810989\",\n \"0.5802099\",\n \"0.579829\",\n \"0.579829\",\n \"0.5767862\",\n \"0.5761386\",\n \"0.5749332\",\n \"0.57490814\",\n \"0.5748556\",\n \"0.5739464\",\n \"0.57277495\",\n \"0.57262045\",\n \"0.5718457\",\n \"0.570355\",\n \"0.5691906\",\n \"0.56888324\",\n \"0.5684109\",\n \"0.5669693\",\n \"0.5645044\",\n \"0.56390214\",\n \"0.563588\",\n \"0.5632126\",\n \"0.5632016\",\n \"0.5627276\",\n \"0.562713\",\n \"0.5624126\",\n \"0.56237334\",\n \"0.5618805\",\n \"0.5597357\",\n \"0.55844337\",\n \"0.5560488\",\n \"0.5560268\",\n \"0.5558785\",\n \"0.555625\",\n \"0.55481374\",\n \"0.5544944\",\n \"0.55415845\",\n \"0.55345964\",\n \"0.55275005\",\n \"0.5521124\",\n \"0.54948336\",\n \"0.5484428\",\n \"0.5476553\",\n \"0.54700446\",\n \"0.5463382\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95590,"cells":{"query":{"kind":"string","value":"Return information about a particular squences."},"document":{"kind":"string","value":"def get_study_info(self,std_id):\n raise NotImplementedError"},"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 getSongTextInfo():\n sids = []\n documents = []\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\n lines = sFile.readlines()\n index = 0\n for line in lines:\n line.strip('\\n')\n line.strip('\\r\\n')\n items = line.split('>>')\n sid = int(items[0])\n text = items[1]\n documents.append(text)\n sids.append(sid)\n sFile.close()\n print 'len = ',len(sids)\n print 'len = ',len(documents)\n return sids,documents","def info(self):\n self.update_info()\n print('Number of electrodes: ' + str(self.n_elecs))\n print('Recording time in seconds: ' + str(self.dur))\n print('Sample Rate in Hz: '+ str(self.sample_rate))\n print('Number of sessions: ' + str(self.n_sessions))\n print('Date created: ' + str(self.date_created))\n print('Meta data: ' + str(self.meta))","def getSentenceInfo(sentence):\n\tpass","def details(self):\n \n sparql_results = self.query (\"\"\"\n select distinct * where {\n\n BIND (<%s> as ?rc)\n \n ?rc olac:speaker ?participant .\n ?participant austalk:id ?pid .\n ?participant austalk:recording_site ?site .\n ?site rdfs:label ?sitelabel .\n \n ?rc austalk:prototype ?component .\n ?component austalk:shortname ?shortname .\n ?rc dc:isPartOf ?rs .\n ?rs austalk:prototype ?session .\n ?session austalk:id ?sessionid .\n \n ?component austalk:name ?name . \n\\\n optional { ?rc austalk:audiorating ?arating .}\n optional { ?rc austalk:videorating ?vrating .}\n optional { ?rc austalk:comment ?comment .}\n }\"\"\" % (self.identifier, ))\n \n # we expect one binding\n bindings = sparql_results[\"results\"][\"bindings\"]\n if len(bindings) == 1:\n bindings = bindings[0]\n self.participantId = bindings['pid']['value']\n self.prototype = bindings['component']['value']\n self.name = bindings['name']['value']\n self.componentId = bindings['shortname']['value']\n self.site = bindings['sitelabel']['value']\n self.sessionId = bindings['sessionid']['value']\n if bindings.has_key('arating'):\n self.audiorating = bindings['arating']['value']","def extract_information(preprocessed_sentences):\n parsed = list(map(lambda sentence: nlp(sentence), preprocessed_sentences))\n\n quantities = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'QUANTITY'), parsed))\n dates = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'DATE'), parsed))\n\n hurricane_name = eh.extract_frequent_regex_match(parsed, '[Hh]urricane ([A-Z][a-z]+)').most_common(1)[0][0]\n hurricane_category = eh.extract_frequent_regex_match(parsed, '[Cc]ategory ([0-9]+)').most_common(1)[0][0]\n\n tropical_storm_name = eh.extract_frequent_regex_match(parsed, '[Tt]ropical [Ss]torm ([A-Z][a-z]+)').most_common(1)[0][0]\n formation_date, middle_month = extract_storm_timeline(dates, hurricane_name)\n\n preperation_info = extract_preparation_information(parsed)\n prep_gpes = preperation_info[0].most_common(3)\n\n restore_info = extract_restoration_information(parsed)\n\n landfall_info = extract_landfall_information(parsed)\n\n wind_info = extract_wind_information(quantities)\n rain_info = extract_rain_information(quantities)\n size_info = extract_size_information(parsed)\n\n # formation_info = extract_formation_info(parsed)\n death_info = extract_death_damages_info(parsed)\n\n print(constants.HURRICANE_SENTENCE.format(hurricane_name, middle_month, hurricane_category))\n print(constants.LANDFALL_SENTENCE.format(hurricane_name, landfall_info[2], landfall_info[3], landfall_info[0], landfall_info[1]))\n print(constants.WIND_SENTENCE.format(wind_info[0], wind_info[1], wind_info[2]))\n print(constants.RAIN_SENTENCE.format(hurricane_name, rain_info[1], rain_info[0], rain_info[2]))\n print(constants.FORMATION_SENTENCE.format(formation_date, tropical_storm_name))\n print(constants.PREPARATION_SENTENCE.format(prep_gpes[0][0], prep_gpes[1][0], prep_gpes[2][0], preperation_info[1].\n most_common(1)[0][0]))\n print(constants.SIZE_SENTENCE.format(size_info[0], size_info[1]))","def info(self) -> list[int]:","def get_phrase(self):\n counter = 30 # give us a full 2 seconds of time to start\n\n with closing(self.Mic()) as mic:\n log.info('Recording phrase.')\n while True:\n frames = mic.next()\n\n score, has_disturbance = self.scorer.add(frames)\n\n if counter < 15 and has_disturbance:\n log.info('Recording more in phrase.')\n counter = 15\n else:\n counter -= 1\n\n if counter >= 1:\n yield frames","def info(self):\n return self.__dict__[self.sid]","def get_freq_details(diagnostics_dir, verbose=False):\n metafile_science = find_metadata_file(diagnostics_dir, 'mslist-scienceData*txt', verbose=False)\n if not metafile_science:\n return None, None, None\n\n with open(metafile_science, 'r') as mslist_file:\n lines = mslist_file.readlines()\n\n in_spw_block = False\n for line in lines:\n if in_spw_block:\n parts = line.split()\n chan_width = float(parts[10])*1000. # convert kHz to Hz\n cfreq = parts[12] #MHz\n nchan = parts[7]\n break\n else:\n in_spw_block = line.find('Frame') >= 0\n\n return chan_width, cfreq, nchan","def read_ams(self):\n current = time.time()\n try:\n if current - self.start > 3:\n self.track_artist = not self.track_artist\n self.start = time.time()\n if self.track_artist:\n data = self.ams.artist\n if not self.track_artist:\n data = self.ams.title\n except (RuntimeError, UnicodeError):\n data = None\n\n if data:\n data = data[:16] + (data[16:] and '..')\n\n return data","def infotodict(seqinfo):\n \n \"\"\"\n MCF Pilot Protocol acquired on Friday April 13th\n \n >>> hdc_look.py -s mfc001 -ss 1\n series_id sequence_name series_description dim1 dim2 dim3 dim4 TR TE is_derived is_motion_corrected\n 0 1-localizer *fl2d1 localizer 192 192 3 1 0.020 5.00 False False\n 1 2-pre_Neutral1_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral1_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\n 2 3-pre_topup_A>>P *epse2d1_64 pre_topup_A>>P 64 64 140 1 2.400 38.00 False False\n 3 4-pre_topup_P>>A *epse2d1_64 pre_topup_P>>A 64 64 140 1 2.400 38.00 False False\n 4 5-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 4.92 False False\n 5 6-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 7.38 False False\n 6 7-pre+heat1_A>>P 4X4X4 *epfid2d1_64 pre+heat1_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\n 7 8-pre_Neutral2_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral2_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\n 8 9-pre+heat2_A>>P 4X4X4 *epfid2d1_64 pre+heat2_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\n 9 10-MPRAGE_GRAPPA2 *tfl3d1_16ns MPRAGE_GRAPPA2 256 240 192 1 2.300 2.98 False False\n 10 11-post_Neutral3_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral3_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\n 11 12-post+heat3_A>>P 4X4X4 *epfid2d1_64 post+heat3_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\n 12 13-post_Neutral4_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral4_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\n 13 14-post+heat4_A>>P 4X4X4 *epfid2d1_64 post+heat4_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\n 14 15-post_topup_A>>P *epse2d1_64 post_topup_A>>P 64 64 140 1 2.400 38.00 False False\n 15 16-post_topup_P>>A *epse2d1_64 post_topup_P>>A 64 64 140 1 2.400 38.00 False False\n \n \"\"\"\n\n bids_prefix = 'sub-{subject}/{session}/'\n\n pre_neutral1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-fmap_bold.{item:01d}')\n pre_heat1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-fmap_bold.{item:01d}')\n pre_heat2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-fmap_bold.{item:01d}')\n pre_neutral2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-fmap_bold.{item:01d}')\n\n pre_neutral1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-topup_bold.{item:01d}')\n pre_heat1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-topup_bold.{item:01d}')\n pre_heat2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-topup_bold.{item:01d}')\n pre_neutral2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-topup_bold.{item:01d}')\n\n pre_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-ap_epi.{item:01d}')\n pre_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-pa_epi.{item:01d}')\n\n # The item was commented out for Phase Difference field maps. Conversion did not work correctly. I removed the item number to try to\n # isolate the problem.\n\n pre_fmap_magnitude1 = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_magnitude1.{item:01d}')\n pre_fmap_phasediff = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_phasediff.{item:01d}')\n\n t1w = create_key(bids_prefix + 'anat/sub-{subject}_{session}_T1w')\n\n post_neutral3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-fmap_bold.{item:01d}')\n post_heat3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-fmap_bold.{item:01d}')\n post_heat4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-fmap_bold.{item:01d}')\n post_neutral4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-fmap_bold.{item:01d}')\n\n post_neutral3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-topup_bold.{item:01d}')\n post_heat3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-topup_bold.{item:01d}')\n post_heat4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-topup_bold.{item:01d}')\n post_neutral4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-topup_bold.{item:01d}')\n\n post_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-ap_epi.{item:01d}')\n post_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-pa_epi.{item:01d}')\n\n # Create an empty dictionary called info for each key\n\n info = {pre_neutral1_ap_fmap: [],\n pre_heat1_ap_fmap: [],\n pre_heat2_ap_fmap: [],\n pre_neutral2_ap_fmap: [],\n\n pre_neutral1_ap_topup: [],\n pre_heat1_ap_topup: [],\n pre_heat2_ap_topup: [],\n pre_neutral2_ap_topup: [],\n\n pre_topup_ap: [],\n pre_topup_pa: [],\n\n pre_fmap_magnitude1: [],\n pre_fmap_phasediff: [],\n\n t1w: [],\n\n post_neutral3_ap_fmap: [],\n post_heat3_ap_fmap: [],\n post_heat4_ap_fmap: [],\n post_neutral4_ap_fmap: [],\n\n post_neutral3_ap_topup: [],\n post_heat3_ap_topup: [],\n post_heat4_ap_topup: [],\n post_neutral4_ap_topup: [],\n\n post_topup_ap: [],\n post_topup_pa: [],\n\n }\n\n # Loop over each sequence. Use if statements to determine which sequences should be linked to which key\n\n for idx, s in enumerate(seqinfo):\n\n if 'pre_Neutral1' in s.series_id:\n info[pre_neutral1_ap_fmap].append([s.series_id])\n info[pre_neutral1_ap_topup].append([s.series_id])\n\n if 'pre+heat1' in s.series_id:\n info[pre_heat1_ap_fmap].append([s.series_id])\n info[pre_heat1_ap_topup].append([s.series_id])\n\n if 'pre+heat2' in s.series_id:\n info[pre_heat2_ap_fmap].append([s.series_id])\n info[pre_heat2_ap_topup].append([s.series_id])\n\n if 'pre_Neutral2' in s.series_id:\n info[pre_neutral2_ap_fmap].append([s.series_id])\n info[pre_neutral2_ap_topup].append([s.series_id])\n\n if 'pre_topup_A>>P' in s.series_id:\n info[pre_topup_ap].append([s.series_id])\n\n if 'pre_topup_P>>A' in s.series_id:\n info[pre_topup_pa].append([s.series_id])\n\n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\n (s.TE == 4.92)):\n info[pre_fmap_magnitude1].append([s.series_id])\n \n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\n (s.TE == 7.38)):\n info[pre_fmap_phasediff].append([s.series_id])\n\n if 'MPRAGE_GRAPPA2' in s.series_id:\n info[t1w].append([s.series_id])\n\n if 'post_Neutral3' in s.series_id:\n info[post_neutral3_ap_fmap].append([s.series_id])\n info[post_neutral3_ap_topup].append([s.series_id])\n\n if 'post+heat3' in s.series_id:\n info[post_heat3_ap_fmap].append([s.series_id])\n info[post_heat3_ap_topup].append([s.series_id])\n\n if 'post+heat4' in s.series_id:\n info[post_heat4_ap_fmap].append([s.series_id])\n info[post_heat4_ap_topup].append([s.series_id])\n\n if 'post_Neutral4' in s.series_id:\n info[post_neutral4_ap_fmap].append([s.series_id])\n info[post_neutral4_ap_topup].append([s.series_id])\n\n if 'post_topup_A>>P' in s.series_id:\n info[post_topup_ap].append([s.series_id])\n\n if 'post_topup_P>>A' in s.series_id:\n info[post_topup_pa].append([s.series_id])\n\n return info","def audiences(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"audiences\")","async def get_information():\n return {\n \"message\": f\"You are the Genome Researcher. \"\n f\"You are meddling with Coronavirus Sars-Cov-2 RNA... \"\n f\"Try to change the RNA at your disposal to uncover as many medical breakthroughs as possible. \"\n f\"use GET /sample to see the original RNA strand \"\n f\"use COPY /sample to create exact duplicate of original to perform experiments. \"\n f\"Try to change the RNA at your disposal to uncover as many medical breakthroughs as possible. \"\n f\"Good luck researcher. \"\n f\"Our souls fates' depend on you! \"\n }","def frequency():\n\n return make_simple_tsv_get_response(FREQ_FILE, 'frequency')","def getLSASpace():\n sids,documents = getSongTextInfo()\n texts = [[word for word in document.lower().split()] for document in documents]\n dictionary = corpora.Dictionary(texts)\n corpus = [dictionary.doc2bow(text) for text in texts]\n tfidf = models.TfidfModel(corpus)\n corpus_tfidf = tfidf[corpus]\n lsi = models.LsiModel(corpus_tfidf, id2word=dictionary, num_topics=30)\n corpus_lsi = lsi[corpus_tfidf]\n songMap = {}\n index = 0\n for doc in corpus_lsi:\n sid = sids[index]\n rMap = {}\n for item in doc:\n wid = item[0]\n count = item[1]\n rMap[wid] = count\n songMap[sid] = rMap\n index += 1\n return songMap","def getInfo():","def dnasequence(self):\n return parseSingleFasta(open(self.dna_file).readlines())[1]","def info():\n # -------- Task 1 -------------------------\n # Please complete the following information\n\n return {\"agent name\": \"?\", # COMPLETE HERE\n \"student name\": [\"?\"], # COMPLETE HERE\n \"student number\": [\"?\"]} # COMPLETE HERE","def thesaurus(self, message):\n read_pointer = open('Thesaurus.txt')\n\n for line in read_pointer:\n split_line = line.split(':', 1)\n if split_line[0] == message:\n return split_line[1]","def subject_info(intent, extra_info=[]):\n\n text = intent['inputTranscript'].lower()\n utterances = AS.load_file('sample_utterances.txt')\n\n # add \"book\" and \"books\" to every utterance\n for line in list(utterances):\n utterances.insert(0, line + \" book\")\n utterances.insert(0, line + \" books\")\n\n # tells how many characters needs to be dropped before the subject starts\n to_drop = 0\n\n for line in utterances:\n if text.startswith(line):\n to_drop = len(line)\n break\n\n # drops the characters and makes a list from the strings that are left\n text = text[to_drop:].strip()\n text_list = text.split(' ', len(text))\n\n subject_list = []\n keywords = [\"books\", \"book\", \"by\", \"published\", \"written\"]\n keyword = \"\"\n\n # Find out when the book name ends\n for word in text_list:\n if word not in keywords:\n subject_list.append(word)\n else:\n break\n\n subject = \" \".join(subject_list)\n\n # Get all the keywords in the middle, so they can be\n # all be dropped at once, eg written by, books by\n text_list = text_list[len(subject_list):]\n if text_list:\n word = text_list[0]\n while word in keywords:\n keyword += word + \" \"\n text_list = text_list[1:]\n if text_list:\n word = text_list[0]\n else:\n break\n\n # search for an author from the rest of the characters\n author_text = text[len(keyword):].strip()\n author = AS.search(author_text, False)\n if author is \"\":\n author = None\n\n # There might be old info in the extra_info (author), so \n # we need to clear it\n extra_info.clear()\n\n # add the author to extra info so it can be used in the Finna API call\n if author:\n extra_info += [\"author:\\\"\" + author + \"\\\"\"]\n elif intent['sessionAttributes'].get('author'):\n extra_info += [\n \"author:\\\"\" + intent['sessionAttributes']['author'] + \"\\\"\"\n ]\n\n # The Finna API call\n request = lookfor(term=subject, filter=extra_info)['json']\n\n return parse_subject(request, subject, {'author': author})","def getSequencesFromSample(self, study_id, sample_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('qiime_assets.get_sequences_for_fasta', [study_id, sample_id, results])\n seqs = {}\n for row in results:\n seqs[row[0]] = row[1]\n return seqs \n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def detail(self):\n url = '/question/%d' % self.id\n d = req.get(url)\n return parser.detail(d)","def get_metadata(data):\n genres = list(data[\"genre\"])\n print(\"genres:\", len(set(genres)), set(genres))\n return genres","def get_song(self): \n\n song = self.tracks.sample(n=1).to_dict('index')\n return list(song.values())[0]","def show():\n\n quality_list = []\n\n conn = sqlite3.connect(\"person_database.bd\")\n c = conn.cursor()\n\n c.execute(\"SELECT *, oid FROM person_info\")\n records = c.fetchall()\n\n conn.commit()\n conn.close()\n\n for record in records:\n quality_list.append(str(record[2]) + \" \" + str(record[0]))\n\n return quality_list","def report_seq(self, seq_map):\n sents = []\n for i in range(0, len(seq_map)):\n\n if seq_map[i]['paragraph']:\n # text += \"\\n \"\n quote_start = '\"'\n else:\n quote_start = \"\"\n if i > len(seq_map) - 2 or seq_map[i + 1]['paragraph']:\n quote_end = '\"'\n else:\n quote_end = \" \"\n if len(seq_map[i]['speech_act']) > 0:\n speech_act = seq_map[i]['speech_act'] + \",\"\n else:\n speech_act = seq_map[i]['speech_act']\n tokens = [utils.START_TOKEN]\n tokens.append(seq_map[i]['speaker_str'])\n tokens.append(speech_act)\n tokens.append(quote_start)\n tokens.extend(seq_map[i]['speech'][1:-1])\n tokens.append(quote_end)\n tokens.append(utils.END_TOKEN)\n sents.append(tokens)\n return sents","def get_repeat_info(self, seq_descr: str, repeat_id: int) -> Optional[Tuple[str, Union[str, int]]]:\n seq_name: str = Sequencer.get_name(seq_descr)\n seq: Optional['Sequencer'] = self.get_seq_by_name(seq_name)\n if seq is None:\n return None\n return seq.get_repeat_info(repeat_id)","def get(self):\n return orthanc.study(self.orthanc_id)","def get_salience(self):\n return self.salience","def print_songs(self):\n\t\tfor i,s in enumerate(self._songs):\n\t\t\tprint('{0}. {1}'.format(i, s.print_info()))","def display_seqres_seq():\n \n import os\n choice = input('Enter the name of the file: ')\n filepath = os.path.join('/home/njesh/python-mini-project-JaneNjeri/Data', choice)\n with open(filepath, 'r') as file:\n for line in file:\n if line[:6] == 'SEQRES':\n line_split = line.split()[4:]\n print(line_split)\n return file","def get_info(self):\n self.exists = self.check_subscr()\n return self.attrs","def get_identifier(self):\n return 'Sequence SMNIST'","def get_seq(self): # -> list[Unknown]:\n ...","def getQiimeSffSamples(self, study_id,seq_run_id):\n try:\n con = self.getSFFDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('get_qiime_sff_samples', \\\n [study_id,seq_run_id,results])\n return results\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), str(e))\n return False","def scrutiny(raw_data=\"\"):\n # Per molecule in DW's listing file, extract count of stereo centres,\n # cistrans double bonds, and assigned diff_inchi label.\n survey = []\n with open(raw_data, mode=\"r\") as source:\n for line in source:\n line = str(line).strip()\n data = line.split(\"\\t\")\n\n stereo = data[0]\n cistrans = data[1]\n diff_inchi = data[9]\n\n retain = str(f\"{stereo} {cistrans} {diff_inchi}\")\n survey.append(retain)\n\n # remove the header line:\n del survey[0]\n\n # for a frequency count, build a dictionary:\n counting = {}\n for instance in survey:\n counting.setdefault(instance, 0)\n counting[instance] = counting[instance] + 1\n\n # convert the dictionary into a list which may be sorted:\n listing = []\n for key, value in counting.items():\n retain = str(\n f\"stereo, E/Z, label diff_inchi:\\t{key}\\tfrequency:\\t{value}\")\n listing.append(retain)\n listing.sort()\n\n # the eventual report:\n with open(\"frequency_list.txt\", mode=\"w\") as newfile:\n for element in listing:\n print(element)\n newfile.write(f\"{element}\\n\")\n\n print(\"\\nSee file 'frequency_list.txt' for a permanent record.\")","def get_details(disease):\n\treturn d_desc_map[disease]","def _get_sample_information(sample: domain.Sample) -> Dict[str, str]: # pragma: no cover\n # TODO: This ideally should be replaced with a constant, rather than a hard-coded string.\n return {\"SampleID\": sample.guid}","def getResidueInformation(self, resIDs=None, atomIDs=None):\n if resIDs is None:\n resIDs = set ()\n else:\n resIDs = set (resIDs)\n\n if atomIDs is not None:\n for i in atomIDs:\n resIDs.add (self._atomInfo[i][\"residue\"])\n return self.getResidueInformation (resIDs=resIDs)\n\n resIDs = list (resIDs)\n resIDs.sort ()\n str=''\n for res in resIDs:\n str=str+self._residueInfo[res][\"name\"]\n print self._shortenResidue (str)\n str = ''\n return dict ((resID, self._residueInfo[resID]) for resID in resIDs)","def instruments(self):\r\n return self.get_field('instrument')","def info(self):\n txt = \"\"\"Lick Index {s.name}\n wavelength units: {s.wavelength_unit}\n Index Band: {s.band}\n Blue continuum band: {s.blue}\n Red continuum band: {s.red}\n Measurement unit: {s.index_unit}\"\"\".format(s=self)\n print(txt)","def info(self):\n txt = \"\"\"Lick Index {s.name}\n wavelength units: {s.wavelength_unit}\n Index Band: {s.band}\n Blue continuum band: {s.blue}\n Red continuum band: {s.red}\n Measurement unit: {s.index_unit}\"\"\".format(s=self)\n print(txt)","def get_technical_details(self):\n\n url = \"https://www.imdb.com/title/%s/reference\" % (self.film_id)\n return Scraper(url).scrape_technical_data()","def get_song_info(self, song_id):\n return self.__get('song', song_id)","def infotoids(seqsinfo, outdir):\n allids = [x.patient_id for x in seqsinfo]\n # TODO: check all patient_ids are the same\n s = allids[0]\n\n return({'subject': \"sub-\" + IDLOOKUP.get(s, 'UNKNOWN'),\n 'locator': None, 'session': None})","def cds_desc(gff3, fasta):\n seqs = {}\n for defline, seq in LocusPocus.fasta.parse(fasta):\n seqid = defline[1:].split(' ')[0]\n if seqid not in seqs:\n seqs[seqid] = seq\n\n accession = ''\n cdslen = 0\n for entry in gff3:\n if '\\tCDS\\t' in entry:\n fields = entry.rstrip().split('\\t')\n assert len(fields) == 9\n accession = re.search(r'accession=([^;\\n]+)', fields[8]).group(1)\n cdslen += int(fields[4]) - int(fields[3]) + 1\n elif entry.startswith('###'):\n if accession:\n cdsseq = seqs[accession]\n if len(cdsseq) != cdslen:\n message = 'CDS for \"%s\": length mismatch' % accession\n message += ' (gff3=%d, fa=%d)' % (cdslen, len(cdsseq))\n message += '; most likely a duplicated accession'\n message += ', discarding'\n print(message, file=sys.stderr)\n else:\n gccontent = gc_content(cdsseq)\n gcskew = gc_skew(cdsseq)\n ncontent = n_content(cdsseq)\n values = '%s %d %.3f %.3f %.3f' % (\n accession, cdslen, gccontent, gcskew, ncontent)\n yield values.split(' ')\n accession = ''\n cdslen = 0","def show_info(self):\n # attr[0] attr[1]\n attrs = [(self.TYP.value, 'nam'),\n ('Skill', 'skl')]\n # voeg ook alle stats en skills in deze lijst toe.\n for stat in Minimals:\n attrs.append((stat.value, stat.name))\n attrs.append(('Spell Battery', 'cur_bat'))\n for stat in StatType:\n attrs.append((stat.value, stat.name))\n for skill in SkillType:\n attrs.append((skill.value, skill.name))\n\n # nu alle mogelijkheden geladen zijn, ga dan aan de slag met diegene die van toepassing zijn\n attr_list = []\n\n import enum\n for attr in attrs:\n value_of_attr = self.get_value_of(attr[1])\n # uitzondering, 'wht' altijd gewoon weergeven\n if attr[0] == StatType.wht.value:\n # deze uitzondering geldt niet voor weapons en shields.\n if not isinstance(self.get_value_of('skl'), enum.Enum): # niet wanneer 'skl' een waarde heeft\n attr_list.append((attr[0], str(value_of_attr)))\n elif value_of_attr:\n if isinstance(value_of_attr, enum.Enum): # uitzondering alleen voor 'skl'\n value_of_attr = value_of_attr.value\n elif attr[0] == StatType.hit.value: # uitzondering alleen voor 'hit'\n value_of_attr = str(value_of_attr)+\"%\"\n attr_list.append((attr[0], str(value_of_attr)))\n\n return attr_list","def info(self):\r\n\r\n return self.sim_info","def show_recs(self):\n if len(self.storage.records) == 0:\n return \"Records not found!\"\n else:\n string_of_records = \"\"\n for record in self.storage.records:\n string_of_records += record.to_string()\n return string_of_records","def getFrequencyDict(sequence):\n # freqs: dictionary (element_type -> int)\n \n for x in sequence:\n hand[x] = hand.get(x,0) + 1\n updatehand(hand, word)\n print hand\n print \"freq function\"\n #return hand","def get_patient(drs):\n for line in drs:\n if line.strip().startswith('sem'):\n datalist = line.split(':')\n for word in datalist: \n if word.count('patient') > 0:\n variable = word[6:7]\n for word in datalist:\n if word.startswith('pred({0}'.format(variable)):\n return word.split(',')[1]","def get_experiment_speaker_info(db_root):\n seen_speakers = ['VCTK-speaker-p225-female',\n 'VCTK-speaker-p226-male',\n 'VCTK-speaker-p227-male',\n 'VCTK-speaker-p228-female',\n 'VCTK-speaker-p229-female',\n 'VCTK-speaker-p230-female',\n 'VCTK-speaker-p231-female',\n 'VCTK-speaker-p232-male',\n 'VCTK-speaker-p233-female',\n 'VCTK-speaker-p234-female',\n 'VCTK-speaker-p236-female',\n 'VCTK-speaker-p237-male',\n 'VCTK-speaker-p238-female',\n 'VCTK-speaker-p239-female',\n 'VCTK-speaker-p240-female',\n 'VCTK-speaker-p241-male',\n 'VCTK-speaker-p243-male',\n 'VCTK-speaker-p244-female',\n 'VCTK-speaker-p245-male',\n 'VCTK-speaker-p246-male',\n 'VCTK-speaker-p247-male',\n 'VCTK-speaker-p248-female',\n 'VCTK-speaker-p249-female',\n 'VCTK-speaker-p250-female',\n 'VCTK-speaker-p251-male',\n 'VCTK-speaker-p252-male',\n 'VCTK-speaker-p253-female',\n 'VCTK-speaker-p254-male',\n 'VCTK-speaker-p255-male',\n 'VCTK-speaker-p256-male',\n 'VCTK-speaker-p257-female',\n 'VCTK-speaker-p258-male',\n 'VCTK-speaker-p259-male',\n 'VCTK-speaker-p260-male',\n 'VCTK-speaker-p261-female',\n 'VCTK-speaker-p262-female',\n 'VCTK-speaker-p263-male',\n 'VCTK-speaker-p264-female',\n 'VCTK-speaker-p265-female',\n 'VCTK-speaker-p266-female',\n 'VCTK-speaker-p267-female',\n 'VCTK-speaker-p268-female',\n 'VCTK-speaker-p269-female',\n 'VCTK-speaker-p270-male',\n 'VCTK-speaker-p271-male',\n 'VCTK-speaker-p272-male',\n 'VCTK-speaker-p273-male',\n 'VCTK-speaker-p274-male',\n 'VCTK-speaker-p275-male',\n 'VCTK-speaker-p276-female',\n 'VCTK-speaker-p277-female',\n 'VCTK-speaker-p278-male',\n 'VCTK-speaker-p279-male',\n 'VCTK-speaker-p280-female',\n 'VCTK-speaker-p281-male',\n 'VCTK-speaker-p282-female',\n 'VCTK-speaker-p283-female',\n 'VCTK-speaker-p284-male',\n 'VCTK-speaker-p285-male',\n 'VCTK-speaker-p286-male',\n 'VCTK-speaker-p287-male',\n 'VCTK-speaker-p288-female',\n 'VCTK-speaker-p292-male',\n 'VCTK-speaker-p293-female',\n 'VCTK-speaker-p294-female',\n 'VCTK-speaker-p295-female',\n 'VCTK-speaker-p297-female',\n 'VCTK-speaker-p298-male',\n 'VCTK-speaker-p299-female',\n 'VCTK-speaker-p300-female',\n 'VCTK-speaker-p301-female',\n 'VCTK-speaker-p302-male',\n 'VCTK-speaker-p303-female',\n 'VCTK-speaker-p304-male',\n 'VCTK-speaker-p305-female',\n 'VCTK-speaker-p306-female',\n 'VCTK-speaker-p307-female',\n 'VCTK-speaker-p308-female',\n 'VCTK-speaker-p310-female',\n 'VCTK-speaker-p311-male',\n 'VCTK-speaker-p312-female',\n 'VCTK-speaker-p313-female',\n 'VCTK-speaker-p314-female',\n 'VCTK-speaker-p316-male',\n 'VCTK-speaker-p317-female',\n 'VCTK-speaker-p318-female',\n 'VCTK-speaker-p323-female',\n 'VCTK-speaker-p326-male',\n 'VCTK-speaker-p329-female',\n 'VCTK-speaker-p330-female',\n 'VCTK-speaker-p333-female',\n 'VCTK-speaker-p334-male',\n 'VCTK-speaker-p335-female',\n 'VCTK-speaker-p336-female',\n 'VCTK-speaker-p339-female',\n 'VCTK-speaker-p340-female',\n 'VCTK-speaker-p341-female',\n 'VCTK-speaker-p343-female',\n 'VCTK-speaker-p345-male',\n 'VCTK-speaker-p347-male',\n 'VCTK-speaker-p351-female',\n 'VCTK-speaker-p360-male',\n 'VCTK-speaker-p361-female',\n 'VCTK-speaker-p362-female',\n 'VCTK-speaker-p363-male',\n 'VCTK-speaker-p364-male',\n 'VCTK-speaker-p374-male',\n 'VCTK-speaker-p376-male']\n\n # speaker index list for training and validation\n n_speaker = len(seen_speakers)\n\n # take all speakers in train and validation!!!\n train_speakers = seen_speakers\n valid_speakers = seen_speakers\n print('number of VCTK speakers = %d' % n_speaker)\n\n sp2id = {sp: i for i, sp in enumerate(seen_speakers)}\n id2sp = {i: sp for i, sp in enumerate(seen_speakers)}\n\n return seen_speakers, sp2id, id2sp","def _get_info(self, id, score=None):\n try:\n info_query = f\"\"\"\n SELECT m.primary_title, m.start_year, r.average_rating, r.num_votes\n FROM movies m\n JOIN ratings r ON m.movie_id = r.movie_id\n WHERE m.movie_id = '{id}'\"\"\"\n self.cursor_dog.execute(info_query)\n except Exception as e:\n return tuple([f\"Movie title unknown. ID:{id}\", None, None, None, None, None, None, id])\n\n t = self.cursor_dog.fetchone()\n if t:\n title = tuple([t[0], t[1], f\"https://www.imdb.com/title/tt{id}/\",\n f\"https://www.letterboxd.com/imdb/tt{id}/\", t[2], t[3], score, id])\n return title\n else:\n return tuple([f\"Movie title not retrieved. ID:{id}\", None, None, None, None, None, None, id])","def info(self):\n past_shows = self.get_shows(Show.start_time <= datetime.now())\n upcoming_shows = self.get_shows(Show.start_time > datetime.now())\n\n return {\n 'id': self.id,\n 'name': self.name,\n 'genres': self.genres,\n 'address': self.address,\n 'city': self.city,\n 'state': self.state,\n 'phone': self.phone,\n 'website': self.website,\n 'facebook_link': self.facebook_link,\n 'seeking_talent': self.seeking_talent,\n 'seeking_description': self.seeking_description,\n 'image_link': self.image_link,\n 'past_shows': past_shows,\n 'upcoming_shows': upcoming_shows,\n 'past_shows_count': len(past_shows),\n 'upcoming_shows_count': len(upcoming_shows)\n }","def get_raw_information(self):\n try:\n info = self.student_attendance_record.get_period_info(\n self.start_date, self.day_periods)\n return (self.student_name, self.student_gender, info)\n except AttributeError:\n raise AttributeError, \\\n \"Failed to get student attendance record for: %s\" \\\n %unicode(self.student)","def getVSMSpace():\n sids,documents = getSongTextInfo()\n texts = [[word for word in document.lower().split()] for document in documents]\n dictionary = corpora.Dictionary(texts)\n corpus = [dictionary.doc2bow(text) for text in texts]\n songMap = {}\n index = 0\n for doc in corpus:\n sid = sids[index]\n rMap = {}\n for item in doc:\n wid = item[0]\n count = item[1]\n rMap[wid] = count\n songMap[sid] = rMap\n index += 1\n return songMap","def print_freqs(self):\n words = list(self.freqs)[0:10]\n print()\n for word in words:\n print(word[0].rjust(15) + \" | \" + str(word[1]).ljust(3) + \" \" + (word[1] * \"*\"))","def get_sequence(self):\n\n with open(self.input_file, 'r') as input_file:\n\n tree = ET.parse(input_file)\n root = tree.getroot()\n\n #print('Root:', root)\n\n # TODO: Expand to handle multiple parts\n part_list_idx = -1\n part_idx = -1\n\n # Find <part-list> and <part> element indexes\n for i, child in enumerate(root):\n if child.tag == 'part-list':\n part_list_idx = i\n elif child.tag == 'part':\n # Choose 1st part only to generate sequence\n part_idx = i if part_idx == -1 else part_idx\n\n # Check for bad MusicXML\n if part_list_idx == -1 or part_idx == -1:\n print('MusicXML file:', self.input_file,' missing <part-list> or <part>')\n return ['']\n sys.exit(0)\n\n # Get number of staves in the MusicXML\n num_staves = 1\n for e in root[part_idx][0][0]:\n if e.tag == 'staff-layout':\n num_staves = int(e.attrib['number'])\n staves = ['' for x in range(num_staves)]\n\n # Read each measure\n r_iter = iter(root[part_idx])\n for i, measure in enumerate(r_iter):\n\n # Gets the symbol sequence of each staff in measure\n measure_staves, skip = self.read_measure(measure, num_staves, i)\n\n for j in range(num_staves):\n staves[j] += measure_staves[j]\n\n for j in range(skip-1):\n next(r_iter)\n\n return staves","def samples():\n f = open(config['samples'], \"r\")\n samp=[]\n for line in f:\n samp.append(line.strip().split()[0])\n return samp","def instruments():\n instr_dict = {}\n #\n instr_dict['LRISr'] = 2**0\n instr_dict['LRISb'] = 2**1\n instr_dict['Kastb'] = 2**2\n instr_dict['shane_kast_red'] = 2**3\n instr_dict['shane_kast_red_ret'] = 2**3\n instr_dict['DEIMOS'] = 2**4\n instr_dict['NIRSPEC'] = 2**5\n instr_dict['GMOS'] = 2**6\n instr_dict['DBSP'] = 2**7\n #\n return instr_dict","def sense(self):\n # Get all PIMAP data from the queue.\n pimap_data = []\n while not self.pimap_data_queue.empty():\n pimap_data.append(self.pimap_data_queue.get())\n\n # Sort the PIMAP data by timestamp. The PIMAP data can be out of order because we are\n # using multiple processes to sense it.\n pimap_data.sort(key=lambda x: float(pu.get_timestamp(x)))\n\n timestamps = (list(map(lambda x: float(pu.get_timestamp(x)), pimap_data)))\n self.latencies.extend(time.time() - np.array(timestamps))\n # Track the amount of sensed PIMAP data.\n self.sensed_data += len(pimap_data)\n\n # If system_samples is True and a system_sample was not created within the last\n # system_samples period, create a system_sample.\n pimap_system_samples = []\n if (self.system_samples and\n (time.time() - self.system_samples_updated > self.system_samples_period)):\n sample_type = \"system_samples\"\n if self.app != \"\":\n sample_type += \"_\" + self.app\n # Identify PIMAP Sense using the host and port.\n patient_id = \"sense\"\n device_id = (self.host, self.port)\n sensed_data_per_s = self.sensed_data/(time.time() - self.system_samples_updated)\n sample = {\"throughput\":sensed_data_per_s}\n if len(self.latencies) > 0:\n sample[\"latency\"] = np.mean(self.latencies)\n system_sample = pu.create_pimap_sample(sample_type, patient_id, device_id, sample)\n pimap_system_samples.append(system_sample)\n\n # Reset system_samples variables.\n self.system_samples_updated = time.time()\n self.sensed_data = 0\n self.latencies = []\n\n return pimap_data + pimap_system_samples","def seqfreqs(seqs):\n #if \"seqfreqs\" in options.debug:\n # print(\"There are {} seqs\".format(len(seqs)))\n x = []\n #this block calculates the frequencies of each sequence\n for i in range(len(seqs)):\n this_x = 0\n for j in range(len(seqs)):\n if str(seqs[i]) == str(seqs[j]):\n #if \"seqfreqs\" in options.debug:\n # print(\"{} == {}\".format(i, j))\n this_x += 1\n x.append(this_x/len(seqs))\n #print(\"done with these seqfreqs\\n\")\n #if \"seqfreqs\" in options.debug:\n # print(\"the frequencies are {}\".format(x))\n return x","def display_genre(self):\n \n # Get first 3 genres and join to a string.\n return ', '.join([ genre.name for genre in self.genre.all()[:3] ])","def info(self):\n past_shows = self.get_shows(Show.start_time <= datetime.now())\n upcoming_shows = self.get_shows(Show.start_time > datetime.now())\n\n return {\n 'id': self.id,\n 'name': self.name,\n 'genres': self.genres,\n 'city': self.city,\n 'state': self.state,\n 'phone': self.phone,\n 'website': self.website,\n 'facebook_link': self.facebook_link,\n 'seeking_venue': self.seeking_venue,\n 'seeking_description': self.seeking_description,\n 'image_link': self.image_link,\n 'past_shows': past_shows,\n 'upcoming_shows': upcoming_shows,\n 'past_shows_count': len(past_shows),\n 'upcoming_shows_count': len(upcoming_shows)\n }","def info(self):","def info(self):","def sr(self):\n return ''.join([str(seg) for seg in self.segments])","def sosid(self):\r\n return self.word2idx.get(SOS, 0)","def gather_sentences(self):\n sentences = Sentence.objects.all()\n return sentences","def get_residue_info(self):\n return","def s_metadata(self):\n index = self.var_index(s=True)\n return self.var_metadata(index)","def __str__(self):\n spkr_appeared = set([])\n for path in self._filepaths:\n sid = path.split('/')[-2][1:]\n assert sid in self._spkr_table, f\"{sid} not a valid speaker!\"\n spkr_appeared.add(sid)\n phoncts = {p: 0 for p in PHONETABLE}\n mindur = {p: 100 for p in PHONETABLE}\n maxdur = {p: 0 for p in PHONETABLE}\n for path in self._filepaths:\n sr = audioinfo(os.path.join(self.root, path)).samplerate\n path = os.path.join(self.root, os.path.splitext(path)[0]+'.PHN')\n for (ts, te), pp in phnread(path):\n assert pp in phoncts, f\"[{pp}] not in phone dict!\"\n phoncts[pp] += 1\n dur = (te - ts) / sr * 1000\n if mindur[pp] > dur:\n mindur[pp] = dur\n if maxdur[pp] < dur:\n maxdur[pp] = dur\n totcts = sum(v for p, v in phoncts.items())\n report = \"\"\"\n +++++ Summary for [{}] partition [{}] +++++\n Total [{}] valid files to be processed.\n Total [{}/{}] speakers appear in this set.\n [Phoneme]: [counts], [percentage], [min-max duration (ms)]\\n{}\n \"\"\".format(self.__class__.__name__,\n self.partition if hasattr(self, 'partition') else None,\n len(self._filepaths), len(spkr_appeared),\n len(self._spkr_table),\n \"\\n\".join(\n f\"\\t\\t[{p:>4}]: [{c:>4}], [{c*100/totcts:2.2f}%], [{mindur[p]:.1f}-{maxdur[p]:.0f}]\"\n for p, c in phoncts.items()))\n\n return report","def Show_Sequences( self ):\r\n self.system.Change_Seq( \"Sequence\" )","def get_frequency(self):\r\n return self._api.get_frequency()","def info(doc):\n\tinfo = {}\n\tinfo['sentences'] = [str(sent) for sent in doc.sents]\n\t#sentences : [sent1, sent2, ...]\n\tinfo['tokens'] = [str(token) for token in doc]\n\t#all tokens in info['tokens']\n\ttoken_vals = {}\n\tfor token in info['tokens']:\n\t\tcurrent_word = token\n\t\ti = 0\n\t\tcurrent_sent = info['sentences'][i]\n\t\tfor i in range(len(info['sentences'])): #for each sentence\n\t\t\tval = current_sent.count(str(current_word))\n\t\t\t#value is the number of times the current word is in the current sent\n\t\t\ttoken_vals[str(token)] = val\n\t\t\t#append to dictionary\n\tinfo['token_vals'] = token_vals\n\t#given a word and a sentence, val is how many times it appears in that sentence\n\treturn info","def frequencies(self):\n return self._frequencies","def get_list_frequencies(self):\r\n _debug('simq03b_api.get_list_frequencies')\r\n \r\n s = self.query('SOUR:LIST:FREQ?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\r\n n += 1\r\n return a","def read(self):\n # open the .SPE file\n with open(self._input_file_path, 'rb') as f:\n lines = f.readlines()\n # Create an empty dictionary for the metadata\n metadata_dictionary = {}\n\n # Search through the file for the needed metadata\n metadata_dictionary['date_acquired'] = re.search(b'date=\"(.*?)\"', lines[1])[1].decode('ANSI') \n metadata_dictionary['width'] = int(re.search(b'width=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['height'] = int(re.search(b'height=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\"Double\">(.*?)</ExposureTime>', lines[1])[1])\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\"(.*?)\"',lines[1])[1])\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\"Double\">(.*?)</CenterWavelength>',lines[1])[1])\n metadata_dictionary['orientation'] = re.search(b'orientation=\"(.*?)\"',lines[1])[1].decode('ANSI')\n\n # Get the wavelength and intensity\n wavelength_string = re.search(b'<Wavelength xml:space=\"preserve\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\n\n f.seek(4100)\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\n\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\n\n f.close()\n \n # create the sidpy dataset\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\n\n data_set.data_type = 'spectrum'\n data_set.units = 'counts'\n data_set.quantity = 'Intensity'\n\n # set dimensions\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\n units = 'cm-1',\n quantity='Raman shift',\n dimension_type='spectral'))\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\n units = 'counts',\n quantity='intensity',\n dimension_type='spectral')) \n\n data_set.metadata = metadata_dictionary\n\n return data_set","def get_spices(self, key):\n spices = []\n if key == 'disease':\n spices.append('(disease|symptom|sign)')\n elif key == 'symptom':\n spices.append('(signs|symptoms)')\n elif key == 'treatment':\n spices.append('(treatment|medicine|operation)')\n return spices","def info_scrambled(out: Export = Export(\"cwb.encoded_scrambled/data/.info\"),\n sentences: AnnotationCommonData = AnnotationCommonData(\"misc.<sentence>_count\"),\n firstdate: AnnotationCommonData = AnnotationCommonData(\"cwb.datefirst\"),\n lastdate: AnnotationCommonData = AnnotationCommonData(\"cwb.datelast\"),\n resolution: AnnotationCommonData = AnnotationCommonData(\"dateformat.resolution\"),\n protected: bool = Config(\"korp.protected\")):\n create_info_file(sentences, firstdate, lastdate, resolution, protected, out)","def __str__(self):\n return self._seq","def get_records(self, _count, random=False):\n\n abtracts=[]\n titles=[]\n\n max_id = [max[0] for max in self.patents.execute(\"SELECT MAX(Id) FROM Patents;\")][0]\n order = \" ORDER BY id ASC \"\n\n if (random == True):\n ids = \"\"\n rands = [randint(1, max_id) for x in range(0, _count)]\n for i, _id in enumerate(rands):\n ids += \"\" + str(_id) + \"\"\n if i != _count - 1:\n ids += \",\"\n\n order = \" AND id IN (\" + ids + \")\"\n\n query = \"SELECT * FROM Patents WHERE (Description!='')\" + \\\n order + \" LIMIT \" + str(_count)\n # print query\n\n for row in self.patents.execute(query):\n # print row[3]\n # remove numbers and some unwantable characters\n text = ''.join(\n [i for i in row[2] if not i.isdigit() and i not in stopwords])\n\n abtracts.append(str(text))\n titles.append(str(row[3]))\n\n return ids, abtracts, titles","def get_passage(sample_name):\n #look for passage information pattern in sample_name\n regex_results = re.match(\"([A-Z0-9a-z_-]+).(P[T0-9]+)\", sample_name)\n #the passage information is the second element of the results\n passage = regex_results.groups()[1]\n return passage","def get_sequence_names(self):\r\n return Wiki().sequences_for_article_url(self.url).keys()","def get_type_of_studies(self) -> str:\n semestr = {\n 1: 'pierwszy',\n 2: 'drugi',\n 3: 'trzeci',\n 4: 'czwarty',\n 5: 'piąty',\n 6: 'szósty',\n 7: 'siódmy',\n 8: 'ósmy',\n 9: 'dziewiąty',\n 10: 'dziesiąty',\n 0: 'niezdefiniowany'}[\n self.semestr]\n return '%s, semestr %s' % (self.program, semestr)","def at_frequency(self):\n result = str(self.seq).count(\"A\") + str(self.seq).count(\"T\")\n return result","def get_info(self):\n return \"Malayalam Stemmer(Experimental)\"","def display_genre(self):\n\n\t\treturn ', '.join(genre.name for genre in self.genre.all()[:3])","def create_seq_record(self, s):\n gene_code = s['gene_code']\n length = self.gene_codes_metadata[gene_code]['length']\n sequence = s['sequences']\n length_difference = length - len(sequence)\n\n sequence += '?' * length_difference\n return sequence","def get_sdesc(self):\n return self._sdesc","def instruments(self) -> dict:\n return self._instruments","def getGenres(movieInfo):\n if \"genres\" in movieInfo:\n return [ _format(genre[\"name\"]) for genre in movieInfo[\"genres\"] ]\n else:\n raise AttributeError(\"%s instance has no attribute genre\" % movieInfo)","def sequence_items(self):\r\n seq_css = 'ol#sequence-list>li>a>p'\r\n return self.q(css=seq_css).map(self._clean_seq_titles).results","def get_sentence(self):","def display_genre(self):\n return ', '.join(genre.name for genre in self.genre.all()[:3])","def GetFrequency(self):\n ...","def __str__(self):\n print('=' * 20, \"Subject Information\", '=' * 20)\n print(\"Subject Name: {}\".format(self.name))\n print(\"Pulse Data Length for general questions\")\n print(self.pulse_length[0:20])\n print(\"Number of general Questions: {}\".format(\n len(self.pulse_data[0])))\n print(\"Pulse Data Length for video 1\")\n print(\"Number of questions for video 1: {}\".format(\n len(self.pulse_data[1])))\n print(self.pulse_length[20:40])\n print(\"Pulse Data Length for video 2\")\n print(\"Number of questions for video 2: {}\".format(\n len(self.pulse_data[0])))\n print(self.pulse_length[40:60])\n print('Label Data')\n print(self.label_data)\n print('Label Data shape: {}'.format(self.label_data.shape))\n\n return ''","def _get_information(self):\n pass","def human_readable_info(self) -> str:\n next_session = unix_str(self._stat.next_session)\n last_session = unix_str(self._stat.last_session)\n return \"\"\"\n Next Session: {}\n Last Session: {}\n Repetitions: {}\n Health: {}\n ------------------------\n Past Quality (last 20):\n ------------------------\n {}\n \"\"\".format(\n next_session,\n last_session,\n self._stat.actual_repetitions,\n self._health(),\n self._past_quality_graph(),\n )","def display_genre(self):\n return ', '.join([ genre.name for genre in self.genre.all()[:3] ])"],"string":"[\n \"def getSongTextInfo():\\n sids = []\\n documents = []\\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\\n lines = sFile.readlines()\\n index = 0\\n for line in lines:\\n line.strip('\\\\n')\\n line.strip('\\\\r\\\\n')\\n items = line.split('>>')\\n sid = int(items[0])\\n text = items[1]\\n documents.append(text)\\n sids.append(sid)\\n sFile.close()\\n print 'len = ',len(sids)\\n print 'len = ',len(documents)\\n return sids,documents\",\n \"def info(self):\\n self.update_info()\\n print('Number of electrodes: ' + str(self.n_elecs))\\n print('Recording time in seconds: ' + str(self.dur))\\n print('Sample Rate in Hz: '+ str(self.sample_rate))\\n print('Number of sessions: ' + str(self.n_sessions))\\n print('Date created: ' + str(self.date_created))\\n print('Meta data: ' + str(self.meta))\",\n \"def getSentenceInfo(sentence):\\n\\tpass\",\n \"def details(self):\\n \\n sparql_results = self.query (\\\"\\\"\\\"\\n select distinct * where {\\n\\n BIND (<%s> as ?rc)\\n \\n ?rc olac:speaker ?participant .\\n ?participant austalk:id ?pid .\\n ?participant austalk:recording_site ?site .\\n ?site rdfs:label ?sitelabel .\\n \\n ?rc austalk:prototype ?component .\\n ?component austalk:shortname ?shortname .\\n ?rc dc:isPartOf ?rs .\\n ?rs austalk:prototype ?session .\\n ?session austalk:id ?sessionid .\\n \\n ?component austalk:name ?name . \\n\\\\\\n optional { ?rc austalk:audiorating ?arating .}\\n optional { ?rc austalk:videorating ?vrating .}\\n optional { ?rc austalk:comment ?comment .}\\n }\\\"\\\"\\\" % (self.identifier, ))\\n \\n # we expect one binding\\n bindings = sparql_results[\\\"results\\\"][\\\"bindings\\\"]\\n if len(bindings) == 1:\\n bindings = bindings[0]\\n self.participantId = bindings['pid']['value']\\n self.prototype = bindings['component']['value']\\n self.name = bindings['name']['value']\\n self.componentId = bindings['shortname']['value']\\n self.site = bindings['sitelabel']['value']\\n self.sessionId = bindings['sessionid']['value']\\n if bindings.has_key('arating'):\\n self.audiorating = bindings['arating']['value']\",\n \"def extract_information(preprocessed_sentences):\\n parsed = list(map(lambda sentence: nlp(sentence), preprocessed_sentences))\\n\\n quantities = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'QUANTITY'), parsed))\\n dates = list(filter(lambda sentence: eh.sentence_has_type(sentence, 'DATE'), parsed))\\n\\n hurricane_name = eh.extract_frequent_regex_match(parsed, '[Hh]urricane ([A-Z][a-z]+)').most_common(1)[0][0]\\n hurricane_category = eh.extract_frequent_regex_match(parsed, '[Cc]ategory ([0-9]+)').most_common(1)[0][0]\\n\\n tropical_storm_name = eh.extract_frequent_regex_match(parsed, '[Tt]ropical [Ss]torm ([A-Z][a-z]+)').most_common(1)[0][0]\\n formation_date, middle_month = extract_storm_timeline(dates, hurricane_name)\\n\\n preperation_info = extract_preparation_information(parsed)\\n prep_gpes = preperation_info[0].most_common(3)\\n\\n restore_info = extract_restoration_information(parsed)\\n\\n landfall_info = extract_landfall_information(parsed)\\n\\n wind_info = extract_wind_information(quantities)\\n rain_info = extract_rain_information(quantities)\\n size_info = extract_size_information(parsed)\\n\\n # formation_info = extract_formation_info(parsed)\\n death_info = extract_death_damages_info(parsed)\\n\\n print(constants.HURRICANE_SENTENCE.format(hurricane_name, middle_month, hurricane_category))\\n print(constants.LANDFALL_SENTENCE.format(hurricane_name, landfall_info[2], landfall_info[3], landfall_info[0], landfall_info[1]))\\n print(constants.WIND_SENTENCE.format(wind_info[0], wind_info[1], wind_info[2]))\\n print(constants.RAIN_SENTENCE.format(hurricane_name, rain_info[1], rain_info[0], rain_info[2]))\\n print(constants.FORMATION_SENTENCE.format(formation_date, tropical_storm_name))\\n print(constants.PREPARATION_SENTENCE.format(prep_gpes[0][0], prep_gpes[1][0], prep_gpes[2][0], preperation_info[1].\\n most_common(1)[0][0]))\\n print(constants.SIZE_SENTENCE.format(size_info[0], size_info[1]))\",\n \"def info(self) -> list[int]:\",\n \"def get_phrase(self):\\n counter = 30 # give us a full 2 seconds of time to start\\n\\n with closing(self.Mic()) as mic:\\n log.info('Recording phrase.')\\n while True:\\n frames = mic.next()\\n\\n score, has_disturbance = self.scorer.add(frames)\\n\\n if counter < 15 and has_disturbance:\\n log.info('Recording more in phrase.')\\n counter = 15\\n else:\\n counter -= 1\\n\\n if counter >= 1:\\n yield frames\",\n \"def info(self):\\n return self.__dict__[self.sid]\",\n \"def get_freq_details(diagnostics_dir, verbose=False):\\n metafile_science = find_metadata_file(diagnostics_dir, 'mslist-scienceData*txt', verbose=False)\\n if not metafile_science:\\n return None, None, None\\n\\n with open(metafile_science, 'r') as mslist_file:\\n lines = mslist_file.readlines()\\n\\n in_spw_block = False\\n for line in lines:\\n if in_spw_block:\\n parts = line.split()\\n chan_width = float(parts[10])*1000. # convert kHz to Hz\\n cfreq = parts[12] #MHz\\n nchan = parts[7]\\n break\\n else:\\n in_spw_block = line.find('Frame') >= 0\\n\\n return chan_width, cfreq, nchan\",\n \"def read_ams(self):\\n current = time.time()\\n try:\\n if current - self.start > 3:\\n self.track_artist = not self.track_artist\\n self.start = time.time()\\n if self.track_artist:\\n data = self.ams.artist\\n if not self.track_artist:\\n data = self.ams.title\\n except (RuntimeError, UnicodeError):\\n data = None\\n\\n if data:\\n data = data[:16] + (data[16:] and '..')\\n\\n return data\",\n \"def infotodict(seqinfo):\\n \\n \\\"\\\"\\\"\\n MCF Pilot Protocol acquired on Friday April 13th\\n \\n >>> hdc_look.py -s mfc001 -ss 1\\n series_id sequence_name series_description dim1 dim2 dim3 dim4 TR TE is_derived is_motion_corrected\\n 0 1-localizer *fl2d1 localizer 192 192 3 1 0.020 5.00 False False\\n 1 2-pre_Neutral1_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral1_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 2 3-pre_topup_A>>P *epse2d1_64 pre_topup_A>>P 64 64 140 1 2.400 38.00 False False\\n 3 4-pre_topup_P>>A *epse2d1_64 pre_topup_P>>A 64 64 140 1 2.400 38.00 False False\\n 4 5-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 4.92 False False\\n 5 6-Field_mapping 4X4X4 A>>P *fm2d2r Field_mapping 4X4X4 A>>P 64 64 35 1 0.488 7.38 False False\\n 6 7-pre+heat1_A>>P 4X4X4 *epfid2d1_64 pre+heat1_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 7 8-pre_Neutral2_A>>P Resting 4X4X4 *epfid2d1_64 pre_Neutral2_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 8 9-pre+heat2_A>>P 4X4X4 *epfid2d1_64 pre+heat2_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 9 10-MPRAGE_GRAPPA2 *tfl3d1_16ns MPRAGE_GRAPPA2 256 240 192 1 2.300 2.98 False False\\n 10 11-post_Neutral3_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral3_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 11 12-post+heat3_A>>P 4X4X4 *epfid2d1_64 post+heat3_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 12 13-post_Neutral4_A>>P Resting 4X4X4 *epfid2d1_64 post_Neutral4_A>>P Resting 4X4X4 64 64 35 148 2.000 25.00 False False\\n 13 14-post+heat4_A>>P 4X4X4 *epfid2d1_64 post+heat4_A>>P 4X4X4 64 64 35 148 2.000 25.00 False False\\n 14 15-post_topup_A>>P *epse2d1_64 post_topup_A>>P 64 64 140 1 2.400 38.00 False False\\n 15 16-post_topup_P>>A *epse2d1_64 post_topup_P>>A 64 64 140 1 2.400 38.00 False False\\n \\n \\\"\\\"\\\"\\n\\n bids_prefix = 'sub-{subject}/{session}/'\\n\\n pre_neutral1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_heat1_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_heat2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-fmap_bold.{item:01d}')\\n pre_neutral2_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-fmap_bold.{item:01d}')\\n\\n pre_neutral1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral1_acq-epi_rec-topup_bold.{item:01d}')\\n pre_heat1_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat1_acq-epi_rec-topup_bold.{item:01d}')\\n pre_heat2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preHeat2_acq-epi_rec-topup_bold.{item:01d}')\\n pre_neutral2_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-preNeutral2_acq-epi_rec-topup_bold.{item:01d}')\\n\\n pre_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-ap_epi.{item:01d}')\\n pre_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-preEpi_dir-pa_epi.{item:01d}')\\n\\n # The item was commented out for Phase Difference field maps. Conversion did not work correctly. I removed the item number to try to\\n # isolate the problem.\\n\\n pre_fmap_magnitude1 = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_magnitude1.{item:01d}')\\n pre_fmap_phasediff = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-pre_phasediff.{item:01d}')\\n\\n t1w = create_key(bids_prefix + 'anat/sub-{subject}_{session}_T1w')\\n\\n post_neutral3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-fmap_bold.{item:01d}')\\n post_heat3_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-fmap_bold.{item:01d}')\\n post_heat4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-fmap_bold.{item:01d}')\\n post_neutral4_ap_fmap = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-fmap_bold.{item:01d}')\\n\\n post_neutral3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral3_acq-epi_rec-topup_bold.{item:01d}')\\n post_heat3_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat3_acq-epi_rec-topup_bold.{item:01d}')\\n post_heat4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postHeat4_acq-epi_rec-topup_bold.{item:01d}')\\n post_neutral4_ap_topup = create_key(bids_prefix + 'func/sub-{subject}_{session}_task-postNeutral4_acq-epi_rec-topup_bold.{item:01d}')\\n\\n post_topup_ap = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-ap_epi.{item:01d}')\\n post_topup_pa = create_key(bids_prefix + 'fmap/sub-{subject}_{session}_acq-postEpi_dir-pa_epi.{item:01d}')\\n\\n # Create an empty dictionary called info for each key\\n\\n info = {pre_neutral1_ap_fmap: [],\\n pre_heat1_ap_fmap: [],\\n pre_heat2_ap_fmap: [],\\n pre_neutral2_ap_fmap: [],\\n\\n pre_neutral1_ap_topup: [],\\n pre_heat1_ap_topup: [],\\n pre_heat2_ap_topup: [],\\n pre_neutral2_ap_topup: [],\\n\\n pre_topup_ap: [],\\n pre_topup_pa: [],\\n\\n pre_fmap_magnitude1: [],\\n pre_fmap_phasediff: [],\\n\\n t1w: [],\\n\\n post_neutral3_ap_fmap: [],\\n post_heat3_ap_fmap: [],\\n post_heat4_ap_fmap: [],\\n post_neutral4_ap_fmap: [],\\n\\n post_neutral3_ap_topup: [],\\n post_heat3_ap_topup: [],\\n post_heat4_ap_topup: [],\\n post_neutral4_ap_topup: [],\\n\\n post_topup_ap: [],\\n post_topup_pa: [],\\n\\n }\\n\\n # Loop over each sequence. Use if statements to determine which sequences should be linked to which key\\n\\n for idx, s in enumerate(seqinfo):\\n\\n if 'pre_Neutral1' in s.series_id:\\n info[pre_neutral1_ap_fmap].append([s.series_id])\\n info[pre_neutral1_ap_topup].append([s.series_id])\\n\\n if 'pre+heat1' in s.series_id:\\n info[pre_heat1_ap_fmap].append([s.series_id])\\n info[pre_heat1_ap_topup].append([s.series_id])\\n\\n if 'pre+heat2' in s.series_id:\\n info[pre_heat2_ap_fmap].append([s.series_id])\\n info[pre_heat2_ap_topup].append([s.series_id])\\n\\n if 'pre_Neutral2' in s.series_id:\\n info[pre_neutral2_ap_fmap].append([s.series_id])\\n info[pre_neutral2_ap_topup].append([s.series_id])\\n\\n if 'pre_topup_A>>P' in s.series_id:\\n info[pre_topup_ap].append([s.series_id])\\n\\n if 'pre_topup_P>>A' in s.series_id:\\n info[pre_topup_pa].append([s.series_id])\\n\\n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\\n (s.TE == 4.92)):\\n info[pre_fmap_magnitude1].append([s.series_id])\\n \\n if (('Field_mapping 4X4X4 A>>P' in s.series_id) and\\n (s.TE == 7.38)):\\n info[pre_fmap_phasediff].append([s.series_id])\\n\\n if 'MPRAGE_GRAPPA2' in s.series_id:\\n info[t1w].append([s.series_id])\\n\\n if 'post_Neutral3' in s.series_id:\\n info[post_neutral3_ap_fmap].append([s.series_id])\\n info[post_neutral3_ap_topup].append([s.series_id])\\n\\n if 'post+heat3' in s.series_id:\\n info[post_heat3_ap_fmap].append([s.series_id])\\n info[post_heat3_ap_topup].append([s.series_id])\\n\\n if 'post+heat4' in s.series_id:\\n info[post_heat4_ap_fmap].append([s.series_id])\\n info[post_heat4_ap_topup].append([s.series_id])\\n\\n if 'post_Neutral4' in s.series_id:\\n info[post_neutral4_ap_fmap].append([s.series_id])\\n info[post_neutral4_ap_topup].append([s.series_id])\\n\\n if 'post_topup_A>>P' in s.series_id:\\n info[post_topup_ap].append([s.series_id])\\n\\n if 'post_topup_P>>A' in s.series_id:\\n info[post_topup_pa].append([s.series_id])\\n\\n return info\",\n \"def audiences(self) -> pulumi.Output[Sequence[str]]:\\n return pulumi.get(self, \\\"audiences\\\")\",\n \"async def get_information():\\n return {\\n \\\"message\\\": f\\\"You are the Genome Researcher. \\\"\\n f\\\"You are meddling with Coronavirus Sars-Cov-2 RNA... \\\"\\n f\\\"Try to change the RNA at your disposal to uncover as many medical breakthroughs as possible. \\\"\\n f\\\"use GET /sample to see the original RNA strand \\\"\\n f\\\"use COPY /sample to create exact duplicate of original to perform experiments. \\\"\\n f\\\"Try to change the RNA at your disposal to uncover as many medical breakthroughs as possible. \\\"\\n f\\\"Good luck researcher. \\\"\\n f\\\"Our souls fates' depend on you! \\\"\\n }\",\n \"def frequency():\\n\\n return make_simple_tsv_get_response(FREQ_FILE, 'frequency')\",\n \"def getLSASpace():\\n sids,documents = getSongTextInfo()\\n texts = [[word for word in document.lower().split()] for document in documents]\\n dictionary = corpora.Dictionary(texts)\\n corpus = [dictionary.doc2bow(text) for text in texts]\\n tfidf = models.TfidfModel(corpus)\\n corpus_tfidf = tfidf[corpus]\\n lsi = models.LsiModel(corpus_tfidf, id2word=dictionary, num_topics=30)\\n corpus_lsi = lsi[corpus_tfidf]\\n songMap = {}\\n index = 0\\n for doc in corpus_lsi:\\n sid = sids[index]\\n rMap = {}\\n for item in doc:\\n wid = item[0]\\n count = item[1]\\n rMap[wid] = count\\n songMap[sid] = rMap\\n index += 1\\n return songMap\",\n \"def getInfo():\",\n \"def dnasequence(self):\\n return parseSingleFasta(open(self.dna_file).readlines())[1]\",\n \"def info():\\n # -------- Task 1 -------------------------\\n # Please complete the following information\\n\\n return {\\\"agent name\\\": \\\"?\\\", # COMPLETE HERE\\n \\\"student name\\\": [\\\"?\\\"], # COMPLETE HERE\\n \\\"student number\\\": [\\\"?\\\"]} # COMPLETE HERE\",\n \"def thesaurus(self, message):\\n read_pointer = open('Thesaurus.txt')\\n\\n for line in read_pointer:\\n split_line = line.split(':', 1)\\n if split_line[0] == message:\\n return split_line[1]\",\n \"def subject_info(intent, extra_info=[]):\\n\\n text = intent['inputTranscript'].lower()\\n utterances = AS.load_file('sample_utterances.txt')\\n\\n # add \\\"book\\\" and \\\"books\\\" to every utterance\\n for line in list(utterances):\\n utterances.insert(0, line + \\\" book\\\")\\n utterances.insert(0, line + \\\" books\\\")\\n\\n # tells how many characters needs to be dropped before the subject starts\\n to_drop = 0\\n\\n for line in utterances:\\n if text.startswith(line):\\n to_drop = len(line)\\n break\\n\\n # drops the characters and makes a list from the strings that are left\\n text = text[to_drop:].strip()\\n text_list = text.split(' ', len(text))\\n\\n subject_list = []\\n keywords = [\\\"books\\\", \\\"book\\\", \\\"by\\\", \\\"published\\\", \\\"written\\\"]\\n keyword = \\\"\\\"\\n\\n # Find out when the book name ends\\n for word in text_list:\\n if word not in keywords:\\n subject_list.append(word)\\n else:\\n break\\n\\n subject = \\\" \\\".join(subject_list)\\n\\n # Get all the keywords in the middle, so they can be\\n # all be dropped at once, eg written by, books by\\n text_list = text_list[len(subject_list):]\\n if text_list:\\n word = text_list[0]\\n while word in keywords:\\n keyword += word + \\\" \\\"\\n text_list = text_list[1:]\\n if text_list:\\n word = text_list[0]\\n else:\\n break\\n\\n # search for an author from the rest of the characters\\n author_text = text[len(keyword):].strip()\\n author = AS.search(author_text, False)\\n if author is \\\"\\\":\\n author = None\\n\\n # There might be old info in the extra_info (author), so \\n # we need to clear it\\n extra_info.clear()\\n\\n # add the author to extra info so it can be used in the Finna API call\\n if author:\\n extra_info += [\\\"author:\\\\\\\"\\\" + author + \\\"\\\\\\\"\\\"]\\n elif intent['sessionAttributes'].get('author'):\\n extra_info += [\\n \\\"author:\\\\\\\"\\\" + intent['sessionAttributes']['author'] + \\\"\\\\\\\"\\\"\\n ]\\n\\n # The Finna API call\\n request = lookfor(term=subject, filter=extra_info)['json']\\n\\n return parse_subject(request, subject, {'author': author})\",\n \"def getSequencesFromSample(self, study_id, sample_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('qiime_assets.get_sequences_for_fasta', [study_id, sample_id, results])\\n seqs = {}\\n for row in results:\\n seqs[row[0]] = row[1]\\n return seqs \\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def detail(self):\\n url = '/question/%d' % self.id\\n d = req.get(url)\\n return parser.detail(d)\",\n \"def get_metadata(data):\\n genres = list(data[\\\"genre\\\"])\\n print(\\\"genres:\\\", len(set(genres)), set(genres))\\n return genres\",\n \"def get_song(self): \\n\\n song = self.tracks.sample(n=1).to_dict('index')\\n return list(song.values())[0]\",\n \"def show():\\n\\n quality_list = []\\n\\n conn = sqlite3.connect(\\\"person_database.bd\\\")\\n c = conn.cursor()\\n\\n c.execute(\\\"SELECT *, oid FROM person_info\\\")\\n records = c.fetchall()\\n\\n conn.commit()\\n conn.close()\\n\\n for record in records:\\n quality_list.append(str(record[2]) + \\\" \\\" + str(record[0]))\\n\\n return quality_list\",\n \"def report_seq(self, seq_map):\\n sents = []\\n for i in range(0, len(seq_map)):\\n\\n if seq_map[i]['paragraph']:\\n # text += \\\"\\\\n \\\"\\n quote_start = '\\\"'\\n else:\\n quote_start = \\\"\\\"\\n if i > len(seq_map) - 2 or seq_map[i + 1]['paragraph']:\\n quote_end = '\\\"'\\n else:\\n quote_end = \\\" \\\"\\n if len(seq_map[i]['speech_act']) > 0:\\n speech_act = seq_map[i]['speech_act'] + \\\",\\\"\\n else:\\n speech_act = seq_map[i]['speech_act']\\n tokens = [utils.START_TOKEN]\\n tokens.append(seq_map[i]['speaker_str'])\\n tokens.append(speech_act)\\n tokens.append(quote_start)\\n tokens.extend(seq_map[i]['speech'][1:-1])\\n tokens.append(quote_end)\\n tokens.append(utils.END_TOKEN)\\n sents.append(tokens)\\n return sents\",\n \"def get_repeat_info(self, seq_descr: str, repeat_id: int) -> Optional[Tuple[str, Union[str, int]]]:\\n seq_name: str = Sequencer.get_name(seq_descr)\\n seq: Optional['Sequencer'] = self.get_seq_by_name(seq_name)\\n if seq is None:\\n return None\\n return seq.get_repeat_info(repeat_id)\",\n \"def get(self):\\n return orthanc.study(self.orthanc_id)\",\n \"def get_salience(self):\\n return self.salience\",\n \"def print_songs(self):\\n\\t\\tfor i,s in enumerate(self._songs):\\n\\t\\t\\tprint('{0}. {1}'.format(i, s.print_info()))\",\n \"def display_seqres_seq():\\n \\n import os\\n choice = input('Enter the name of the file: ')\\n filepath = os.path.join('/home/njesh/python-mini-project-JaneNjeri/Data', choice)\\n with open(filepath, 'r') as file:\\n for line in file:\\n if line[:6] == 'SEQRES':\\n line_split = line.split()[4:]\\n print(line_split)\\n return file\",\n \"def get_info(self):\\n self.exists = self.check_subscr()\\n return self.attrs\",\n \"def get_identifier(self):\\n return 'Sequence SMNIST'\",\n \"def get_seq(self): # -> list[Unknown]:\\n ...\",\n \"def getQiimeSffSamples(self, study_id,seq_run_id):\\n try:\\n con = self.getSFFDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('get_qiime_sff_samples', \\\\\\n [study_id,seq_run_id,results])\\n return results\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), str(e))\\n return False\",\n \"def scrutiny(raw_data=\\\"\\\"):\\n # Per molecule in DW's listing file, extract count of stereo centres,\\n # cistrans double bonds, and assigned diff_inchi label.\\n survey = []\\n with open(raw_data, mode=\\\"r\\\") as source:\\n for line in source:\\n line = str(line).strip()\\n data = line.split(\\\"\\\\t\\\")\\n\\n stereo = data[0]\\n cistrans = data[1]\\n diff_inchi = data[9]\\n\\n retain = str(f\\\"{stereo} {cistrans} {diff_inchi}\\\")\\n survey.append(retain)\\n\\n # remove the header line:\\n del survey[0]\\n\\n # for a frequency count, build a dictionary:\\n counting = {}\\n for instance in survey:\\n counting.setdefault(instance, 0)\\n counting[instance] = counting[instance] + 1\\n\\n # convert the dictionary into a list which may be sorted:\\n listing = []\\n for key, value in counting.items():\\n retain = str(\\n f\\\"stereo, E/Z, label diff_inchi:\\\\t{key}\\\\tfrequency:\\\\t{value}\\\")\\n listing.append(retain)\\n listing.sort()\\n\\n # the eventual report:\\n with open(\\\"frequency_list.txt\\\", mode=\\\"w\\\") as newfile:\\n for element in listing:\\n print(element)\\n newfile.write(f\\\"{element}\\\\n\\\")\\n\\n print(\\\"\\\\nSee file 'frequency_list.txt' for a permanent record.\\\")\",\n \"def get_details(disease):\\n\\treturn d_desc_map[disease]\",\n \"def _get_sample_information(sample: domain.Sample) -> Dict[str, str]: # pragma: no cover\\n # TODO: This ideally should be replaced with a constant, rather than a hard-coded string.\\n return {\\\"SampleID\\\": sample.guid}\",\n \"def getResidueInformation(self, resIDs=None, atomIDs=None):\\n if resIDs is None:\\n resIDs = set ()\\n else:\\n resIDs = set (resIDs)\\n\\n if atomIDs is not None:\\n for i in atomIDs:\\n resIDs.add (self._atomInfo[i][\\\"residue\\\"])\\n return self.getResidueInformation (resIDs=resIDs)\\n\\n resIDs = list (resIDs)\\n resIDs.sort ()\\n str=''\\n for res in resIDs:\\n str=str+self._residueInfo[res][\\\"name\\\"]\\n print self._shortenResidue (str)\\n str = ''\\n return dict ((resID, self._residueInfo[resID]) for resID in resIDs)\",\n \"def instruments(self):\\r\\n return self.get_field('instrument')\",\n \"def info(self):\\n txt = \\\"\\\"\\\"Lick Index {s.name}\\n wavelength units: {s.wavelength_unit}\\n Index Band: {s.band}\\n Blue continuum band: {s.blue}\\n Red continuum band: {s.red}\\n Measurement unit: {s.index_unit}\\\"\\\"\\\".format(s=self)\\n print(txt)\",\n \"def info(self):\\n txt = \\\"\\\"\\\"Lick Index {s.name}\\n wavelength units: {s.wavelength_unit}\\n Index Band: {s.band}\\n Blue continuum band: {s.blue}\\n Red continuum band: {s.red}\\n Measurement unit: {s.index_unit}\\\"\\\"\\\".format(s=self)\\n print(txt)\",\n \"def get_technical_details(self):\\n\\n url = \\\"https://www.imdb.com/title/%s/reference\\\" % (self.film_id)\\n return Scraper(url).scrape_technical_data()\",\n \"def get_song_info(self, song_id):\\n return self.__get('song', song_id)\",\n \"def infotoids(seqsinfo, outdir):\\n allids = [x.patient_id for x in seqsinfo]\\n # TODO: check all patient_ids are the same\\n s = allids[0]\\n\\n return({'subject': \\\"sub-\\\" + IDLOOKUP.get(s, 'UNKNOWN'),\\n 'locator': None, 'session': None})\",\n \"def cds_desc(gff3, fasta):\\n seqs = {}\\n for defline, seq in LocusPocus.fasta.parse(fasta):\\n seqid = defline[1:].split(' ')[0]\\n if seqid not in seqs:\\n seqs[seqid] = seq\\n\\n accession = ''\\n cdslen = 0\\n for entry in gff3:\\n if '\\\\tCDS\\\\t' in entry:\\n fields = entry.rstrip().split('\\\\t')\\n assert len(fields) == 9\\n accession = re.search(r'accession=([^;\\\\n]+)', fields[8]).group(1)\\n cdslen += int(fields[4]) - int(fields[3]) + 1\\n elif entry.startswith('###'):\\n if accession:\\n cdsseq = seqs[accession]\\n if len(cdsseq) != cdslen:\\n message = 'CDS for \\\"%s\\\": length mismatch' % accession\\n message += ' (gff3=%d, fa=%d)' % (cdslen, len(cdsseq))\\n message += '; most likely a duplicated accession'\\n message += ', discarding'\\n print(message, file=sys.stderr)\\n else:\\n gccontent = gc_content(cdsseq)\\n gcskew = gc_skew(cdsseq)\\n ncontent = n_content(cdsseq)\\n values = '%s %d %.3f %.3f %.3f' % (\\n accession, cdslen, gccontent, gcskew, ncontent)\\n yield values.split(' ')\\n accession = ''\\n cdslen = 0\",\n \"def show_info(self):\\n # attr[0] attr[1]\\n attrs = [(self.TYP.value, 'nam'),\\n ('Skill', 'skl')]\\n # voeg ook alle stats en skills in deze lijst toe.\\n for stat in Minimals:\\n attrs.append((stat.value, stat.name))\\n attrs.append(('Spell Battery', 'cur_bat'))\\n for stat in StatType:\\n attrs.append((stat.value, stat.name))\\n for skill in SkillType:\\n attrs.append((skill.value, skill.name))\\n\\n # nu alle mogelijkheden geladen zijn, ga dan aan de slag met diegene die van toepassing zijn\\n attr_list = []\\n\\n import enum\\n for attr in attrs:\\n value_of_attr = self.get_value_of(attr[1])\\n # uitzondering, 'wht' altijd gewoon weergeven\\n if attr[0] == StatType.wht.value:\\n # deze uitzondering geldt niet voor weapons en shields.\\n if not isinstance(self.get_value_of('skl'), enum.Enum): # niet wanneer 'skl' een waarde heeft\\n attr_list.append((attr[0], str(value_of_attr)))\\n elif value_of_attr:\\n if isinstance(value_of_attr, enum.Enum): # uitzondering alleen voor 'skl'\\n value_of_attr = value_of_attr.value\\n elif attr[0] == StatType.hit.value: # uitzondering alleen voor 'hit'\\n value_of_attr = str(value_of_attr)+\\\"%\\\"\\n attr_list.append((attr[0], str(value_of_attr)))\\n\\n return attr_list\",\n \"def info(self):\\r\\n\\r\\n return self.sim_info\",\n \"def show_recs(self):\\n if len(self.storage.records) == 0:\\n return \\\"Records not found!\\\"\\n else:\\n string_of_records = \\\"\\\"\\n for record in self.storage.records:\\n string_of_records += record.to_string()\\n return string_of_records\",\n \"def getFrequencyDict(sequence):\\n # freqs: dictionary (element_type -> int)\\n \\n for x in sequence:\\n hand[x] = hand.get(x,0) + 1\\n updatehand(hand, word)\\n print hand\\n print \\\"freq function\\\"\\n #return hand\",\n \"def get_patient(drs):\\n for line in drs:\\n if line.strip().startswith('sem'):\\n datalist = line.split(':')\\n for word in datalist: \\n if word.count('patient') > 0:\\n variable = word[6:7]\\n for word in datalist:\\n if word.startswith('pred({0}'.format(variable)):\\n return word.split(',')[1]\",\n \"def get_experiment_speaker_info(db_root):\\n seen_speakers = ['VCTK-speaker-p225-female',\\n 'VCTK-speaker-p226-male',\\n 'VCTK-speaker-p227-male',\\n 'VCTK-speaker-p228-female',\\n 'VCTK-speaker-p229-female',\\n 'VCTK-speaker-p230-female',\\n 'VCTK-speaker-p231-female',\\n 'VCTK-speaker-p232-male',\\n 'VCTK-speaker-p233-female',\\n 'VCTK-speaker-p234-female',\\n 'VCTK-speaker-p236-female',\\n 'VCTK-speaker-p237-male',\\n 'VCTK-speaker-p238-female',\\n 'VCTK-speaker-p239-female',\\n 'VCTK-speaker-p240-female',\\n 'VCTK-speaker-p241-male',\\n 'VCTK-speaker-p243-male',\\n 'VCTK-speaker-p244-female',\\n 'VCTK-speaker-p245-male',\\n 'VCTK-speaker-p246-male',\\n 'VCTK-speaker-p247-male',\\n 'VCTK-speaker-p248-female',\\n 'VCTK-speaker-p249-female',\\n 'VCTK-speaker-p250-female',\\n 'VCTK-speaker-p251-male',\\n 'VCTK-speaker-p252-male',\\n 'VCTK-speaker-p253-female',\\n 'VCTK-speaker-p254-male',\\n 'VCTK-speaker-p255-male',\\n 'VCTK-speaker-p256-male',\\n 'VCTK-speaker-p257-female',\\n 'VCTK-speaker-p258-male',\\n 'VCTK-speaker-p259-male',\\n 'VCTK-speaker-p260-male',\\n 'VCTK-speaker-p261-female',\\n 'VCTK-speaker-p262-female',\\n 'VCTK-speaker-p263-male',\\n 'VCTK-speaker-p264-female',\\n 'VCTK-speaker-p265-female',\\n 'VCTK-speaker-p266-female',\\n 'VCTK-speaker-p267-female',\\n 'VCTK-speaker-p268-female',\\n 'VCTK-speaker-p269-female',\\n 'VCTK-speaker-p270-male',\\n 'VCTK-speaker-p271-male',\\n 'VCTK-speaker-p272-male',\\n 'VCTK-speaker-p273-male',\\n 'VCTK-speaker-p274-male',\\n 'VCTK-speaker-p275-male',\\n 'VCTK-speaker-p276-female',\\n 'VCTK-speaker-p277-female',\\n 'VCTK-speaker-p278-male',\\n 'VCTK-speaker-p279-male',\\n 'VCTK-speaker-p280-female',\\n 'VCTK-speaker-p281-male',\\n 'VCTK-speaker-p282-female',\\n 'VCTK-speaker-p283-female',\\n 'VCTK-speaker-p284-male',\\n 'VCTK-speaker-p285-male',\\n 'VCTK-speaker-p286-male',\\n 'VCTK-speaker-p287-male',\\n 'VCTK-speaker-p288-female',\\n 'VCTK-speaker-p292-male',\\n 'VCTK-speaker-p293-female',\\n 'VCTK-speaker-p294-female',\\n 'VCTK-speaker-p295-female',\\n 'VCTK-speaker-p297-female',\\n 'VCTK-speaker-p298-male',\\n 'VCTK-speaker-p299-female',\\n 'VCTK-speaker-p300-female',\\n 'VCTK-speaker-p301-female',\\n 'VCTK-speaker-p302-male',\\n 'VCTK-speaker-p303-female',\\n 'VCTK-speaker-p304-male',\\n 'VCTK-speaker-p305-female',\\n 'VCTK-speaker-p306-female',\\n 'VCTK-speaker-p307-female',\\n 'VCTK-speaker-p308-female',\\n 'VCTK-speaker-p310-female',\\n 'VCTK-speaker-p311-male',\\n 'VCTK-speaker-p312-female',\\n 'VCTK-speaker-p313-female',\\n 'VCTK-speaker-p314-female',\\n 'VCTK-speaker-p316-male',\\n 'VCTK-speaker-p317-female',\\n 'VCTK-speaker-p318-female',\\n 'VCTK-speaker-p323-female',\\n 'VCTK-speaker-p326-male',\\n 'VCTK-speaker-p329-female',\\n 'VCTK-speaker-p330-female',\\n 'VCTK-speaker-p333-female',\\n 'VCTK-speaker-p334-male',\\n 'VCTK-speaker-p335-female',\\n 'VCTK-speaker-p336-female',\\n 'VCTK-speaker-p339-female',\\n 'VCTK-speaker-p340-female',\\n 'VCTK-speaker-p341-female',\\n 'VCTK-speaker-p343-female',\\n 'VCTK-speaker-p345-male',\\n 'VCTK-speaker-p347-male',\\n 'VCTK-speaker-p351-female',\\n 'VCTK-speaker-p360-male',\\n 'VCTK-speaker-p361-female',\\n 'VCTK-speaker-p362-female',\\n 'VCTK-speaker-p363-male',\\n 'VCTK-speaker-p364-male',\\n 'VCTK-speaker-p374-male',\\n 'VCTK-speaker-p376-male']\\n\\n # speaker index list for training and validation\\n n_speaker = len(seen_speakers)\\n\\n # take all speakers in train and validation!!!\\n train_speakers = seen_speakers\\n valid_speakers = seen_speakers\\n print('number of VCTK speakers = %d' % n_speaker)\\n\\n sp2id = {sp: i for i, sp in enumerate(seen_speakers)}\\n id2sp = {i: sp for i, sp in enumerate(seen_speakers)}\\n\\n return seen_speakers, sp2id, id2sp\",\n \"def _get_info(self, id, score=None):\\n try:\\n info_query = f\\\"\\\"\\\"\\n SELECT m.primary_title, m.start_year, r.average_rating, r.num_votes\\n FROM movies m\\n JOIN ratings r ON m.movie_id = r.movie_id\\n WHERE m.movie_id = '{id}'\\\"\\\"\\\"\\n self.cursor_dog.execute(info_query)\\n except Exception as e:\\n return tuple([f\\\"Movie title unknown. ID:{id}\\\", None, None, None, None, None, None, id])\\n\\n t = self.cursor_dog.fetchone()\\n if t:\\n title = tuple([t[0], t[1], f\\\"https://www.imdb.com/title/tt{id}/\\\",\\n f\\\"https://www.letterboxd.com/imdb/tt{id}/\\\", t[2], t[3], score, id])\\n return title\\n else:\\n return tuple([f\\\"Movie title not retrieved. ID:{id}\\\", None, None, None, None, None, None, id])\",\n \"def info(self):\\n past_shows = self.get_shows(Show.start_time <= datetime.now())\\n upcoming_shows = self.get_shows(Show.start_time > datetime.now())\\n\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'genres': self.genres,\\n 'address': self.address,\\n 'city': self.city,\\n 'state': self.state,\\n 'phone': self.phone,\\n 'website': self.website,\\n 'facebook_link': self.facebook_link,\\n 'seeking_talent': self.seeking_talent,\\n 'seeking_description': self.seeking_description,\\n 'image_link': self.image_link,\\n 'past_shows': past_shows,\\n 'upcoming_shows': upcoming_shows,\\n 'past_shows_count': len(past_shows),\\n 'upcoming_shows_count': len(upcoming_shows)\\n }\",\n \"def get_raw_information(self):\\n try:\\n info = self.student_attendance_record.get_period_info(\\n self.start_date, self.day_periods)\\n return (self.student_name, self.student_gender, info)\\n except AttributeError:\\n raise AttributeError, \\\\\\n \\\"Failed to get student attendance record for: %s\\\" \\\\\\n %unicode(self.student)\",\n \"def getVSMSpace():\\n sids,documents = getSongTextInfo()\\n texts = [[word for word in document.lower().split()] for document in documents]\\n dictionary = corpora.Dictionary(texts)\\n corpus = [dictionary.doc2bow(text) for text in texts]\\n songMap = {}\\n index = 0\\n for doc in corpus:\\n sid = sids[index]\\n rMap = {}\\n for item in doc:\\n wid = item[0]\\n count = item[1]\\n rMap[wid] = count\\n songMap[sid] = rMap\\n index += 1\\n return songMap\",\n \"def print_freqs(self):\\n words = list(self.freqs)[0:10]\\n print()\\n for word in words:\\n print(word[0].rjust(15) + \\\" | \\\" + str(word[1]).ljust(3) + \\\" \\\" + (word[1] * \\\"*\\\"))\",\n \"def get_sequence(self):\\n\\n with open(self.input_file, 'r') as input_file:\\n\\n tree = ET.parse(input_file)\\n root = tree.getroot()\\n\\n #print('Root:', root)\\n\\n # TODO: Expand to handle multiple parts\\n part_list_idx = -1\\n part_idx = -1\\n\\n # Find <part-list> and <part> element indexes\\n for i, child in enumerate(root):\\n if child.tag == 'part-list':\\n part_list_idx = i\\n elif child.tag == 'part':\\n # Choose 1st part only to generate sequence\\n part_idx = i if part_idx == -1 else part_idx\\n\\n # Check for bad MusicXML\\n if part_list_idx == -1 or part_idx == -1:\\n print('MusicXML file:', self.input_file,' missing <part-list> or <part>')\\n return ['']\\n sys.exit(0)\\n\\n # Get number of staves in the MusicXML\\n num_staves = 1\\n for e in root[part_idx][0][0]:\\n if e.tag == 'staff-layout':\\n num_staves = int(e.attrib['number'])\\n staves = ['' for x in range(num_staves)]\\n\\n # Read each measure\\n r_iter = iter(root[part_idx])\\n for i, measure in enumerate(r_iter):\\n\\n # Gets the symbol sequence of each staff in measure\\n measure_staves, skip = self.read_measure(measure, num_staves, i)\\n\\n for j in range(num_staves):\\n staves[j] += measure_staves[j]\\n\\n for j in range(skip-1):\\n next(r_iter)\\n\\n return staves\",\n \"def samples():\\n f = open(config['samples'], \\\"r\\\")\\n samp=[]\\n for line in f:\\n samp.append(line.strip().split()[0])\\n return samp\",\n \"def instruments():\\n instr_dict = {}\\n #\\n instr_dict['LRISr'] = 2**0\\n instr_dict['LRISb'] = 2**1\\n instr_dict['Kastb'] = 2**2\\n instr_dict['shane_kast_red'] = 2**3\\n instr_dict['shane_kast_red_ret'] = 2**3\\n instr_dict['DEIMOS'] = 2**4\\n instr_dict['NIRSPEC'] = 2**5\\n instr_dict['GMOS'] = 2**6\\n instr_dict['DBSP'] = 2**7\\n #\\n return instr_dict\",\n \"def sense(self):\\n # Get all PIMAP data from the queue.\\n pimap_data = []\\n while not self.pimap_data_queue.empty():\\n pimap_data.append(self.pimap_data_queue.get())\\n\\n # Sort the PIMAP data by timestamp. The PIMAP data can be out of order because we are\\n # using multiple processes to sense it.\\n pimap_data.sort(key=lambda x: float(pu.get_timestamp(x)))\\n\\n timestamps = (list(map(lambda x: float(pu.get_timestamp(x)), pimap_data)))\\n self.latencies.extend(time.time() - np.array(timestamps))\\n # Track the amount of sensed PIMAP data.\\n self.sensed_data += len(pimap_data)\\n\\n # If system_samples is True and a system_sample was not created within the last\\n # system_samples period, create a system_sample.\\n pimap_system_samples = []\\n if (self.system_samples and\\n (time.time() - self.system_samples_updated > self.system_samples_period)):\\n sample_type = \\\"system_samples\\\"\\n if self.app != \\\"\\\":\\n sample_type += \\\"_\\\" + self.app\\n # Identify PIMAP Sense using the host and port.\\n patient_id = \\\"sense\\\"\\n device_id = (self.host, self.port)\\n sensed_data_per_s = self.sensed_data/(time.time() - self.system_samples_updated)\\n sample = {\\\"throughput\\\":sensed_data_per_s}\\n if len(self.latencies) > 0:\\n sample[\\\"latency\\\"] = np.mean(self.latencies)\\n system_sample = pu.create_pimap_sample(sample_type, patient_id, device_id, sample)\\n pimap_system_samples.append(system_sample)\\n\\n # Reset system_samples variables.\\n self.system_samples_updated = time.time()\\n self.sensed_data = 0\\n self.latencies = []\\n\\n return pimap_data + pimap_system_samples\",\n \"def seqfreqs(seqs):\\n #if \\\"seqfreqs\\\" in options.debug:\\n # print(\\\"There are {} seqs\\\".format(len(seqs)))\\n x = []\\n #this block calculates the frequencies of each sequence\\n for i in range(len(seqs)):\\n this_x = 0\\n for j in range(len(seqs)):\\n if str(seqs[i]) == str(seqs[j]):\\n #if \\\"seqfreqs\\\" in options.debug:\\n # print(\\\"{} == {}\\\".format(i, j))\\n this_x += 1\\n x.append(this_x/len(seqs))\\n #print(\\\"done with these seqfreqs\\\\n\\\")\\n #if \\\"seqfreqs\\\" in options.debug:\\n # print(\\\"the frequencies are {}\\\".format(x))\\n return x\",\n \"def display_genre(self):\\n \\n # Get first 3 genres and join to a string.\\n return ', '.join([ genre.name for genre in self.genre.all()[:3] ])\",\n \"def info(self):\\n past_shows = self.get_shows(Show.start_time <= datetime.now())\\n upcoming_shows = self.get_shows(Show.start_time > datetime.now())\\n\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'genres': self.genres,\\n 'city': self.city,\\n 'state': self.state,\\n 'phone': self.phone,\\n 'website': self.website,\\n 'facebook_link': self.facebook_link,\\n 'seeking_venue': self.seeking_venue,\\n 'seeking_description': self.seeking_description,\\n 'image_link': self.image_link,\\n 'past_shows': past_shows,\\n 'upcoming_shows': upcoming_shows,\\n 'past_shows_count': len(past_shows),\\n 'upcoming_shows_count': len(upcoming_shows)\\n }\",\n \"def info(self):\",\n \"def info(self):\",\n \"def sr(self):\\n return ''.join([str(seg) for seg in self.segments])\",\n \"def sosid(self):\\r\\n return self.word2idx.get(SOS, 0)\",\n \"def gather_sentences(self):\\n sentences = Sentence.objects.all()\\n return sentences\",\n \"def get_residue_info(self):\\n return\",\n \"def s_metadata(self):\\n index = self.var_index(s=True)\\n return self.var_metadata(index)\",\n \"def __str__(self):\\n spkr_appeared = set([])\\n for path in self._filepaths:\\n sid = path.split('/')[-2][1:]\\n assert sid in self._spkr_table, f\\\"{sid} not a valid speaker!\\\"\\n spkr_appeared.add(sid)\\n phoncts = {p: 0 for p in PHONETABLE}\\n mindur = {p: 100 for p in PHONETABLE}\\n maxdur = {p: 0 for p in PHONETABLE}\\n for path in self._filepaths:\\n sr = audioinfo(os.path.join(self.root, path)).samplerate\\n path = os.path.join(self.root, os.path.splitext(path)[0]+'.PHN')\\n for (ts, te), pp in phnread(path):\\n assert pp in phoncts, f\\\"[{pp}] not in phone dict!\\\"\\n phoncts[pp] += 1\\n dur = (te - ts) / sr * 1000\\n if mindur[pp] > dur:\\n mindur[pp] = dur\\n if maxdur[pp] < dur:\\n maxdur[pp] = dur\\n totcts = sum(v for p, v in phoncts.items())\\n report = \\\"\\\"\\\"\\n +++++ Summary for [{}] partition [{}] +++++\\n Total [{}] valid files to be processed.\\n Total [{}/{}] speakers appear in this set.\\n [Phoneme]: [counts], [percentage], [min-max duration (ms)]\\\\n{}\\n \\\"\\\"\\\".format(self.__class__.__name__,\\n self.partition if hasattr(self, 'partition') else None,\\n len(self._filepaths), len(spkr_appeared),\\n len(self._spkr_table),\\n \\\"\\\\n\\\".join(\\n f\\\"\\\\t\\\\t[{p:>4}]: [{c:>4}], [{c*100/totcts:2.2f}%], [{mindur[p]:.1f}-{maxdur[p]:.0f}]\\\"\\n for p, c in phoncts.items()))\\n\\n return report\",\n \"def Show_Sequences( self ):\\r\\n self.system.Change_Seq( \\\"Sequence\\\" )\",\n \"def get_frequency(self):\\r\\n return self._api.get_frequency()\",\n \"def info(doc):\\n\\tinfo = {}\\n\\tinfo['sentences'] = [str(sent) for sent in doc.sents]\\n\\t#sentences : [sent1, sent2, ...]\\n\\tinfo['tokens'] = [str(token) for token in doc]\\n\\t#all tokens in info['tokens']\\n\\ttoken_vals = {}\\n\\tfor token in info['tokens']:\\n\\t\\tcurrent_word = token\\n\\t\\ti = 0\\n\\t\\tcurrent_sent = info['sentences'][i]\\n\\t\\tfor i in range(len(info['sentences'])): #for each sentence\\n\\t\\t\\tval = current_sent.count(str(current_word))\\n\\t\\t\\t#value is the number of times the current word is in the current sent\\n\\t\\t\\ttoken_vals[str(token)] = val\\n\\t\\t\\t#append to dictionary\\n\\tinfo['token_vals'] = token_vals\\n\\t#given a word and a sentence, val is how many times it appears in that sentence\\n\\treturn info\",\n \"def frequencies(self):\\n return self._frequencies\",\n \"def get_list_frequencies(self):\\r\\n _debug('simq03b_api.get_list_frequencies')\\r\\n \\r\\n s = self.query('SOUR:LIST:FREQ?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def read(self):\\n # open the .SPE file\\n with open(self._input_file_path, 'rb') as f:\\n lines = f.readlines()\\n # Create an empty dictionary for the metadata\\n metadata_dictionary = {}\\n\\n # Search through the file for the needed metadata\\n metadata_dictionary['date_acquired'] = re.search(b'date=\\\"(.*?)\\\"', lines[1])[1].decode('ANSI') \\n metadata_dictionary['width'] = int(re.search(b'width=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['height'] = int(re.search(b'height=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\\\"Double\\\">(.*?)</ExposureTime>', lines[1])[1])\\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\\\"(.*?)\\\"',lines[1])[1])\\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\\\"Double\\\">(.*?)</CenterWavelength>',lines[1])[1])\\n metadata_dictionary['orientation'] = re.search(b'orientation=\\\"(.*?)\\\"',lines[1])[1].decode('ANSI')\\n\\n # Get the wavelength and intensity\\n wavelength_string = re.search(b'<Wavelength xml:space=\\\"preserve\\\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\\n\\n f.seek(4100)\\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\\n\\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\\n\\n f.close()\\n \\n # create the sidpy dataset\\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\\n\\n data_set.data_type = 'spectrum'\\n data_set.units = 'counts'\\n data_set.quantity = 'Intensity'\\n\\n # set dimensions\\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\\n units = 'cm-1',\\n quantity='Raman shift',\\n dimension_type='spectral'))\\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\\n units = 'counts',\\n quantity='intensity',\\n dimension_type='spectral')) \\n\\n data_set.metadata = metadata_dictionary\\n\\n return data_set\",\n \"def get_spices(self, key):\\n spices = []\\n if key == 'disease':\\n spices.append('(disease|symptom|sign)')\\n elif key == 'symptom':\\n spices.append('(signs|symptoms)')\\n elif key == 'treatment':\\n spices.append('(treatment|medicine|operation)')\\n return spices\",\n \"def info_scrambled(out: Export = Export(\\\"cwb.encoded_scrambled/data/.info\\\"),\\n sentences: AnnotationCommonData = AnnotationCommonData(\\\"misc.<sentence>_count\\\"),\\n firstdate: AnnotationCommonData = AnnotationCommonData(\\\"cwb.datefirst\\\"),\\n lastdate: AnnotationCommonData = AnnotationCommonData(\\\"cwb.datelast\\\"),\\n resolution: AnnotationCommonData = AnnotationCommonData(\\\"dateformat.resolution\\\"),\\n protected: bool = Config(\\\"korp.protected\\\")):\\n create_info_file(sentences, firstdate, lastdate, resolution, protected, out)\",\n \"def __str__(self):\\n return self._seq\",\n \"def get_records(self, _count, random=False):\\n\\n abtracts=[]\\n titles=[]\\n\\n max_id = [max[0] for max in self.patents.execute(\\\"SELECT MAX(Id) FROM Patents;\\\")][0]\\n order = \\\" ORDER BY id ASC \\\"\\n\\n if (random == True):\\n ids = \\\"\\\"\\n rands = [randint(1, max_id) for x in range(0, _count)]\\n for i, _id in enumerate(rands):\\n ids += \\\"\\\" + str(_id) + \\\"\\\"\\n if i != _count - 1:\\n ids += \\\",\\\"\\n\\n order = \\\" AND id IN (\\\" + ids + \\\")\\\"\\n\\n query = \\\"SELECT * FROM Patents WHERE (Description!='')\\\" + \\\\\\n order + \\\" LIMIT \\\" + str(_count)\\n # print query\\n\\n for row in self.patents.execute(query):\\n # print row[3]\\n # remove numbers and some unwantable characters\\n text = ''.join(\\n [i for i in row[2] if not i.isdigit() and i not in stopwords])\\n\\n abtracts.append(str(text))\\n titles.append(str(row[3]))\\n\\n return ids, abtracts, titles\",\n \"def get_passage(sample_name):\\n #look for passage information pattern in sample_name\\n regex_results = re.match(\\\"([A-Z0-9a-z_-]+).(P[T0-9]+)\\\", sample_name)\\n #the passage information is the second element of the results\\n passage = regex_results.groups()[1]\\n return passage\",\n \"def get_sequence_names(self):\\r\\n return Wiki().sequences_for_article_url(self.url).keys()\",\n \"def get_type_of_studies(self) -> str:\\n semestr = {\\n 1: 'pierwszy',\\n 2: 'drugi',\\n 3: 'trzeci',\\n 4: 'czwarty',\\n 5: 'piąty',\\n 6: 'szósty',\\n 7: 'siódmy',\\n 8: 'ósmy',\\n 9: 'dziewiąty',\\n 10: 'dziesiąty',\\n 0: 'niezdefiniowany'}[\\n self.semestr]\\n return '%s, semestr %s' % (self.program, semestr)\",\n \"def at_frequency(self):\\n result = str(self.seq).count(\\\"A\\\") + str(self.seq).count(\\\"T\\\")\\n return result\",\n \"def get_info(self):\\n return \\\"Malayalam Stemmer(Experimental)\\\"\",\n \"def display_genre(self):\\n\\n\\t\\treturn ', '.join(genre.name for genre in self.genre.all()[:3])\",\n \"def create_seq_record(self, s):\\n gene_code = s['gene_code']\\n length = self.gene_codes_metadata[gene_code]['length']\\n sequence = s['sequences']\\n length_difference = length - len(sequence)\\n\\n sequence += '?' * length_difference\\n return sequence\",\n \"def get_sdesc(self):\\n return self._sdesc\",\n \"def instruments(self) -> dict:\\n return self._instruments\",\n \"def getGenres(movieInfo):\\n if \\\"genres\\\" in movieInfo:\\n return [ _format(genre[\\\"name\\\"]) for genre in movieInfo[\\\"genres\\\"] ]\\n else:\\n raise AttributeError(\\\"%s instance has no attribute genre\\\" % movieInfo)\",\n \"def sequence_items(self):\\r\\n seq_css = 'ol#sequence-list>li>a>p'\\r\\n return self.q(css=seq_css).map(self._clean_seq_titles).results\",\n \"def get_sentence(self):\",\n \"def display_genre(self):\\n return ', '.join(genre.name for genre in self.genre.all()[:3])\",\n \"def GetFrequency(self):\\n ...\",\n \"def __str__(self):\\n print('=' * 20, \\\"Subject Information\\\", '=' * 20)\\n print(\\\"Subject Name: {}\\\".format(self.name))\\n print(\\\"Pulse Data Length for general questions\\\")\\n print(self.pulse_length[0:20])\\n print(\\\"Number of general Questions: {}\\\".format(\\n len(self.pulse_data[0])))\\n print(\\\"Pulse Data Length for video 1\\\")\\n print(\\\"Number of questions for video 1: {}\\\".format(\\n len(self.pulse_data[1])))\\n print(self.pulse_length[20:40])\\n print(\\\"Pulse Data Length for video 2\\\")\\n print(\\\"Number of questions for video 2: {}\\\".format(\\n len(self.pulse_data[0])))\\n print(self.pulse_length[40:60])\\n print('Label Data')\\n print(self.label_data)\\n print('Label Data shape: {}'.format(self.label_data.shape))\\n\\n return ''\",\n \"def _get_information(self):\\n pass\",\n \"def human_readable_info(self) -> str:\\n next_session = unix_str(self._stat.next_session)\\n last_session = unix_str(self._stat.last_session)\\n return \\\"\\\"\\\"\\n Next Session: {}\\n Last Session: {}\\n Repetitions: {}\\n Health: {}\\n ------------------------\\n Past Quality (last 20):\\n ------------------------\\n {}\\n \\\"\\\"\\\".format(\\n next_session,\\n last_session,\\n self._stat.actual_repetitions,\\n self._health(),\\n self._past_quality_graph(),\\n )\",\n \"def display_genre(self):\\n return ', '.join([ genre.name for genre in self.genre.all()[:3] ])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5863178","0.5489143","0.54585916","0.5428158","0.536509","0.53436375","0.53430116","0.53390235","0.532284","0.529443","0.52938986","0.5290507","0.52477586","0.5244924","0.5206089","0.5205835","0.5202415","0.51880074","0.51695544","0.513454","0.51211977","0.5120762","0.51196593","0.5117652","0.511687","0.511681","0.51096773","0.5102836","0.5066955","0.5058819","0.5051457","0.50453436","0.50288993","0.50253433","0.50217795","0.50151855","0.5004227","0.49967584","0.4988832","0.4979121","0.49738884","0.49738884","0.49697825","0.49692628","0.49677506","0.49650586","0.49612984","0.49560234","0.49414974","0.49320355","0.49163145","0.49154377","0.4911237","0.490847","0.4897634","0.48922706","0.4885011","0.48709437","0.48699763","0.48649937","0.48622316","0.48510954","0.4846766","0.48450065","0.48428595","0.48428595","0.48378295","0.48375216","0.4837156","0.48370525","0.48285666","0.4823623","0.48192805","0.48169255","0.48150566","0.481291","0.4809518","0.48072904","0.48063147","0.48050195","0.48023525","0.47992772","0.4793497","0.47871128","0.477798","0.47773302","0.47744292","0.47738916","0.47737592","0.4773427","0.47665843","0.4765616","0.47631076","0.47628227","0.47606197","0.47594115","0.47575003","0.47555542","0.47538933","0.47532484"],"string":"[\n \"0.5863178\",\n \"0.5489143\",\n \"0.54585916\",\n \"0.5428158\",\n \"0.536509\",\n \"0.53436375\",\n \"0.53430116\",\n \"0.53390235\",\n \"0.532284\",\n \"0.529443\",\n \"0.52938986\",\n \"0.5290507\",\n \"0.52477586\",\n \"0.5244924\",\n \"0.5206089\",\n \"0.5205835\",\n \"0.5202415\",\n \"0.51880074\",\n \"0.51695544\",\n \"0.513454\",\n \"0.51211977\",\n \"0.5120762\",\n \"0.51196593\",\n \"0.5117652\",\n \"0.511687\",\n \"0.511681\",\n \"0.51096773\",\n \"0.5102836\",\n \"0.5066955\",\n \"0.5058819\",\n \"0.5051457\",\n \"0.50453436\",\n \"0.50288993\",\n \"0.50253433\",\n \"0.50217795\",\n \"0.50151855\",\n \"0.5004227\",\n \"0.49967584\",\n \"0.4988832\",\n \"0.4979121\",\n \"0.49738884\",\n \"0.49738884\",\n \"0.49697825\",\n \"0.49692628\",\n \"0.49677506\",\n \"0.49650586\",\n \"0.49612984\",\n \"0.49560234\",\n \"0.49414974\",\n \"0.49320355\",\n \"0.49163145\",\n \"0.49154377\",\n \"0.4911237\",\n \"0.490847\",\n \"0.4897634\",\n \"0.48922706\",\n \"0.4885011\",\n \"0.48709437\",\n \"0.48699763\",\n \"0.48649937\",\n \"0.48622316\",\n \"0.48510954\",\n \"0.4846766\",\n \"0.48450065\",\n \"0.48428595\",\n \"0.48428595\",\n \"0.48378295\",\n \"0.48375216\",\n \"0.4837156\",\n \"0.48370525\",\n \"0.48285666\",\n \"0.4823623\",\n \"0.48192805\",\n \"0.48169255\",\n \"0.48150566\",\n \"0.481291\",\n \"0.4809518\",\n \"0.48072904\",\n \"0.48063147\",\n \"0.48050195\",\n \"0.48023525\",\n \"0.47992772\",\n \"0.4793497\",\n \"0.47871128\",\n \"0.477798\",\n \"0.47773302\",\n \"0.47744292\",\n \"0.47738916\",\n \"0.47737592\",\n \"0.4773427\",\n \"0.47665843\",\n \"0.4765616\",\n \"0.47631076\",\n \"0.47628227\",\n \"0.47606197\",\n \"0.47594115\",\n \"0.47575003\",\n \"0.47555542\",\n \"0.47538933\",\n \"0.47532484\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55018765"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":95591,"cells":{"query":{"kind":"string","value":"Get a set of frames from a particular study."},"document":{"kind":"string","value":"def get_frames(self,std_id, frame_ids, anno=None):\n raise"},"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_frames_for_sample(sample):\n path = os.path.join('data', sample[0])\n filename = sample[1]\n images = sorted(glob.glob(os.path.join(path, filename + '*jpg')))\n return images","def getFrames():\n\t\tfor cam in Camera.CAMERAS: cam.getFrame()","def getQiimeSffSamples(self, study_id,seq_run_id):\n try:\n con = self.getSFFDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('get_qiime_sff_samples', \\\n [study_id,seq_run_id,results])\n return results\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), str(e))\n return False","def get(self):\n return self.frames","def get_frames(data: Union[sc.DataArray, sc.Dataset], **kwargs) -> sc.Dataset:\n\n # if data is not None:\n # return frames_peakfinding(data=data,\n # instrument=instrument,\n # plot=plot,\n # **kwargs)\n # else:\n\n return frames_analytical(data=data, **kwargs)","def get_frames(comkey):\n logger.info('Topic Group: {}'.format(browser.title))\n\n # Fetch frames one at a time until no more found\n more_pages = True\n while more_pages:\n base_name = \"{}.html\".format(frame.frame_id())\n frame_name = os.path.join(FRAMESDIR, base_name)\n logger.info('Creating {}'.format(frame_name))\n frame.write_page(frame_name)\n more_pages = frame.next_page()\n\n return None","def get_frames(self):\n\n log(\"Getting frames for {} at {}\".format(self._location, self._t0))\n fn_get = lambda time_str: self.get_wximg(time_str)\n pool0 = multiprocessing.dummy.Pool(self._frames)\n raw = pool0.map(fn_get, self.get_time_strs())\n wximages = [x for x in raw if x is not None]\n if not wximages:\n return None\n pool1 = multiprocessing.dummy.Pool(len(wximages))\n background = self.get_background()\n if background is None:\n return None\n fn_composite = lambda x: self._pilimg.alpha_composite(background, x)\n composites = pool1.map(fn_composite, wximages)\n legend = self.get_legend()\n if legend is None:\n return None\n loop_frames = pool1.map(lambda _: legend.copy(), composites)\n fn_paste = lambda x: x[0].paste(x[1], (0, 0))\n pool1.map(fn_paste, zip(loop_frames, composites))\n return loop_frames","def getSFFFiles(self, study_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n items = []\n con.cursor().callproc('qiime_assets.get_sff_files', [study_id, results])\n for row in results:\n items.append(row[0])\n return items\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def getSampleIDsFromStudy(self, study_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('qiime_assets.get_sample_ids_from_study', [study_id, results])\n metadata_fields = []\n for row in results:\n metadata_fields.append(row[0])\n return metadata_fields\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def get_all_frames(self):\n #pdb.set_trace()\n frame_size=(512,512)\n frame_data = []\n variant_type = (pythoncom.VT_BYREF | pythoncom.VT_ARRAY | pythoncom.VT_UI2)\n for i in xrange(self.defaults['EXP_SEQUENTS']):\n frame_data.append(win32com.client.VARIANT(variant_type, numpy.empty(frame_size)))\n frame_data[i]=self.appdoc.GetFrame(i+1,frame_data[i])\n \n return numpy.array(frame_data, dtype=numpy.uint16)","def get_frames_rep_hdf5(file_hdf5, time_hdf5, filename, time_begin_s, time_end_s):\n get_features = Features_Accessor(time_hdf5, file_hdf5).get_features_from_raw\n return get_features(dict({'file': [filename], 'onset': [time_begin_s], 'offset': [time_end_s]}))[1]","def experiment_frames(request,id):\n\texp = Experiment.objects.get(id=id)\n\tmovies_glob = PROJECT_DIR + exp.frames_url() + '*.swf'\n\tmovies = glob.glob(movies_glob)\n\truns = map(os.path.basename,movies)\n\truns.sort()\n\treturn render_to_response('experiments/experiment_frames.html',\n\t\t\t\t\t\t\t{'exp':exp,'runs':runs},\n\t\t\t\t\t\t\tcontext_instance=RequestContext(request))","def get_frames_by_filename(self, filename, data_type):\n # First, find the sample row.\n sample = None\n\n for row in self.data:\n if row[1] == filename:\n sample = row\n break\n if sample is None:\n raise ValueError(\"Couldn't find sample: %s\" % filename)\n\n # Get the sequence from disk.\n sequence = self.get_extracted_sequence(data_type, sample)\n if sequence is None:\n raise ValueError(\"Can't find sequence. Did you generate them?\")\n \n return sequence","def getFrames(job, **options):\n criteria = search.FrameSearch.criteriaFromOptions(**options)\n framesSeq = Cuebot.getStub('frame').GetFrames(\n job_pb2.FrameGetFramesRequest(job=job, r=criteria), timeout=Cuebot.Timeout).frames\n return [Frame(f) for f in framesSeq.frames]","def getSampleList(self, study_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('qiime_assets.get_sample_list', [study_id, results])\n sample_list = {}\n for sample_name, sample_id in results:\n sample_list[sample_id] = sample_name\n return sample_list\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def get_frame():\n\tall_frames = {}\n\tkeys = get_utt()\n\tfor i, matrix_id in enumerate(mfcc_h5.read(keys)):\t\n\t\tmatrix = np.asarray(matrix_id)\t\n\t\tall_frames[keys[i]] = matrix \n\t\n\treturn all_frames","def get_frames_with_manifests() -> Generator[dict, dict, list[FrameWithManifest]]:\n response = yield {\"method\": \"ApplicationCache.getFramesWithManifests\", \"params\": {}}\n return [FrameWithManifest.from_json(f) for f in response[\"frameIds\"]]","def extract_frames():\n vc = cv2.VideoCapture(INPUT_FILE)\n c=1\n\n if vc.isOpened():\n rval , frame = vc.read()\n else:\n rval, frame = False, False\n\n while rval:\n # cv2.imwrite((MODIFIED_FRAMES_DIR + 'img' + str(c) + '.jpg'),frame)\n cv2.imwrite((MODIFIED_FRAMES_DIR + str(c) + '.jpg'),frame)\n c = c + 1\n cv2.waitKey(1)\n rval, frame = vc.read()\n vc.release()\n print(\"All frames extracted successfully...\")","def _subsample_frames(self, video_clip_frames):\n subsampled_frames = []\n current_ix = 0\n step_size = len(video_clip_frames) / float(config.RGB_N_FRAMES)\n for _ in range(config.RGB_N_FRAMES):\n frame = video_clip_frames[int(current_ix)]\n subsampled_frames.append(frame)\n current_ix += step_size\n\n return np.array(subsampled_frames)","def _select_frames(self, frames):\n converted_frames = list()\n # Ignore some frame at begin and end.\n for i in np.linspace(0, self.video_size, self.frame_num + 2)[1:self.frame_num + 1]:\n img = frames[int(i)]\n img = img.resize((224, 224), Image.BILINEAR)\n frame_data = np.array(img)\n converted_frames.append(frame_data)\n return converted_frames","def get_experiment_frames(experiments, datadir=None):\n import pandas as pd\n\n exp_frames = dict()\n\n if not datadir:\n datadir = os.getcwd()\n\n print 'reading profiles in %s' % datadir\n\n for exp in experiments:\n print \" - %s\" % exp\n exp_frames[exp] = list()\n\n for sid, label in experiments[exp]:\n print \" - %s\" % sid\n \n import glob\n for prof in glob.glob (\"%s/%s-pilot.*.prof\" % (datadir, sid)):\n print \" - %s\" % prof\n frame = pd.read_csv(prof)\n exp_frames[exp].append ([frame, label])\n \n return exp_frames","def frames(self):\n return list(self._frames)","def get_lidc_dataframes(data_path: str, num_sectors: int):\n sorted_studies = sorted(glob(os.path.join(data_path, \"*\")))\n frames = []\n for study in sorted_studies:\n df_temp = pd.read_csv(\n os.path.join(study, \"annotations.txt\"), sep=\": \", header=None, dtype=str\n )\n df_temp.columns = [\"File\", \"Label\"]\n df_temp[\"File\"] = df_temp[\"File\"].apply(lambda e: f\"{study}/{e}.png\")\n frames.append(df_temp)\n\n return [balance_frame(frame) for frame in slice_sector(frames, num_sectors)]","def _read_frames(self):\n cap = self._read_file()\n\n frame_list = []\n ret_list = []\n\n while True:\n ret, frame = cap.read()\n if ret:\n frame_list.append(np.array(frame))\n ret_list.append(ret)\n else:\n break\n if self.mode==\"np\":\n frame_list = np.array(frame_list)\n return frame_list","def condition_frames(run_evs, skip=0):\n frames_list = []\n for ev in run_evs: # loop through runs\n if not bool(ev): # empty EV file (e.g. when there were no error trials or no no-response trials)\n frames_list.append(np.array([]))\n else:\n # Determine when trial starts, rounded down\n start = np.floor(ev[\"onset\"] / TR).astype(int)\n\n # Use trial duration to determine how many frames to include for trial\n duration = np.ceil(ev[\"duration\"] / TR).astype(int)\n\n # Take the range of frames that correspond to this specific trial\n if type(start) == np.ndarray: # many trials\n frames = [s + np.arange(skip, d) for s, d in zip(start, duration)] # loop through different onsets for each trial\n elif type(start) == float or type(start) == np.int64:\n # contains only one onset: it is either the full block (with many trials inside,\n # but just one onset value) or just a single trial\n frames = [start + np.arange(skip, duration)]\n\n frames_list.append(np.concatenate(frames))\n\n return frames_list","def get_images_in_frame(self, frame: int) -> np.ndarray:\n\n # Check if it's the first time the frames are requested and the videos are not unrolled\n if not os.path.exists(self.videos_dir):\n self.unroll_videos()\n\n # print(\"Searching for images of frame \", frame, \"...\")\n # Create the string of the name of the frame that we are going to search for in all camera folders\n frame_name = \"frame\" + ''.zfill(9)\n frame_string = str(frame*2-1) if self.half_resolution else str(frame)\n number_of_chars = len(frame_string)\n frame_name = frame_name[:-number_of_chars] + frame_string + \".\" + self.image_format\n \n # print(\"Frame name: \" + frame_name)\n\n # Get the paths to all cameras inside the videos folder sorted by name\n cameras_paths = [os.path.join(self.videos_dir, name) for name in os.listdir(self.videos_dir) if os.path.isdir(os.path.join(self.videos_dir,name))]\n cameras_paths.sort()\n\n # Get the frame_name image from those paths\n images = []\n # print(cameras_paths)\n\n for path in cameras_paths:\n image = cv2.imread(os.path.join(path, frame_name), cv2.IMREAD_COLOR)\n # print(os.path.join(path, frame_name))\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n images.append(image)\n\n # print(\"Images of frame \", frame, \" retrieved.\")\n return np.array(images)","def sample_frames(frame_dir, fps, visualize_sample_rate):\n visualize_every_x_frames = visualize_sample_rate * int(fps)\n sampled_frames = np.empty((0, 3, IMG_DIM, IMG_DIM), dtype=np.float32) # B, C, H, W\n i = 0\n for file in sorted(os.listdir(frame_dir)):\n if i % visualize_every_x_frames == 0:\n img = skimage.img_as_float(skimage.io.imread(os.path.join(frame_dir, file))).astype(np.float32)\n img = skimage.transform.resize(img, (IMG_DIM, IMG_DIM)) # H, W, C\n img = img.swapaxes(1, 2).swapaxes(0, 1) # C, H, W\n sampled_frames = np.append(sampled_frames, np.array([img]), axis=0)\n i += 1\n logger.debug(\"total number of frames: {}\".format(i))\n return sampled_frames","def get_frame(self, f):\n return self._frames[f, :]","def getSampleDetailList(self, study_id):\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('get_sample_detail_list', [study_id, results])\n sample_details = []\n for sample_name, sample_id, public, collection_date, run_prefix, sequence_count, otu_count, otu_percent_hit in results:\n sample_details.append((sample_name, sample_id, public, collection_date, run_prefix, sequence_count, otu_count, otu_percent_hit))\n return sample_details","def get_fixation_frames(subject, run=0):\n\n trial_frames = np.append(condition_frames(load_evs(subject, 'wm', 'all_bk_cor'))[run],\n condition_frames(load_evs(subject, 'wm', 'all_bk_err'))[run]) # TODO: include no response trials\n trial_frames = np.sort(trial_frames)\n\n fixation_start = np.array([], dtype=int) # initialize\n\n for idx, i in enumerate(trial_frames):\n if idx == 0:\n continue\n\n # find frames with difference greater than 10s\n if i - trial_frames[idx - 1] > 10 / TR:\n fixation_start = np.append(fixation_start, trial_frames[idx - 1])\n\n fixation_duration = np.ceil(15 / TR) # always 15s duration\n\n # get range of frames corresponding to duration of fixation block\n fixation_frames = np.concatenate([i + np.arange(0, fixation_duration, dtype=int) for i in fixation_start])\n\n return fixation_frames","def _getDataSetForFCSFileSample(self):\n\n # Get the dataset for current FCS file sample\n dataSets = searchService.getDataSet(self._entityId)\n if dataSets is None:\n self._message = \"Could not retrieve datasets for \" \\\n \"FCS file with identifier \" + self._entityId + \"!\"\n self._logger.error(self._message)\n else:\n dataSets = [dataSets]\n\n # Return\n return dataSets","def getSequencesFromSample(self, study_id, sample_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('qiime_assets.get_sequences_for_fasta', [study_id, sample_id, results])\n seqs = {}\n for row in results:\n seqs[row[0]] = row[1]\n return seqs \n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def studies(self):\n return self._study_queryset","def find_frames(self, ftype, calib_ID=None, index=False):\n if 'framebit' not in self.keys():\n msgs.error('Frame types are not set. First run get_frame_types.')\n if ftype == 'None':\n return self['framebit'] == 0\n # Select frames\n indx = self.type_bitmask.flagged(self['framebit'], ftype)\n\n if calib_ID is not None:\n # Select frames in the same calibration group\n indx &= self.find_calib_group(calib_ID)\n\n # Return\n return np.where(indx)[0] if index else indx","def _read_frames(filename: str) -> Iterator[Tuple[CritterType, numpy.ndarray]]:\n frame_skip = 0\n last_section = None\n last_frame = None\n\n good_frames: Dict[Tuple[CritterType, int], numpy.ndarray] = {}\n\n cap = cv2.VideoCapture(filename)\n while True:\n ret, frame = cap.read()\n if not ret:\n break # Video is over\n\n if frame_skip > 0:\n frame_skip -= 1\n continue\n\n if frame.shape[:2] == (1080, 1920):\n frame = cv2.resize(frame, (1280, 720))\n\n assert frame.shape[:2] == (720, 1280), \\\n 'Invalid resolution: {1}x{0}'.format(*frame.shape)\n\n if not detect(frame):\n continue # Skip frames that are not showing critterpedia.\n\n # Detect a dark line that shows up only in Pictures Mode.\n mode_detector = frame[20:24, 600:800].mean(axis=(0, 1))\n if numpy.linalg.norm(mode_detector - (199, 234, 237)) > 50:\n raise AssertionError('Critterpedia is in Pictures Mode.')\n\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n if filename.endswith('.jpg'): # Handle screenshots\n yield _detect_critter_section(gray), frame[149:623, :]\n continue\n\n if last_frame is None:\n last_frame = frame\n continue\n\n critter_section = _detect_critter_section(gray)\n if critter_section != last_section:\n if last_section is not None:\n frame_skip = 15\n last_section = critter_section\n continue\n\n # Grab the last frame for each side and section combination.\n if last_frame[570:600, :70, 2].min() > 230:\n good_frames[critter_section, 0] = last_frame\n elif last_frame[570:600, -70:, 2].min() > 230:\n good_frames[critter_section, 1] = last_frame\n\n last_frame = frame\n\n cap.release()\n\n for (critter_type, _), frame in good_frames.items():\n # Crop the region containing critter icons.\n yield critter_type, frame[149:623, :]","def img_filenames(self, matricule):\n proj, sid = next((proj, proj.Matricule(matricule).to('AmcStudentId'))\n for proj in self.projects_by_serie.values()\n if proj.Matricule(matricule).exists('AmcStudentId'))\n return [\n (int(num), filename.replace('%PROJET', proj.path))\n for num, filename in proj.dbs['capture'].execute('select page, src from capture_page where student=? order by page', [sid])\n ]","def frame_list_fixture():\n return [[4, 3, 5, 7], [8, 6, 3], [6, 7]]","def getBitstreamFrames(self):\n \n return self.bitstream_frames","def frames(self) -> Set[int]:\n return self._frames","def get_stack_frames(self, threadId=0, startFrame=0, levels=0, format=None):\n\n # format is ignored, TODO?\n # threadId is ignored since renpy is single threaded for stuff we need\n\n clevel = 0\n slevel = 0 if startFrame is None else startFrame\n elevel = None if levels is None or levels == 0 else levels\n\n frames = []\n cframe = self.active_frame\n while cframe is not None:\n if clevel >= slevel:\n finfo = {}\n\n finfo[\"id\"] = clevel\n finfo[\"name\"] = cframe.f_code.co_name + self.format_method_signature(cframe.f_locals, cframe.f_code)\n finfo[\"source\"] = {\"path\": cframe.f_code.co_filename}\n finfo[\"line\"] = cframe.f_lineno\n finfo[\"presentationHint\"] = \"normal\"\n finfo[\"column\"] = 0\n\n dis_info = {}\n finfo[\"subsource\"] = dis_info\n\n disassembled = dis(cframe.f_code, cframe.f_lasti)\n dis_info[\"sources\"] = [{\"text\": self.format_disassembly(cframe.f_lineno, *de), \"line\": de[1], \"source\": finfo[\"source\"]} for de in disassembled]\n ord = 0\n for de in disassembled:\n if de[0]:\n break\n ord += 1\n finfo[\"subsourceElement\"] = ord\n\n frames.append(finfo)\n clevel += 1\n if elevel is not None and clevel >= elevel:\n break\n cframe = cframe.f_back\n\n return frames","def get_frames(self):\n if not self.video:\n return []\n # We cannot validate shape on construction as that happens inside graph\n # mode as we construct from a tf.data.Dataset, so we validate here.\n self.video[0].validate_shape_and_dtype()\n return self.video","def getDataFrames(sampleparams, shakeparams, predictors, outparams):\n coverage = sampleparams['coverage']\n f = fiona.collection(coverage, 'r')\n cbounds = f.bounds\n f.close()\n dx = sampleparams['dx']\n cb = sampleparams['cb']\n nmax = sampleparams['nmax']\n nsamp = sampleparams['nsamp']\n touch_center = sampleparams['touch_center']\n testpercent = sampleparams['testpercent']\n extent = sampleparams['extent']\n h1 = sampleparams['h1']\n h2 = sampleparams['h2']\n\n yestest, yestrain, notest, notrain, xvar, yvar, pshapes, proj = sampleFromFile(coverage, dx=dx,\n nmax=nmax, testPercent=testpercent, touch_center=touch_center, classBalance=cb, extent=extent,\n Nsamp=nsamp, h1=h1, h2=h2)\n\n traincolumns = OrderedDict()\n testcolumns = OrderedDict()\n\n if (100-testpercent) > 0:\n traincolumns['lat'] = np.concatenate((yestrain[:, 1], notrain[:, 1]))\n traincolumns['lon'] = np.concatenate((yestrain[:, 0], notrain[:, 0]))\n traincolumns['coverage'] = np.concatenate((np.ones_like(yestrain[:, 1]),\n np.zeros_like(notrain[:, 1])))\n\n if testpercent > 0:\n testcolumns['lat'] = np.concatenate((yestest[:, 1], notest[:, 1]))\n testcolumns['lon'] = np.concatenate((yestest[:, 0], notest[:, 0]))\n testcolumns['coverage'] = np.concatenate((np.ones_like(yestest[:, 1]), np.zeros_like(notest[:, 1])))\n\n for predname, predfile in predictors.items():\n ftype = getFileType(predfile)\n if ftype == 'shapefile':\n attribute = predictors[predname+'_attribute']\n shapes = subsetShapes(predfile, cbounds)\n yes_test_samples = sampleShapes(shapes, yestest, attribute)\n no_test_samples = sampleShapes(shapes, notest, attribute)\n yes_train_samples = sampleShapes(shapes, yestrain, attribute)\n no_train_samples = sampleShapes(shapes, notrain, attribute)\n testcolumns[predname] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\n traincolumns[predname] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\n elif ftype == 'grid':\n method = 'nearest'\n if predname+'_sampling' in predictors:\n method = predictors[predname+'_sampling']\n\n if testpercent > 0:\n yes_test_samples = sampleGridFile(predfile, yestest, method=method)\n no_test_samples = sampleGridFile(predfile, notest, method=method)\n testcolumns[predname] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\n\n if (100-testpercent) > 0:\n yes_train_samples = sampleGridFile(predfile, yestrain, method=method)\n no_train_samples = sampleGridFile(predfile, notrain, method=method)\n traincolumns[predname] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\n else:\n continue # attribute or sampling method key\n\n #sample the shakemap\n layers = ['mmi', 'pga', 'pgv', 'psa03', 'psa10', 'psa30']\n shakegrid = ShakeGrid.load(shakeparams['shakemap'], adjust='res')\n for layer in layers:\n yes_test_samples = sampleFromMultiGrid(shakegrid, layer, yestest)\n no_test_samples = sampleFromMultiGrid(shakegrid, layer, notest)\n yes_train_samples = sampleFromMultiGrid(shakegrid, layer, yestrain)\n no_train_samples = sampleFromMultiGrid(shakegrid, layer, notrain)\n if testpercent > 0:\n testcolumns[layer] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\n if (100-testpercent) > 0:\n traincolumns[layer] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\n\n dftest = pd.DataFrame(testcolumns)\n dftrain = pd.DataFrame(traincolumns)\n\n return (dftrain, dftest)","def getEMPStudyList(self):\n try:\n studies = []\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n con.cursor().callproc('qiime_assets.get_emp_study_list', [results])\n for row in results:\n # study_id, sample_id, sample_name, project_name, study_title, email, sample_count, metadata_complete,\n # study_score, sample_score, s.number_samples_promised, s.number_samples_in_freezer, \n # s.principal_investigator\n studies.append((row[0], row[1], row[2], row[3], row[4], row[5],\n row[6], row[7], row[8], row[9], row[10], row[11], row[12]))\n return studies\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)","def get_files(self, subj_id, study, modality, series):\n if type(series) is int:\n series = str(series)\n\n url = 'files?' + self._login_code + '&projectCode=' + \\\n self.proj_code + '&subjectNo=' + subj_id + '&study=' + \\\n study + '&modality=' + modality + '&serieNo=' + series\n output = self._send_request(url)\n\n # Split at '\\n'\n file_list = output.split('\\n')\n # Remove any empty entries!\n file_list = [x for x in file_list if x]\n\n return(file_list)","def stream_frames(video_capture):","def getFrameList(self):\n with self.frameLock:\n return list(self.frameList)","def frames(self):\n return self._frames","def getSubframe( self, x, y, w, h):\n\n return TrackedObject.frame[y:y+h,x:x+w,:], \\\n TrackedObject.frameG[y:y+h,x:x+w]","def get_frames_image_for_display(self, mouse_x, mouse_y):\n barcode_shape = self.barcode.get_barcode().shape\n # Get the middle position of the saved frame\n cur_pos = (mouse_x * barcode_shape[0] + mouse_y) / (barcode_shape[0] * barcode_shape[1])\n frame_pos = round(cur_pos * len(self.barcode.saved_frames))\n\n # Get another four frames around the middle frame\n # Make sure the frame positions/indexes are valid\n if frame_pos < 2:\n frame_pos = 2\n if frame_pos > len(self.barcode.saved_frames) - 3:\n frame_pos = len(self.barcode.saved_frames) - 3\n frames = self.barcode.saved_frames[frame_pos - 2: frame_pos + 3]\n\n # Get the combined five frames image\n combine_image = frames[0]\n for frame in frames[1:]:\n # Combine the frames into one image\n combine_image = np.concatenate((combine_image, frame), axis=1)\n\n return combine_image","def _get_headers_by_study(\n files: Set[Path], file_errors: DefaultDict[Path, List[str]]\n):\n study_key_type = Tuple[str, ...]\n studies: Dict[study_key_type, Dict[str, Any]] = {}\n indices: Dict[str, Dict[study_key_type, int]] = {}\n\n for file in files:\n if not file.is_file():\n continue\n with file.open(\"rb\") as f:\n try:\n # Read header only, skip reading the pixel data for now\n ds = pydicom.dcmread(f, stop_before_pixels=True)\n\n # Group by series instance uid or by stack ID (for 4D images)\n # Additionally also group by SOP class UID to skip over extra\n # raw data (dose reports for example) that are sometimes stored\n # under the same series instance UID.\n key: study_key_type = (\n ds.StudyInstanceUID,\n getattr(ds, \"StackID\", ds.SeriesInstanceUID),\n ds.SOPClassUID,\n )\n\n studies[key] = studies.get(key, {})\n indices[ds.StudyInstanceUID] = indices.get(\n ds.StudyInstanceUID, {}\n )\n\n try:\n index = indices[ds.StudyInstanceUID][key]\n except KeyError:\n index = len(indices[ds.StudyInstanceUID])\n indices[ds.StudyInstanceUID][key] = index\n\n headers = studies[key].get(\"headers\", [])\n headers.append({\"file\": file, \"data\": ds})\n studies[key][\"headers\"] = headers\n\n # Since we might need to combine multiple images with different\n # series instance UID (in 4D images), we cannot use the series\n # as the unique file name - instead, we use the study instance\n # uid and a counter (index) per study\n studies[key][\"name\"] = f\"{ds.StudyInstanceUID}-{index}\"\n\n except Exception as e:\n file_errors[file].append(format_error(str(e)))\n\n return studies","def get_snapshot_list(self, base, snappref=\"SPECTRA_\"):\n #print('Looking for spectra in', base)\n powerspectra = FluxPower(maxk=self.max_k)\n for snap in range(30):\n snapdir = os.path.join(base,snappref+str(snap).rjust(3,'0'))\n #We ran out of snapshots\n if not os.path.exists(snapdir):\n snapdir = os.path.join(base,\"PART_\"+str(snap).rjust(3,'0'))\n if not os.path.exists(snapdir):\n snapdir = os.path.join(base, \"snap_\"+str(snap).rjust(3,'0'))\n if not os.path.exists(snapdir):\n continue\n #We have all we need\n if powerspectra.len() == np.size(self.zout):\n break\n try:\n ss = self._get_spectra_snap(snap, base)\n# print('Found spectra in', ss)\n if ss is not None:\n powerspectra.add_snapshot(snap,ss)\n except IOError:\n print(\"Didn't find any spectra because of IOError\")\n continue\n #Make sure we have enough outputs\n if powerspectra.len() != np.size(self.zout):\n raise ValueError(\"Found only\",powerspectra.len(),\"of\",np.size(self.zout),\"from snaps:\",powerspectra.snaps)\n return powerspectra","def get_stim_onset_times(sessions, metadata_dict):\n if not isinstance(sessions, list):\n sessions = list(sessions)\n\n for line in sessions:\n session_id = line['Sess.ID']\n if session_id: # we loaded a line with session info\n session_name = '{}_{}'.format(line['Experiment'], line['Sess.ID'])\n\n # Check if session is already in database\n if database is not None and session_name in database.index:\n continue\n session_stimuli = {}\n session_stimuli['session_id'] = session_id\n session_stimuli['stimuli'] = {}\n session_stimuli['stimuli']['visual'] = []\n session_stimuli['stimuli']['audio'] = []\n session_stimuli['stimuli']['digital'] = []\n videopaths = []\n # load data from .tdms and .avi fils\n for recording in line['Recordings']:\n path = os.path.join(line['Base fld'], line['Exp fld'], recording)\n for f in os.listdir(path):\n if '.avi' in f:\n videopaths.append(os.path.join(path, f))\n print(videopaths)\n elif '.tdms' == f[-5:]:\n tdmspath = os.path.join(path, f)\n # Loop over each .tdms file and extract stimuli frames\n print(colored('Loading {}: {}'.format(session_name,os.path.basename(tdmspath)),'yellow'))\n tdms = TdmsFile(tdmspath)\n if metadata_dict[session_name]['software'] == 'behaviour':\n visual_rec_stims, audio_rec_stims, digital_rec_stims = [], [], []\n for group in tdms.groups():\n for obj in tdms.group_channels(group):\n if 'stimulis' in str(obj).lower():\n for idx in obj.as_dataframe().loc[0].index:\n if \"/' \" in idx:\n framen = int(idx.split(\"/' \")[1].split('-')[0])\n elif \"/' \" in idx:\n framen = int(idx.split(\"/' \")[1].split('-')[0])\n else:\n framen = int(idx.split(\"/'\")[2].split('-')[0])\n if 'visual' in str(obj).lower():\n visual_rec_stims.append(framen)\n elif 'audio' in str(obj).lower():\n audio_rec_stims.append(framen)\n elif 'digital' in str(obj).lower():\n digital_rec_stims.append(framen)\n else:\n print(colored('Couldnt load stim correctly','yellow'))\n # Now use the AI channels to find the *real* stimulus onset times and replace them\n if audio_rec_stims:\n stimulus_on_idx = np.where(tdms.group_channels('AI')[3].data > .55)[0] #in first data sets this is AI 1, later AI 2\n idx_since_last_stimulus_on = np.diff(stimulus_on_idx)\n if stimulus_on_idx.size:\n stimulus_start_idx = stimulus_on_idx[np.append(np.ones(1).astype(bool),idx_since_last_stimulus_on>2*10000)] #usually 10 or 30\n stimulus_start_frame = np.ceil(stimulus_start_idx / 10000 / (33 + 1 / 3) * 1000).astype(int)\n stimulus_start_frame = stimulus_start_frame[stimulus_start_frame > 300]\n else:\n stimulus_start_frame = np.array(audio_rec_stims)\n print('NO STIMULI FOUND!!')\n\n if len(stimulus_start_frame) != len(audio_rec_stims):\n print('audio AI channel does not match number of timestamps by ' + str(len(audio_rec_stims)-len(stimulus_start_frame)) )\n else:\n discrepancy = stimulus_start_frame - audio_rec_stims\n if sum(discrepancy>8):\n print('audio AI channel does not match values of timestamps')\n else:\n print(discrepancy)\n # for conditioning experiment, just use what the tdms says\n # if 'food' in line['Experiment']:\n # stimulus_start_frame = np.array(audio_rec_stims)\n audio_rec_stims = list(stimulus_start_frame)\n\n session_stimuli['stimuli']['visual'].append(visual_rec_stims)\n session_stimuli['stimuli']['audio'].append(audio_rec_stims)\n session_stimuli['stimuli']['digital'].append(digital_rec_stims)\n\n else:\n \"\"\" HERE IS WHERE THE CODE TO GET THE STIM TIMES IN MANTIS WILL HAVE TO BE ADDEDD \"\"\"\n pass\n\n # Add to dictionary (or update entry)\n stimulus_dict[session_name] = session_stimuli\n return stimulus_dict","def _scan_and_sample_dataset(self, dives):\n roots = [os.path.join(self.p.data_root, n) for n in dives]\n ret = []\n for root in roots:\n h5_files = glob.glob(os.path.join(root, '*.h5'))\n for h5 in h5_files:\n try:\n fgroup = FrameGroup(h5, self.meta)\n except (AssertionError, KeyError, OSError) as e:\n if type(e) == AssertionError:\n print_warn('Unmatched time: {}'.format(h5))\n else:\n print_warn('Corrupted h5: {}'.format(h5))\n continue\n num_samples = int(self.p.downsample * fgroup.num_frames)\n indices = np.random.choice(\n fgroup.num_frames, size=num_samples, replace=False)\n ret.extend([(h5, int(idx)) for idx in indices])\n random.shuffle(ret)\n return ret","def get_frame_list(self):\r\n\r\n logger.debug('Executing frame extraction')\r\n\r\n frames_loaded = False\r\n\r\n # Try to load YAML file with frame list\r\n if os.path.exists(self.frames_file_path):\r\n\r\n print 'Loading YAML file with frame list'\r\n logger.debug('Loading YAML file with frame list')\r\n\r\n f_list = utils.load_YAML_file(self.frames_file_path)\r\n\r\n if f_list:\r\n self.frame_list = f_list\r\n\r\n print 'YAML file with frame_list loaded'\r\n logger.debug('YAML file with frame_list loaded')\r\n\r\n frames_loaded = True\r\n\r\n if not frames_loaded:\r\n\r\n print '\\n\\n### Frame extraction ###\\n'\r\n logger.debug('\\n\\n### Frame extraction ###\\n')\r\n\r\n # Save processing time\r\n start_time = cv2.getTickCount()\r\n\r\n if not (os.path.exists(self.frames_path)):\r\n os.makedirs(self.frames_path)\r\n\r\n # Counter for all frames\r\n frame_counter = 0\r\n\r\n # Value of frame_counter for last analyzed frame\r\n last_anal_frame = 0\r\n\r\n # Open video file\r\n capture = cv2.VideoCapture(self.resource_path)\r\n\r\n self.frame_list = []\r\n\r\n # Save parameters for this video\r\n param_dict = {}\r\n\r\n if capture is None or not capture.isOpened():\r\n\r\n error = 'Error in opening video file'\r\n\r\n print error\r\n logger.debug(error)\r\n\r\n return\r\n\r\n else:\r\n\r\n video_fps = capture.get(cv2.cv.CV_CAP_PROP_FPS)\r\n\r\n param_dict[c.VIDEO_FPS_KEY] = video_fps\r\n\r\n # Original number of frames\r\n tot_frames = capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)\r\n\r\n param_dict[c.VIDEO_TOT_FRAMES_KEY] = tot_frames\r\n\r\n self.fps = video_fps\r\n\r\n self.video_frames = float(tot_frames)\r\n\r\n # Saved frames\r\n saved_frames = 0\r\n\r\n while True:\r\n\r\n # Read frame\r\n ret, frame = capture.read()\r\n\r\n # If no frame is read, abort\r\n if not ret:\r\n break\r\n\r\n used_fps = c.USED_FPS\r\n use_or_fps = c.USE_ORIGINAL_FPS\r\n use_or_res = c.USE_ORIGINAL_RES\r\n used_res_scale_factor = c.USED_RES_SCALE_FACTOR\r\n\r\n if self.params is not None:\r\n\r\n if c.USED_FPS_KEY in self.params:\r\n used_fps = self.params[c.USED_FPS_KEY]\r\n\r\n if c.USE_ORIGINAL_FPS_KEY in self.params:\r\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\r\n\r\n if c.USE_ORIGINAL_RES_KEY in self.params:\r\n use_or_res = self.params[c.USE_ORIGINAL_RES_KEY]\r\n\r\n if c.USED_RES_SCALE_FACTOR_KEY in self.params:\r\n used_res_scale_factor = self.params[\r\n c.USED_RES_SCALE_FACTOR_KEY]\r\n\r\n # Next frame to be analyzed\r\n next_frame = last_anal_frame + (video_fps / used_fps) - 1\r\n\r\n if use_or_fps or (frame_counter > next_frame):\r\n\r\n # Frame position in video in milliseconds\r\n elapsed_ms = capture.get(cv2.cv.CV_CAP_PROP_POS_MSEC)\r\n\r\n # print 'elapsed video s =', elapsed_video_s\r\n\r\n fr_name = '%07d.png' % frame_counter\r\n\r\n frame_path = os.path.join(self.frames_path, fr_name)\r\n\r\n # Resize frame\r\n if not use_or_res:\r\n fx = used_res_scale_factor\r\n\r\n fy = used_res_scale_factor\r\n\r\n interp = cv2.INTER_AREA\r\n\r\n frame = cv2.resize(src=frame, dsize=(0, 0),\r\n fx=fx, fy=fy,\r\n interpolation=interp)\r\n\r\n cv2.imwrite(frame_path, frame,\r\n [cv.CV_IMWRITE_PNG_COMPRESSION, 0])\r\n\r\n frame_dict = {c.SAVED_FRAME_NAME_KEY: fr_name,\r\n c.ELAPSED_VIDEO_TIME_KEY: int(elapsed_ms)}\r\n\r\n self.frame_list.append(frame_dict)\r\n\r\n last_anal_frame = frame_counter\r\n\r\n saved_frames += 1\r\n\r\n frame_counter += 1\r\n\r\n self.progress = 100 * (frame_counter / self.video_frames)\r\n\r\n print('progress: ' + str(self.progress) + ' % \\r'),\r\n\r\n del capture\r\n\r\n self.saved_frames = float(saved_frames)\r\n\r\n param_dict[c.VIDEO_SAVED_FRAMES_KEY] = self.saved_frames\r\n\r\n # Save frame list in YAML file\r\n utils.save_YAML_file(self.frames_file_path, self.frame_list)\r\n\r\n # Save video parameters in YAML file\r\n\r\n utils.save_YAML_file(self.params_file_path, param_dict)\r\n\r\n # Save processing time\r\n time_in_clocks = cv2.getTickCount() - start_time\r\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\r\n\r\n print 'Time for frame extraction:', str(time_in_seconds), 's\\n'\r\n logger.debug(\r\n 'Time for frame extraction:', str(time_in_seconds), 's\\n')\r\n\r\n self.anal_times[c.FRAME_EXTRACTION_TIME_KEY] = time_in_seconds\r\n\r\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)","def _construct_frame_list(self):\n\n chunks = self._chunk_list(list(range(self._start_frame, self._max_frame + 1)),\n int((self._max_frame - self._start_frame) / self._sub))\n frame_list = [[c[0], c[len(c) - 1]] for c in chunks]\n\n # Fix the frame_list in case of rounding errors\n if len(frame_list) > self._sub:\n frame_list = self._restructure_frames(frame_list)\n return frame_list","def test_get_studies(self):\n states = [\n study_pb2.StudySpec.STATE_ENABLED, study_pb2.StudySpec.STATE_DISABLED\n ]\n studies = []\n for i in range(5):\n study_spec = sample_study_spec(name=str(i), state=states[i % len(states)])\n self.storage.create_study(study_spec)\n studies.append(study_spec)\n\n self.assertListEqual(studies, self.storage.get_studies())\n for state in states:\n self.assertListEqual([study for study in studies if study.state is state],\n self.storage.get_studies(state=state))","def get_video_frames(self):\r\n\r\n vid_dir = self._video_dir\r\n vid_frames = [str(img_path) for img_path in\r\n Path(vid_dir).glob('*.jpg')]\r\n if len(vid_frames) == 0:\r\n vid_frames = [str(img_path) for img_path in\r\n Path(vid_dir).glob('*.png')]\r\n list_of_frames = sorted(vid_frames)\r\n\r\n self._vid_frames = [list_of_frames]\r\n\r\n return self._vid_frames","def get_files(self, sid):\n try:\n return self.datas.get(sid)\n except Exception as ex:\n raise ex","def get_frames_from_video_capture(video_capture):\n while video_capture.isOpened():\n success, frame = video_capture.read()\n if not success:\n break\n else:\n yield frame","def load_frames(self, path, frames, convert_alpha=False):\n dir_path = self.get_path(path)\n extension = \"\"\n for name in listdir(dir_path):\n file = join(dir_path, name)\n if isfile(file):\n striped, file_ext = splitext(name)\n if striped == \"1\":\n extension = file_ext\n break\n surfs = []\n for c in range(1, frames + 1):\n file = join(dir_path, str(c) + extension)\n if convert_alpha:\n surfs.append(load(file).convert_alpha())\n continue\n surfs.append(load(file).convert())\n return surfs","def get_activations_from_studies(cls, studies):\n\n activations = cls.query.filter(\n cls.pmid.in_(studies), cls.location_id < 81925).all()\n\n return activations","def frames(self):\n while True:\n ret, frame = self.classification()\n if ret == True:\n yield cv2.imencode('.jpg', frame)[1].tobytes()\n else:\n break","def get_source_studies(self):\n return list(set([trait.source_dataset.source_study_version.study for trait in self.get_all_source_traits()]))","def _read_frame(path: str, *, format):\n if not os.path.isfile(path):\n tpath = resources_path(path)\n if not os.path.isfile(path):\n raise IOError(\"Unable to find file.\\nTried paths:\\n%s\\n%s\" % (path, tpath))\n path = tpath\n\n data = scio.loadmat(path)\n res = []\n for (matkey, consumer) in format:\n res.append(consumer(data[matkey]))\n return res","def readFrames(video):\n frames = []\n while True:\n _, frame = video.read()\n\n if frame is None:\n break\n else:\n frames.append(frame)\n video.release()\n return frames","def get_measured_subframes(self):\r\r\n loggerCmw = logging.getLogger('get_measured_subframes')\r\r\n numSf_str = self.read('FETCh:WCDMa:SIGN:HACK:MSFRames?')\r\r\n numSf_list = numSf_str.split(',')\r\r\n\r\r\n num = -1\r\r\n measured_subframes = self.NO_MEASURED_FRAMES_STR\r\r\n reliability = numSf_list[0]\r\r\n if reliability == '0':\r\r\n measured_subframes = numSf_list[1]\r\r\n else:\r\r\n loggerCmw.info(\"Measurements are not reliable, reliability indicator %s\" %reliability)\r\r\n\r\r\n return measured_subframes","def frames(self) -> Optional[Tuple[int, ...]]:\n return self._frames","def get_frame_sequence(captured_file):\n frame_seq = []\n get_all_frame = \"tshark -r {} -Y 'http.request || http.response' -T fields -e frame.number\".format(captured_file)\n frames = run_command(get_all_frame, True)\n for f in frames:\n fn = int(f.decode('utf8').rstrip('\\n'))\n frame_seq.append(HTTPNode(fn))\n \n return frame_seq","def search_research_studies_with_observations():\n return ResearchStudy.where(struct={}).include('focus', Observation, reverse=True)","def getStudyTemplates(self, study_id):\n try:\n con = self.getMetadataDatabaseConnection()\n results = con.cursor()\n items = []\n con.cursor().callproc('qiime_assets.get_study_templates', [study_id, results])\n for row in results:\n items.append(row[0])\n return items\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def get_all_frames(self) -> List[str]:\n frames = self.allFramesAsString().split(\"\\n\")\n frames.remove(\"\")\n return frames","def find_records():\r\n\r\n print(\"begin find records\")\r\n\r\n study_list = retrieve_ref('study_list')\r\n sensor_list = retrieve_ref('sensor_list')\r\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\r\n\r\n for study in study_list:\r\n # print('study = ' + str(study))\r\n source_path = os.path.join(study, 'source')\r\n # print('source_path = ' + str(source_path))\r\n\r\n source_folders = os.listdir(source_path)\r\n # print(str(study) + ' source_folders = ')\r\n # print(source_folders)\r\n\r\n df_meta = pd.DataFrame()\r\n df_meta['source_path'] = source_folders\r\n save_meta(study, df_meta)\r\n record_to_summary(study, 'Records found', str(len(source_folders)))\r\n\r\n print(\"completed find records\")","def get_frame(self, frame: int) -> BaseImage:\n return self.sequence[frame]","def get_windows(timsData):\n conn = timsData.conn\n pasef_ms2_id = 8 # diaPASEF ms2 scans are denoted by 8 instead of 2\n cycle_length = get_cycle_length(conn, pasef_ms2_id)\n wpf = get_windows_per_frame(conn, pasef_ms2_id)\n q = timsData.conn.execute(\"SELECT * FROM Frames INNER JOIN PasefFrameMsMsInfo ON Frames.Id=PasefFrameMsMsInfo.Frame WHERE MsMsType=%d LIMIT %d\" % (pasef_ms2_id, cycle_length*wpf))\n frames = q.fetchall()\n colnames = [description[0] for description in q.description]\n resframe = pd.DataFrame(data = frames, columns = colnames)\n return resframe","def scenes_to_frames():\n # Scene 001 from frames 1-150\n cmd.scene('001', animate=0)\n cmd.mview('store', 1)\n cmd.mview('store', 150)\n # Scene 002 from frames 250-400\n cmd.scene('002', animate=0)\n cmd.mview('store', 250)\n cmd.mview('store', 400)","def frames_df(task, conditions):\n\n frames_df = pd.DataFrame([])\n\n for subject in subjects:\n for condition in conditions:\n evs = load_evs(subject, task, condition)\n df = pd.DataFrame(evs) # load evs into df\n df['run'] = [0, 1]\n df['subject'] = subject\n df['condition'] = condition\n df['frames'] = condition_frames(evs)\n frames_df = frames_df.append(df, ignore_index=True)\n\n return frames_df","def get_tracks(num=1):\n pass","def find_frame_files(self, ftype, calib_ID=None):\n return self.frame_paths(self.find_frames(ftype, calib_ID=calib_ID))","def getFrameByName(self, frameName):\n return self.data.frames[frameName]","def rend_samples(data,start_frame,cap,fs=[30,51,78,90],show=False):\n row1 = [];\n row2 = [];\n row3 = [];\n for f in fs:\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\n _,data['frame'] = cap.read();\n data['i'] = f;\n row1.append(extract_head(data));\n row2.append(data['plts']['y'][f]);\n render = cv2.imread(cf.renders_path + \"{:04d}.png\".format(f+1));\n render = cv2.resize(render,(256,256));\n row3.append(render);\n row1 = np.concatenate(row1,axis=1);\n row2 = np.concatenate(row2,axis=1);\n row3 = np.concatenate(row3,axis=1);\n grid = np.concatenate([row1,row2,row3]);\n if show:\n ut.show(grid);\n return grid;","def get_studies(self, subj_id, modality=None, unique=False):\n\n url = 'studies?' + self._login_code + \\\n '&projectCode=' + self.proj_code + '&subjectNo=' + subj_id\n output = self._send_request(url)\n\n # Split at '\\n'\n stud_list = output.split('\\n')\n # Remove any empty entries!\n stud_list = [x for x in stud_list if x]\n\n if modality:\n for ii, study in enumerate(stud_list):\n url = 'modalities?' + self._login_code + \\\n '&projectCode=' + self.proj_code + '&subjectNo=' + \\\n subj_id + '&study=' + study\n output = self._send_request(url).split('\\n')\n\n if modality in output:\n if unique:\n return([study, ]) # always return a list\n else:\n stud_list[ii] = None\n\n # In Py3, filter returns an iterable object, but here we want list\n stud_list = list(filter(None, stud_list))\n\n return(stud_list)","def get_frame(self):\n return self.frames.get()","def subsample(self, se):\n\t\tdf = ReadDF('noname', self.readdict.refmap)\n\t\tfor i in random.sample(xrange(1, self.n+1), min(se, self.n)):\n\t\t\tpos, read = self.partial_sampling_func(i)\n\t\t\tdf.add_read_to_vec(read,copy=1) # important to remember to use just this ONE copy!!!\n\t\treturn df","def _crop_frames(self, frames, center_crop=True):\n cropped_frames = []\n crop_location = 0.5 if center_crop else np.random.random_sample()\n for frame in frames:\n cropped_frame = self._crop_frame(frame, crop_location)\n cropped_frames.append(cropped_frame)\n\n return np.array(cropped_frames)","def getframe(self, num):\n if num < 0 or num > self.nframes:\n raise RuntimeError(\"Requested frame number is out of range\")\n # Do a deep copy of the header to make a new one\n frame = hdf5image(header=self.header.copy())\n frame.header_keys = self.header_keys[:]\n for key in (\"dim1\", \"dim2\", \"nframes\", \"bytecode\", \"hdf5\", \"ds\"):\n frame.__setattr__(key, self.__getattribute__(key))\n frame.hdf5_location = copy.deepcopy(self.hdf5_location)\n frame.hdf5_location.set_index(num)\n if self.hdf5_location.slice:\n self.data = self.ds[tuple(self.hdf5_location.slice)]\n self.nframes = self.ds.shape[self.hdf5_location.last_index]\n else:\n self.data = self.ds[:]\n return frame","def get_frame(self,t):\n\n return pyfx.util.to_array(self._img_list[t],dtype=np.uint8,\n num_channels=4)","def getSubsampleList(vcfname, ss_count):\n\n vcf_o = pysam.VariantFile(vcfname)\n rec = next(vcf_o)\n vcf_o.close()\n lst = []\n for samp in rec.samples:\n lst.append(samp)\n return lst[:int(ss_count)]","def get_frame(self, indices: List[int]) -> List[np.ndarray]:\n if isinstance(indices, int):\n indices = [indices]\n img_list = []\n if self.frame_zip_fid is None:\n self._check_available(self.zip_path)\n self.frame_zip_fid = zipfile.ZipFile(self.zip_path, 'r')\n\n for idx in indices:\n file_name = self.frame_fmt.format(int(idx) + 1)\n img = self.load_image_from_zip(self.frame_zip_fid, file_name, cv2.IMREAD_COLOR)\n img_list.append(img)\n return img_list","def available_frames(self):\n if self._pipeline:\n #return [getattr(frame[0], \"name\", frame[0]) for frame in self._pipeline]\n return [step.frame if isinstance(step.frame, str) else step.frame.name for step in self._pipeline ]\n else:\n return None","def get_srcs():\n global ms\n global srcs\n\n if not srcs:\n # Update both of them if one was not already declared\n ms, srcs = stixhelpers.get_stix_memory_stores() \n \n return srcs","def GetSubContoursByFrame(watershed, allValsByFrame):\n scListByFrame = []\n for frame in range(len(watershed)):\n scList = []\n for v in allValsByFrame[frame]:\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\n (\n perimeterVals,\n perimeterList,\n scPoints,\n ) = ImageContour.GetPerimeterByNeighborVal(\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\n )\n scPointsAdj = [\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\n for scp in scPoints\n ] # Will need to - 0.5 to line up on an overlay\n if len(perimeterList) > 0:\n scList += [\n SubContour(\n points=scPointsAdj[i],\n numPoints=len(scPointsAdj[i]),\n adjusted_length=perimeterList[i],\n values=tuple(sorted([v, perimeterVals[i]])),\n startPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][0]\n ),\n endPointValues=GetValuesAroundSCPoint(\n watershed[frame], scPointsAdj[i][-1]\n ),\n )\n for i in range(len(perimeterVals))\n ]\n scList.sort(key=lambda x: x.values)\n for i in range(len(scList) - 1, 0, -1):\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\n if scList[i - 1].values == scList[i].values:\n scList[i - 1].adjusted_length = min(\n scList[i - 1].adjusted_length, scList[i].adjusted_length\n )\n del scList[i]\n scListByFrame.append(scList)\n return scListByFrame","def get_recorded_audio(self):\n return self.frames","def get_frame(self, frame):\n return self.frames[frame]","def get(self, filter_params, after, limit):\n filter_params.pop('study_id', None)\n\n q = (Study.query\n .filter_by(**filter_params))\n\n return (StudySchema(many=True)\n .jsonify(Pagination(q, after, limit)))","def _get_all_spectra(self):\n pass","def list_data_frames():\n\n cmd = dict()\n cmd[\"type_\"] = \"list_data_frames\"\n cmd[\"name_\"] = \"\"\n \n s = comm.send_and_receive_socket(cmd)\n\n msg = comm.recv_string(s)\n\n if msg != \"Success!\":\n raise Exception(msg)\n \n json_str = comm.recv_string(s) \n \n s.close() \n\n return json.loads(json_str)","def get_dataframe(self):\n for i, study_id in enumerate(self.studies_to_combine):\n copy = repr(self.original_study_location).strip(\"'\")\n study_location = copy.replace(\"MTBLS1\", study_id)\n\n for maf in self.sort_mafs(study_location, study_id):\n maf_temp = None\n try:\n maf_temp = pandas.read_csv(os.path.join(study_location, maf), sep=\"\\t\", header=0, encoding='unicode_escape')\n except pandas.errors.EmptyDataError as e:\n logger.error(f'EmptyDataError Issue with opening maf file {maf}: {str(e)}')\n self.unopenable_maf_register.append(maf)\n continue\n except Exception as e:\n logger.error(f'Issue with opening maf file {maf}, cause of error unclear: {str(e)}')\n self.unopenable_maf_register.append(maf)\n continue\n\n cleanup_function = getattr(DataFrameUtils, f'{self.method}_maf_cleanup')\n maf_temp = cleanup_function(maf_temp, study_id, maf)\n maf_as_dict = totuples(df=maf_temp, text='dict')['dict']\n\n yield maf_as_dict","def get_bodyparts(project_dir):\n print(f\"\\n\\n\\nLoading data\")\n df_paths = sorted(glob.glob(os.path.join(project_dir, '*.h5')))\n points_2d_df = utils.create_dlc_points_2d_file(df_paths)\n arr = points_2d_df[points_2d_df[\"frame\"]==0][[\"marker\"]][points_2d_df[\"camera\"]==0].values\n final_arr = arr.flatten().tolist()\n return(final_arr)","def query_and_read_frame(frame_type, channels, start_time, end_time):\n logging.info('querying datafind server')\n paths = frame_paths(frame_type, start_time, end_time)\n logging.info('found files: %s' % (' '.join(paths)))\n return read_frame(paths, channels, \n start_time=start_time, \n end_time=end_time)","def __setup_video_frames_extraction(self, video_file, scene_ratio,\n start_duration=None, stop_duration=None,\n frames_folder=None):\n frames = _ExtractFrames(video_file, scene_ratio, start_time=start_duration,\n stop_time=stop_duration, frames_path=frames_folder)\n\n print \"Initialize video frames extraction\"\n return frames"],"string":"[\n \"def get_frames_for_sample(sample):\\n path = os.path.join('data', sample[0])\\n filename = sample[1]\\n images = sorted(glob.glob(os.path.join(path, filename + '*jpg')))\\n return images\",\n \"def getFrames():\\n\\t\\tfor cam in Camera.CAMERAS: cam.getFrame()\",\n \"def getQiimeSffSamples(self, study_id,seq_run_id):\\n try:\\n con = self.getSFFDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('get_qiime_sff_samples', \\\\\\n [study_id,seq_run_id,results])\\n return results\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), str(e))\\n return False\",\n \"def get(self):\\n return self.frames\",\n \"def get_frames(data: Union[sc.DataArray, sc.Dataset], **kwargs) -> sc.Dataset:\\n\\n # if data is not None:\\n # return frames_peakfinding(data=data,\\n # instrument=instrument,\\n # plot=plot,\\n # **kwargs)\\n # else:\\n\\n return frames_analytical(data=data, **kwargs)\",\n \"def get_frames(comkey):\\n logger.info('Topic Group: {}'.format(browser.title))\\n\\n # Fetch frames one at a time until no more found\\n more_pages = True\\n while more_pages:\\n base_name = \\\"{}.html\\\".format(frame.frame_id())\\n frame_name = os.path.join(FRAMESDIR, base_name)\\n logger.info('Creating {}'.format(frame_name))\\n frame.write_page(frame_name)\\n more_pages = frame.next_page()\\n\\n return None\",\n \"def get_frames(self):\\n\\n log(\\\"Getting frames for {} at {}\\\".format(self._location, self._t0))\\n fn_get = lambda time_str: self.get_wximg(time_str)\\n pool0 = multiprocessing.dummy.Pool(self._frames)\\n raw = pool0.map(fn_get, self.get_time_strs())\\n wximages = [x for x in raw if x is not None]\\n if not wximages:\\n return None\\n pool1 = multiprocessing.dummy.Pool(len(wximages))\\n background = self.get_background()\\n if background is None:\\n return None\\n fn_composite = lambda x: self._pilimg.alpha_composite(background, x)\\n composites = pool1.map(fn_composite, wximages)\\n legend = self.get_legend()\\n if legend is None:\\n return None\\n loop_frames = pool1.map(lambda _: legend.copy(), composites)\\n fn_paste = lambda x: x[0].paste(x[1], (0, 0))\\n pool1.map(fn_paste, zip(loop_frames, composites))\\n return loop_frames\",\n \"def getSFFFiles(self, study_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n items = []\\n con.cursor().callproc('qiime_assets.get_sff_files', [study_id, results])\\n for row in results:\\n items.append(row[0])\\n return items\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def getSampleIDsFromStudy(self, study_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('qiime_assets.get_sample_ids_from_study', [study_id, results])\\n metadata_fields = []\\n for row in results:\\n metadata_fields.append(row[0])\\n return metadata_fields\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def get_all_frames(self):\\n #pdb.set_trace()\\n frame_size=(512,512)\\n frame_data = []\\n variant_type = (pythoncom.VT_BYREF | pythoncom.VT_ARRAY | pythoncom.VT_UI2)\\n for i in xrange(self.defaults['EXP_SEQUENTS']):\\n frame_data.append(win32com.client.VARIANT(variant_type, numpy.empty(frame_size)))\\n frame_data[i]=self.appdoc.GetFrame(i+1,frame_data[i])\\n \\n return numpy.array(frame_data, dtype=numpy.uint16)\",\n \"def get_frames_rep_hdf5(file_hdf5, time_hdf5, filename, time_begin_s, time_end_s):\\n get_features = Features_Accessor(time_hdf5, file_hdf5).get_features_from_raw\\n return get_features(dict({'file': [filename], 'onset': [time_begin_s], 'offset': [time_end_s]}))[1]\",\n \"def experiment_frames(request,id):\\n\\texp = Experiment.objects.get(id=id)\\n\\tmovies_glob = PROJECT_DIR + exp.frames_url() + '*.swf'\\n\\tmovies = glob.glob(movies_glob)\\n\\truns = map(os.path.basename,movies)\\n\\truns.sort()\\n\\treturn render_to_response('experiments/experiment_frames.html',\\n\\t\\t\\t\\t\\t\\t\\t{'exp':exp,'runs':runs},\\n\\t\\t\\t\\t\\t\\t\\tcontext_instance=RequestContext(request))\",\n \"def get_frames_by_filename(self, filename, data_type):\\n # First, find the sample row.\\n sample = None\\n\\n for row in self.data:\\n if row[1] == filename:\\n sample = row\\n break\\n if sample is None:\\n raise ValueError(\\\"Couldn't find sample: %s\\\" % filename)\\n\\n # Get the sequence from disk.\\n sequence = self.get_extracted_sequence(data_type, sample)\\n if sequence is None:\\n raise ValueError(\\\"Can't find sequence. Did you generate them?\\\")\\n \\n return sequence\",\n \"def getFrames(job, **options):\\n criteria = search.FrameSearch.criteriaFromOptions(**options)\\n framesSeq = Cuebot.getStub('frame').GetFrames(\\n job_pb2.FrameGetFramesRequest(job=job, r=criteria), timeout=Cuebot.Timeout).frames\\n return [Frame(f) for f in framesSeq.frames]\",\n \"def getSampleList(self, study_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('qiime_assets.get_sample_list', [study_id, results])\\n sample_list = {}\\n for sample_name, sample_id in results:\\n sample_list[sample_id] = sample_name\\n return sample_list\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def get_frame():\\n\\tall_frames = {}\\n\\tkeys = get_utt()\\n\\tfor i, matrix_id in enumerate(mfcc_h5.read(keys)):\\t\\n\\t\\tmatrix = np.asarray(matrix_id)\\t\\n\\t\\tall_frames[keys[i]] = matrix \\n\\t\\n\\treturn all_frames\",\n \"def get_frames_with_manifests() -> Generator[dict, dict, list[FrameWithManifest]]:\\n response = yield {\\\"method\\\": \\\"ApplicationCache.getFramesWithManifests\\\", \\\"params\\\": {}}\\n return [FrameWithManifest.from_json(f) for f in response[\\\"frameIds\\\"]]\",\n \"def extract_frames():\\n vc = cv2.VideoCapture(INPUT_FILE)\\n c=1\\n\\n if vc.isOpened():\\n rval , frame = vc.read()\\n else:\\n rval, frame = False, False\\n\\n while rval:\\n # cv2.imwrite((MODIFIED_FRAMES_DIR + 'img' + str(c) + '.jpg'),frame)\\n cv2.imwrite((MODIFIED_FRAMES_DIR + str(c) + '.jpg'),frame)\\n c = c + 1\\n cv2.waitKey(1)\\n rval, frame = vc.read()\\n vc.release()\\n print(\\\"All frames extracted successfully...\\\")\",\n \"def _subsample_frames(self, video_clip_frames):\\n subsampled_frames = []\\n current_ix = 0\\n step_size = len(video_clip_frames) / float(config.RGB_N_FRAMES)\\n for _ in range(config.RGB_N_FRAMES):\\n frame = video_clip_frames[int(current_ix)]\\n subsampled_frames.append(frame)\\n current_ix += step_size\\n\\n return np.array(subsampled_frames)\",\n \"def _select_frames(self, frames):\\n converted_frames = list()\\n # Ignore some frame at begin and end.\\n for i in np.linspace(0, self.video_size, self.frame_num + 2)[1:self.frame_num + 1]:\\n img = frames[int(i)]\\n img = img.resize((224, 224), Image.BILINEAR)\\n frame_data = np.array(img)\\n converted_frames.append(frame_data)\\n return converted_frames\",\n \"def get_experiment_frames(experiments, datadir=None):\\n import pandas as pd\\n\\n exp_frames = dict()\\n\\n if not datadir:\\n datadir = os.getcwd()\\n\\n print 'reading profiles in %s' % datadir\\n\\n for exp in experiments:\\n print \\\" - %s\\\" % exp\\n exp_frames[exp] = list()\\n\\n for sid, label in experiments[exp]:\\n print \\\" - %s\\\" % sid\\n \\n import glob\\n for prof in glob.glob (\\\"%s/%s-pilot.*.prof\\\" % (datadir, sid)):\\n print \\\" - %s\\\" % prof\\n frame = pd.read_csv(prof)\\n exp_frames[exp].append ([frame, label])\\n \\n return exp_frames\",\n \"def frames(self):\\n return list(self._frames)\",\n \"def get_lidc_dataframes(data_path: str, num_sectors: int):\\n sorted_studies = sorted(glob(os.path.join(data_path, \\\"*\\\")))\\n frames = []\\n for study in sorted_studies:\\n df_temp = pd.read_csv(\\n os.path.join(study, \\\"annotations.txt\\\"), sep=\\\": \\\", header=None, dtype=str\\n )\\n df_temp.columns = [\\\"File\\\", \\\"Label\\\"]\\n df_temp[\\\"File\\\"] = df_temp[\\\"File\\\"].apply(lambda e: f\\\"{study}/{e}.png\\\")\\n frames.append(df_temp)\\n\\n return [balance_frame(frame) for frame in slice_sector(frames, num_sectors)]\",\n \"def _read_frames(self):\\n cap = self._read_file()\\n\\n frame_list = []\\n ret_list = []\\n\\n while True:\\n ret, frame = cap.read()\\n if ret:\\n frame_list.append(np.array(frame))\\n ret_list.append(ret)\\n else:\\n break\\n if self.mode==\\\"np\\\":\\n frame_list = np.array(frame_list)\\n return frame_list\",\n \"def condition_frames(run_evs, skip=0):\\n frames_list = []\\n for ev in run_evs: # loop through runs\\n if not bool(ev): # empty EV file (e.g. when there were no error trials or no no-response trials)\\n frames_list.append(np.array([]))\\n else:\\n # Determine when trial starts, rounded down\\n start = np.floor(ev[\\\"onset\\\"] / TR).astype(int)\\n\\n # Use trial duration to determine how many frames to include for trial\\n duration = np.ceil(ev[\\\"duration\\\"] / TR).astype(int)\\n\\n # Take the range of frames that correspond to this specific trial\\n if type(start) == np.ndarray: # many trials\\n frames = [s + np.arange(skip, d) for s, d in zip(start, duration)] # loop through different onsets for each trial\\n elif type(start) == float or type(start) == np.int64:\\n # contains only one onset: it is either the full block (with many trials inside,\\n # but just one onset value) or just a single trial\\n frames = [start + np.arange(skip, duration)]\\n\\n frames_list.append(np.concatenate(frames))\\n\\n return frames_list\",\n \"def get_images_in_frame(self, frame: int) -> np.ndarray:\\n\\n # Check if it's the first time the frames are requested and the videos are not unrolled\\n if not os.path.exists(self.videos_dir):\\n self.unroll_videos()\\n\\n # print(\\\"Searching for images of frame \\\", frame, \\\"...\\\")\\n # Create the string of the name of the frame that we are going to search for in all camera folders\\n frame_name = \\\"frame\\\" + ''.zfill(9)\\n frame_string = str(frame*2-1) if self.half_resolution else str(frame)\\n number_of_chars = len(frame_string)\\n frame_name = frame_name[:-number_of_chars] + frame_string + \\\".\\\" + self.image_format\\n \\n # print(\\\"Frame name: \\\" + frame_name)\\n\\n # Get the paths to all cameras inside the videos folder sorted by name\\n cameras_paths = [os.path.join(self.videos_dir, name) for name in os.listdir(self.videos_dir) if os.path.isdir(os.path.join(self.videos_dir,name))]\\n cameras_paths.sort()\\n\\n # Get the frame_name image from those paths\\n images = []\\n # print(cameras_paths)\\n\\n for path in cameras_paths:\\n image = cv2.imread(os.path.join(path, frame_name), cv2.IMREAD_COLOR)\\n # print(os.path.join(path, frame_name))\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n images.append(image)\\n\\n # print(\\\"Images of frame \\\", frame, \\\" retrieved.\\\")\\n return np.array(images)\",\n \"def sample_frames(frame_dir, fps, visualize_sample_rate):\\n visualize_every_x_frames = visualize_sample_rate * int(fps)\\n sampled_frames = np.empty((0, 3, IMG_DIM, IMG_DIM), dtype=np.float32) # B, C, H, W\\n i = 0\\n for file in sorted(os.listdir(frame_dir)):\\n if i % visualize_every_x_frames == 0:\\n img = skimage.img_as_float(skimage.io.imread(os.path.join(frame_dir, file))).astype(np.float32)\\n img = skimage.transform.resize(img, (IMG_DIM, IMG_DIM)) # H, W, C\\n img = img.swapaxes(1, 2).swapaxes(0, 1) # C, H, W\\n sampled_frames = np.append(sampled_frames, np.array([img]), axis=0)\\n i += 1\\n logger.debug(\\\"total number of frames: {}\\\".format(i))\\n return sampled_frames\",\n \"def get_frame(self, f):\\n return self._frames[f, :]\",\n \"def getSampleDetailList(self, study_id):\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('get_sample_detail_list', [study_id, results])\\n sample_details = []\\n for sample_name, sample_id, public, collection_date, run_prefix, sequence_count, otu_count, otu_percent_hit in results:\\n sample_details.append((sample_name, sample_id, public, collection_date, run_prefix, sequence_count, otu_count, otu_percent_hit))\\n return sample_details\",\n \"def get_fixation_frames(subject, run=0):\\n\\n trial_frames = np.append(condition_frames(load_evs(subject, 'wm', 'all_bk_cor'))[run],\\n condition_frames(load_evs(subject, 'wm', 'all_bk_err'))[run]) # TODO: include no response trials\\n trial_frames = np.sort(trial_frames)\\n\\n fixation_start = np.array([], dtype=int) # initialize\\n\\n for idx, i in enumerate(trial_frames):\\n if idx == 0:\\n continue\\n\\n # find frames with difference greater than 10s\\n if i - trial_frames[idx - 1] > 10 / TR:\\n fixation_start = np.append(fixation_start, trial_frames[idx - 1])\\n\\n fixation_duration = np.ceil(15 / TR) # always 15s duration\\n\\n # get range of frames corresponding to duration of fixation block\\n fixation_frames = np.concatenate([i + np.arange(0, fixation_duration, dtype=int) for i in fixation_start])\\n\\n return fixation_frames\",\n \"def _getDataSetForFCSFileSample(self):\\n\\n # Get the dataset for current FCS file sample\\n dataSets = searchService.getDataSet(self._entityId)\\n if dataSets is None:\\n self._message = \\\"Could not retrieve datasets for \\\" \\\\\\n \\\"FCS file with identifier \\\" + self._entityId + \\\"!\\\"\\n self._logger.error(self._message)\\n else:\\n dataSets = [dataSets]\\n\\n # Return\\n return dataSets\",\n \"def getSequencesFromSample(self, study_id, sample_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('qiime_assets.get_sequences_for_fasta', [study_id, sample_id, results])\\n seqs = {}\\n for row in results:\\n seqs[row[0]] = row[1]\\n return seqs \\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def studies(self):\\n return self._study_queryset\",\n \"def find_frames(self, ftype, calib_ID=None, index=False):\\n if 'framebit' not in self.keys():\\n msgs.error('Frame types are not set. First run get_frame_types.')\\n if ftype == 'None':\\n return self['framebit'] == 0\\n # Select frames\\n indx = self.type_bitmask.flagged(self['framebit'], ftype)\\n\\n if calib_ID is not None:\\n # Select frames in the same calibration group\\n indx &= self.find_calib_group(calib_ID)\\n\\n # Return\\n return np.where(indx)[0] if index else indx\",\n \"def _read_frames(filename: str) -> Iterator[Tuple[CritterType, numpy.ndarray]]:\\n frame_skip = 0\\n last_section = None\\n last_frame = None\\n\\n good_frames: Dict[Tuple[CritterType, int], numpy.ndarray] = {}\\n\\n cap = cv2.VideoCapture(filename)\\n while True:\\n ret, frame = cap.read()\\n if not ret:\\n break # Video is over\\n\\n if frame_skip > 0:\\n frame_skip -= 1\\n continue\\n\\n if frame.shape[:2] == (1080, 1920):\\n frame = cv2.resize(frame, (1280, 720))\\n\\n assert frame.shape[:2] == (720, 1280), \\\\\\n 'Invalid resolution: {1}x{0}'.format(*frame.shape)\\n\\n if not detect(frame):\\n continue # Skip frames that are not showing critterpedia.\\n\\n # Detect a dark line that shows up only in Pictures Mode.\\n mode_detector = frame[20:24, 600:800].mean(axis=(0, 1))\\n if numpy.linalg.norm(mode_detector - (199, 234, 237)) > 50:\\n raise AssertionError('Critterpedia is in Pictures Mode.')\\n\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n if filename.endswith('.jpg'): # Handle screenshots\\n yield _detect_critter_section(gray), frame[149:623, :]\\n continue\\n\\n if last_frame is None:\\n last_frame = frame\\n continue\\n\\n critter_section = _detect_critter_section(gray)\\n if critter_section != last_section:\\n if last_section is not None:\\n frame_skip = 15\\n last_section = critter_section\\n continue\\n\\n # Grab the last frame for each side and section combination.\\n if last_frame[570:600, :70, 2].min() > 230:\\n good_frames[critter_section, 0] = last_frame\\n elif last_frame[570:600, -70:, 2].min() > 230:\\n good_frames[critter_section, 1] = last_frame\\n\\n last_frame = frame\\n\\n cap.release()\\n\\n for (critter_type, _), frame in good_frames.items():\\n # Crop the region containing critter icons.\\n yield critter_type, frame[149:623, :]\",\n \"def img_filenames(self, matricule):\\n proj, sid = next((proj, proj.Matricule(matricule).to('AmcStudentId'))\\n for proj in self.projects_by_serie.values()\\n if proj.Matricule(matricule).exists('AmcStudentId'))\\n return [\\n (int(num), filename.replace('%PROJET', proj.path))\\n for num, filename in proj.dbs['capture'].execute('select page, src from capture_page where student=? order by page', [sid])\\n ]\",\n \"def frame_list_fixture():\\n return [[4, 3, 5, 7], [8, 6, 3], [6, 7]]\",\n \"def getBitstreamFrames(self):\\n \\n return self.bitstream_frames\",\n \"def frames(self) -> Set[int]:\\n return self._frames\",\n \"def get_stack_frames(self, threadId=0, startFrame=0, levels=0, format=None):\\n\\n # format is ignored, TODO?\\n # threadId is ignored since renpy is single threaded for stuff we need\\n\\n clevel = 0\\n slevel = 0 if startFrame is None else startFrame\\n elevel = None if levels is None or levels == 0 else levels\\n\\n frames = []\\n cframe = self.active_frame\\n while cframe is not None:\\n if clevel >= slevel:\\n finfo = {}\\n\\n finfo[\\\"id\\\"] = clevel\\n finfo[\\\"name\\\"] = cframe.f_code.co_name + self.format_method_signature(cframe.f_locals, cframe.f_code)\\n finfo[\\\"source\\\"] = {\\\"path\\\": cframe.f_code.co_filename}\\n finfo[\\\"line\\\"] = cframe.f_lineno\\n finfo[\\\"presentationHint\\\"] = \\\"normal\\\"\\n finfo[\\\"column\\\"] = 0\\n\\n dis_info = {}\\n finfo[\\\"subsource\\\"] = dis_info\\n\\n disassembled = dis(cframe.f_code, cframe.f_lasti)\\n dis_info[\\\"sources\\\"] = [{\\\"text\\\": self.format_disassembly(cframe.f_lineno, *de), \\\"line\\\": de[1], \\\"source\\\": finfo[\\\"source\\\"]} for de in disassembled]\\n ord = 0\\n for de in disassembled:\\n if de[0]:\\n break\\n ord += 1\\n finfo[\\\"subsourceElement\\\"] = ord\\n\\n frames.append(finfo)\\n clevel += 1\\n if elevel is not None and clevel >= elevel:\\n break\\n cframe = cframe.f_back\\n\\n return frames\",\n \"def get_frames(self):\\n if not self.video:\\n return []\\n # We cannot validate shape on construction as that happens inside graph\\n # mode as we construct from a tf.data.Dataset, so we validate here.\\n self.video[0].validate_shape_and_dtype()\\n return self.video\",\n \"def getDataFrames(sampleparams, shakeparams, predictors, outparams):\\n coverage = sampleparams['coverage']\\n f = fiona.collection(coverage, 'r')\\n cbounds = f.bounds\\n f.close()\\n dx = sampleparams['dx']\\n cb = sampleparams['cb']\\n nmax = sampleparams['nmax']\\n nsamp = sampleparams['nsamp']\\n touch_center = sampleparams['touch_center']\\n testpercent = sampleparams['testpercent']\\n extent = sampleparams['extent']\\n h1 = sampleparams['h1']\\n h2 = sampleparams['h2']\\n\\n yestest, yestrain, notest, notrain, xvar, yvar, pshapes, proj = sampleFromFile(coverage, dx=dx,\\n nmax=nmax, testPercent=testpercent, touch_center=touch_center, classBalance=cb, extent=extent,\\n Nsamp=nsamp, h1=h1, h2=h2)\\n\\n traincolumns = OrderedDict()\\n testcolumns = OrderedDict()\\n\\n if (100-testpercent) > 0:\\n traincolumns['lat'] = np.concatenate((yestrain[:, 1], notrain[:, 1]))\\n traincolumns['lon'] = np.concatenate((yestrain[:, 0], notrain[:, 0]))\\n traincolumns['coverage'] = np.concatenate((np.ones_like(yestrain[:, 1]),\\n np.zeros_like(notrain[:, 1])))\\n\\n if testpercent > 0:\\n testcolumns['lat'] = np.concatenate((yestest[:, 1], notest[:, 1]))\\n testcolumns['lon'] = np.concatenate((yestest[:, 0], notest[:, 0]))\\n testcolumns['coverage'] = np.concatenate((np.ones_like(yestest[:, 1]), np.zeros_like(notest[:, 1])))\\n\\n for predname, predfile in predictors.items():\\n ftype = getFileType(predfile)\\n if ftype == 'shapefile':\\n attribute = predictors[predname+'_attribute']\\n shapes = subsetShapes(predfile, cbounds)\\n yes_test_samples = sampleShapes(shapes, yestest, attribute)\\n no_test_samples = sampleShapes(shapes, notest, attribute)\\n yes_train_samples = sampleShapes(shapes, yestrain, attribute)\\n no_train_samples = sampleShapes(shapes, notrain, attribute)\\n testcolumns[predname] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\\n traincolumns[predname] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\\n elif ftype == 'grid':\\n method = 'nearest'\\n if predname+'_sampling' in predictors:\\n method = predictors[predname+'_sampling']\\n\\n if testpercent > 0:\\n yes_test_samples = sampleGridFile(predfile, yestest, method=method)\\n no_test_samples = sampleGridFile(predfile, notest, method=method)\\n testcolumns[predname] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\\n\\n if (100-testpercent) > 0:\\n yes_train_samples = sampleGridFile(predfile, yestrain, method=method)\\n no_train_samples = sampleGridFile(predfile, notrain, method=method)\\n traincolumns[predname] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\\n else:\\n continue # attribute or sampling method key\\n\\n #sample the shakemap\\n layers = ['mmi', 'pga', 'pgv', 'psa03', 'psa10', 'psa30']\\n shakegrid = ShakeGrid.load(shakeparams['shakemap'], adjust='res')\\n for layer in layers:\\n yes_test_samples = sampleFromMultiGrid(shakegrid, layer, yestest)\\n no_test_samples = sampleFromMultiGrid(shakegrid, layer, notest)\\n yes_train_samples = sampleFromMultiGrid(shakegrid, layer, yestrain)\\n no_train_samples = sampleFromMultiGrid(shakegrid, layer, notrain)\\n if testpercent > 0:\\n testcolumns[layer] = np.squeeze(np.concatenate((yes_test_samples, no_test_samples)))\\n if (100-testpercent) > 0:\\n traincolumns[layer] = np.squeeze(np.concatenate((yes_train_samples, no_train_samples)))\\n\\n dftest = pd.DataFrame(testcolumns)\\n dftrain = pd.DataFrame(traincolumns)\\n\\n return (dftrain, dftest)\",\n \"def getEMPStudyList(self):\\n try:\\n studies = []\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n con.cursor().callproc('qiime_assets.get_emp_study_list', [results])\\n for row in results:\\n # study_id, sample_id, sample_name, project_name, study_title, email, sample_count, metadata_complete,\\n # study_score, sample_score, s.number_samples_promised, s.number_samples_in_freezer, \\n # s.principal_investigator\\n studies.append((row[0], row[1], row[2], row[3], row[4], row[5],\\n row[6], row[7], row[8], row[9], row[10], row[11], row[12]))\\n return studies\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\",\n \"def get_files(self, subj_id, study, modality, series):\\n if type(series) is int:\\n series = str(series)\\n\\n url = 'files?' + self._login_code + '&projectCode=' + \\\\\\n self.proj_code + '&subjectNo=' + subj_id + '&study=' + \\\\\\n study + '&modality=' + modality + '&serieNo=' + series\\n output = self._send_request(url)\\n\\n # Split at '\\\\n'\\n file_list = output.split('\\\\n')\\n # Remove any empty entries!\\n file_list = [x for x in file_list if x]\\n\\n return(file_list)\",\n \"def stream_frames(video_capture):\",\n \"def getFrameList(self):\\n with self.frameLock:\\n return list(self.frameList)\",\n \"def frames(self):\\n return self._frames\",\n \"def getSubframe( self, x, y, w, h):\\n\\n return TrackedObject.frame[y:y+h,x:x+w,:], \\\\\\n TrackedObject.frameG[y:y+h,x:x+w]\",\n \"def get_frames_image_for_display(self, mouse_x, mouse_y):\\n barcode_shape = self.barcode.get_barcode().shape\\n # Get the middle position of the saved frame\\n cur_pos = (mouse_x * barcode_shape[0] + mouse_y) / (barcode_shape[0] * barcode_shape[1])\\n frame_pos = round(cur_pos * len(self.barcode.saved_frames))\\n\\n # Get another four frames around the middle frame\\n # Make sure the frame positions/indexes are valid\\n if frame_pos < 2:\\n frame_pos = 2\\n if frame_pos > len(self.barcode.saved_frames) - 3:\\n frame_pos = len(self.barcode.saved_frames) - 3\\n frames = self.barcode.saved_frames[frame_pos - 2: frame_pos + 3]\\n\\n # Get the combined five frames image\\n combine_image = frames[0]\\n for frame in frames[1:]:\\n # Combine the frames into one image\\n combine_image = np.concatenate((combine_image, frame), axis=1)\\n\\n return combine_image\",\n \"def _get_headers_by_study(\\n files: Set[Path], file_errors: DefaultDict[Path, List[str]]\\n):\\n study_key_type = Tuple[str, ...]\\n studies: Dict[study_key_type, Dict[str, Any]] = {}\\n indices: Dict[str, Dict[study_key_type, int]] = {}\\n\\n for file in files:\\n if not file.is_file():\\n continue\\n with file.open(\\\"rb\\\") as f:\\n try:\\n # Read header only, skip reading the pixel data for now\\n ds = pydicom.dcmread(f, stop_before_pixels=True)\\n\\n # Group by series instance uid or by stack ID (for 4D images)\\n # Additionally also group by SOP class UID to skip over extra\\n # raw data (dose reports for example) that are sometimes stored\\n # under the same series instance UID.\\n key: study_key_type = (\\n ds.StudyInstanceUID,\\n getattr(ds, \\\"StackID\\\", ds.SeriesInstanceUID),\\n ds.SOPClassUID,\\n )\\n\\n studies[key] = studies.get(key, {})\\n indices[ds.StudyInstanceUID] = indices.get(\\n ds.StudyInstanceUID, {}\\n )\\n\\n try:\\n index = indices[ds.StudyInstanceUID][key]\\n except KeyError:\\n index = len(indices[ds.StudyInstanceUID])\\n indices[ds.StudyInstanceUID][key] = index\\n\\n headers = studies[key].get(\\\"headers\\\", [])\\n headers.append({\\\"file\\\": file, \\\"data\\\": ds})\\n studies[key][\\\"headers\\\"] = headers\\n\\n # Since we might need to combine multiple images with different\\n # series instance UID (in 4D images), we cannot use the series\\n # as the unique file name - instead, we use the study instance\\n # uid and a counter (index) per study\\n studies[key][\\\"name\\\"] = f\\\"{ds.StudyInstanceUID}-{index}\\\"\\n\\n except Exception as e:\\n file_errors[file].append(format_error(str(e)))\\n\\n return studies\",\n \"def get_snapshot_list(self, base, snappref=\\\"SPECTRA_\\\"):\\n #print('Looking for spectra in', base)\\n powerspectra = FluxPower(maxk=self.max_k)\\n for snap in range(30):\\n snapdir = os.path.join(base,snappref+str(snap).rjust(3,'0'))\\n #We ran out of snapshots\\n if not os.path.exists(snapdir):\\n snapdir = os.path.join(base,\\\"PART_\\\"+str(snap).rjust(3,'0'))\\n if not os.path.exists(snapdir):\\n snapdir = os.path.join(base, \\\"snap_\\\"+str(snap).rjust(3,'0'))\\n if not os.path.exists(snapdir):\\n continue\\n #We have all we need\\n if powerspectra.len() == np.size(self.zout):\\n break\\n try:\\n ss = self._get_spectra_snap(snap, base)\\n# print('Found spectra in', ss)\\n if ss is not None:\\n powerspectra.add_snapshot(snap,ss)\\n except IOError:\\n print(\\\"Didn't find any spectra because of IOError\\\")\\n continue\\n #Make sure we have enough outputs\\n if powerspectra.len() != np.size(self.zout):\\n raise ValueError(\\\"Found only\\\",powerspectra.len(),\\\"of\\\",np.size(self.zout),\\\"from snaps:\\\",powerspectra.snaps)\\n return powerspectra\",\n \"def get_stim_onset_times(sessions, metadata_dict):\\n if not isinstance(sessions, list):\\n sessions = list(sessions)\\n\\n for line in sessions:\\n session_id = line['Sess.ID']\\n if session_id: # we loaded a line with session info\\n session_name = '{}_{}'.format(line['Experiment'], line['Sess.ID'])\\n\\n # Check if session is already in database\\n if database is not None and session_name in database.index:\\n continue\\n session_stimuli = {}\\n session_stimuli['session_id'] = session_id\\n session_stimuli['stimuli'] = {}\\n session_stimuli['stimuli']['visual'] = []\\n session_stimuli['stimuli']['audio'] = []\\n session_stimuli['stimuli']['digital'] = []\\n videopaths = []\\n # load data from .tdms and .avi fils\\n for recording in line['Recordings']:\\n path = os.path.join(line['Base fld'], line['Exp fld'], recording)\\n for f in os.listdir(path):\\n if '.avi' in f:\\n videopaths.append(os.path.join(path, f))\\n print(videopaths)\\n elif '.tdms' == f[-5:]:\\n tdmspath = os.path.join(path, f)\\n # Loop over each .tdms file and extract stimuli frames\\n print(colored('Loading {}: {}'.format(session_name,os.path.basename(tdmspath)),'yellow'))\\n tdms = TdmsFile(tdmspath)\\n if metadata_dict[session_name]['software'] == 'behaviour':\\n visual_rec_stims, audio_rec_stims, digital_rec_stims = [], [], []\\n for group in tdms.groups():\\n for obj in tdms.group_channels(group):\\n if 'stimulis' in str(obj).lower():\\n for idx in obj.as_dataframe().loc[0].index:\\n if \\\"/' \\\" in idx:\\n framen = int(idx.split(\\\"/' \\\")[1].split('-')[0])\\n elif \\\"/' \\\" in idx:\\n framen = int(idx.split(\\\"/' \\\")[1].split('-')[0])\\n else:\\n framen = int(idx.split(\\\"/'\\\")[2].split('-')[0])\\n if 'visual' in str(obj).lower():\\n visual_rec_stims.append(framen)\\n elif 'audio' in str(obj).lower():\\n audio_rec_stims.append(framen)\\n elif 'digital' in str(obj).lower():\\n digital_rec_stims.append(framen)\\n else:\\n print(colored('Couldnt load stim correctly','yellow'))\\n # Now use the AI channels to find the *real* stimulus onset times and replace them\\n if audio_rec_stims:\\n stimulus_on_idx = np.where(tdms.group_channels('AI')[3].data > .55)[0] #in first data sets this is AI 1, later AI 2\\n idx_since_last_stimulus_on = np.diff(stimulus_on_idx)\\n if stimulus_on_idx.size:\\n stimulus_start_idx = stimulus_on_idx[np.append(np.ones(1).astype(bool),idx_since_last_stimulus_on>2*10000)] #usually 10 or 30\\n stimulus_start_frame = np.ceil(stimulus_start_idx / 10000 / (33 + 1 / 3) * 1000).astype(int)\\n stimulus_start_frame = stimulus_start_frame[stimulus_start_frame > 300]\\n else:\\n stimulus_start_frame = np.array(audio_rec_stims)\\n print('NO STIMULI FOUND!!')\\n\\n if len(stimulus_start_frame) != len(audio_rec_stims):\\n print('audio AI channel does not match number of timestamps by ' + str(len(audio_rec_stims)-len(stimulus_start_frame)) )\\n else:\\n discrepancy = stimulus_start_frame - audio_rec_stims\\n if sum(discrepancy>8):\\n print('audio AI channel does not match values of timestamps')\\n else:\\n print(discrepancy)\\n # for conditioning experiment, just use what the tdms says\\n # if 'food' in line['Experiment']:\\n # stimulus_start_frame = np.array(audio_rec_stims)\\n audio_rec_stims = list(stimulus_start_frame)\\n\\n session_stimuli['stimuli']['visual'].append(visual_rec_stims)\\n session_stimuli['stimuli']['audio'].append(audio_rec_stims)\\n session_stimuli['stimuli']['digital'].append(digital_rec_stims)\\n\\n else:\\n \\\"\\\"\\\" HERE IS WHERE THE CODE TO GET THE STIM TIMES IN MANTIS WILL HAVE TO BE ADDEDD \\\"\\\"\\\"\\n pass\\n\\n # Add to dictionary (or update entry)\\n stimulus_dict[session_name] = session_stimuli\\n return stimulus_dict\",\n \"def _scan_and_sample_dataset(self, dives):\\n roots = [os.path.join(self.p.data_root, n) for n in dives]\\n ret = []\\n for root in roots:\\n h5_files = glob.glob(os.path.join(root, '*.h5'))\\n for h5 in h5_files:\\n try:\\n fgroup = FrameGroup(h5, self.meta)\\n except (AssertionError, KeyError, OSError) as e:\\n if type(e) == AssertionError:\\n print_warn('Unmatched time: {}'.format(h5))\\n else:\\n print_warn('Corrupted h5: {}'.format(h5))\\n continue\\n num_samples = int(self.p.downsample * fgroup.num_frames)\\n indices = np.random.choice(\\n fgroup.num_frames, size=num_samples, replace=False)\\n ret.extend([(h5, int(idx)) for idx in indices])\\n random.shuffle(ret)\\n return ret\",\n \"def get_frame_list(self):\\r\\n\\r\\n logger.debug('Executing frame extraction')\\r\\n\\r\\n frames_loaded = False\\r\\n\\r\\n # Try to load YAML file with frame list\\r\\n if os.path.exists(self.frames_file_path):\\r\\n\\r\\n print 'Loading YAML file with frame list'\\r\\n logger.debug('Loading YAML file with frame list')\\r\\n\\r\\n f_list = utils.load_YAML_file(self.frames_file_path)\\r\\n\\r\\n if f_list:\\r\\n self.frame_list = f_list\\r\\n\\r\\n print 'YAML file with frame_list loaded'\\r\\n logger.debug('YAML file with frame_list loaded')\\r\\n\\r\\n frames_loaded = True\\r\\n\\r\\n if not frames_loaded:\\r\\n\\r\\n print '\\\\n\\\\n### Frame extraction ###\\\\n'\\r\\n logger.debug('\\\\n\\\\n### Frame extraction ###\\\\n')\\r\\n\\r\\n # Save processing time\\r\\n start_time = cv2.getTickCount()\\r\\n\\r\\n if not (os.path.exists(self.frames_path)):\\r\\n os.makedirs(self.frames_path)\\r\\n\\r\\n # Counter for all frames\\r\\n frame_counter = 0\\r\\n\\r\\n # Value of frame_counter for last analyzed frame\\r\\n last_anal_frame = 0\\r\\n\\r\\n # Open video file\\r\\n capture = cv2.VideoCapture(self.resource_path)\\r\\n\\r\\n self.frame_list = []\\r\\n\\r\\n # Save parameters for this video\\r\\n param_dict = {}\\r\\n\\r\\n if capture is None or not capture.isOpened():\\r\\n\\r\\n error = 'Error in opening video file'\\r\\n\\r\\n print error\\r\\n logger.debug(error)\\r\\n\\r\\n return\\r\\n\\r\\n else:\\r\\n\\r\\n video_fps = capture.get(cv2.cv.CV_CAP_PROP_FPS)\\r\\n\\r\\n param_dict[c.VIDEO_FPS_KEY] = video_fps\\r\\n\\r\\n # Original number of frames\\r\\n tot_frames = capture.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT)\\r\\n\\r\\n param_dict[c.VIDEO_TOT_FRAMES_KEY] = tot_frames\\r\\n\\r\\n self.fps = video_fps\\r\\n\\r\\n self.video_frames = float(tot_frames)\\r\\n\\r\\n # Saved frames\\r\\n saved_frames = 0\\r\\n\\r\\n while True:\\r\\n\\r\\n # Read frame\\r\\n ret, frame = capture.read()\\r\\n\\r\\n # If no frame is read, abort\\r\\n if not ret:\\r\\n break\\r\\n\\r\\n used_fps = c.USED_FPS\\r\\n use_or_fps = c.USE_ORIGINAL_FPS\\r\\n use_or_res = c.USE_ORIGINAL_RES\\r\\n used_res_scale_factor = c.USED_RES_SCALE_FACTOR\\r\\n\\r\\n if self.params is not None:\\r\\n\\r\\n if c.USED_FPS_KEY in self.params:\\r\\n used_fps = self.params[c.USED_FPS_KEY]\\r\\n\\r\\n if c.USE_ORIGINAL_FPS_KEY in self.params:\\r\\n use_or_fps = self.params[c.USE_ORIGINAL_FPS_KEY]\\r\\n\\r\\n if c.USE_ORIGINAL_RES_KEY in self.params:\\r\\n use_or_res = self.params[c.USE_ORIGINAL_RES_KEY]\\r\\n\\r\\n if c.USED_RES_SCALE_FACTOR_KEY in self.params:\\r\\n used_res_scale_factor = self.params[\\r\\n c.USED_RES_SCALE_FACTOR_KEY]\\r\\n\\r\\n # Next frame to be analyzed\\r\\n next_frame = last_anal_frame + (video_fps / used_fps) - 1\\r\\n\\r\\n if use_or_fps or (frame_counter > next_frame):\\r\\n\\r\\n # Frame position in video in milliseconds\\r\\n elapsed_ms = capture.get(cv2.cv.CV_CAP_PROP_POS_MSEC)\\r\\n\\r\\n # print 'elapsed video s =', elapsed_video_s\\r\\n\\r\\n fr_name = '%07d.png' % frame_counter\\r\\n\\r\\n frame_path = os.path.join(self.frames_path, fr_name)\\r\\n\\r\\n # Resize frame\\r\\n if not use_or_res:\\r\\n fx = used_res_scale_factor\\r\\n\\r\\n fy = used_res_scale_factor\\r\\n\\r\\n interp = cv2.INTER_AREA\\r\\n\\r\\n frame = cv2.resize(src=frame, dsize=(0, 0),\\r\\n fx=fx, fy=fy,\\r\\n interpolation=interp)\\r\\n\\r\\n cv2.imwrite(frame_path, frame,\\r\\n [cv.CV_IMWRITE_PNG_COMPRESSION, 0])\\r\\n\\r\\n frame_dict = {c.SAVED_FRAME_NAME_KEY: fr_name,\\r\\n c.ELAPSED_VIDEO_TIME_KEY: int(elapsed_ms)}\\r\\n\\r\\n self.frame_list.append(frame_dict)\\r\\n\\r\\n last_anal_frame = frame_counter\\r\\n\\r\\n saved_frames += 1\\r\\n\\r\\n frame_counter += 1\\r\\n\\r\\n self.progress = 100 * (frame_counter / self.video_frames)\\r\\n\\r\\n print('progress: ' + str(self.progress) + ' % \\\\r'),\\r\\n\\r\\n del capture\\r\\n\\r\\n self.saved_frames = float(saved_frames)\\r\\n\\r\\n param_dict[c.VIDEO_SAVED_FRAMES_KEY] = self.saved_frames\\r\\n\\r\\n # Save frame list in YAML file\\r\\n utils.save_YAML_file(self.frames_file_path, self.frame_list)\\r\\n\\r\\n # Save video parameters in YAML file\\r\\n\\r\\n utils.save_YAML_file(self.params_file_path, param_dict)\\r\\n\\r\\n # Save processing time\\r\\n time_in_clocks = cv2.getTickCount() - start_time\\r\\n time_in_seconds = time_in_clocks / cv2.getTickFrequency()\\r\\n\\r\\n print 'Time for frame extraction:', str(time_in_seconds), 's\\\\n'\\r\\n logger.debug(\\r\\n 'Time for frame extraction:', str(time_in_seconds), 's\\\\n')\\r\\n\\r\\n self.anal_times[c.FRAME_EXTRACTION_TIME_KEY] = time_in_seconds\\r\\n\\r\\n utils.save_YAML_file(self.analysis_file_path, self.anal_times)\",\n \"def _construct_frame_list(self):\\n\\n chunks = self._chunk_list(list(range(self._start_frame, self._max_frame + 1)),\\n int((self._max_frame - self._start_frame) / self._sub))\\n frame_list = [[c[0], c[len(c) - 1]] for c in chunks]\\n\\n # Fix the frame_list in case of rounding errors\\n if len(frame_list) > self._sub:\\n frame_list = self._restructure_frames(frame_list)\\n return frame_list\",\n \"def test_get_studies(self):\\n states = [\\n study_pb2.StudySpec.STATE_ENABLED, study_pb2.StudySpec.STATE_DISABLED\\n ]\\n studies = []\\n for i in range(5):\\n study_spec = sample_study_spec(name=str(i), state=states[i % len(states)])\\n self.storage.create_study(study_spec)\\n studies.append(study_spec)\\n\\n self.assertListEqual(studies, self.storage.get_studies())\\n for state in states:\\n self.assertListEqual([study for study in studies if study.state is state],\\n self.storage.get_studies(state=state))\",\n \"def get_video_frames(self):\\r\\n\\r\\n vid_dir = self._video_dir\\r\\n vid_frames = [str(img_path) for img_path in\\r\\n Path(vid_dir).glob('*.jpg')]\\r\\n if len(vid_frames) == 0:\\r\\n vid_frames = [str(img_path) for img_path in\\r\\n Path(vid_dir).glob('*.png')]\\r\\n list_of_frames = sorted(vid_frames)\\r\\n\\r\\n self._vid_frames = [list_of_frames]\\r\\n\\r\\n return self._vid_frames\",\n \"def get_files(self, sid):\\n try:\\n return self.datas.get(sid)\\n except Exception as ex:\\n raise ex\",\n \"def get_frames_from_video_capture(video_capture):\\n while video_capture.isOpened():\\n success, frame = video_capture.read()\\n if not success:\\n break\\n else:\\n yield frame\",\n \"def load_frames(self, path, frames, convert_alpha=False):\\n dir_path = self.get_path(path)\\n extension = \\\"\\\"\\n for name in listdir(dir_path):\\n file = join(dir_path, name)\\n if isfile(file):\\n striped, file_ext = splitext(name)\\n if striped == \\\"1\\\":\\n extension = file_ext\\n break\\n surfs = []\\n for c in range(1, frames + 1):\\n file = join(dir_path, str(c) + extension)\\n if convert_alpha:\\n surfs.append(load(file).convert_alpha())\\n continue\\n surfs.append(load(file).convert())\\n return surfs\",\n \"def get_activations_from_studies(cls, studies):\\n\\n activations = cls.query.filter(\\n cls.pmid.in_(studies), cls.location_id < 81925).all()\\n\\n return activations\",\n \"def frames(self):\\n while True:\\n ret, frame = self.classification()\\n if ret == True:\\n yield cv2.imencode('.jpg', frame)[1].tobytes()\\n else:\\n break\",\n \"def get_source_studies(self):\\n return list(set([trait.source_dataset.source_study_version.study for trait in self.get_all_source_traits()]))\",\n \"def _read_frame(path: str, *, format):\\n if not os.path.isfile(path):\\n tpath = resources_path(path)\\n if not os.path.isfile(path):\\n raise IOError(\\\"Unable to find file.\\\\nTried paths:\\\\n%s\\\\n%s\\\" % (path, tpath))\\n path = tpath\\n\\n data = scio.loadmat(path)\\n res = []\\n for (matkey, consumer) in format:\\n res.append(consumer(data[matkey]))\\n return res\",\n \"def readFrames(video):\\n frames = []\\n while True:\\n _, frame = video.read()\\n\\n if frame is None:\\n break\\n else:\\n frames.append(frame)\\n video.release()\\n return frames\",\n \"def get_measured_subframes(self):\\r\\r\\n loggerCmw = logging.getLogger('get_measured_subframes')\\r\\r\\n numSf_str = self.read('FETCh:WCDMa:SIGN:HACK:MSFRames?')\\r\\r\\n numSf_list = numSf_str.split(',')\\r\\r\\n\\r\\r\\n num = -1\\r\\r\\n measured_subframes = self.NO_MEASURED_FRAMES_STR\\r\\r\\n reliability = numSf_list[0]\\r\\r\\n if reliability == '0':\\r\\r\\n measured_subframes = numSf_list[1]\\r\\r\\n else:\\r\\r\\n loggerCmw.info(\\\"Measurements are not reliable, reliability indicator %s\\\" %reliability)\\r\\r\\n\\r\\r\\n return measured_subframes\",\n \"def frames(self) -> Optional[Tuple[int, ...]]:\\n return self._frames\",\n \"def get_frame_sequence(captured_file):\\n frame_seq = []\\n get_all_frame = \\\"tshark -r {} -Y 'http.request || http.response' -T fields -e frame.number\\\".format(captured_file)\\n frames = run_command(get_all_frame, True)\\n for f in frames:\\n fn = int(f.decode('utf8').rstrip('\\\\n'))\\n frame_seq.append(HTTPNode(fn))\\n \\n return frame_seq\",\n \"def search_research_studies_with_observations():\\n return ResearchStudy.where(struct={}).include('focus', Observation, reverse=True)\",\n \"def getStudyTemplates(self, study_id):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n results = con.cursor()\\n items = []\\n con.cursor().callproc('qiime_assets.get_study_templates', [study_id, results])\\n for row in results:\\n items.append(row[0])\\n return items\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def get_all_frames(self) -> List[str]:\\n frames = self.allFramesAsString().split(\\\"\\\\n\\\")\\n frames.remove(\\\"\\\")\\n return frames\",\n \"def find_records():\\r\\n\\r\\n print(\\\"begin find records\\\")\\r\\n\\r\\n study_list = retrieve_ref('study_list')\\r\\n sensor_list = retrieve_ref('sensor_list')\\r\\n # sensor_unit_list = retrieve_ref('sensor_unit_list')\\r\\n\\r\\n for study in study_list:\\r\\n # print('study = ' + str(study))\\r\\n source_path = os.path.join(study, 'source')\\r\\n # print('source_path = ' + str(source_path))\\r\\n\\r\\n source_folders = os.listdir(source_path)\\r\\n # print(str(study) + ' source_folders = ')\\r\\n # print(source_folders)\\r\\n\\r\\n df_meta = pd.DataFrame()\\r\\n df_meta['source_path'] = source_folders\\r\\n save_meta(study, df_meta)\\r\\n record_to_summary(study, 'Records found', str(len(source_folders)))\\r\\n\\r\\n print(\\\"completed find records\\\")\",\n \"def get_frame(self, frame: int) -> BaseImage:\\n return self.sequence[frame]\",\n \"def get_windows(timsData):\\n conn = timsData.conn\\n pasef_ms2_id = 8 # diaPASEF ms2 scans are denoted by 8 instead of 2\\n cycle_length = get_cycle_length(conn, pasef_ms2_id)\\n wpf = get_windows_per_frame(conn, pasef_ms2_id)\\n q = timsData.conn.execute(\\\"SELECT * FROM Frames INNER JOIN PasefFrameMsMsInfo ON Frames.Id=PasefFrameMsMsInfo.Frame WHERE MsMsType=%d LIMIT %d\\\" % (pasef_ms2_id, cycle_length*wpf))\\n frames = q.fetchall()\\n colnames = [description[0] for description in q.description]\\n resframe = pd.DataFrame(data = frames, columns = colnames)\\n return resframe\",\n \"def scenes_to_frames():\\n # Scene 001 from frames 1-150\\n cmd.scene('001', animate=0)\\n cmd.mview('store', 1)\\n cmd.mview('store', 150)\\n # Scene 002 from frames 250-400\\n cmd.scene('002', animate=0)\\n cmd.mview('store', 250)\\n cmd.mview('store', 400)\",\n \"def frames_df(task, conditions):\\n\\n frames_df = pd.DataFrame([])\\n\\n for subject in subjects:\\n for condition in conditions:\\n evs = load_evs(subject, task, condition)\\n df = pd.DataFrame(evs) # load evs into df\\n df['run'] = [0, 1]\\n df['subject'] = subject\\n df['condition'] = condition\\n df['frames'] = condition_frames(evs)\\n frames_df = frames_df.append(df, ignore_index=True)\\n\\n return frames_df\",\n \"def get_tracks(num=1):\\n pass\",\n \"def find_frame_files(self, ftype, calib_ID=None):\\n return self.frame_paths(self.find_frames(ftype, calib_ID=calib_ID))\",\n \"def getFrameByName(self, frameName):\\n return self.data.frames[frameName]\",\n \"def rend_samples(data,start_frame,cap,fs=[30,51,78,90],show=False):\\n row1 = [];\\n row2 = [];\\n row3 = [];\\n for f in fs:\\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\\n _,data['frame'] = cap.read();\\n data['i'] = f;\\n row1.append(extract_head(data));\\n row2.append(data['plts']['y'][f]);\\n render = cv2.imread(cf.renders_path + \\\"{:04d}.png\\\".format(f+1));\\n render = cv2.resize(render,(256,256));\\n row3.append(render);\\n row1 = np.concatenate(row1,axis=1);\\n row2 = np.concatenate(row2,axis=1);\\n row3 = np.concatenate(row3,axis=1);\\n grid = np.concatenate([row1,row2,row3]);\\n if show:\\n ut.show(grid);\\n return grid;\",\n \"def get_studies(self, subj_id, modality=None, unique=False):\\n\\n url = 'studies?' + self._login_code + \\\\\\n '&projectCode=' + self.proj_code + '&subjectNo=' + subj_id\\n output = self._send_request(url)\\n\\n # Split at '\\\\n'\\n stud_list = output.split('\\\\n')\\n # Remove any empty entries!\\n stud_list = [x for x in stud_list if x]\\n\\n if modality:\\n for ii, study in enumerate(stud_list):\\n url = 'modalities?' + self._login_code + \\\\\\n '&projectCode=' + self.proj_code + '&subjectNo=' + \\\\\\n subj_id + '&study=' + study\\n output = self._send_request(url).split('\\\\n')\\n\\n if modality in output:\\n if unique:\\n return([study, ]) # always return a list\\n else:\\n stud_list[ii] = None\\n\\n # In Py3, filter returns an iterable object, but here we want list\\n stud_list = list(filter(None, stud_list))\\n\\n return(stud_list)\",\n \"def get_frame(self):\\n return self.frames.get()\",\n \"def subsample(self, se):\\n\\t\\tdf = ReadDF('noname', self.readdict.refmap)\\n\\t\\tfor i in random.sample(xrange(1, self.n+1), min(se, self.n)):\\n\\t\\t\\tpos, read = self.partial_sampling_func(i)\\n\\t\\t\\tdf.add_read_to_vec(read,copy=1) # important to remember to use just this ONE copy!!!\\n\\t\\treturn df\",\n \"def _crop_frames(self, frames, center_crop=True):\\n cropped_frames = []\\n crop_location = 0.5 if center_crop else np.random.random_sample()\\n for frame in frames:\\n cropped_frame = self._crop_frame(frame, crop_location)\\n cropped_frames.append(cropped_frame)\\n\\n return np.array(cropped_frames)\",\n \"def getframe(self, num):\\n if num < 0 or num > self.nframes:\\n raise RuntimeError(\\\"Requested frame number is out of range\\\")\\n # Do a deep copy of the header to make a new one\\n frame = hdf5image(header=self.header.copy())\\n frame.header_keys = self.header_keys[:]\\n for key in (\\\"dim1\\\", \\\"dim2\\\", \\\"nframes\\\", \\\"bytecode\\\", \\\"hdf5\\\", \\\"ds\\\"):\\n frame.__setattr__(key, self.__getattribute__(key))\\n frame.hdf5_location = copy.deepcopy(self.hdf5_location)\\n frame.hdf5_location.set_index(num)\\n if self.hdf5_location.slice:\\n self.data = self.ds[tuple(self.hdf5_location.slice)]\\n self.nframes = self.ds.shape[self.hdf5_location.last_index]\\n else:\\n self.data = self.ds[:]\\n return frame\",\n \"def get_frame(self,t):\\n\\n return pyfx.util.to_array(self._img_list[t],dtype=np.uint8,\\n num_channels=4)\",\n \"def getSubsampleList(vcfname, ss_count):\\n\\n vcf_o = pysam.VariantFile(vcfname)\\n rec = next(vcf_o)\\n vcf_o.close()\\n lst = []\\n for samp in rec.samples:\\n lst.append(samp)\\n return lst[:int(ss_count)]\",\n \"def get_frame(self, indices: List[int]) -> List[np.ndarray]:\\n if isinstance(indices, int):\\n indices = [indices]\\n img_list = []\\n if self.frame_zip_fid is None:\\n self._check_available(self.zip_path)\\n self.frame_zip_fid = zipfile.ZipFile(self.zip_path, 'r')\\n\\n for idx in indices:\\n file_name = self.frame_fmt.format(int(idx) + 1)\\n img = self.load_image_from_zip(self.frame_zip_fid, file_name, cv2.IMREAD_COLOR)\\n img_list.append(img)\\n return img_list\",\n \"def available_frames(self):\\n if self._pipeline:\\n #return [getattr(frame[0], \\\"name\\\", frame[0]) for frame in self._pipeline]\\n return [step.frame if isinstance(step.frame, str) else step.frame.name for step in self._pipeline ]\\n else:\\n return None\",\n \"def get_srcs():\\n global ms\\n global srcs\\n\\n if not srcs:\\n # Update both of them if one was not already declared\\n ms, srcs = stixhelpers.get_stix_memory_stores() \\n \\n return srcs\",\n \"def GetSubContoursByFrame(watershed, allValsByFrame):\\n scListByFrame = []\\n for frame in range(len(watershed)):\\n scList = []\\n for v in allValsByFrame[frame]:\\n boundingRect = ImageContour.GetBoundingRect(watershed[frame], v)\\n # No longer needed: #contour,turns,vals = ImageContour.GetContour(watershed[0],v,boundingRect=boundingRect,byNeighbor=True)\\n (\\n perimeterVals,\\n perimeterList,\\n scPoints,\\n ) = ImageContour.GetPerimeterByNeighborVal(\\n watershed[frame], v, boundingRect=boundingRect, getSubContours=True\\n )\\n scPointsAdj = [\\n (np.array(scp) + [boundingRect[0][0], boundingRect[1][0]]).tolist()\\n for scp in scPoints\\n ] # Will need to - 0.5 to line up on an overlay\\n if len(perimeterList) > 0:\\n scList += [\\n SubContour(\\n points=scPointsAdj[i],\\n numPoints=len(scPointsAdj[i]),\\n adjusted_length=perimeterList[i],\\n values=tuple(sorted([v, perimeterVals[i]])),\\n startPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][0]\\n ),\\n endPointValues=GetValuesAroundSCPoint(\\n watershed[frame], scPointsAdj[i][-1]\\n ),\\n )\\n for i in range(len(perimeterVals))\\n ]\\n scList.sort(key=lambda x: x.values)\\n for i in range(len(scList) - 1, 0, -1):\\n # if 2 subcoutours are the same, keep only the one with the minimum length computation\\n if scList[i - 1].values == scList[i].values:\\n scList[i - 1].adjusted_length = min(\\n scList[i - 1].adjusted_length, scList[i].adjusted_length\\n )\\n del scList[i]\\n scListByFrame.append(scList)\\n return scListByFrame\",\n \"def get_recorded_audio(self):\\n return self.frames\",\n \"def get_frame(self, frame):\\n return self.frames[frame]\",\n \"def get(self, filter_params, after, limit):\\n filter_params.pop('study_id', None)\\n\\n q = (Study.query\\n .filter_by(**filter_params))\\n\\n return (StudySchema(many=True)\\n .jsonify(Pagination(q, after, limit)))\",\n \"def _get_all_spectra(self):\\n pass\",\n \"def list_data_frames():\\n\\n cmd = dict()\\n cmd[\\\"type_\\\"] = \\\"list_data_frames\\\"\\n cmd[\\\"name_\\\"] = \\\"\\\"\\n \\n s = comm.send_and_receive_socket(cmd)\\n\\n msg = comm.recv_string(s)\\n\\n if msg != \\\"Success!\\\":\\n raise Exception(msg)\\n \\n json_str = comm.recv_string(s) \\n \\n s.close() \\n\\n return json.loads(json_str)\",\n \"def get_dataframe(self):\\n for i, study_id in enumerate(self.studies_to_combine):\\n copy = repr(self.original_study_location).strip(\\\"'\\\")\\n study_location = copy.replace(\\\"MTBLS1\\\", study_id)\\n\\n for maf in self.sort_mafs(study_location, study_id):\\n maf_temp = None\\n try:\\n maf_temp = pandas.read_csv(os.path.join(study_location, maf), sep=\\\"\\\\t\\\", header=0, encoding='unicode_escape')\\n except pandas.errors.EmptyDataError as e:\\n logger.error(f'EmptyDataError Issue with opening maf file {maf}: {str(e)}')\\n self.unopenable_maf_register.append(maf)\\n continue\\n except Exception as e:\\n logger.error(f'Issue with opening maf file {maf}, cause of error unclear: {str(e)}')\\n self.unopenable_maf_register.append(maf)\\n continue\\n\\n cleanup_function = getattr(DataFrameUtils, f'{self.method}_maf_cleanup')\\n maf_temp = cleanup_function(maf_temp, study_id, maf)\\n maf_as_dict = totuples(df=maf_temp, text='dict')['dict']\\n\\n yield maf_as_dict\",\n \"def get_bodyparts(project_dir):\\n print(f\\\"\\\\n\\\\n\\\\nLoading data\\\")\\n df_paths = sorted(glob.glob(os.path.join(project_dir, '*.h5')))\\n points_2d_df = utils.create_dlc_points_2d_file(df_paths)\\n arr = points_2d_df[points_2d_df[\\\"frame\\\"]==0][[\\\"marker\\\"]][points_2d_df[\\\"camera\\\"]==0].values\\n final_arr = arr.flatten().tolist()\\n return(final_arr)\",\n \"def query_and_read_frame(frame_type, channels, start_time, end_time):\\n logging.info('querying datafind server')\\n paths = frame_paths(frame_type, start_time, end_time)\\n logging.info('found files: %s' % (' '.join(paths)))\\n return read_frame(paths, channels, \\n start_time=start_time, \\n end_time=end_time)\",\n \"def __setup_video_frames_extraction(self, video_file, scene_ratio,\\n start_duration=None, stop_duration=None,\\n frames_folder=None):\\n frames = _ExtractFrames(video_file, scene_ratio, start_time=start_duration,\\n stop_time=stop_duration, frames_path=frames_folder)\\n\\n print \\\"Initialize video frames extraction\\\"\\n return frames\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6049885","0.59706116","0.57190984","0.5599101","0.5508475","0.55001473","0.54696465","0.5453543","0.5443962","0.54344064","0.5425413","0.53727776","0.53502667","0.53314114","0.5238596","0.5207204","0.51428056","0.5139112","0.51072145","0.509223","0.5054078","0.50375295","0.5009608","0.50031275","0.49796918","0.49614277","0.49533322","0.49530774","0.4947847","0.4940793","0.49178955","0.49153247","0.49121943","0.48996004","0.4896901","0.4891801","0.4890971","0.4879641","0.48794425","0.48638797","0.4840882","0.48408586","0.47971347","0.47776544","0.47766024","0.47742635","0.47710678","0.47706273","0.47688955","0.4763027","0.4760436","0.4759032","0.47543895","0.47519603","0.47431007","0.47389412","0.4723116","0.47200224","0.47196072","0.47157457","0.47096613","0.4706132","0.46955422","0.46924964","0.46756834","0.46682844","0.46670142","0.46419388","0.4639011","0.463821","0.46340752","0.46294498","0.46243757","0.46197662","0.46168935","0.46095663","0.4608431","0.46003556","0.45971084","0.458257","0.4570562","0.4565017","0.456453","0.45630226","0.45584396","0.4557779","0.45565143","0.4554588","0.45538265","0.45522344","0.45513755","0.45499104","0.45397067","0.4537952","0.4535386","0.4533202","0.4526452","0.4524087","0.4516339","0.45141032"],"string":"[\n \"0.6049885\",\n \"0.59706116\",\n \"0.57190984\",\n \"0.5599101\",\n \"0.5508475\",\n \"0.55001473\",\n \"0.54696465\",\n \"0.5453543\",\n \"0.5443962\",\n \"0.54344064\",\n \"0.5425413\",\n \"0.53727776\",\n \"0.53502667\",\n \"0.53314114\",\n \"0.5238596\",\n \"0.5207204\",\n \"0.51428056\",\n \"0.5139112\",\n \"0.51072145\",\n \"0.509223\",\n \"0.5054078\",\n \"0.50375295\",\n \"0.5009608\",\n \"0.50031275\",\n \"0.49796918\",\n \"0.49614277\",\n \"0.49533322\",\n \"0.49530774\",\n \"0.4947847\",\n \"0.4940793\",\n \"0.49178955\",\n \"0.49153247\",\n \"0.49121943\",\n \"0.48996004\",\n \"0.4896901\",\n \"0.4891801\",\n \"0.4890971\",\n \"0.4879641\",\n \"0.48794425\",\n \"0.48638797\",\n \"0.4840882\",\n \"0.48408586\",\n \"0.47971347\",\n \"0.47776544\",\n \"0.47766024\",\n \"0.47742635\",\n \"0.47710678\",\n \"0.47706273\",\n \"0.47688955\",\n \"0.4763027\",\n \"0.4760436\",\n \"0.4759032\",\n \"0.47543895\",\n \"0.47519603\",\n \"0.47431007\",\n \"0.47389412\",\n \"0.4723116\",\n \"0.47200224\",\n \"0.47196072\",\n \"0.47157457\",\n \"0.47096613\",\n \"0.4706132\",\n \"0.46955422\",\n \"0.46924964\",\n \"0.46756834\",\n \"0.46682844\",\n \"0.46670142\",\n \"0.46419388\",\n \"0.4639011\",\n \"0.463821\",\n \"0.46340752\",\n \"0.46294498\",\n \"0.46243757\",\n \"0.46197662\",\n \"0.46168935\",\n \"0.46095663\",\n \"0.4608431\",\n \"0.46003556\",\n \"0.45971084\",\n \"0.458257\",\n \"0.4570562\",\n \"0.4565017\",\n \"0.456453\",\n \"0.45630226\",\n \"0.45584396\",\n \"0.4557779\",\n \"0.45565143\",\n \"0.4554588\",\n \"0.45538265\",\n \"0.45522344\",\n \"0.45513755\",\n \"0.45499104\",\n \"0.45397067\",\n \"0.4537952\",\n \"0.4535386\",\n \"0.4533202\",\n \"0.4526452\",\n \"0.4524087\",\n \"0.4516339\",\n \"0.45141032\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58449024"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":95592,"cells":{"query":{"kind":"string","value":"Returns definitions of module output ports."},"document":{"kind":"string","value":"def output_types(self) -> Optional[Dict[str, NeuralType]]:\n return {\n 'input_ids': NeuralType(('B', 'T'), ChannelType()),\n 'segment_ids': NeuralType(('B', 'T'), ChannelType()),\n 'input_mask': NeuralType(('B', 'T'), MaskType()),\n \"labels\": NeuralType(\n tuple('B'), RegressionValuesType() if self.task_name == 'sts-b' else CategoricalValuesType()\n ),\n }"},"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 getOutputPortsInfo(self):\n return [(gport.parentItem().module, gport.port, gport.controller.get_connections_from(gport.controller.current_pipeline, [gport.parentItem().module.id], gport.port.name), (gport.parentItem().boundingRect().right()-gport.parentItem().boundingRect().left())/2) for gport in self.pipelineView.getSelectedOutputPorts()]","def get_node_output_ports(node: Node):\n consumers = []\n for port in node.out_ports().values():\n for dst_port in port.get_destinations():\n consumers.append(dst_port)\n return consumers","def output_ports(self):\n return {\n 'audio_signal': NeuralType(('B', 'T'), AudioSignal(freq=self._sample_rate)),\n 'a_sig_length': NeuralType(tuple('B'), LengthsType()),\n 'label': NeuralType(tuple('B'), LabelsType()),\n 'label_length': NeuralType(tuple('B'), LengthsType()),\n }","def get_number_of_output_ports(self):\n return 1","def get_ports(self) -> tuple:\n raise NotImplementedError","def message_ports_out(self):\n return _spacegrant_swig.hdlc_deframer_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.udp_debug_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_message_ports_out(self)","def get_ports():\r\n ports = serial.tools.list_ports.comports()\r\n return ports","def port_list(self):\n return self._port_list","def _ports(self):\n try:\n return self._graph.node[self.node_id][\"_ports\"]\n except KeyError:\n log.debug(\"No interfaces initialised for %s\" % self)\n return","def get_port_list(self):\r\n self.ports = Manager().dict()\r\n self.value = Manager().dict()\r\n self.sensors = dict()\r\n for p in self.device.ports['input']:\r\n if p.enabled:\r\n self.ports[p.number] = p\r\n self.value[p.number] = 'Connexion à la carte'\r\n self.sensors[p.number] = Sensor.get(p._type)","def message_ports_out(self):\n return _spacegrant_swig.hdlc_framer_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.binary_sink_sptr_message_ports_out(self)","def get_ports(self) -> tuple:\n return self._current_dev_manager.get_ports()","def get_all_node_outputs(node: Node):\n return [port.node for port in get_node_output_ports(node)]","def output_ports(self):\n return {\n 'dialog_history': NeuralType(\n axes=(AxisType(kind=AxisKind.Batch, is_list=True), AxisType(kind=AxisKind.Time, is_list=True),),\n elements_type=AgentUtterance(),\n ),\n }","def list_ports(self):\n return self.ironic_client.port.list()","def message_ports_out(self):\n return _spacegrant_swig.G3RUH_descramble_sptr_message_ports_out(self)","def list_ports(state):\n\tstate.report()","def message_ports_out(self):\n return _spacegrant_swig.message_debug_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_message_ports_out(self)","def get_ports(self):\n return self._ports","def exposed_ports(self) -> list[\"Port\"]:\n _args: list[Arg] = []\n _ctx = self._select(\"exposedPorts\", _args)\n _ctx = Port(_ctx)._select_multiple(\n _description=\"description\",\n _port=\"port\",\n _protocol=\"protocol\",\n )\n return _ctx.execute_sync(list[Port])","def message_ports_out(self):\n return _uhd_swig.usrp_source_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.ax25_pdu_packer_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.general_burster_2_sptr_message_ports_out(self)","def message_ports_out(self):\n return _uhd_swig.usrp_sink_sptr_message_ports_out(self)","def message_ports_out(self):\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)","def _GetPorts(self):\n ports = []\n for start, end in self.term.destination_port:\n if start == end:\n ports.append(str(start))\n else:\n ports.append('%d-%d' % (start, end))\n return ports","def ports(self):\r\n # check connected to chip\r\n if not self._core.is_connected():\r\n raise ka_exceptions.NotConnectedError()\r\n\r\n # check symbols are loaded\r\n self._core.sym.assert_have_symbols()\r\n\r\n # get the symbols we need\r\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\r\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\r\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\r\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\r\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\r\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\r\n\r\n def read_dm(addr):\r\n return self._core.dm[addr]\r\n\r\n # get the read and write offset\r\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n read_offset = map(read_dm, read_offset_addr)\r\n write_offset = map(read_dm, write_offset_addr)\r\n\r\n # get the read and write limit\r\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\r\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\r\n read_limit = map(read_dm, read_limit_addr)\r\n write_limit = map(read_dm, write_limit_addr)\r\n\r\n # get the port size\r\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\r\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\r\n # calculate size mask (size-1) for non-zero sizes\r\n read_mask = map(lambda s: s - (s>0), read_size)\r\n write_mask = map(lambda s: s - (s>0), write_size)\r\n\r\n # calculate data/space in port\r\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\r\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\r\n\r\n # read port configs\r\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\r\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\r\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n\r\n # extract data size (in octets) from config\r\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\r\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\r\n\r\n # decode configs into strings\r\n read_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"No Sign Ext\" if (c & 0x8) else \"Sign Ext\" ), \\\r\n read_conf, read_data_size)\r\n write_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"Saturate\" if (c & 0x8) else \"No Saturate\"), \\\r\n write_conf, write_space_size)\r\n\r\n # print information\r\n print \"Read ports:\\n Port Status Offset Address Size(Bytes) Data Config\"\r\n for i in range(len(read_offset_addr)):\r\n if read_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i\r\n\r\n print \"Write ports:\\n Port Status Offset Address Size(Bytes) Space Config\"\r\n for i in range(len(write_offset_addr)):\r\n if write_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i","def get_ports(cls):\n return cls._open_ports.copy()","def serial_ports():\r\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))","def definitions(self) -> Dict[str, GraphOutput]:\n # Get the right output dictionary.\n d = self._manual_outputs if len(self._manual_outputs) > 0 else self._default_outputs\n\n # Extract port definitions (Neural Types) and return an immutable dictionary,\n # so the user won't be able to modify its content by an accident!\n return frozendict({k: v.ntype for k, v in d.items()})","def get_outputs(self):\n return [x[1] for x in self.io_mapping]","def get_ports_list() -> List[str]:\n return [comport.device for comport in serial.tools.list_ports.comports()]","def list_ports():\n print '\\nHere is the list of available ports on this machine:'\n # lp.comports returns a list of (port, description, hardware ID) tuples\n iterator = sorted(lp.comports())\n for port, desc, hwid in iterator:\n print port\n exit()","def message_ports_out(self):\n return _spacegrant_swig.DeNRZI_sptr_message_ports_out(self)","def enumerate_midi_devices(self):\n\n ports = self.midiout.get_ports()\n\n return ports","def get_target_ports(self):\n return self.targets","def message_ports_out(self):\n return _spacegrant_swig.NRZI_sptr_message_ports_out(self)","def ports(self): # type: () -> t.Dict[str, t.List[t.Dict[str, str]]]\n return self.network_settings['Ports']","def raw_interfaces(self):\n return self._ports","def get_all_port(self, conf, dpid):\n\t\tpass","def resolve(self):\n # Find defines for all ports\n for port_name, port in self.ports.items():\n if not isinstance(port, ElemExportPort):\n print('hha')\n for k, p in port.items():\n name, bit_range = k\n if p:\n continue\n not_find = True\n for io_list in self.all_io.values():\n if name in io_list:\n port[k] = io_list[name]\n not_find = False\n break\n if not_find:\n raise VlogSyntaxError('A port defined in port list of module is NOT defined as input/output/inout')","def getListOfPorts(self):\n return _libsbml.CompModelPlugin_getListOfPorts(self)","def message_ports_out(self):\n return _TestA_swig.my_qpsk_demod_cb_sptr_message_ports_out(self)","def list_port(self):\n _url = \"http://\" + self.host_ip + \":9696/v2.0/ports.json\"\n _headers = {'Content-type': 'application/json',\n 'x-auth-token': self.project_info[\"token_project\"]}\n _body = None\n\n response = self.request(\"GET\", _url, _headers, _body)\n\n if response is None:\n LOG_OBJ.error(\"No response from Server, while listing ports.\")\n return response\n\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\"Get port list Failed with status %s\"\n % response.status)\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"Port List : %s \" % output)\n return output[\"ports\"]","def getViewPorts(self):\n return self._viewPorts","def _generate_expose_services(self):\n ports = []\n for p in self.image['ports']:\n if p.get('expose', True):\n\n r = \"{}/{}\".format(p['value'], p.get('protocol', 'tcp'))\n\n if 'service' in p:\n r += \":{}\".format(p['service'])\n ports.append(r)\n else:\n # attempt to supply a service name by looking up the socket number\n try:\n service = socket.getservbyport(p['value'], p.get('protocol','tcp'))\n r += \":{}\".format(service)\n ports.append(r)\n\n except OSError: # py3\n pass\n except socket.error: # py2\n pass\n\n return \",\".join(ports)","def message_ports_out(self):\n return _TestA_swig.cleanslate_sptr_message_ports_out(self)","def read_all_rom_ports(self):\n return self.ROM_PORT","def display_port(self):\n ports=os.popen(\"sudo netstat -ntlp\").read().strip().splitlines()[2:]\n for port in ports:\n split=re.split('[\\s]+',port)\n self.portDic[\"Protcol\"]=split[0]\n self.portDic[\"Receive Q\"]=split[1]\n self.portDic[\"Send Q\"]=split[2]\n split_port=split[3].split(\":\")\n if split_port[1]==\"\":\n self.portDic[\"port\"]=\"No Port\" \n else:\n self.portDic[\"port\"]=split_port[1]\n self.portDic[\"Foreign Address\"]=split[4]\n self.portDic[\"State\"]=split[5]\n split_ID=split[6].split(\"/\")\n self.portDic[\"PID\"]=split_ID[0]\n self.portDic[\"Programme Name\"]=split_ID[1]\n self.portList.append(self.portDic.copy())\n return self.portList","def all_ports(self, **kwargs) -> t.Any:\n\n return tools.all_ports(**kwargs)","def ports(self):\n return self.attrs.get('NetworkSettings', {}).get('Ports', {})","def trafficOutboundPorts(self):\n #\n # TODO: Reimplement this if possible\n #\n return client.trafficOutboundPorts(self)","def serial_ports(self):\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def serial_ports(self):\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def getInputPortsInfo(self):\n return [(gport.parentItem().module, gport.port, gport.controller.get_connections_to(gport.controller.current_pipeline, [gport.parentItem().module.id], gport.port.name), (gport.parentItem().boundingRect().right()-gport.parentItem().boundingRect().left())/2) for gport in self.pipelineView.getSelectedInputPorts()]","def get_outputs(self):\n raise NotImplementedError","def determine_ports():\n ports = [config('admin-port'), config('service-port')]\n return list(set(ports))","def output_definitions(self) -> models.QuerySet:\n return self.output_specification.output_definitions","def outputs(self):\n\n outputs = []\n for arg in self.arguments:\n if arg.OUT:\n outputs.append(arg)\n\n return outputs","def _out_connections(self, g, tick):\n # outputs could be connected to many different input ports - this is not yet covered\n out_connections=[]\n output_map = {}\n # get the out connections of the given task\n for source,dest in g.get_out_connections(tick):\n if source.port not in output_map.keys():\n output_map[source.port]=[]\n output_map[source.port].append(dest)\n for source,dest in self.body_graph.get_in_connections(graph.FINAL_TICK):\n out_source=graph.Endpoint(source.tick << tick, source.port)\n portname=dest.port\n for out_dest in output_map[portname]:\n out_connections.append((out_source, out_dest))\n return out_connections","def port_out(self) -> int:\n return self.proto.port_out","def outputs(self):\r\n return self._outputs","def message_ports_out(self) -> \"pmt::pmt_t\":\n return _beamforming_swig.doaesprit_sptr_message_ports_out(self)","def message_ports_out(self) -> \"pmt::pmt_t\":\n return _beamforming_swig.beamformer_sptr_message_ports_out(self)","def output_fields(self):\r\n if not len(self.inputs) == 1:\r\n raise ValueError(\"Can not get default list of output fields: node has more than one input\"\r\n \" or no input is provided. Subclasses should override this method\")\r\n\r\n if not self.input.fields:\r\n raise ValueError(\"Can not get default list of output fields: input pipe fields are not \"\r\n \"initialized\")\r\n\r\n return self.input.fields","def outputs(self):\n return self.outputs","def get_outputs(self, flatten=False):\n ret = [x[1] for x in self.io_mapping]\n if flatten: return sum(ret,[])\n else: return ret","def _list_outputs(self):\n \n outputs = self._outputs().get()\n return outputs","def list_available_ports():\n ports = [u\"COM%s\" % (i + 1) for i in range(16)]\n results = []\n\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n results.append(port)\n print(u\"Find {0} device.\".format(port))\n except (OSError, serial.SerialException):\n pass\n\n return results","def get_output_descriptions(self):\n raise NotImplementedError","def message_ports_out(self) -> \"pmt::pmt_t\":\n return _beamforming_swig.phasedarray_sptr_message_ports_out(self)","def get_node_output(node: Node, out_port: int):\n consumers = []\n for dst_node in node.out_port(out_port).get_destinations():\n consumers.append(dst_node.node)\n return consumers","def enumerate_serial_devices(self):\n\n ports = list(list_ports.comports())\n\n return ports","def message_ports_in(self):\n return _spacegrant_swig.binary_sink_sptr_message_ports_in(self)","def message_ports_out(self):\n return _add_vector_swig.add_vector_2_cpp_sptr_message_ports_out(self)","def outputs(self):\n return self._outputs","def outputs(self):\n return self._outputs","def get_node_input_ports(node: Node):\n sources_ports = [parent.get_source() for parent in node.in_ports().values()]\n return [port for port in sources_ports if port is not None]","def getPortList(self):\n return [(portDetail[1], \"In Use\" in str(portDetail[2]) and int(1) or int(0), portDetail[2], portDetail[0]) for portDetail in self.portLines]","def message_ports_in(self):\n return _spacegrant_swig.udp_debug_sptr_message_ports_in(self)","def serial_ports():\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def message_ports_in(self):\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_message_ports_in(self)","def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]]]:\n return pulumi.get(self, \"ports\")","def OutputPort(*args, **kw):\n return Port.make_shared(OutputPortInterface(*args, **kw))","def read_all_ram_ports(self):\n return self.RAM_PORT","def look_for_available_ports():\n available_ports = glob.glob('/dev/ttyACM*')\n print(\"Available porst: \")\n print(available_ports)\n\n return available_ports","def serial_ports():\n if sys.platform.startswith('win'):\n result = []\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n result.append('COM' + str(i + 1))\n except serial.SerialException:\n pass\n return result\n\n elif sys.platform.startswith('linux'):\n return glob.glob('/dev/rf*')\n\n elif sys.platform.startswith('darwin'):\n return glob.glob('/dev/tty.*')","def get_vulnerable_ports(self):\n self.__get_vulnerable_ports(modules.__path__[0])\n return self.__vulnerable_ports","def input_ports(self):\n return {\n 'sys_uttr': NeuralType(\n axes=[AxisType(kind=AxisKind.Batch, is_list=True)], elements_type=SystemUtterance()\n ),\n 'dialog_history': NeuralType(\n axes=(AxisType(kind=AxisKind.Batch, is_list=True), AxisType(kind=AxisKind.Time, is_list=True),),\n elements_type=AgentUtterance(),\n ),\n }","def _list_modi_ports() -> List[ListPortInfo]:\n def __is_modi_port(port):\n return (\n port.manufacturer == \"LUXROBO\"\n or port.product == \"MODI Network Module\"\n or port.description == \"MODI Network Module\"\n or (port.vid == 12254 and port.pid == 2))\n\n return [port for port in stl.comports() if __is_modi_port(port)]","def get_outputs(self):\n return self.outputs","def named_ports(self) -> pulumi.Output[Optional[List['outputs.RegionInstanceGroupManagerNamedPort']]]:\n return pulumi.get(self, \"named_ports\")","def get_group_out_ports(self, dp, dstip):\n pass","def message_ports_in(self):\n return _spacegrant_swig.hdlc_deframer_sptr_message_ports_in(self)","def serialize(self) -> Dict[str, Any]:\n serialized_outputs = {\"mappings\": []}\n\n # Get the right output dictionary.\n if len(self._manual_outputs) > 0:\n serialized_outputs[\"type\"] = \"manual\"\n d = self._manual_outputs\n else:\n serialized_outputs[\"type\"] = \"default\"\n d = self._default_outputs\n\n # Iterate through \"bindings\" (GraphOutputs).\n for key, binding in d.items():\n # Serialize: step.module.port -> output | ntype.\n smp = binding.producer_step_module_port\n source = str(smp.step_number) + \".\" + smp.module_name + \".\" + smp.port_name\n # Get type.\n ntype_str = str(binding.ntype)\n # Serialize!\n serialized_outputs[\"mappings\"].append(source + \"->\" + key + \" | \" + ntype_str)\n # Return the result.\n return serialized_outputs","def output_node(self, port: int):\n return self._output_nodes_map[port]"],"string":"[\n \"def getOutputPortsInfo(self):\\n return [(gport.parentItem().module, gport.port, gport.controller.get_connections_from(gport.controller.current_pipeline, [gport.parentItem().module.id], gport.port.name), (gport.parentItem().boundingRect().right()-gport.parentItem().boundingRect().left())/2) for gport in self.pipelineView.getSelectedOutputPorts()]\",\n \"def get_node_output_ports(node: Node):\\n consumers = []\\n for port in node.out_ports().values():\\n for dst_port in port.get_destinations():\\n consumers.append(dst_port)\\n return consumers\",\n \"def output_ports(self):\\n return {\\n 'audio_signal': NeuralType(('B', 'T'), AudioSignal(freq=self._sample_rate)),\\n 'a_sig_length': NeuralType(tuple('B'), LengthsType()),\\n 'label': NeuralType(tuple('B'), LabelsType()),\\n 'label_length': NeuralType(tuple('B'), LengthsType()),\\n }\",\n \"def get_number_of_output_ports(self):\\n return 1\",\n \"def get_ports(self) -> tuple:\\n raise NotImplementedError\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.udp_debug_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_message_ports_out(self)\",\n \"def get_ports():\\r\\n ports = serial.tools.list_ports.comports()\\r\\n return ports\",\n \"def port_list(self):\\n return self._port_list\",\n \"def _ports(self):\\n try:\\n return self._graph.node[self.node_id][\\\"_ports\\\"]\\n except KeyError:\\n log.debug(\\\"No interfaces initialised for %s\\\" % self)\\n return\",\n \"def get_port_list(self):\\r\\n self.ports = Manager().dict()\\r\\n self.value = Manager().dict()\\r\\n self.sensors = dict()\\r\\n for p in self.device.ports['input']:\\r\\n if p.enabled:\\r\\n self.ports[p.number] = p\\r\\n self.value[p.number] = 'Connexion à la carte'\\r\\n self.sensors[p.number] = Sensor.get(p._type)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.hdlc_framer_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.binary_sink_sptr_message_ports_out(self)\",\n \"def get_ports(self) -> tuple:\\n return self._current_dev_manager.get_ports()\",\n \"def get_all_node_outputs(node: Node):\\n return [port.node for port in get_node_output_ports(node)]\",\n \"def output_ports(self):\\n return {\\n 'dialog_history': NeuralType(\\n axes=(AxisType(kind=AxisKind.Batch, is_list=True), AxisType(kind=AxisKind.Time, is_list=True),),\\n elements_type=AgentUtterance(),\\n ),\\n }\",\n \"def list_ports(self):\\n return self.ironic_client.port.list()\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.G3RUH_descramble_sptr_message_ports_out(self)\",\n \"def list_ports(state):\\n\\tstate.report()\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.message_debug_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_message_ports_out(self)\",\n \"def get_ports(self):\\n return self._ports\",\n \"def exposed_ports(self) -> list[\\\"Port\\\"]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"exposedPorts\\\", _args)\\n _ctx = Port(_ctx)._select_multiple(\\n _description=\\\"description\\\",\\n _port=\\\"port\\\",\\n _protocol=\\\"protocol\\\",\\n )\\n return _ctx.execute_sync(list[Port])\",\n \"def message_ports_out(self):\\n return _uhd_swig.usrp_source_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.ax25_pdu_packer_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.general_burster_2_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _uhd_swig.usrp_sink_sptr_message_ports_out(self)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)\",\n \"def _GetPorts(self):\\n ports = []\\n for start, end in self.term.destination_port:\\n if start == end:\\n ports.append(str(start))\\n else:\\n ports.append('%d-%d' % (start, end))\\n return ports\",\n \"def ports(self):\\r\\n # check connected to chip\\r\\n if not self._core.is_connected():\\r\\n raise ka_exceptions.NotConnectedError()\\r\\n\\r\\n # check symbols are loaded\\r\\n self._core.sym.assert_have_symbols()\\r\\n\\r\\n # get the symbols we need\\r\\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\\r\\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\\r\\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\\r\\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\\r\\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\\r\\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\\r\\n\\r\\n def read_dm(addr):\\r\\n return self._core.dm[addr]\\r\\n\\r\\n # get the read and write offset\\r\\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n read_offset = map(read_dm, read_offset_addr)\\r\\n write_offset = map(read_dm, write_offset_addr)\\r\\n\\r\\n # get the read and write limit\\r\\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\\r\\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\\r\\n read_limit = map(read_dm, read_limit_addr)\\r\\n write_limit = map(read_dm, write_limit_addr)\\r\\n\\r\\n # get the port size\\r\\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\\r\\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\\r\\n # calculate size mask (size-1) for non-zero sizes\\r\\n read_mask = map(lambda s: s - (s>0), read_size)\\r\\n write_mask = map(lambda s: s - (s>0), write_size)\\r\\n\\r\\n # calculate data/space in port\\r\\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\\r\\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\\r\\n\\r\\n # read port configs\\r\\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\\r\\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\\r\\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n\\r\\n # extract data size (in octets) from config\\r\\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\\r\\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\\r\\n\\r\\n # decode configs into strings\\r\\n read_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"No Sign Ext\\\" if (c & 0x8) else \\\"Sign Ext\\\" ), \\\\\\r\\n read_conf, read_data_size)\\r\\n write_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"Saturate\\\" if (c & 0x8) else \\\"No Saturate\\\"), \\\\\\r\\n write_conf, write_space_size)\\r\\n\\r\\n # print information\\r\\n print \\\"Read ports:\\\\n Port Status Offset Address Size(Bytes) Data Config\\\"\\r\\n for i in range(len(read_offset_addr)):\\r\\n if read_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\\r\\n\\r\\n print \\\"Write ports:\\\\n Port Status Offset Address Size(Bytes) Space Config\\\"\\r\\n for i in range(len(write_offset_addr)):\\r\\n if write_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\",\n \"def get_ports(cls):\\n return cls._open_ports.copy()\",\n \"def serial_ports():\\r\\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))\",\n \"def definitions(self) -> Dict[str, GraphOutput]:\\n # Get the right output dictionary.\\n d = self._manual_outputs if len(self._manual_outputs) > 0 else self._default_outputs\\n\\n # Extract port definitions (Neural Types) and return an immutable dictionary,\\n # so the user won't be able to modify its content by an accident!\\n return frozendict({k: v.ntype for k, v in d.items()})\",\n \"def get_outputs(self):\\n return [x[1] for x in self.io_mapping]\",\n \"def get_ports_list() -> List[str]:\\n return [comport.device for comport in serial.tools.list_ports.comports()]\",\n \"def list_ports():\\n print '\\\\nHere is the list of available ports on this machine:'\\n # lp.comports returns a list of (port, description, hardware ID) tuples\\n iterator = sorted(lp.comports())\\n for port, desc, hwid in iterator:\\n print port\\n exit()\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.DeNRZI_sptr_message_ports_out(self)\",\n \"def enumerate_midi_devices(self):\\n\\n ports = self.midiout.get_ports()\\n\\n return ports\",\n \"def get_target_ports(self):\\n return self.targets\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.NRZI_sptr_message_ports_out(self)\",\n \"def ports(self): # type: () -> t.Dict[str, t.List[t.Dict[str, str]]]\\n return self.network_settings['Ports']\",\n \"def raw_interfaces(self):\\n return self._ports\",\n \"def get_all_port(self, conf, dpid):\\n\\t\\tpass\",\n \"def resolve(self):\\n # Find defines for all ports\\n for port_name, port in self.ports.items():\\n if not isinstance(port, ElemExportPort):\\n print('hha')\\n for k, p in port.items():\\n name, bit_range = k\\n if p:\\n continue\\n not_find = True\\n for io_list in self.all_io.values():\\n if name in io_list:\\n port[k] = io_list[name]\\n not_find = False\\n break\\n if not_find:\\n raise VlogSyntaxError('A port defined in port list of module is NOT defined as input/output/inout')\",\n \"def getListOfPorts(self):\\n return _libsbml.CompModelPlugin_getListOfPorts(self)\",\n \"def message_ports_out(self):\\n return _TestA_swig.my_qpsk_demod_cb_sptr_message_ports_out(self)\",\n \"def list_port(self):\\n _url = \\\"http://\\\" + self.host_ip + \\\":9696/v2.0/ports.json\\\"\\n _headers = {'Content-type': 'application/json',\\n 'x-auth-token': self.project_info[\\\"token_project\\\"]}\\n _body = None\\n\\n response = self.request(\\\"GET\\\", _url, _headers, _body)\\n\\n if response is None:\\n LOG_OBJ.error(\\\"No response from Server, while listing ports.\\\")\\n return response\\n\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\\"Get port list Failed with status %s\\\"\\n % response.status)\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"Port List : %s \\\" % output)\\n return output[\\\"ports\\\"]\",\n \"def getViewPorts(self):\\n return self._viewPorts\",\n \"def _generate_expose_services(self):\\n ports = []\\n for p in self.image['ports']:\\n if p.get('expose', True):\\n\\n r = \\\"{}/{}\\\".format(p['value'], p.get('protocol', 'tcp'))\\n\\n if 'service' in p:\\n r += \\\":{}\\\".format(p['service'])\\n ports.append(r)\\n else:\\n # attempt to supply a service name by looking up the socket number\\n try:\\n service = socket.getservbyport(p['value'], p.get('protocol','tcp'))\\n r += \\\":{}\\\".format(service)\\n ports.append(r)\\n\\n except OSError: # py3\\n pass\\n except socket.error: # py2\\n pass\\n\\n return \\\",\\\".join(ports)\",\n \"def message_ports_out(self):\\n return _TestA_swig.cleanslate_sptr_message_ports_out(self)\",\n \"def read_all_rom_ports(self):\\n return self.ROM_PORT\",\n \"def display_port(self):\\n ports=os.popen(\\\"sudo netstat -ntlp\\\").read().strip().splitlines()[2:]\\n for port in ports:\\n split=re.split('[\\\\s]+',port)\\n self.portDic[\\\"Protcol\\\"]=split[0]\\n self.portDic[\\\"Receive Q\\\"]=split[1]\\n self.portDic[\\\"Send Q\\\"]=split[2]\\n split_port=split[3].split(\\\":\\\")\\n if split_port[1]==\\\"\\\":\\n self.portDic[\\\"port\\\"]=\\\"No Port\\\" \\n else:\\n self.portDic[\\\"port\\\"]=split_port[1]\\n self.portDic[\\\"Foreign Address\\\"]=split[4]\\n self.portDic[\\\"State\\\"]=split[5]\\n split_ID=split[6].split(\\\"/\\\")\\n self.portDic[\\\"PID\\\"]=split_ID[0]\\n self.portDic[\\\"Programme Name\\\"]=split_ID[1]\\n self.portList.append(self.portDic.copy())\\n return self.portList\",\n \"def all_ports(self, **kwargs) -> t.Any:\\n\\n return tools.all_ports(**kwargs)\",\n \"def ports(self):\\n return self.attrs.get('NetworkSettings', {}).get('Ports', {})\",\n \"def trafficOutboundPorts(self):\\n #\\n # TODO: Reimplement this if possible\\n #\\n return client.trafficOutboundPorts(self)\",\n \"def serial_ports(self):\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def serial_ports(self):\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def getInputPortsInfo(self):\\n return [(gport.parentItem().module, gport.port, gport.controller.get_connections_to(gport.controller.current_pipeline, [gport.parentItem().module.id], gport.port.name), (gport.parentItem().boundingRect().right()-gport.parentItem().boundingRect().left())/2) for gport in self.pipelineView.getSelectedInputPorts()]\",\n \"def get_outputs(self):\\n raise NotImplementedError\",\n \"def determine_ports():\\n ports = [config('admin-port'), config('service-port')]\\n return list(set(ports))\",\n \"def output_definitions(self) -> models.QuerySet:\\n return self.output_specification.output_definitions\",\n \"def outputs(self):\\n\\n outputs = []\\n for arg in self.arguments:\\n if arg.OUT:\\n outputs.append(arg)\\n\\n return outputs\",\n \"def _out_connections(self, g, tick):\\n # outputs could be connected to many different input ports - this is not yet covered\\n out_connections=[]\\n output_map = {}\\n # get the out connections of the given task\\n for source,dest in g.get_out_connections(tick):\\n if source.port not in output_map.keys():\\n output_map[source.port]=[]\\n output_map[source.port].append(dest)\\n for source,dest in self.body_graph.get_in_connections(graph.FINAL_TICK):\\n out_source=graph.Endpoint(source.tick << tick, source.port)\\n portname=dest.port\\n for out_dest in output_map[portname]:\\n out_connections.append((out_source, out_dest))\\n return out_connections\",\n \"def port_out(self) -> int:\\n return self.proto.port_out\",\n \"def outputs(self):\\r\\n return self._outputs\",\n \"def message_ports_out(self) -> \\\"pmt::pmt_t\\\":\\n return _beamforming_swig.doaesprit_sptr_message_ports_out(self)\",\n \"def message_ports_out(self) -> \\\"pmt::pmt_t\\\":\\n return _beamforming_swig.beamformer_sptr_message_ports_out(self)\",\n \"def output_fields(self):\\r\\n if not len(self.inputs) == 1:\\r\\n raise ValueError(\\\"Can not get default list of output fields: node has more than one input\\\"\\r\\n \\\" or no input is provided. Subclasses should override this method\\\")\\r\\n\\r\\n if not self.input.fields:\\r\\n raise ValueError(\\\"Can not get default list of output fields: input pipe fields are not \\\"\\r\\n \\\"initialized\\\")\\r\\n\\r\\n return self.input.fields\",\n \"def outputs(self):\\n return self.outputs\",\n \"def get_outputs(self, flatten=False):\\n ret = [x[1] for x in self.io_mapping]\\n if flatten: return sum(ret,[])\\n else: return ret\",\n \"def _list_outputs(self):\\n \\n outputs = self._outputs().get()\\n return outputs\",\n \"def list_available_ports():\\n ports = [u\\\"COM%s\\\" % (i + 1) for i in range(16)]\\n results = []\\n\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n results.append(port)\\n print(u\\\"Find {0} device.\\\".format(port))\\n except (OSError, serial.SerialException):\\n pass\\n\\n return results\",\n \"def get_output_descriptions(self):\\n raise NotImplementedError\",\n \"def message_ports_out(self) -> \\\"pmt::pmt_t\\\":\\n return _beamforming_swig.phasedarray_sptr_message_ports_out(self)\",\n \"def get_node_output(node: Node, out_port: int):\\n consumers = []\\n for dst_node in node.out_port(out_port).get_destinations():\\n consumers.append(dst_node.node)\\n return consumers\",\n \"def enumerate_serial_devices(self):\\n\\n ports = list(list_ports.comports())\\n\\n return ports\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.binary_sink_sptr_message_ports_in(self)\",\n \"def message_ports_out(self):\\n return _add_vector_swig.add_vector_2_cpp_sptr_message_ports_out(self)\",\n \"def outputs(self):\\n return self._outputs\",\n \"def outputs(self):\\n return self._outputs\",\n \"def get_node_input_ports(node: Node):\\n sources_ports = [parent.get_source() for parent in node.in_ports().values()]\\n return [port for port in sources_ports if port is not None]\",\n \"def getPortList(self):\\n return [(portDetail[1], \\\"In Use\\\" in str(portDetail[2]) and int(1) or int(0), portDetail[2], portDetail[0]) for portDetail in self.portLines]\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.udp_debug_sptr_message_ports_in(self)\",\n \"def serial_ports():\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_message_ports_in(self)\",\n \"def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]]]:\\n return pulumi.get(self, \\\"ports\\\")\",\n \"def OutputPort(*args, **kw):\\n return Port.make_shared(OutputPortInterface(*args, **kw))\",\n \"def read_all_ram_ports(self):\\n return self.RAM_PORT\",\n \"def look_for_available_ports():\\n available_ports = glob.glob('/dev/ttyACM*')\\n print(\\\"Available porst: \\\")\\n print(available_ports)\\n\\n return available_ports\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n result = []\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n result.append('COM' + str(i + 1))\\n except serial.SerialException:\\n pass\\n return result\\n\\n elif sys.platform.startswith('linux'):\\n return glob.glob('/dev/rf*')\\n\\n elif sys.platform.startswith('darwin'):\\n return glob.glob('/dev/tty.*')\",\n \"def get_vulnerable_ports(self):\\n self.__get_vulnerable_ports(modules.__path__[0])\\n return self.__vulnerable_ports\",\n \"def input_ports(self):\\n return {\\n 'sys_uttr': NeuralType(\\n axes=[AxisType(kind=AxisKind.Batch, is_list=True)], elements_type=SystemUtterance()\\n ),\\n 'dialog_history': NeuralType(\\n axes=(AxisType(kind=AxisKind.Batch, is_list=True), AxisType(kind=AxisKind.Time, is_list=True),),\\n elements_type=AgentUtterance(),\\n ),\\n }\",\n \"def _list_modi_ports() -> List[ListPortInfo]:\\n def __is_modi_port(port):\\n return (\\n port.manufacturer == \\\"LUXROBO\\\"\\n or port.product == \\\"MODI Network Module\\\"\\n or port.description == \\\"MODI Network Module\\\"\\n or (port.vid == 12254 and port.pid == 2))\\n\\n return [port for port in stl.comports() if __is_modi_port(port)]\",\n \"def get_outputs(self):\\n return self.outputs\",\n \"def named_ports(self) -> pulumi.Output[Optional[List['outputs.RegionInstanceGroupManagerNamedPort']]]:\\n return pulumi.get(self, \\\"named_ports\\\")\",\n \"def get_group_out_ports(self, dp, dstip):\\n pass\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_message_ports_in(self)\",\n \"def serialize(self) -> Dict[str, Any]:\\n serialized_outputs = {\\\"mappings\\\": []}\\n\\n # Get the right output dictionary.\\n if len(self._manual_outputs) > 0:\\n serialized_outputs[\\\"type\\\"] = \\\"manual\\\"\\n d = self._manual_outputs\\n else:\\n serialized_outputs[\\\"type\\\"] = \\\"default\\\"\\n d = self._default_outputs\\n\\n # Iterate through \\\"bindings\\\" (GraphOutputs).\\n for key, binding in d.items():\\n # Serialize: step.module.port -> output | ntype.\\n smp = binding.producer_step_module_port\\n source = str(smp.step_number) + \\\".\\\" + smp.module_name + \\\".\\\" + smp.port_name\\n # Get type.\\n ntype_str = str(binding.ntype)\\n # Serialize!\\n serialized_outputs[\\\"mappings\\\"].append(source + \\\"->\\\" + key + \\\" | \\\" + ntype_str)\\n # Return the result.\\n return serialized_outputs\",\n \"def output_node(self, port: int):\\n return self._output_nodes_map[port]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7231068","0.7108193","0.7017519","0.698227","0.68667525","0.6826521","0.6819943","0.67742664","0.6712915","0.6690715","0.66691464","0.6668941","0.66622776","0.66509235","0.6629479","0.66278684","0.6618243","0.6612363","0.6601604","0.6582517","0.65754664","0.6561065","0.6556166","0.6540711","0.65385544","0.6520195","0.6475474","0.64606667","0.6451759","0.6441488","0.6429259","0.642597","0.6422558","0.6411996","0.64073044","0.6400737","0.6397496","0.63965285","0.6385203","0.6383235","0.637431","0.635967","0.63261485","0.6312596","0.62848747","0.62762415","0.6259129","0.6226155","0.61605966","0.6153221","0.6141573","0.6107296","0.6104552","0.607051","0.6063836","0.60486734","0.603739","0.6036817","0.6036817","0.60050356","0.5922777","0.59012824","0.5895449","0.588001","0.5856447","0.5852306","0.584482","0.58402455","0.5838579","0.5836416","0.5805866","0.57874835","0.5784171","0.5782383","0.57756495","0.5769555","0.57495975","0.5747719","0.5743746","0.573979","0.57395357","0.57395357","0.57341546","0.57294184","0.57118714","0.57068217","0.57034284","0.5690668","0.56885165","0.56868565","0.5681813","0.56746185","0.56738317","0.5659519","0.56551486","0.5654497","0.5650887","0.56499815","0.56418353","0.5637193","0.56338584"],"string":"[\n \"0.7231068\",\n \"0.7108193\",\n \"0.7017519\",\n \"0.698227\",\n \"0.68667525\",\n \"0.6826521\",\n \"0.6819943\",\n \"0.67742664\",\n \"0.6712915\",\n \"0.6690715\",\n \"0.66691464\",\n \"0.6668941\",\n \"0.66622776\",\n \"0.66509235\",\n \"0.6629479\",\n \"0.66278684\",\n \"0.6618243\",\n \"0.6612363\",\n \"0.6601604\",\n \"0.6582517\",\n \"0.65754664\",\n \"0.6561065\",\n \"0.6556166\",\n \"0.6540711\",\n \"0.65385544\",\n \"0.6520195\",\n \"0.6475474\",\n \"0.64606667\",\n \"0.6451759\",\n \"0.6441488\",\n \"0.6429259\",\n \"0.642597\",\n \"0.6422558\",\n \"0.6411996\",\n \"0.64073044\",\n \"0.6400737\",\n \"0.6397496\",\n \"0.63965285\",\n \"0.6385203\",\n \"0.6383235\",\n \"0.637431\",\n \"0.635967\",\n \"0.63261485\",\n \"0.6312596\",\n \"0.62848747\",\n \"0.62762415\",\n \"0.6259129\",\n \"0.6226155\",\n \"0.61605966\",\n \"0.6153221\",\n \"0.6141573\",\n \"0.6107296\",\n \"0.6104552\",\n \"0.607051\",\n \"0.6063836\",\n \"0.60486734\",\n \"0.603739\",\n \"0.6036817\",\n \"0.6036817\",\n \"0.60050356\",\n \"0.5922777\",\n \"0.59012824\",\n \"0.5895449\",\n \"0.588001\",\n \"0.5856447\",\n \"0.5852306\",\n \"0.584482\",\n \"0.58402455\",\n \"0.5838579\",\n \"0.5836416\",\n \"0.5805866\",\n \"0.57874835\",\n \"0.5784171\",\n \"0.5782383\",\n \"0.57756495\",\n \"0.5769555\",\n \"0.57495975\",\n \"0.5747719\",\n \"0.5743746\",\n \"0.573979\",\n \"0.57395357\",\n \"0.57395357\",\n \"0.57341546\",\n \"0.57294184\",\n \"0.57118714\",\n \"0.57068217\",\n \"0.57034284\",\n \"0.5690668\",\n \"0.56885165\",\n \"0.56868565\",\n \"0.5681813\",\n \"0.56746185\",\n \"0.56738317\",\n \"0.5659519\",\n \"0.56551486\",\n \"0.5654497\",\n \"0.5650887\",\n \"0.56499815\",\n \"0.56418353\",\n \"0.5637193\",\n \"0.56338584\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95593,"cells":{"query":{"kind":"string","value":"Loads a data file into a list of `InputBatch`s."},"document":{"kind":"string","value":"def convert_examples_to_features(\n self,\n examples: List[str],\n label_list: List[int],\n max_seq_length: int,\n tokenizer: TokenizerSpec,\n output_mode: str,\n bos_token: str = None,\n eos_token: str = '[SEP]',\n pad_token: str = '[PAD]',\n cls_token: str = '[CLS]',\n sep_token_extra: str = None,\n cls_token_at_end: bool = False,\n cls_token_segment_id: int = 0,\n pad_token_segment_id: int = 0,\n pad_on_left: bool = False,\n mask_padding_with_zero: bool = True,\n sequence_a_segment_id: int = 0,\n sequence_b_segment_id: int = 1,\n ):\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for ex_index, example in enumerate(examples):\n if example.label == \"-\": # skip examples without a consensus label (e.g. in SNLI data set)\n continue\n if ex_index % 10000 == 0:\n logging.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\n\n tokens_a = tokenizer.text_to_tokens(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.text_to_tokens(example.text_b)\n\n special_tokens_count = 2 if eos_token else 0\n special_tokens_count += 1 if sep_token_extra else 0\n special_tokens_count += 2 if bos_token else 0\n special_tokens_count += 1 if cls_token else 0\n self._truncate_seq_pair(tokens_a, tokens_b, max_seq_length - special_tokens_count)\n else:\n special_tokens_count = 1 if eos_token else 0\n special_tokens_count += 1 if sep_token_extra else 0\n special_tokens_count += 1 if bos_token else 0\n if len(tokens_a) > max_seq_length - special_tokens_count:\n tokens_a = tokens_a[: max_seq_length - special_tokens_count]\n # Add special tokens to sequence_a\n tokens = tokens_a\n if bos_token:\n tokens = [bos_token] + tokens\n if eos_token:\n tokens += [eos_token]\n segment_ids = [sequence_a_segment_id] * len(tokens)\n\n # Add sequence separator between sequences\n if tokens_b and sep_token_extra:\n tokens += [sep_token_extra]\n segment_ids += [sequence_a_segment_id]\n\n # Add special tokens to sequence_b\n if tokens_b:\n if bos_token:\n tokens += [bos_token]\n segment_ids += [sequence_b_segment_id]\n tokens += tokens_b\n segment_ids += [sequence_b_segment_id] * (len(tokens_b))\n if eos_token:\n tokens += [eos_token]\n segment_ids += [sequence_b_segment_id]\n\n # Add classification token - for BERT models\n if cls_token:\n if cls_token_at_end:\n tokens += [cls_token]\n segment_ids += [cls_token_segment_id]\n else:\n tokens = [cls_token] + tokens\n segment_ids = [cls_token_segment_id] + segment_ids\n input_ids = tokenizer.tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_seq_length - len(input_ids)\n pad_token_id = tokenizer.tokens_to_ids([pad_token])[0]\n if pad_on_left:\n input_ids = ([pad_token_id] * padding_length) + input_ids\n input_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask\n segment_ids = ([pad_token_segment_id] * padding_length) + segment_ids\n else:\n input_ids = input_ids + ([pad_token_id] * padding_length)\n input_mask = input_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n segment_ids = segment_ids + ([pad_token_segment_id] * padding_length)\n if len(input_ids) != max_seq_length:\n raise ValueError(\"input_ids must be of length max_seq_length\")\n if len(input_mask) != max_seq_length:\n raise ValueError(\"input_mask must be of length max_seq_length\")\n if len(segment_ids) != max_seq_length:\n raise ValueError(\"segment_ids must be of length max_seq_length\")\n if output_mode == \"classification\":\n label_id = label_map[example.label]\n elif output_mode == \"regression\":\n label_id = np.float32(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logging.info(\"*** Example ***\")\n logging.info(\"guid: %s\" % (example.guid))\n logging.info(\"tokens: %s\" % \" \".join(list(map(str, tokens))))\n logging.info(\"input_ids: %s\" % \" \".join(list(map(str, input_ids))))\n logging.info(\"input_mask: %s\" % \" \".join(list(map(str, input_mask))))\n logging.info(\"segment_ids: %s\" % \" \".join(list(map(str, segment_ids))))\n logging.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n features.append(\n InputFeatures(input_ids=input_ids, input_mask=input_mask, segment_ids=segment_ids, label_id=label_id)\n )\n return features"},"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 LoadBatch(filename):","def load_batch(fpath, label_key='labels'):\n f = open(fpath, 'rb')\n if sys.version_info < (3,):\n d = cPickle.load(f)\n else:\n d = cPickle.load(f, encoding='bytes')\n # decode utf8\n d_decoded = {}\n for k, v in d.items():\n d_decoded[k.decode('utf8')] = v\n d = d_decoded\n f.close()\n data = d['data']\n labels = d[label_key]\n\n data = data.reshape(data.shape[0], 3, 32, 32)\n return data, labels","def loadData(self, file):\n self.data = batchImport(file, self.ps)","def load_data():\r\n global labelNames\r\n print(\"Loading Data...\")\r\n\r\n fnpath = \"rawdata\\\\cifar-10-batches-py\"\r\n fnprefix = 'data_batch_'\r\n fnlblnames = 'batches.meta'\r\n fntstbatch = 'test_batch'\r\n\r\n labelNames = unpickle(path.join(fnpath, fnlblnames))\r\n label_names = []\r\n for label in labelNames['label_names']:\r\n label_names.append(\"\".join(map(chr, label)))\r\n labelNames['label_names'] = label_names\r\n\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\r\n for n in range(1, 6):\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))","def _load_input() -> List[List[int]]:\n filepath = os.path.join(os.getcwd(), os.path.dirname(__file__), INPUT_FILE)\n f = open(filepath, 'r')\n data = f.read()\n f.close()\n\n raw_input = data.strip().split('\\n')\n input = [list(ri) for ri in raw_input]\n return [[int(i) for i in line] for line in input]","def load_batch(batch_name):\n data_dict = unpickle('./datasets/cifar-10-batches-py/' + batch_name)\n X = data_dict[b'data'] / 255\n X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).reshape(10000, 3072).transpose(1,0)\n y = data_dict[b'labels']\n Y = make_one_hot(y)\n return X, Y, y","def load_batch(n):\r\n print ('Loadng one batch...')\r\n batchfilename = flist[n - 1] + '.pkl'\r\n if not os.path.exists(batchfilename):\r\n set_batch_data()\r\n with open(batchfilename, 'rb') as cifar_pickle:\r\n data = six.moves.cPickle.load(cifar_pickle)\r\n return data","def _load_batch_file(filename):\n # Load the pickled data-file.\n data = _unpickle(filename)\n # Get the raw images.\n raw_images = data[b'data']\n # Get the class-numbers for each image. Convert to numpy-array.\n cls = np.array(data[b'labels'])\n # Convert the images.\n images = _convert_images(raw_images)\n\n return images, cls","def split_and_load(batch, ctx_list):\n new_batch = []\n for i, data in enumerate(batch):\n if isinstance(data, (list, tuple)):\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\n else:\n new_data = [data.as_in_context(ctx_list[0])]\n new_batch.append(new_data)\n return new_batch","def loadInMemoryOneBatch(fileName,batchSize):\n\n inputFile = open(fileName)\n\n while True:\n objects = []\n allDone = False\n while True:\n line = inputFile.readline()\n if line:\n objects.append(line)\n if len(objects) == batchSize:\n break\n else:\n allDone = True\n break\n yield objects\n if allDone == True:\n break","def split_and_load(batch, ctx_list):\n num_ctx = len(ctx_list)\n new_batch = []\n for i, data in enumerate(batch):\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\n new_batch.append(new_data)\n return new_batch","def split_and_load(batch, ctx_list):\n num_ctx = len(ctx_list)\n new_batch = []\n for i, data in enumerate(batch):\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\n new_batch.append(new_data)\n return new_batch","def batch(data_path):\n train, _, _ = get_datasets(\n data_path=data_path,\n nb_nodes=7,\n task_type=\"classification\",\n nb_classes=2,\n split=None,\n k_fold=None,\n seed=1234,\n )\n for batch in torch.utils.data.DataLoader(\n train, shuffle=False, batch_size=25, drop_last=False\n ):\n return batch","def load_preprocess_training_batch(batch_id, batch_size):\n path, dataset = select_dataset(training = True)\n data = dataset_lib.get_data(batch_id, dataset=dataset, path=path)\n features = [np.array(x[1]) for x in data]\n labels = np.array([x[0] for x in data])\n\n # Return the training data in batches of size <batch_size> or less\n return batch_features_labels(features, labels, batch_size)","def load_all_data(self):\n layers, layers_fnames = [], []\n # TODO: add multiprocessing\n for i in range(len(self.infiles)):\n fname = self.infiles[i]\n self.logger.info(\n \"#Loading file: {} {}\".format(fname, \"(text file)\" if pathlib.Path(fname).suffix == \"\" else \"\"))\n\n # load text file\n data = load_data_text(file_path=fname, sample_names=self.sn, feature_names=self.fn, drop_features=self.df,\n drop_samples=self.ds)\n layers.append(data)\n layers_fnames.append(fname)\n\n return list(zip(layers_fnames, layers))","def _read_one_file(file_name, label_list):\n lines = tf.io.gfile.GFile(file_name, \"r\").readlines()\n examples = []\n label_id_map = {label: i for i, label in enumerate(label_list)}\n sentence_id = 0\n example = InputExample(sentence_id=0)\n for line in lines:\n line = line.strip(\"\\n\")\n if line:\n # The format is: <token>\\t<label> for train/dev set and <token> for test.\n items = line.split(\"\\t\")\n assert len(items) == 2 or len(items) == 1\n token = items[0].strip()\n\n # Assign a dummy label_id for test set\n label_id = label_id_map[items[1].strip()] if len(items) == 2 else 0\n example.add_word_and_label_id(token, label_id)\n else:\n # Empty line indicates a new sentence.\n if example.words:\n examples.append(example)\n sentence_id += 1\n example = InputExample(sentence_id=sentence_id)\n\n if example.words:\n examples.append(example)\n return examples","def load_batch(batch, feat_list, device='cpu'):\n batch_feat_list = []\n for hop_feat_list in feat_list:\n batch_feats = [feat[batch] for feat in hop_feat_list]\n batch_feat_list.append(batch_feats)\n\n batch_feat_list = [torch.stack(feat) for feat in batch_feat_list]\n batch_feats = torch.cat(batch_feat_list, dim=0)\n # if len(batch_feats.shape) == 2:\n # batch_feats = batch_feats.unsqueeze(1)\n\n return batch_feats.to(device)","def __init__(self, data_path):\r\n\t\tfile_names = ['data_batch_%d' % i for i in range(1,6)]\r\n\t\tfile_names.append('test_batch')\r\n\r\n\t\tX = []\r\n\t\ty = []\r\n\t\tfor file_name in file_names:\r\n\t\t\twith open(data_path + file_name) as fin:\r\n\t\t\t\tdata_dict = cPickle.load(fin)\r\n\t\t\tX.append(data_dict['data'].ravel())\r\n\t\t\ty = y + data_dict['labels']\r\n\r\n\t\tself.X = np.asarray(X).reshape(60000, 32*32*3)\r\n\t\tself.y = np.asarray(y)\r\n\r\n\t\tfin = open(data_path + 'batches.meta')\r\n\t\tself.LABEL_NAMES = cPickle.load(fin)['label_names']\r\n\t\tfin.close()","def load_training_data(list_files):\n training_data = []\n for tr_file in list_files:\n with open(os.path.join(\"data\", tr_file)) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n training_data.append(row[1])\n return training_data","def load_data():\n # Load and preprocess data\n sentences, labels = load_data_and_labels()\n sentences_padded = pad_sentences(sentences)\n vocabulary, vocabulary_inv = build_vocab(sentences_padded)\n x, y = build_input_data(sentences_padded, labels, vocabulary)\n return [x, y, vocabulary, vocabulary_inv]","def load_training(file_name, target_val, training_data, training_targets, \n elements):\n\n file = open(file_name, \"r\")\n\n # Iterate over file until empty line recieved\n while True:\n chunk = file.readline()\n\n if(chunk == ''):\n break\n\n ret = load_chunk(chunk, elements)\n\n training_targets.append(target_val)\n\n # Convert data to frequency domain using fft()\n training_data.append([i.real for i in fft(ret)])","def load_dataset(filepath):\n \n X = list()\n x = list()\n\n Y = list()\n y = list()\n \n for line in open(filepath):\n # blank lines separate sequences\n if len(line) <= 1:\n X.append(x)\n Y.append(y)\n\n x = list()\n y = list()\n else:\n a, b = line.strip().split('\\t')\n x.append(a)\n y.append(b)\n \n return X, Y","def load_input(input_name):\n with open(input_name) as input_file:\n input_list = list(map(int,input_file.readline().split(\",\")))\n return input_list","def load_dataset(self):\n # Get all the files in the directory\n file_list = self.get_file_list()\n\n # Concatenate the data corresponding to a list of files\n data = self.concatenate_file_data(file_list)\n\n # Shuffle the data and create the training and the validation datasets\n data = self.shuffle_data_dictionary(data)\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)","def load_preprocess_training_batch(batch_id, batch_size):\r\n filename = 'preprocess_batch_' + str(batch_id) + '.p'\r\n features, labels = pickle.load(open(filename, mode='rb'))\r\n\r\n # Return the training data in batches of size <batch_size> or less\r\n return batch_features_labels(features, labels, batch_size)","def load_preprocess_training_batch(batch_id, batch_size):\r\n filename = 'preprocess_batch_' + str(batch_id) + '.p'\r\n features, labels = pickle.load(open(filename, mode='rb'))\r\n# labels = np.argmax(labels,1)\r\n# num = len(labels)\r\n# arr = np.zeros((num, 1))\r\n# for i in range(num):\r\n# arr[i][0] = labels[i]\r\n# np.reshape(features,(2500,150528))\r\n# ind = [i for i in range(len(features))]\r\n# random.shuffle(ind)\r\n# features = features[ind]\r\n# labels = labels[ind]\r\n\r\n # Return the training data in batches of size <batch_size> or less\r\n return features[0:batch_size],labels[0:batch_size]","def read_input_files(input_file: str) -> list[Food]:\n with open(input_file) as input_fobj:\n foods = [Food.from_raw(line.strip()) for line in input_fobj]\n return foods","def make_batch(self, batch_size):\n filenames = self.get_filenames()\n\n if os.path.isdir(filenames):\n num_records = len(os.listdir(filenames))\n print(\"Loading from directory. \" + str(num_records) + \" tfRecords found.\")\n files = tf.data.Dataset.list_files(filenames + \"/\" + \"*.tfrecord\").shuffle(num_records)\n dataset = files.apply(\n tf.contrib.data.parallel_interleave(\n lambda x: tf.data.TFRecordDataset(x, num_parallel_reads=256, buffer_size=8*1024*1024),\n cycle_length=32, sloppy=True)\n )\n else:\n print(\"Loading from single tfRecord...\")\n dataset = tf.data.TFRecordDataset(filenames + \".tfrecord\").repeat()\n \n dataset = dataset.map(self.parser, num_parallel_calls=128)\n \n if self.subset == 'train':\n min_queue_examples = int(\n Cifar10DataSet.num_examples_per_epoch(self.subset) * 0.4)\n # Ensure that the capacity is sufficiently large to provide good random\n # shuffling.\n dataset = dataset.shuffle(buffer_size=min_queue_examples + 3 * batch_size)\n \n dataset = dataset.apply(tf.contrib.data.batch_and_drop_remainder(batch_size))\n dataset = dataset.prefetch(10)\n \n iterator = dataset.make_one_shot_iterator()\n seq_batch, input_batch, map_batch, transformation_batch = iterator.get_next()\n\n return seq_batch, input_batch, map_batch, transformation_batch","def _load_cifar_batch(fpath, label_key='labels'):\n if isinstance(fpath, (os.PathLike, str, bytes)):\n with open(fpath, 'rb') as f:\n return _load_cifar_batch(f, label_key)\n\n d = pickle.load(fpath, encoding='bytes')\n # decode utf8\n d_decoded = {}\n for k, v in d.items():\n d_decoded[k.decode('utf8')] = v\n d = d_decoded\n data = d['data']\n labels = d[label_key]\n\n data = data.reshape(data.shape[0], 3, 32, 32).transpose([0, 2, 3, 1])\n return data, labels","def data_batch(self, batch_size, input_size, seed=None):\n listing = self.listing\n if seed:\n listing, _ = train_test_split(self.listing, random_state=seed, test_size=0.25)\n image_list = [item + '_orig.jpg' for item in listing]\n label_list = [item + '_contour.png' for item in listing]\n image_files, label_files = tf.convert_to_tensor(image_list), tf.convert_to_tensor(label_list)\n queue = tf.train.slice_input_producer([image_files, label_files],\n shuffle=True)\n img_contents = tf.read_file(queue[0])\n label_contents = tf.read_file(queue[1])\n image = tf.image.decode_jpeg(img_contents, channels=3)\n label = tf.image.decode_png(label_contents, channels=1)\n image, label = default_image_prep(image, label, input_size)\n return tf.train.batch([image, label],\n batch_size=batch_size)","def inputs(data_dir, batch_size,num_data_files=FLAGS.num_data_files):\n\n \n filenames = [os.path.join(data_dir, 'fc6pool4mask_batch_%d' % i)\n for i in xrange(1,num_data_files+1)]\n for f in filenames:\n if not tf.gfile.Exists(f):\n raise ValueError('Failed to find file: ' + f)\n\n\n\n # Create a queue that produces the filenames to read.\n filename_queue = tf.train.string_input_producer(filenames)\n\n # Read examples from files in the filename queue.\n read_input = read_record(filename_queue)\n\n # Subtract off the mean and divide by the variance of the pixels??\n \n # Ensure that the random shuffling has good mixing properties.\n min_fraction_of_examples_in_queue = 0.1\n min_queue_examples = int(NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN *\n min_fraction_of_examples_in_queue)\n\n #print(min_queue_examples)\n print ('Filling queue with %d bottlenecked inputs before starting to train. '\n 'This will take a few minutes.' % min_queue_examples)\n\n # Generate a batch of images and labels by building up a queue of examples.\n return _generate_bottlenecked_batch(read_input.fc6, read_input.pool,read_input.mask,\n min_queue_examples, batch_size,\n shuffle=True)","def load_dataset(path, test_or_train):\n senta_batch, sentb_batch, scores_batch = [], [], []\n with open(path, encoding='utf-8') as f:\n for i, line in enumerate(f):\n items = line.strip().split('\\t')\n if test_or_train == 'train':\n senta, sentb, score = items[-2], items[-1], float(items[-3])\n elif test_or_train in ['dev', 'test']:\n senta, sentb, score = items[-2], items[-1], float(items[-3])\n else:\n raise Exception(\"{} error\".format(test_or_train))\n senta_batch.append(senta)\n sentb_batch.append(sentb)\n scores_batch.append(score)\n return senta_batch, sentb_batch, scores_batch","def load_batch(self, fpath, match, in_num):\n if in_num == None:\n in_num = input('Please specify IN number: ')\n\n if match == None:\n match = input('Please specify filename string to match for batch loading (ex. \\'_s2_\\'): ')\n\n # get a list of all matching files\n glob_match = f'{fpath}/*{match}*'\n files = glob.glob(glob_match)\n\n # load & concatenate files into a single dataframe\n data = pd.concat((pd.read_csv(file, header = [0, 1], index_col = 0, parse_dates=True, low_memory=False) for file in files)).sort_index()\n\n # extract sampling frequency\n s_freq = 1/(data.index[1] - data.index[0]).total_seconds()\n\n # reset the index to continuous time\n ind_freq = str(int(1/s_freq*1000000))+'us'\n ind_start = '1900-01-01 00:00:00.000'\n ind = pd.date_range(start = ind_start, periods=len(data), freq=ind_freq)\n data.index = ind\n\n # set metadata & attributes\n self.metadata = {'file_info':{'in_num': in_num, 'files': files, 'dir': fpath,\n 'match_phrase': match},\n 'analysis_info':{'s_freq': s_freq} }\n self.data = data\n self.s_freq = s_freq","def load_data():\n with open('../data/dataset.txt', 'r') as data_file:\n return data_file.read().split('\\n')","def read_group_batches(filename):\n l = []\n try:\n with open(filename) as f:\n for line in f:\n elements = line.rstrip('\\n').split('\\t')\n batchname = elements[0]\n batchgroup = int(elements[1])\n # Check if there is a nested list with index of the batchgroup\n if len(l)-1 < batchgroup:\n l.append([])\n l[batchgroup].append(batchname)\n except IOError as e:\n print(e)\n return l","def generator_input(filenames, chunk_size, batch_size=64):\n\n feature_cols = None\n while True:\n input_reader = pd.read_csv(\n tf.gfile.Open(filenames[0]),\n names=CSV_COLUMNS,\n chunksize=chunk_size,\n na_values=' ?')\n\n for input_data in input_reader:\n input_data = input_data.dropna()\n # Pop off all of the columns we want to predict and concatenate them\n labels = pd.concat([input_data.pop(x) for x in LABEL_COLUMNS], 1)\n\n input_data = to_numeric_features(input_data, feature_cols)\n\n # Retains schema for next chunk processing.\n if feature_cols is None:\n feature_cols = input_data.columns\n\n idx_len = input_data.shape[0]\n for index in range(0, idx_len, batch_size):\n yield (input_data.iloc[index:min(idx_len, index + batch_size)],\n labels.iloc[index:min(idx_len, index + batch_size)])","def load_nli_file(data_path, num_par=2):\n tokenizer = tokenization.NltkTokenizer()\n dataset = tf.data.TextLineDataset(data_path)\n dataset = dataset.map(\n functools.partial(_nli_line_to_tensors, tokenizer=tokenizer),\n num_parallel_calls=num_par)\n dataset = dataset.filter(lambda x: tf.greater_equal(x[\"label\"], 0))\n return dataset","def split_and_load(batch_data, num_gpus):\n return [batch_data[i].data[0] for i in range(num_gpus)], \\\n [batch_data[i].label[0].as_in_context(mx.gpu(i)) for i in range(num_gpus)]","def load_batch(filename: str) -> Tuple[ndarray, ndarray, ndarray]:\n dataDict = unpickle(filename)\n print(\"1\", dataDict[b\"data\"][1, :])\n X = (dataDict[b\"data\"] / 255).T\n print(\"2\", X[:, 1])\n y = np.array(dataDict[b\"labels\"])\n Y = np.eye(10)[y].T\n return X, Y, y","def input_fn(data_file, num_epochs, shuffle, batch_size):\n assert tf.gfile.Exists(data_file), (\n '%s not found. Please make sure you have either run data_download.py or '\n 'set both arguments --train_data and --test_data.' % data_file)\n\n def parse_csv(value): \n print('Parsing', data_file)\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\n features = dict(zip(_CSV_COLUMNS, columns))\n labels = features.pop('labels')\n return features, tf.equal(labels, 'TRUE')\n \n\n # Extract lines from input files using the Dataset API.\n dataset = tf.data.TextLineDataset(data_file)\n\n if shuffle:\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\n\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\n\n # We call repeat after shuffling, rather than before, to prevent separate\n # epochs from blending together.\n dataset = dataset.repeat(num_epochs)\n dataset = dataset.batch(batch_size)\n\n iterator = dataset.make_one_shot_iterator()\n features, labels = iterator.get_next()\n return features, labels","def input_fn(data_file, batch_size):\n assert tf.gfile.Exists(data_file), (\n '%s not found. Please make sure you have set both arguments --train_data and --test_data.' % data_file)\n\n def parse(serialized_example):\n context_feature = {'label': tf.FixedLenFeature([], dtype=tf.int64)}\n sequence_features = {\n \"week_list\": tf.FixedLenSequenceFeature([], dtype=tf.string),\n 'week_weight': tf.FixedLenSequenceFeature([], dtype=tf.float32)}\n context_parsed, sequence_parsed = tf.parse_single_sequence_example(\n serialized=serialized_example,\n context_features=context_feature,\n sequence_features=sequence_features)\n labels = context_parsed['label']\n week_list = sequence_parsed['week_list']\n week_weight = sequence_parsed['week_weight']\n return labels, week_list, week_weight\n\n def form_features(*line):\n cols = ['label', 'week_list', 'week_weight']\n features = dict(zip(cols, line))\n label = features.pop('label')\n return features, label\n\n dataset = tf.data.TFRecordDataset(data_file) \\\n .map(parse) \\\n .padded_batch(batch_size, ([1], [7], [7])) \\\n .map(form_features)\n iterator = dataset.make_one_shot_iterator()\n features, labels = iterator.get_next()\n return features, labels","def data_loader(\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\n ) -> DataLoader:\n data = self.data\n datasets = []\n\n for _, dat in data.items():\n datasets.append(dat.dataset())\n\n if len(datasets) < 1:\n raise FileNotFoundError(\n \"no datasets available for this model to create a loader from\"\n )\n\n return DataLoader(\n *datasets,\n batch_size=batch_size,\n iter_steps=iter_steps,\n batch_as_list=batch_as_list,\n )","def load_input(self, file_name):\n with open(file_name, \"r\") as in_file:\n self.all_lines = [line.rstrip('\\n') for line in in_file]","def load_all(cls, data):\n return [cls.load(obj) for obj in data]","def input_fn(data_file, num_epochs, shuffle, batch_size):\n assert tf.gfile.Exists(data_file), (\n '%s not found. Please make sure you have either run data_download.py or '\n 'set both arguments --train_data and --test_data.' % data_file)\n\n def parse_csv(value):\n print('Parsing', data_file)\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\n features = dict(zip(_CSV_COLUMNS, columns))\n labels = features.pop('income_bracket')\n return features, tf.equal(labels, '>50K')\n\n # Extract lines from input files using the Dataset API.\n dataset = tf.data.TextLineDataset(data_file)\n\n if shuffle:\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\n\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\n\n # We call repeat after shuffling, rather than before, to prevent separate\n # epochs from blending together.\n dataset = dataset.repeat(num_epochs)\n dataset = dataset.batch(batch_size)\n\n iterator = dataset.make_one_shot_iterator()\n features, labels = iterator.get_next()\n return features, labels","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n # all_files = tf.gfile.Glob(os.path.join(input_dir, '*.png'))\n # test_files = [all_files[idx] for x in np.random.choice(len(all_files), 200, replace=False)]\n # for filepath in test_files:\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n with tf.gfile.Open(filepath) as f:\n image = imread(f, mode='RGB').astype(np.float) / 255.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx, :, :, :] = image * 2.0 - 1.0\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_data(batch_size=batch_size):\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\n\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\n\n return train_loader, test_loader","def input_fn():\n bos_id = tf.constant(BOS_ID, tf.int32)\n eos_id = tf.constant(EOS_ID, tf.int32)\n\n # For training, we want a lot of parallel reading and shuffling.\n # For eval, we want no shuffling and parallel reading doesn't matter.\n d = tf.data.TFRecordDataset(input_files)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.map(lambda record: _decode_record(record, name_to_features))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\n tf.concat([tgt_ids, [eos_id]], 0),\n label))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n src_ids[:FLAGS.max_sequence_length],\n tgt_ids[:FLAGS.max_sequence_length],\n label\n ))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([src_ids, tgt_ids], 0),\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\n label\n ))\n\n d = d.map(lambda input_ids, segment_ids, label_ids: (\n input_ids,\n segment_ids,\n tf.ones_like(input_ids),\n label_ids\n ))\n\n def batching_func(x):\n return x.padded_batch(\n batch_size,\n # The entry is the source line rows;\n # this has unknown-length vectors. The last entry is\n # the source row size; this is a scalar.\n padded_shapes=(\n tf.TensorShape([None]), # src\n tf.TensorShape([None]), # tgt\n tf.TensorShape([None]),\n tf.TensorShape([])), # src_len\n # Pad the source sequences with eos tokens.\n # (Though notice we don't generally need to do this since\n # later on we will be masking out calculations past the true sequence.\n padding_values=(\n PAD_ID, # src\n PAD_ID,\n PAD_ID,\n 0)) # src_len -- unused\n\n batched_dataset = batching_func(d)\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\n {\n \"input_ids\": input_ids,\n \"segment_ids\": segment_ids,\n \"input_mask\": input_mask,\n \"label_ids\": label\n\n })\n\n return features","def load_CIFAR_batch(filename):\r\n with open(filename, 'rb') as f:\r\n datadict = load_pickle(f)\r\n X = datadict['data']\r\n Y = datadict['labels']\r\n X = X.reshape(10000,3072)\r\n Y = np.array(Y)\r\n return X, Y","def load_batch(dataset, batch_size=32, height=299, width=299, is_training=False):\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\n dataset, common_queue_capacity=32,\n common_queue_min=8)\n image_raw, label = data_provider.get(['image', 'label'])\n\n # Preprocess image for usage by Inception.\n image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\n\n # Preprocess the image for display purposes.\n image_raw = tf.expand_dims(image_raw, 0)\n image_raw = tf.image.resize_images(image_raw, [height, width])\n image_raw = tf.squeeze(image_raw)\n\n # Batch it up.\n images, images_raw, labels = tf.train.batch(\n [image, image_raw, label],\n batch_size=batch_size,\n num_threads=1,\n capacity=2 * batch_size)\n\n return images, images_raw, labels","def load_training_data(file_path):\n return load_data(file_path)","def load_batch(dataset, batch_size=32, height=299, width=299, is_training=False):\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\n dataset, common_queue_capacity=32,\n common_queue_min=8)\n image_raw, label = data_provider.get(['image', 'label'])\n \n # Preprocess image for usage by Inception.\n image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\n \n # Preprocess the image for display purposes.\n image_raw = tf.expand_dims(image_raw, 0)\n image_raw = tf.image.resize_images(image_raw, [height, width])\n image_raw = tf.squeeze(image_raw)\n\n # Batch it up.\n images, images_raw, labels = tf.train.batch(\n [image, image_raw, label],\n batch_size=batch_size,\n num_threads=1,\n capacity=2 * batch_size)\n \n return images, images_raw, labels","def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def load_CIFAR_batch(filename):\n with open(filename, 'rb') as f:\n datadict = load_pickle(f)\n X = datadict['data']\n Y = datadict['labels']\n X = X.reshape(10000,3072)\n Y = np.array(Y)\n return X, Y","def load_dataset(input_path):\n with open(input_path, \"r\") as f:\n smiles_list = f.read().strip().split(\"\\n\")\n return smiles_list","def load_batch(dataset, batch_size=32, height=224, width=224, is_training=False):\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\n dataset, common_queue_capacity=32,\n common_queue_min=8)\n image_raw, label = data_provider.get(['image', 'label'])\n\n # Preprocess image for usage by Inception.\n # image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\n image = no_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\n\n # Preprocess the image for display purposes.\n image_raw = tf.expand_dims(image_raw, 0)\n image_raw = tf.image.resize_images(image_raw, [height, width])\n image_raw = tf.squeeze(image_raw)\n\n # Batch it up.\n images, images_raw, labels = tf.train.batch(\n [image, image_raw, label],\n batch_size=batch_size,\n num_threads=1,\n capacity=2 * batch_size)\n\n return images, images_raw, labels","def load_dataset(path):\n training_data = []\n with open(path) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n training_data.append(row[1])\n return training_data","def input_fn():\n files = tf.data.Dataset.list_files(os.path.join(\n tft_working_dir, filebase + '*'))\n dataset = files.interleave(\n tf.data.TFRecordDataset, cycle_length=4, block_length=16)\n dataset = dataset.map(parser)\n\n if shuffle:\n dataset = dataset.shuffle(buffer_size)\n\n dataset = dataset.repeat(num_epochs)\n dataset = dataset.batch(batch_size)\n\n dataset = dataset.prefetch(prefetch_buffer_size)\n iterator = dataset.make_one_shot_iterator()\n transformed_features, transformed_labels = iterator.get_next()\n\n return transformed_features, transformed_labels","def input_fn(data_file, num_epochs, shuffle, batch_size):\n assert tf.gfile.Exists(data_file), (\n '%s not found. Please make sure you have either run data_download.py or '\n 'set both arguments --train_data and --test_data.' % data_file)\n\n def parse_csv(value):\n print('Parsing', data_file)\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\n features = dict(zip(_CSV_COLUMNS, columns))\n\n labels = features.pop('price')\n return features, tf.equal(labels, '>1000')\n\n # Extract lines from input files using the Dataset API.\n\n dataset = tf.data.TextLineDataset(data_file)\n\n if shuffle:\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\n\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\n\n # We call repeat after shuffling, rather than before, to prevent separate\n # epochs from blending together.\n dataset = dataset.repeat(num_epochs)\n dataset = dataset.batch(batch_size)\n return dataset","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n with tf.gfile.Open(filepath) as f:\n image = np.array(Image.open(f).convert('RGB')).astype(np.float) / 1.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx, :, :, :] = image\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_CIFAR10(path):\r\n sampleList = []\r\n labelList = []\r\n # load all the data, as there only five training samples name as data_batch_id\r\n for i in range(1, 6):\r\n # get full filename\r\n filename = os.path.join(path, 'data_batch_%d' % (i, ))\r\n x, y = load_CIFAR_batch(filename)\r\n\r\n sampleList.append(x)\r\n labelList.append(y)\r\n\r\n # combine elements as one array\r\n Xtr = np.concatenate(sampleList)\r\n Ytr = np.concatenate(labelList)\r\n del x, y\r\n print(\"Training data loaded, total size : %d\", len(Xtr))\r\n # load test data\r\n Xte, Yte = load_CIFAR_batch(os.path.join(path, 'test_batch'))\r\n return Xtr, Ytr, Xte, Yte","def load_train_batch(self):\n def _parse_train_img(img_path):\n with tf.device('/cpu:0'):\n img_buffer = tf.read_file(img_path)\n image_decoded = tf.image.decode_jpeg(img_buffer)\n tgt_image, src_image_stack = \\\n self.unpack_image_sequence(\n image_decoded, self.img_height, self.img_width, self.num_source)\n return tgt_image, src_image_stack\n\n def _batch_preprocessing(stack_images, intrinsics, optional_data):\n intrinsics = tf.cast(intrinsics, tf.float32)\n image_all = tf.concat([stack_images[0], stack_images[1]], axis=3)\n\n if self.match_num == 0: # otherwise matches coords are wrong\n image_all, intrinsics = self.data_augmentation(\n image_all, intrinsics, self.img_height, self.img_width)\n tgt_image = image_all[:, :, :, :3]\n src_image_stack = image_all[:, :, :, 3:]\n intrinsics = self.get_multi_scale_intrinsics(intrinsics, self.num_scales)\n return tgt_image, src_image_stack, intrinsics, optional_data\n\n file_list = self.format_file_list(self.dataset_dir, 'train')\n self.steps_per_epoch = int(len(file_list['image_file_list'])//self.batch_size)\n\n input_image_names_ph = tf.placeholder(tf.string, shape=[None], name='input_image_names_ph')\n image_dataset = tf.data.Dataset.from_tensor_slices(\n input_image_names_ph).map(_parse_train_img)\n\n cam_intrinsics_ph = tf.placeholder(tf.float32, [None, 3, 3], name='cam_intrinsics_ph')\n intrinsics_dataset = tf.data.Dataset.from_tensor_slices(cam_intrinsics_ph)\n\n datasets = (image_dataset, intrinsics_dataset, intrinsics_dataset)\n if self.read_pose:\n poses_ph = tf.placeholder(tf.float32, [None, self.num_source+1, 6], name='poses_ph')\n pose_dataset = tf.data.Dataset.from_tensor_slices(poses_ph)\n datasets = (image_dataset, intrinsics_dataset, pose_dataset)\n if self.match_num > 0:\n matches_ph = tf.placeholder(tf.float32, [None, self.num_source, self.match_num, 4], name='matches_ph')\n match_dataset = tf.data.Dataset.from_tensor_slices(matches_ph)\n datasets = (image_dataset, intrinsics_dataset, match_dataset)\n\n all_dataset = tf.data.Dataset.zip(datasets)\n all_dataset = all_dataset.batch(self.batch_size).repeat().prefetch(self.batch_size*4)\n all_dataset = all_dataset.map(_batch_preprocessing)\n iterator = all_dataset.make_initializable_iterator()\n return iterator","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n with tf.gfile.Open(filepath) as f:\n image = np.array(Image.open(f).convert('RGB')).astype(np.float) / 255.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx] = image * 2.0 - 1.0\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_data(path_dataset):\n data = read_txt(path_dataset)[1:]\n return preprocess_data(data)","def get_train_batches(data_dir='/home/yunhan/batchified'):\n # todo: read in data that is preoprocessed\n # Use batch 1 - 52 as train (60%), 53 - 71 as validation (20%), 72 - 89 as test (20%)\n n = 53\n idx = np.random.permutation(n)\n idx = idx + 1\n for i in range(n):\n X = np.load(\"%s/X%d.npy\" % (data_dir, idx[i]))/255.\n Y = np.load(\"%s/y%d.npy\" % (data_dir, idx[i])).reshape(-1)\n yield X, Y","def load_input(file_name, elements):\n\n input_file = open(file_name)\n input_data = []\n\n while True:\n chunk = input_file.readline()\n\n if(chunk == ''):\n break\n \n ret = load_chunk(chunk, elements)\n\n # Convert data to frequency domain using fft()\n input_data.append([i.real for i in fft(ret)])\n\n return input_data","def load_dataset(fname, nb_lines):\n import os.path\n if os.path.isfile('safe/Amazon-'+str(nb_lines)+'.p'):\n return util.load('safe/Amazon-'+str(nb_lines)+'.p')\n count = 1\n X = []\n y = []\n with open(fname) as f:\n for line in f:\n text, label = read_line(line)\n #print((label, text))\n X.append(text)\n y.append(label)\n if count >= nb_lines:\n break\n count+=1\n\n #load pretrained dictonary\n dico = util.load('safe/vocab_gensim.p')\n preprocessor = text_preprocessing.Preprocessor(dico=dico)\n X = preprocessor.preprocess(X)\n #save the loaded dataset in a pickle for speeding up next run\n util.save((X,y), 'safe/Amazon-'+str(nb_lines)+'.p')\n return (X, y)","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n with tf.gfile.Open(filepath) as f:\n image = imread(f, mode='RGB').astype(np.float) / 255.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx] = image * 2.0 - 1.0\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_datasets(filepath):\n\n data_file = open(filepath, 'r')\n data_list = data_file.readlines()\n data_file.close()\n\n return data_list","def load_data(self):\n with open(self.file_name) as f:\n lines = f.readlines()\n\n labels = list()\n all_dat = list()\n for i, l in enumerate(lines):\n\n labels.append(int(l[0]))\n\n l = gensim.utils.any2unicode(l)\n all_dat.append(LabeledSentence(l.split(\"\\t\")[-1], [i]))\n\n return all_dat, np.asarray(labels)","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n with tf.gfile.Open(filepath) as f:\n image = imread(f, mode='RGB').astype(np.float) / 255.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx, :, :, :] = image * 2.0 - 1.0\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_cifa_10():\n train_set_x = np.ndarray([ 50000, 3072 ])\n train_set_y = np.ndarray( [50000] )\n\n batch_size = 10000\n for i in xrange(5):\n batch = open( datapath + \"data_batch_\"+str(i+1), 'rb')\n map = cPickle.load( batch )\n batch.close()\n train_set_x[ i*batch_size : (i+1)*batch_size , : ] = np.asarray( map[ 'data' ], dtype = 'float32' )\n train_set_y[ i*batch_size : (i+1)*batch_size ] = np.asarray( map[ 'labels' ], dtype = 'float32' )\n\n test_file = open( datapath + 'test_batch', 'rb')\n map = cPickle.load( test_file )\n test_file.close()\n \n test_set_x = np.asarray( map['data'], dtype = 'float32' )\n test_set_y = np.asarray( map['labels'], dtype = 'float32' )\n \n\n return train_set_x, train_set_y, test_set_x, test_set_y","def load_CIFAR_batch(filename):\n with open(filename, 'rb')as f:\n # datadict = p.load(f)\n datadict = pickle.load(f, encoding = 'bytes')\n X = datadict[b'data']\n Y = datadict[b'labels']\n X = X.reshape(10000, 3, 32, 32)\n Y = np.array(Y)\n return X, Y","def batch_data(cls, train_data, train_labels, batch_size):\n for batch in range(int(np.ceil(train_data.shape[0] / batch_size))):\n start = batch_size * batch\n end = start + batch_size\n if end > train_data.shape[0]:\n yield batch, (train_data[start:train_data.shape[0]], \\\n train_labels[start:train_data.shape[0]])\n else:\n yield batch, (train_data[start:end], \\\n train_labels[start:end])","def load_preprocess_test_batch(batch_id, batch_size):\r\n filename = 'preprocess_test_' + str(batch_id) + '.p'\r\n features, labels = pickle.load(open(filename, mode='rb'))\r\n# labels = np.argmax(labels,1)\r\n# num = len(labels)\r\n# arr = np.zeros((num, 1))\r\n# for i in range(num):\r\n# arr[i][0] = labels[i]\r\n# ind = [i for i in range(len(features))]\r\n# random.shuffle(ind)\r\n# features = features[ind]\r\n# labels = labels[ind]\r\n\r\n # Return the training data in batches of size <batch_size> or less\r\n return features[1200:batch_size],labels[1200:batch_size]\r\n #return batch_features_labels(features, labels, batch_size)\r","def parse_file(self, file_path) -> list:\n data = []\n with open(file_path, 'rb') as f:\n lines = pickle.load(f)\n for line in lines:\n input, output = line\n if input.strip() == \"\" or output.strip() == \"\":\n continue\n input_len = len(input.split())\n output_len = len(output.split())\n if input_len > 50 or output_len > 50:\n continue\n data_item = Text2TextDataItem(input_text=input, output_text=output, tokenizer=self.tokenizer,\n share_vocab=self.share_vocab)\n data.append(data_item)\n return data","def load_input(filepath: str) -> list:\n lines = []\n with open(filepath, \"r\", encoding=\"utf-8\") as file:\n for line in file.readlines():\n lines.append(line.strip())\n return lines","def load_CIFAR_batch(filename):\r\n with open(filename, 'rb')as f:\r\n datadict = p.load(f)\r\n \r\n X = datadict['data']\r\n Y = datadict['labels']\r\n \r\n print X.shape\r\n X = X.reshape(X.shape[0], SHAPE[0], SHAPE[1], SHAPE[2])\r\n Y = np.array(Y)\r\n return X, Y","def _load_split_data(self, dataset_path):\n for i, prefix in enumerate(['train', 'dev', 'test']):\n filename = os.path.join(dataset_path, '{}.txt'.format(prefix))\n knowledge, src, tgt = self._load_multi_data(filename)\n self.group_text_data[0].append(knowledge)\n self.group_text_data[1].append(src)\n self.group_text_data[2].append(tgt)","def batch_iter(input_data,batch_size):\r\n batch_ids,batch_mask,batch_segment,batch_label=[],[],[],[]\r\n for features in input_data:\r\n if len(batch_ids) == batch_size:\r\n yield batch_ids,batch_mask,batch_segment,batch_label\r\n batch_ids, batch_mask, batch_segment, batch_label = [], [], [], []\r\n\r\n batch_ids.append(features['input_ids'])\r\n batch_mask.append(features['input_mask'])\r\n batch_segment.append(features['segment_ids'])\r\n batch_label.append(features['label_ids'])\r\n\r\n if len(batch_ids) != 0:\r\n yield batch_ids, batch_mask, batch_segment, batch_label","def load_images(input_dir, batch_shape):\n images = np.zeros(batch_shape)\n filenames = []\n idx = 0\n batch_size = batch_shape[0]\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\n if(FLAGS.checkpoint_file_name==\"vgg_16.ckpt\")or(FLAGS.checkpoint_file_name==\"vgg_19.ckpt\")or(FLAGS.checkpoint_file_name==\"resnet_v1_50.ckpt\")or(FLAGS.checkpoint_file_name==\"resnet_v1_101.ckpt\")or(FLAGS.checkpoint_file_name==\"resnet_v1_152.ckpt\"):\n with tf.gfile.Open(filepath) as f:\n image = imread(f, mode='RGB').astype(np.float)\n images[idx, :, :, :] = image\n else:\n with tf.gfile.Open(filepath) as f:\n image = imread(f, mode='RGB').astype(np.float) / 255.0\n # Images for inception classifier are normalized to be in [-1, 1] interval.\n images[idx, :, :, :] = image * 2.0 - 1.0\n filenames.append(os.path.basename(filepath))\n idx += 1\n if idx == batch_size:\n yield filenames, images\n filenames = []\n images = np.zeros(batch_shape)\n idx = 0\n if idx > 0:\n yield filenames, images","def load_data(loc='../data/SICK/'):\n trainA, trainB, testA, testB = [],[],[],[]\n trainS, testS = [],[]\n\n with open(loc + 'SICK_train.txt', 'rb') as f:\n for line in f:\n text = line.strip().split('\\t')\n trainA.append(text[1])\n trainB.append(text[2])\n trainS.append(text[3])\n with open(loc + 'SICK_test_annotated.txt', 'rb') as f:\n for line in f:\n text = line.strip().split('\\t')\n testA.append(text[1])\n testB.append(text[2])\n testS.append(text[3])\n\n trainS = [float(s) for s in trainS[1:]]\n testS = [float(s) for s in testS[1:]]\n\n return [trainA[1:], trainB[1:]], [testA[1:], testB[1:]], [trainS, testS]","def load_dataset(filenames, batch_size, corruption_func, crop_size):\n cache = dict()\n while True:\n source_batch = np.zeros((batch_size, crop_size[0], crop_size[1], 1))\n target_batch = np.zeros((batch_size, crop_size[0], crop_size[1], 1))\n chosen_filenames = _read_images_and_put_in_dict(filenames,\n cache,\n batch_size)\n for filename_idx in range(len(chosen_filenames)):\n filename = chosen_filenames[filename_idx]\n im = cache[filename]\n patch = _get_random_patch_of_the_image(im, crop_size)\n corrupted_im = corruption_func(patch)\n source_batch[filename_idx, :, :, 0] = corrupted_im - 0.5\n target_batch[filename_idx, :, :, 0] = patch - 0.5\n yield source_batch, target_batch","def load_training_data(config):\n # Load data\n LOGGER.info(\"Loading training data.\")\n train_x = load_data(config['data_source'], config['train_x_filename'])\n train_y = load_data(config['data_source'], config['train_y_filename'])\n val_x = load_data(config['data_source'], config['val_x_filename'])\n val_y = load_data(config['data_source'], config['val_y_filename'])\n LOGGER.info(\"Training data size: %d\", len(train_x))\n LOGGER.info(\"Validation data size: %d\", len(val_x))\n\n # Build datasets and create iterators\n LOGGER.info(\"Building dataset.\")\n train_dataset = get_dataset(\n train_x, train_y, config['batch_size'], config['data_shape'],\n config['n_classes'], True)\n val_dataset = get_dataset(\n val_x, val_y, config['batch_size'], config['data_shape'],\n config['n_classes'])\n\n return train_dataset, val_dataset, len(val_x)","def load_features(feature_path):\n if not os.path.exists(os.path.join(feature_path, f\"0_features.npy\")): \n raise ValueError(f\"The provided location {feature_path} does not contain any representation files\")\n\n ds_list, chunk_id = [], 0\n while os.path.exists(os.path.join(feature_path, f\"{chunk_id}_features.npy\")): \n features = ch.from_numpy(np.load(os.path.join(feature_path, f\"{chunk_id}_features.npy\"))).float()\n labels = ch.from_numpy(np.load(os.path.join(feature_path, f\"{chunk_id}_labels.npy\"))).long()\n ds_list.append(ch.utils.data.TensorDataset(features, labels))\n chunk_id += 1\n\n print(f\"==> loaded {chunk_id} files of representations...\")\n return ch.utils.data.ConcatDataset(ds_list)","def load_CIFAR_batch(filename):\r\n with open(filename, 'rb') as f:\r\n datadict = pickle.load(f, encoding='latin1')\r\n X = datadict['data']\r\n Y = datadict['labels']\r\n X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype(\"float\")\r\n Y = np.array(Y)\r\n return X, Y","def read_files(\n self,\n file_instructions: List[Dict],\n num_examples_per_shard: List[int],\n shuffle_files: bool,\n ) -> DatasetType:\n if not file_instructions:\n raise AssertionError(f'Instruction {file_instructions} corresponds to no data')\n\n # Prepend path to filename\n files = copy.deepcopy(file_instructions)\n for f in files:\n f.update(filename=os.path.join(self._path, f['filename']))\n\n if self._read_config.experimental_interleave_sort_fn is not None:\n files = self._read_config.experimental_interleave_sort_fn(files)\n\n do_skip = any(f['skip'] > 0 for f in files)\n do_take = any(f['take'] > -1 for f in files)\n\n tensor_inputs = {\n k: list(vals) if k == 'filename' else np.array(vals, dtype=np.int64)\n for k, vals in zip_dict(*files)\n }\n\n instruction_ds = tf.data.Dataset.from_tensor_slices(tensor_inputs)\n if shuffle_files:\n instruction_ds = instruction_ds.shuffle(\n len(tensor_inputs['filename']),\n seed=self._read_config.seed,\n reshuffle_each_iteration=self._read_config.shuffle_reshuffle_each_iteration,\n )\n\n ds = instruction_ds.interleave(\n partial(self._get_dataset_from_filename, do_skip=do_skip, do_take=do_take),\n cycle_length=self._read_config.interleave_cycle_length,\n block_length=self._read_config.interleave_block_length,\n num_parallel_calls=tf.data.experimental.AUTOTUNE,\n )\n\n if (num_examples_per_shard and hasattr(tf.data.experimental, 'assert_cardinality')):\n cardinality = sum(num_examples_per_shard)\n ds = ds.apply(tf.data.experimental.assert_cardinality(cardinality))\n ds = ds.with_options(self._read_config.options)\n return ds.map(self._parser.parse_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)","def set_batch_data():\r\n if not os.path.exists(filepath):\r\n download_data()\r\n for n in range(0,6):\r\n d = read(filepath + flist[n])\r\n metadata = read(filepath + flist[-1])\r\n ndata = metadata['num_cases_per_batch']\r\n ndim = metadata['num_vis']\r\n\r\n data, trts = {}, {}\r\n data['labels'] = metadata['label_names']\r\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\r\n data['ntestdata'] = metadata['num_cases_per_batch']\r\n data['ndim'] = metadata['num_vis']\r\n trts['x'], trts['y'] = d['data'], d['labels']\r\n trtsflag = ['train', 'train', 'train', 'train', 'train', 'test']\r\n\r\n data['flag'] = trtsflag[n]\r\n data[trtsflag[n]] = trts\r\n save_pkl(data, savename=flist[n]+'.pkl')","def load_array(data_arrays, batch_size, is_train=True):\n dataset = data.TensorDataset(*data_arrays)\n return data.DataLoader(dataset, batch_size, shuffle=is_train)","def load_CIFAR_batch(filename):\n with open(filename, 'rb')as f:\n datadict = p.load(f, encoding='iso-8859-1')\n X = datadict['data']\n Y = datadict['labels']\n X = X.reshape(10000, 3, 32, 32)\n Y = np.array(Y)\n return X, Y","def _read_train_datas(self):\r\n with open(self.train_label_path, 'r') as fb:\r\n lines = fb.readlines()\r\n return self._parse_raw_labels(lines)","def read_data(cls, input_file):\n with tf.gfile.Open(input_file, \"r\") as f:\n lines = []\n for line in f:\n line = line.strip()\n if line.startswith('-DOCSTART-'):\n continue\n else:\n word_labels = line.split('-seq-')\n assert len(word_labels) == 2\n\n words = word_labels[0]\n labels = word_labels[1]\n lines.append([words, labels])\n\n return lines","def load_CIFAR_batch(filename):\n with open(filename, 'rb') as f:\n datadict = pickle.load(f, encoding='latin1')\n X = datadict['data']\n Y = datadict['labels']\n X = X.reshape(10000, 3, 32, 32).transpose(0, 2, 3, 1).astype(\"float64\")\n Y = np.array(Y)\n return X, Y","def load_array(data_arrays, batch_size, is_train=True): #@save\n dataset = tf.data.Dataset.from_tensor_slices(data_arrays)\n if is_train:\n dataset = dataset.shuffle(buffer_size=1000)\n dataset = dataset.batch(batch_size)\n return dataset","def load_array(data_arrays, batch_size, is_train=True): #@save\n dataset = tf.data.Dataset.from_tensor_slices(data_arrays)\n if is_train:\n dataset = dataset.shuffle(buffer_size=1000)\n dataset = dataset.batch(batch_size)\n return dataset","def load_data(self, file_path):\n \n dataset = []\n \n for line in open(file_path):\n arr = line.strip().split('\\t')\n label = [w for w in arr[0].split(' ')]\n sentence = [w for w in arr[1].split(' ')]\n cname = ' '.join(label)\n \n # The line is useless if the class is\n # not in the class dictionary.\n if cname not in self.class_list:\n raise Exception(\"{} not in class list.\".format(cname))\n \n # Build the sample dictionary.\n sample = {}\n sample['sentence_w2v'] = []\n \n for word in sentence:\n if word not in self.w2v.vocab.keys():\n continue # ignore sentence\n \n # In the loading embedding (see self.load_embedding()), we\n # stack one additional layer of zeros in front to handle padding.\n # Thus here we append the embedding index plus one.\n sample['sentence_w2v'].append(torch.Tensor([self.w2v.vocab[word].index + 1]))\n\n sample['length'] = len(sample['sentence_w2v'])\n sample['label_onehot'] = self.onehot(self.class_indices[cname])\n sample['label_w2v'] = self.class_w2v[cname]\n dataset.append(sample)\n \n return dataset","def load_raw_data(self, input_files):\n\n log.debug(f\"Loading dataset {input_files}\") \n print(f\"Loading dataset\")\n\n # Load stroke information from XML files\n for file in input_files:\n new_strokeset = strokeset.StrokeSet(file)\n self.strokesets.append(new_strokeset)\n self.stroke_matrix.append(new_strokeset.as_delta_array())\n self.stroke_ascii.append(new_strokeset.get_text())\n\n done_msg = \"Finished parsing dataset. Imported {} lines\".format(len(self.get_strokesets()))\n print (done_msg)\n log.info(done_msg)","def generateBatches(data, batch_size):\n random.shuffle(data)\n batches = []\n size = len(data)\n def loadBatches(data, total_size, batch_size_):\n for i in range(0, total_size, batch_size_):\n yield data[i:min(total_size, i + batch_size_)]\n\n for unprocessed_batch in loadBatches(data, size, batch_size):\n processed_batch = processBatch(unprocessed_batch)\n batches.append(processed_batch)\n return batches","def load_data_list(self):\n\n data = mat4py.loadmat(self.ann_file)['images']\n names = data['name']\n labels = data['class']\n parts = data['set']\n num = len(names)\n assert num == len(labels) == len(parts), 'get error ann file'\n\n if self.split == 'train':\n target_set = {1}\n elif self.split == 'val':\n target_set = {2}\n elif self.split == 'test':\n target_set = {3}\n else:\n target_set = {1, 2}\n\n data_list = []\n for i in range(num):\n if parts[i] in target_set:\n img_name = names[i]\n img_path = self.backend.join_path(self.img_prefix, img_name)\n gt_label = labels[i] - 1\n info = dict(img_path=img_path, gt_label=gt_label)\n data_list.append(info)\n\n return data_list"],"string":"[\n \"def LoadBatch(filename):\",\n \"def load_batch(fpath, label_key='labels'):\\n f = open(fpath, 'rb')\\n if sys.version_info < (3,):\\n d = cPickle.load(f)\\n else:\\n d = cPickle.load(f, encoding='bytes')\\n # decode utf8\\n d_decoded = {}\\n for k, v in d.items():\\n d_decoded[k.decode('utf8')] = v\\n d = d_decoded\\n f.close()\\n data = d['data']\\n labels = d[label_key]\\n\\n data = data.reshape(data.shape[0], 3, 32, 32)\\n return data, labels\",\n \"def loadData(self, file):\\n self.data = batchImport(file, self.ps)\",\n \"def load_data():\\r\\n global labelNames\\r\\n print(\\\"Loading Data...\\\")\\r\\n\\r\\n fnpath = \\\"rawdata\\\\\\\\cifar-10-batches-py\\\"\\r\\n fnprefix = 'data_batch_'\\r\\n fnlblnames = 'batches.meta'\\r\\n fntstbatch = 'test_batch'\\r\\n\\r\\n labelNames = unpickle(path.join(fnpath, fnlblnames))\\r\\n label_names = []\\r\\n for label in labelNames['label_names']:\\r\\n label_names.append(\\\"\\\".join(map(chr, label)))\\r\\n labelNames['label_names'] = label_names\\r\\n\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\\r\\n for n in range(1, 6):\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))\",\n \"def _load_input() -> List[List[int]]:\\n filepath = os.path.join(os.getcwd(), os.path.dirname(__file__), INPUT_FILE)\\n f = open(filepath, 'r')\\n data = f.read()\\n f.close()\\n\\n raw_input = data.strip().split('\\\\n')\\n input = [list(ri) for ri in raw_input]\\n return [[int(i) for i in line] for line in input]\",\n \"def load_batch(batch_name):\\n data_dict = unpickle('./datasets/cifar-10-batches-py/' + batch_name)\\n X = data_dict[b'data'] / 255\\n X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).reshape(10000, 3072).transpose(1,0)\\n y = data_dict[b'labels']\\n Y = make_one_hot(y)\\n return X, Y, y\",\n \"def load_batch(n):\\r\\n print ('Loadng one batch...')\\r\\n batchfilename = flist[n - 1] + '.pkl'\\r\\n if not os.path.exists(batchfilename):\\r\\n set_batch_data()\\r\\n with open(batchfilename, 'rb') as cifar_pickle:\\r\\n data = six.moves.cPickle.load(cifar_pickle)\\r\\n return data\",\n \"def _load_batch_file(filename):\\n # Load the pickled data-file.\\n data = _unpickle(filename)\\n # Get the raw images.\\n raw_images = data[b'data']\\n # Get the class-numbers for each image. Convert to numpy-array.\\n cls = np.array(data[b'labels'])\\n # Convert the images.\\n images = _convert_images(raw_images)\\n\\n return images, cls\",\n \"def split_and_load(batch, ctx_list):\\n new_batch = []\\n for i, data in enumerate(batch):\\n if isinstance(data, (list, tuple)):\\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\\n else:\\n new_data = [data.as_in_context(ctx_list[0])]\\n new_batch.append(new_data)\\n return new_batch\",\n \"def loadInMemoryOneBatch(fileName,batchSize):\\n\\n inputFile = open(fileName)\\n\\n while True:\\n objects = []\\n allDone = False\\n while True:\\n line = inputFile.readline()\\n if line:\\n objects.append(line)\\n if len(objects) == batchSize:\\n break\\n else:\\n allDone = True\\n break\\n yield objects\\n if allDone == True:\\n break\",\n \"def split_and_load(batch, ctx_list):\\n num_ctx = len(ctx_list)\\n new_batch = []\\n for i, data in enumerate(batch):\\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\\n new_batch.append(new_data)\\n return new_batch\",\n \"def split_and_load(batch, ctx_list):\\n num_ctx = len(ctx_list)\\n new_batch = []\\n for i, data in enumerate(batch):\\n new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]\\n new_batch.append(new_data)\\n return new_batch\",\n \"def batch(data_path):\\n train, _, _ = get_datasets(\\n data_path=data_path,\\n nb_nodes=7,\\n task_type=\\\"classification\\\",\\n nb_classes=2,\\n split=None,\\n k_fold=None,\\n seed=1234,\\n )\\n for batch in torch.utils.data.DataLoader(\\n train, shuffle=False, batch_size=25, drop_last=False\\n ):\\n return batch\",\n \"def load_preprocess_training_batch(batch_id, batch_size):\\n path, dataset = select_dataset(training = True)\\n data = dataset_lib.get_data(batch_id, dataset=dataset, path=path)\\n features = [np.array(x[1]) for x in data]\\n labels = np.array([x[0] for x in data])\\n\\n # Return the training data in batches of size <batch_size> or less\\n return batch_features_labels(features, labels, batch_size)\",\n \"def load_all_data(self):\\n layers, layers_fnames = [], []\\n # TODO: add multiprocessing\\n for i in range(len(self.infiles)):\\n fname = self.infiles[i]\\n self.logger.info(\\n \\\"#Loading file: {} {}\\\".format(fname, \\\"(text file)\\\" if pathlib.Path(fname).suffix == \\\"\\\" else \\\"\\\"))\\n\\n # load text file\\n data = load_data_text(file_path=fname, sample_names=self.sn, feature_names=self.fn, drop_features=self.df,\\n drop_samples=self.ds)\\n layers.append(data)\\n layers_fnames.append(fname)\\n\\n return list(zip(layers_fnames, layers))\",\n \"def _read_one_file(file_name, label_list):\\n lines = tf.io.gfile.GFile(file_name, \\\"r\\\").readlines()\\n examples = []\\n label_id_map = {label: i for i, label in enumerate(label_list)}\\n sentence_id = 0\\n example = InputExample(sentence_id=0)\\n for line in lines:\\n line = line.strip(\\\"\\\\n\\\")\\n if line:\\n # The format is: <token>\\\\t<label> for train/dev set and <token> for test.\\n items = line.split(\\\"\\\\t\\\")\\n assert len(items) == 2 or len(items) == 1\\n token = items[0].strip()\\n\\n # Assign a dummy label_id for test set\\n label_id = label_id_map[items[1].strip()] if len(items) == 2 else 0\\n example.add_word_and_label_id(token, label_id)\\n else:\\n # Empty line indicates a new sentence.\\n if example.words:\\n examples.append(example)\\n sentence_id += 1\\n example = InputExample(sentence_id=sentence_id)\\n\\n if example.words:\\n examples.append(example)\\n return examples\",\n \"def load_batch(batch, feat_list, device='cpu'):\\n batch_feat_list = []\\n for hop_feat_list in feat_list:\\n batch_feats = [feat[batch] for feat in hop_feat_list]\\n batch_feat_list.append(batch_feats)\\n\\n batch_feat_list = [torch.stack(feat) for feat in batch_feat_list]\\n batch_feats = torch.cat(batch_feat_list, dim=0)\\n # if len(batch_feats.shape) == 2:\\n # batch_feats = batch_feats.unsqueeze(1)\\n\\n return batch_feats.to(device)\",\n \"def __init__(self, data_path):\\r\\n\\t\\tfile_names = ['data_batch_%d' % i for i in range(1,6)]\\r\\n\\t\\tfile_names.append('test_batch')\\r\\n\\r\\n\\t\\tX = []\\r\\n\\t\\ty = []\\r\\n\\t\\tfor file_name in file_names:\\r\\n\\t\\t\\twith open(data_path + file_name) as fin:\\r\\n\\t\\t\\t\\tdata_dict = cPickle.load(fin)\\r\\n\\t\\t\\tX.append(data_dict['data'].ravel())\\r\\n\\t\\t\\ty = y + data_dict['labels']\\r\\n\\r\\n\\t\\tself.X = np.asarray(X).reshape(60000, 32*32*3)\\r\\n\\t\\tself.y = np.asarray(y)\\r\\n\\r\\n\\t\\tfin = open(data_path + 'batches.meta')\\r\\n\\t\\tself.LABEL_NAMES = cPickle.load(fin)['label_names']\\r\\n\\t\\tfin.close()\",\n \"def load_training_data(list_files):\\n training_data = []\\n for tr_file in list_files:\\n with open(os.path.join(\\\"data\\\", tr_file)) as csv_file:\\n reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n next(reader)\\n for row in reader:\\n training_data.append(row[1])\\n return training_data\",\n \"def load_data():\\n # Load and preprocess data\\n sentences, labels = load_data_and_labels()\\n sentences_padded = pad_sentences(sentences)\\n vocabulary, vocabulary_inv = build_vocab(sentences_padded)\\n x, y = build_input_data(sentences_padded, labels, vocabulary)\\n return [x, y, vocabulary, vocabulary_inv]\",\n \"def load_training(file_name, target_val, training_data, training_targets, \\n elements):\\n\\n file = open(file_name, \\\"r\\\")\\n\\n # Iterate over file until empty line recieved\\n while True:\\n chunk = file.readline()\\n\\n if(chunk == ''):\\n break\\n\\n ret = load_chunk(chunk, elements)\\n\\n training_targets.append(target_val)\\n\\n # Convert data to frequency domain using fft()\\n training_data.append([i.real for i in fft(ret)])\",\n \"def load_dataset(filepath):\\n \\n X = list()\\n x = list()\\n\\n Y = list()\\n y = list()\\n \\n for line in open(filepath):\\n # blank lines separate sequences\\n if len(line) <= 1:\\n X.append(x)\\n Y.append(y)\\n\\n x = list()\\n y = list()\\n else:\\n a, b = line.strip().split('\\\\t')\\n x.append(a)\\n y.append(b)\\n \\n return X, Y\",\n \"def load_input(input_name):\\n with open(input_name) as input_file:\\n input_list = list(map(int,input_file.readline().split(\\\",\\\")))\\n return input_list\",\n \"def load_dataset(self):\\n # Get all the files in the directory\\n file_list = self.get_file_list()\\n\\n # Concatenate the data corresponding to a list of files\\n data = self.concatenate_file_data(file_list)\\n\\n # Shuffle the data and create the training and the validation datasets\\n data = self.shuffle_data_dictionary(data)\\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)\",\n \"def load_preprocess_training_batch(batch_id, batch_size):\\r\\n filename = 'preprocess_batch_' + str(batch_id) + '.p'\\r\\n features, labels = pickle.load(open(filename, mode='rb'))\\r\\n\\r\\n # Return the training data in batches of size <batch_size> or less\\r\\n return batch_features_labels(features, labels, batch_size)\",\n \"def load_preprocess_training_batch(batch_id, batch_size):\\r\\n filename = 'preprocess_batch_' + str(batch_id) + '.p'\\r\\n features, labels = pickle.load(open(filename, mode='rb'))\\r\\n# labels = np.argmax(labels,1)\\r\\n# num = len(labels)\\r\\n# arr = np.zeros((num, 1))\\r\\n# for i in range(num):\\r\\n# arr[i][0] = labels[i]\\r\\n# np.reshape(features,(2500,150528))\\r\\n# ind = [i for i in range(len(features))]\\r\\n# random.shuffle(ind)\\r\\n# features = features[ind]\\r\\n# labels = labels[ind]\\r\\n\\r\\n # Return the training data in batches of size <batch_size> or less\\r\\n return features[0:batch_size],labels[0:batch_size]\",\n \"def read_input_files(input_file: str) -> list[Food]:\\n with open(input_file) as input_fobj:\\n foods = [Food.from_raw(line.strip()) for line in input_fobj]\\n return foods\",\n \"def make_batch(self, batch_size):\\n filenames = self.get_filenames()\\n\\n if os.path.isdir(filenames):\\n num_records = len(os.listdir(filenames))\\n print(\\\"Loading from directory. \\\" + str(num_records) + \\\" tfRecords found.\\\")\\n files = tf.data.Dataset.list_files(filenames + \\\"/\\\" + \\\"*.tfrecord\\\").shuffle(num_records)\\n dataset = files.apply(\\n tf.contrib.data.parallel_interleave(\\n lambda x: tf.data.TFRecordDataset(x, num_parallel_reads=256, buffer_size=8*1024*1024),\\n cycle_length=32, sloppy=True)\\n )\\n else:\\n print(\\\"Loading from single tfRecord...\\\")\\n dataset = tf.data.TFRecordDataset(filenames + \\\".tfrecord\\\").repeat()\\n \\n dataset = dataset.map(self.parser, num_parallel_calls=128)\\n \\n if self.subset == 'train':\\n min_queue_examples = int(\\n Cifar10DataSet.num_examples_per_epoch(self.subset) * 0.4)\\n # Ensure that the capacity is sufficiently large to provide good random\\n # shuffling.\\n dataset = dataset.shuffle(buffer_size=min_queue_examples + 3 * batch_size)\\n \\n dataset = dataset.apply(tf.contrib.data.batch_and_drop_remainder(batch_size))\\n dataset = dataset.prefetch(10)\\n \\n iterator = dataset.make_one_shot_iterator()\\n seq_batch, input_batch, map_batch, transformation_batch = iterator.get_next()\\n\\n return seq_batch, input_batch, map_batch, transformation_batch\",\n \"def _load_cifar_batch(fpath, label_key='labels'):\\n if isinstance(fpath, (os.PathLike, str, bytes)):\\n with open(fpath, 'rb') as f:\\n return _load_cifar_batch(f, label_key)\\n\\n d = pickle.load(fpath, encoding='bytes')\\n # decode utf8\\n d_decoded = {}\\n for k, v in d.items():\\n d_decoded[k.decode('utf8')] = v\\n d = d_decoded\\n data = d['data']\\n labels = d[label_key]\\n\\n data = data.reshape(data.shape[0], 3, 32, 32).transpose([0, 2, 3, 1])\\n return data, labels\",\n \"def data_batch(self, batch_size, input_size, seed=None):\\n listing = self.listing\\n if seed:\\n listing, _ = train_test_split(self.listing, random_state=seed, test_size=0.25)\\n image_list = [item + '_orig.jpg' for item in listing]\\n label_list = [item + '_contour.png' for item in listing]\\n image_files, label_files = tf.convert_to_tensor(image_list), tf.convert_to_tensor(label_list)\\n queue = tf.train.slice_input_producer([image_files, label_files],\\n shuffle=True)\\n img_contents = tf.read_file(queue[0])\\n label_contents = tf.read_file(queue[1])\\n image = tf.image.decode_jpeg(img_contents, channels=3)\\n label = tf.image.decode_png(label_contents, channels=1)\\n image, label = default_image_prep(image, label, input_size)\\n return tf.train.batch([image, label],\\n batch_size=batch_size)\",\n \"def inputs(data_dir, batch_size,num_data_files=FLAGS.num_data_files):\\n\\n \\n filenames = [os.path.join(data_dir, 'fc6pool4mask_batch_%d' % i)\\n for i in xrange(1,num_data_files+1)]\\n for f in filenames:\\n if not tf.gfile.Exists(f):\\n raise ValueError('Failed to find file: ' + f)\\n\\n\\n\\n # Create a queue that produces the filenames to read.\\n filename_queue = tf.train.string_input_producer(filenames)\\n\\n # Read examples from files in the filename queue.\\n read_input = read_record(filename_queue)\\n\\n # Subtract off the mean and divide by the variance of the pixels??\\n \\n # Ensure that the random shuffling has good mixing properties.\\n min_fraction_of_examples_in_queue = 0.1\\n min_queue_examples = int(NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN *\\n min_fraction_of_examples_in_queue)\\n\\n #print(min_queue_examples)\\n print ('Filling queue with %d bottlenecked inputs before starting to train. '\\n 'This will take a few minutes.' % min_queue_examples)\\n\\n # Generate a batch of images and labels by building up a queue of examples.\\n return _generate_bottlenecked_batch(read_input.fc6, read_input.pool,read_input.mask,\\n min_queue_examples, batch_size,\\n shuffle=True)\",\n \"def load_dataset(path, test_or_train):\\n senta_batch, sentb_batch, scores_batch = [], [], []\\n with open(path, encoding='utf-8') as f:\\n for i, line in enumerate(f):\\n items = line.strip().split('\\\\t')\\n if test_or_train == 'train':\\n senta, sentb, score = items[-2], items[-1], float(items[-3])\\n elif test_or_train in ['dev', 'test']:\\n senta, sentb, score = items[-2], items[-1], float(items[-3])\\n else:\\n raise Exception(\\\"{} error\\\".format(test_or_train))\\n senta_batch.append(senta)\\n sentb_batch.append(sentb)\\n scores_batch.append(score)\\n return senta_batch, sentb_batch, scores_batch\",\n \"def load_batch(self, fpath, match, in_num):\\n if in_num == None:\\n in_num = input('Please specify IN number: ')\\n\\n if match == None:\\n match = input('Please specify filename string to match for batch loading (ex. \\\\'_s2_\\\\'): ')\\n\\n # get a list of all matching files\\n glob_match = f'{fpath}/*{match}*'\\n files = glob.glob(glob_match)\\n\\n # load & concatenate files into a single dataframe\\n data = pd.concat((pd.read_csv(file, header = [0, 1], index_col = 0, parse_dates=True, low_memory=False) for file in files)).sort_index()\\n\\n # extract sampling frequency\\n s_freq = 1/(data.index[1] - data.index[0]).total_seconds()\\n\\n # reset the index to continuous time\\n ind_freq = str(int(1/s_freq*1000000))+'us'\\n ind_start = '1900-01-01 00:00:00.000'\\n ind = pd.date_range(start = ind_start, periods=len(data), freq=ind_freq)\\n data.index = ind\\n\\n # set metadata & attributes\\n self.metadata = {'file_info':{'in_num': in_num, 'files': files, 'dir': fpath,\\n 'match_phrase': match},\\n 'analysis_info':{'s_freq': s_freq} }\\n self.data = data\\n self.s_freq = s_freq\",\n \"def load_data():\\n with open('../data/dataset.txt', 'r') as data_file:\\n return data_file.read().split('\\\\n')\",\n \"def read_group_batches(filename):\\n l = []\\n try:\\n with open(filename) as f:\\n for line in f:\\n elements = line.rstrip('\\\\n').split('\\\\t')\\n batchname = elements[0]\\n batchgroup = int(elements[1])\\n # Check if there is a nested list with index of the batchgroup\\n if len(l)-1 < batchgroup:\\n l.append([])\\n l[batchgroup].append(batchname)\\n except IOError as e:\\n print(e)\\n return l\",\n \"def generator_input(filenames, chunk_size, batch_size=64):\\n\\n feature_cols = None\\n while True:\\n input_reader = pd.read_csv(\\n tf.gfile.Open(filenames[0]),\\n names=CSV_COLUMNS,\\n chunksize=chunk_size,\\n na_values=' ?')\\n\\n for input_data in input_reader:\\n input_data = input_data.dropna()\\n # Pop off all of the columns we want to predict and concatenate them\\n labels = pd.concat([input_data.pop(x) for x in LABEL_COLUMNS], 1)\\n\\n input_data = to_numeric_features(input_data, feature_cols)\\n\\n # Retains schema for next chunk processing.\\n if feature_cols is None:\\n feature_cols = input_data.columns\\n\\n idx_len = input_data.shape[0]\\n for index in range(0, idx_len, batch_size):\\n yield (input_data.iloc[index:min(idx_len, index + batch_size)],\\n labels.iloc[index:min(idx_len, index + batch_size)])\",\n \"def load_nli_file(data_path, num_par=2):\\n tokenizer = tokenization.NltkTokenizer()\\n dataset = tf.data.TextLineDataset(data_path)\\n dataset = dataset.map(\\n functools.partial(_nli_line_to_tensors, tokenizer=tokenizer),\\n num_parallel_calls=num_par)\\n dataset = dataset.filter(lambda x: tf.greater_equal(x[\\\"label\\\"], 0))\\n return dataset\",\n \"def split_and_load(batch_data, num_gpus):\\n return [batch_data[i].data[0] for i in range(num_gpus)], \\\\\\n [batch_data[i].label[0].as_in_context(mx.gpu(i)) for i in range(num_gpus)]\",\n \"def load_batch(filename: str) -> Tuple[ndarray, ndarray, ndarray]:\\n dataDict = unpickle(filename)\\n print(\\\"1\\\", dataDict[b\\\"data\\\"][1, :])\\n X = (dataDict[b\\\"data\\\"] / 255).T\\n print(\\\"2\\\", X[:, 1])\\n y = np.array(dataDict[b\\\"labels\\\"])\\n Y = np.eye(10)[y].T\\n return X, Y, y\",\n \"def input_fn(data_file, num_epochs, shuffle, batch_size):\\n assert tf.gfile.Exists(data_file), (\\n '%s not found. Please make sure you have either run data_download.py or '\\n 'set both arguments --train_data and --test_data.' % data_file)\\n\\n def parse_csv(value): \\n print('Parsing', data_file)\\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\\n features = dict(zip(_CSV_COLUMNS, columns))\\n labels = features.pop('labels')\\n return features, tf.equal(labels, 'TRUE')\\n \\n\\n # Extract lines from input files using the Dataset API.\\n dataset = tf.data.TextLineDataset(data_file)\\n\\n if shuffle:\\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\\n\\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\\n\\n # We call repeat after shuffling, rather than before, to prevent separate\\n # epochs from blending together.\\n dataset = dataset.repeat(num_epochs)\\n dataset = dataset.batch(batch_size)\\n\\n iterator = dataset.make_one_shot_iterator()\\n features, labels = iterator.get_next()\\n return features, labels\",\n \"def input_fn(data_file, batch_size):\\n assert tf.gfile.Exists(data_file), (\\n '%s not found. Please make sure you have set both arguments --train_data and --test_data.' % data_file)\\n\\n def parse(serialized_example):\\n context_feature = {'label': tf.FixedLenFeature([], dtype=tf.int64)}\\n sequence_features = {\\n \\\"week_list\\\": tf.FixedLenSequenceFeature([], dtype=tf.string),\\n 'week_weight': tf.FixedLenSequenceFeature([], dtype=tf.float32)}\\n context_parsed, sequence_parsed = tf.parse_single_sequence_example(\\n serialized=serialized_example,\\n context_features=context_feature,\\n sequence_features=sequence_features)\\n labels = context_parsed['label']\\n week_list = sequence_parsed['week_list']\\n week_weight = sequence_parsed['week_weight']\\n return labels, week_list, week_weight\\n\\n def form_features(*line):\\n cols = ['label', 'week_list', 'week_weight']\\n features = dict(zip(cols, line))\\n label = features.pop('label')\\n return features, label\\n\\n dataset = tf.data.TFRecordDataset(data_file) \\\\\\n .map(parse) \\\\\\n .padded_batch(batch_size, ([1], [7], [7])) \\\\\\n .map(form_features)\\n iterator = dataset.make_one_shot_iterator()\\n features, labels = iterator.get_next()\\n return features, labels\",\n \"def data_loader(\\n self, batch_size: int = 1, iter_steps: int = 0, batch_as_list: bool = True\\n ) -> DataLoader:\\n data = self.data\\n datasets = []\\n\\n for _, dat in data.items():\\n datasets.append(dat.dataset())\\n\\n if len(datasets) < 1:\\n raise FileNotFoundError(\\n \\\"no datasets available for this model to create a loader from\\\"\\n )\\n\\n return DataLoader(\\n *datasets,\\n batch_size=batch_size,\\n iter_steps=iter_steps,\\n batch_as_list=batch_as_list,\\n )\",\n \"def load_input(self, file_name):\\n with open(file_name, \\\"r\\\") as in_file:\\n self.all_lines = [line.rstrip('\\\\n') for line in in_file]\",\n \"def load_all(cls, data):\\n return [cls.load(obj) for obj in data]\",\n \"def input_fn(data_file, num_epochs, shuffle, batch_size):\\n assert tf.gfile.Exists(data_file), (\\n '%s not found. Please make sure you have either run data_download.py or '\\n 'set both arguments --train_data and --test_data.' % data_file)\\n\\n def parse_csv(value):\\n print('Parsing', data_file)\\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\\n features = dict(zip(_CSV_COLUMNS, columns))\\n labels = features.pop('income_bracket')\\n return features, tf.equal(labels, '>50K')\\n\\n # Extract lines from input files using the Dataset API.\\n dataset = tf.data.TextLineDataset(data_file)\\n\\n if shuffle:\\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\\n\\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\\n\\n # We call repeat after shuffling, rather than before, to prevent separate\\n # epochs from blending together.\\n dataset = dataset.repeat(num_epochs)\\n dataset = dataset.batch(batch_size)\\n\\n iterator = dataset.make_one_shot_iterator()\\n features, labels = iterator.get_next()\\n return features, labels\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n # all_files = tf.gfile.Glob(os.path.join(input_dir, '*.png'))\\n # test_files = [all_files[idx] for x in np.random.choice(len(all_files), 200, replace=False)]\\n # for filepath in test_files:\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n with tf.gfile.Open(filepath) as f:\\n image = imread(f, mode='RGB').astype(np.float) / 255.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx, :, :, :] = image * 2.0 - 1.0\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_data(batch_size=batch_size):\\n trainset = LibriSpeechDataset(training_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds))\\n testset = LibriSpeechDataset(validation_set, int(LIBRISPEECH_SAMPLING_RATE * n_seconds), stochastic=False)\\n\\n train_loader = DataLoader(trainset, batch_size=batch_size, num_workers=1, shuffle=True, drop_last=True)\\n test_loader = DataLoader(testset, batch_size=1, num_workers=1, drop_last=True)\\n\\n return train_loader, test_loader\",\n \"def input_fn():\\n bos_id = tf.constant(BOS_ID, tf.int32)\\n eos_id = tf.constant(EOS_ID, tf.int32)\\n\\n # For training, we want a lot of parallel reading and shuffling.\\n # For eval, we want no shuffling and parallel reading doesn't matter.\\n d = tf.data.TFRecordDataset(input_files)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.map(lambda record: _decode_record(record, name_to_features))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\\n tf.concat([tgt_ids, [eos_id]], 0),\\n label))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n src_ids[:FLAGS.max_sequence_length],\\n tgt_ids[:FLAGS.max_sequence_length],\\n label\\n ))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([src_ids, tgt_ids], 0),\\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\\n label\\n ))\\n\\n d = d.map(lambda input_ids, segment_ids, label_ids: (\\n input_ids,\\n segment_ids,\\n tf.ones_like(input_ids),\\n label_ids\\n ))\\n\\n def batching_func(x):\\n return x.padded_batch(\\n batch_size,\\n # The entry is the source line rows;\\n # this has unknown-length vectors. The last entry is\\n # the source row size; this is a scalar.\\n padded_shapes=(\\n tf.TensorShape([None]), # src\\n tf.TensorShape([None]), # tgt\\n tf.TensorShape([None]),\\n tf.TensorShape([])), # src_len\\n # Pad the source sequences with eos tokens.\\n # (Though notice we don't generally need to do this since\\n # later on we will be masking out calculations past the true sequence.\\n padding_values=(\\n PAD_ID, # src\\n PAD_ID,\\n PAD_ID,\\n 0)) # src_len -- unused\\n\\n batched_dataset = batching_func(d)\\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\\n {\\n \\\"input_ids\\\": input_ids,\\n \\\"segment_ids\\\": segment_ids,\\n \\\"input_mask\\\": input_mask,\\n \\\"label_ids\\\": label\\n\\n })\\n\\n return features\",\n \"def load_CIFAR_batch(filename):\\r\\n with open(filename, 'rb') as f:\\r\\n datadict = load_pickle(f)\\r\\n X = datadict['data']\\r\\n Y = datadict['labels']\\r\\n X = X.reshape(10000,3072)\\r\\n Y = np.array(Y)\\r\\n return X, Y\",\n \"def load_batch(dataset, batch_size=32, height=299, width=299, is_training=False):\\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\\n dataset, common_queue_capacity=32,\\n common_queue_min=8)\\n image_raw, label = data_provider.get(['image', 'label'])\\n\\n # Preprocess image for usage by Inception.\\n image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\\n\\n # Preprocess the image for display purposes.\\n image_raw = tf.expand_dims(image_raw, 0)\\n image_raw = tf.image.resize_images(image_raw, [height, width])\\n image_raw = tf.squeeze(image_raw)\\n\\n # Batch it up.\\n images, images_raw, labels = tf.train.batch(\\n [image, image_raw, label],\\n batch_size=batch_size,\\n num_threads=1,\\n capacity=2 * batch_size)\\n\\n return images, images_raw, labels\",\n \"def load_training_data(file_path):\\n return load_data(file_path)\",\n \"def load_batch(dataset, batch_size=32, height=299, width=299, is_training=False):\\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\\n dataset, common_queue_capacity=32,\\n common_queue_min=8)\\n image_raw, label = data_provider.get(['image', 'label'])\\n \\n # Preprocess image for usage by Inception.\\n image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\\n \\n # Preprocess the image for display purposes.\\n image_raw = tf.expand_dims(image_raw, 0)\\n image_raw = tf.image.resize_images(image_raw, [height, width])\\n image_raw = tf.squeeze(image_raw)\\n\\n # Batch it up.\\n images, images_raw, labels = tf.train.batch(\\n [image, image_raw, label],\\n batch_size=batch_size,\\n num_threads=1,\\n capacity=2 * batch_size)\\n \\n return images, images_raw, labels\",\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def load_CIFAR_batch(filename):\\n with open(filename, 'rb') as f:\\n datadict = load_pickle(f)\\n X = datadict['data']\\n Y = datadict['labels']\\n X = X.reshape(10000,3072)\\n Y = np.array(Y)\\n return X, Y\",\n \"def load_dataset(input_path):\\n with open(input_path, \\\"r\\\") as f:\\n smiles_list = f.read().strip().split(\\\"\\\\n\\\")\\n return smiles_list\",\n \"def load_batch(dataset, batch_size=32, height=224, width=224, is_training=False):\\n data_provider = slim.dataset_data_provider.DatasetDataProvider(\\n dataset, common_queue_capacity=32,\\n common_queue_min=8)\\n image_raw, label = data_provider.get(['image', 'label'])\\n\\n # Preprocess image for usage by Inception.\\n # image = inception_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\\n image = no_preprocessing.preprocess_image(image_raw, height, width, is_training=is_training)\\n\\n # Preprocess the image for display purposes.\\n image_raw = tf.expand_dims(image_raw, 0)\\n image_raw = tf.image.resize_images(image_raw, [height, width])\\n image_raw = tf.squeeze(image_raw)\\n\\n # Batch it up.\\n images, images_raw, labels = tf.train.batch(\\n [image, image_raw, label],\\n batch_size=batch_size,\\n num_threads=1,\\n capacity=2 * batch_size)\\n\\n return images, images_raw, labels\",\n \"def load_dataset(path):\\n training_data = []\\n with open(path) as csv_file:\\n reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n next(reader)\\n for row in reader:\\n training_data.append(row[1])\\n return training_data\",\n \"def input_fn():\\n files = tf.data.Dataset.list_files(os.path.join(\\n tft_working_dir, filebase + '*'))\\n dataset = files.interleave(\\n tf.data.TFRecordDataset, cycle_length=4, block_length=16)\\n dataset = dataset.map(parser)\\n\\n if shuffle:\\n dataset = dataset.shuffle(buffer_size)\\n\\n dataset = dataset.repeat(num_epochs)\\n dataset = dataset.batch(batch_size)\\n\\n dataset = dataset.prefetch(prefetch_buffer_size)\\n iterator = dataset.make_one_shot_iterator()\\n transformed_features, transformed_labels = iterator.get_next()\\n\\n return transformed_features, transformed_labels\",\n \"def input_fn(data_file, num_epochs, shuffle, batch_size):\\n assert tf.gfile.Exists(data_file), (\\n '%s not found. Please make sure you have either run data_download.py or '\\n 'set both arguments --train_data and --test_data.' % data_file)\\n\\n def parse_csv(value):\\n print('Parsing', data_file)\\n columns = tf.decode_csv(value, record_defaults=_CSV_COLUMN_DEFAULTS)\\n features = dict(zip(_CSV_COLUMNS, columns))\\n\\n labels = features.pop('price')\\n return features, tf.equal(labels, '>1000')\\n\\n # Extract lines from input files using the Dataset API.\\n\\n dataset = tf.data.TextLineDataset(data_file)\\n\\n if shuffle:\\n dataset = dataset.shuffle(buffer_size=_NUM_EXAMPLES['train'])\\n\\n dataset = dataset.map(parse_csv, num_parallel_calls=5)\\n\\n # We call repeat after shuffling, rather than before, to prevent separate\\n # epochs from blending together.\\n dataset = dataset.repeat(num_epochs)\\n dataset = dataset.batch(batch_size)\\n return dataset\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n with tf.gfile.Open(filepath) as f:\\n image = np.array(Image.open(f).convert('RGB')).astype(np.float) / 1.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx, :, :, :] = image\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_CIFAR10(path):\\r\\n sampleList = []\\r\\n labelList = []\\r\\n # load all the data, as there only five training samples name as data_batch_id\\r\\n for i in range(1, 6):\\r\\n # get full filename\\r\\n filename = os.path.join(path, 'data_batch_%d' % (i, ))\\r\\n x, y = load_CIFAR_batch(filename)\\r\\n\\r\\n sampleList.append(x)\\r\\n labelList.append(y)\\r\\n\\r\\n # combine elements as one array\\r\\n Xtr = np.concatenate(sampleList)\\r\\n Ytr = np.concatenate(labelList)\\r\\n del x, y\\r\\n print(\\\"Training data loaded, total size : %d\\\", len(Xtr))\\r\\n # load test data\\r\\n Xte, Yte = load_CIFAR_batch(os.path.join(path, 'test_batch'))\\r\\n return Xtr, Ytr, Xte, Yte\",\n \"def load_train_batch(self):\\n def _parse_train_img(img_path):\\n with tf.device('/cpu:0'):\\n img_buffer = tf.read_file(img_path)\\n image_decoded = tf.image.decode_jpeg(img_buffer)\\n tgt_image, src_image_stack = \\\\\\n self.unpack_image_sequence(\\n image_decoded, self.img_height, self.img_width, self.num_source)\\n return tgt_image, src_image_stack\\n\\n def _batch_preprocessing(stack_images, intrinsics, optional_data):\\n intrinsics = tf.cast(intrinsics, tf.float32)\\n image_all = tf.concat([stack_images[0], stack_images[1]], axis=3)\\n\\n if self.match_num == 0: # otherwise matches coords are wrong\\n image_all, intrinsics = self.data_augmentation(\\n image_all, intrinsics, self.img_height, self.img_width)\\n tgt_image = image_all[:, :, :, :3]\\n src_image_stack = image_all[:, :, :, 3:]\\n intrinsics = self.get_multi_scale_intrinsics(intrinsics, self.num_scales)\\n return tgt_image, src_image_stack, intrinsics, optional_data\\n\\n file_list = self.format_file_list(self.dataset_dir, 'train')\\n self.steps_per_epoch = int(len(file_list['image_file_list'])//self.batch_size)\\n\\n input_image_names_ph = tf.placeholder(tf.string, shape=[None], name='input_image_names_ph')\\n image_dataset = tf.data.Dataset.from_tensor_slices(\\n input_image_names_ph).map(_parse_train_img)\\n\\n cam_intrinsics_ph = tf.placeholder(tf.float32, [None, 3, 3], name='cam_intrinsics_ph')\\n intrinsics_dataset = tf.data.Dataset.from_tensor_slices(cam_intrinsics_ph)\\n\\n datasets = (image_dataset, intrinsics_dataset, intrinsics_dataset)\\n if self.read_pose:\\n poses_ph = tf.placeholder(tf.float32, [None, self.num_source+1, 6], name='poses_ph')\\n pose_dataset = tf.data.Dataset.from_tensor_slices(poses_ph)\\n datasets = (image_dataset, intrinsics_dataset, pose_dataset)\\n if self.match_num > 0:\\n matches_ph = tf.placeholder(tf.float32, [None, self.num_source, self.match_num, 4], name='matches_ph')\\n match_dataset = tf.data.Dataset.from_tensor_slices(matches_ph)\\n datasets = (image_dataset, intrinsics_dataset, match_dataset)\\n\\n all_dataset = tf.data.Dataset.zip(datasets)\\n all_dataset = all_dataset.batch(self.batch_size).repeat().prefetch(self.batch_size*4)\\n all_dataset = all_dataset.map(_batch_preprocessing)\\n iterator = all_dataset.make_initializable_iterator()\\n return iterator\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n with tf.gfile.Open(filepath) as f:\\n image = np.array(Image.open(f).convert('RGB')).astype(np.float) / 255.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx] = image * 2.0 - 1.0\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_data(path_dataset):\\n data = read_txt(path_dataset)[1:]\\n return preprocess_data(data)\",\n \"def get_train_batches(data_dir='/home/yunhan/batchified'):\\n # todo: read in data that is preoprocessed\\n # Use batch 1 - 52 as train (60%), 53 - 71 as validation (20%), 72 - 89 as test (20%)\\n n = 53\\n idx = np.random.permutation(n)\\n idx = idx + 1\\n for i in range(n):\\n X = np.load(\\\"%s/X%d.npy\\\" % (data_dir, idx[i]))/255.\\n Y = np.load(\\\"%s/y%d.npy\\\" % (data_dir, idx[i])).reshape(-1)\\n yield X, Y\",\n \"def load_input(file_name, elements):\\n\\n input_file = open(file_name)\\n input_data = []\\n\\n while True:\\n chunk = input_file.readline()\\n\\n if(chunk == ''):\\n break\\n \\n ret = load_chunk(chunk, elements)\\n\\n # Convert data to frequency domain using fft()\\n input_data.append([i.real for i in fft(ret)])\\n\\n return input_data\",\n \"def load_dataset(fname, nb_lines):\\n import os.path\\n if os.path.isfile('safe/Amazon-'+str(nb_lines)+'.p'):\\n return util.load('safe/Amazon-'+str(nb_lines)+'.p')\\n count = 1\\n X = []\\n y = []\\n with open(fname) as f:\\n for line in f:\\n text, label = read_line(line)\\n #print((label, text))\\n X.append(text)\\n y.append(label)\\n if count >= nb_lines:\\n break\\n count+=1\\n\\n #load pretrained dictonary\\n dico = util.load('safe/vocab_gensim.p')\\n preprocessor = text_preprocessing.Preprocessor(dico=dico)\\n X = preprocessor.preprocess(X)\\n #save the loaded dataset in a pickle for speeding up next run\\n util.save((X,y), 'safe/Amazon-'+str(nb_lines)+'.p')\\n return (X, y)\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n with tf.gfile.Open(filepath) as f:\\n image = imread(f, mode='RGB').astype(np.float) / 255.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx] = image * 2.0 - 1.0\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_datasets(filepath):\\n\\n data_file = open(filepath, 'r')\\n data_list = data_file.readlines()\\n data_file.close()\\n\\n return data_list\",\n \"def load_data(self):\\n with open(self.file_name) as f:\\n lines = f.readlines()\\n\\n labels = list()\\n all_dat = list()\\n for i, l in enumerate(lines):\\n\\n labels.append(int(l[0]))\\n\\n l = gensim.utils.any2unicode(l)\\n all_dat.append(LabeledSentence(l.split(\\\"\\\\t\\\")[-1], [i]))\\n\\n return all_dat, np.asarray(labels)\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n with tf.gfile.Open(filepath) as f:\\n image = imread(f, mode='RGB').astype(np.float) / 255.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx, :, :, :] = image * 2.0 - 1.0\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_cifa_10():\\n train_set_x = np.ndarray([ 50000, 3072 ])\\n train_set_y = np.ndarray( [50000] )\\n\\n batch_size = 10000\\n for i in xrange(5):\\n batch = open( datapath + \\\"data_batch_\\\"+str(i+1), 'rb')\\n map = cPickle.load( batch )\\n batch.close()\\n train_set_x[ i*batch_size : (i+1)*batch_size , : ] = np.asarray( map[ 'data' ], dtype = 'float32' )\\n train_set_y[ i*batch_size : (i+1)*batch_size ] = np.asarray( map[ 'labels' ], dtype = 'float32' )\\n\\n test_file = open( datapath + 'test_batch', 'rb')\\n map = cPickle.load( test_file )\\n test_file.close()\\n \\n test_set_x = np.asarray( map['data'], dtype = 'float32' )\\n test_set_y = np.asarray( map['labels'], dtype = 'float32' )\\n \\n\\n return train_set_x, train_set_y, test_set_x, test_set_y\",\n \"def load_CIFAR_batch(filename):\\n with open(filename, 'rb')as f:\\n # datadict = p.load(f)\\n datadict = pickle.load(f, encoding = 'bytes')\\n X = datadict[b'data']\\n Y = datadict[b'labels']\\n X = X.reshape(10000, 3, 32, 32)\\n Y = np.array(Y)\\n return X, Y\",\n \"def batch_data(cls, train_data, train_labels, batch_size):\\n for batch in range(int(np.ceil(train_data.shape[0] / batch_size))):\\n start = batch_size * batch\\n end = start + batch_size\\n if end > train_data.shape[0]:\\n yield batch, (train_data[start:train_data.shape[0]], \\\\\\n train_labels[start:train_data.shape[0]])\\n else:\\n yield batch, (train_data[start:end], \\\\\\n train_labels[start:end])\",\n \"def load_preprocess_test_batch(batch_id, batch_size):\\r\\n filename = 'preprocess_test_' + str(batch_id) + '.p'\\r\\n features, labels = pickle.load(open(filename, mode='rb'))\\r\\n# labels = np.argmax(labels,1)\\r\\n# num = len(labels)\\r\\n# arr = np.zeros((num, 1))\\r\\n# for i in range(num):\\r\\n# arr[i][0] = labels[i]\\r\\n# ind = [i for i in range(len(features))]\\r\\n# random.shuffle(ind)\\r\\n# features = features[ind]\\r\\n# labels = labels[ind]\\r\\n\\r\\n # Return the training data in batches of size <batch_size> or less\\r\\n return features[1200:batch_size],labels[1200:batch_size]\\r\\n #return batch_features_labels(features, labels, batch_size)\\r\",\n \"def parse_file(self, file_path) -> list:\\n data = []\\n with open(file_path, 'rb') as f:\\n lines = pickle.load(f)\\n for line in lines:\\n input, output = line\\n if input.strip() == \\\"\\\" or output.strip() == \\\"\\\":\\n continue\\n input_len = len(input.split())\\n output_len = len(output.split())\\n if input_len > 50 or output_len > 50:\\n continue\\n data_item = Text2TextDataItem(input_text=input, output_text=output, tokenizer=self.tokenizer,\\n share_vocab=self.share_vocab)\\n data.append(data_item)\\n return data\",\n \"def load_input(filepath: str) -> list:\\n lines = []\\n with open(filepath, \\\"r\\\", encoding=\\\"utf-8\\\") as file:\\n for line in file.readlines():\\n lines.append(line.strip())\\n return lines\",\n \"def load_CIFAR_batch(filename):\\r\\n with open(filename, 'rb')as f:\\r\\n datadict = p.load(f)\\r\\n \\r\\n X = datadict['data']\\r\\n Y = datadict['labels']\\r\\n \\r\\n print X.shape\\r\\n X = X.reshape(X.shape[0], SHAPE[0], SHAPE[1], SHAPE[2])\\r\\n Y = np.array(Y)\\r\\n return X, Y\",\n \"def _load_split_data(self, dataset_path):\\n for i, prefix in enumerate(['train', 'dev', 'test']):\\n filename = os.path.join(dataset_path, '{}.txt'.format(prefix))\\n knowledge, src, tgt = self._load_multi_data(filename)\\n self.group_text_data[0].append(knowledge)\\n self.group_text_data[1].append(src)\\n self.group_text_data[2].append(tgt)\",\n \"def batch_iter(input_data,batch_size):\\r\\n batch_ids,batch_mask,batch_segment,batch_label=[],[],[],[]\\r\\n for features in input_data:\\r\\n if len(batch_ids) == batch_size:\\r\\n yield batch_ids,batch_mask,batch_segment,batch_label\\r\\n batch_ids, batch_mask, batch_segment, batch_label = [], [], [], []\\r\\n\\r\\n batch_ids.append(features['input_ids'])\\r\\n batch_mask.append(features['input_mask'])\\r\\n batch_segment.append(features['segment_ids'])\\r\\n batch_label.append(features['label_ids'])\\r\\n\\r\\n if len(batch_ids) != 0:\\r\\n yield batch_ids, batch_mask, batch_segment, batch_label\",\n \"def load_images(input_dir, batch_shape):\\n images = np.zeros(batch_shape)\\n filenames = []\\n idx = 0\\n batch_size = batch_shape[0]\\n for filepath in tf.gfile.Glob(os.path.join(input_dir, '*.png')):\\n if(FLAGS.checkpoint_file_name==\\\"vgg_16.ckpt\\\")or(FLAGS.checkpoint_file_name==\\\"vgg_19.ckpt\\\")or(FLAGS.checkpoint_file_name==\\\"resnet_v1_50.ckpt\\\")or(FLAGS.checkpoint_file_name==\\\"resnet_v1_101.ckpt\\\")or(FLAGS.checkpoint_file_name==\\\"resnet_v1_152.ckpt\\\"):\\n with tf.gfile.Open(filepath) as f:\\n image = imread(f, mode='RGB').astype(np.float)\\n images[idx, :, :, :] = image\\n else:\\n with tf.gfile.Open(filepath) as f:\\n image = imread(f, mode='RGB').astype(np.float) / 255.0\\n # Images for inception classifier are normalized to be in [-1, 1] interval.\\n images[idx, :, :, :] = image * 2.0 - 1.0\\n filenames.append(os.path.basename(filepath))\\n idx += 1\\n if idx == batch_size:\\n yield filenames, images\\n filenames = []\\n images = np.zeros(batch_shape)\\n idx = 0\\n if idx > 0:\\n yield filenames, images\",\n \"def load_data(loc='../data/SICK/'):\\n trainA, trainB, testA, testB = [],[],[],[]\\n trainS, testS = [],[]\\n\\n with open(loc + 'SICK_train.txt', 'rb') as f:\\n for line in f:\\n text = line.strip().split('\\\\t')\\n trainA.append(text[1])\\n trainB.append(text[2])\\n trainS.append(text[3])\\n with open(loc + 'SICK_test_annotated.txt', 'rb') as f:\\n for line in f:\\n text = line.strip().split('\\\\t')\\n testA.append(text[1])\\n testB.append(text[2])\\n testS.append(text[3])\\n\\n trainS = [float(s) for s in trainS[1:]]\\n testS = [float(s) for s in testS[1:]]\\n\\n return [trainA[1:], trainB[1:]], [testA[1:], testB[1:]], [trainS, testS]\",\n \"def load_dataset(filenames, batch_size, corruption_func, crop_size):\\n cache = dict()\\n while True:\\n source_batch = np.zeros((batch_size, crop_size[0], crop_size[1], 1))\\n target_batch = np.zeros((batch_size, crop_size[0], crop_size[1], 1))\\n chosen_filenames = _read_images_and_put_in_dict(filenames,\\n cache,\\n batch_size)\\n for filename_idx in range(len(chosen_filenames)):\\n filename = chosen_filenames[filename_idx]\\n im = cache[filename]\\n patch = _get_random_patch_of_the_image(im, crop_size)\\n corrupted_im = corruption_func(patch)\\n source_batch[filename_idx, :, :, 0] = corrupted_im - 0.5\\n target_batch[filename_idx, :, :, 0] = patch - 0.5\\n yield source_batch, target_batch\",\n \"def load_training_data(config):\\n # Load data\\n LOGGER.info(\\\"Loading training data.\\\")\\n train_x = load_data(config['data_source'], config['train_x_filename'])\\n train_y = load_data(config['data_source'], config['train_y_filename'])\\n val_x = load_data(config['data_source'], config['val_x_filename'])\\n val_y = load_data(config['data_source'], config['val_y_filename'])\\n LOGGER.info(\\\"Training data size: %d\\\", len(train_x))\\n LOGGER.info(\\\"Validation data size: %d\\\", len(val_x))\\n\\n # Build datasets and create iterators\\n LOGGER.info(\\\"Building dataset.\\\")\\n train_dataset = get_dataset(\\n train_x, train_y, config['batch_size'], config['data_shape'],\\n config['n_classes'], True)\\n val_dataset = get_dataset(\\n val_x, val_y, config['batch_size'], config['data_shape'],\\n config['n_classes'])\\n\\n return train_dataset, val_dataset, len(val_x)\",\n \"def load_features(feature_path):\\n if not os.path.exists(os.path.join(feature_path, f\\\"0_features.npy\\\")): \\n raise ValueError(f\\\"The provided location {feature_path} does not contain any representation files\\\")\\n\\n ds_list, chunk_id = [], 0\\n while os.path.exists(os.path.join(feature_path, f\\\"{chunk_id}_features.npy\\\")): \\n features = ch.from_numpy(np.load(os.path.join(feature_path, f\\\"{chunk_id}_features.npy\\\"))).float()\\n labels = ch.from_numpy(np.load(os.path.join(feature_path, f\\\"{chunk_id}_labels.npy\\\"))).long()\\n ds_list.append(ch.utils.data.TensorDataset(features, labels))\\n chunk_id += 1\\n\\n print(f\\\"==> loaded {chunk_id} files of representations...\\\")\\n return ch.utils.data.ConcatDataset(ds_list)\",\n \"def load_CIFAR_batch(filename):\\r\\n with open(filename, 'rb') as f:\\r\\n datadict = pickle.load(f, encoding='latin1')\\r\\n X = datadict['data']\\r\\n Y = datadict['labels']\\r\\n X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype(\\\"float\\\")\\r\\n Y = np.array(Y)\\r\\n return X, Y\",\n \"def read_files(\\n self,\\n file_instructions: List[Dict],\\n num_examples_per_shard: List[int],\\n shuffle_files: bool,\\n ) -> DatasetType:\\n if not file_instructions:\\n raise AssertionError(f'Instruction {file_instructions} corresponds to no data')\\n\\n # Prepend path to filename\\n files = copy.deepcopy(file_instructions)\\n for f in files:\\n f.update(filename=os.path.join(self._path, f['filename']))\\n\\n if self._read_config.experimental_interleave_sort_fn is not None:\\n files = self._read_config.experimental_interleave_sort_fn(files)\\n\\n do_skip = any(f['skip'] > 0 for f in files)\\n do_take = any(f['take'] > -1 for f in files)\\n\\n tensor_inputs = {\\n k: list(vals) if k == 'filename' else np.array(vals, dtype=np.int64)\\n for k, vals in zip_dict(*files)\\n }\\n\\n instruction_ds = tf.data.Dataset.from_tensor_slices(tensor_inputs)\\n if shuffle_files:\\n instruction_ds = instruction_ds.shuffle(\\n len(tensor_inputs['filename']),\\n seed=self._read_config.seed,\\n reshuffle_each_iteration=self._read_config.shuffle_reshuffle_each_iteration,\\n )\\n\\n ds = instruction_ds.interleave(\\n partial(self._get_dataset_from_filename, do_skip=do_skip, do_take=do_take),\\n cycle_length=self._read_config.interleave_cycle_length,\\n block_length=self._read_config.interleave_block_length,\\n num_parallel_calls=tf.data.experimental.AUTOTUNE,\\n )\\n\\n if (num_examples_per_shard and hasattr(tf.data.experimental, 'assert_cardinality')):\\n cardinality = sum(num_examples_per_shard)\\n ds = ds.apply(tf.data.experimental.assert_cardinality(cardinality))\\n ds = ds.with_options(self._read_config.options)\\n return ds.map(self._parser.parse_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)\",\n \"def set_batch_data():\\r\\n if not os.path.exists(filepath):\\r\\n download_data()\\r\\n for n in range(0,6):\\r\\n d = read(filepath + flist[n])\\r\\n metadata = read(filepath + flist[-1])\\r\\n ndata = metadata['num_cases_per_batch']\\r\\n ndim = metadata['num_vis']\\r\\n\\r\\n data, trts = {}, {}\\r\\n data['labels'] = metadata['label_names']\\r\\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\\r\\n data['ntestdata'] = metadata['num_cases_per_batch']\\r\\n data['ndim'] = metadata['num_vis']\\r\\n trts['x'], trts['y'] = d['data'], d['labels']\\r\\n trtsflag = ['train', 'train', 'train', 'train', 'train', 'test']\\r\\n\\r\\n data['flag'] = trtsflag[n]\\r\\n data[trtsflag[n]] = trts\\r\\n save_pkl(data, savename=flist[n]+'.pkl')\",\n \"def load_array(data_arrays, batch_size, is_train=True):\\n dataset = data.TensorDataset(*data_arrays)\\n return data.DataLoader(dataset, batch_size, shuffle=is_train)\",\n \"def load_CIFAR_batch(filename):\\n with open(filename, 'rb')as f:\\n datadict = p.load(f, encoding='iso-8859-1')\\n X = datadict['data']\\n Y = datadict['labels']\\n X = X.reshape(10000, 3, 32, 32)\\n Y = np.array(Y)\\n return X, Y\",\n \"def _read_train_datas(self):\\r\\n with open(self.train_label_path, 'r') as fb:\\r\\n lines = fb.readlines()\\r\\n return self._parse_raw_labels(lines)\",\n \"def read_data(cls, input_file):\\n with tf.gfile.Open(input_file, \\\"r\\\") as f:\\n lines = []\\n for line in f:\\n line = line.strip()\\n if line.startswith('-DOCSTART-'):\\n continue\\n else:\\n word_labels = line.split('-seq-')\\n assert len(word_labels) == 2\\n\\n words = word_labels[0]\\n labels = word_labels[1]\\n lines.append([words, labels])\\n\\n return lines\",\n \"def load_CIFAR_batch(filename):\\n with open(filename, 'rb') as f:\\n datadict = pickle.load(f, encoding='latin1')\\n X = datadict['data']\\n Y = datadict['labels']\\n X = X.reshape(10000, 3, 32, 32).transpose(0, 2, 3, 1).astype(\\\"float64\\\")\\n Y = np.array(Y)\\n return X, Y\",\n \"def load_array(data_arrays, batch_size, is_train=True): #@save\\n dataset = tf.data.Dataset.from_tensor_slices(data_arrays)\\n if is_train:\\n dataset = dataset.shuffle(buffer_size=1000)\\n dataset = dataset.batch(batch_size)\\n return dataset\",\n \"def load_array(data_arrays, batch_size, is_train=True): #@save\\n dataset = tf.data.Dataset.from_tensor_slices(data_arrays)\\n if is_train:\\n dataset = dataset.shuffle(buffer_size=1000)\\n dataset = dataset.batch(batch_size)\\n return dataset\",\n \"def load_data(self, file_path):\\n \\n dataset = []\\n \\n for line in open(file_path):\\n arr = line.strip().split('\\\\t')\\n label = [w for w in arr[0].split(' ')]\\n sentence = [w for w in arr[1].split(' ')]\\n cname = ' '.join(label)\\n \\n # The line is useless if the class is\\n # not in the class dictionary.\\n if cname not in self.class_list:\\n raise Exception(\\\"{} not in class list.\\\".format(cname))\\n \\n # Build the sample dictionary.\\n sample = {}\\n sample['sentence_w2v'] = []\\n \\n for word in sentence:\\n if word not in self.w2v.vocab.keys():\\n continue # ignore sentence\\n \\n # In the loading embedding (see self.load_embedding()), we\\n # stack one additional layer of zeros in front to handle padding.\\n # Thus here we append the embedding index plus one.\\n sample['sentence_w2v'].append(torch.Tensor([self.w2v.vocab[word].index + 1]))\\n\\n sample['length'] = len(sample['sentence_w2v'])\\n sample['label_onehot'] = self.onehot(self.class_indices[cname])\\n sample['label_w2v'] = self.class_w2v[cname]\\n dataset.append(sample)\\n \\n return dataset\",\n \"def load_raw_data(self, input_files):\\n\\n log.debug(f\\\"Loading dataset {input_files}\\\") \\n print(f\\\"Loading dataset\\\")\\n\\n # Load stroke information from XML files\\n for file in input_files:\\n new_strokeset = strokeset.StrokeSet(file)\\n self.strokesets.append(new_strokeset)\\n self.stroke_matrix.append(new_strokeset.as_delta_array())\\n self.stroke_ascii.append(new_strokeset.get_text())\\n\\n done_msg = \\\"Finished parsing dataset. Imported {} lines\\\".format(len(self.get_strokesets()))\\n print (done_msg)\\n log.info(done_msg)\",\n \"def generateBatches(data, batch_size):\\n random.shuffle(data)\\n batches = []\\n size = len(data)\\n def loadBatches(data, total_size, batch_size_):\\n for i in range(0, total_size, batch_size_):\\n yield data[i:min(total_size, i + batch_size_)]\\n\\n for unprocessed_batch in loadBatches(data, size, batch_size):\\n processed_batch = processBatch(unprocessed_batch)\\n batches.append(processed_batch)\\n return batches\",\n \"def load_data_list(self):\\n\\n data = mat4py.loadmat(self.ann_file)['images']\\n names = data['name']\\n labels = data['class']\\n parts = data['set']\\n num = len(names)\\n assert num == len(labels) == len(parts), 'get error ann file'\\n\\n if self.split == 'train':\\n target_set = {1}\\n elif self.split == 'val':\\n target_set = {2}\\n elif self.split == 'test':\\n target_set = {3}\\n else:\\n target_set = {1, 2}\\n\\n data_list = []\\n for i in range(num):\\n if parts[i] in target_set:\\n img_name = names[i]\\n img_path = self.backend.join_path(self.img_prefix, img_name)\\n gt_label = labels[i] - 1\\n info = dict(img_path=img_path, gt_label=gt_label)\\n data_list.append(info)\\n\\n return data_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7116717","0.6971949","0.6867253","0.66187465","0.65909564","0.6522058","0.6507134","0.6502703","0.6472176","0.64224887","0.64197946","0.64197946","0.6409885","0.6405037","0.638099","0.6297901","0.62916416","0.6273321","0.6232164","0.6228044","0.62100035","0.619388","0.6192539","0.61876273","0.617474","0.61606276","0.61519134","0.61499006","0.61281717","0.6128039","0.61150753","0.6111708","0.6111542","0.61110896","0.61090493","0.61071134","0.6101637","0.6086956","0.60579926","0.6032005","0.6024992","0.6019548","0.6017373","0.6011465","0.6010065","0.60000634","0.5978645","0.596911","0.595964","0.5958455","0.59583694","0.59521914","0.595202","0.595202","0.595202","0.594958","0.59444404","0.5941284","0.59343547","0.59342116","0.59296846","0.59216154","0.59120494","0.5904878","0.59041274","0.59016997","0.59010535","0.5900086","0.58996344","0.58840376","0.58830106","0.58741426","0.58731467","0.5872644","0.5872463","0.5869319","0.5865742","0.58558446","0.585137","0.58511966","0.5842526","0.58325833","0.58243495","0.5822058","0.58119094","0.5810837","0.58093053","0.5808302","0.5805563","0.5805004","0.57928324","0.57900864","0.57870924","0.578546","0.57852185","0.57847345","0.57847345","0.5769793","0.5768504","0.5762122","0.5751444"],"string":"[\n \"0.7116717\",\n \"0.6971949\",\n \"0.6867253\",\n \"0.66187465\",\n \"0.65909564\",\n \"0.6522058\",\n \"0.6507134\",\n \"0.6502703\",\n \"0.6472176\",\n \"0.64224887\",\n \"0.64197946\",\n \"0.64197946\",\n \"0.6409885\",\n \"0.6405037\",\n \"0.638099\",\n \"0.6297901\",\n \"0.62916416\",\n \"0.6273321\",\n \"0.6232164\",\n \"0.6228044\",\n \"0.62100035\",\n \"0.619388\",\n \"0.6192539\",\n \"0.61876273\",\n \"0.617474\",\n \"0.61606276\",\n \"0.61519134\",\n \"0.61499006\",\n \"0.61281717\",\n \"0.6128039\",\n \"0.61150753\",\n \"0.6111708\",\n \"0.6111542\",\n \"0.61110896\",\n \"0.61090493\",\n \"0.61071134\",\n \"0.6101637\",\n \"0.6086956\",\n \"0.60579926\",\n \"0.6032005\",\n \"0.6024992\",\n \"0.6019548\",\n \"0.6017373\",\n \"0.6011465\",\n \"0.6010065\",\n \"0.60000634\",\n \"0.5978645\",\n \"0.596911\",\n \"0.595964\",\n \"0.5958455\",\n \"0.59583694\",\n \"0.59521914\",\n \"0.595202\",\n \"0.595202\",\n \"0.595202\",\n \"0.594958\",\n \"0.59444404\",\n \"0.5941284\",\n \"0.59343547\",\n \"0.59342116\",\n \"0.59296846\",\n \"0.59216154\",\n \"0.59120494\",\n \"0.5904878\",\n \"0.59041274\",\n \"0.59016997\",\n \"0.59010535\",\n \"0.5900086\",\n \"0.58996344\",\n \"0.58840376\",\n \"0.58830106\",\n \"0.58741426\",\n \"0.58731467\",\n \"0.5872644\",\n \"0.5872463\",\n \"0.5869319\",\n \"0.5865742\",\n \"0.58558446\",\n \"0.585137\",\n \"0.58511966\",\n \"0.5842526\",\n \"0.58325833\",\n \"0.58243495\",\n \"0.5822058\",\n \"0.58119094\",\n \"0.5810837\",\n \"0.58093053\",\n \"0.5808302\",\n \"0.5805563\",\n \"0.5805004\",\n \"0.57928324\",\n \"0.57900864\",\n \"0.57870924\",\n \"0.578546\",\n \"0.57852185\",\n \"0.57847345\",\n \"0.57847345\",\n \"0.5769793\",\n \"0.5768504\",\n \"0.5762122\",\n \"0.5751444\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95594,"cells":{"query":{"kind":"string","value":"Truncates a sequence pair in place to the maximum length. This will always truncate the longer sequence one token at a time. This makes more sense than truncating an equal percent of tokens from each, since if one sequence is very short then each token that's truncated likely contains more information than a longer sequence."},"document":{"kind":"string","value":"def _truncate_seq_pair(self, tokens_a: str, tokens_b: str, max_length: int):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()"},"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 _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop(0) #For dialogue context\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n \"\"\"Need to check whether truncation really helps, coz it might remove context! :( \"\"\"\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\n\n\t\t# This is a simple heuristic which will always truncate the longer sequence\n\t\t# one token at a time. This makes more sense than truncating an equal percent\n\t\t# of tokens from each, since if one sequence is very short then each token\n\t\t# that's truncated likely contains more information than a longer sequence.\n\t\twhile True:\n\t\t\ttotal_length = len(tokens_a) + len(tokens_b)\n\t\t\tif total_length <= max_length:\n\t\t\t\tbreak\n\t\t\tif len(tokens_a) > len(tokens_b):\n\t\t\t\ttokens_a.pop()\n\t\t\telse:\n\t\t\t\ttokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n ####\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\r\n\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n\t# This is a simple heuristic which will always truncate the longer sequence\n\t# one token at a time. This makes more sense than truncating an equal percent\n\t# of tokens from each, since if one sequence is very short then each token\n\t# that's truncated likely contains more information than a longer sequence.\n\twhile True:\n\t\ttotal_length = len(tokens_a) + len(tokens_b)\n\t\tif total_length <= max_length:\n\t\t\tbreak\n\t\tif len(tokens_a) > len(tokens_b):\n\t\t\ttokens_a.pop()\n\t\telse:\n\t\t\ttokens_b.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal\n # percent of tokens from each, since if one sequence is very short then\n # each token that's truncated likely contains more information than a\n # longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_length = len(tokens_a) + len(tokens_b)\r\n if total_length <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\r\n\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then each token\r\n # that's truncated likely contains more information than a longer sequence.\r\n while True:\r\n total_len = len(tokens_a) + len(tokens_b)\r\n if total_len <= max_length:\r\n break\r\n if len(tokens_a) > len(tokens_b):\r\n tokens_a.pop()\r\n else:\r\n tokens_b.pop()","def truncate_seq_pair(tokens_a, tokens_b, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair_RE(tokens_name_1, tokens_name_2, tokens_psg, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_name_1) + len(tokens_name_2) + len(tokens_psg) \n if total_length <= max_length:\n break\n tokens_psg.pop()","def truncate_seq_pair_test(tokens_a, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a)\n if total_length <= max_length:\n break\n else:\n tokens_a = tokens_a[-max_length:].copy()\n return tokens_a","def _truncate_seq_pair(tokens_a, tokens_b, max_length, rng):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n if rng is None:\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()\n else:\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n\n trunc_tokens = tokens_a if len(\n tokens_a) > len(tokens_b) else tokens_b\n assert len(trunc_tokens) >= 1\n\n # We want to sometimes truncate from the front and sometimes from the\n # back to add more randomness and avoid biases.\n if rng.random() < 0.5:\n del trunc_tokens[0]\n else:\n trunc_tokens.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair(tokens_a, tokens_b, max_length):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def truncate_seq_pair(tokens_a, tokens_b, max_length=509):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()","def _truncate_seq_pair_3(tokens_a, tokens_b, tokens_c, max_length):\n\n # This is a simple heuristic which will always truncate the longer sequence\n # one token at a time. This makes more sense than truncating an equal percent\n # of tokens from each, since if one sequence is very short then each token\n # that's truncated likely contains more information than a longer sequence.\n while True:\n total_length = len(tokens_a) + len(tokens_b) + len(tokens_c)\n if total_length <= max_length:\n break\n if len(tokens_b) > len(tokens_c):\n tokens_b.pop()\n else:\n tokens_c.pop()","def _truncate_seq_pair_two_length(tokens_a, tokens_b, max_length_a, max_length_b):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_length_a + max_length_b:\n break\n if len(tokens_b) > max_length_b:\n tokens_b.pop()\n else: # len(tokens_a) > max_length_a\n tokens_a.pop()","def _truncate_seq_pair(self, tokens_a, tokens_b):\n try:\n while True:\n if tokens_b:\n total_length = len(tokens_a) + len(tokens_b)\n else:\n total_length = len(tokens_a)\n\n if total_length <= 45 - 3:\n break\n if tokens_b == None:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()\n except:\n self.logger.error()","def truncate_seq_pair(self,tokens_a, tokens_b, max_num_tokens, rng):\n while True:\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_num_tokens:\n break\n\n trunc_tokens = tokens_a if len(tokens_a) > len(tokens_b) else tokens_b\n assert len(trunc_tokens) >= 1\n\n # We want to sometimes truncate from the front and sometimes from the\n # back to add more randomness and avoid biases.\n if rng.random() < 0.5:\n del trunc_tokens[0]\n else:\n trunc_tokens.pop()","def truncate_sequences(self,\n ids,\n pair_ids=None,\n num_tokens_to_remove=0,\n truncation_strategy='longest_first',\n stride=0):\n if num_tokens_to_remove <= 0:\n return ids, pair_ids, []\n\n if truncation_strategy == 'longest_first':\n overflowing_tokens = []\n if pair_ids is None or len(ids) <= len(pair_ids):\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) >= len(pair_ids):\n overflowing_tokens = [ids[-1]] + overflowing_tokens\n ids = ids[:-1]\n else:\n pair_ids = pair_ids[:-1]\n window_len = min(len(ids), stride)\n else:\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) > len(pair_ids):\n overflowing_tokens = [ids[-1]] + overflowing_tokens\n ids = ids[:-1]\n else:\n pair_ids = pair_ids[:-1]\n window_len = min(len(ids), stride)\n if window_len > 0:\n overflowing_tokens = ids[-window_len:] + overflowing_tokens\n elif truncation_strategy == 'only_first':\n assert len(ids) > num_tokens_to_remove\n window_len = min(len(ids), stride + num_tokens_to_remove)\n overflowing_tokens = ids[-window_len:]\n ids = ids[:-num_tokens_to_remove]\n elif truncation_strategy == 'only_second':\n assert pair_ids is not None and len(pair_ids) > num_tokens_to_remove\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\n overflowing_tokens = pair_ids[-window_len:]\n pair_ids = pair_ids[:-num_tokens_to_remove]\n elif truncation_strategy == 'do_not_truncate':\n raise ValueError(\n \"Input sequence are too long for max_length. Please select a truncation strategy.\"\n )\n else:\n raise ValueError(\n \"Truncation_strategy should be selected in ['longest_first', 'only_first', 'only_second', 'do_not_truncate']\"\n )\n return (ids, pair_ids, overflowing_tokens)","def _truncate_tokens(tokens_a, tokens_b, max_length):\n while len(tokens_a) + len(tokens_b) > max_length:\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop(0)\n else:\n tokens_b.pop()\n return tokens_a, tokens_b","def truncate(data, sequence_length=3000):\n res = []\n for sample in data:\n if len(sample) > sequence_length:\n sample = sample[:sequence_length]\n res.append(sample)\n else:\n str_added = [PAD_STR] * (sequence_length - len(sample))\n sample += str_added\n res.append(sample)\n return res","def _truncate(self):\n dif = len(self) - self._maxLen\n if dif > 0:\n #return\n self[:dif] = []","def truncate_seqs(self, seqinfo, kvinfo, cyst_positions, debug=False):\n\n lengths = self.get_truncation_parameters(seqinfo, cyst_positions, debug)\n\n # truncate all the sequences to these lengths\n for query, seq in seqinfo.items():\n cpos = cyst_positions[query]\n istart = cpos - lengths['min']['left']\n istop = cpos + lengths['min']['right']\n chopleft = istart\n chopright = len(seq) - istop\n if debug:\n print ' chop %d %d %s' % (chopleft, chopright, query)\n print ' %d --> %d (%d-%d --> %d-%d) %s' % (len(seq), len(seq[istart : istop]),\n -1 if kvinfo is None else kvinfo[query]['min'], -1 if kvinfo is None else kvinfo[query]['max'],\n -1 if kvinfo is None else (kvinfo[query]['min'] - chopleft), -1 if kvinfo is None else (kvinfo[query]['max'] - chopleft),\n query)\n seqinfo[query] = seq[istart : istop]\n if kvinfo is not None:\n kvinfo[query]['min'] -= chopleft\n kvinfo[query]['max'] -= chopleft","def truncate_sequences(\n self,\n ids: List[int],\n token_boxes: List[List[int]],\n pair_ids: Optional[List[int]] = None,\n pair_token_boxes: Optional[List[List[int]]] = None,\n labels: Optional[List[int]] = None,\n num_tokens_to_remove: int = 0,\n truncation_strategy: Union[str, TruncationStrategy] = \"longest_first\",\n stride: int = 0,\n ) -> Tuple[List[int], List[int], List[int]]:\n if num_tokens_to_remove <= 0:\n return ids, token_boxes, pair_ids, pair_token_boxes, labels, [], [], []\n\n if not isinstance(truncation_strategy, TruncationStrategy):\n truncation_strategy = TruncationStrategy(truncation_strategy)\n\n overflowing_tokens = []\n overflowing_token_boxes = []\n overflowing_labels = []\n if truncation_strategy == TruncationStrategy.LONGEST_FIRST:\n for _ in range(num_tokens_to_remove):\n if pair_ids is None or len(ids) > len(pair_ids):\n if not overflowing_tokens:\n window_len = min(len(ids), stride + 1)\n else:\n window_len = 1\n overflowing_tokens.extend(ids[-window_len:])\n overflowing_token_boxes.extend(token_boxes[-window_len:])\n overflowing_labels.extend(labels[-window_len:])\n ids = ids[:-1]\n token_boxes = token_boxes[:-1]\n labels = labels[:-1]\n else:\n if not overflowing_tokens:\n window_len = min(len(pair_ids), stride + 1)\n else:\n window_len = 1\n overflowing_tokens.extend(pair_ids[-window_len:])\n overflowing_token_boxes.extend(pair_token_boxes[-window_len:])\n pair_ids = pair_ids[:-1]\n pair_token_boxes = pair_token_boxes[:-1]\n elif truncation_strategy == TruncationStrategy.ONLY_FIRST:\n if len(ids) > num_tokens_to_remove:\n window_len = min(len(ids), stride + num_tokens_to_remove)\n overflowing_tokens = ids[-window_len:]\n overflowing_token_boxes = token_boxes[-window_len:]\n overflowing_labels = labels[-window_len:]\n ids = ids[:-num_tokens_to_remove]\n token_boxes = token_boxes[:-num_tokens_to_remove]\n labels = labels[:-num_tokens_to_remove]\n else:\n logger.error(\n f\"We need to remove {num_tokens_to_remove} to truncate the input \"\n f\"but the first sequence has a length {len(ids)}. \"\n f\"Please select another truncation strategy than {truncation_strategy}, \"\n \"for instance 'longest_first' or 'only_second'.\"\n )\n elif truncation_strategy == TruncationStrategy.ONLY_SECOND and pair_ids is not None:\n if len(pair_ids) > num_tokens_to_remove:\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\n overflowing_tokens = pair_ids[-window_len:]\n overflowing_token_boxes = pair_token_boxes[-window_len:]\n pair_ids = pair_ids[:-num_tokens_to_remove]\n pair_token_boxes = pair_token_boxes[:-num_tokens_to_remove]\n else:\n logger.error(\n f\"We need to remove {num_tokens_to_remove} to truncate the input \"\n f\"but the second sequence has a length {len(pair_ids)}. \"\n f\"Please select another truncation strategy than {truncation_strategy}, \"\n \"for instance 'longest_first' or 'only_first'.\"\n )\n\n return (\n ids,\n token_boxes,\n pair_ids,\n pair_token_boxes,\n labels,\n overflowing_tokens,\n overflowing_token_boxes,\n overflowing_labels,\n )","def range_truncate(s, max_len=8) :\n if len(s) > max_len :\n return s[0:2] + \"...\" + s[-2:]\n return s","def trunc(fname, maxlen):\n front, back = fname.rsplit('.', 1)\n front_pieces = front.split(' ')\n new_max = maxlen - len(back) - 1\n\n while len(front) >= new_max:\n front_pieces = front_pieces[:-1]\n if front_pieces[-1] == '-':\n front_pieces = front_pieces[:-1]\n front = ' '.join(front_pieces)\n\n new_fname = front + '.' + back\n return new_fname.replace(',.' + back, '.' + back) # remove trailing commas","def _truncate_string(cls, s1, s2, max_len):\n s1_len = len(s1.split(' '))\n s2_len = len(s2.split(' '))\n MIN_S2_LEN = 6\n if s1_len + s2_len <= max_len or s2_len < MIN_S2_LEN:\n return s2, False\n\n truncate_point = MIN_S2_LEN if s1_len > max_len else max_len - s1_len\n\n return ' '.join(s2.split(' ')[0:truncate_point]), True","def _smart_truncate(self, text, length, suffix='...'):\n\n slen = len(suffix)\n pattern = r'^(.{0,%d}\\S)\\s+\\S+' % (length-slen-1)\n if len(text) > length:\n match = re.match(pattern, text)\n if match:\n length0 = match.end(0)\n length1 = match.end(1)\n if abs(length0+slen-length) < abs(length1+slen-length):\n return match.group(0) + suffix\n else:\n return match.group(1) + suffix\n return text","def _smart_truncate(self, text, length, suffix='...'):\n\n slen = len(suffix)\n pattern = r'^(.{0,%d}\\S)\\s+\\S+' % (length-slen-1)\n if len(text) > length:\n match = re.match(pattern, text)\n if match:\n length0 = match.end(0)\n length1 = match.end(1)\n if abs(length0+slen-length) < abs(length1+slen-length):\n return match.group(0) + suffix\n else:\n return match.group(1) + suffix\n return text","def auto_truncate(val):\n return val[:7]","def smart_truncate(text, length=100, suffix='...'):\n\n slen = len(suffix)\n pattern = r'^(.{0,%d}\\S)\\s+\\S+' % (length - slen - 1)\n if len(text) > length:\n match = re.match(pattern, text)\n if match:\n length0 = match.end(0)\n length1 = match.end(1)\n if abs(length0 + slen - length) < abs(length1 + slen - length):\n return match.group(0) + suffix\n else:\n return match.group(1) + suffix\n return text","def truncate(self, parts_a: List[Tuple[List[int], bool]], parts_b: List[Tuple[List[int], bool]], answer: List[int],\n max_length: int):\n total_len = self._seq_length(parts_a) + self._seq_length(parts_b)\n if answer:\n total_len += len(answer)\n total_len += num_special_tokens_to_add(\n parts_a, parts_b, answer, add_cls=True, add_sep=False, add_piece=True)\n num_tokens_to_remove = total_len - max_length\n\n if num_tokens_to_remove <= 0:\n return False\n\n for _ in range(num_tokens_to_remove):\n if self._seq_length(parts_a, only_shortenable=True) > self._seq_length(parts_b, only_shortenable=True):\n self._remove_last(parts_a)\n else:\n self._remove_last(parts_b)\n return True","def truncate(string):","def truncate(value, size=72):\n value = value.replace(\"\\n\", \" \").replace(\"\\r\", \"\").replace(\"\\t\", \" \")\n value = value.strip()\n value = WHITESPACES.sub(\" \", value)\n\n if len(value) > size:\n value = \"{0}...\".format(value[:size-3])\n\n return value","def pad_to_max_length(self, sequence):\n sequence = sequence[:self.max_seq_length]\n n = len(sequence)\n #return sequence + ['[PAD]'] * (self.max_seq_length - n)\n return sequence + [0] *(self.max_seq_length - n)","def truncate(text_str: str, max_length: int = 256) -> str:\n truncated_str = text_str[:max_length]\n if len(truncated_str) == max_length:\n i = max(0, (max_length - 3) // 2)\n j = max(0, max_length - 3 - i)\n truncated_str = text_str[:i] + text_str[len(text_str)-j:]\n truncated_str = truncated_str[:i] + '...' + truncated_str[len(truncated_str)-j:]\n return truncated_str","async def _truncate_adjusted_tick_data(self, pair: str):\n\n truncate = len(self.close_times[pair]) - self.min_tick_length\n if truncate > 60:\n del self.base_24hr_volumes[pair][1][:truncate]\n del self.adjusted_close_values[pair][:truncate]","def truncate_middle(path: str, acceptable_len: int):\n if len(path) <= acceptable_len:\n return path\n # half of the size, minus the 3 .'s\n n_2 = int(acceptable_len / 2 - 3)\n # whatever's left\n n_1 = int(acceptable_len - n_2 - 3)\n return f\"{path[:n_1]}...{path[-n_2:]}\"","def pad_or_trim(seq, max_len=1000):\n n, m = seq.shape\n \n if n > max_len:\n seq = seq[-max_len:, :]\n elif n < max_len:\n if sparse.issparse(seq):\n pad_csr(seq, (max_len, m))\n else:\n seq = np.r_[seq, np.zeros((max_len - n, m))]\n return seq","def truncate(text, max_length=140, pad_with_dot=True):\n if len(text) > max_length:\n if pad_with_dot:\n return text[:max_length-3] + \"...\"\n else:\n return text[:max_length]\n return text","def trunc(s, max_pos=75): \n length = len(s)\n if length <= max_pos:\n return s\n else:\n end = s.rfind(' ',0,max_pos)\n if end > 0 and end > max_pos-5:\n return s[0:end] + '...'\n else:\n if s[max_pos-1] == '.':\n max_pos = max_pos - 1\n return s[0:max_pos] + '...'","def trunc_string(string, length=50):\n if len(string)>length:\n return \"%s...\" % string[:length-3]\n else:\n return string","def _truncate(text: str, max_len: int) -> str:\n if len(text) > max_len:\n return text[:max_len - 1] + \"…\"\n return text","def truncate_reads(tmp_dir, infile, unaligned_set, n, min_len):\n\n outfile = \"{0}/truncated.fastq\".format(tmp_dir)\n with ps.FastxFile(infile, \"r\") as inf, open(outfile, \"w\") as outf:\n for entry in inf:\n if entry.name in unaligned_set or n == min_len:\n entry.sequence = entry.sequence[:n]\n entry.quality = entry.quality[:n]\n outf.write(str(entry) + \"\\n\")\n return outfile","def truncate(cls, value, target_len=200, ellipsis='...'):\n # open tags are pushed on here, then popped when\n # the matching close tag is found\n stack = []\n # string to be returned\n retval = []\n # number of characters (not counting markup) placed in retval so far\n length = 0\n tokens = Tokenizer(value)\n tok = tokens.next_token()\n while tok != tokens.token_end:\n if not length < target_len:\n retval.append(ellipsis)\n break\n if tok.__class__.__name__ == 'OpenTag':\n stack.append(tok)\n retval.append(tok.as_string())\n elif tok.__class__.__name__ == 'CloseTag':\n if stack[-1].tag == tok.tag:\n stack.pop()\n retval.append(tok.as_string())\n else:\n raise UnbalancedError(tok.as_string())\n elif tok.__class__.__name__ == 'SelfClosingTag':\n retval.append(tok.as_string())\n else:\n retval.append(tok)\n length += 1\n tok = tokens.next_token()\n while len(stack) > 0:\n tok = CloseTag(stack.pop().tag)\n retval.append(tok.as_string())\n return ''.join(retval)","def truncate(self, count=0, reverse=True):\n if reverse:\n return self.value[:(len(self.value) - count)]\n else:\n return self.value[count:]","async def _truncate_tick_data(self, pair: str):\n\n truncate = len(self.close_times[pair]) - self.min_tick_length\n if truncate > 60:\n del self.base_24hr_volumes[pair][0][:truncate]\n del self.close_values[pair][:truncate]\n del self.close_times[pair][:truncate]","def limit_size(msg, max_size, trunc_symbol=\"...\"):\n if len(msg) > max_size:\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\n return msg","def truncate_text_by_num_tokens(text, max_tokens, tok_separator=\" \"):\n _toks = text.split(tok_separator)\n return tok_separator.join(_toks[:min(max_tokens, len(_toks))])","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate(x: str, limit: int) -> str:\n return \" \".join(x.split()[:limit])","def shrink_seq(mrnaseq, mrna_frag, mrna_frag_target, total_length=50):\n # Prepare sequences with no gaps\n mrnaseq_nogap = mrnaseq.replace(\"-\", \"\")\n mrna_frag_nogap = mrna_frag.replace(\"-\", \"\")\n if len(mrna_frag_nogap) < total_length:\n syserr(mrna_frag_nogap)\n syserr(mrnaseq)\n syserr(mrna_frag)\n syserr(mrna_frag_target)\n raise Exception(\n \"Check your sequences maybe you should extend, not shrink them\")\n span = re.search(mrna_frag_nogap, mrnaseq_nogap).span()\n\n # Decide which type of extension to do\n gap_pos_mean = mean(\n [i for i, x in enumerate(mrna_frag_target) if x == \"-\"])\n list_median = median([i for i in range(len(mrna_frag_target))])\n\n # this ratio gives us relative position of the gaps\n ratio = gap_pos_mean / list_median\n\n # Based on the ratio do the shrinkage of the sequence\n if ratio > 0.5 and ratio < 1.5: # extend both sides\n li = span[0]\n ui = span[1]\n length = ui - li\n if length < total_length:\n return -1\n elif length == total_length:\n return mrnaseq_nogap[li:ui]\n else:\n dif = abs(total_length - length)\n quot = dif // 2 # this is explicit integer division\n l_ext = li + quot\n u_ext = ui - (dif - quot)\n if (u_ext < 0) or (u_ext > len(mrnaseq_nogap) - 1):\n return \"NA\"\n else:\n return mrnaseq_nogap[l_ext:u_ext]\n elif ratio <= 0.5: # trim left - it means upstream (5'end)\n li = span[0]\n ui = span[1]\n length = ui - li\n dif = len(mrna_frag_nogap) - total_length\n return mrnaseq_nogap[li + dif:ui]\n elif ratio >= 1.5: # extend right - it means downstream (3'end)\n li = span[0]\n ui = span[1]\n length = ui - li\n dif = len(mrna_frag_nogap) - total_length\n return mrnaseq_nogap[li:ui - dif]","def _truncate_string(self, text, max_size):\n import textwrap\n\n if len(text) <= max_size:\n return text\n return textwrap.wrap(text, max_size-3)[0] + \"...\"","def trunc_inplace(a):","def test_truncate_seqs(self):\r\n\r\n base_pos = 5\r\n\r\n fasta_seqs = {'seq1': 'GAAATCAAGAATAC',\r\n 'seq2': 'ATAAACAAGAT'}\r\n qual_scores = {'seq1': array(map(str, [20, 10, 15, 25, 24, 25, 27])),\r\n 'seq2': array(map(str, [22, 21, 15, 12, 22, 25, 27, 28]))}\r\n\r\n expected_fasta = {'seq1': 'GAAAT',\r\n 'seq2': 'ATAAA'}\r\n\r\n expected_qual = {'seq1': map(str, array([20, 10, 15, 25, 24])),\r\n 'seq2': map(str, array([22, 21, 15, 12, 22]))}\r\n\r\n actual_fasta_seqs, actual_qual_scores =\\\r\n truncate_seqs(fasta_seqs, qual_scores, base_pos)\r\n\r\n self.assertDictEqual(actual_fasta_seqs, expected_fasta)\r\n self.assertItemsEqual(expected_qual, actual_qual_scores)","def truncate_signals(signals, length=None, samplerate=None):\n if length is None:\n return signals\n if samplerate is not None:\n length = round(samplerate * length)\n\n def truncation(signal):\n return signal[..., :length]\n\n return _apply_to_signals(truncation, signals)","def pad_tokens(x, max_length, pad_token_id,\n truncate_from=\"left\",\n pad_from=\"left\"):\n assert truncate_from in (\"left\", \"right\")\n assert pad_from in (\"left\", \"right\")\n if len(x) > max_length:\n if truncate_from == \"left\":\n return x[-max_length:]\n else:\n return x[:max_length]\n elif len(x) < max_length:\n padding = [pad_token_id] * (max_length - len(x))\n if pad_from == \"left\":\n return padding + x\n else:\n return x + padding\n else:\n return x","def truncate(text=\"\", max_len=50):\n return text if len(text) < max_len else text[:max_len]","def truncatesmart(value, limit=80):\n\n try:\n limit = int(limit)\n # invalid literal for int()\n except ValueError:\n # Fail silently.\n return value\n\n # Make sure it's unicode\n value = unicode(value)\n\n # Return the string itself if length is smaller or equal to the limit\n if len(value) <= limit:\n return value\n\n # Cut the string\n value = value[:limit]\n\n return value + '...'","def truncate(s, max_len=10) :\n MAX_LEN = max_len\n display_string = escape_for_display(s)\n if len(s) == 0 :\n return display_string # Display empty string token.\n if len(s) > MAX_LEN :\n display_string = display_string[0:MAX_LEN] + \"...\"\n return display_string","def truncate_description(description):\n if len(description) <= 160 :\n return description\n\n cut_desc = \"\"\n character_counter = 0\n for i, letter in enumerate(description) :\n character_counter += 1\n if character_counter > 160 :\n if letter == ' ' :\n return cut_desc+\"...\"\n else :\n return cut_desc.rsplit(' ',1)[0]+\"...\"\n cut_desc += description[i]\n return cut_desc","def pad_seq(seq, max_seq_len=0):\n if max_seq_len:\n pad_len = max_seq_len - len(seq)\n if pad_len > 0:\n return np.concatenate([seq, np.zeros(pad_len, dtype=np.int64)])\n elif pad_len < 0: # chop to fit\n two_last_tokens = seq[-2:]\n out = seq[:max_seq_len]\n out[-2:] = two_last_tokens\n return out.astype(np.int64)\n return seq.astype(np.int64)","def fast_forward_to_length(sequences, length):\n return itertools.dropwhile(lambda seq: len(seq) != length, sequences)","def remove_every_other(seq):\n length = len(seq)\n new_seq = seq[0:length:2]\n return new_seq","def truncate_string(text, length):\n word_tokens = word_tokenize(text)\n truncated = word_tokens[:length]\n truncated_text = \" \".join(truncated)\n return truncated_text","def truncate(text, length=100, suffix=\"...\"):\n if len(text) > length:\n return text[: length - len(suffix)] + suffix\n else:\n return text","def truncate(s):\n truncate = whenFloating $ \\c e ->\n if dangerouslySmall c e\n then 0\n else fromInteger $ c `quotInteger` magnitude (-e)","def test_truncates_to_correct_size(self):\n truncated = truncateFeedback(self.simpleTestString)\n self.assertTrue(len(truncated) < 16000)\n truncated = truncateFeedback(self.complicatedString)\n self.assertTrue(len(truncated) < 16000)"],"string":"[\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop(0) #For dialogue context\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n \\\"\\\"\\\"Need to check whether truncation really helps, coz it might remove context! :( \\\"\\\"\\\"\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\n\\n\\t\\t# This is a simple heuristic which will always truncate the longer sequence\\n\\t\\t# one token at a time. This makes more sense than truncating an equal percent\\n\\t\\t# of tokens from each, since if one sequence is very short then each token\\n\\t\\t# that's truncated likely contains more information than a longer sequence.\\n\\t\\twhile True:\\n\\t\\t\\ttotal_length = len(tokens_a) + len(tokens_b)\\n\\t\\t\\tif total_length <= max_length:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tif len(tokens_a) > len(tokens_b):\\n\\t\\t\\t\\ttokens_a.pop()\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n ####\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\r\\n\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n\\t# This is a simple heuristic which will always truncate the longer sequence\\n\\t# one token at a time. This makes more sense than truncating an equal percent\\n\\t# of tokens from each, since if one sequence is very short then each token\\n\\t# that's truncated likely contains more information than a longer sequence.\\n\\twhile True:\\n\\t\\ttotal_length = len(tokens_a) + len(tokens_b)\\n\\t\\tif total_length <= max_length:\\n\\t\\t\\tbreak\\n\\t\\tif len(tokens_a) > len(tokens_b):\\n\\t\\t\\ttokens_a.pop()\\n\\t\\telse:\\n\\t\\t\\ttokens_b.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal\\n # percent of tokens from each, since if one sequence is very short then\\n # each token that's truncated likely contains more information than a\\n # longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_length = len(tokens_a) + len(tokens_b)\\r\\n if total_length <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\r\\n\\r\\n # This is a simple heuristic which will always truncate the longer sequence\\r\\n # one token at a time. This makes more sense than truncating an equal percent\\r\\n # of tokens from each, since if one sequence is very short then each token\\r\\n # that's truncated likely contains more information than a longer sequence.\\r\\n while True:\\r\\n total_len = len(tokens_a) + len(tokens_b)\\r\\n if total_len <= max_length:\\r\\n break\\r\\n if len(tokens_a) > len(tokens_b):\\r\\n tokens_a.pop()\\r\\n else:\\r\\n tokens_b.pop()\",\n \"def truncate_seq_pair(tokens_a, tokens_b, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair_RE(tokens_name_1, tokens_name_2, tokens_psg, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_name_1) + len(tokens_name_2) + len(tokens_psg) \\n if total_length <= max_length:\\n break\\n tokens_psg.pop()\",\n \"def truncate_seq_pair_test(tokens_a, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a)\\n if total_length <= max_length:\\n break\\n else:\\n tokens_a = tokens_a[-max_length:].copy()\\n return tokens_a\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length, rng):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n if rng is None:\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\\n else:\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n\\n trunc_tokens = tokens_a if len(\\n tokens_a) > len(tokens_b) else tokens_b\\n assert len(trunc_tokens) >= 1\\n\\n # We want to sometimes truncate from the front and sometimes from the\\n # back to add more randomness and avoid biases.\\n if rng.random() < 0.5:\\n del trunc_tokens[0]\\n else:\\n trunc_tokens.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair(tokens_a, tokens_b, max_length):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def truncate_seq_pair(tokens_a, tokens_b, max_length=509):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\",\n \"def _truncate_seq_pair_3(tokens_a, tokens_b, tokens_c, max_length):\\n\\n # This is a simple heuristic which will always truncate the longer sequence\\n # one token at a time. This makes more sense than truncating an equal percent\\n # of tokens from each, since if one sequence is very short then each token\\n # that's truncated likely contains more information than a longer sequence.\\n while True:\\n total_length = len(tokens_a) + len(tokens_b) + len(tokens_c)\\n if total_length <= max_length:\\n break\\n if len(tokens_b) > len(tokens_c):\\n tokens_b.pop()\\n else:\\n tokens_c.pop()\",\n \"def _truncate_seq_pair_two_length(tokens_a, tokens_b, max_length_a, max_length_b):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_length_a + max_length_b:\\n break\\n if len(tokens_b) > max_length_b:\\n tokens_b.pop()\\n else: # len(tokens_a) > max_length_a\\n tokens_a.pop()\",\n \"def _truncate_seq_pair(self, tokens_a, tokens_b):\\n try:\\n while True:\\n if tokens_b:\\n total_length = len(tokens_a) + len(tokens_b)\\n else:\\n total_length = len(tokens_a)\\n\\n if total_length <= 45 - 3:\\n break\\n if tokens_b == None:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\\n except:\\n self.logger.error()\",\n \"def truncate_seq_pair(self,tokens_a, tokens_b, max_num_tokens, rng):\\n while True:\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_num_tokens:\\n break\\n\\n trunc_tokens = tokens_a if len(tokens_a) > len(tokens_b) else tokens_b\\n assert len(trunc_tokens) >= 1\\n\\n # We want to sometimes truncate from the front and sometimes from the\\n # back to add more randomness and avoid biases.\\n if rng.random() < 0.5:\\n del trunc_tokens[0]\\n else:\\n trunc_tokens.pop()\",\n \"def truncate_sequences(self,\\n ids,\\n pair_ids=None,\\n num_tokens_to_remove=0,\\n truncation_strategy='longest_first',\\n stride=0):\\n if num_tokens_to_remove <= 0:\\n return ids, pair_ids, []\\n\\n if truncation_strategy == 'longest_first':\\n overflowing_tokens = []\\n if pair_ids is None or len(ids) <= len(pair_ids):\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) >= len(pair_ids):\\n overflowing_tokens = [ids[-1]] + overflowing_tokens\\n ids = ids[:-1]\\n else:\\n pair_ids = pair_ids[:-1]\\n window_len = min(len(ids), stride)\\n else:\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) > len(pair_ids):\\n overflowing_tokens = [ids[-1]] + overflowing_tokens\\n ids = ids[:-1]\\n else:\\n pair_ids = pair_ids[:-1]\\n window_len = min(len(ids), stride)\\n if window_len > 0:\\n overflowing_tokens = ids[-window_len:] + overflowing_tokens\\n elif truncation_strategy == 'only_first':\\n assert len(ids) > num_tokens_to_remove\\n window_len = min(len(ids), stride + num_tokens_to_remove)\\n overflowing_tokens = ids[-window_len:]\\n ids = ids[:-num_tokens_to_remove]\\n elif truncation_strategy == 'only_second':\\n assert pair_ids is not None and len(pair_ids) > num_tokens_to_remove\\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\\n overflowing_tokens = pair_ids[-window_len:]\\n pair_ids = pair_ids[:-num_tokens_to_remove]\\n elif truncation_strategy == 'do_not_truncate':\\n raise ValueError(\\n \\\"Input sequence are too long for max_length. Please select a truncation strategy.\\\"\\n )\\n else:\\n raise ValueError(\\n \\\"Truncation_strategy should be selected in ['longest_first', 'only_first', 'only_second', 'do_not_truncate']\\\"\\n )\\n return (ids, pair_ids, overflowing_tokens)\",\n \"def _truncate_tokens(tokens_a, tokens_b, max_length):\\n while len(tokens_a) + len(tokens_b) > max_length:\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop(0)\\n else:\\n tokens_b.pop()\\n return tokens_a, tokens_b\",\n \"def truncate(data, sequence_length=3000):\\n res = []\\n for sample in data:\\n if len(sample) > sequence_length:\\n sample = sample[:sequence_length]\\n res.append(sample)\\n else:\\n str_added = [PAD_STR] * (sequence_length - len(sample))\\n sample += str_added\\n res.append(sample)\\n return res\",\n \"def _truncate(self):\\n dif = len(self) - self._maxLen\\n if dif > 0:\\n #return\\n self[:dif] = []\",\n \"def truncate_seqs(self, seqinfo, kvinfo, cyst_positions, debug=False):\\n\\n lengths = self.get_truncation_parameters(seqinfo, cyst_positions, debug)\\n\\n # truncate all the sequences to these lengths\\n for query, seq in seqinfo.items():\\n cpos = cyst_positions[query]\\n istart = cpos - lengths['min']['left']\\n istop = cpos + lengths['min']['right']\\n chopleft = istart\\n chopright = len(seq) - istop\\n if debug:\\n print ' chop %d %d %s' % (chopleft, chopright, query)\\n print ' %d --> %d (%d-%d --> %d-%d) %s' % (len(seq), len(seq[istart : istop]),\\n -1 if kvinfo is None else kvinfo[query]['min'], -1 if kvinfo is None else kvinfo[query]['max'],\\n -1 if kvinfo is None else (kvinfo[query]['min'] - chopleft), -1 if kvinfo is None else (kvinfo[query]['max'] - chopleft),\\n query)\\n seqinfo[query] = seq[istart : istop]\\n if kvinfo is not None:\\n kvinfo[query]['min'] -= chopleft\\n kvinfo[query]['max'] -= chopleft\",\n \"def truncate_sequences(\\n self,\\n ids: List[int],\\n token_boxes: List[List[int]],\\n pair_ids: Optional[List[int]] = None,\\n pair_token_boxes: Optional[List[List[int]]] = None,\\n labels: Optional[List[int]] = None,\\n num_tokens_to_remove: int = 0,\\n truncation_strategy: Union[str, TruncationStrategy] = \\\"longest_first\\\",\\n stride: int = 0,\\n ) -> Tuple[List[int], List[int], List[int]]:\\n if num_tokens_to_remove <= 0:\\n return ids, token_boxes, pair_ids, pair_token_boxes, labels, [], [], []\\n\\n if not isinstance(truncation_strategy, TruncationStrategy):\\n truncation_strategy = TruncationStrategy(truncation_strategy)\\n\\n overflowing_tokens = []\\n overflowing_token_boxes = []\\n overflowing_labels = []\\n if truncation_strategy == TruncationStrategy.LONGEST_FIRST:\\n for _ in range(num_tokens_to_remove):\\n if pair_ids is None or len(ids) > len(pair_ids):\\n if not overflowing_tokens:\\n window_len = min(len(ids), stride + 1)\\n else:\\n window_len = 1\\n overflowing_tokens.extend(ids[-window_len:])\\n overflowing_token_boxes.extend(token_boxes[-window_len:])\\n overflowing_labels.extend(labels[-window_len:])\\n ids = ids[:-1]\\n token_boxes = token_boxes[:-1]\\n labels = labels[:-1]\\n else:\\n if not overflowing_tokens:\\n window_len = min(len(pair_ids), stride + 1)\\n else:\\n window_len = 1\\n overflowing_tokens.extend(pair_ids[-window_len:])\\n overflowing_token_boxes.extend(pair_token_boxes[-window_len:])\\n pair_ids = pair_ids[:-1]\\n pair_token_boxes = pair_token_boxes[:-1]\\n elif truncation_strategy == TruncationStrategy.ONLY_FIRST:\\n if len(ids) > num_tokens_to_remove:\\n window_len = min(len(ids), stride + num_tokens_to_remove)\\n overflowing_tokens = ids[-window_len:]\\n overflowing_token_boxes = token_boxes[-window_len:]\\n overflowing_labels = labels[-window_len:]\\n ids = ids[:-num_tokens_to_remove]\\n token_boxes = token_boxes[:-num_tokens_to_remove]\\n labels = labels[:-num_tokens_to_remove]\\n else:\\n logger.error(\\n f\\\"We need to remove {num_tokens_to_remove} to truncate the input \\\"\\n f\\\"but the first sequence has a length {len(ids)}. \\\"\\n f\\\"Please select another truncation strategy than {truncation_strategy}, \\\"\\n \\\"for instance 'longest_first' or 'only_second'.\\\"\\n )\\n elif truncation_strategy == TruncationStrategy.ONLY_SECOND and pair_ids is not None:\\n if len(pair_ids) > num_tokens_to_remove:\\n window_len = min(len(pair_ids), stride + num_tokens_to_remove)\\n overflowing_tokens = pair_ids[-window_len:]\\n overflowing_token_boxes = pair_token_boxes[-window_len:]\\n pair_ids = pair_ids[:-num_tokens_to_remove]\\n pair_token_boxes = pair_token_boxes[:-num_tokens_to_remove]\\n else:\\n logger.error(\\n f\\\"We need to remove {num_tokens_to_remove} to truncate the input \\\"\\n f\\\"but the second sequence has a length {len(pair_ids)}. \\\"\\n f\\\"Please select another truncation strategy than {truncation_strategy}, \\\"\\n \\\"for instance 'longest_first' or 'only_first'.\\\"\\n )\\n\\n return (\\n ids,\\n token_boxes,\\n pair_ids,\\n pair_token_boxes,\\n labels,\\n overflowing_tokens,\\n overflowing_token_boxes,\\n overflowing_labels,\\n )\",\n \"def range_truncate(s, max_len=8) :\\n if len(s) > max_len :\\n return s[0:2] + \\\"...\\\" + s[-2:]\\n return s\",\n \"def trunc(fname, maxlen):\\n front, back = fname.rsplit('.', 1)\\n front_pieces = front.split(' ')\\n new_max = maxlen - len(back) - 1\\n\\n while len(front) >= new_max:\\n front_pieces = front_pieces[:-1]\\n if front_pieces[-1] == '-':\\n front_pieces = front_pieces[:-1]\\n front = ' '.join(front_pieces)\\n\\n new_fname = front + '.' + back\\n return new_fname.replace(',.' + back, '.' + back) # remove trailing commas\",\n \"def _truncate_string(cls, s1, s2, max_len):\\n s1_len = len(s1.split(' '))\\n s2_len = len(s2.split(' '))\\n MIN_S2_LEN = 6\\n if s1_len + s2_len <= max_len or s2_len < MIN_S2_LEN:\\n return s2, False\\n\\n truncate_point = MIN_S2_LEN if s1_len > max_len else max_len - s1_len\\n\\n return ' '.join(s2.split(' ')[0:truncate_point]), True\",\n \"def _smart_truncate(self, text, length, suffix='...'):\\n\\n slen = len(suffix)\\n pattern = r'^(.{0,%d}\\\\S)\\\\s+\\\\S+' % (length-slen-1)\\n if len(text) > length:\\n match = re.match(pattern, text)\\n if match:\\n length0 = match.end(0)\\n length1 = match.end(1)\\n if abs(length0+slen-length) < abs(length1+slen-length):\\n return match.group(0) + suffix\\n else:\\n return match.group(1) + suffix\\n return text\",\n \"def _smart_truncate(self, text, length, suffix='...'):\\n\\n slen = len(suffix)\\n pattern = r'^(.{0,%d}\\\\S)\\\\s+\\\\S+' % (length-slen-1)\\n if len(text) > length:\\n match = re.match(pattern, text)\\n if match:\\n length0 = match.end(0)\\n length1 = match.end(1)\\n if abs(length0+slen-length) < abs(length1+slen-length):\\n return match.group(0) + suffix\\n else:\\n return match.group(1) + suffix\\n return text\",\n \"def auto_truncate(val):\\n return val[:7]\",\n \"def smart_truncate(text, length=100, suffix='...'):\\n\\n slen = len(suffix)\\n pattern = r'^(.{0,%d}\\\\S)\\\\s+\\\\S+' % (length - slen - 1)\\n if len(text) > length:\\n match = re.match(pattern, text)\\n if match:\\n length0 = match.end(0)\\n length1 = match.end(1)\\n if abs(length0 + slen - length) < abs(length1 + slen - length):\\n return match.group(0) + suffix\\n else:\\n return match.group(1) + suffix\\n return text\",\n \"def truncate(self, parts_a: List[Tuple[List[int], bool]], parts_b: List[Tuple[List[int], bool]], answer: List[int],\\n max_length: int):\\n total_len = self._seq_length(parts_a) + self._seq_length(parts_b)\\n if answer:\\n total_len += len(answer)\\n total_len += num_special_tokens_to_add(\\n parts_a, parts_b, answer, add_cls=True, add_sep=False, add_piece=True)\\n num_tokens_to_remove = total_len - max_length\\n\\n if num_tokens_to_remove <= 0:\\n return False\\n\\n for _ in range(num_tokens_to_remove):\\n if self._seq_length(parts_a, only_shortenable=True) > self._seq_length(parts_b, only_shortenable=True):\\n self._remove_last(parts_a)\\n else:\\n self._remove_last(parts_b)\\n return True\",\n \"def truncate(string):\",\n \"def truncate(value, size=72):\\n value = value.replace(\\\"\\\\n\\\", \\\" \\\").replace(\\\"\\\\r\\\", \\\"\\\").replace(\\\"\\\\t\\\", \\\" \\\")\\n value = value.strip()\\n value = WHITESPACES.sub(\\\" \\\", value)\\n\\n if len(value) > size:\\n value = \\\"{0}...\\\".format(value[:size-3])\\n\\n return value\",\n \"def pad_to_max_length(self, sequence):\\n sequence = sequence[:self.max_seq_length]\\n n = len(sequence)\\n #return sequence + ['[PAD]'] * (self.max_seq_length - n)\\n return sequence + [0] *(self.max_seq_length - n)\",\n \"def truncate(text_str: str, max_length: int = 256) -> str:\\n truncated_str = text_str[:max_length]\\n if len(truncated_str) == max_length:\\n i = max(0, (max_length - 3) // 2)\\n j = max(0, max_length - 3 - i)\\n truncated_str = text_str[:i] + text_str[len(text_str)-j:]\\n truncated_str = truncated_str[:i] + '...' + truncated_str[len(truncated_str)-j:]\\n return truncated_str\",\n \"async def _truncate_adjusted_tick_data(self, pair: str):\\n\\n truncate = len(self.close_times[pair]) - self.min_tick_length\\n if truncate > 60:\\n del self.base_24hr_volumes[pair][1][:truncate]\\n del self.adjusted_close_values[pair][:truncate]\",\n \"def truncate_middle(path: str, acceptable_len: int):\\n if len(path) <= acceptable_len:\\n return path\\n # half of the size, minus the 3 .'s\\n n_2 = int(acceptable_len / 2 - 3)\\n # whatever's left\\n n_1 = int(acceptable_len - n_2 - 3)\\n return f\\\"{path[:n_1]}...{path[-n_2:]}\\\"\",\n \"def pad_or_trim(seq, max_len=1000):\\n n, m = seq.shape\\n \\n if n > max_len:\\n seq = seq[-max_len:, :]\\n elif n < max_len:\\n if sparse.issparse(seq):\\n pad_csr(seq, (max_len, m))\\n else:\\n seq = np.r_[seq, np.zeros((max_len - n, m))]\\n return seq\",\n \"def truncate(text, max_length=140, pad_with_dot=True):\\n if len(text) > max_length:\\n if pad_with_dot:\\n return text[:max_length-3] + \\\"...\\\"\\n else:\\n return text[:max_length]\\n return text\",\n \"def trunc(s, max_pos=75): \\n length = len(s)\\n if length <= max_pos:\\n return s\\n else:\\n end = s.rfind(' ',0,max_pos)\\n if end > 0 and end > max_pos-5:\\n return s[0:end] + '...'\\n else:\\n if s[max_pos-1] == '.':\\n max_pos = max_pos - 1\\n return s[0:max_pos] + '...'\",\n \"def trunc_string(string, length=50):\\n if len(string)>length:\\n return \\\"%s...\\\" % string[:length-3]\\n else:\\n return string\",\n \"def _truncate(text: str, max_len: int) -> str:\\n if len(text) > max_len:\\n return text[:max_len - 1] + \\\"…\\\"\\n return text\",\n \"def truncate_reads(tmp_dir, infile, unaligned_set, n, min_len):\\n\\n outfile = \\\"{0}/truncated.fastq\\\".format(tmp_dir)\\n with ps.FastxFile(infile, \\\"r\\\") as inf, open(outfile, \\\"w\\\") as outf:\\n for entry in inf:\\n if entry.name in unaligned_set or n == min_len:\\n entry.sequence = entry.sequence[:n]\\n entry.quality = entry.quality[:n]\\n outf.write(str(entry) + \\\"\\\\n\\\")\\n return outfile\",\n \"def truncate(cls, value, target_len=200, ellipsis='...'):\\n # open tags are pushed on here, then popped when\\n # the matching close tag is found\\n stack = []\\n # string to be returned\\n retval = []\\n # number of characters (not counting markup) placed in retval so far\\n length = 0\\n tokens = Tokenizer(value)\\n tok = tokens.next_token()\\n while tok != tokens.token_end:\\n if not length < target_len:\\n retval.append(ellipsis)\\n break\\n if tok.__class__.__name__ == 'OpenTag':\\n stack.append(tok)\\n retval.append(tok.as_string())\\n elif tok.__class__.__name__ == 'CloseTag':\\n if stack[-1].tag == tok.tag:\\n stack.pop()\\n retval.append(tok.as_string())\\n else:\\n raise UnbalancedError(tok.as_string())\\n elif tok.__class__.__name__ == 'SelfClosingTag':\\n retval.append(tok.as_string())\\n else:\\n retval.append(tok)\\n length += 1\\n tok = tokens.next_token()\\n while len(stack) > 0:\\n tok = CloseTag(stack.pop().tag)\\n retval.append(tok.as_string())\\n return ''.join(retval)\",\n \"def truncate(self, count=0, reverse=True):\\n if reverse:\\n return self.value[:(len(self.value) - count)]\\n else:\\n return self.value[count:]\",\n \"async def _truncate_tick_data(self, pair: str):\\n\\n truncate = len(self.close_times[pair]) - self.min_tick_length\\n if truncate > 60:\\n del self.base_24hr_volumes[pair][0][:truncate]\\n del self.close_values[pair][:truncate]\\n del self.close_times[pair][:truncate]\",\n \"def limit_size(msg, max_size, trunc_symbol=\\\"...\\\"):\\n if len(msg) > max_size:\\n msg = msg[:max_size - len(trunc_symbol)] + trunc_symbol\\n return msg\",\n \"def truncate_text_by_num_tokens(text, max_tokens, tok_separator=\\\" \\\"):\\n _toks = text.split(tok_separator)\\n return tok_separator.join(_toks[:min(max_tokens, len(_toks))])\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate(x: str, limit: int) -> str:\\n return \\\" \\\".join(x.split()[:limit])\",\n \"def shrink_seq(mrnaseq, mrna_frag, mrna_frag_target, total_length=50):\\n # Prepare sequences with no gaps\\n mrnaseq_nogap = mrnaseq.replace(\\\"-\\\", \\\"\\\")\\n mrna_frag_nogap = mrna_frag.replace(\\\"-\\\", \\\"\\\")\\n if len(mrna_frag_nogap) < total_length:\\n syserr(mrna_frag_nogap)\\n syserr(mrnaseq)\\n syserr(mrna_frag)\\n syserr(mrna_frag_target)\\n raise Exception(\\n \\\"Check your sequences maybe you should extend, not shrink them\\\")\\n span = re.search(mrna_frag_nogap, mrnaseq_nogap).span()\\n\\n # Decide which type of extension to do\\n gap_pos_mean = mean(\\n [i for i, x in enumerate(mrna_frag_target) if x == \\\"-\\\"])\\n list_median = median([i for i in range(len(mrna_frag_target))])\\n\\n # this ratio gives us relative position of the gaps\\n ratio = gap_pos_mean / list_median\\n\\n # Based on the ratio do the shrinkage of the sequence\\n if ratio > 0.5 and ratio < 1.5: # extend both sides\\n li = span[0]\\n ui = span[1]\\n length = ui - li\\n if length < total_length:\\n return -1\\n elif length == total_length:\\n return mrnaseq_nogap[li:ui]\\n else:\\n dif = abs(total_length - length)\\n quot = dif // 2 # this is explicit integer division\\n l_ext = li + quot\\n u_ext = ui - (dif - quot)\\n if (u_ext < 0) or (u_ext > len(mrnaseq_nogap) - 1):\\n return \\\"NA\\\"\\n else:\\n return mrnaseq_nogap[l_ext:u_ext]\\n elif ratio <= 0.5: # trim left - it means upstream (5'end)\\n li = span[0]\\n ui = span[1]\\n length = ui - li\\n dif = len(mrna_frag_nogap) - total_length\\n return mrnaseq_nogap[li + dif:ui]\\n elif ratio >= 1.5: # extend right - it means downstream (3'end)\\n li = span[0]\\n ui = span[1]\\n length = ui - li\\n dif = len(mrna_frag_nogap) - total_length\\n return mrnaseq_nogap[li:ui - dif]\",\n \"def _truncate_string(self, text, max_size):\\n import textwrap\\n\\n if len(text) <= max_size:\\n return text\\n return textwrap.wrap(text, max_size-3)[0] + \\\"...\\\"\",\n \"def trunc_inplace(a):\",\n \"def test_truncate_seqs(self):\\r\\n\\r\\n base_pos = 5\\r\\n\\r\\n fasta_seqs = {'seq1': 'GAAATCAAGAATAC',\\r\\n 'seq2': 'ATAAACAAGAT'}\\r\\n qual_scores = {'seq1': array(map(str, [20, 10, 15, 25, 24, 25, 27])),\\r\\n 'seq2': array(map(str, [22, 21, 15, 12, 22, 25, 27, 28]))}\\r\\n\\r\\n expected_fasta = {'seq1': 'GAAAT',\\r\\n 'seq2': 'ATAAA'}\\r\\n\\r\\n expected_qual = {'seq1': map(str, array([20, 10, 15, 25, 24])),\\r\\n 'seq2': map(str, array([22, 21, 15, 12, 22]))}\\r\\n\\r\\n actual_fasta_seqs, actual_qual_scores =\\\\\\r\\n truncate_seqs(fasta_seqs, qual_scores, base_pos)\\r\\n\\r\\n self.assertDictEqual(actual_fasta_seqs, expected_fasta)\\r\\n self.assertItemsEqual(expected_qual, actual_qual_scores)\",\n \"def truncate_signals(signals, length=None, samplerate=None):\\n if length is None:\\n return signals\\n if samplerate is not None:\\n length = round(samplerate * length)\\n\\n def truncation(signal):\\n return signal[..., :length]\\n\\n return _apply_to_signals(truncation, signals)\",\n \"def pad_tokens(x, max_length, pad_token_id,\\n truncate_from=\\\"left\\\",\\n pad_from=\\\"left\\\"):\\n assert truncate_from in (\\\"left\\\", \\\"right\\\")\\n assert pad_from in (\\\"left\\\", \\\"right\\\")\\n if len(x) > max_length:\\n if truncate_from == \\\"left\\\":\\n return x[-max_length:]\\n else:\\n return x[:max_length]\\n elif len(x) < max_length:\\n padding = [pad_token_id] * (max_length - len(x))\\n if pad_from == \\\"left\\\":\\n return padding + x\\n else:\\n return x + padding\\n else:\\n return x\",\n \"def truncate(text=\\\"\\\", max_len=50):\\n return text if len(text) < max_len else text[:max_len]\",\n \"def truncatesmart(value, limit=80):\\n\\n try:\\n limit = int(limit)\\n # invalid literal for int()\\n except ValueError:\\n # Fail silently.\\n return value\\n\\n # Make sure it's unicode\\n value = unicode(value)\\n\\n # Return the string itself if length is smaller or equal to the limit\\n if len(value) <= limit:\\n return value\\n\\n # Cut the string\\n value = value[:limit]\\n\\n return value + '...'\",\n \"def truncate(s, max_len=10) :\\n MAX_LEN = max_len\\n display_string = escape_for_display(s)\\n if len(s) == 0 :\\n return display_string # Display empty string token.\\n if len(s) > MAX_LEN :\\n display_string = display_string[0:MAX_LEN] + \\\"...\\\"\\n return display_string\",\n \"def truncate_description(description):\\n if len(description) <= 160 :\\n return description\\n\\n cut_desc = \\\"\\\"\\n character_counter = 0\\n for i, letter in enumerate(description) :\\n character_counter += 1\\n if character_counter > 160 :\\n if letter == ' ' :\\n return cut_desc+\\\"...\\\"\\n else :\\n return cut_desc.rsplit(' ',1)[0]+\\\"...\\\"\\n cut_desc += description[i]\\n return cut_desc\",\n \"def pad_seq(seq, max_seq_len=0):\\n if max_seq_len:\\n pad_len = max_seq_len - len(seq)\\n if pad_len > 0:\\n return np.concatenate([seq, np.zeros(pad_len, dtype=np.int64)])\\n elif pad_len < 0: # chop to fit\\n two_last_tokens = seq[-2:]\\n out = seq[:max_seq_len]\\n out[-2:] = two_last_tokens\\n return out.astype(np.int64)\\n return seq.astype(np.int64)\",\n \"def fast_forward_to_length(sequences, length):\\n return itertools.dropwhile(lambda seq: len(seq) != length, sequences)\",\n \"def remove_every_other(seq):\\n length = len(seq)\\n new_seq = seq[0:length:2]\\n return new_seq\",\n \"def truncate_string(text, length):\\n word_tokens = word_tokenize(text)\\n truncated = word_tokens[:length]\\n truncated_text = \\\" \\\".join(truncated)\\n return truncated_text\",\n \"def truncate(text, length=100, suffix=\\\"...\\\"):\\n if len(text) > length:\\n return text[: length - len(suffix)] + suffix\\n else:\\n return text\",\n \"def truncate(s):\\n truncate = whenFloating $ \\\\c e ->\\n if dangerouslySmall c e\\n then 0\\n else fromInteger $ c `quotInteger` magnitude (-e)\",\n \"def test_truncates_to_correct_size(self):\\n truncated = truncateFeedback(self.simpleTestString)\\n self.assertTrue(len(truncated) < 16000)\\n truncated = truncateFeedback(self.complicatedString)\\n self.assertTrue(len(truncated) < 16000)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8350219","0.8350219","0.8350219","0.8334177","0.83308214","0.83209616","0.8302651","0.83008575","0.8299758","0.8299758","0.8289869","0.82892597","0.8288885","0.8280558","0.82622397","0.82547146","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.8251895","0.82393414","0.8221394","0.8221394","0.8219125","0.81621796","0.8049963","0.7977625","0.78859013","0.77645457","0.77645457","0.76782703","0.7595379","0.7472622","0.7395533","0.7118285","0.6879421","0.65802157","0.6526709","0.6285459","0.62153745","0.6122734","0.6067807","0.6006387","0.59978825","0.5971672","0.5971672","0.5859187","0.58416826","0.5841678","0.5835902","0.5750511","0.572871","0.5707871","0.5701778","0.5690294","0.56891525","0.56858164","0.56840295","0.56005436","0.5579431","0.55693763","0.556896","0.55380267","0.5531859","0.55277276","0.5526574","0.5512613","0.5512613","0.5512613","0.5498131","0.54882157","0.54801923","0.5478129","0.5463013","0.54561543","0.5445229","0.5441065","0.54367125","0.54260373","0.5415514","0.5379853","0.5368602","0.5351211","0.5350351","0.5349813","0.5325778","0.5324221"],"string":"[\n \"0.8350219\",\n \"0.8350219\",\n \"0.8350219\",\n \"0.8334177\",\n \"0.83308214\",\n \"0.83209616\",\n \"0.8302651\",\n \"0.83008575\",\n \"0.8299758\",\n \"0.8299758\",\n \"0.8289869\",\n \"0.82892597\",\n \"0.8288885\",\n \"0.8280558\",\n \"0.82622397\",\n \"0.82547146\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.8251895\",\n \"0.82393414\",\n \"0.8221394\",\n \"0.8221394\",\n \"0.8219125\",\n \"0.81621796\",\n \"0.8049963\",\n \"0.7977625\",\n \"0.78859013\",\n \"0.77645457\",\n \"0.77645457\",\n \"0.76782703\",\n \"0.7595379\",\n \"0.7472622\",\n \"0.7395533\",\n \"0.7118285\",\n \"0.6879421\",\n \"0.65802157\",\n \"0.6526709\",\n \"0.6285459\",\n \"0.62153745\",\n \"0.6122734\",\n \"0.6067807\",\n \"0.6006387\",\n \"0.59978825\",\n \"0.5971672\",\n \"0.5971672\",\n \"0.5859187\",\n \"0.58416826\",\n \"0.5841678\",\n \"0.5835902\",\n \"0.5750511\",\n \"0.572871\",\n \"0.5707871\",\n \"0.5701778\",\n \"0.5690294\",\n \"0.56891525\",\n \"0.56858164\",\n \"0.56840295\",\n \"0.56005436\",\n \"0.5579431\",\n \"0.55693763\",\n \"0.556896\",\n \"0.55380267\",\n \"0.5531859\",\n \"0.55277276\",\n \"0.5526574\",\n \"0.5512613\",\n \"0.5512613\",\n \"0.5512613\",\n \"0.5498131\",\n \"0.54882157\",\n \"0.54801923\",\n \"0.5478129\",\n \"0.5463013\",\n \"0.54561543\",\n \"0.5445229\",\n \"0.5441065\",\n \"0.54367125\",\n \"0.54260373\",\n \"0.5415514\",\n \"0.5379853\",\n \"0.5368602\",\n \"0.5351211\",\n \"0.5350351\",\n \"0.5349813\",\n \"0.5325778\",\n \"0.5324221\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78222877"},"document_rank":{"kind":"string","value":"41"}}},{"rowIdx":95595,"cells":{"query":{"kind":"string","value":"Converts examples into TexttoText batches to be used with a model like T5. Inputs are prefixed with a text prompt that indicates the task to perform."},"document":{"kind":"string","value":"def convert_examples_to_features(self):\n features = []\n for ex_index, example in enumerate(self.examples):\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n\n text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)\n enc_query = self.tokenizer.text_to_ids(text_to_text_query)\n if len(enc_query) > self.max_seq_length:\n enc_query = enc_query[: self.max_seq_length]\n dec_query = (\n [self.tokenizer.bos_id]\n + self.tokenizer.text_to_ids(self.processor.label2string(example.label))\n + [self.tokenizer.eos_id]\n )\n\n dec_input = dec_query[:-1]\n labels = dec_query[1:]\n\n features.append([enc_query, dec_input, labels])\n\n return features"},"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 batch_tokenize_fn(examples):\n sources = examples[config.source_lang]\n targets = examples[config.target_lang]\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\n\n # setup the tokenizer for targets,\n # huggingface expects the target tokenized ids to be stored in the labels field\n with config.tokenizer.as_target_tokenizer():\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\n\n model_inputs[\"labels\"] = labels[\"input_ids\"]\n return model_inputs","def create_InputExamples(self, data, labels):\n examples = []\n for (i, u_tips) in enumerate(data):\n for text in u_tips:\n examples.append(\n run_classifier.InputExample(\n guid=None,\n text_a=text,\n text_b=None,\n label=np.argmax(labels[i])\n )\n )\n return examples","def create_examples(topics, sentences):\n input_examples = []\n \n for i in range(len(sentences)):\n input_examples.append(InputExample(text_a=topics[i], text_b=sentences[i], label='NoArgument'))\n return input_examples","def read_examples_string(input_text):#(input_file, input_text):\n examples = []\n unique_id = 0\n \n with io.StringIO(input_text) as reader:\n while True:\n line = tokenization.convert_to_unicode(reader.readline())\n if not line:\n break\n\n line = line.strip()\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n\n if m is None:\n text_a = line\n else:\n text_a = m.group(1)\n text_b = m.group(2)\n\n examples.append(InputExample(unique_id=unique_id,\n text_a=text_a, \n text_b=text_b))\n unique_id += 1\n return examples","def test_text_task(self):\n args = BASE_ARGS.copy()\n args.update(TEXT_ARGS)\n valid, test = testing_utils.train_model(args)\n self.assertLessEqual(\n valid['ppl'], 1.5, 'failed to train image_seq2seq on text task'\n )","def batchify(self, observations):\n # valid examples\n exs = [ex for ex in observations if 'text' in ex]\n # the indices of the valid (non-empty) tensors\n valid_inds = [i for i, ex in enumerate(observations) if 'text' in ex]\n\n # set up the input tensors\n batchsize = len(exs)\n if batchsize == 0:\n return None, None, None\n # tokenize the text\n parsed_x = [deque(maxlen=self.truncate) for _ in exs]\n for dq, ex in zip(parsed_x, exs):\n dq += self.parse(ex['text'])\n # parsed = [self.parse(ex['text']) for ex in exs]\n max_x_len = max((len(x) for x in parsed_x))\n for x in parsed_x:\n # left pad with zeros\n x.extendleft([self.fairseq_dict.pad()] * (max_x_len - len(x)))\n xs = torch.LongTensor(parsed_x)\n\n # set up the target tensors\n ys = None\n if 'labels' in exs[0]:\n # randomly select one of the labels to update on, if multiple\n labels = [random.choice(ex.get('labels', [''])) for ex in exs]\n parsed_y = [deque(maxlen=self.truncate) for _ in labels]\n for dq, y in zip(parsed_y, labels):\n dq.extendleft(reversed(self.parse(y)))\n for y in parsed_y:\n y.append(self.fairseq_dict.eos())\n # append EOS to each label\n max_y_len = max(len(y) for y in parsed_y)\n for y in parsed_y:\n y += [self.fairseq_dict.pad()] * (max_y_len - len(y))\n ys = torch.LongTensor(parsed_y)\n return xs, ys, valid_inds","def args_batch_to_text(args_batch: ArgsBatch) -> Text:\n lines = []\n for args in args_batch:\n lines.append('; '.join(str(a) for a in args))\n return '\\n'.join(lines)","def _create_examples(self, lines, kb_data, set_type):\n examples = []\n for idx, line in enumerate(lines):\n item = json.loads(line.strip())\n question_id = \"%s-%s\" % (set_type, idx)\n \n context_a_list = kb_data[idx]['answerA']\n context_b_list = kb_data[idx]['answerB']\n context_c_list = kb_data[idx]['answerC']\n\n context_a = \"\"\n for l in context_a_list[:1]:\n context_a += l.replace(\"\\n\",\". \")\n context_a = context_a[:-1]\n\n context_b = \"\"\n for l in context_b_list[:1]:\n context_b += l.replace(\"\\n\",\". \")\n context_b = context_b[:-1]\n\n context_c = \"\"\n for l in context_c_list[:1]:\n context_c += l.replace(\"\\n\",\". \")\n context_c = context_c[:-1]\n \n \n question = item[\"context\"] + item[\"question\"]\n endings = [item[\"answerA\"],item[\"answerB\"],item[\"answerC\"] ]\n label = item[\"correct\"]\n #race_id = \"%s-%s\" % (set_type, data_raw[\"race_id\"])\n #article = data_raw[\"article\"]\n #for i in range(len(data_raw[\"answers\"])):\n #truth = str(ord(data_raw[\"answers\"][i]) - ord(\"A\"))\n #question = data_raw[\"questions\"][i]\n #options = data_raw[\"options\"][i]\n\n examples.append(\n InputExample(\n example_id=question_id,\n question=question,\n contexts=[context_a,context_b,context_c],\n endings=[endings[0], endings[1], endings[2]],#, options[3]\n label=label,\n )\n )\n return examples","def _create_examples(self, lines):\n examples = []\n for (i, line) in enumerate(lines):\n logger.info(line)\n guid = int(line[0])\n label = int(line[1])\n text = \" \".join(clean_tokens(line[3].split()))\n if guid < 1000:\n args_char_offset = find_char_offsets(text, line[2].split(\"-\"))\n else:\n args_char_offset = [int(i) for i in line[2].split('-')]\n examples.append(\n InputExample(guid=guid, text=text, args_char_offset=args_char_offset, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = line[0]\n text_a = line[1] + \" . \" + line[2]\n text_b = line[-1]\n label = 0\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(self):\n features = []\n max_label_len = 0\n # find ou the max label length\n labels_list = []\n for ex_index, example in enumerate(self.examples):\n processor = example.processor\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\n max_label_len = max(len(label_ids), max_label_len)\n labels_list.append(label_ids)\n if self.max_seq_length_decoder is None:\n self.max_seq_length_decoder = max_label_len\n else:\n self.max_seq_length_decoder = max(\n self.max_seq_length_decoder, max_label_len\n ) # take the max of the two to be conservative\n for ex_index, example in enumerate(self.examples):\n taskname = example.taskname\n taskname_ids = self.tokenizer.text_to_ids(taskname)\n processor = example.processor\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n label_ids = labels_list[ex_index]\n enc_query = processor.get_ptune_query(\n example.content,\n self.pseudo_token_id,\n self.max_seq_length - self.max_seq_length_decoder + 1,\n self.templates,\n self.tokenizer,\n )\n input_ids = enc_query + label_ids[:-1]\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\n features.append([input_ids, labels, enc_query, taskname_ids])\n return features","def qkgnn_convert_examples_to_features(\r\n examples,\r\n tokenizer,\r\n max_length=512,\r\n task=None,\r\n label_list=None,\r\n output_mode=None,\r\n pad_on_left=False,\r\n pad_token=0,\r\n pad_token_segment_id=0,\r\n mask_padding_with_zero=True,\r\n):\r\n\r\n if task is not None:\r\n processor = gnn_processors[task]()\r\n if label_list is None:\r\n label_list = processor.get_labels()\r\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\r\n if output_mode is None:\r\n output_mode = gnn_output_modes[task]\r\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\r\n label_map = {label: i for i, label in enumerate(label_list)}\r\n\r\n\r\n # TODO : optimize this part if out of memory error occurs\r\n def convert_inputs_to_processed(inputs):\r\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\r\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\r\n # tokens are attended to.\r\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\r\n\r\n # Zero-pad up to the sequence length.\r\n padding_length = max_length - len(input_ids)\r\n if pad_on_left:\r\n input_ids = ([pad_token] * padding_length) + input_ids\r\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\r\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\r\n else:\r\n input_ids = input_ids + ([pad_token] * padding_length)\r\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\r\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\r\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\r\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\r\n len(attention_mask), max_length\r\n )\r\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\r\n len(token_type_ids), max_length\r\n )\r\n\r\n return input_ids, attention_mask, token_type_ids\r\n\r\n # TODO : optimize this part if out of memory error occurs\r\n def qkgnn_convert_single_exampl_to_feature(example, ex_index=10):\r\n inputs_q = tokenizer.encode_plus(example.text_a, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_k = tokenizer.encode_plus(example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk1 = tokenizer.encode_plus(example.text_a, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk2 = tokenizer.encode_plus(example.text_a, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk3 = tokenizer.encode_plus(example.text_a, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq1 = tokenizer.encode_plus(example.text_b, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq2 = tokenizer.encode_plus(example.text_b, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq3 = tokenizer.encode_plus(example.text_b, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk1 = tokenizer.encode_plus(example.text_b, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk2 = tokenizer.encode_plus(example.text_b, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk3 = tokenizer.encode_plus(example.text_b, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq1 = tokenizer.encode_plus(example.text_a, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq2 = tokenizer.encode_plus(example.text_a, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq3 = tokenizer.encode_plus(example.text_a, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n # generate [input_ids, input_mask, segment_ids]\r\n # for q self\r\n input_ids_q, input_mask_q, segment_ids_q = convert_inputs_to_processed(inputs_q)\r\n # for k self\r\n input_ids_k, input_mask_k, segment_ids_k = convert_inputs_to_processed(inputs_k)\r\n # for qk\r\n input_ids_qk, input_mask_qk, segment_ids_qk = convert_inputs_to_processed(inputs_qk)\r\n # for qk1\r\n input_ids_qk1, input_mask_qk1, segment_ids_qk1 = convert_inputs_to_processed(inputs_qk1)\r\n # for qk2\r\n input_ids_qk2, input_mask_qk2, segment_ids_qk2 = convert_inputs_to_processed(inputs_qk2)\r\n # for qk3\r\n input_ids_qk3, input_mask_qk3, segment_ids_qk3 = convert_inputs_to_processed(inputs_qk3)\r\n # for kq1\r\n input_ids_kq1, input_mask_kq1, segment_ids_kq1 = convert_inputs_to_processed(inputs_kq1)\r\n # for kq2\r\n input_ids_kq2, input_mask_kq2, segment_ids_kq2 = convert_inputs_to_processed(inputs_kq2)\r\n # for kq3\r\n input_ids_kq3, input_mask_kq3, segment_ids_kq3 = convert_inputs_to_processed(inputs_kq3)\r\n # for kk1\r\n input_ids_kk1, input_mask_kk1, segment_ids_kk1 = convert_inputs_to_processed(inputs_kk1)\r\n # for kk2\r\n input_ids_kk2, input_mask_kk2, segment_ids_kk2 = convert_inputs_to_processed(inputs_kk2)\r\n # for kk3\r\n input_ids_kk3, input_mask_kk3, segment_ids_kk3 = convert_inputs_to_processed(inputs_kk3)\r\n # for qq1\r\n input_ids_qq1, input_mask_qq1, segment_ids_qq1 = convert_inputs_to_processed(inputs_qq1)\r\n # for qq2\r\n input_ids_qq2, input_mask_qq2, segment_ids_qq2 = convert_inputs_to_processed(inputs_qq2)\r\n # for qq3\r\n input_ids_qq3, input_mask_qq3, segment_ids_qq3 = convert_inputs_to_processed(inputs_qq3)\r\n\r\n # generate label\r\n if output_mode == \"classification\" or output_mode == \"classification2\":\r\n label = label_map[example.label]\r\n elif output_mode == \"regression\":\r\n label = float(example.label)\r\n else:\r\n raise KeyError(output_mode)\r\n\r\n # log info\r\n if ex_index < 5:\r\n logger.info(\"*** Example ***\")\r\n logger.info(\"guid: %s\" % (example.guid))\r\n logger.info(\"text_a: %s\" % (example.text_a))\r\n logger.info(\"text_b: %s\" % (example.text_b))\r\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_qk]))\r\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in input_mask_qk]))\r\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in segment_ids_qk]))\r\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\r\n # generate the feature for single example\r\n feature = InputFeatures_GNN(\r\n input_ids_q=input_ids_q,\r\n input_mask_q=input_mask_q,\r\n segment_ids_q=segment_ids_q,\r\n\r\n input_ids_k=input_ids_k,\r\n input_mask_k=input_mask_k,\r\n segment_ids_k=segment_ids_k,\r\n\r\n input_ids_qk=input_ids_qk,\r\n input_mask_qk=input_mask_qk,\r\n segment_ids_qk=segment_ids_qk,\r\n\r\n input_ids_qk1=input_ids_qk1,\r\n input_mask_qk1=input_mask_qk1,\r\n segment_ids_qk1=segment_ids_qk1,\r\n input_ids_qk2=input_ids_qk2,\r\n input_mask_qk2=input_mask_qk2,\r\n segment_ids_qk2=segment_ids_qk2,\r\n input_ids_qk3=input_ids_qk3,\r\n input_mask_qk3=input_mask_qk3,\r\n segment_ids_qk3=segment_ids_qk3,\r\n\r\n input_ids_kq1=input_ids_kq1,\r\n input_mask_kq1=input_mask_kq1,\r\n segment_ids_kq1=segment_ids_kq1,\r\n input_ids_kq2=input_ids_kq2,\r\n input_mask_kq2=input_mask_kq2,\r\n segment_ids_kq2=segment_ids_kq2,\r\n input_ids_kq3=input_ids_kq3,\r\n input_mask_kq3=input_mask_kq3,\r\n segment_ids_kq3=segment_ids_kq3,\r\n\r\n input_ids_qq1=input_ids_qq1,\r\n input_mask_qq1=input_mask_qq1,\r\n segment_ids_qq1=segment_ids_qq1,\r\n input_ids_qq2=input_ids_qq2,\r\n input_mask_qq2=input_mask_qq2,\r\n segment_ids_qq2=segment_ids_qq2,\r\n input_ids_qq3=input_ids_qq3,\r\n input_mask_qq3=input_mask_qq3,\r\n segment_ids_qq3=segment_ids_qq3,\r\n\r\n input_ids_kk1=input_ids_kk1,\r\n input_mask_kk1=input_mask_kk1,\r\n segment_ids_kk1=segment_ids_kk1,\r\n input_ids_kk2=input_ids_kk2,\r\n input_mask_kk2=input_mask_kk2,\r\n segment_ids_kk2=segment_ids_kk2,\r\n input_ids_kk3=input_ids_kk3,\r\n input_mask_kk3=input_mask_kk3,\r\n segment_ids_kk3=segment_ids_kk3,\r\n\r\n row_id=int(example.guid),\r\n label_id=label,\r\n task_id=task,\r\n is_real_example=True)\r\n return feature\r\n\r\n features = []\r\n for (ex_index, example) in tqdm(enumerate(examples)):\r\n features.append(qkgnn_convert_single_exampl_to_feature(example, ex_index=ex_index))\r\n\r\n return features","def _create_examples(self, lines: List[str], mode: Split):\n examples = []\n text_index = 1 if mode == Split.test else 0\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, i)\n text_a = line[text_index]\n if len(line) > text_index + 1:\n label = line[text_index + 1]\n else:\n label = None\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self,lines, set_type):\n examples = []\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n text_b = tx.utils.compat_as_text(line[1])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n elif len(lines[1]) == 1: # text_a (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n elif len(lines[1]) == 3: # label text_a text_b\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n text_b = tx.utils.compat_as_text(line[2])\n\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n return examples","def create_examples(lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, str(i))\n text_a_id = line[0]\n text_a = tokenization.convert_to_unicode(line[1])\n text_b_id = line[2]\n text_b = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(InputExample(guid=guid, text_a_id=text_a_id, text_a=text_a, text_b_id=text_b_id, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[0])\n text_b = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines: List[str], mode: Split):\n # id,title,content,label\n test_mode = mode == Split.test\n title_index = 1\n content_index = 2\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[title_index]\n text_b = line[content_index]\n if test_mode:\n label = None\n else:\n label = line[3]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n text_b = tokenization.convert_to_unicode(line[2])\n label = tokenization.convert_to_unicode(line[3])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines: List[str], mode: Split):\n test_mode = mode == Split.test\n q1_index = 1 if test_mode else 3\n q2_index = 2 if test_mode else 4\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[q1_index]\n text_b = line[q2_index]\n label = None if test_mode else line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000000000\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\n\n query_tokens = tokenizer.tokenize(example.question_text)\n if max_query_length is None:\n max_query_length = len(query_tokens)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n for _ in enumerate(range(1)):\n tokens_ = []\n tokens_.append(\"[CLS]\")\n for token in query_tokens:\n tokens_.append(token)\n tokens_.append(\"[SEP]\")\n\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids_) < max_query_length + 2:\n input_ids_.append(0)\n input_mask_.append(0)\n\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n if example_index < 1:\n # logger.info(\"*** Example ***\")\n # logger.info(\"unique_id: %s\" % (unique_id))\n # logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in query_tokens]))\n # logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_]))\n # logger.info(\n # \"input_mask: %s\" % \" \".join([str(x) for x in input_mask_]))\n\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n unique_id += 1\n\n return question_features","def _create_examples(self, lines, set_type):\n test_mode = set_type == \"test\"\n if test_mode:\n lines = lines[1:]\n text_index = 1 if test_mode else 3\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[text_index]\n label = None if test_mode else line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n if set_type == \"test\":\n label = \"contradiction\"\n else:\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for i, line in lines.iterrows():\n guid = \"%s-%s\" % (set_type, i)\n text_a = line['sentence1']\n text_b = line['sentence2']\n label = line['label']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def print_examples(example_iter, model, num=0, max_len=100,\n bos_index=1,\n src_eos_index = None,\n trg_eos_index = None,\n src_vocab=None, trg_vocab=None):\n model.eval()\n count=0\n\n BOS_TOKEN = \"<s>\"\n EOS_TOKEN = \"</s>\"\n UNK_TOKEN = \"<unk>\"\n\n if src_vocab is not None and trg_vocab is not None:\n src_bos_index = src_vocab.stoi[BOS_TOKEN]\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\n trg_unk_index = trg_vocab.stoi[UNK_TOKEN]\n # trg_bos_index = trg_vocab.stoi[BOS_TOKEN]\n # trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\n else:\n src_bos_index = 0\n src_eos_index = 1\n trg_unk_index = 2\n # trg_bos_index = 1\n # trg_eos_index = None\n\n for i, batch in enumerate(example_iter, 1):\n src = batch.src.cpu().numpy()[0, :]\n trg_idx = batch.trg_idx.cpu().numpy()[0, :]\n\n # remove </s>\n src = src[1:] if src[0]==src_bos_index else src\n src = src[:-1] if src[-1]==src_eos_index else src\n # trg = trg[:-1] if trg[-1]==trg_eos_index else trg\n\n result = greedy_decode(model, batch.src_idx, batch.src_mask, batch.src_lengths)\n print()\n print(\"Example %d\" % i)\n print(\"Source: \", \" \".join(lookup_words(src, vocab=src_vocab)))\n print()\n print(\"Target: \", set(lookup_words(trg_idx, vocab=trg_vocab)))\n print()\n print(\"Prediction: \", \" \".join(lookup_words(result[0], vocab=trg_vocab)))\n\n count += 1\n if count == num:\n break","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[8]\n text_b = line[9]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, max_seq_length, tokenizer):\n\n features = []\n for (ex_index, example) in enumerate(examples):\n print(example.text_a)\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n input_mask = [1] * len(input_ids)\n\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n \n labels_ids = []\n for label in example.labels:\n labels_ids.append(int(label))\n \n if ex_index < 0:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %s)\" % (example.labels, labels_ids))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=labels_ids))\n return features","def _create_examples(self, data, set_type):\n examples = []\n for (i, elem) in enumerate(data):\n guid = \"%s-%s\" % (set_type, i)\n text = elem[0]\n label = elem[1]\n examples.append(\n InputExample(guid=guid, text=text, label=label))\n return examples","def generate_text(pmodel, num_generate, temperature, start_string):\n\n # Converting the start string to numbers (vectorizing)\n input_eval = [char2idx[s] for s in start_string]\n input_eval = tf.expand_dims(input_eval, 0)\n\n # Empty string to store the results\n text_generated = np.empty(1)\n\n # Here batch size = 1\n pmodel.reset_states()\n for i in range(num_generate):\n \n predictions = pmodel(input_eval)\n \n # remove the batch dimension\n predictions = tf.squeeze(predictions, 0)\n \n # using a multinomial distribution to predict the word returned by the model\n predictions = predictions / temperature\n predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\n \n # We pass the predicted word as the next input to the model\n # along with the previous hidden state\n input_eval = tf.expand_dims([predicted_id], 0)\n \n text_generated = np.vstack((text_generated, idx2char[predicted_id].tolist()))\n \n return text_generated","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n try:\n text_a = line[3]\n text_b = line[4]\n label = line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(\n examples: List[InputExample],\n label_list: List[str],\n max_length: int,\n tokenizer: PreTrainedTokenizer,\n pad_token_segment_id=0,\n pad_on_left=False,\n pad_token=0,\n mask_padding_with_zero=True,\n) -> List[InputFeatures]:\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\"convert examples to features\"):\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\n choices_features = []\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\n text_a = context\n if example.question.find(\"_\") != -1:\n # this is for cloze question\n text_b = example.question.replace(\"_\", ending)\n else:\n text_b = example.question + \" \" + ending\n if len(text_a) == 0:\n logger.info(\"context of example %d have length 0\" % (ex_index))\n text_a = \" \"\n\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\n if \"num_truncated_tokens\" in inputs and inputs[\"num_truncated_tokens\"] > 0:\n logger.info(\n \"Attention! you are cropping tokens (swag task is ok). \"\n \"If you are training ARC and RACE and you are poping question + options,\"\n \"you need to try to use a bigger max seq length!\"\n )\n\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length\n assert len(attention_mask) == max_length\n assert len(token_type_ids) == max_length\n choices_features.append((input_ids, attention_mask, token_type_ids))\n\n label = label_map[example.label]\n\n if ex_index < 2:\n logger.info(\"*** Example ***\")\n logger.info(\"race_id: {}\".format(example.example_id))\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\n logger.info(\"choice: {}\".format(choice_idx))\n logger.info(\"input_ids: {}\".format(\" \".join(map(str, input_ids))))\n logger.info(\"attention_mask: {}\".format(\" \".join(map(str, attention_mask))))\n logger.info(\"token_type_ids: {}\".format(\" \".join(map(str, token_type_ids))))\n logger.info(\"label: {}\".format(label))\n\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\n\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for i, line in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[5]\n text_b = line[6]\n pairID = line[7][2:] if line[7].startswith(\"ex\") else line[7]\n label = line[0]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n text_a = line[1]\n text_b = line[2]\n label = line[-1] if set_type != \"test\" else \"entailment\"\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n # label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n exindex = {}\n passagelens = []\n\n sum_of_labels = 0\n\n for (ex_index, example) in tqdm(enumerate(examples), desc=\"Tokenizing:\"):\n if example.text_a not in tokenmap.keys():\n tokens_a = tokenizer.tokenize(example.text_a)\n tokenmap[example.text_a] = tokens_a\n else:\n tokens_a = tokenmap[example.text_a]\n\n tokens_b = None\n if example.text_b:\n if example.text_b not in tokenmap.keys():\n tokens_b = tokenizer.tokenize(example.text_b)\n tokenmap[example.text_b] = tokens_b\n else:\n tokens_b = tokenmap[example.text_b]\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\n\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n # label_id = label_map[example.label]\n label_id = example.label\n\n sum_of_labels += label_id\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %d)\" % (str(example.label), 0))\n\n exindex[ex_index] = example.guid\n features.append(\n InputFeatures(uuid=ex_index,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n\n print(\"Passage Token Lengths Distribution\", passagelens[-1], np.percentile(passagelens, 50),\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\n return features, exindex","def convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n multilabel=False,\n):\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n if multilabel:\n domain_label_map = {label: i for i, label in enumerate([\"0\", \"1\"])}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, )\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label = label_map[example.label] if not multilabel else label_map[example.label[0]]\n elif output_mode == \"regression\":\n label = float(example.label) if not multilabel else float(example.label[0])\n else:\n raise KeyError(output_mode)\n if multilabel:\n label = [label, domain_label_map[example.label[1]]]\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n if multilabel:\n logger.info(\"label: %s (id = %d)\" % (example.label[0], label[0]))\n logger.info(\"domain label: %s (id = %d)\" % (example.label[1], label[1]))\n else:\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\n )\n )\n\n return features","def glue_convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n):\n is_tf_dataset = False\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\n is_tf_dataset = True\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = 0\n if is_tf_dataset:\n example = processor.get_example_from_tensor_dict(example)\n example = processor.tfds_map(example)\n len_examples = tf.data.experimental.cardinality(examples)\n else:\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label_id = label_map[example.label]\n elif output_mode == \"regression\":\n label_id = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label_id=label_id\n )\n )\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # if i == 0:\n # continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[1]\n text_b = None\n label = line[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # if i == 0:\n # continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[1]\n text_b = None\n label = line[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n text_a = lines[ids]['sentence']\n examples.append(\n InputExample(text_a=text_a) )\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n text_b = line[4]\r\n# if set_type == 'test':\r\n# label = self.get_labels()[0]\r\n# else:\r\n# label = line[0]\r\n label = line[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = None if set_type == \"test\" else line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[0]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n try:\n text_a = line[3] if set_type != \"test\" else line[1]\n text_b = line[4] if set_type != \"test\" else line[2]\n label = line[5] if set_type != \"test\" else \"0\"\n except IndexError:\n continue\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n if set_type == \"test\":\n label = \"0\"\n else:\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens = example.text\n\n# # Account for [CLS] and [SEP] with \"- 2\"\n# if len(tokens) > max_seq_length - 2:\n# tokens = tokens[:(max_seq_length - 2)]\n\n bert_tokens = []\n orig_to_tok_map = []\n\n bert_tokens.append(\"[CLS]\")\n for token in tokens:\n new_tokens = tokenizer.tokenize(token)\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\n # print(\"You shouldn't see this since the test set is already pre-separated.\")\n break\n else:\n orig_to_tok_map.append(len(bert_tokens))\n bert_tokens.extend(new_tokens)\n bert_tokens.append(\"[SEP]\")\n\n if len(bert_tokens) == 2: # edge case\n continue\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n\n segment_ids = [0] * max_seq_length # no use for our problem\n\n labels = example.label\n label_ids = [0] * max_seq_length\n label_mask = [0] * max_seq_length\n\n for label, target_index in zip(labels, orig_to_tok_map):\n label_ids[target_index] = label_map[label]\n label_mask[target_index] = 1\n\n assert len(segment_ids) == max_seq_length\n assert len(label_ids) == max_seq_length\n assert len(label_mask) == max_seq_length\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=label_ids,\n label_mask=label_mask))\n return features","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n text_b = line[4]\r\n label = line[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[8]\r\n text_b = line[9]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[7]\r\n text_b = line[8]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def read_examples(input_file):\n examples = []\n unique_id = 0\n with tf.gfile.GFile(input_file, \"r\") as reader:\n while True:\n line = tokenization.convert_to_unicode(reader.readline())\n if not line:\n break\n \n line = line.strip()\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n \n if m is None:\n text_a = line\n else:\n text_a = m.group(1)\n text_b = m.group(2)\n examples.append(InputExample(unique_id=unique_id,\n text_a=text_a, \n text_b=text_b))\n unique_id += 1\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[0]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[1]\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n\r\n return examples","def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\r\n label_map = {}\r\n for (i, label) in enumerate(label_list):\r\n label_map[label] = i\r\n\r\n input_data=[]\r\n for (ex_index, example) in enumerate(examples):\r\n tokens_a = tokenizer.tokenize(example.text_a)\r\n tokens_b = None\r\n if example.text_b:\r\n tokens_b = tokenizer.tokenize(example.text_b)\r\n if tokens_b:\r\n # Modifies `tokens_a` and `tokens_b` in place so that the total\r\n # length is less than the specified length.\r\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\r\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\r\n else:\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n if len(tokens_a) > max_seq_length - 2:\r\n tokens_a = tokens_a[0:(max_seq_length - 2)]\r\n\r\n if ex_index % 10000 == 0:\r\n tf.logging.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\r\n\r\n # The convention in BERT is:\r\n # (a) For sequence pairs:\r\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\r\n # (b) For single sequences:\r\n # tokens: [CLS] the dog is hairy . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0\r\n #\r\n # Where \"type_ids\" are used to indicate whether this is the first\r\n # sequence or the second sequence. The embedding vectors for `type=0` and\r\n # `type=1` were learned during pre-training and are added to the wordpiece\r\n # embedding vector (and position vector). This is not *strictly* necessary\r\n # since the [SEP] token unambigiously separates the sequences, but it makes\r\n # it easier for the model to learn the concept of sequences.\r\n #\r\n # For classification tasks, the first vector (corresponding to [CLS]) is\r\n # used as as the \"sentence vector\". Note that this only makes sense because\r\n # the entire model is fine-tuned.\r\n tokens = []\r\n segment_ids = []\r\n tokens.append(\"[CLS]\")\r\n segment_ids.append(0)\r\n for token in tokens_a:\r\n tokens.append(token)\r\n segment_ids.append(0)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(0)\r\n\r\n if tokens_b:\r\n for token in tokens_b:\r\n tokens.append(token)\r\n segment_ids.append(1)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(1)\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n input_mask = [1] * len(input_ids)\r\n\r\n while len(input_ids) < max_seq_length:\r\n input_ids.append(0)\r\n input_mask.append(0)\r\n segment_ids.append(0)\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n label_id = label_map[example.label]\r\n if ex_index < 3:\r\n tf.logging.info(\"*** Example ***\")\r\n tf.logging.info(\"guid: %s\" % (example.guid))\r\n tf.logging.info(\"tokens: %s\" % \" \".join([tokenization.printable_text(x) for x in tokens]))\r\n tf.logging.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\r\n tf.logging.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\r\n tf.logging.info(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\r\n tf.logging.info(\"label: %s (id = %d)\" % (example.label, label_id))\r\n\r\n features = collections.OrderedDict()\r\n features[\"input_ids\"] = input_ids\r\n features[\"input_mask\"] = input_mask\r\n features[\"segment_ids\"] = segment_ids\r\n features[\"label_ids\"] =label_id\r\n input_data.append(features)\r\n\r\n return input_data","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"][\"text\"]\n for Q in data[\"passage\"][\"questions\"]:\n question = Q[\"question\"]\n for A in Q[\"answers\"]:\n guid = f\"{set_type}-{data['idx']-Q['idx']-A['idx']}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage,\n text_b=question + \" \" + A[\"text\"],\n label=str(A[\"label\"]),\n )\n )\n return examples","def _create_examples(self, data_dir, set_type):\n\t\texamples = []\n\t\tinput_file_data = os.path.join(data_dir, \"data.tsv\")\n\t\twith open(input_file_data, \"r\", encoding=\"utf-8-sig\") as f:\n\t\t\tfor i, inp in enumerate(f):\n\t\t\t\tinps = inp.split('\\t') \n\t\t\t\tguid = \"%s-%s\" % (set_type, i)\n\t\t\t\ttext_inp = inps[1].strip()\n\t\t\t\ttext_out = inps[2].strip()\n\t\t\t\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\n\t\t\t\t\n\t\t\t# Sort these out before returning\n\t\t\texamples = sorted(examples, key=sort_inp_len)\n\t\t\treturn examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[8]\r\n text_b = line[9]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _convert_single_example(self, text_a, text_b):\n tokens = []\n input_ids = []\n segment_ids = []\n input_mask = []\n try:\n text_a = self.tokenizer.tokenize(text_a)\n if text_b:\n text_b = self.tokenizer.tokenize(text_b)\n self._truncate_seq_pair(text_a, text_b)\n\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n\n for token in text_a:\n tokens.append(token)\n segment_ids.append(0)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n\n if text_b:\n for token in text_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append('[SEP]')\n segment_ids.append(1)\n\n input_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n\n input_mask = [1] * len(input_ids)\n\n while len(input_ids) < 50:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n except:\n self.logger.error()\n\n finally:\n return input_ids, input_mask, segment_ids","def print_examples(example_iter, model, n=2, max_len=100, \n sos_index=1, \n src_eos_index=None, \n trg_eos_index=None, \n src_vocab=None, trg_vocab=None):\n\n model.eval()\n count = 0\n print()\n \n if src_vocab is not None and trg_vocab is not None:\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\n trg_sos_index = trg_vocab.stoi[SOS_TOKEN]\n trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\n else:\n src_eos_index = None\n trg_sos_index = 1\n trg_eos_index = None\n \n for i, batch in enumerate(example_iter):\n \n src = batch.src.cpu().numpy()[0, :]\n trg = batch.trg_y.cpu().numpy()[0, :]\n\n # remove </s> (if it is there)\n src = src[:-1] if src[-1] == src_eos_index else src\n trg = trg[:-1] if trg[-1] == trg_eos_index else trg \n \n result, _ = beam_decode(\n model, batch.src, batch.src_mask, batch.src_lengths,\n max_len=max_len, sos_index=trg_sos_index, eos_index=trg_eos_index)\n print(\"Example #%d\" % (i+1))\n print(\"Src : \", \" \".join(lookup_words(src, vocab=src_vocab)))\n print(\"Trg : \", \" \".join(lookup_words(trg, vocab=trg_vocab)))\n print(\"Pred: \", \" \".join(lookup_words(result, vocab=trg_vocab)))\n print()\n \n count += 1\n if count == n:\n break","def _create_examples(self, lines, set_type):\n examples = []\n \n for (i, line) in enumerate(lines):\n sentence_number = 0\n premise_text = line[\"premise\"]\n modified_premise_text = re.sub(self.stage_name_pattern,\"\",premise_text)\n modified_premise_text = re.sub(self.w_patterns,\"\",modified_premise_text)\n hypothesis_text = line[\"hypothesis\"]\n hypothesis_text = re.sub(self.w_patterns,\"\",hypothesis_text)\n a_label = int(line[\"label\"])\n\n sentences = modified_premise_text.split('.')\n\n for j, sentence in enumerate(sentences):\n guid = \"\" + str(sentence_number) + \"\\t\" + str(i) + \"\\t\" + str(len(sentences)) + \"\\t\" + str(a_label)\n text_a = sentence\n text_b = hypothesis_text\n label = a_label\n sentence_number += 1\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n #print(\"16th sentence::\",sentences[16])\n\n return examples","def text_generator(self, example_generator):\n\t\tif self._data_as_tf_example:\n\t\t\tquery_text = None\n\t\t\tquery_edge_list = None\n\t\t\tword_edge_list = None\n\t\t\t\n\t\t\twhile True:\n\t\t\t\te, epoch_num = example_generator.next() # e is a tf.Example\n\t\t\t\ttry:\n\t\t\t\t\tarticle_text = e.features.feature['article'].bytes_list.value[0] # document text\n\t\t\t\t\tabstract_text = e.features.feature['abstract'].bytes_list.value[0] # response text\n\t\t\t\t\tif self._hps.query_encoder.value:\n\t\t\t\t\t\ttry:\n\t\t\t\t\t\t\tquery_text = e.features.feature['query'].bytes_list.value[0] # context text\n\t\t\t\t\t\texcept:\n\t\t\t\t\t\t\tquery_text = ''\n\t\t\t\t\tif self._hps.word_gcn.value:\n\t\t\t\t\t\tword_edge_list = []\n\t\t\t\t\t\tif self._hps.use_default_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t#tf.logging.info((word_edge_list[0]))\n\t\t\t\t\t\tif self._hps.use_coref_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_coref_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_entity_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_entity_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_lexical_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_lexical_edge_list'].bytes_list.value[0])\n\t\t\t\t\t#\tprint(word_edge_list)\n\t\t\t\t\t\n\n\t\t\t\t\tif self._hps.query_gcn.value:\n\t\t\t\t\t\tquery_edge_list = []\n\t\t\t\t\t\tif self._hps.use_default_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t\n\t\t\t\t\t\t'''\n\t\t\t\t\t\tThese are inter-sentence graph and may not be applicable\n\t\t\t\t\t\tif self._hps.use_coref_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_coref_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_entity_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_entity_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_lexical_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_lexical_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t'''\n\n\n\n\t\t\t\texcept ValueError:\n\t\t\t\t\ttf.logging.error('Failed to get article or abstract from example')\n\t\t\t\t\tcontinue\n\t\t\t\tif len(article_text)==0: # See https://github.com/abisee/pointer-generator/issues/1\n\t\t\t\t\ttf.logging.warning('Found an example with empty article text. Skipping it.')\n\t\t\t\telse:\n\t\t\t\t\t#tf.logging.info(abstract_text)\n\t\t\t\t\tyield (article_text, abstract_text, word_edge_list, query_text, query_edge_list, epoch_num)\n\t\t\t\n\t\telse:\n\n\t\t\twhile True:\n\t\t\t\te = example_generator.next()\n\t\t\t\tyield e","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n examples.append(\n InputExample(\n guid=f\"{set_type}-{data['idx']}\",\n text_a=data[\"passage\"],\n text_b=data[\"question\"],\n label=str(data[\"label\"]),\n )\n )\n return examples","def generate_tpu(self, prompts: List[str]):\n from flax.training.common_utils import shard # pylint:disable=g-import-not-at-top,g-importing-member\n import jax # pylint:disable=g-import-not-at-top\n import time # pylint:disable=g-import-not-at-top\n import numpy as np # pylint:disable=g-import-not-at-top\n\n rng = jax.random.PRNGKey(0)\n rng = jax.random.split(rng, jax.device_count())\n\n assert prompts, \"prompt parameter cannot be empty\"\n print(\"Prompts: \", prompts)\n prompt_ids = self._pipeline.prepare_inputs(prompts)\n prompt_ids = shard(prompt_ids)\n print(\"Sharded prompt ids has shape:\", prompt_ids.shape)\n if self._run_with_profiler:\n jax.profiler.start_trace(self._profiler_dir)\n\n time_start = time.time()\n images = self._p_generate(prompt_ids, self._p_params, rng)\n images = images.block_until_ready()\n elapsed = time.time() - time_start\n if self._run_with_profiler:\n jax.profiler.stop_trace()\n\n print(\"Inference time (in seconds): \", elapsed)\n print(\"Shape of the predictions: \", images.shape)\n images = images.reshape(\n (images.shape[0] * images.shape[1],) + images.shape[-3:])\n print(\"Shape of images afterwards: \", images.shape)\n return self._pipeline.numpy_to_pil(np.array(images))","def translate_interactive(estimator, tokenizer_):\n \n predictor = ContinuePredict(estimator, continue_input_fn)\n while True:\n tf.logging.info(\"Enter the English sentence end with ENTER.\")\n raw_text = input().strip()\n if raw_text == r'\\q':\n predictor.close()\n break\n encoded_txt = _encode_and_add_eos(raw_text, tokenizer_)\n target = predictor.predict(encoded_txt)\n target = next(target)['outputs']\n target = _trim_and_decode(target, tokenizer_)\n tf.logging.info('\\t{}'.format(target))","def generate_text(session, model, config, starting_text='<eos>',\n stop_length=100, stop_tokens=None, temp=1.0):\n state = model.initial_state.eval()\n # Imagine tokens as a batch size of one, length of len(tokens[0])\n tokens = [model.vocab.encode(word) for word in starting_text.split()]\n for i in xrange(stop_length):\n ### YOUR CODE HERE\n #print tokens\n feed = {}\n #x = np.array([tokens[-1]])\n #x.reshape(1,1)\n feed[model.input_placeholder] = [[tokens[-1]]]\n feed[model.dropout_placeholder] = 1\n feed[model.initial_state] = state\n y_pred, state = session.run([model.predictions[-1], model.final_state], feed_dict=feed)\n ### END YOUR CODE\n next_word_idx = sample(y_pred[0], temperature=temp)\n tokens.append(next_word_idx)\n if stop_tokens and model.vocab.decode(tokens[-1]) in stop_tokens:\n break\n output = [model.vocab.decode(word_idx) for word_idx in tokens]\n return output","def batchify(TEXT, data, batch_size, device):\r\n data = TEXT.numericalize([data.examples[0].text])\r\n num_batches = data.size(0)//batch_size\r\n data = data.narrow(0, 0, num_batches * batch_size)\r\n data = data.view(batch_size, -1).t().contiguous()\r\n\r\n return data.to(device)","def convert_example(example,\n tokenizer,\n label_list,\n max_seq_length=512,\n is_test=False):\n\n def _truncate_seqs(seqs, max_seq_length):\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n tokens_a, tokens_b = seqs\n max_seq_length -= 3\n while True: # truncate with longest_first strategy\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_seq_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()\n return seqs\n\n def _concat_seqs(seqs, separators, seq_mask=0, separator_mask=1):\n concat = sum((seq + sep for sep, seq in zip(separators, seqs)), [])\n segment_ids = sum(\n ([i] * (len(seq) + len(sep))\n for i, (sep, seq) in enumerate(zip(separators, seqs))), [])\n if isinstance(seq_mask, int):\n seq_mask = [[seq_mask] * len(seq) for seq in seqs]\n if isinstance(separator_mask, int):\n separator_mask = [[separator_mask] * len(sep) for sep in separators]\n p_mask = sum((s_mask + mask\n for sep, seq, s_mask, mask in zip(\n separators, seqs, seq_mask, separator_mask)), [])\n return concat, segment_ids, p_mask\n\n if not is_test:\n # `label_list == None` is for regression task\n label_dtype = \"int64\" if label_list else \"float32\"\n # get the label\n label = example[-2]\n example = example[:-2]\n #create label maps if classification task\n if label_list:\n label_map = {}\n for (i, l) in enumerate(label_list):\n label_map[l] = i\n label = label_map[label]\n label = np.array([label], dtype=label_dtype)\n else:\n qas_id = example[-1]\n example = example[:-2]\n # tokenize raw text\n tokens_raw = [tokenizer(l) for l in example]\n # truncate to the truncate_length,\n tokens_trun = _truncate_seqs(tokens_raw, max_seq_length)\n # concate the sequences with special tokens\n tokens_trun[0] = [tokenizer.cls_token] + tokens_trun[0]\n tokens, segment_ids, _ = _concat_seqs(tokens_trun, [[tokenizer.sep_token]] *\n len(tokens_trun))\n # convert the token to ids\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n valid_length = len(input_ids)\n\n if not is_test:\n return input_ids, segment_ids, valid_length, label\n else:\n return input_ids, segment_ids, valid_length, qas_id","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[3]\r\n text_b = line[4]\r\n label = line[5]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[1]\r\n text_b = line[2]\r\n label = self.get_labels()[0]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n\r\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[0]\n label = line[1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n guid = \"%s-%s\" % (set_type, i)\r\n if set_type != 'test':\r\n text_a = line[3]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n else:\r\n if i == 0:\r\n continue\r\n text_a = line[1]\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def query(self,text_input,prefix='answer:',convert_to_string=True):\n predictions, raw_outputs = self.model.predict([text_input])\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\n return self._post_process_output(preds,convert_to_string=convert_to_string)","def sample_to_features_text(\n sample, tasks, max_seq_len, tokenizer\n):\n\n if tokenizer.is_fast:\n text = sample.clear_text[\"text\"]\n # Here, we tokenize the sample for the second time to get all relevant ids\n # This should change once we git rid of FARM's tokenize_with_metadata()\n inputs = tokenizer(text,\n return_token_type_ids=True,\n truncation=True,\n truncation_strategy=\"longest_first\",\n max_length=max_seq_len,\n return_special_tokens_mask=True)\n\n if (len(inputs[\"input_ids\"]) - inputs[\"special_tokens_mask\"].count(1)) != len(sample.tokenized[\"tokens\"]):\n logger.error(f\"FastTokenizer encoded sample {sample.clear_text['text']} to \"\n f\"{len(inputs['input_ids']) - inputs['special_tokens_mask'].count(1)} tokens, which differs \"\n f\"from number of tokens produced in tokenize_with_metadata(). \\n\"\n f\"Further processing is likely to be wrong.\")\n else:\n # TODO It might be cleaner to adjust the data structure in sample.tokenized\n tokens_a = sample.tokenized[\"tokens\"]\n tokens_b = sample.tokenized.get(\"tokens_b\", None)\n\n inputs = tokenizer.encode_plus(\n tokens_a,\n tokens_b,\n add_special_tokens=True,\n truncation=False, # truncation_strategy is deprecated\n return_token_type_ids=True,\n is_split_into_words=False,\n )\n\n input_ids, segment_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n padding_mask = [1] * len(input_ids)\n\n # Padding up to the sequence length.\n # Normal case: adding multiple 0 to the right\n # Special cases:\n # a) xlnet pads on the left and uses \"4\" for padding token_type_ids\n if tokenizer.__class__.__name__ == \"XLNetTokenizer\":\n pad_on_left = True\n segment_ids = pad(segment_ids, max_seq_len, 4, pad_on_left=pad_on_left)\n else:\n pad_on_left = False\n segment_ids = pad(segment_ids, max_seq_len, 0, pad_on_left=pad_on_left)\n\n input_ids = pad(input_ids, max_seq_len, tokenizer.pad_token_id, pad_on_left=pad_on_left)\n padding_mask = pad(padding_mask, max_seq_len, 0, pad_on_left=pad_on_left)\n\n assert len(input_ids) == max_seq_len\n assert len(padding_mask) == max_seq_len\n assert len(segment_ids) == max_seq_len\n\n feat_dict = {\n \"input_ids\": input_ids,\n \"padding_mask\": padding_mask,\n \"segment_ids\": segment_ids,\n }\n\n # Add Labels for different tasks\n for task_name, task in tasks.items():\n try:\n label_name = task[\"label_name\"]\n label_raw = sample.clear_text[label_name]\n label_list = task[\"label_list\"]\n if task[\"task_type\"] == \"classification\":\n # id of label\n try:\n label_ids = [label_list.index(label_raw)]\n except ValueError as e:\n raise ValueError(f'[Task: {task_name}] Observed label {label_raw} not in defined label_list')\n elif task[\"task_type\"] == \"multilabel_classification\":\n # multi-hot-format\n label_ids = [0] * len(label_list)\n for l in label_raw.split(\",\"):\n if l != \"\":\n label_ids[label_list.index(l)] = 1\n elif task[\"task_type\"] == \"regression\":\n label_ids = [float(label_raw)]\n else:\n raise ValueError(task[\"task_type\"])\n except KeyError:\n # For inference mode we don't expect labels\n label_ids = None\n if label_ids is not None:\n feat_dict[task[\"label_tensor_name\"]] = label_ids\n return [feat_dict]","def tokenize_nmt(text, num_examples=None):\n source, target = [], []\n for i, line in enumerate(text.split('\\n')):\n if num_examples and i > num_examples:\n break\n parts = line.split('\\t')\n if len(parts) == 2:\n source.append(parts[0].split(' '))\n target.append(parts[1].split(' '))\n return source, target","def process(self, example: str) -> List[torch.Tensor]:\n return self._tokenizer.batch_encode_plus([example], return_tensors=\"pt\", output_past=True, max_length=self.max_seq_len)['input_ids'][0]","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def main():\n # Load and prep training files\n raw_speech_text = hg.load_training_file('trump_train.txt')\n speech_text = hg.prep_training(raw_speech_text)\n tweet_data = load_tweets('trump_tweets.json')\n raw_tweets = \"\"\n for dct in tweet_data:\n raw_tweets += \"{} \".format(dct['text'])\n tweets = hg.prep_training(raw_tweets)\n corpus = speech_text + tweets\n corpus = strip_punctuation(corpus)\n dict_1 = hg.map_one_to_one(corpus)\n dict_2 = hg.map_two_to_one(corpus)\n text = []\n \n # Introduction\n print(\"\\nTrump Speech Generator\\n\")\n print(\"Select words to add to speech\")\n print(\"\\'x\\' to exit\")\n print(\"\\'p\\' to add punctuation\")\n print(\"Select \\'p\\' before selecting the word you want to punctuate\")\n\n # Select first word\n options = corpus\n print ()\n selection = select_word(corpus)\n text.append(selection)\n \n # Select second word\n last = text[0]\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n # Select subsequent word\n while True:\n last = \"{} {}\".format(text[-2].strip(punctuation),\n text[-1].strip(punctuation))\n options = word_after_two(last, dict_2)\n if options == []:\n last = last.split()[1]\n options = word_after_one(last, dict_1)\n while options == []:\n last = random.choice(corpus)\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n print_text(text)","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n if i <= 3:\n print(\"i={}, line={}\".format(i, line))\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for idx, line in enumerate(lines):\n item = json.loads(line.strip())\n question_id = \"%s-%s\" % (set_type, idx)\n context = item[\"context\"]\n question = item[\"question\"]\n endings = [item[\"answerA\"],item[\"answerB\"],item[\"answerC\"] ]\n label = item[\"correct\"]\n #race_id = \"%s-%s\" % (set_type, data_raw[\"race_id\"])\n #article = data_raw[\"article\"]\n #for i in range(len(data_raw[\"answers\"])):\n #truth = str(ord(data_raw[\"answers\"][i]) - ord(\"A\"))\n #question = data_raw[\"questions\"][i]\n #options = data_raw[\"options\"][i]\n\n examples.append(\n InputExample(\n example_id=question_id,\n question=question,\n contexts=[context,context,context],\n endings=[endings[0], endings[1], endings[2]],#, options[3]\n label=label,\n )\n )\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test_matched':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"]\n ents_pos = [(pos[\"start\"], pos[\"end\"])\n for pos in passage[\"entities\"]]\n ents = [passage[\"text\"][start:end+1] for start, end in ents_pos]\n for qa in data[\"qas\"]:\n qa_id = f\"{set_type}-{data['idx']}-{qa['idx']}\"\n answers = set([ans[\"text\"] for ans in qa[\"answers\"]])\n for ent_idx, ent in enumerate(ents):\n is_answer = ent in answers\n guid = f\"{qa_id}-{ent_idx}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage[\"text\"],\n # Insert entity in query\n text_b=qa[\"query\"].replace(\"@placeholder\", ent),\n label=\"1\" if is_answer else \"0\",\n )\n )\n return examples","def run_prediction(question_texts, context_text):\r\n examples = []\r\n\r\n for i, question_text in enumerate(question_texts):\r\n example = SquadExample(\r\n qas_id=str(i),\r\n question_text=question_text,\r\n context_text=context_text,\r\n answer_text=None,\r\n start_position_character=None,\r\n title=\"Predict\",\r\n is_impossible=False,\r\n answers=None,\r\n )\r\n\r\n examples.append(example)\r\n\r\n features, dataset = squad_convert_examples_to_features(\r\n examples=examples,\r\n tokenizer=tokenizer,\r\n max_seq_length=384,\r\n doc_stride=128,\r\n max_query_length=64,\r\n is_training=False,\r\n return_dataset=\"pt\",\r\n threads=1,\r\n )\r\n\r\n eval_sampler = SequentialSampler(dataset)\r\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\r\n\r\n all_results = []\r\n\r\n for batch in eval_dataloader:\r\n model.eval()\r\n batch = tuple(t.to(device) for t in batch)\r\n\r\n with torch.no_grad():\r\n inputs = {\r\n \"input_ids\": batch[0],\r\n \"attention_mask\": batch[1],\r\n \"token_type_ids\": batch[2],\r\n }\r\n\r\n example_indices = batch[3]\r\n\r\n outputs = model(**inputs)\r\n\r\n for i, example_index in enumerate(example_indices):\r\n eval_feature = features[example_index.item()]\r\n unique_id = int(eval_feature.unique_id)\r\n\r\n output = [to_list(output[i]) for output in outputs]\r\n\r\n start_logits, end_logits = output\r\n result = SquadResult(unique_id, start_logits, end_logits)\r\n all_results.append(result)\r\n\r\n output_prediction_file = \"predictions.json\"\r\n output_nbest_file = \"nbest_predictions.json\"\r\n output_null_log_odds_file = \"null_predictions.json\"\r\n\r\n predictions = compute_predictions_logits(\r\n examples,\r\n features,\r\n all_results,\r\n n_best_size,\r\n max_answer_length,\r\n do_lower_case,\r\n output_prediction_file,\r\n output_nbest_file,\r\n output_null_log_odds_file,\r\n False, # verbose_logging\r\n True, # version_2_with_negative\r\n null_score_diff_threshold,\r\n tokenizer,\r\n )\r\n\r\n return predictions","def get_transformed_io(data_path, data_dir):\n sents, labels = read_line_examples_from_file(data_path)\n\n # the input is just the raw sentence\n inputs = [s.copy() for s in sents]\n\n task = 'asqp'\n if task == 'aste':\n targets = get_para_aste_targets(sents, labels)\n elif task == 'tasd':\n targets = get_para_tasd_targets(sents, labels)\n elif task == 'asqp':\n targets = get_para_asqp_targets(sents, labels)\n else:\n raise NotImplementedError\n\n return inputs, targets","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, type):\n examples = []\n\n for i in range(0, len(lines), self.interval):\n text_a = lines[i]\n label = lines[i + 2]\n\n examples.append(\n InputExample(guid=len(examples), text_a=text_a, pos=None, label=label))\n return examples","def _create_examples(self, df, set_type):\n examples = []\n for i, row in df.iterrows():\n guid = \"%s-%s\" % (set_type, i)\n text_a = row[4]\n label = row[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, ids )\n text_a = lines[ids]['term']\n text_b = lines[ids]['sentence']\n label = lines[ids]['polarity']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n label_id = label_map[example.label]\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # Only the test set has a header\n if set_type == \"test\" and i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples"],"string":"[\n \"def batch_tokenize_fn(examples):\\n sources = examples[config.source_lang]\\n targets = examples[config.target_lang]\\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\\n\\n # setup the tokenizer for targets,\\n # huggingface expects the target tokenized ids to be stored in the labels field\\n with config.tokenizer.as_target_tokenizer():\\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\\n\\n model_inputs[\\\"labels\\\"] = labels[\\\"input_ids\\\"]\\n return model_inputs\",\n \"def create_InputExamples(self, data, labels):\\n examples = []\\n for (i, u_tips) in enumerate(data):\\n for text in u_tips:\\n examples.append(\\n run_classifier.InputExample(\\n guid=None,\\n text_a=text,\\n text_b=None,\\n label=np.argmax(labels[i])\\n )\\n )\\n return examples\",\n \"def create_examples(topics, sentences):\\n input_examples = []\\n \\n for i in range(len(sentences)):\\n input_examples.append(InputExample(text_a=topics[i], text_b=sentences[i], label='NoArgument'))\\n return input_examples\",\n \"def read_examples_string(input_text):#(input_file, input_text):\\n examples = []\\n unique_id = 0\\n \\n with io.StringIO(input_text) as reader:\\n while True:\\n line = tokenization.convert_to_unicode(reader.readline())\\n if not line:\\n break\\n\\n line = line.strip()\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", line)\\n\\n if m is None:\\n text_a = line\\n else:\\n text_a = m.group(1)\\n text_b = m.group(2)\\n\\n examples.append(InputExample(unique_id=unique_id,\\n text_a=text_a, \\n text_b=text_b))\\n unique_id += 1\\n return examples\",\n \"def test_text_task(self):\\n args = BASE_ARGS.copy()\\n args.update(TEXT_ARGS)\\n valid, test = testing_utils.train_model(args)\\n self.assertLessEqual(\\n valid['ppl'], 1.5, 'failed to train image_seq2seq on text task'\\n )\",\n \"def batchify(self, observations):\\n # valid examples\\n exs = [ex for ex in observations if 'text' in ex]\\n # the indices of the valid (non-empty) tensors\\n valid_inds = [i for i, ex in enumerate(observations) if 'text' in ex]\\n\\n # set up the input tensors\\n batchsize = len(exs)\\n if batchsize == 0:\\n return None, None, None\\n # tokenize the text\\n parsed_x = [deque(maxlen=self.truncate) for _ in exs]\\n for dq, ex in zip(parsed_x, exs):\\n dq += self.parse(ex['text'])\\n # parsed = [self.parse(ex['text']) for ex in exs]\\n max_x_len = max((len(x) for x in parsed_x))\\n for x in parsed_x:\\n # left pad with zeros\\n x.extendleft([self.fairseq_dict.pad()] * (max_x_len - len(x)))\\n xs = torch.LongTensor(parsed_x)\\n\\n # set up the target tensors\\n ys = None\\n if 'labels' in exs[0]:\\n # randomly select one of the labels to update on, if multiple\\n labels = [random.choice(ex.get('labels', [''])) for ex in exs]\\n parsed_y = [deque(maxlen=self.truncate) for _ in labels]\\n for dq, y in zip(parsed_y, labels):\\n dq.extendleft(reversed(self.parse(y)))\\n for y in parsed_y:\\n y.append(self.fairseq_dict.eos())\\n # append EOS to each label\\n max_y_len = max(len(y) for y in parsed_y)\\n for y in parsed_y:\\n y += [self.fairseq_dict.pad()] * (max_y_len - len(y))\\n ys = torch.LongTensor(parsed_y)\\n return xs, ys, valid_inds\",\n \"def args_batch_to_text(args_batch: ArgsBatch) -> Text:\\n lines = []\\n for args in args_batch:\\n lines.append('; '.join(str(a) for a in args))\\n return '\\\\n'.join(lines)\",\n \"def _create_examples(self, lines, kb_data, set_type):\\n examples = []\\n for idx, line in enumerate(lines):\\n item = json.loads(line.strip())\\n question_id = \\\"%s-%s\\\" % (set_type, idx)\\n \\n context_a_list = kb_data[idx]['answerA']\\n context_b_list = kb_data[idx]['answerB']\\n context_c_list = kb_data[idx]['answerC']\\n\\n context_a = \\\"\\\"\\n for l in context_a_list[:1]:\\n context_a += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_a = context_a[:-1]\\n\\n context_b = \\\"\\\"\\n for l in context_b_list[:1]:\\n context_b += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_b = context_b[:-1]\\n\\n context_c = \\\"\\\"\\n for l in context_c_list[:1]:\\n context_c += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_c = context_c[:-1]\\n \\n \\n question = item[\\\"context\\\"] + item[\\\"question\\\"]\\n endings = [item[\\\"answerA\\\"],item[\\\"answerB\\\"],item[\\\"answerC\\\"] ]\\n label = item[\\\"correct\\\"]\\n #race_id = \\\"%s-%s\\\" % (set_type, data_raw[\\\"race_id\\\"])\\n #article = data_raw[\\\"article\\\"]\\n #for i in range(len(data_raw[\\\"answers\\\"])):\\n #truth = str(ord(data_raw[\\\"answers\\\"][i]) - ord(\\\"A\\\"))\\n #question = data_raw[\\\"questions\\\"][i]\\n #options = data_raw[\\\"options\\\"][i]\\n\\n examples.append(\\n InputExample(\\n example_id=question_id,\\n question=question,\\n contexts=[context_a,context_b,context_c],\\n endings=[endings[0], endings[1], endings[2]],#, options[3]\\n label=label,\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines):\\n examples = []\\n for (i, line) in enumerate(lines):\\n logger.info(line)\\n guid = int(line[0])\\n label = int(line[1])\\n text = \\\" \\\".join(clean_tokens(line[3].split()))\\n if guid < 1000:\\n args_char_offset = find_char_offsets(text, line[2].split(\\\"-\\\"))\\n else:\\n args_char_offset = [int(i) for i in line[2].split('-')]\\n examples.append(\\n InputExample(guid=guid, text=text, args_char_offset=args_char_offset, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = line[0]\\n text_a = line[1] + \\\" . \\\" + line[2]\\n text_b = line[-1]\\n label = 0\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(self):\\n features = []\\n max_label_len = 0\\n # find ou the max label length\\n labels_list = []\\n for ex_index, example in enumerate(self.examples):\\n processor = example.processor\\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\\n max_label_len = max(len(label_ids), max_label_len)\\n labels_list.append(label_ids)\\n if self.max_seq_length_decoder is None:\\n self.max_seq_length_decoder = max_label_len\\n else:\\n self.max_seq_length_decoder = max(\\n self.max_seq_length_decoder, max_label_len\\n ) # take the max of the two to be conservative\\n for ex_index, example in enumerate(self.examples):\\n taskname = example.taskname\\n taskname_ids = self.tokenizer.text_to_ids(taskname)\\n processor = example.processor\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n label_ids = labels_list[ex_index]\\n enc_query = processor.get_ptune_query(\\n example.content,\\n self.pseudo_token_id,\\n self.max_seq_length - self.max_seq_length_decoder + 1,\\n self.templates,\\n self.tokenizer,\\n )\\n input_ids = enc_query + label_ids[:-1]\\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\\n features.append([input_ids, labels, enc_query, taskname_ids])\\n return features\",\n \"def qkgnn_convert_examples_to_features(\\r\\n examples,\\r\\n tokenizer,\\r\\n max_length=512,\\r\\n task=None,\\r\\n label_list=None,\\r\\n output_mode=None,\\r\\n pad_on_left=False,\\r\\n pad_token=0,\\r\\n pad_token_segment_id=0,\\r\\n mask_padding_with_zero=True,\\r\\n):\\r\\n\\r\\n if task is not None:\\r\\n processor = gnn_processors[task]()\\r\\n if label_list is None:\\r\\n label_list = processor.get_labels()\\r\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\r\\n if output_mode is None:\\r\\n output_mode = gnn_output_modes[task]\\r\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\r\\n label_map = {label: i for i, label in enumerate(label_list)}\\r\\n\\r\\n\\r\\n # TODO : optimize this part if out of memory error occurs\\r\\n def convert_inputs_to_processed(inputs):\\r\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\r\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\r\\n # tokens are attended to.\\r\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\r\\n\\r\\n # Zero-pad up to the sequence length.\\r\\n padding_length = max_length - len(input_ids)\\r\\n if pad_on_left:\\r\\n input_ids = ([pad_token] * padding_length) + input_ids\\r\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\r\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\r\\n else:\\r\\n input_ids = input_ids + ([pad_token] * padding_length)\\r\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\r\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\r\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\r\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\r\\n len(attention_mask), max_length\\r\\n )\\r\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\r\\n len(token_type_ids), max_length\\r\\n )\\r\\n\\r\\n return input_ids, attention_mask, token_type_ids\\r\\n\\r\\n # TODO : optimize this part if out of memory error occurs\\r\\n def qkgnn_convert_single_exampl_to_feature(example, ex_index=10):\\r\\n inputs_q = tokenizer.encode_plus(example.text_a, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_k = tokenizer.encode_plus(example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk1 = tokenizer.encode_plus(example.text_a, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk2 = tokenizer.encode_plus(example.text_a, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk3 = tokenizer.encode_plus(example.text_a, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq1 = tokenizer.encode_plus(example.text_b, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq2 = tokenizer.encode_plus(example.text_b, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq3 = tokenizer.encode_plus(example.text_b, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk1 = tokenizer.encode_plus(example.text_b, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk2 = tokenizer.encode_plus(example.text_b, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk3 = tokenizer.encode_plus(example.text_b, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq1 = tokenizer.encode_plus(example.text_a, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq2 = tokenizer.encode_plus(example.text_a, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq3 = tokenizer.encode_plus(example.text_a, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n # generate [input_ids, input_mask, segment_ids]\\r\\n # for q self\\r\\n input_ids_q, input_mask_q, segment_ids_q = convert_inputs_to_processed(inputs_q)\\r\\n # for k self\\r\\n input_ids_k, input_mask_k, segment_ids_k = convert_inputs_to_processed(inputs_k)\\r\\n # for qk\\r\\n input_ids_qk, input_mask_qk, segment_ids_qk = convert_inputs_to_processed(inputs_qk)\\r\\n # for qk1\\r\\n input_ids_qk1, input_mask_qk1, segment_ids_qk1 = convert_inputs_to_processed(inputs_qk1)\\r\\n # for qk2\\r\\n input_ids_qk2, input_mask_qk2, segment_ids_qk2 = convert_inputs_to_processed(inputs_qk2)\\r\\n # for qk3\\r\\n input_ids_qk3, input_mask_qk3, segment_ids_qk3 = convert_inputs_to_processed(inputs_qk3)\\r\\n # for kq1\\r\\n input_ids_kq1, input_mask_kq1, segment_ids_kq1 = convert_inputs_to_processed(inputs_kq1)\\r\\n # for kq2\\r\\n input_ids_kq2, input_mask_kq2, segment_ids_kq2 = convert_inputs_to_processed(inputs_kq2)\\r\\n # for kq3\\r\\n input_ids_kq3, input_mask_kq3, segment_ids_kq3 = convert_inputs_to_processed(inputs_kq3)\\r\\n # for kk1\\r\\n input_ids_kk1, input_mask_kk1, segment_ids_kk1 = convert_inputs_to_processed(inputs_kk1)\\r\\n # for kk2\\r\\n input_ids_kk2, input_mask_kk2, segment_ids_kk2 = convert_inputs_to_processed(inputs_kk2)\\r\\n # for kk3\\r\\n input_ids_kk3, input_mask_kk3, segment_ids_kk3 = convert_inputs_to_processed(inputs_kk3)\\r\\n # for qq1\\r\\n input_ids_qq1, input_mask_qq1, segment_ids_qq1 = convert_inputs_to_processed(inputs_qq1)\\r\\n # for qq2\\r\\n input_ids_qq2, input_mask_qq2, segment_ids_qq2 = convert_inputs_to_processed(inputs_qq2)\\r\\n # for qq3\\r\\n input_ids_qq3, input_mask_qq3, segment_ids_qq3 = convert_inputs_to_processed(inputs_qq3)\\r\\n\\r\\n # generate label\\r\\n if output_mode == \\\"classification\\\" or output_mode == \\\"classification2\\\":\\r\\n label = label_map[example.label]\\r\\n elif output_mode == \\\"regression\\\":\\r\\n label = float(example.label)\\r\\n else:\\r\\n raise KeyError(output_mode)\\r\\n\\r\\n # log info\\r\\n if ex_index < 5:\\r\\n logger.info(\\\"*** Example ***\\\")\\r\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\r\\n logger.info(\\\"text_a: %s\\\" % (example.text_a))\\r\\n logger.info(\\\"text_b: %s\\\" % (example.text_b))\\r\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_qk]))\\r\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_qk]))\\r\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids_qk]))\\r\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label))\\r\\n # generate the feature for single example\\r\\n feature = InputFeatures_GNN(\\r\\n input_ids_q=input_ids_q,\\r\\n input_mask_q=input_mask_q,\\r\\n segment_ids_q=segment_ids_q,\\r\\n\\r\\n input_ids_k=input_ids_k,\\r\\n input_mask_k=input_mask_k,\\r\\n segment_ids_k=segment_ids_k,\\r\\n\\r\\n input_ids_qk=input_ids_qk,\\r\\n input_mask_qk=input_mask_qk,\\r\\n segment_ids_qk=segment_ids_qk,\\r\\n\\r\\n input_ids_qk1=input_ids_qk1,\\r\\n input_mask_qk1=input_mask_qk1,\\r\\n segment_ids_qk1=segment_ids_qk1,\\r\\n input_ids_qk2=input_ids_qk2,\\r\\n input_mask_qk2=input_mask_qk2,\\r\\n segment_ids_qk2=segment_ids_qk2,\\r\\n input_ids_qk3=input_ids_qk3,\\r\\n input_mask_qk3=input_mask_qk3,\\r\\n segment_ids_qk3=segment_ids_qk3,\\r\\n\\r\\n input_ids_kq1=input_ids_kq1,\\r\\n input_mask_kq1=input_mask_kq1,\\r\\n segment_ids_kq1=segment_ids_kq1,\\r\\n input_ids_kq2=input_ids_kq2,\\r\\n input_mask_kq2=input_mask_kq2,\\r\\n segment_ids_kq2=segment_ids_kq2,\\r\\n input_ids_kq3=input_ids_kq3,\\r\\n input_mask_kq3=input_mask_kq3,\\r\\n segment_ids_kq3=segment_ids_kq3,\\r\\n\\r\\n input_ids_qq1=input_ids_qq1,\\r\\n input_mask_qq1=input_mask_qq1,\\r\\n segment_ids_qq1=segment_ids_qq1,\\r\\n input_ids_qq2=input_ids_qq2,\\r\\n input_mask_qq2=input_mask_qq2,\\r\\n segment_ids_qq2=segment_ids_qq2,\\r\\n input_ids_qq3=input_ids_qq3,\\r\\n input_mask_qq3=input_mask_qq3,\\r\\n segment_ids_qq3=segment_ids_qq3,\\r\\n\\r\\n input_ids_kk1=input_ids_kk1,\\r\\n input_mask_kk1=input_mask_kk1,\\r\\n segment_ids_kk1=segment_ids_kk1,\\r\\n input_ids_kk2=input_ids_kk2,\\r\\n input_mask_kk2=input_mask_kk2,\\r\\n segment_ids_kk2=segment_ids_kk2,\\r\\n input_ids_kk3=input_ids_kk3,\\r\\n input_mask_kk3=input_mask_kk3,\\r\\n segment_ids_kk3=segment_ids_kk3,\\r\\n\\r\\n row_id=int(example.guid),\\r\\n label_id=label,\\r\\n task_id=task,\\r\\n is_real_example=True)\\r\\n return feature\\r\\n\\r\\n features = []\\r\\n for (ex_index, example) in tqdm(enumerate(examples)):\\r\\n features.append(qkgnn_convert_single_exampl_to_feature(example, ex_index=ex_index))\\r\\n\\r\\n return features\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n examples = []\\n text_index = 1 if mode == Split.test else 0\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, i)\\n text_a = line[text_index]\\n if len(line) > text_index + 1:\\n label = line[text_index + 1]\\n else:\\n label = None\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self,lines, set_type):\\n examples = []\\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n\\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n text_b = tx.utils.compat_as_text(line[1])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n elif len(lines[1]) == 1: # text_a (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n elif len(lines[1]) == 3: # label text_a text_b\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n text_b = tx.utils.compat_as_text(line[2])\\n\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n return examples\",\n \"def create_examples(lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, str(i))\\n text_a_id = line[0]\\n text_a = tokenization.convert_to_unicode(line[1])\\n text_b_id = line[2]\\n text_b = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(InputExample(guid=guid, text_a_id=text_a_id, text_a=text_a, text_b_id=text_b_id, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[0])\\n text_b = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n # id,title,content,label\\n test_mode = mode == Split.test\\n title_index = 1\\n content_index = 2\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[title_index]\\n text_b = line[content_index]\\n if test_mode:\\n label = None\\n else:\\n label = line[3]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n text_b = tokenization.convert_to_unicode(line[2])\\n label = tokenization.convert_to_unicode(line[3])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n test_mode = mode == Split.test\\n q1_index = 1 if test_mode else 3\\n q2_index = 2 if test_mode else 4\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[q1_index]\\n text_b = line[q2_index]\\n label = None if test_mode else line[5]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\\n\\n unique_id = 1000000000\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\\n\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if max_query_length is None:\\n max_query_length = len(query_tokens)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n for _ in enumerate(range(1)):\\n tokens_ = []\\n tokens_.append(\\\"[CLS]\\\")\\n for token in query_tokens:\\n tokens_.append(token)\\n tokens_.append(\\\"[SEP]\\\")\\n\\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids_) < max_query_length + 2:\\n input_ids_.append(0)\\n input_mask_.append(0)\\n\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n if example_index < 1:\\n # logger.info(\\\"*** Example ***\\\")\\n # logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n # logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in query_tokens]))\\n # logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_]))\\n # logger.info(\\n # \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_]))\\n\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n unique_id += 1\\n\\n return question_features\",\n \"def _create_examples(self, lines, set_type):\\n test_mode = set_type == \\\"test\\\"\\n if test_mode:\\n lines = lines[1:]\\n text_index = 1 if test_mode else 3\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[text_index]\\n label = None if test_mode else line[1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n if set_type == \\\"test\\\":\\n label = \\\"contradiction\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for i, line in lines.iterrows():\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line['sentence1']\\n text_b = line['sentence2']\\n label = line['label']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def print_examples(example_iter, model, num=0, max_len=100,\\n bos_index=1,\\n src_eos_index = None,\\n trg_eos_index = None,\\n src_vocab=None, trg_vocab=None):\\n model.eval()\\n count=0\\n\\n BOS_TOKEN = \\\"<s>\\\"\\n EOS_TOKEN = \\\"</s>\\\"\\n UNK_TOKEN = \\\"<unk>\\\"\\n\\n if src_vocab is not None and trg_vocab is not None:\\n src_bos_index = src_vocab.stoi[BOS_TOKEN]\\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\\n trg_unk_index = trg_vocab.stoi[UNK_TOKEN]\\n # trg_bos_index = trg_vocab.stoi[BOS_TOKEN]\\n # trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\\n else:\\n src_bos_index = 0\\n src_eos_index = 1\\n trg_unk_index = 2\\n # trg_bos_index = 1\\n # trg_eos_index = None\\n\\n for i, batch in enumerate(example_iter, 1):\\n src = batch.src.cpu().numpy()[0, :]\\n trg_idx = batch.trg_idx.cpu().numpy()[0, :]\\n\\n # remove </s>\\n src = src[1:] if src[0]==src_bos_index else src\\n src = src[:-1] if src[-1]==src_eos_index else src\\n # trg = trg[:-1] if trg[-1]==trg_eos_index else trg\\n\\n result = greedy_decode(model, batch.src_idx, batch.src_mask, batch.src_lengths)\\n print()\\n print(\\\"Example %d\\\" % i)\\n print(\\\"Source: \\\", \\\" \\\".join(lookup_words(src, vocab=src_vocab)))\\n print()\\n print(\\\"Target: \\\", set(lookup_words(trg_idx, vocab=trg_vocab)))\\n print()\\n print(\\\"Prediction: \\\", \\\" \\\".join(lookup_words(result[0], vocab=trg_vocab)))\\n\\n count += 1\\n if count == num:\\n break\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[8]\\n text_b = line[9]\\n label = line[-1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, max_seq_length, tokenizer):\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n print(example.text_a)\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n input_mask = [1] * len(input_ids)\\n\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n \\n labels_ids = []\\n for label in example.labels:\\n labels_ids.append(int(label))\\n \\n if ex_index < 0:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %s)\\\" % (example.labels, labels_ids))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=labels_ids))\\n return features\",\n \"def _create_examples(self, data, set_type):\\n examples = []\\n for (i, elem) in enumerate(data):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text = elem[0]\\n label = elem[1]\\n examples.append(\\n InputExample(guid=guid, text=text, label=label))\\n return examples\",\n \"def generate_text(pmodel, num_generate, temperature, start_string):\\n\\n # Converting the start string to numbers (vectorizing)\\n input_eval = [char2idx[s] for s in start_string]\\n input_eval = tf.expand_dims(input_eval, 0)\\n\\n # Empty string to store the results\\n text_generated = np.empty(1)\\n\\n # Here batch size = 1\\n pmodel.reset_states()\\n for i in range(num_generate):\\n \\n predictions = pmodel(input_eval)\\n \\n # remove the batch dimension\\n predictions = tf.squeeze(predictions, 0)\\n \\n # using a multinomial distribution to predict the word returned by the model\\n predictions = predictions / temperature\\n predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\\n \\n # We pass the predicted word as the next input to the model\\n # along with the previous hidden state\\n input_eval = tf.expand_dims([predicted_id], 0)\\n \\n text_generated = np.vstack((text_generated, idx2char[predicted_id].tolist()))\\n \\n return text_generated\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n try:\\n text_a = line[3]\\n text_b = line[4]\\n label = line[5]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(\\n examples: List[InputExample],\\n label_list: List[str],\\n max_length: int,\\n tokenizer: PreTrainedTokenizer,\\n pad_token_segment_id=0,\\n pad_on_left=False,\\n pad_token=0,\\n mask_padding_with_zero=True,\\n) -> List[InputFeatures]:\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\\\"convert examples to features\\\"):\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\n choices_features = []\\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\\n text_a = context\\n if example.question.find(\\\"_\\\") != -1:\\n # this is for cloze question\\n text_b = example.question.replace(\\\"_\\\", ending)\\n else:\\n text_b = example.question + \\\" \\\" + ending\\n if len(text_a) == 0:\\n logger.info(\\\"context of example %d have length 0\\\" % (ex_index))\\n text_a = \\\" \\\"\\n\\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\\n if \\\"num_truncated_tokens\\\" in inputs and inputs[\\\"num_truncated_tokens\\\"] > 0:\\n logger.info(\\n \\\"Attention! you are cropping tokens (swag task is ok). \\\"\\n \\\"If you are training ARC and RACE and you are poping question + options,\\\"\\n \\\"you need to try to use a bigger max seq length!\\\"\\n )\\n\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length\\n assert len(attention_mask) == max_length\\n assert len(token_type_ids) == max_length\\n choices_features.append((input_ids, attention_mask, token_type_ids))\\n\\n label = label_map[example.label]\\n\\n if ex_index < 2:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"race_id: {}\\\".format(example.example_id))\\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\\n logger.info(\\\"choice: {}\\\".format(choice_idx))\\n logger.info(\\\"input_ids: {}\\\".format(\\\" \\\".join(map(str, input_ids))))\\n logger.info(\\\"attention_mask: {}\\\".format(\\\" \\\".join(map(str, attention_mask))))\\n logger.info(\\\"token_type_ids: {}\\\".format(\\\" \\\".join(map(str, token_type_ids))))\\n logger.info(\\\"label: {}\\\".format(label))\\n\\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\\n\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for i, line in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[5]\\n text_b = line[6]\\n pairID = line[7][2:] if line[7].startswith(\\\"ex\\\") else line[7]\\n label = line[0]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n text_b = line[4]\\n label = line[0]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1] if set_type != \\\"test\\\" else \\\"entailment\\\"\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n # label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n exindex = {}\\n passagelens = []\\n\\n sum_of_labels = 0\\n\\n for (ex_index, example) in tqdm(enumerate(examples), desc=\\\"Tokenizing:\\\"):\\n if example.text_a not in tokenmap.keys():\\n tokens_a = tokenizer.tokenize(example.text_a)\\n tokenmap[example.text_a] = tokens_a\\n else:\\n tokens_a = tokenmap[example.text_a]\\n\\n tokens_b = None\\n if example.text_b:\\n if example.text_b not in tokenmap.keys():\\n tokens_b = tokenizer.tokenize(example.text_b)\\n tokenmap[example.text_b] = tokens_b\\n else:\\n tokens_b = tokenmap[example.text_b]\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\\n\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n # label_id = label_map[example.label]\\n label_id = example.label\\n\\n sum_of_labels += label_id\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (str(example.label), 0))\\n\\n exindex[ex_index] = example.guid\\n features.append(\\n InputFeatures(uuid=ex_index,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n\\n print(\\\"Passage Token Lengths Distribution\\\", passagelens[-1], np.percentile(passagelens, 50),\\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\\n return features, exindex\",\n \"def convert_examples_to_features(\\n examples,\\n tokenizer,\\n max_length=512,\\n task=None,\\n label_list=None,\\n output_mode=None,\\n pad_on_left=False,\\n pad_token=0,\\n pad_token_segment_id=0,\\n mask_padding_with_zero=True,\\n multilabel=False,\\n):\\n\\n if task is not None:\\n processor = glue_processors[task]()\\n if label_list is None:\\n label_list = processor.get_labels()\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\n if output_mode is None:\\n output_mode = glue_output_modes[task]\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n if multilabel:\\n domain_label_map = {label: i for i, label in enumerate([\\\"0\\\", \\\"1\\\"])}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n len_examples = len(examples)\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d/%d\\\" % (ex_index, len_examples))\\n\\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, )\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(attention_mask), max_length\\n )\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(token_type_ids), max_length\\n )\\n\\n if output_mode == \\\"classification\\\":\\n label = label_map[example.label] if not multilabel else label_map[example.label[0]]\\n elif output_mode == \\\"regression\\\":\\n label = float(example.label) if not multilabel else float(example.label[0])\\n else:\\n raise KeyError(output_mode)\\n if multilabel:\\n label = [label, domain_label_map[example.label[1]]]\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in attention_mask]))\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in token_type_ids]))\\n if multilabel:\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label[0], label[0]))\\n logger.info(\\\"domain label: %s (id = %d)\\\" % (example.label[1], label[1]))\\n else:\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label))\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\\n )\\n )\\n\\n return features\",\n \"def glue_convert_examples_to_features(\\n examples,\\n tokenizer,\\n max_length=512,\\n task=None,\\n label_list=None,\\n output_mode=None,\\n pad_on_left=False,\\n pad_token=0,\\n pad_token_segment_id=0,\\n mask_padding_with_zero=True,\\n):\\n is_tf_dataset = False\\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\\n is_tf_dataset = True\\n\\n if task is not None:\\n processor = glue_processors[task]()\\n if label_list is None:\\n label_list = processor.get_labels()\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\n if output_mode is None:\\n output_mode = glue_output_modes[task]\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n len_examples = 0\\n if is_tf_dataset:\\n example = processor.get_example_from_tensor_dict(example)\\n example = processor.tfds_map(example)\\n len_examples = tf.data.experimental.cardinality(examples)\\n else:\\n len_examples = len(examples)\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d/%d\\\" % (ex_index, len_examples))\\n\\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(attention_mask), max_length\\n )\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(token_type_ids), max_length\\n )\\n\\n if output_mode == \\\"classification\\\":\\n label_id = label_map[example.label]\\n elif output_mode == \\\"regression\\\":\\n label_id = float(example.label)\\n else:\\n raise KeyError(output_mode)\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in attention_mask]))\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in token_type_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label_id=label_id\\n )\\n )\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # if i == 0:\\n # continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[1]\\n text_b = None\\n label = line[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # if i == 0:\\n # continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[1]\\n text_b = None\\n label = line[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n text_a = lines[ids]['sentence']\\n examples.append(\\n InputExample(text_a=text_a) )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n# if set_type == 'test':\\r\\n# label = self.get_labels()[0]\\r\\n# else:\\r\\n# label = line[0]\\r\\n label = line[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[7]\\n text_b = line[8]\\n label = None if set_type == \\\"test\\\" else line[-1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[0]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n try:\\n text_a = line[3] if set_type != \\\"test\\\" else line[1]\\n text_b = line[4] if set_type != \\\"test\\\" else line[2]\\n label = line[5] if set_type != \\\"test\\\" else \\\"0\\\"\\n except IndexError:\\n continue\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens = example.text\\n\\n# # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n# if len(tokens) > max_seq_length - 2:\\n# tokens = tokens[:(max_seq_length - 2)]\\n\\n bert_tokens = []\\n orig_to_tok_map = []\\n\\n bert_tokens.append(\\\"[CLS]\\\")\\n for token in tokens:\\n new_tokens = tokenizer.tokenize(token)\\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\\n # print(\\\"You shouldn't see this since the test set is already pre-separated.\\\")\\n break\\n else:\\n orig_to_tok_map.append(len(bert_tokens))\\n bert_tokens.extend(new_tokens)\\n bert_tokens.append(\\\"[SEP]\\\")\\n\\n if len(bert_tokens) == 2: # edge case\\n continue\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n\\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n\\n segment_ids = [0] * max_seq_length # no use for our problem\\n\\n labels = example.label\\n label_ids = [0] * max_seq_length\\n label_mask = [0] * max_seq_length\\n\\n for label, target_index in zip(labels, orig_to_tok_map):\\n label_ids[target_index] = label_map[label]\\n label_mask[target_index] = 1\\n\\n assert len(segment_ids) == max_seq_length\\n assert len(label_ids) == max_seq_length\\n assert len(label_mask) == max_seq_length\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=label_ids,\\n label_mask=label_mask))\\n return features\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n label = line[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[8]\\r\\n text_b = line[9]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[7]\\r\\n text_b = line[8]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def read_examples(input_file):\\n examples = []\\n unique_id = 0\\n with tf.gfile.GFile(input_file, \\\"r\\\") as reader:\\n while True:\\n line = tokenization.convert_to_unicode(reader.readline())\\n if not line:\\n break\\n \\n line = line.strip()\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", line)\\n \\n if m is None:\\n text_a = line\\n else:\\n text_a = m.group(1)\\n text_b = m.group(2)\\n examples.append(InputExample(unique_id=unique_id,\\n text_a=text_a, \\n text_b=text_b))\\n unique_id += 1\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[0]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[1]\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n\\r\\n return examples\",\n \"def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\\r\\n label_map = {}\\r\\n for (i, label) in enumerate(label_list):\\r\\n label_map[label] = i\\r\\n\\r\\n input_data=[]\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens_a = tokenizer.tokenize(example.text_a)\\r\\n tokens_b = None\\r\\n if example.text_b:\\r\\n tokens_b = tokenizer.tokenize(example.text_b)\\r\\n if tokens_b:\\r\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\r\\n # length is less than the specified length.\\r\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\r\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\r\\n else:\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n if len(tokens_a) > max_seq_length - 2:\\r\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\r\\n\\r\\n if ex_index % 10000 == 0:\\r\\n tf.logging.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\r\\n\\r\\n # The convention in BERT is:\\r\\n # (a) For sequence pairs:\\r\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\r\\n # (b) For single sequences:\\r\\n # tokens: [CLS] the dog is hairy . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0\\r\\n #\\r\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\r\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\r\\n # `type=1` were learned during pre-training and are added to the wordpiece\\r\\n # embedding vector (and position vector). This is not *strictly* necessary\\r\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\r\\n # it easier for the model to learn the concept of sequences.\\r\\n #\\r\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\r\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\r\\n # the entire model is fine-tuned.\\r\\n tokens = []\\r\\n segment_ids = []\\r\\n tokens.append(\\\"[CLS]\\\")\\r\\n segment_ids.append(0)\\r\\n for token in tokens_a:\\r\\n tokens.append(token)\\r\\n segment_ids.append(0)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(0)\\r\\n\\r\\n if tokens_b:\\r\\n for token in tokens_b:\\r\\n tokens.append(token)\\r\\n segment_ids.append(1)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(1)\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n while len(input_ids) < max_seq_length:\\r\\n input_ids.append(0)\\r\\n input_mask.append(0)\\r\\n segment_ids.append(0)\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n label_id = label_map[example.label]\\r\\n if ex_index < 3:\\r\\n tf.logging.info(\\\"*** Example ***\\\")\\r\\n tf.logging.info(\\\"guid: %s\\\" % (example.guid))\\r\\n tf.logging.info(\\\"tokens: %s\\\" % \\\" \\\".join([tokenization.printable_text(x) for x in tokens]))\\r\\n tf.logging.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\r\\n tf.logging.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\r\\n tf.logging.info(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\r\\n tf.logging.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\r\\n\\r\\n features = collections.OrderedDict()\\r\\n features[\\\"input_ids\\\"] = input_ids\\r\\n features[\\\"input_mask\\\"] = input_mask\\r\\n features[\\\"segment_ids\\\"] = segment_ids\\r\\n features[\\\"label_ids\\\"] =label_id\\r\\n input_data.append(features)\\r\\n\\r\\n return input_data\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"][\\\"text\\\"]\\n for Q in data[\\\"passage\\\"][\\\"questions\\\"]:\\n question = Q[\\\"question\\\"]\\n for A in Q[\\\"answers\\\"]:\\n guid = f\\\"{set_type}-{data['idx']-Q['idx']-A['idx']}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage,\\n text_b=question + \\\" \\\" + A[\\\"text\\\"],\\n label=str(A[\\\"label\\\"]),\\n )\\n )\\n return examples\",\n \"def _create_examples(self, data_dir, set_type):\\n\\t\\texamples = []\\n\\t\\tinput_file_data = os.path.join(data_dir, \\\"data.tsv\\\")\\n\\t\\twith open(input_file_data, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as f:\\n\\t\\t\\tfor i, inp in enumerate(f):\\n\\t\\t\\t\\tinps = inp.split('\\\\t') \\n\\t\\t\\t\\tguid = \\\"%s-%s\\\" % (set_type, i)\\n\\t\\t\\t\\ttext_inp = inps[1].strip()\\n\\t\\t\\t\\ttext_out = inps[2].strip()\\n\\t\\t\\t\\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\\n\\t\\t\\t\\t\\n\\t\\t\\t# Sort these out before returning\\n\\t\\t\\texamples = sorted(examples, key=sort_inp_len)\\n\\t\\t\\treturn examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[8]\\r\\n text_b = line[9]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _convert_single_example(self, text_a, text_b):\\n tokens = []\\n input_ids = []\\n segment_ids = []\\n input_mask = []\\n try:\\n text_a = self.tokenizer.tokenize(text_a)\\n if text_b:\\n text_b = self.tokenizer.tokenize(text_b)\\n self._truncate_seq_pair(text_a, text_b)\\n\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n\\n for token in text_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n\\n if text_b:\\n for token in text_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append('[SEP]')\\n segment_ids.append(1)\\n\\n input_ids = self.tokenizer.convert_tokens_to_ids(tokens)\\n\\n input_mask = [1] * len(input_ids)\\n\\n while len(input_ids) < 50:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n except:\\n self.logger.error()\\n\\n finally:\\n return input_ids, input_mask, segment_ids\",\n \"def print_examples(example_iter, model, n=2, max_len=100, \\n sos_index=1, \\n src_eos_index=None, \\n trg_eos_index=None, \\n src_vocab=None, trg_vocab=None):\\n\\n model.eval()\\n count = 0\\n print()\\n \\n if src_vocab is not None and trg_vocab is not None:\\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\\n trg_sos_index = trg_vocab.stoi[SOS_TOKEN]\\n trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\\n else:\\n src_eos_index = None\\n trg_sos_index = 1\\n trg_eos_index = None\\n \\n for i, batch in enumerate(example_iter):\\n \\n src = batch.src.cpu().numpy()[0, :]\\n trg = batch.trg_y.cpu().numpy()[0, :]\\n\\n # remove </s> (if it is there)\\n src = src[:-1] if src[-1] == src_eos_index else src\\n trg = trg[:-1] if trg[-1] == trg_eos_index else trg \\n \\n result, _ = beam_decode(\\n model, batch.src, batch.src_mask, batch.src_lengths,\\n max_len=max_len, sos_index=trg_sos_index, eos_index=trg_eos_index)\\n print(\\\"Example #%d\\\" % (i+1))\\n print(\\\"Src : \\\", \\\" \\\".join(lookup_words(src, vocab=src_vocab)))\\n print(\\\"Trg : \\\", \\\" \\\".join(lookup_words(trg, vocab=trg_vocab)))\\n print(\\\"Pred: \\\", \\\" \\\".join(lookup_words(result, vocab=trg_vocab)))\\n print()\\n \\n count += 1\\n if count == n:\\n break\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n \\n for (i, line) in enumerate(lines):\\n sentence_number = 0\\n premise_text = line[\\\"premise\\\"]\\n modified_premise_text = re.sub(self.stage_name_pattern,\\\"\\\",premise_text)\\n modified_premise_text = re.sub(self.w_patterns,\\\"\\\",modified_premise_text)\\n hypothesis_text = line[\\\"hypothesis\\\"]\\n hypothesis_text = re.sub(self.w_patterns,\\\"\\\",hypothesis_text)\\n a_label = int(line[\\\"label\\\"])\\n\\n sentences = modified_premise_text.split('.')\\n\\n for j, sentence in enumerate(sentences):\\n guid = \\\"\\\" + str(sentence_number) + \\\"\\\\t\\\" + str(i) + \\\"\\\\t\\\" + str(len(sentences)) + \\\"\\\\t\\\" + str(a_label)\\n text_a = sentence\\n text_b = hypothesis_text\\n label = a_label\\n sentence_number += 1\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n #print(\\\"16th sentence::\\\",sentences[16])\\n\\n return examples\",\n \"def text_generator(self, example_generator):\\n\\t\\tif self._data_as_tf_example:\\n\\t\\t\\tquery_text = None\\n\\t\\t\\tquery_edge_list = None\\n\\t\\t\\tword_edge_list = None\\n\\t\\t\\t\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\te, epoch_num = example_generator.next() # e is a tf.Example\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tarticle_text = e.features.feature['article'].bytes_list.value[0] # document text\\n\\t\\t\\t\\t\\tabstract_text = e.features.feature['abstract'].bytes_list.value[0] # response text\\n\\t\\t\\t\\t\\tif self._hps.query_encoder.value:\\n\\t\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\tquery_text = e.features.feature['query'].bytes_list.value[0] # context text\\n\\t\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\t\\tquery_text = ''\\n\\t\\t\\t\\t\\tif self._hps.word_gcn.value:\\n\\t\\t\\t\\t\\t\\tword_edge_list = []\\n\\t\\t\\t\\t\\t\\tif self._hps.use_default_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t#tf.logging.info((word_edge_list[0]))\\n\\t\\t\\t\\t\\t\\tif self._hps.use_coref_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_coref_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_entity_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_entity_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_lexical_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_lexical_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t#\\tprint(word_edge_list)\\n\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\tif self._hps.query_gcn.value:\\n\\t\\t\\t\\t\\t\\tquery_edge_list = []\\n\\t\\t\\t\\t\\t\\tif self._hps.use_default_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t'''\\n\\t\\t\\t\\t\\t\\tThese are inter-sentence graph and may not be applicable\\n\\t\\t\\t\\t\\t\\tif self._hps.use_coref_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_coref_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_entity_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_entity_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_lexical_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_lexical_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t'''\\n\\n\\n\\n\\t\\t\\t\\texcept ValueError:\\n\\t\\t\\t\\t\\ttf.logging.error('Failed to get article or abstract from example')\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif len(article_text)==0: # See https://github.com/abisee/pointer-generator/issues/1\\n\\t\\t\\t\\t\\ttf.logging.warning('Found an example with empty article text. Skipping it.')\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t#tf.logging.info(abstract_text)\\n\\t\\t\\t\\t\\tyield (article_text, abstract_text, word_edge_list, query_text, query_edge_list, epoch_num)\\n\\t\\t\\t\\n\\t\\telse:\\n\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\te = example_generator.next()\\n\\t\\t\\t\\tyield e\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n examples.append(\\n InputExample(\\n guid=f\\\"{set_type}-{data['idx']}\\\",\\n text_a=data[\\\"passage\\\"],\\n text_b=data[\\\"question\\\"],\\n label=str(data[\\\"label\\\"]),\\n )\\n )\\n return examples\",\n \"def generate_tpu(self, prompts: List[str]):\\n from flax.training.common_utils import shard # pylint:disable=g-import-not-at-top,g-importing-member\\n import jax # pylint:disable=g-import-not-at-top\\n import time # pylint:disable=g-import-not-at-top\\n import numpy as np # pylint:disable=g-import-not-at-top\\n\\n rng = jax.random.PRNGKey(0)\\n rng = jax.random.split(rng, jax.device_count())\\n\\n assert prompts, \\\"prompt parameter cannot be empty\\\"\\n print(\\\"Prompts: \\\", prompts)\\n prompt_ids = self._pipeline.prepare_inputs(prompts)\\n prompt_ids = shard(prompt_ids)\\n print(\\\"Sharded prompt ids has shape:\\\", prompt_ids.shape)\\n if self._run_with_profiler:\\n jax.profiler.start_trace(self._profiler_dir)\\n\\n time_start = time.time()\\n images = self._p_generate(prompt_ids, self._p_params, rng)\\n images = images.block_until_ready()\\n elapsed = time.time() - time_start\\n if self._run_with_profiler:\\n jax.profiler.stop_trace()\\n\\n print(\\\"Inference time (in seconds): \\\", elapsed)\\n print(\\\"Shape of the predictions: \\\", images.shape)\\n images = images.reshape(\\n (images.shape[0] * images.shape[1],) + images.shape[-3:])\\n print(\\\"Shape of images afterwards: \\\", images.shape)\\n return self._pipeline.numpy_to_pil(np.array(images))\",\n \"def translate_interactive(estimator, tokenizer_):\\n \\n predictor = ContinuePredict(estimator, continue_input_fn)\\n while True:\\n tf.logging.info(\\\"Enter the English sentence end with ENTER.\\\")\\n raw_text = input().strip()\\n if raw_text == r'\\\\q':\\n predictor.close()\\n break\\n encoded_txt = _encode_and_add_eos(raw_text, tokenizer_)\\n target = predictor.predict(encoded_txt)\\n target = next(target)['outputs']\\n target = _trim_and_decode(target, tokenizer_)\\n tf.logging.info('\\\\t{}'.format(target))\",\n \"def generate_text(session, model, config, starting_text='<eos>',\\n stop_length=100, stop_tokens=None, temp=1.0):\\n state = model.initial_state.eval()\\n # Imagine tokens as a batch size of one, length of len(tokens[0])\\n tokens = [model.vocab.encode(word) for word in starting_text.split()]\\n for i in xrange(stop_length):\\n ### YOUR CODE HERE\\n #print tokens\\n feed = {}\\n #x = np.array([tokens[-1]])\\n #x.reshape(1,1)\\n feed[model.input_placeholder] = [[tokens[-1]]]\\n feed[model.dropout_placeholder] = 1\\n feed[model.initial_state] = state\\n y_pred, state = session.run([model.predictions[-1], model.final_state], feed_dict=feed)\\n ### END YOUR CODE\\n next_word_idx = sample(y_pred[0], temperature=temp)\\n tokens.append(next_word_idx)\\n if stop_tokens and model.vocab.decode(tokens[-1]) in stop_tokens:\\n break\\n output = [model.vocab.decode(word_idx) for word_idx in tokens]\\n return output\",\n \"def batchify(TEXT, data, batch_size, device):\\r\\n data = TEXT.numericalize([data.examples[0].text])\\r\\n num_batches = data.size(0)//batch_size\\r\\n data = data.narrow(0, 0, num_batches * batch_size)\\r\\n data = data.view(batch_size, -1).t().contiguous()\\r\\n\\r\\n return data.to(device)\",\n \"def convert_example(example,\\n tokenizer,\\n label_list,\\n max_seq_length=512,\\n is_test=False):\\n\\n def _truncate_seqs(seqs, max_seq_length):\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n tokens_a, tokens_b = seqs\\n max_seq_length -= 3\\n while True: # truncate with longest_first strategy\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_seq_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\\n return seqs\\n\\n def _concat_seqs(seqs, separators, seq_mask=0, separator_mask=1):\\n concat = sum((seq + sep for sep, seq in zip(separators, seqs)), [])\\n segment_ids = sum(\\n ([i] * (len(seq) + len(sep))\\n for i, (sep, seq) in enumerate(zip(separators, seqs))), [])\\n if isinstance(seq_mask, int):\\n seq_mask = [[seq_mask] * len(seq) for seq in seqs]\\n if isinstance(separator_mask, int):\\n separator_mask = [[separator_mask] * len(sep) for sep in separators]\\n p_mask = sum((s_mask + mask\\n for sep, seq, s_mask, mask in zip(\\n separators, seqs, seq_mask, separator_mask)), [])\\n return concat, segment_ids, p_mask\\n\\n if not is_test:\\n # `label_list == None` is for regression task\\n label_dtype = \\\"int64\\\" if label_list else \\\"float32\\\"\\n # get the label\\n label = example[-2]\\n example = example[:-2]\\n #create label maps if classification task\\n if label_list:\\n label_map = {}\\n for (i, l) in enumerate(label_list):\\n label_map[l] = i\\n label = label_map[label]\\n label = np.array([label], dtype=label_dtype)\\n else:\\n qas_id = example[-1]\\n example = example[:-2]\\n # tokenize raw text\\n tokens_raw = [tokenizer(l) for l in example]\\n # truncate to the truncate_length,\\n tokens_trun = _truncate_seqs(tokens_raw, max_seq_length)\\n # concate the sequences with special tokens\\n tokens_trun[0] = [tokenizer.cls_token] + tokens_trun[0]\\n tokens, segment_ids, _ = _concat_seqs(tokens_trun, [[tokenizer.sep_token]] *\\n len(tokens_trun))\\n # convert the token to ids\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n valid_length = len(input_ids)\\n\\n if not is_test:\\n return input_ids, segment_ids, valid_length, label\\n else:\\n return input_ids, segment_ids, valid_length, qas_id\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n label = line[5]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n label = self.get_labels()[0]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[0]\\n label = line[1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n if set_type != 'test':\\r\\n text_a = line[3]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n else:\\r\\n if i == 0:\\r\\n continue\\r\\n text_a = line[1]\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def query(self,text_input,prefix='answer:',convert_to_string=True):\\n predictions, raw_outputs = self.model.predict([text_input])\\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\\n return self._post_process_output(preds,convert_to_string=convert_to_string)\",\n \"def sample_to_features_text(\\n sample, tasks, max_seq_len, tokenizer\\n):\\n\\n if tokenizer.is_fast:\\n text = sample.clear_text[\\\"text\\\"]\\n # Here, we tokenize the sample for the second time to get all relevant ids\\n # This should change once we git rid of FARM's tokenize_with_metadata()\\n inputs = tokenizer(text,\\n return_token_type_ids=True,\\n truncation=True,\\n truncation_strategy=\\\"longest_first\\\",\\n max_length=max_seq_len,\\n return_special_tokens_mask=True)\\n\\n if (len(inputs[\\\"input_ids\\\"]) - inputs[\\\"special_tokens_mask\\\"].count(1)) != len(sample.tokenized[\\\"tokens\\\"]):\\n logger.error(f\\\"FastTokenizer encoded sample {sample.clear_text['text']} to \\\"\\n f\\\"{len(inputs['input_ids']) - inputs['special_tokens_mask'].count(1)} tokens, which differs \\\"\\n f\\\"from number of tokens produced in tokenize_with_metadata(). \\\\n\\\"\\n f\\\"Further processing is likely to be wrong.\\\")\\n else:\\n # TODO It might be cleaner to adjust the data structure in sample.tokenized\\n tokens_a = sample.tokenized[\\\"tokens\\\"]\\n tokens_b = sample.tokenized.get(\\\"tokens_b\\\", None)\\n\\n inputs = tokenizer.encode_plus(\\n tokens_a,\\n tokens_b,\\n add_special_tokens=True,\\n truncation=False, # truncation_strategy is deprecated\\n return_token_type_ids=True,\\n is_split_into_words=False,\\n )\\n\\n input_ids, segment_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n padding_mask = [1] * len(input_ids)\\n\\n # Padding up to the sequence length.\\n # Normal case: adding multiple 0 to the right\\n # Special cases:\\n # a) xlnet pads on the left and uses \\\"4\\\" for padding token_type_ids\\n if tokenizer.__class__.__name__ == \\\"XLNetTokenizer\\\":\\n pad_on_left = True\\n segment_ids = pad(segment_ids, max_seq_len, 4, pad_on_left=pad_on_left)\\n else:\\n pad_on_left = False\\n segment_ids = pad(segment_ids, max_seq_len, 0, pad_on_left=pad_on_left)\\n\\n input_ids = pad(input_ids, max_seq_len, tokenizer.pad_token_id, pad_on_left=pad_on_left)\\n padding_mask = pad(padding_mask, max_seq_len, 0, pad_on_left=pad_on_left)\\n\\n assert len(input_ids) == max_seq_len\\n assert len(padding_mask) == max_seq_len\\n assert len(segment_ids) == max_seq_len\\n\\n feat_dict = {\\n \\\"input_ids\\\": input_ids,\\n \\\"padding_mask\\\": padding_mask,\\n \\\"segment_ids\\\": segment_ids,\\n }\\n\\n # Add Labels for different tasks\\n for task_name, task in tasks.items():\\n try:\\n label_name = task[\\\"label_name\\\"]\\n label_raw = sample.clear_text[label_name]\\n label_list = task[\\\"label_list\\\"]\\n if task[\\\"task_type\\\"] == \\\"classification\\\":\\n # id of label\\n try:\\n label_ids = [label_list.index(label_raw)]\\n except ValueError as e:\\n raise ValueError(f'[Task: {task_name}] Observed label {label_raw} not in defined label_list')\\n elif task[\\\"task_type\\\"] == \\\"multilabel_classification\\\":\\n # multi-hot-format\\n label_ids = [0] * len(label_list)\\n for l in label_raw.split(\\\",\\\"):\\n if l != \\\"\\\":\\n label_ids[label_list.index(l)] = 1\\n elif task[\\\"task_type\\\"] == \\\"regression\\\":\\n label_ids = [float(label_raw)]\\n else:\\n raise ValueError(task[\\\"task_type\\\"])\\n except KeyError:\\n # For inference mode we don't expect labels\\n label_ids = None\\n if label_ids is not None:\\n feat_dict[task[\\\"label_tensor_name\\\"]] = label_ids\\n return [feat_dict]\",\n \"def tokenize_nmt(text, num_examples=None):\\n source, target = [], []\\n for i, line in enumerate(text.split('\\\\n')):\\n if num_examples and i > num_examples:\\n break\\n parts = line.split('\\\\t')\\n if len(parts) == 2:\\n source.append(parts[0].split(' '))\\n target.append(parts[1].split(' '))\\n return source, target\",\n \"def process(self, example: str) -> List[torch.Tensor]:\\n return self._tokenizer.batch_encode_plus([example], return_tensors=\\\"pt\\\", output_past=True, max_length=self.max_seq_len)['input_ids'][0]\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def main():\\n # Load and prep training files\\n raw_speech_text = hg.load_training_file('trump_train.txt')\\n speech_text = hg.prep_training(raw_speech_text)\\n tweet_data = load_tweets('trump_tweets.json')\\n raw_tweets = \\\"\\\"\\n for dct in tweet_data:\\n raw_tweets += \\\"{} \\\".format(dct['text'])\\n tweets = hg.prep_training(raw_tweets)\\n corpus = speech_text + tweets\\n corpus = strip_punctuation(corpus)\\n dict_1 = hg.map_one_to_one(corpus)\\n dict_2 = hg.map_two_to_one(corpus)\\n text = []\\n \\n # Introduction\\n print(\\\"\\\\nTrump Speech Generator\\\\n\\\")\\n print(\\\"Select words to add to speech\\\")\\n print(\\\"\\\\'x\\\\' to exit\\\")\\n print(\\\"\\\\'p\\\\' to add punctuation\\\")\\n print(\\\"Select \\\\'p\\\\' before selecting the word you want to punctuate\\\")\\n\\n # Select first word\\n options = corpus\\n print ()\\n selection = select_word(corpus)\\n text.append(selection)\\n \\n # Select second word\\n last = text[0]\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n # Select subsequent word\\n while True:\\n last = \\\"{} {}\\\".format(text[-2].strip(punctuation),\\n text[-1].strip(punctuation))\\n options = word_after_two(last, dict_2)\\n if options == []:\\n last = last.split()[1]\\n options = word_after_one(last, dict_1)\\n while options == []:\\n last = random.choice(corpus)\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n print_text(text)\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n if i <= 3:\\n print(\\\"i={}, line={}\\\".format(i, line))\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for idx, line in enumerate(lines):\\n item = json.loads(line.strip())\\n question_id = \\\"%s-%s\\\" % (set_type, idx)\\n context = item[\\\"context\\\"]\\n question = item[\\\"question\\\"]\\n endings = [item[\\\"answerA\\\"],item[\\\"answerB\\\"],item[\\\"answerC\\\"] ]\\n label = item[\\\"correct\\\"]\\n #race_id = \\\"%s-%s\\\" % (set_type, data_raw[\\\"race_id\\\"])\\n #article = data_raw[\\\"article\\\"]\\n #for i in range(len(data_raw[\\\"answers\\\"])):\\n #truth = str(ord(data_raw[\\\"answers\\\"][i]) - ord(\\\"A\\\"))\\n #question = data_raw[\\\"questions\\\"][i]\\n #options = data_raw[\\\"options\\\"][i]\\n\\n examples.append(\\n InputExample(\\n example_id=question_id,\\n question=question,\\n contexts=[context,context,context],\\n endings=[endings[0], endings[1], endings[2]],#, options[3]\\n label=label,\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test_matched':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"]\\n ents_pos = [(pos[\\\"start\\\"], pos[\\\"end\\\"])\\n for pos in passage[\\\"entities\\\"]]\\n ents = [passage[\\\"text\\\"][start:end+1] for start, end in ents_pos]\\n for qa in data[\\\"qas\\\"]:\\n qa_id = f\\\"{set_type}-{data['idx']}-{qa['idx']}\\\"\\n answers = set([ans[\\\"text\\\"] for ans in qa[\\\"answers\\\"]])\\n for ent_idx, ent in enumerate(ents):\\n is_answer = ent in answers\\n guid = f\\\"{qa_id}-{ent_idx}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage[\\\"text\\\"],\\n # Insert entity in query\\n text_b=qa[\\\"query\\\"].replace(\\\"@placeholder\\\", ent),\\n label=\\\"1\\\" if is_answer else \\\"0\\\",\\n )\\n )\\n return examples\",\n \"def run_prediction(question_texts, context_text):\\r\\n examples = []\\r\\n\\r\\n for i, question_text in enumerate(question_texts):\\r\\n example = SquadExample(\\r\\n qas_id=str(i),\\r\\n question_text=question_text,\\r\\n context_text=context_text,\\r\\n answer_text=None,\\r\\n start_position_character=None,\\r\\n title=\\\"Predict\\\",\\r\\n is_impossible=False,\\r\\n answers=None,\\r\\n )\\r\\n\\r\\n examples.append(example)\\r\\n\\r\\n features, dataset = squad_convert_examples_to_features(\\r\\n examples=examples,\\r\\n tokenizer=tokenizer,\\r\\n max_seq_length=384,\\r\\n doc_stride=128,\\r\\n max_query_length=64,\\r\\n is_training=False,\\r\\n return_dataset=\\\"pt\\\",\\r\\n threads=1,\\r\\n )\\r\\n\\r\\n eval_sampler = SequentialSampler(dataset)\\r\\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\\r\\n\\r\\n all_results = []\\r\\n\\r\\n for batch in eval_dataloader:\\r\\n model.eval()\\r\\n batch = tuple(t.to(device) for t in batch)\\r\\n\\r\\n with torch.no_grad():\\r\\n inputs = {\\r\\n \\\"input_ids\\\": batch[0],\\r\\n \\\"attention_mask\\\": batch[1],\\r\\n \\\"token_type_ids\\\": batch[2],\\r\\n }\\r\\n\\r\\n example_indices = batch[3]\\r\\n\\r\\n outputs = model(**inputs)\\r\\n\\r\\n for i, example_index in enumerate(example_indices):\\r\\n eval_feature = features[example_index.item()]\\r\\n unique_id = int(eval_feature.unique_id)\\r\\n\\r\\n output = [to_list(output[i]) for output in outputs]\\r\\n\\r\\n start_logits, end_logits = output\\r\\n result = SquadResult(unique_id, start_logits, end_logits)\\r\\n all_results.append(result)\\r\\n\\r\\n output_prediction_file = \\\"predictions.json\\\"\\r\\n output_nbest_file = \\\"nbest_predictions.json\\\"\\r\\n output_null_log_odds_file = \\\"null_predictions.json\\\"\\r\\n\\r\\n predictions = compute_predictions_logits(\\r\\n examples,\\r\\n features,\\r\\n all_results,\\r\\n n_best_size,\\r\\n max_answer_length,\\r\\n do_lower_case,\\r\\n output_prediction_file,\\r\\n output_nbest_file,\\r\\n output_null_log_odds_file,\\r\\n False, # verbose_logging\\r\\n True, # version_2_with_negative\\r\\n null_score_diff_threshold,\\r\\n tokenizer,\\r\\n )\\r\\n\\r\\n return predictions\",\n \"def get_transformed_io(data_path, data_dir):\\n sents, labels = read_line_examples_from_file(data_path)\\n\\n # the input is just the raw sentence\\n inputs = [s.copy() for s in sents]\\n\\n task = 'asqp'\\n if task == 'aste':\\n targets = get_para_aste_targets(sents, labels)\\n elif task == 'tasd':\\n targets = get_para_tasd_targets(sents, labels)\\n elif task == 'asqp':\\n targets = get_para_asqp_targets(sents, labels)\\n else:\\n raise NotImplementedError\\n\\n return inputs, targets\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n text_b = line[4]\\n label = line[0]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[7]\\n text_b = line[8]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, type):\\n examples = []\\n\\n for i in range(0, len(lines), self.interval):\\n text_a = lines[i]\\n label = lines[i + 2]\\n\\n examples.append(\\n InputExample(guid=len(examples), text_a=text_a, pos=None, label=label))\\n return examples\",\n \"def _create_examples(self, df, set_type):\\n examples = []\\n for i, row in df.iterrows():\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = row[4]\\n label = row[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, ids )\\n text_a = lines[ids]['term']\\n text_b = lines[ids]['sentence']\\n label = lines[ids]['polarity']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n label_id = label_map[example.label]\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # Only the test set has a header\\n if set_type == \\\"test\\\" and i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61118716","0.592422","0.58838516","0.585979","0.5801184","0.5781311","0.57746387","0.57520574","0.57209575","0.56961864","0.5692046","0.5686498","0.5684553","0.5684334","0.56032795","0.5577988","0.55708474","0.55665946","0.55582416","0.5552899","0.5534642","0.55299616","0.55197054","0.5517937","0.55169827","0.55169827","0.5511616","0.550572","0.5499984","0.5494332","0.5491262","0.54877734","0.54781","0.547139","0.5471115","0.547109","0.54651093","0.5456408","0.5456408","0.54546094","0.54541314","0.54510176","0.545045","0.5447743","0.5443042","0.5443042","0.5442952","0.54371274","0.5437034","0.5434161","0.5423708","0.5423645","0.54224443","0.54152596","0.54126334","0.5410348","0.5401643","0.53947794","0.53685164","0.5364609","0.53529596","0.5346267","0.5344079","0.5342889","0.53388065","0.5338763","0.5334941","0.53341085","0.53306425","0.5329905","0.5326312","0.53261626","0.5323165","0.5318985","0.5316931","0.53124577","0.5288165","0.528546","0.5284152","0.5281828","0.52811784","0.5279969","0.527894","0.527894","0.527894","0.52783775","0.52757883","0.5275729","0.5273562","0.52716976","0.52700806","0.5265037","0.526453","0.52609104","0.52589476","0.52557975","0.5252407","0.5246993","0.52448076","0.52409756"],"string":"[\n \"0.61118716\",\n \"0.592422\",\n \"0.58838516\",\n \"0.585979\",\n \"0.5801184\",\n \"0.5781311\",\n \"0.57746387\",\n \"0.57520574\",\n \"0.57209575\",\n \"0.56961864\",\n \"0.5692046\",\n \"0.5686498\",\n \"0.5684553\",\n \"0.5684334\",\n \"0.56032795\",\n \"0.5577988\",\n \"0.55708474\",\n \"0.55665946\",\n \"0.55582416\",\n \"0.5552899\",\n \"0.5534642\",\n \"0.55299616\",\n \"0.55197054\",\n \"0.5517937\",\n \"0.55169827\",\n \"0.55169827\",\n \"0.5511616\",\n \"0.550572\",\n \"0.5499984\",\n \"0.5494332\",\n \"0.5491262\",\n \"0.54877734\",\n \"0.54781\",\n \"0.547139\",\n \"0.5471115\",\n \"0.547109\",\n \"0.54651093\",\n \"0.5456408\",\n \"0.5456408\",\n \"0.54546094\",\n \"0.54541314\",\n \"0.54510176\",\n \"0.545045\",\n \"0.5447743\",\n \"0.5443042\",\n \"0.5443042\",\n \"0.5442952\",\n \"0.54371274\",\n \"0.5437034\",\n \"0.5434161\",\n \"0.5423708\",\n \"0.5423645\",\n \"0.54224443\",\n \"0.54152596\",\n \"0.54126334\",\n \"0.5410348\",\n \"0.5401643\",\n \"0.53947794\",\n \"0.53685164\",\n \"0.5364609\",\n \"0.53529596\",\n \"0.5346267\",\n \"0.5344079\",\n \"0.5342889\",\n \"0.53388065\",\n \"0.5338763\",\n \"0.5334941\",\n \"0.53341085\",\n \"0.53306425\",\n \"0.5329905\",\n \"0.5326312\",\n \"0.53261626\",\n \"0.5323165\",\n \"0.5318985\",\n \"0.5316931\",\n \"0.53124577\",\n \"0.5288165\",\n \"0.528546\",\n \"0.5284152\",\n \"0.5281828\",\n \"0.52811784\",\n \"0.5279969\",\n \"0.527894\",\n \"0.527894\",\n \"0.527894\",\n \"0.52783775\",\n \"0.52757883\",\n \"0.5275729\",\n \"0.5273562\",\n \"0.52716976\",\n \"0.52700806\",\n \"0.5265037\",\n \"0.526453\",\n \"0.52609104\",\n \"0.52589476\",\n \"0.52557975\",\n \"0.5252407\",\n \"0.5246993\",\n \"0.52448076\",\n \"0.52409756\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56218064"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":95596,"cells":{"query":{"kind":"string","value":"Converts examples into TexttoText batches to be used with a model like T5. Inputs are prefixed with a text prompt that indicates the task to perform."},"document":{"kind":"string","value":"def convert_xnli_examples_to_features(self):\n features = self.features\n lang_filtered_features = []\n for ex_index, example in enumerate(self.examples):\n language = example.guid.split('-')[1]\n if language in self.lang_list:\n lang_filtered_features.append(features[ex_index] + [language])\n return lang_filtered_features"},"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 batch_tokenize_fn(examples):\n sources = examples[config.source_lang]\n targets = examples[config.target_lang]\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\n\n # setup the tokenizer for targets,\n # huggingface expects the target tokenized ids to be stored in the labels field\n with config.tokenizer.as_target_tokenizer():\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\n\n model_inputs[\"labels\"] = labels[\"input_ids\"]\n return model_inputs","def create_InputExamples(self, data, labels):\n examples = []\n for (i, u_tips) in enumerate(data):\n for text in u_tips:\n examples.append(\n run_classifier.InputExample(\n guid=None,\n text_a=text,\n text_b=None,\n label=np.argmax(labels[i])\n )\n )\n return examples","def create_examples(topics, sentences):\n input_examples = []\n \n for i in range(len(sentences)):\n input_examples.append(InputExample(text_a=topics[i], text_b=sentences[i], label='NoArgument'))\n return input_examples","def read_examples_string(input_text):#(input_file, input_text):\n examples = []\n unique_id = 0\n \n with io.StringIO(input_text) as reader:\n while True:\n line = tokenization.convert_to_unicode(reader.readline())\n if not line:\n break\n\n line = line.strip()\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n\n if m is None:\n text_a = line\n else:\n text_a = m.group(1)\n text_b = m.group(2)\n\n examples.append(InputExample(unique_id=unique_id,\n text_a=text_a, \n text_b=text_b))\n unique_id += 1\n return examples","def test_text_task(self):\n args = BASE_ARGS.copy()\n args.update(TEXT_ARGS)\n valid, test = testing_utils.train_model(args)\n self.assertLessEqual(\n valid['ppl'], 1.5, 'failed to train image_seq2seq on text task'\n )","def batchify(self, observations):\n # valid examples\n exs = [ex for ex in observations if 'text' in ex]\n # the indices of the valid (non-empty) tensors\n valid_inds = [i for i, ex in enumerate(observations) if 'text' in ex]\n\n # set up the input tensors\n batchsize = len(exs)\n if batchsize == 0:\n return None, None, None\n # tokenize the text\n parsed_x = [deque(maxlen=self.truncate) for _ in exs]\n for dq, ex in zip(parsed_x, exs):\n dq += self.parse(ex['text'])\n # parsed = [self.parse(ex['text']) for ex in exs]\n max_x_len = max((len(x) for x in parsed_x))\n for x in parsed_x:\n # left pad with zeros\n x.extendleft([self.fairseq_dict.pad()] * (max_x_len - len(x)))\n xs = torch.LongTensor(parsed_x)\n\n # set up the target tensors\n ys = None\n if 'labels' in exs[0]:\n # randomly select one of the labels to update on, if multiple\n labels = [random.choice(ex.get('labels', [''])) for ex in exs]\n parsed_y = [deque(maxlen=self.truncate) for _ in labels]\n for dq, y in zip(parsed_y, labels):\n dq.extendleft(reversed(self.parse(y)))\n for y in parsed_y:\n y.append(self.fairseq_dict.eos())\n # append EOS to each label\n max_y_len = max(len(y) for y in parsed_y)\n for y in parsed_y:\n y += [self.fairseq_dict.pad()] * (max_y_len - len(y))\n ys = torch.LongTensor(parsed_y)\n return xs, ys, valid_inds","def args_batch_to_text(args_batch: ArgsBatch) -> Text:\n lines = []\n for args in args_batch:\n lines.append('; '.join(str(a) for a in args))\n return '\\n'.join(lines)","def _create_examples(self, lines, kb_data, set_type):\n examples = []\n for idx, line in enumerate(lines):\n item = json.loads(line.strip())\n question_id = \"%s-%s\" % (set_type, idx)\n \n context_a_list = kb_data[idx]['answerA']\n context_b_list = kb_data[idx]['answerB']\n context_c_list = kb_data[idx]['answerC']\n\n context_a = \"\"\n for l in context_a_list[:1]:\n context_a += l.replace(\"\\n\",\". \")\n context_a = context_a[:-1]\n\n context_b = \"\"\n for l in context_b_list[:1]:\n context_b += l.replace(\"\\n\",\". \")\n context_b = context_b[:-1]\n\n context_c = \"\"\n for l in context_c_list[:1]:\n context_c += l.replace(\"\\n\",\". \")\n context_c = context_c[:-1]\n \n \n question = item[\"context\"] + item[\"question\"]\n endings = [item[\"answerA\"],item[\"answerB\"],item[\"answerC\"] ]\n label = item[\"correct\"]\n #race_id = \"%s-%s\" % (set_type, data_raw[\"race_id\"])\n #article = data_raw[\"article\"]\n #for i in range(len(data_raw[\"answers\"])):\n #truth = str(ord(data_raw[\"answers\"][i]) - ord(\"A\"))\n #question = data_raw[\"questions\"][i]\n #options = data_raw[\"options\"][i]\n\n examples.append(\n InputExample(\n example_id=question_id,\n question=question,\n contexts=[context_a,context_b,context_c],\n endings=[endings[0], endings[1], endings[2]],#, options[3]\n label=label,\n )\n )\n return examples","def _create_examples(self, lines):\n examples = []\n for (i, line) in enumerate(lines):\n logger.info(line)\n guid = int(line[0])\n label = int(line[1])\n text = \" \".join(clean_tokens(line[3].split()))\n if guid < 1000:\n args_char_offset = find_char_offsets(text, line[2].split(\"-\"))\n else:\n args_char_offset = [int(i) for i in line[2].split('-')]\n examples.append(\n InputExample(guid=guid, text=text, args_char_offset=args_char_offset, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = line[0]\n text_a = line[1] + \" . \" + line[2]\n text_b = line[-1]\n label = 0\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(self):\n features = []\n max_label_len = 0\n # find ou the max label length\n labels_list = []\n for ex_index, example in enumerate(self.examples):\n processor = example.processor\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\n max_label_len = max(len(label_ids), max_label_len)\n labels_list.append(label_ids)\n if self.max_seq_length_decoder is None:\n self.max_seq_length_decoder = max_label_len\n else:\n self.max_seq_length_decoder = max(\n self.max_seq_length_decoder, max_label_len\n ) # take the max of the two to be conservative\n for ex_index, example in enumerate(self.examples):\n taskname = example.taskname\n taskname_ids = self.tokenizer.text_to_ids(taskname)\n processor = example.processor\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n label_ids = labels_list[ex_index]\n enc_query = processor.get_ptune_query(\n example.content,\n self.pseudo_token_id,\n self.max_seq_length - self.max_seq_length_decoder + 1,\n self.templates,\n self.tokenizer,\n )\n input_ids = enc_query + label_ids[:-1]\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\n features.append([input_ids, labels, enc_query, taskname_ids])\n return features","def qkgnn_convert_examples_to_features(\r\n examples,\r\n tokenizer,\r\n max_length=512,\r\n task=None,\r\n label_list=None,\r\n output_mode=None,\r\n pad_on_left=False,\r\n pad_token=0,\r\n pad_token_segment_id=0,\r\n mask_padding_with_zero=True,\r\n):\r\n\r\n if task is not None:\r\n processor = gnn_processors[task]()\r\n if label_list is None:\r\n label_list = processor.get_labels()\r\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\r\n if output_mode is None:\r\n output_mode = gnn_output_modes[task]\r\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\r\n label_map = {label: i for i, label in enumerate(label_list)}\r\n\r\n\r\n # TODO : optimize this part if out of memory error occurs\r\n def convert_inputs_to_processed(inputs):\r\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\r\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\r\n # tokens are attended to.\r\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\r\n\r\n # Zero-pad up to the sequence length.\r\n padding_length = max_length - len(input_ids)\r\n if pad_on_left:\r\n input_ids = ([pad_token] * padding_length) + input_ids\r\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\r\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\r\n else:\r\n input_ids = input_ids + ([pad_token] * padding_length)\r\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\r\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\r\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\r\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\r\n len(attention_mask), max_length\r\n )\r\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\r\n len(token_type_ids), max_length\r\n )\r\n\r\n return input_ids, attention_mask, token_type_ids\r\n\r\n # TODO : optimize this part if out of memory error occurs\r\n def qkgnn_convert_single_exampl_to_feature(example, ex_index=10):\r\n inputs_q = tokenizer.encode_plus(example.text_a, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_k = tokenizer.encode_plus(example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk1 = tokenizer.encode_plus(example.text_a, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk2 = tokenizer.encode_plus(example.text_a, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qk3 = tokenizer.encode_plus(example.text_a, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq1 = tokenizer.encode_plus(example.text_b, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq2 = tokenizer.encode_plus(example.text_b, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kq3 = tokenizer.encode_plus(example.text_b, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk1 = tokenizer.encode_plus(example.text_b, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk2 = tokenizer.encode_plus(example.text_b, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_kk3 = tokenizer.encode_plus(example.text_b, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq1 = tokenizer.encode_plus(example.text_a, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq2 = tokenizer.encode_plus(example.text_a, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\r\n inputs_qq3 = tokenizer.encode_plus(example.text_a, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\r\n # generate [input_ids, input_mask, segment_ids]\r\n # for q self\r\n input_ids_q, input_mask_q, segment_ids_q = convert_inputs_to_processed(inputs_q)\r\n # for k self\r\n input_ids_k, input_mask_k, segment_ids_k = convert_inputs_to_processed(inputs_k)\r\n # for qk\r\n input_ids_qk, input_mask_qk, segment_ids_qk = convert_inputs_to_processed(inputs_qk)\r\n # for qk1\r\n input_ids_qk1, input_mask_qk1, segment_ids_qk1 = convert_inputs_to_processed(inputs_qk1)\r\n # for qk2\r\n input_ids_qk2, input_mask_qk2, segment_ids_qk2 = convert_inputs_to_processed(inputs_qk2)\r\n # for qk3\r\n input_ids_qk3, input_mask_qk3, segment_ids_qk3 = convert_inputs_to_processed(inputs_qk3)\r\n # for kq1\r\n input_ids_kq1, input_mask_kq1, segment_ids_kq1 = convert_inputs_to_processed(inputs_kq1)\r\n # for kq2\r\n input_ids_kq2, input_mask_kq2, segment_ids_kq2 = convert_inputs_to_processed(inputs_kq2)\r\n # for kq3\r\n input_ids_kq3, input_mask_kq3, segment_ids_kq3 = convert_inputs_to_processed(inputs_kq3)\r\n # for kk1\r\n input_ids_kk1, input_mask_kk1, segment_ids_kk1 = convert_inputs_to_processed(inputs_kk1)\r\n # for kk2\r\n input_ids_kk2, input_mask_kk2, segment_ids_kk2 = convert_inputs_to_processed(inputs_kk2)\r\n # for kk3\r\n input_ids_kk3, input_mask_kk3, segment_ids_kk3 = convert_inputs_to_processed(inputs_kk3)\r\n # for qq1\r\n input_ids_qq1, input_mask_qq1, segment_ids_qq1 = convert_inputs_to_processed(inputs_qq1)\r\n # for qq2\r\n input_ids_qq2, input_mask_qq2, segment_ids_qq2 = convert_inputs_to_processed(inputs_qq2)\r\n # for qq3\r\n input_ids_qq3, input_mask_qq3, segment_ids_qq3 = convert_inputs_to_processed(inputs_qq3)\r\n\r\n # generate label\r\n if output_mode == \"classification\" or output_mode == \"classification2\":\r\n label = label_map[example.label]\r\n elif output_mode == \"regression\":\r\n label = float(example.label)\r\n else:\r\n raise KeyError(output_mode)\r\n\r\n # log info\r\n if ex_index < 5:\r\n logger.info(\"*** Example ***\")\r\n logger.info(\"guid: %s\" % (example.guid))\r\n logger.info(\"text_a: %s\" % (example.text_a))\r\n logger.info(\"text_b: %s\" % (example.text_b))\r\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_qk]))\r\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in input_mask_qk]))\r\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in segment_ids_qk]))\r\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\r\n # generate the feature for single example\r\n feature = InputFeatures_GNN(\r\n input_ids_q=input_ids_q,\r\n input_mask_q=input_mask_q,\r\n segment_ids_q=segment_ids_q,\r\n\r\n input_ids_k=input_ids_k,\r\n input_mask_k=input_mask_k,\r\n segment_ids_k=segment_ids_k,\r\n\r\n input_ids_qk=input_ids_qk,\r\n input_mask_qk=input_mask_qk,\r\n segment_ids_qk=segment_ids_qk,\r\n\r\n input_ids_qk1=input_ids_qk1,\r\n input_mask_qk1=input_mask_qk1,\r\n segment_ids_qk1=segment_ids_qk1,\r\n input_ids_qk2=input_ids_qk2,\r\n input_mask_qk2=input_mask_qk2,\r\n segment_ids_qk2=segment_ids_qk2,\r\n input_ids_qk3=input_ids_qk3,\r\n input_mask_qk3=input_mask_qk3,\r\n segment_ids_qk3=segment_ids_qk3,\r\n\r\n input_ids_kq1=input_ids_kq1,\r\n input_mask_kq1=input_mask_kq1,\r\n segment_ids_kq1=segment_ids_kq1,\r\n input_ids_kq2=input_ids_kq2,\r\n input_mask_kq2=input_mask_kq2,\r\n segment_ids_kq2=segment_ids_kq2,\r\n input_ids_kq3=input_ids_kq3,\r\n input_mask_kq3=input_mask_kq3,\r\n segment_ids_kq3=segment_ids_kq3,\r\n\r\n input_ids_qq1=input_ids_qq1,\r\n input_mask_qq1=input_mask_qq1,\r\n segment_ids_qq1=segment_ids_qq1,\r\n input_ids_qq2=input_ids_qq2,\r\n input_mask_qq2=input_mask_qq2,\r\n segment_ids_qq2=segment_ids_qq2,\r\n input_ids_qq3=input_ids_qq3,\r\n input_mask_qq3=input_mask_qq3,\r\n segment_ids_qq3=segment_ids_qq3,\r\n\r\n input_ids_kk1=input_ids_kk1,\r\n input_mask_kk1=input_mask_kk1,\r\n segment_ids_kk1=segment_ids_kk1,\r\n input_ids_kk2=input_ids_kk2,\r\n input_mask_kk2=input_mask_kk2,\r\n segment_ids_kk2=segment_ids_kk2,\r\n input_ids_kk3=input_ids_kk3,\r\n input_mask_kk3=input_mask_kk3,\r\n segment_ids_kk3=segment_ids_kk3,\r\n\r\n row_id=int(example.guid),\r\n label_id=label,\r\n task_id=task,\r\n is_real_example=True)\r\n return feature\r\n\r\n features = []\r\n for (ex_index, example) in tqdm(enumerate(examples)):\r\n features.append(qkgnn_convert_single_exampl_to_feature(example, ex_index=ex_index))\r\n\r\n return features","def _create_examples(self, lines: List[str], mode: Split):\n examples = []\n text_index = 1 if mode == Split.test else 0\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, i)\n text_a = line[text_index]\n if len(line) > text_index + 1:\n label = line[text_index + 1]\n else:\n label = None\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self,lines, set_type):\n examples = []\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n text_b = tx.utils.compat_as_text(line[1])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n elif len(lines[1]) == 1: # text_a (when test file has no label)\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[0])\n if set_type == \"test\":\n label = \"0\"\n else:\n print(\"the file is not for testing, yet contains no labels\")\n exit()\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=\"\", label=label))\n elif len(lines[1]) == 3: # label text_a text_b\n for (i, line) in enumerate(lines):\n guid = f\"{set_type}-{i}\"\n text_a = tx.utils.compat_as_text(line[1])\n text_b = tx.utils.compat_as_text(line[2])\n\n label = tx.utils.compat_as_text(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a,\n text_b=text_b, label=label))\n return examples","def convert_examples_to_features(self):\n features = []\n for ex_index, example in enumerate(self.examples):\n if ex_index % 10000 == 0:\n logging.info(f\"Writing example {ex_index} of {len(self.examples)}\")\n\n text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)\n enc_query = self.tokenizer.text_to_ids(text_to_text_query)\n if len(enc_query) > self.max_seq_length:\n enc_query = enc_query[: self.max_seq_length]\n dec_query = (\n [self.tokenizer.bos_id]\n + self.tokenizer.text_to_ids(self.processor.label2string(example.label))\n + [self.tokenizer.eos_id]\n )\n\n dec_input = dec_query[:-1]\n labels = dec_query[1:]\n\n features.append([enc_query, dec_input, labels])\n\n return features","def create_examples(lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, str(i))\n text_a_id = line[0]\n text_a = tokenization.convert_to_unicode(line[1])\n text_b_id = line[2]\n text_b = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(InputExample(guid=guid, text_a_id=text_a_id, text_a=text_a, text_b_id=text_b_id, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[0])\n text_b = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines: List[str], mode: Split):\n # id,title,content,label\n test_mode = mode == Split.test\n title_index = 1\n content_index = 2\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[title_index]\n text_b = line[content_index]\n if test_mode:\n label = None\n else:\n label = line[3]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n text_b = tokenization.convert_to_unicode(line[2])\n label = tokenization.convert_to_unicode(line[3])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines: List[str], mode: Split):\n test_mode = mode == Split.test\n q1_index = 1 if test_mode else 3\n q2_index = 2 if test_mode else 4\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[q1_index]\n text_b = line[q2_index]\n label = None if test_mode else line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000000000\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\n\n query_tokens = tokenizer.tokenize(example.question_text)\n if max_query_length is None:\n max_query_length = len(query_tokens)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n for _ in enumerate(range(1)):\n tokens_ = []\n tokens_.append(\"[CLS]\")\n for token in query_tokens:\n tokens_.append(token)\n tokens_.append(\"[SEP]\")\n\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids_) < max_query_length + 2:\n input_ids_.append(0)\n input_mask_.append(0)\n\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n if example_index < 1:\n # logger.info(\"*** Example ***\")\n # logger.info(\"unique_id: %s\" % (unique_id))\n # logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in query_tokens]))\n # logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_]))\n # logger.info(\n # \"input_mask: %s\" % \" \".join([str(x) for x in input_mask_]))\n\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n unique_id += 1\n\n return question_features","def _create_examples(self, lines, set_type):\n test_mode = set_type == \"test\"\n if test_mode:\n lines = lines[1:]\n text_index = 1 if test_mode else 3\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[text_index]\n label = None if test_mode else line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[2])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n label = tokenization.convert_to_unicode(line[1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, tokenization.convert_to_unicode(line[0]))\n text_a = tokenization.convert_to_unicode(line[8])\n text_b = tokenization.convert_to_unicode(line[9])\n if set_type == \"test\":\n label = \"contradiction\"\n else:\n label = tokenization.convert_to_unicode(line[-1])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for i, line in lines.iterrows():\n guid = \"%s-%s\" % (set_type, i)\n text_a = line['sentence1']\n text_b = line['sentence2']\n label = line['label']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def print_examples(example_iter, model, num=0, max_len=100,\n bos_index=1,\n src_eos_index = None,\n trg_eos_index = None,\n src_vocab=None, trg_vocab=None):\n model.eval()\n count=0\n\n BOS_TOKEN = \"<s>\"\n EOS_TOKEN = \"</s>\"\n UNK_TOKEN = \"<unk>\"\n\n if src_vocab is not None and trg_vocab is not None:\n src_bos_index = src_vocab.stoi[BOS_TOKEN]\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\n trg_unk_index = trg_vocab.stoi[UNK_TOKEN]\n # trg_bos_index = trg_vocab.stoi[BOS_TOKEN]\n # trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\n else:\n src_bos_index = 0\n src_eos_index = 1\n trg_unk_index = 2\n # trg_bos_index = 1\n # trg_eos_index = None\n\n for i, batch in enumerate(example_iter, 1):\n src = batch.src.cpu().numpy()[0, :]\n trg_idx = batch.trg_idx.cpu().numpy()[0, :]\n\n # remove </s>\n src = src[1:] if src[0]==src_bos_index else src\n src = src[:-1] if src[-1]==src_eos_index else src\n # trg = trg[:-1] if trg[-1]==trg_eos_index else trg\n\n result = greedy_decode(model, batch.src_idx, batch.src_mask, batch.src_lengths)\n print()\n print(\"Example %d\" % i)\n print(\"Source: \", \" \".join(lookup_words(src, vocab=src_vocab)))\n print()\n print(\"Target: \", set(lookup_words(trg_idx, vocab=trg_vocab)))\n print()\n print(\"Prediction: \", \" \".join(lookup_words(result[0], vocab=trg_vocab)))\n\n count += 1\n if count == num:\n break","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[8]\n text_b = line[9]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, max_seq_length, tokenizer):\n\n features = []\n for (ex_index, example) in enumerate(examples):\n print(example.text_a)\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n input_mask = [1] * len(input_ids)\n\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n \n labels_ids = []\n for label in example.labels:\n labels_ids.append(int(label))\n \n if ex_index < 0:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %s)\" % (example.labels, labels_ids))\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=labels_ids))\n return features","def _create_examples(self, data, set_type):\n examples = []\n for (i, elem) in enumerate(data):\n guid = \"%s-%s\" % (set_type, i)\n text = elem[0]\n label = elem[1]\n examples.append(\n InputExample(guid=guid, text=text, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n try:\n text_a = line[3]\n text_b = line[4]\n label = line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def generate_text(pmodel, num_generate, temperature, start_string):\n\n # Converting the start string to numbers (vectorizing)\n input_eval = [char2idx[s] for s in start_string]\n input_eval = tf.expand_dims(input_eval, 0)\n\n # Empty string to store the results\n text_generated = np.empty(1)\n\n # Here batch size = 1\n pmodel.reset_states()\n for i in range(num_generate):\n \n predictions = pmodel(input_eval)\n \n # remove the batch dimension\n predictions = tf.squeeze(predictions, 0)\n \n # using a multinomial distribution to predict the word returned by the model\n predictions = predictions / temperature\n predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\n \n # We pass the predicted word as the next input to the model\n # along with the previous hidden state\n input_eval = tf.expand_dims([predicted_id], 0)\n \n text_generated = np.vstack((text_generated, idx2char[predicted_id].tolist()))\n \n return text_generated","def convert_examples_to_features(\n examples: List[InputExample],\n label_list: List[str],\n max_length: int,\n tokenizer: PreTrainedTokenizer,\n pad_token_segment_id=0,\n pad_on_left=False,\n pad_token=0,\n mask_padding_with_zero=True,\n) -> List[InputFeatures]:\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\"convert examples to features\"):\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\n choices_features = []\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\n text_a = context\n if example.question.find(\"_\") != -1:\n # this is for cloze question\n text_b = example.question.replace(\"_\", ending)\n else:\n text_b = example.question + \" \" + ending\n if len(text_a) == 0:\n logger.info(\"context of example %d have length 0\" % (ex_index))\n text_a = \" \"\n\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\n if \"num_truncated_tokens\" in inputs and inputs[\"num_truncated_tokens\"] > 0:\n logger.info(\n \"Attention! you are cropping tokens (swag task is ok). \"\n \"If you are training ARC and RACE and you are poping question + options,\"\n \"you need to try to use a bigger max seq length!\"\n )\n\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length\n assert len(attention_mask) == max_length\n assert len(token_type_ids) == max_length\n choices_features.append((input_ids, attention_mask, token_type_ids))\n\n label = label_map[example.label]\n\n if ex_index < 2:\n logger.info(\"*** Example ***\")\n logger.info(\"race_id: {}\".format(example.example_id))\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\n logger.info(\"choice: {}\".format(choice_idx))\n logger.info(\"input_ids: {}\".format(\" \".join(map(str, input_ids))))\n logger.info(\"attention_mask: {}\".format(\" \".join(map(str, attention_mask))))\n logger.info(\"token_type_ids: {}\".format(\" \".join(map(str, token_type_ids))))\n logger.info(\"label: {}\".format(label))\n\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\n\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for i, line in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[5]\n text_b = line[6]\n pairID = line[7][2:] if line[7].startswith(\"ex\") else line[7]\n label = line[0]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n text_a = line[1]\n text_b = line[2]\n label = line[-1] if set_type != \"test\" else \"entailment\"\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n # label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n exindex = {}\n passagelens = []\n\n sum_of_labels = 0\n\n for (ex_index, example) in tqdm(enumerate(examples), desc=\"Tokenizing:\"):\n if example.text_a not in tokenmap.keys():\n tokens_a = tokenizer.tokenize(example.text_a)\n tokenmap[example.text_a] = tokens_a\n else:\n tokens_a = tokenmap[example.text_a]\n\n tokens_b = None\n if example.text_b:\n if example.text_b not in tokenmap.keys():\n tokens_b = tokenizer.tokenize(example.text_b)\n tokenmap[example.text_b] = tokens_b\n else:\n tokens_b = tokenmap[example.text_b]\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\n\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n # label_id = label_map[example.label]\n label_id = example.label\n\n sum_of_labels += label_id\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"tokens: %s\" % \" \".join(\n [str(x) for x in tokens]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n logger.info(\n \"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\n logger.info(\"label: %s (id = %d)\" % (str(example.label), 0))\n\n exindex[ex_index] = example.guid\n features.append(\n InputFeatures(uuid=ex_index,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n\n print(\"Passage Token Lengths Distribution\", passagelens[-1], np.percentile(passagelens, 50),\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\n return features, exindex","def convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n multilabel=False,\n):\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n if multilabel:\n domain_label_map = {label: i for i, label in enumerate([\"0\", \"1\"])}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, )\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label = label_map[example.label] if not multilabel else label_map[example.label[0]]\n elif output_mode == \"regression\":\n label = float(example.label) if not multilabel else float(example.label[0])\n else:\n raise KeyError(output_mode)\n if multilabel:\n label = [label, domain_label_map[example.label[1]]]\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n if multilabel:\n logger.info(\"label: %s (id = %d)\" % (example.label[0], label[0]))\n logger.info(\"domain label: %s (id = %d)\" % (example.label[1], label[1]))\n else:\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\n )\n )\n\n return features","def glue_convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n):\n is_tf_dataset = False\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\n is_tf_dataset = True\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = 0\n if is_tf_dataset:\n example = processor.get_example_from_tensor_dict(example)\n example = processor.tfds_map(example)\n len_examples = tf.data.experimental.cardinality(examples)\n else:\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label_id = label_map[example.label]\n elif output_mode == \"regression\":\n label_id = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label_id))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label_id=label_id\n )\n )\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n text_a = lines[ids]['sentence']\n examples.append(\n InputExample(text_a=text_a) )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # if i == 0:\n # continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[1]\n text_b = None\n label = line[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # if i == 0:\n # continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[1]\n text_b = None\n label = line[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n text_b = line[4]\r\n# if set_type == 'test':\r\n# label = self.get_labels()[0]\r\n# else:\r\n# label = line[0]\r\n label = line[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = None if set_type == \"test\" else line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[0]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0]) if set_type != \"test\" else line[0]\n try:\n text_a = line[3] if set_type != \"test\" else line[1]\n text_b = line[4] if set_type != \"test\" else line[2]\n label = line[5] if set_type != \"test\" else \"0\"\n except IndexError:\n continue\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = tokenization.convert_to_unicode(line[3])\n text_b = tokenization.convert_to_unicode(line[4])\n if set_type == \"test\":\n label = \"0\"\n else:\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label : i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens = example.text\n\n# # Account for [CLS] and [SEP] with \"- 2\"\n# if len(tokens) > max_seq_length - 2:\n# tokens = tokens[:(max_seq_length - 2)]\n\n bert_tokens = []\n orig_to_tok_map = []\n\n bert_tokens.append(\"[CLS]\")\n for token in tokens:\n new_tokens = tokenizer.tokenize(token)\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\n # print(\"You shouldn't see this since the test set is already pre-separated.\")\n break\n else:\n orig_to_tok_map.append(len(bert_tokens))\n bert_tokens.extend(new_tokens)\n bert_tokens.append(\"[SEP]\")\n\n if len(bert_tokens) == 2: # edge case\n continue\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n\n segment_ids = [0] * max_seq_length # no use for our problem\n\n labels = example.label\n label_ids = [0] * max_seq_length\n label_mask = [0] * max_seq_length\n\n for label, target_index in zip(labels, orig_to_tok_map):\n label_ids[target_index] = label_map[label]\n label_mask[target_index] = 1\n\n assert len(segment_ids) == max_seq_length\n assert len(label_ids) == max_seq_length\n assert len(label_mask) == max_seq_length\n\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_ids=label_ids,\n label_mask=label_mask))\n return features","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n text_b = line[4]\r\n label = line[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[3]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[8]\r\n text_b = line[9]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[7]\r\n text_b = line[8]\r\n label = line[-1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def read_examples(input_file):\n examples = []\n unique_id = 0\n with tf.gfile.GFile(input_file, \"r\") as reader:\n while True:\n line = tokenization.convert_to_unicode(reader.readline())\n if not line:\n break\n \n line = line.strip()\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n \n if m is None:\n text_a = line\n else:\n text_a = m.group(1)\n text_b = m.group(2)\n examples.append(InputExample(unique_id=unique_id,\n text_a=text_a, \n text_b=text_b))\n unique_id += 1\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[0]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, i)\r\n text_a = line[1]\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n\r\n return examples","def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\r\n label_map = {}\r\n for (i, label) in enumerate(label_list):\r\n label_map[label] = i\r\n\r\n input_data=[]\r\n for (ex_index, example) in enumerate(examples):\r\n tokens_a = tokenizer.tokenize(example.text_a)\r\n tokens_b = None\r\n if example.text_b:\r\n tokens_b = tokenizer.tokenize(example.text_b)\r\n if tokens_b:\r\n # Modifies `tokens_a` and `tokens_b` in place so that the total\r\n # length is less than the specified length.\r\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\r\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\r\n else:\r\n # Account for [CLS] and [SEP] with \"- 2\"\r\n if len(tokens_a) > max_seq_length - 2:\r\n tokens_a = tokens_a[0:(max_seq_length - 2)]\r\n\r\n if ex_index % 10000 == 0:\r\n tf.logging.info(\"Writing example %d of %d\" % (ex_index, len(examples)))\r\n\r\n # The convention in BERT is:\r\n # (a) For sequence pairs:\r\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\r\n # (b) For single sequences:\r\n # tokens: [CLS] the dog is hairy . [SEP]\r\n # type_ids: 0 0 0 0 0 0 0\r\n #\r\n # Where \"type_ids\" are used to indicate whether this is the first\r\n # sequence or the second sequence. The embedding vectors for `type=0` and\r\n # `type=1` were learned during pre-training and are added to the wordpiece\r\n # embedding vector (and position vector). This is not *strictly* necessary\r\n # since the [SEP] token unambigiously separates the sequences, but it makes\r\n # it easier for the model to learn the concept of sequences.\r\n #\r\n # For classification tasks, the first vector (corresponding to [CLS]) is\r\n # used as as the \"sentence vector\". Note that this only makes sense because\r\n # the entire model is fine-tuned.\r\n tokens = []\r\n segment_ids = []\r\n tokens.append(\"[CLS]\")\r\n segment_ids.append(0)\r\n for token in tokens_a:\r\n tokens.append(token)\r\n segment_ids.append(0)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(0)\r\n\r\n if tokens_b:\r\n for token in tokens_b:\r\n tokens.append(token)\r\n segment_ids.append(1)\r\n tokens.append(\"[SEP]\")\r\n segment_ids.append(1)\r\n\r\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\r\n\r\n input_mask = [1] * len(input_ids)\r\n\r\n while len(input_ids) < max_seq_length:\r\n input_ids.append(0)\r\n input_mask.append(0)\r\n segment_ids.append(0)\r\n assert len(input_ids) == max_seq_length\r\n assert len(input_mask) == max_seq_length\r\n assert len(segment_ids) == max_seq_length\r\n\r\n label_id = label_map[example.label]\r\n if ex_index < 3:\r\n tf.logging.info(\"*** Example ***\")\r\n tf.logging.info(\"guid: %s\" % (example.guid))\r\n tf.logging.info(\"tokens: %s\" % \" \".join([tokenization.printable_text(x) for x in tokens]))\r\n tf.logging.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\r\n tf.logging.info(\"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\r\n tf.logging.info(\"segment_ids: %s\" % \" \".join([str(x) for x in segment_ids]))\r\n tf.logging.info(\"label: %s (id = %d)\" % (example.label, label_id))\r\n\r\n features = collections.OrderedDict()\r\n features[\"input_ids\"] = input_ids\r\n features[\"input_mask\"] = input_mask\r\n features[\"segment_ids\"] = segment_ids\r\n features[\"label_ids\"] =label_id\r\n input_data.append(features)\r\n\r\n return input_data","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"][\"text\"]\n for Q in data[\"passage\"][\"questions\"]:\n question = Q[\"question\"]\n for A in Q[\"answers\"]:\n guid = f\"{set_type}-{data['idx']-Q['idx']-A['idx']}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage,\n text_b=question + \" \" + A[\"text\"],\n label=str(A[\"label\"]),\n )\n )\n return examples","def _create_examples(self, data_dir, set_type):\n\t\texamples = []\n\t\tinput_file_data = os.path.join(data_dir, \"data.tsv\")\n\t\twith open(input_file_data, \"r\", encoding=\"utf-8-sig\") as f:\n\t\t\tfor i, inp in enumerate(f):\n\t\t\t\tinps = inp.split('\\t') \n\t\t\t\tguid = \"%s-%s\" % (set_type, i)\n\t\t\t\ttext_inp = inps[1].strip()\n\t\t\t\ttext_out = inps[2].strip()\n\t\t\t\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\n\t\t\t\t\n\t\t\t# Sort these out before returning\n\t\t\texamples = sorted(examples, key=sort_inp_len)\n\t\t\treturn examples","def _convert_single_example(self, text_a, text_b):\n tokens = []\n input_ids = []\n segment_ids = []\n input_mask = []\n try:\n text_a = self.tokenizer.tokenize(text_a)\n if text_b:\n text_b = self.tokenizer.tokenize(text_b)\n self._truncate_seq_pair(text_a, text_b)\n\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n\n for token in text_a:\n tokens.append(token)\n segment_ids.append(0)\n segment_ids.append(0)\n tokens.append(\"[SEP]\")\n\n if text_b:\n for token in text_b:\n tokens.append(token)\n segment_ids.append(1)\n tokens.append('[SEP]')\n segment_ids.append(1)\n\n input_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n\n input_mask = [1] * len(input_ids)\n\n while len(input_ids) < 50:\n input_ids.append(0)\n input_mask.append(0)\n segment_ids.append(0)\n\n except:\n self.logger.error()\n\n finally:\n return input_ids, input_mask, segment_ids","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[8]\r\n text_b = line[9]\r\n if set_type != 'test':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def print_examples(example_iter, model, n=2, max_len=100, \n sos_index=1, \n src_eos_index=None, \n trg_eos_index=None, \n src_vocab=None, trg_vocab=None):\n\n model.eval()\n count = 0\n print()\n \n if src_vocab is not None and trg_vocab is not None:\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\n trg_sos_index = trg_vocab.stoi[SOS_TOKEN]\n trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\n else:\n src_eos_index = None\n trg_sos_index = 1\n trg_eos_index = None\n \n for i, batch in enumerate(example_iter):\n \n src = batch.src.cpu().numpy()[0, :]\n trg = batch.trg_y.cpu().numpy()[0, :]\n\n # remove </s> (if it is there)\n src = src[:-1] if src[-1] == src_eos_index else src\n trg = trg[:-1] if trg[-1] == trg_eos_index else trg \n \n result, _ = beam_decode(\n model, batch.src, batch.src_mask, batch.src_lengths,\n max_len=max_len, sos_index=trg_sos_index, eos_index=trg_eos_index)\n print(\"Example #%d\" % (i+1))\n print(\"Src : \", \" \".join(lookup_words(src, vocab=src_vocab)))\n print(\"Trg : \", \" \".join(lookup_words(trg, vocab=trg_vocab)))\n print(\"Pred: \", \" \".join(lookup_words(result, vocab=trg_vocab)))\n print()\n \n count += 1\n if count == n:\n break","def _create_examples(self, lines, set_type):\n examples = []\n \n for (i, line) in enumerate(lines):\n sentence_number = 0\n premise_text = line[\"premise\"]\n modified_premise_text = re.sub(self.stage_name_pattern,\"\",premise_text)\n modified_premise_text = re.sub(self.w_patterns,\"\",modified_premise_text)\n hypothesis_text = line[\"hypothesis\"]\n hypothesis_text = re.sub(self.w_patterns,\"\",hypothesis_text)\n a_label = int(line[\"label\"])\n\n sentences = modified_premise_text.split('.')\n\n for j, sentence in enumerate(sentences):\n guid = \"\" + str(sentence_number) + \"\\t\" + str(i) + \"\\t\" + str(len(sentences)) + \"\\t\" + str(a_label)\n text_a = sentence\n text_b = hypothesis_text\n label = a_label\n sentence_number += 1\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n #print(\"16th sentence::\",sentences[16])\n\n return examples","def text_generator(self, example_generator):\n\t\tif self._data_as_tf_example:\n\t\t\tquery_text = None\n\t\t\tquery_edge_list = None\n\t\t\tword_edge_list = None\n\t\t\t\n\t\t\twhile True:\n\t\t\t\te, epoch_num = example_generator.next() # e is a tf.Example\n\t\t\t\ttry:\n\t\t\t\t\tarticle_text = e.features.feature['article'].bytes_list.value[0] # document text\n\t\t\t\t\tabstract_text = e.features.feature['abstract'].bytes_list.value[0] # response text\n\t\t\t\t\tif self._hps.query_encoder.value:\n\t\t\t\t\t\ttry:\n\t\t\t\t\t\t\tquery_text = e.features.feature['query'].bytes_list.value[0] # context text\n\t\t\t\t\t\texcept:\n\t\t\t\t\t\t\tquery_text = ''\n\t\t\t\t\tif self._hps.word_gcn.value:\n\t\t\t\t\t\tword_edge_list = []\n\t\t\t\t\t\tif self._hps.use_default_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t#tf.logging.info((word_edge_list[0]))\n\t\t\t\t\t\tif self._hps.use_coref_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_coref_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_entity_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_entity_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_lexical_graph.value:\n\t\t\t\t\t\t\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_lexical_edge_list'].bytes_list.value[0])\n\t\t\t\t\t#\tprint(word_edge_list)\n\t\t\t\t\t\n\n\t\t\t\t\tif self._hps.query_gcn.value:\n\t\t\t\t\t\tquery_edge_list = []\n\t\t\t\t\t\tif self._hps.use_default_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t\n\t\t\t\t\t\t'''\n\t\t\t\t\t\tThese are inter-sentence graph and may not be applicable\n\t\t\t\t\t\tif self._hps.use_coref_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_coref_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_entity_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_entity_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\tif self._hps.use_lexical_graph.value:\n\t\t\t\t\t\t\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_lexical_edge_list'].bytes_list.value[0])\n\t\t\t\t\t\t'''\n\n\n\n\t\t\t\texcept ValueError:\n\t\t\t\t\ttf.logging.error('Failed to get article or abstract from example')\n\t\t\t\t\tcontinue\n\t\t\t\tif len(article_text)==0: # See https://github.com/abisee/pointer-generator/issues/1\n\t\t\t\t\ttf.logging.warning('Found an example with empty article text. Skipping it.')\n\t\t\t\telse:\n\t\t\t\t\t#tf.logging.info(abstract_text)\n\t\t\t\t\tyield (article_text, abstract_text, word_edge_list, query_text, query_edge_list, epoch_num)\n\t\t\t\n\t\telse:\n\n\t\t\twhile True:\n\t\t\t\te = example_generator.next()\n\t\t\t\tyield e","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n examples.append(\n InputExample(\n guid=f\"{set_type}-{data['idx']}\",\n text_a=data[\"passage\"],\n text_b=data[\"question\"],\n label=str(data[\"label\"]),\n )\n )\n return examples","def translate_interactive(estimator, tokenizer_):\n \n predictor = ContinuePredict(estimator, continue_input_fn)\n while True:\n tf.logging.info(\"Enter the English sentence end with ENTER.\")\n raw_text = input().strip()\n if raw_text == r'\\q':\n predictor.close()\n break\n encoded_txt = _encode_and_add_eos(raw_text, tokenizer_)\n target = predictor.predict(encoded_txt)\n target = next(target)['outputs']\n target = _trim_and_decode(target, tokenizer_)\n tf.logging.info('\\t{}'.format(target))","def generate_tpu(self, prompts: List[str]):\n from flax.training.common_utils import shard # pylint:disable=g-import-not-at-top,g-importing-member\n import jax # pylint:disable=g-import-not-at-top\n import time # pylint:disable=g-import-not-at-top\n import numpy as np # pylint:disable=g-import-not-at-top\n\n rng = jax.random.PRNGKey(0)\n rng = jax.random.split(rng, jax.device_count())\n\n assert prompts, \"prompt parameter cannot be empty\"\n print(\"Prompts: \", prompts)\n prompt_ids = self._pipeline.prepare_inputs(prompts)\n prompt_ids = shard(prompt_ids)\n print(\"Sharded prompt ids has shape:\", prompt_ids.shape)\n if self._run_with_profiler:\n jax.profiler.start_trace(self._profiler_dir)\n\n time_start = time.time()\n images = self._p_generate(prompt_ids, self._p_params, rng)\n images = images.block_until_ready()\n elapsed = time.time() - time_start\n if self._run_with_profiler:\n jax.profiler.stop_trace()\n\n print(\"Inference time (in seconds): \", elapsed)\n print(\"Shape of the predictions: \", images.shape)\n images = images.reshape(\n (images.shape[0] * images.shape[1],) + images.shape[-3:])\n print(\"Shape of images afterwards: \", images.shape)\n return self._pipeline.numpy_to_pil(np.array(images))","def generate_text(session, model, config, starting_text='<eos>',\n stop_length=100, stop_tokens=None, temp=1.0):\n state = model.initial_state.eval()\n # Imagine tokens as a batch size of one, length of len(tokens[0])\n tokens = [model.vocab.encode(word) for word in starting_text.split()]\n for i in xrange(stop_length):\n ### YOUR CODE HERE\n #print tokens\n feed = {}\n #x = np.array([tokens[-1]])\n #x.reshape(1,1)\n feed[model.input_placeholder] = [[tokens[-1]]]\n feed[model.dropout_placeholder] = 1\n feed[model.initial_state] = state\n y_pred, state = session.run([model.predictions[-1], model.final_state], feed_dict=feed)\n ### END YOUR CODE\n next_word_idx = sample(y_pred[0], temperature=temp)\n tokens.append(next_word_idx)\n if stop_tokens and model.vocab.decode(tokens[-1]) in stop_tokens:\n break\n output = [model.vocab.decode(word_idx) for word_idx in tokens]\n return output","def batchify(TEXT, data, batch_size, device):\r\n data = TEXT.numericalize([data.examples[0].text])\r\n num_batches = data.size(0)//batch_size\r\n data = data.narrow(0, 0, num_batches * batch_size)\r\n data = data.view(batch_size, -1).t().contiguous()\r\n\r\n return data.to(device)","def convert_example(example,\n tokenizer,\n label_list,\n max_seq_length=512,\n is_test=False):\n\n def _truncate_seqs(seqs, max_seq_length):\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n tokens_a, tokens_b = seqs\n max_seq_length -= 3\n while True: # truncate with longest_first strategy\n total_length = len(tokens_a) + len(tokens_b)\n if total_length <= max_seq_length:\n break\n if len(tokens_a) > len(tokens_b):\n tokens_a.pop()\n else:\n tokens_b.pop()\n return seqs\n\n def _concat_seqs(seqs, separators, seq_mask=0, separator_mask=1):\n concat = sum((seq + sep for sep, seq in zip(separators, seqs)), [])\n segment_ids = sum(\n ([i] * (len(seq) + len(sep))\n for i, (sep, seq) in enumerate(zip(separators, seqs))), [])\n if isinstance(seq_mask, int):\n seq_mask = [[seq_mask] * len(seq) for seq in seqs]\n if isinstance(separator_mask, int):\n separator_mask = [[separator_mask] * len(sep) for sep in separators]\n p_mask = sum((s_mask + mask\n for sep, seq, s_mask, mask in zip(\n separators, seqs, seq_mask, separator_mask)), [])\n return concat, segment_ids, p_mask\n\n if not is_test:\n # `label_list == None` is for regression task\n label_dtype = \"int64\" if label_list else \"float32\"\n # get the label\n label = example[-2]\n example = example[:-2]\n #create label maps if classification task\n if label_list:\n label_map = {}\n for (i, l) in enumerate(label_list):\n label_map[l] = i\n label = label_map[label]\n label = np.array([label], dtype=label_dtype)\n else:\n qas_id = example[-1]\n example = example[:-2]\n # tokenize raw text\n tokens_raw = [tokenizer(l) for l in example]\n # truncate to the truncate_length,\n tokens_trun = _truncate_seqs(tokens_raw, max_seq_length)\n # concate the sequences with special tokens\n tokens_trun[0] = [tokenizer.cls_token] + tokens_trun[0]\n tokens, segment_ids, _ = _concat_seqs(tokens_trun, [[tokenizer.sep_token]] *\n len(tokens_trun))\n # convert the token to ids\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n valid_length = len(input_ids)\n\n if not is_test:\n return input_ids, segment_ids, valid_length, label\n else:\n return input_ids, segment_ids, valid_length, qas_id","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n if set_type != 'test':\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[3]\r\n text_b = line[4]\r\n label = line[5]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n else:\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n try:\r\n text_a = line[1]\r\n text_b = line[2]\r\n label = self.get_labels()[0]\r\n except IndexError:\r\n continue\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n\r\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[0]\n label = line[1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n guid = \"%s-%s\" % (set_type, i)\r\n if set_type != 'test':\r\n text_a = line[3]\r\n label = line[1]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n else:\r\n if i == 0:\r\n continue\r\n text_a = line[1]\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\r\n return examples","def query(self,text_input,prefix='answer:',convert_to_string=True):\n predictions, raw_outputs = self.model.predict([text_input])\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\n return self._post_process_output(preds,convert_to_string=convert_to_string)","def sample_to_features_text(\n sample, tasks, max_seq_len, tokenizer\n):\n\n if tokenizer.is_fast:\n text = sample.clear_text[\"text\"]\n # Here, we tokenize the sample for the second time to get all relevant ids\n # This should change once we git rid of FARM's tokenize_with_metadata()\n inputs = tokenizer(text,\n return_token_type_ids=True,\n truncation=True,\n truncation_strategy=\"longest_first\",\n max_length=max_seq_len,\n return_special_tokens_mask=True)\n\n if (len(inputs[\"input_ids\"]) - inputs[\"special_tokens_mask\"].count(1)) != len(sample.tokenized[\"tokens\"]):\n logger.error(f\"FastTokenizer encoded sample {sample.clear_text['text']} to \"\n f\"{len(inputs['input_ids']) - inputs['special_tokens_mask'].count(1)} tokens, which differs \"\n f\"from number of tokens produced in tokenize_with_metadata(). \\n\"\n f\"Further processing is likely to be wrong.\")\n else:\n # TODO It might be cleaner to adjust the data structure in sample.tokenized\n tokens_a = sample.tokenized[\"tokens\"]\n tokens_b = sample.tokenized.get(\"tokens_b\", None)\n\n inputs = tokenizer.encode_plus(\n tokens_a,\n tokens_b,\n add_special_tokens=True,\n truncation=False, # truncation_strategy is deprecated\n return_token_type_ids=True,\n is_split_into_words=False,\n )\n\n input_ids, segment_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n padding_mask = [1] * len(input_ids)\n\n # Padding up to the sequence length.\n # Normal case: adding multiple 0 to the right\n # Special cases:\n # a) xlnet pads on the left and uses \"4\" for padding token_type_ids\n if tokenizer.__class__.__name__ == \"XLNetTokenizer\":\n pad_on_left = True\n segment_ids = pad(segment_ids, max_seq_len, 4, pad_on_left=pad_on_left)\n else:\n pad_on_left = False\n segment_ids = pad(segment_ids, max_seq_len, 0, pad_on_left=pad_on_left)\n\n input_ids = pad(input_ids, max_seq_len, tokenizer.pad_token_id, pad_on_left=pad_on_left)\n padding_mask = pad(padding_mask, max_seq_len, 0, pad_on_left=pad_on_left)\n\n assert len(input_ids) == max_seq_len\n assert len(padding_mask) == max_seq_len\n assert len(segment_ids) == max_seq_len\n\n feat_dict = {\n \"input_ids\": input_ids,\n \"padding_mask\": padding_mask,\n \"segment_ids\": segment_ids,\n }\n\n # Add Labels for different tasks\n for task_name, task in tasks.items():\n try:\n label_name = task[\"label_name\"]\n label_raw = sample.clear_text[label_name]\n label_list = task[\"label_list\"]\n if task[\"task_type\"] == \"classification\":\n # id of label\n try:\n label_ids = [label_list.index(label_raw)]\n except ValueError as e:\n raise ValueError(f'[Task: {task_name}] Observed label {label_raw} not in defined label_list')\n elif task[\"task_type\"] == \"multilabel_classification\":\n # multi-hot-format\n label_ids = [0] * len(label_list)\n for l in label_raw.split(\",\"):\n if l != \"\":\n label_ids[label_list.index(l)] = 1\n elif task[\"task_type\"] == \"regression\":\n label_ids = [float(label_raw)]\n else:\n raise ValueError(task[\"task_type\"])\n except KeyError:\n # For inference mode we don't expect labels\n label_ids = None\n if label_ids is not None:\n feat_dict[task[\"label_tensor_name\"]] = label_ids\n return [feat_dict]","def tokenize_nmt(text, num_examples=None):\n source, target = [], []\n for i, line in enumerate(text.split('\\n')):\n if num_examples and i > num_examples:\n break\n parts = line.split('\\t')\n if len(parts) == 2:\n source.append(parts[0].split(' '))\n target.append(parts[1].split(' '))\n return source, target","def process(self, example: str) -> List[torch.Tensor]:\n return self._tokenizer.batch_encode_plus([example], return_tensors=\"pt\", output_past=True, max_length=self.max_seq_len)['input_ids'][0]","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def main():\n # Load and prep training files\n raw_speech_text = hg.load_training_file('trump_train.txt')\n speech_text = hg.prep_training(raw_speech_text)\n tweet_data = load_tweets('trump_tweets.json')\n raw_tweets = \"\"\n for dct in tweet_data:\n raw_tweets += \"{} \".format(dct['text'])\n tweets = hg.prep_training(raw_tweets)\n corpus = speech_text + tweets\n corpus = strip_punctuation(corpus)\n dict_1 = hg.map_one_to_one(corpus)\n dict_2 = hg.map_two_to_one(corpus)\n text = []\n \n # Introduction\n print(\"\\nTrump Speech Generator\\n\")\n print(\"Select words to add to speech\")\n print(\"\\'x\\' to exit\")\n print(\"\\'p\\' to add punctuation\")\n print(\"Select \\'p\\' before selecting the word you want to punctuate\")\n\n # Select first word\n options = corpus\n print ()\n selection = select_word(corpus)\n text.append(selection)\n \n # Select second word\n last = text[0]\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n # Select subsequent word\n while True:\n last = \"{} {}\".format(text[-2].strip(punctuation),\n text[-1].strip(punctuation))\n options = word_after_two(last, dict_2)\n if options == []:\n last = last.split()[1]\n options = word_after_one(last, dict_1)\n while options == []:\n last = random.choice(corpus)\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n print_text(text)","def _create_examples(self, lines, set_type):\n examples = []\n for idx, line in enumerate(lines):\n item = json.loads(line.strip())\n question_id = \"%s-%s\" % (set_type, idx)\n context = item[\"context\"]\n question = item[\"question\"]\n endings = [item[\"answerA\"],item[\"answerB\"],item[\"answerC\"] ]\n label = item[\"correct\"]\n #race_id = \"%s-%s\" % (set_type, data_raw[\"race_id\"])\n #article = data_raw[\"article\"]\n #for i in range(len(data_raw[\"answers\"])):\n #truth = str(ord(data_raw[\"answers\"][i]) - ord(\"A\"))\n #question = data_raw[\"questions\"][i]\n #options = data_raw[\"options\"][i]\n\n examples.append(\n InputExample(\n example_id=question_id,\n question=question,\n contexts=[context,context,context],\n endings=[endings[0], endings[1], endings[2]],#, options[3]\n label=label,\n )\n )\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n if i <= 3:\n print(\"i={}, line={}\".format(i, line))\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\r\n examples = []\r\n for (i, line) in enumerate(lines):\r\n if i == 0:\r\n continue\r\n guid = \"%s-%s\" % (set_type, line[0])\r\n text_a = line[1]\r\n text_b = line[2]\r\n if set_type != 'test_matched':\r\n label = line[-1]\r\n else:\r\n label = self.get_labels()[0]\r\n examples.append(\r\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\r\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (_, data) in enumerate(lines):\n passage = data[\"passage\"]\n ents_pos = [(pos[\"start\"], pos[\"end\"])\n for pos in passage[\"entities\"]]\n ents = [passage[\"text\"][start:end+1] for start, end in ents_pos]\n for qa in data[\"qas\"]:\n qa_id = f\"{set_type}-{data['idx']}-{qa['idx']}\"\n answers = set([ans[\"text\"] for ans in qa[\"answers\"]])\n for ent_idx, ent in enumerate(ents):\n is_answer = ent in answers\n guid = f\"{qa_id}-{ent_idx}\"\n examples.append(\n InputExample(\n guid=guid,\n text_a=passage[\"text\"],\n # Insert entity in query\n text_b=qa[\"query\"].replace(\"@placeholder\", ent),\n label=\"1\" if is_answer else \"0\",\n )\n )\n return examples","def run_prediction(question_texts, context_text):\r\n examples = []\r\n\r\n for i, question_text in enumerate(question_texts):\r\n example = SquadExample(\r\n qas_id=str(i),\r\n question_text=question_text,\r\n context_text=context_text,\r\n answer_text=None,\r\n start_position_character=None,\r\n title=\"Predict\",\r\n is_impossible=False,\r\n answers=None,\r\n )\r\n\r\n examples.append(example)\r\n\r\n features, dataset = squad_convert_examples_to_features(\r\n examples=examples,\r\n tokenizer=tokenizer,\r\n max_seq_length=384,\r\n doc_stride=128,\r\n max_query_length=64,\r\n is_training=False,\r\n return_dataset=\"pt\",\r\n threads=1,\r\n )\r\n\r\n eval_sampler = SequentialSampler(dataset)\r\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\r\n\r\n all_results = []\r\n\r\n for batch in eval_dataloader:\r\n model.eval()\r\n batch = tuple(t.to(device) for t in batch)\r\n\r\n with torch.no_grad():\r\n inputs = {\r\n \"input_ids\": batch[0],\r\n \"attention_mask\": batch[1],\r\n \"token_type_ids\": batch[2],\r\n }\r\n\r\n example_indices = batch[3]\r\n\r\n outputs = model(**inputs)\r\n\r\n for i, example_index in enumerate(example_indices):\r\n eval_feature = features[example_index.item()]\r\n unique_id = int(eval_feature.unique_id)\r\n\r\n output = [to_list(output[i]) for output in outputs]\r\n\r\n start_logits, end_logits = output\r\n result = SquadResult(unique_id, start_logits, end_logits)\r\n all_results.append(result)\r\n\r\n output_prediction_file = \"predictions.json\"\r\n output_nbest_file = \"nbest_predictions.json\"\r\n output_null_log_odds_file = \"null_predictions.json\"\r\n\r\n predictions = compute_predictions_logits(\r\n examples,\r\n features,\r\n all_results,\r\n n_best_size,\r\n max_answer_length,\r\n do_lower_case,\r\n output_prediction_file,\r\n output_nbest_file,\r\n output_null_log_odds_file,\r\n False, # verbose_logging\r\n True, # version_2_with_negative\r\n null_score_diff_threshold,\r\n tokenizer,\r\n )\r\n\r\n return predictions","def get_transformed_io(data_path, data_dir):\n sents, labels = read_line_examples_from_file(data_path)\n\n # the input is just the raw sentence\n inputs = [s.copy() for s in sents]\n\n task = 'asqp'\n if task == 'aste':\n targets = get_para_aste_targets(sents, labels)\n elif task == 'tasd':\n targets = get_para_tasd_targets(sents, labels)\n elif task == 'asqp':\n targets = get_para_asqp_targets(sents, labels)\n else:\n raise NotImplementedError\n\n return inputs, targets","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = line[-1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def _create_examples(self, lines, type):\n examples = []\n\n for i in range(0, len(lines), self.interval):\n text_a = lines[i]\n label = lines[i + 2]\n\n examples.append(\n InputExample(guid=len(examples), text_a=text_a, pos=None, label=label))\n return examples","def _create_examples(self, df, set_type):\n examples = []\n for i, row in df.iterrows():\n guid = \"%s-%s\" % (set_type, i)\n text_a = row[4]\n label = row[2]\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type, dom=-1):\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n if dom != -1:\n label = [label, str(dom)]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples","def _create_examples(self, lines, set_type):\n examples = []\n for (i, ids) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, ids )\n text_a = lines[ids]['term']\n text_b = lines[ids]['sentence']\n label = lines[ids]['polarity']\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n tokens_a = tokenizer.tokenize(example.text_a)\n\n tokens_b = None\n if example.text_b:\n tokens_b = tokenizer.tokenize(example.text_b)\n # Modifies `tokens_a` and `tokens_b` in place so that the total\n # length is less than the specified length.\n # Account for [CLS], [SEP], [SEP] with \"- 3\"\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\n else:\n # Account for [CLS] and [SEP] with \"- 2\"\n if len(tokens_a) > max_seq_length - 2:\n tokens_a = tokens_a[:(max_seq_length - 2)]\n\n # The convention in BERT is:\n # (a) For sequence pairs:\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\n # (b) For single sequences:\n # tokens: [CLS] the dog is hairy . [SEP]\n # type_ids: 0 0 0 0 0 0 0\n #\n # Where \"type_ids\" are used to indicate whether this is the first\n # sequence or the second sequence. The embedding vectors for `type=0` and\n # `type=1` were learned during pre-training and are added to the wordpiece\n # embedding vector (and position vector). This is not *strictly* necessary\n # since the [SEP] token unambigiously separates the sequences, but it makes\n # it easier for the model to learn the concept of sequences.\n #\n # For classification tasks, the first vector (corresponding to [CLS]) is\n # used as as the \"sentence vector\". Note that this only makes sense because\n # the entire model is fine-tuned.\n tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n segment_ids = [0] * len(tokens)\n\n if tokens_b:\n tokens += tokens_b + [\"[SEP]\"]\n segment_ids += [1] * (len(tokens_b) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n\n label_id = label_map[example.label]\n features.append(\n InputFeatures(input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n label_id=label_id))\n return features","def _create_examples(self, lines, set_type):\n examples = []\n for (i, line) in enumerate(lines):\n # Only the test set has a header\n if set_type == \"test\" and i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n if set_type == \"test\":\n text_a = tokenization.convert_to_unicode(line[1])\n label = \"0\"\n else:\n text_a = tokenization.convert_to_unicode(line[1])\n label = tokenization.convert_to_unicode(line[0])\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples"],"string":"[\n \"def batch_tokenize_fn(examples):\\n sources = examples[config.source_lang]\\n targets = examples[config.target_lang]\\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\\n\\n # setup the tokenizer for targets,\\n # huggingface expects the target tokenized ids to be stored in the labels field\\n with config.tokenizer.as_target_tokenizer():\\n labels = config.tokenizer(targets, max_length=config.max_target_length, truncation=True)\\n\\n model_inputs[\\\"labels\\\"] = labels[\\\"input_ids\\\"]\\n return model_inputs\",\n \"def create_InputExamples(self, data, labels):\\n examples = []\\n for (i, u_tips) in enumerate(data):\\n for text in u_tips:\\n examples.append(\\n run_classifier.InputExample(\\n guid=None,\\n text_a=text,\\n text_b=None,\\n label=np.argmax(labels[i])\\n )\\n )\\n return examples\",\n \"def create_examples(topics, sentences):\\n input_examples = []\\n \\n for i in range(len(sentences)):\\n input_examples.append(InputExample(text_a=topics[i], text_b=sentences[i], label='NoArgument'))\\n return input_examples\",\n \"def read_examples_string(input_text):#(input_file, input_text):\\n examples = []\\n unique_id = 0\\n \\n with io.StringIO(input_text) as reader:\\n while True:\\n line = tokenization.convert_to_unicode(reader.readline())\\n if not line:\\n break\\n\\n line = line.strip()\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", line)\\n\\n if m is None:\\n text_a = line\\n else:\\n text_a = m.group(1)\\n text_b = m.group(2)\\n\\n examples.append(InputExample(unique_id=unique_id,\\n text_a=text_a, \\n text_b=text_b))\\n unique_id += 1\\n return examples\",\n \"def test_text_task(self):\\n args = BASE_ARGS.copy()\\n args.update(TEXT_ARGS)\\n valid, test = testing_utils.train_model(args)\\n self.assertLessEqual(\\n valid['ppl'], 1.5, 'failed to train image_seq2seq on text task'\\n )\",\n \"def batchify(self, observations):\\n # valid examples\\n exs = [ex for ex in observations if 'text' in ex]\\n # the indices of the valid (non-empty) tensors\\n valid_inds = [i for i, ex in enumerate(observations) if 'text' in ex]\\n\\n # set up the input tensors\\n batchsize = len(exs)\\n if batchsize == 0:\\n return None, None, None\\n # tokenize the text\\n parsed_x = [deque(maxlen=self.truncate) for _ in exs]\\n for dq, ex in zip(parsed_x, exs):\\n dq += self.parse(ex['text'])\\n # parsed = [self.parse(ex['text']) for ex in exs]\\n max_x_len = max((len(x) for x in parsed_x))\\n for x in parsed_x:\\n # left pad with zeros\\n x.extendleft([self.fairseq_dict.pad()] * (max_x_len - len(x)))\\n xs = torch.LongTensor(parsed_x)\\n\\n # set up the target tensors\\n ys = None\\n if 'labels' in exs[0]:\\n # randomly select one of the labels to update on, if multiple\\n labels = [random.choice(ex.get('labels', [''])) for ex in exs]\\n parsed_y = [deque(maxlen=self.truncate) for _ in labels]\\n for dq, y in zip(parsed_y, labels):\\n dq.extendleft(reversed(self.parse(y)))\\n for y in parsed_y:\\n y.append(self.fairseq_dict.eos())\\n # append EOS to each label\\n max_y_len = max(len(y) for y in parsed_y)\\n for y in parsed_y:\\n y += [self.fairseq_dict.pad()] * (max_y_len - len(y))\\n ys = torch.LongTensor(parsed_y)\\n return xs, ys, valid_inds\",\n \"def args_batch_to_text(args_batch: ArgsBatch) -> Text:\\n lines = []\\n for args in args_batch:\\n lines.append('; '.join(str(a) for a in args))\\n return '\\\\n'.join(lines)\",\n \"def _create_examples(self, lines, kb_data, set_type):\\n examples = []\\n for idx, line in enumerate(lines):\\n item = json.loads(line.strip())\\n question_id = \\\"%s-%s\\\" % (set_type, idx)\\n \\n context_a_list = kb_data[idx]['answerA']\\n context_b_list = kb_data[idx]['answerB']\\n context_c_list = kb_data[idx]['answerC']\\n\\n context_a = \\\"\\\"\\n for l in context_a_list[:1]:\\n context_a += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_a = context_a[:-1]\\n\\n context_b = \\\"\\\"\\n for l in context_b_list[:1]:\\n context_b += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_b = context_b[:-1]\\n\\n context_c = \\\"\\\"\\n for l in context_c_list[:1]:\\n context_c += l.replace(\\\"\\\\n\\\",\\\". \\\")\\n context_c = context_c[:-1]\\n \\n \\n question = item[\\\"context\\\"] + item[\\\"question\\\"]\\n endings = [item[\\\"answerA\\\"],item[\\\"answerB\\\"],item[\\\"answerC\\\"] ]\\n label = item[\\\"correct\\\"]\\n #race_id = \\\"%s-%s\\\" % (set_type, data_raw[\\\"race_id\\\"])\\n #article = data_raw[\\\"article\\\"]\\n #for i in range(len(data_raw[\\\"answers\\\"])):\\n #truth = str(ord(data_raw[\\\"answers\\\"][i]) - ord(\\\"A\\\"))\\n #question = data_raw[\\\"questions\\\"][i]\\n #options = data_raw[\\\"options\\\"][i]\\n\\n examples.append(\\n InputExample(\\n example_id=question_id,\\n question=question,\\n contexts=[context_a,context_b,context_c],\\n endings=[endings[0], endings[1], endings[2]],#, options[3]\\n label=label,\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines):\\n examples = []\\n for (i, line) in enumerate(lines):\\n logger.info(line)\\n guid = int(line[0])\\n label = int(line[1])\\n text = \\\" \\\".join(clean_tokens(line[3].split()))\\n if guid < 1000:\\n args_char_offset = find_char_offsets(text, line[2].split(\\\"-\\\"))\\n else:\\n args_char_offset = [int(i) for i in line[2].split('-')]\\n examples.append(\\n InputExample(guid=guid, text=text, args_char_offset=args_char_offset, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = line[0]\\n text_a = line[1] + \\\" . \\\" + line[2]\\n text_b = line[-1]\\n label = 0\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(self):\\n features = []\\n max_label_len = 0\\n # find ou the max label length\\n labels_list = []\\n for ex_index, example in enumerate(self.examples):\\n processor = example.processor\\n label_ids = self.tokenizer.text_to_ids(processor.label2string(example.label)) + [self.tokenizer.eos_id]\\n max_label_len = max(len(label_ids), max_label_len)\\n labels_list.append(label_ids)\\n if self.max_seq_length_decoder is None:\\n self.max_seq_length_decoder = max_label_len\\n else:\\n self.max_seq_length_decoder = max(\\n self.max_seq_length_decoder, max_label_len\\n ) # take the max of the two to be conservative\\n for ex_index, example in enumerate(self.examples):\\n taskname = example.taskname\\n taskname_ids = self.tokenizer.text_to_ids(taskname)\\n processor = example.processor\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n label_ids = labels_list[ex_index]\\n enc_query = processor.get_ptune_query(\\n example.content,\\n self.pseudo_token_id,\\n self.max_seq_length - self.max_seq_length_decoder + 1,\\n self.templates,\\n self.tokenizer,\\n )\\n input_ids = enc_query + label_ids[:-1]\\n labels = [SMALL_NUM for i in range(len(enc_query) - 1)] + label_ids\\n features.append([input_ids, labels, enc_query, taskname_ids])\\n return features\",\n \"def qkgnn_convert_examples_to_features(\\r\\n examples,\\r\\n tokenizer,\\r\\n max_length=512,\\r\\n task=None,\\r\\n label_list=None,\\r\\n output_mode=None,\\r\\n pad_on_left=False,\\r\\n pad_token=0,\\r\\n pad_token_segment_id=0,\\r\\n mask_padding_with_zero=True,\\r\\n):\\r\\n\\r\\n if task is not None:\\r\\n processor = gnn_processors[task]()\\r\\n if label_list is None:\\r\\n label_list = processor.get_labels()\\r\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\r\\n if output_mode is None:\\r\\n output_mode = gnn_output_modes[task]\\r\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\r\\n label_map = {label: i for i, label in enumerate(label_list)}\\r\\n\\r\\n\\r\\n # TODO : optimize this part if out of memory error occurs\\r\\n def convert_inputs_to_processed(inputs):\\r\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\r\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\r\\n # tokens are attended to.\\r\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\r\\n\\r\\n # Zero-pad up to the sequence length.\\r\\n padding_length = max_length - len(input_ids)\\r\\n if pad_on_left:\\r\\n input_ids = ([pad_token] * padding_length) + input_ids\\r\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\r\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\r\\n else:\\r\\n input_ids = input_ids + ([pad_token] * padding_length)\\r\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\r\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\r\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\r\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\r\\n len(attention_mask), max_length\\r\\n )\\r\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\r\\n len(token_type_ids), max_length\\r\\n )\\r\\n\\r\\n return input_ids, attention_mask, token_type_ids\\r\\n\\r\\n # TODO : optimize this part if out of memory error occurs\\r\\n def qkgnn_convert_single_exampl_to_feature(example, ex_index=10):\\r\\n inputs_q = tokenizer.encode_plus(example.text_a, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_k = tokenizer.encode_plus(example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk1 = tokenizer.encode_plus(example.text_a, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk2 = tokenizer.encode_plus(example.text_a, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qk3 = tokenizer.encode_plus(example.text_a, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq1 = tokenizer.encode_plus(example.text_b, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq2 = tokenizer.encode_plus(example.text_b, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kq3 = tokenizer.encode_plus(example.text_b, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk1 = tokenizer.encode_plus(example.text_b, example.k1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk2 = tokenizer.encode_plus(example.text_b, example.k2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_kk3 = tokenizer.encode_plus(example.text_b, example.k3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq1 = tokenizer.encode_plus(example.text_a, example.q1, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq2 = tokenizer.encode_plus(example.text_a, example.q2, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n inputs_qq3 = tokenizer.encode_plus(example.text_a, example.q3, add_special_tokens=True, max_length=max_length, truncation=True)\\r\\n # generate [input_ids, input_mask, segment_ids]\\r\\n # for q self\\r\\n input_ids_q, input_mask_q, segment_ids_q = convert_inputs_to_processed(inputs_q)\\r\\n # for k self\\r\\n input_ids_k, input_mask_k, segment_ids_k = convert_inputs_to_processed(inputs_k)\\r\\n # for qk\\r\\n input_ids_qk, input_mask_qk, segment_ids_qk = convert_inputs_to_processed(inputs_qk)\\r\\n # for qk1\\r\\n input_ids_qk1, input_mask_qk1, segment_ids_qk1 = convert_inputs_to_processed(inputs_qk1)\\r\\n # for qk2\\r\\n input_ids_qk2, input_mask_qk2, segment_ids_qk2 = convert_inputs_to_processed(inputs_qk2)\\r\\n # for qk3\\r\\n input_ids_qk3, input_mask_qk3, segment_ids_qk3 = convert_inputs_to_processed(inputs_qk3)\\r\\n # for kq1\\r\\n input_ids_kq1, input_mask_kq1, segment_ids_kq1 = convert_inputs_to_processed(inputs_kq1)\\r\\n # for kq2\\r\\n input_ids_kq2, input_mask_kq2, segment_ids_kq2 = convert_inputs_to_processed(inputs_kq2)\\r\\n # for kq3\\r\\n input_ids_kq3, input_mask_kq3, segment_ids_kq3 = convert_inputs_to_processed(inputs_kq3)\\r\\n # for kk1\\r\\n input_ids_kk1, input_mask_kk1, segment_ids_kk1 = convert_inputs_to_processed(inputs_kk1)\\r\\n # for kk2\\r\\n input_ids_kk2, input_mask_kk2, segment_ids_kk2 = convert_inputs_to_processed(inputs_kk2)\\r\\n # for kk3\\r\\n input_ids_kk3, input_mask_kk3, segment_ids_kk3 = convert_inputs_to_processed(inputs_kk3)\\r\\n # for qq1\\r\\n input_ids_qq1, input_mask_qq1, segment_ids_qq1 = convert_inputs_to_processed(inputs_qq1)\\r\\n # for qq2\\r\\n input_ids_qq2, input_mask_qq2, segment_ids_qq2 = convert_inputs_to_processed(inputs_qq2)\\r\\n # for qq3\\r\\n input_ids_qq3, input_mask_qq3, segment_ids_qq3 = convert_inputs_to_processed(inputs_qq3)\\r\\n\\r\\n # generate label\\r\\n if output_mode == \\\"classification\\\" or output_mode == \\\"classification2\\\":\\r\\n label = label_map[example.label]\\r\\n elif output_mode == \\\"regression\\\":\\r\\n label = float(example.label)\\r\\n else:\\r\\n raise KeyError(output_mode)\\r\\n\\r\\n # log info\\r\\n if ex_index < 5:\\r\\n logger.info(\\\"*** Example ***\\\")\\r\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\r\\n logger.info(\\\"text_a: %s\\\" % (example.text_a))\\r\\n logger.info(\\\"text_b: %s\\\" % (example.text_b))\\r\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_qk]))\\r\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_qk]))\\r\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids_qk]))\\r\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label))\\r\\n # generate the feature for single example\\r\\n feature = InputFeatures_GNN(\\r\\n input_ids_q=input_ids_q,\\r\\n input_mask_q=input_mask_q,\\r\\n segment_ids_q=segment_ids_q,\\r\\n\\r\\n input_ids_k=input_ids_k,\\r\\n input_mask_k=input_mask_k,\\r\\n segment_ids_k=segment_ids_k,\\r\\n\\r\\n input_ids_qk=input_ids_qk,\\r\\n input_mask_qk=input_mask_qk,\\r\\n segment_ids_qk=segment_ids_qk,\\r\\n\\r\\n input_ids_qk1=input_ids_qk1,\\r\\n input_mask_qk1=input_mask_qk1,\\r\\n segment_ids_qk1=segment_ids_qk1,\\r\\n input_ids_qk2=input_ids_qk2,\\r\\n input_mask_qk2=input_mask_qk2,\\r\\n segment_ids_qk2=segment_ids_qk2,\\r\\n input_ids_qk3=input_ids_qk3,\\r\\n input_mask_qk3=input_mask_qk3,\\r\\n segment_ids_qk3=segment_ids_qk3,\\r\\n\\r\\n input_ids_kq1=input_ids_kq1,\\r\\n input_mask_kq1=input_mask_kq1,\\r\\n segment_ids_kq1=segment_ids_kq1,\\r\\n input_ids_kq2=input_ids_kq2,\\r\\n input_mask_kq2=input_mask_kq2,\\r\\n segment_ids_kq2=segment_ids_kq2,\\r\\n input_ids_kq3=input_ids_kq3,\\r\\n input_mask_kq3=input_mask_kq3,\\r\\n segment_ids_kq3=segment_ids_kq3,\\r\\n\\r\\n input_ids_qq1=input_ids_qq1,\\r\\n input_mask_qq1=input_mask_qq1,\\r\\n segment_ids_qq1=segment_ids_qq1,\\r\\n input_ids_qq2=input_ids_qq2,\\r\\n input_mask_qq2=input_mask_qq2,\\r\\n segment_ids_qq2=segment_ids_qq2,\\r\\n input_ids_qq3=input_ids_qq3,\\r\\n input_mask_qq3=input_mask_qq3,\\r\\n segment_ids_qq3=segment_ids_qq3,\\r\\n\\r\\n input_ids_kk1=input_ids_kk1,\\r\\n input_mask_kk1=input_mask_kk1,\\r\\n segment_ids_kk1=segment_ids_kk1,\\r\\n input_ids_kk2=input_ids_kk2,\\r\\n input_mask_kk2=input_mask_kk2,\\r\\n segment_ids_kk2=segment_ids_kk2,\\r\\n input_ids_kk3=input_ids_kk3,\\r\\n input_mask_kk3=input_mask_kk3,\\r\\n segment_ids_kk3=segment_ids_kk3,\\r\\n\\r\\n row_id=int(example.guid),\\r\\n label_id=label,\\r\\n task_id=task,\\r\\n is_real_example=True)\\r\\n return feature\\r\\n\\r\\n features = []\\r\\n for (ex_index, example) in tqdm(enumerate(examples)):\\r\\n features.append(qkgnn_convert_single_exampl_to_feature(example, ex_index=ex_index))\\r\\n\\r\\n return features\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n examples = []\\n text_index = 1 if mode == Split.test else 0\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, i)\\n text_a = line[text_index]\\n if len(line) > text_index + 1:\\n label = line[text_index + 1]\\n else:\\n label = None\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self,lines, set_type):\\n examples = []\\n if len(lines[1]) == 2 and len(lines[1][0]) == 1: # label text_a\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n\\n elif len(lines[1]) == 2 and len(lines[1][0]) > 1: # text_a text_b (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n text_b = tx.utils.compat_as_text(line[1])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n elif len(lines[1]) == 1: # text_a (when test file has no label)\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[0])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n print(\\\"the file is not for testing, yet contains no labels\\\")\\n exit()\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=\\\"\\\", label=label))\\n elif len(lines[1]) == 3: # label text_a text_b\\n for (i, line) in enumerate(lines):\\n guid = f\\\"{set_type}-{i}\\\"\\n text_a = tx.utils.compat_as_text(line[1])\\n text_b = tx.utils.compat_as_text(line[2])\\n\\n label = tx.utils.compat_as_text(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a,\\n text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(self):\\n features = []\\n for ex_index, example in enumerate(self.examples):\\n if ex_index % 10000 == 0:\\n logging.info(f\\\"Writing example {ex_index} of {len(self.examples)}\\\")\\n\\n text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)\\n enc_query = self.tokenizer.text_to_ids(text_to_text_query)\\n if len(enc_query) > self.max_seq_length:\\n enc_query = enc_query[: self.max_seq_length]\\n dec_query = (\\n [self.tokenizer.bos_id]\\n + self.tokenizer.text_to_ids(self.processor.label2string(example.label))\\n + [self.tokenizer.eos_id]\\n )\\n\\n dec_input = dec_query[:-1]\\n labels = dec_query[1:]\\n\\n features.append([enc_query, dec_input, labels])\\n\\n return features\",\n \"def create_examples(lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, str(i))\\n text_a_id = line[0]\\n text_a = tokenization.convert_to_unicode(line[1])\\n text_b_id = line[2]\\n text_b = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(InputExample(guid=guid, text_a_id=text_a_id, text_a=text_a, text_b_id=text_b_id, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[0])\\n text_b = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n # id,title,content,label\\n test_mode = mode == Split.test\\n title_index = 1\\n content_index = 2\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[title_index]\\n text_b = line[content_index]\\n if test_mode:\\n label = None\\n else:\\n label = line[3]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n text_b = tokenization.convert_to_unicode(line[2])\\n label = tokenization.convert_to_unicode(line[3])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n test_mode = mode == Split.test\\n q1_index = 1 if test_mode else 3\\n q2_index = 2 if test_mode else 4\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[q1_index]\\n text_b = line[q2_index]\\n label = None if test_mode else line[5]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\\n\\n unique_id = 1000000000\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\\n\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if max_query_length is None:\\n max_query_length = len(query_tokens)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n for _ in enumerate(range(1)):\\n tokens_ = []\\n tokens_.append(\\\"[CLS]\\\")\\n for token in query_tokens:\\n tokens_.append(token)\\n tokens_.append(\\\"[SEP]\\\")\\n\\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids_) < max_query_length + 2:\\n input_ids_.append(0)\\n input_mask_.append(0)\\n\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n if example_index < 1:\\n # logger.info(\\\"*** Example ***\\\")\\n # logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n # logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in query_tokens]))\\n # logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_]))\\n # logger.info(\\n # \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_]))\\n\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n unique_id += 1\\n\\n return question_features\",\n \"def _create_examples(self, lines, set_type):\\n test_mode = set_type == \\\"test\\\"\\n if test_mode:\\n lines = lines[1:]\\n text_index = 1 if test_mode else 3\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[text_index]\\n label = None if test_mode else line[1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[2])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n label = tokenization.convert_to_unicode(line[1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, tokenization.convert_to_unicode(line[0]))\\n text_a = tokenization.convert_to_unicode(line[8])\\n text_b = tokenization.convert_to_unicode(line[9])\\n if set_type == \\\"test\\\":\\n label = \\\"contradiction\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[-1])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for i, line in lines.iterrows():\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line['sentence1']\\n text_b = line['sentence2']\\n label = line['label']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def print_examples(example_iter, model, num=0, max_len=100,\\n bos_index=1,\\n src_eos_index = None,\\n trg_eos_index = None,\\n src_vocab=None, trg_vocab=None):\\n model.eval()\\n count=0\\n\\n BOS_TOKEN = \\\"<s>\\\"\\n EOS_TOKEN = \\\"</s>\\\"\\n UNK_TOKEN = \\\"<unk>\\\"\\n\\n if src_vocab is not None and trg_vocab is not None:\\n src_bos_index = src_vocab.stoi[BOS_TOKEN]\\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\\n trg_unk_index = trg_vocab.stoi[UNK_TOKEN]\\n # trg_bos_index = trg_vocab.stoi[BOS_TOKEN]\\n # trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\\n else:\\n src_bos_index = 0\\n src_eos_index = 1\\n trg_unk_index = 2\\n # trg_bos_index = 1\\n # trg_eos_index = None\\n\\n for i, batch in enumerate(example_iter, 1):\\n src = batch.src.cpu().numpy()[0, :]\\n trg_idx = batch.trg_idx.cpu().numpy()[0, :]\\n\\n # remove </s>\\n src = src[1:] if src[0]==src_bos_index else src\\n src = src[:-1] if src[-1]==src_eos_index else src\\n # trg = trg[:-1] if trg[-1]==trg_eos_index else trg\\n\\n result = greedy_decode(model, batch.src_idx, batch.src_mask, batch.src_lengths)\\n print()\\n print(\\\"Example %d\\\" % i)\\n print(\\\"Source: \\\", \\\" \\\".join(lookup_words(src, vocab=src_vocab)))\\n print()\\n print(\\\"Target: \\\", set(lookup_words(trg_idx, vocab=trg_vocab)))\\n print()\\n print(\\\"Prediction: \\\", \\\" \\\".join(lookup_words(result[0], vocab=trg_vocab)))\\n\\n count += 1\\n if count == num:\\n break\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[8]\\n text_b = line[9]\\n label = line[-1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, max_seq_length, tokenizer):\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n print(example.text_a)\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n input_mask = [1] * len(input_ids)\\n\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n \\n labels_ids = []\\n for label in example.labels:\\n labels_ids.append(int(label))\\n \\n if ex_index < 0:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %s)\\\" % (example.labels, labels_ids))\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=labels_ids))\\n return features\",\n \"def _create_examples(self, data, set_type):\\n examples = []\\n for (i, elem) in enumerate(data):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text = elem[0]\\n label = elem[1]\\n examples.append(\\n InputExample(guid=guid, text=text, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n try:\\n text_a = line[3]\\n text_b = line[4]\\n label = line[5]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def generate_text(pmodel, num_generate, temperature, start_string):\\n\\n # Converting the start string to numbers (vectorizing)\\n input_eval = [char2idx[s] for s in start_string]\\n input_eval = tf.expand_dims(input_eval, 0)\\n\\n # Empty string to store the results\\n text_generated = np.empty(1)\\n\\n # Here batch size = 1\\n pmodel.reset_states()\\n for i in range(num_generate):\\n \\n predictions = pmodel(input_eval)\\n \\n # remove the batch dimension\\n predictions = tf.squeeze(predictions, 0)\\n \\n # using a multinomial distribution to predict the word returned by the model\\n predictions = predictions / temperature\\n predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\\n \\n # We pass the predicted word as the next input to the model\\n # along with the previous hidden state\\n input_eval = tf.expand_dims([predicted_id], 0)\\n \\n text_generated = np.vstack((text_generated, idx2char[predicted_id].tolist()))\\n \\n return text_generated\",\n \"def convert_examples_to_features(\\n examples: List[InputExample],\\n label_list: List[str],\\n max_length: int,\\n tokenizer: PreTrainedTokenizer,\\n pad_token_segment_id=0,\\n pad_on_left=False,\\n pad_token=0,\\n mask_padding_with_zero=True,\\n) -> List[InputFeatures]:\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in tqdm.tqdm(enumerate(examples), desc=\\\"convert examples to features\\\"):\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\n choices_features = []\\n for ending_idx, (context, ending) in enumerate(zip(example.contexts, example.endings)):\\n text_a = context\\n if example.question.find(\\\"_\\\") != -1:\\n # this is for cloze question\\n text_b = example.question.replace(\\\"_\\\", ending)\\n else:\\n text_b = example.question + \\\" \\\" + ending\\n if len(text_a) == 0:\\n logger.info(\\\"context of example %d have length 0\\\" % (ex_index))\\n text_a = \\\" \\\"\\n\\n inputs = tokenizer.encode_plus(text_a, text_b, add_special_tokens=True, max_length=max_length,)\\n if \\\"num_truncated_tokens\\\" in inputs and inputs[\\\"num_truncated_tokens\\\"] > 0:\\n logger.info(\\n \\\"Attention! you are cropping tokens (swag task is ok). \\\"\\n \\\"If you are training ARC and RACE and you are poping question + options,\\\"\\n \\\"you need to try to use a bigger max seq length!\\\"\\n )\\n\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length\\n assert len(attention_mask) == max_length\\n assert len(token_type_ids) == max_length\\n choices_features.append((input_ids, attention_mask, token_type_ids))\\n\\n label = label_map[example.label]\\n\\n if ex_index < 2:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"race_id: {}\\\".format(example.example_id))\\n for choice_idx, (input_ids, attention_mask, token_type_ids) in enumerate(choices_features):\\n logger.info(\\\"choice: {}\\\".format(choice_idx))\\n logger.info(\\\"input_ids: {}\\\".format(\\\" \\\".join(map(str, input_ids))))\\n logger.info(\\\"attention_mask: {}\\\".format(\\\" \\\".join(map(str, attention_mask))))\\n logger.info(\\\"token_type_ids: {}\\\".format(\\\" \\\".join(map(str, token_type_ids))))\\n logger.info(\\\"label: {}\\\".format(label))\\n\\n features.append(InputFeatures(example_id=example.example_id, choices_features=choices_features, label=label,))\\n\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for i, line in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[5]\\n text_b = line[6]\\n pairID = line[7][2:] if line[7].startswith(\\\"ex\\\") else line[7]\\n label = line[0]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label, pairID=pairID))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n text_b = line[4]\\n label = line[0]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1] if set_type != \\\"test\\\" else \\\"entailment\\\"\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n # label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n exindex = {}\\n passagelens = []\\n\\n sum_of_labels = 0\\n\\n for (ex_index, example) in tqdm(enumerate(examples), desc=\\\"Tokenizing:\\\"):\\n if example.text_a not in tokenmap.keys():\\n tokens_a = tokenizer.tokenize(example.text_a)\\n tokenmap[example.text_a] = tokens_a\\n else:\\n tokens_a = tokenmap[example.text_a]\\n\\n tokens_b = None\\n if example.text_b:\\n if example.text_b not in tokenmap.keys():\\n tokens_b = tokenizer.tokenize(example.text_b)\\n tokenmap[example.text_b] = tokens_b\\n else:\\n tokens_b = tokenmap[example.text_b]\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n\\n passagelens.append(len(tokens_a) + len(tokens_b) + 3)\\n\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n # label_id = label_map[example.label]\\n label_id = example.label\\n\\n sum_of_labels += label_id\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [str(x) for x in tokens]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n logger.info(\\n \\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (str(example.label), 0))\\n\\n exindex[ex_index] = example.guid\\n features.append(\\n InputFeatures(uuid=ex_index,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n\\n print(\\\"Passage Token Lengths Distribution\\\", passagelens[-1], np.percentile(passagelens, 50),\\n np.percentile(passagelens, 90), np.percentile(passagelens, 95), np.percentile(passagelens, 99))\\n return features, exindex\",\n \"def convert_examples_to_features(\\n examples,\\n tokenizer,\\n max_length=512,\\n task=None,\\n label_list=None,\\n output_mode=None,\\n pad_on_left=False,\\n pad_token=0,\\n pad_token_segment_id=0,\\n mask_padding_with_zero=True,\\n multilabel=False,\\n):\\n\\n if task is not None:\\n processor = glue_processors[task]()\\n if label_list is None:\\n label_list = processor.get_labels()\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\n if output_mode is None:\\n output_mode = glue_output_modes[task]\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n if multilabel:\\n domain_label_map = {label: i for i, label in enumerate([\\\"0\\\", \\\"1\\\"])}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n len_examples = len(examples)\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d/%d\\\" % (ex_index, len_examples))\\n\\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length, )\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(attention_mask), max_length\\n )\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(token_type_ids), max_length\\n )\\n\\n if output_mode == \\\"classification\\\":\\n label = label_map[example.label] if not multilabel else label_map[example.label[0]]\\n elif output_mode == \\\"regression\\\":\\n label = float(example.label) if not multilabel else float(example.label[0])\\n else:\\n raise KeyError(output_mode)\\n if multilabel:\\n label = [label, domain_label_map[example.label[1]]]\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in attention_mask]))\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in token_type_ids]))\\n if multilabel:\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label[0], label[0]))\\n logger.info(\\\"domain label: %s (id = %d)\\\" % (example.label[1], label[1]))\\n else:\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label))\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\\n )\\n )\\n\\n return features\",\n \"def glue_convert_examples_to_features(\\n examples,\\n tokenizer,\\n max_length=512,\\n task=None,\\n label_list=None,\\n output_mode=None,\\n pad_on_left=False,\\n pad_token=0,\\n pad_token_segment_id=0,\\n mask_padding_with_zero=True,\\n):\\n is_tf_dataset = False\\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\\n is_tf_dataset = True\\n\\n if task is not None:\\n processor = glue_processors[task]()\\n if label_list is None:\\n label_list = processor.get_labels()\\n logger.info(\\\"Using label list %s for task %s\\\" % (label_list, task))\\n if output_mode is None:\\n output_mode = glue_output_modes[task]\\n logger.info(\\\"Using output mode %s for task %s\\\" % (output_mode, task))\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n len_examples = 0\\n if is_tf_dataset:\\n example = processor.get_example_from_tensor_dict(example)\\n example = processor.tfds_map(example)\\n len_examples = tf.data.experimental.cardinality(examples)\\n else:\\n len_examples = len(examples)\\n if ex_index % 10000 == 0:\\n logger.info(\\\"Writing example %d/%d\\\" % (ex_index, len_examples))\\n\\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\\n input_ids, token_type_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding_length = max_length - len(input_ids)\\n if pad_on_left:\\n input_ids = ([pad_token] * padding_length) + input_ids\\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\\n else:\\n input_ids = input_ids + ([pad_token] * padding_length)\\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\\n\\n assert len(input_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(len(input_ids), max_length)\\n assert len(attention_mask) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(attention_mask), max_length\\n )\\n assert len(token_type_ids) == max_length, \\\"Error with input length {} vs {}\\\".format(\\n len(token_type_ids), max_length\\n )\\n\\n if output_mode == \\\"classification\\\":\\n label_id = label_map[example.label]\\n elif output_mode == \\\"regression\\\":\\n label_id = float(example.label)\\n else:\\n raise KeyError(output_mode)\\n\\n if ex_index < 5:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"guid: %s\\\" % (example.guid))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\\"attention_mask: %s\\\" % \\\" \\\".join([str(x) for x in attention_mask]))\\n logger.info(\\\"token_type_ids: %s\\\" % \\\" \\\".join([str(x) for x in token_type_ids]))\\n logger.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\n\\n features.append(\\n InputFeatures(\\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label_id=label_id\\n )\\n )\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n text_a = lines[ids]['sentence']\\n examples.append(\\n InputExample(text_a=text_a) )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # if i == 0:\\n # continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[1]\\n text_b = None\\n label = line[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # if i == 0:\\n # continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[1]\\n text_b = None\\n label = line[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n# if set_type == 'test':\\r\\n# label = self.get_labels()[0]\\r\\n# else:\\r\\n# label = line[0]\\r\\n label = line[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[7]\\n text_b = line[8]\\n label = None if set_type == \\\"test\\\" else line[-1]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[0]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0]) if set_type != \\\"test\\\" else line[0]\\n try:\\n text_a = line[3] if set_type != \\\"test\\\" else line[1]\\n text_b = line[4] if set_type != \\\"test\\\" else line[2]\\n label = line[5] if set_type != \\\"test\\\" else \\\"0\\\"\\n except IndexError:\\n continue\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = tokenization.convert_to_unicode(line[3])\\n text_b = tokenization.convert_to_unicode(line[4])\\n if set_type == \\\"test\\\":\\n label = \\\"0\\\"\\n else:\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label : i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens = example.text\\n\\n# # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n# if len(tokens) > max_seq_length - 2:\\n# tokens = tokens[:(max_seq_length - 2)]\\n\\n bert_tokens = []\\n orig_to_tok_map = []\\n\\n bert_tokens.append(\\\"[CLS]\\\")\\n for token in tokens:\\n new_tokens = tokenizer.tokenize(token)\\n if len(bert_tokens) + len(new_tokens) > max_seq_length - 1:\\n # print(\\\"You shouldn't see this since the test set is already pre-separated.\\\")\\n break\\n else:\\n orig_to_tok_map.append(len(bert_tokens))\\n bert_tokens.extend(new_tokens)\\n bert_tokens.append(\\\"[SEP]\\\")\\n\\n if len(bert_tokens) == 2: # edge case\\n continue\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n\\n input_ids = tokenizer.convert_tokens_to_ids(bert_tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n\\n segment_ids = [0] * max_seq_length # no use for our problem\\n\\n labels = example.label\\n label_ids = [0] * max_seq_length\\n label_mask = [0] * max_seq_length\\n\\n for label, target_index in zip(labels, orig_to_tok_map):\\n label_ids[target_index] = label_map[label]\\n label_mask[target_index] = 1\\n\\n assert len(segment_ids) == max_seq_length\\n assert len(label_ids) == max_seq_length\\n assert len(label_mask) == max_seq_length\\n\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_ids=label_ids,\\n label_mask=label_mask))\\n return features\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n label = line[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[3]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[8]\\r\\n text_b = line[9]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[7]\\r\\n text_b = line[8]\\r\\n label = line[-1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def read_examples(input_file):\\n examples = []\\n unique_id = 0\\n with tf.gfile.GFile(input_file, \\\"r\\\") as reader:\\n while True:\\n line = tokenization.convert_to_unicode(reader.readline())\\n if not line:\\n break\\n \\n line = line.strip()\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", line)\\n \\n if m is None:\\n text_a = line\\n else:\\n text_a = m.group(1)\\n text_b = m.group(2)\\n examples.append(InputExample(unique_id=unique_id,\\n text_a=text_a, \\n text_b=text_b))\\n unique_id += 1\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[0]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n text_a = line[1]\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n\\r\\n return examples\",\n \"def convert_examples_to_features(examples,label_list, max_seq_length,tokenizer):\\r\\n label_map = {}\\r\\n for (i, label) in enumerate(label_list):\\r\\n label_map[label] = i\\r\\n\\r\\n input_data=[]\\r\\n for (ex_index, example) in enumerate(examples):\\r\\n tokens_a = tokenizer.tokenize(example.text_a)\\r\\n tokens_b = None\\r\\n if example.text_b:\\r\\n tokens_b = tokenizer.tokenize(example.text_b)\\r\\n if tokens_b:\\r\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\r\\n # length is less than the specified length.\\r\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\r\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\r\\n else:\\r\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\r\\n if len(tokens_a) > max_seq_length - 2:\\r\\n tokens_a = tokens_a[0:(max_seq_length - 2)]\\r\\n\\r\\n if ex_index % 10000 == 0:\\r\\n tf.logging.info(\\\"Writing example %d of %d\\\" % (ex_index, len(examples)))\\r\\n\\r\\n # The convention in BERT is:\\r\\n # (a) For sequence pairs:\\r\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\r\\n # (b) For single sequences:\\r\\n # tokens: [CLS] the dog is hairy . [SEP]\\r\\n # type_ids: 0 0 0 0 0 0 0\\r\\n #\\r\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\r\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\r\\n # `type=1` were learned during pre-training and are added to the wordpiece\\r\\n # embedding vector (and position vector). This is not *strictly* necessary\\r\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\r\\n # it easier for the model to learn the concept of sequences.\\r\\n #\\r\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\r\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\r\\n # the entire model is fine-tuned.\\r\\n tokens = []\\r\\n segment_ids = []\\r\\n tokens.append(\\\"[CLS]\\\")\\r\\n segment_ids.append(0)\\r\\n for token in tokens_a:\\r\\n tokens.append(token)\\r\\n segment_ids.append(0)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(0)\\r\\n\\r\\n if tokens_b:\\r\\n for token in tokens_b:\\r\\n tokens.append(token)\\r\\n segment_ids.append(1)\\r\\n tokens.append(\\\"[SEP]\\\")\\r\\n segment_ids.append(1)\\r\\n\\r\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\r\\n\\r\\n input_mask = [1] * len(input_ids)\\r\\n\\r\\n while len(input_ids) < max_seq_length:\\r\\n input_ids.append(0)\\r\\n input_mask.append(0)\\r\\n segment_ids.append(0)\\r\\n assert len(input_ids) == max_seq_length\\r\\n assert len(input_mask) == max_seq_length\\r\\n assert len(segment_ids) == max_seq_length\\r\\n\\r\\n label_id = label_map[example.label]\\r\\n if ex_index < 3:\\r\\n tf.logging.info(\\\"*** Example ***\\\")\\r\\n tf.logging.info(\\\"guid: %s\\\" % (example.guid))\\r\\n tf.logging.info(\\\"tokens: %s\\\" % \\\" \\\".join([tokenization.printable_text(x) for x in tokens]))\\r\\n tf.logging.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\r\\n tf.logging.info(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\r\\n tf.logging.info(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in segment_ids]))\\r\\n tf.logging.info(\\\"label: %s (id = %d)\\\" % (example.label, label_id))\\r\\n\\r\\n features = collections.OrderedDict()\\r\\n features[\\\"input_ids\\\"] = input_ids\\r\\n features[\\\"input_mask\\\"] = input_mask\\r\\n features[\\\"segment_ids\\\"] = segment_ids\\r\\n features[\\\"label_ids\\\"] =label_id\\r\\n input_data.append(features)\\r\\n\\r\\n return input_data\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"][\\\"text\\\"]\\n for Q in data[\\\"passage\\\"][\\\"questions\\\"]:\\n question = Q[\\\"question\\\"]\\n for A in Q[\\\"answers\\\"]:\\n guid = f\\\"{set_type}-{data['idx']-Q['idx']-A['idx']}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage,\\n text_b=question + \\\" \\\" + A[\\\"text\\\"],\\n label=str(A[\\\"label\\\"]),\\n )\\n )\\n return examples\",\n \"def _create_examples(self, data_dir, set_type):\\n\\t\\texamples = []\\n\\t\\tinput_file_data = os.path.join(data_dir, \\\"data.tsv\\\")\\n\\t\\twith open(input_file_data, \\\"r\\\", encoding=\\\"utf-8-sig\\\") as f:\\n\\t\\t\\tfor i, inp in enumerate(f):\\n\\t\\t\\t\\tinps = inp.split('\\\\t') \\n\\t\\t\\t\\tguid = \\\"%s-%s\\\" % (set_type, i)\\n\\t\\t\\t\\ttext_inp = inps[1].strip()\\n\\t\\t\\t\\ttext_out = inps[2].strip()\\n\\t\\t\\t\\texamples.append(InputExample(guid=guid, text_inp=text_inp, text_out=text_out))\\n\\t\\t\\t\\t\\n\\t\\t\\t# Sort these out before returning\\n\\t\\t\\texamples = sorted(examples, key=sort_inp_len)\\n\\t\\t\\treturn examples\",\n \"def _convert_single_example(self, text_a, text_b):\\n tokens = []\\n input_ids = []\\n segment_ids = []\\n input_mask = []\\n try:\\n text_a = self.tokenizer.tokenize(text_a)\\n if text_b:\\n text_b = self.tokenizer.tokenize(text_b)\\n self._truncate_seq_pair(text_a, text_b)\\n\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n\\n for token in text_a:\\n tokens.append(token)\\n segment_ids.append(0)\\n segment_ids.append(0)\\n tokens.append(\\\"[SEP]\\\")\\n\\n if text_b:\\n for token in text_b:\\n tokens.append(token)\\n segment_ids.append(1)\\n tokens.append('[SEP]')\\n segment_ids.append(1)\\n\\n input_ids = self.tokenizer.convert_tokens_to_ids(tokens)\\n\\n input_mask = [1] * len(input_ids)\\n\\n while len(input_ids) < 50:\\n input_ids.append(0)\\n input_mask.append(0)\\n segment_ids.append(0)\\n\\n except:\\n self.logger.error()\\n\\n finally:\\n return input_ids, input_mask, segment_ids\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[8]\\r\\n text_b = line[9]\\r\\n if set_type != 'test':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def print_examples(example_iter, model, n=2, max_len=100, \\n sos_index=1, \\n src_eos_index=None, \\n trg_eos_index=None, \\n src_vocab=None, trg_vocab=None):\\n\\n model.eval()\\n count = 0\\n print()\\n \\n if src_vocab is not None and trg_vocab is not None:\\n src_eos_index = src_vocab.stoi[EOS_TOKEN]\\n trg_sos_index = trg_vocab.stoi[SOS_TOKEN]\\n trg_eos_index = trg_vocab.stoi[EOS_TOKEN]\\n else:\\n src_eos_index = None\\n trg_sos_index = 1\\n trg_eos_index = None\\n \\n for i, batch in enumerate(example_iter):\\n \\n src = batch.src.cpu().numpy()[0, :]\\n trg = batch.trg_y.cpu().numpy()[0, :]\\n\\n # remove </s> (if it is there)\\n src = src[:-1] if src[-1] == src_eos_index else src\\n trg = trg[:-1] if trg[-1] == trg_eos_index else trg \\n \\n result, _ = beam_decode(\\n model, batch.src, batch.src_mask, batch.src_lengths,\\n max_len=max_len, sos_index=trg_sos_index, eos_index=trg_eos_index)\\n print(\\\"Example #%d\\\" % (i+1))\\n print(\\\"Src : \\\", \\\" \\\".join(lookup_words(src, vocab=src_vocab)))\\n print(\\\"Trg : \\\", \\\" \\\".join(lookup_words(trg, vocab=trg_vocab)))\\n print(\\\"Pred: \\\", \\\" \\\".join(lookup_words(result, vocab=trg_vocab)))\\n print()\\n \\n count += 1\\n if count == n:\\n break\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n \\n for (i, line) in enumerate(lines):\\n sentence_number = 0\\n premise_text = line[\\\"premise\\\"]\\n modified_premise_text = re.sub(self.stage_name_pattern,\\\"\\\",premise_text)\\n modified_premise_text = re.sub(self.w_patterns,\\\"\\\",modified_premise_text)\\n hypothesis_text = line[\\\"hypothesis\\\"]\\n hypothesis_text = re.sub(self.w_patterns,\\\"\\\",hypothesis_text)\\n a_label = int(line[\\\"label\\\"])\\n\\n sentences = modified_premise_text.split('.')\\n\\n for j, sentence in enumerate(sentences):\\n guid = \\\"\\\" + str(sentence_number) + \\\"\\\\t\\\" + str(i) + \\\"\\\\t\\\" + str(len(sentences)) + \\\"\\\\t\\\" + str(a_label)\\n text_a = sentence\\n text_b = hypothesis_text\\n label = a_label\\n sentence_number += 1\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n #print(\\\"16th sentence::\\\",sentences[16])\\n\\n return examples\",\n \"def text_generator(self, example_generator):\\n\\t\\tif self._data_as_tf_example:\\n\\t\\t\\tquery_text = None\\n\\t\\t\\tquery_edge_list = None\\n\\t\\t\\tword_edge_list = None\\n\\t\\t\\t\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\te, epoch_num = example_generator.next() # e is a tf.Example\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tarticle_text = e.features.feature['article'].bytes_list.value[0] # document text\\n\\t\\t\\t\\t\\tabstract_text = e.features.feature['abstract'].bytes_list.value[0] # response text\\n\\t\\t\\t\\t\\tif self._hps.query_encoder.value:\\n\\t\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\tquery_text = e.features.feature['query'].bytes_list.value[0] # context text\\n\\t\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\t\\tquery_text = ''\\n\\t\\t\\t\\t\\tif self._hps.word_gcn.value:\\n\\t\\t\\t\\t\\t\\tword_edge_list = []\\n\\t\\t\\t\\t\\t\\tif self._hps.use_default_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t#tf.logging.info((word_edge_list[0]))\\n\\t\\t\\t\\t\\t\\tif self._hps.use_coref_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_coref_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_entity_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_entity_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_lexical_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tword_edge_list = word_edge_list + ast.literal_eval(e.features.feature['word_lexical_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t#\\tprint(word_edge_list)\\n\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\tif self._hps.query_gcn.value:\\n\\t\\t\\t\\t\\t\\tquery_edge_list = []\\n\\t\\t\\t\\t\\t\\tif self._hps.use_default_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t'''\\n\\t\\t\\t\\t\\t\\tThese are inter-sentence graph and may not be applicable\\n\\t\\t\\t\\t\\t\\tif self._hps.use_coref_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_coref_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_entity_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_entity_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\tif self._hps.use_lexical_graph.value:\\n\\t\\t\\t\\t\\t\\t\\tquery_edge_list = query_edge_list + ast.literal_eval(e.features.feature['query_lexical_edge_list'].bytes_list.value[0])\\n\\t\\t\\t\\t\\t\\t'''\\n\\n\\n\\n\\t\\t\\t\\texcept ValueError:\\n\\t\\t\\t\\t\\ttf.logging.error('Failed to get article or abstract from example')\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif len(article_text)==0: # See https://github.com/abisee/pointer-generator/issues/1\\n\\t\\t\\t\\t\\ttf.logging.warning('Found an example with empty article text. Skipping it.')\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t#tf.logging.info(abstract_text)\\n\\t\\t\\t\\t\\tyield (article_text, abstract_text, word_edge_list, query_text, query_edge_list, epoch_num)\\n\\t\\t\\t\\n\\t\\telse:\\n\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\te = example_generator.next()\\n\\t\\t\\t\\tyield e\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n examples.append(\\n InputExample(\\n guid=f\\\"{set_type}-{data['idx']}\\\",\\n text_a=data[\\\"passage\\\"],\\n text_b=data[\\\"question\\\"],\\n label=str(data[\\\"label\\\"]),\\n )\\n )\\n return examples\",\n \"def translate_interactive(estimator, tokenizer_):\\n \\n predictor = ContinuePredict(estimator, continue_input_fn)\\n while True:\\n tf.logging.info(\\\"Enter the English sentence end with ENTER.\\\")\\n raw_text = input().strip()\\n if raw_text == r'\\\\q':\\n predictor.close()\\n break\\n encoded_txt = _encode_and_add_eos(raw_text, tokenizer_)\\n target = predictor.predict(encoded_txt)\\n target = next(target)['outputs']\\n target = _trim_and_decode(target, tokenizer_)\\n tf.logging.info('\\\\t{}'.format(target))\",\n \"def generate_tpu(self, prompts: List[str]):\\n from flax.training.common_utils import shard # pylint:disable=g-import-not-at-top,g-importing-member\\n import jax # pylint:disable=g-import-not-at-top\\n import time # pylint:disable=g-import-not-at-top\\n import numpy as np # pylint:disable=g-import-not-at-top\\n\\n rng = jax.random.PRNGKey(0)\\n rng = jax.random.split(rng, jax.device_count())\\n\\n assert prompts, \\\"prompt parameter cannot be empty\\\"\\n print(\\\"Prompts: \\\", prompts)\\n prompt_ids = self._pipeline.prepare_inputs(prompts)\\n prompt_ids = shard(prompt_ids)\\n print(\\\"Sharded prompt ids has shape:\\\", prompt_ids.shape)\\n if self._run_with_profiler:\\n jax.profiler.start_trace(self._profiler_dir)\\n\\n time_start = time.time()\\n images = self._p_generate(prompt_ids, self._p_params, rng)\\n images = images.block_until_ready()\\n elapsed = time.time() - time_start\\n if self._run_with_profiler:\\n jax.profiler.stop_trace()\\n\\n print(\\\"Inference time (in seconds): \\\", elapsed)\\n print(\\\"Shape of the predictions: \\\", images.shape)\\n images = images.reshape(\\n (images.shape[0] * images.shape[1],) + images.shape[-3:])\\n print(\\\"Shape of images afterwards: \\\", images.shape)\\n return self._pipeline.numpy_to_pil(np.array(images))\",\n \"def generate_text(session, model, config, starting_text='<eos>',\\n stop_length=100, stop_tokens=None, temp=1.0):\\n state = model.initial_state.eval()\\n # Imagine tokens as a batch size of one, length of len(tokens[0])\\n tokens = [model.vocab.encode(word) for word in starting_text.split()]\\n for i in xrange(stop_length):\\n ### YOUR CODE HERE\\n #print tokens\\n feed = {}\\n #x = np.array([tokens[-1]])\\n #x.reshape(1,1)\\n feed[model.input_placeholder] = [[tokens[-1]]]\\n feed[model.dropout_placeholder] = 1\\n feed[model.initial_state] = state\\n y_pred, state = session.run([model.predictions[-1], model.final_state], feed_dict=feed)\\n ### END YOUR CODE\\n next_word_idx = sample(y_pred[0], temperature=temp)\\n tokens.append(next_word_idx)\\n if stop_tokens and model.vocab.decode(tokens[-1]) in stop_tokens:\\n break\\n output = [model.vocab.decode(word_idx) for word_idx in tokens]\\n return output\",\n \"def batchify(TEXT, data, batch_size, device):\\r\\n data = TEXT.numericalize([data.examples[0].text])\\r\\n num_batches = data.size(0)//batch_size\\r\\n data = data.narrow(0, 0, num_batches * batch_size)\\r\\n data = data.view(batch_size, -1).t().contiguous()\\r\\n\\r\\n return data.to(device)\",\n \"def convert_example(example,\\n tokenizer,\\n label_list,\\n max_seq_length=512,\\n is_test=False):\\n\\n def _truncate_seqs(seqs, max_seq_length):\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n tokens_a, tokens_b = seqs\\n max_seq_length -= 3\\n while True: # truncate with longest_first strategy\\n total_length = len(tokens_a) + len(tokens_b)\\n if total_length <= max_seq_length:\\n break\\n if len(tokens_a) > len(tokens_b):\\n tokens_a.pop()\\n else:\\n tokens_b.pop()\\n return seqs\\n\\n def _concat_seqs(seqs, separators, seq_mask=0, separator_mask=1):\\n concat = sum((seq + sep for sep, seq in zip(separators, seqs)), [])\\n segment_ids = sum(\\n ([i] * (len(seq) + len(sep))\\n for i, (sep, seq) in enumerate(zip(separators, seqs))), [])\\n if isinstance(seq_mask, int):\\n seq_mask = [[seq_mask] * len(seq) for seq in seqs]\\n if isinstance(separator_mask, int):\\n separator_mask = [[separator_mask] * len(sep) for sep in separators]\\n p_mask = sum((s_mask + mask\\n for sep, seq, s_mask, mask in zip(\\n separators, seqs, seq_mask, separator_mask)), [])\\n return concat, segment_ids, p_mask\\n\\n if not is_test:\\n # `label_list == None` is for regression task\\n label_dtype = \\\"int64\\\" if label_list else \\\"float32\\\"\\n # get the label\\n label = example[-2]\\n example = example[:-2]\\n #create label maps if classification task\\n if label_list:\\n label_map = {}\\n for (i, l) in enumerate(label_list):\\n label_map[l] = i\\n label = label_map[label]\\n label = np.array([label], dtype=label_dtype)\\n else:\\n qas_id = example[-1]\\n example = example[:-2]\\n # tokenize raw text\\n tokens_raw = [tokenizer(l) for l in example]\\n # truncate to the truncate_length,\\n tokens_trun = _truncate_seqs(tokens_raw, max_seq_length)\\n # concate the sequences with special tokens\\n tokens_trun[0] = [tokenizer.cls_token] + tokens_trun[0]\\n tokens, segment_ids, _ = _concat_seqs(tokens_trun, [[tokenizer.sep_token]] *\\n len(tokens_trun))\\n # convert the token to ids\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n valid_length = len(input_ids)\\n\\n if not is_test:\\n return input_ids, segment_ids, valid_length, label\\n else:\\n return input_ids, segment_ids, valid_length, qas_id\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n if set_type != 'test':\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[3]\\r\\n text_b = line[4]\\r\\n label = line[5]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n else:\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n try:\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n label = self.get_labels()[0]\\r\\n except IndexError:\\r\\n continue\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[0]\\n label = line[1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n guid = \\\"%s-%s\\\" % (set_type, i)\\r\\n if set_type != 'test':\\r\\n text_a = line[3]\\r\\n label = line[1]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n else:\\r\\n if i == 0:\\r\\n continue\\r\\n text_a = line[1]\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\r\\n return examples\",\n \"def query(self,text_input,prefix='answer:',convert_to_string=True):\\n predictions, raw_outputs = self.model.predict([text_input])\\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\\n return self._post_process_output(preds,convert_to_string=convert_to_string)\",\n \"def sample_to_features_text(\\n sample, tasks, max_seq_len, tokenizer\\n):\\n\\n if tokenizer.is_fast:\\n text = sample.clear_text[\\\"text\\\"]\\n # Here, we tokenize the sample for the second time to get all relevant ids\\n # This should change once we git rid of FARM's tokenize_with_metadata()\\n inputs = tokenizer(text,\\n return_token_type_ids=True,\\n truncation=True,\\n truncation_strategy=\\\"longest_first\\\",\\n max_length=max_seq_len,\\n return_special_tokens_mask=True)\\n\\n if (len(inputs[\\\"input_ids\\\"]) - inputs[\\\"special_tokens_mask\\\"].count(1)) != len(sample.tokenized[\\\"tokens\\\"]):\\n logger.error(f\\\"FastTokenizer encoded sample {sample.clear_text['text']} to \\\"\\n f\\\"{len(inputs['input_ids']) - inputs['special_tokens_mask'].count(1)} tokens, which differs \\\"\\n f\\\"from number of tokens produced in tokenize_with_metadata(). \\\\n\\\"\\n f\\\"Further processing is likely to be wrong.\\\")\\n else:\\n # TODO It might be cleaner to adjust the data structure in sample.tokenized\\n tokens_a = sample.tokenized[\\\"tokens\\\"]\\n tokens_b = sample.tokenized.get(\\\"tokens_b\\\", None)\\n\\n inputs = tokenizer.encode_plus(\\n tokens_a,\\n tokens_b,\\n add_special_tokens=True,\\n truncation=False, # truncation_strategy is deprecated\\n return_token_type_ids=True,\\n is_split_into_words=False,\\n )\\n\\n input_ids, segment_ids = inputs[\\\"input_ids\\\"], inputs[\\\"token_type_ids\\\"]\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n padding_mask = [1] * len(input_ids)\\n\\n # Padding up to the sequence length.\\n # Normal case: adding multiple 0 to the right\\n # Special cases:\\n # a) xlnet pads on the left and uses \\\"4\\\" for padding token_type_ids\\n if tokenizer.__class__.__name__ == \\\"XLNetTokenizer\\\":\\n pad_on_left = True\\n segment_ids = pad(segment_ids, max_seq_len, 4, pad_on_left=pad_on_left)\\n else:\\n pad_on_left = False\\n segment_ids = pad(segment_ids, max_seq_len, 0, pad_on_left=pad_on_left)\\n\\n input_ids = pad(input_ids, max_seq_len, tokenizer.pad_token_id, pad_on_left=pad_on_left)\\n padding_mask = pad(padding_mask, max_seq_len, 0, pad_on_left=pad_on_left)\\n\\n assert len(input_ids) == max_seq_len\\n assert len(padding_mask) == max_seq_len\\n assert len(segment_ids) == max_seq_len\\n\\n feat_dict = {\\n \\\"input_ids\\\": input_ids,\\n \\\"padding_mask\\\": padding_mask,\\n \\\"segment_ids\\\": segment_ids,\\n }\\n\\n # Add Labels for different tasks\\n for task_name, task in tasks.items():\\n try:\\n label_name = task[\\\"label_name\\\"]\\n label_raw = sample.clear_text[label_name]\\n label_list = task[\\\"label_list\\\"]\\n if task[\\\"task_type\\\"] == \\\"classification\\\":\\n # id of label\\n try:\\n label_ids = [label_list.index(label_raw)]\\n except ValueError as e:\\n raise ValueError(f'[Task: {task_name}] Observed label {label_raw} not in defined label_list')\\n elif task[\\\"task_type\\\"] == \\\"multilabel_classification\\\":\\n # multi-hot-format\\n label_ids = [0] * len(label_list)\\n for l in label_raw.split(\\\",\\\"):\\n if l != \\\"\\\":\\n label_ids[label_list.index(l)] = 1\\n elif task[\\\"task_type\\\"] == \\\"regression\\\":\\n label_ids = [float(label_raw)]\\n else:\\n raise ValueError(task[\\\"task_type\\\"])\\n except KeyError:\\n # For inference mode we don't expect labels\\n label_ids = None\\n if label_ids is not None:\\n feat_dict[task[\\\"label_tensor_name\\\"]] = label_ids\\n return [feat_dict]\",\n \"def tokenize_nmt(text, num_examples=None):\\n source, target = [], []\\n for i, line in enumerate(text.split('\\\\n')):\\n if num_examples and i > num_examples:\\n break\\n parts = line.split('\\\\t')\\n if len(parts) == 2:\\n source.append(parts[0].split(' '))\\n target.append(parts[1].split(' '))\\n return source, target\",\n \"def process(self, example: str) -> List[torch.Tensor]:\\n return self._tokenizer.batch_encode_plus([example], return_tensors=\\\"pt\\\", output_past=True, max_length=self.max_seq_len)['input_ids'][0]\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[1]\\n text_b = line[2]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def main():\\n # Load and prep training files\\n raw_speech_text = hg.load_training_file('trump_train.txt')\\n speech_text = hg.prep_training(raw_speech_text)\\n tweet_data = load_tweets('trump_tweets.json')\\n raw_tweets = \\\"\\\"\\n for dct in tweet_data:\\n raw_tweets += \\\"{} \\\".format(dct['text'])\\n tweets = hg.prep_training(raw_tweets)\\n corpus = speech_text + tweets\\n corpus = strip_punctuation(corpus)\\n dict_1 = hg.map_one_to_one(corpus)\\n dict_2 = hg.map_two_to_one(corpus)\\n text = []\\n \\n # Introduction\\n print(\\\"\\\\nTrump Speech Generator\\\\n\\\")\\n print(\\\"Select words to add to speech\\\")\\n print(\\\"\\\\'x\\\\' to exit\\\")\\n print(\\\"\\\\'p\\\\' to add punctuation\\\")\\n print(\\\"Select \\\\'p\\\\' before selecting the word you want to punctuate\\\")\\n\\n # Select first word\\n options = corpus\\n print ()\\n selection = select_word(corpus)\\n text.append(selection)\\n \\n # Select second word\\n last = text[0]\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n # Select subsequent word\\n while True:\\n last = \\\"{} {}\\\".format(text[-2].strip(punctuation),\\n text[-1].strip(punctuation))\\n options = word_after_two(last, dict_2)\\n if options == []:\\n last = last.split()[1]\\n options = word_after_one(last, dict_1)\\n while options == []:\\n last = random.choice(corpus)\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n print_text(text)\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for idx, line in enumerate(lines):\\n item = json.loads(line.strip())\\n question_id = \\\"%s-%s\\\" % (set_type, idx)\\n context = item[\\\"context\\\"]\\n question = item[\\\"question\\\"]\\n endings = [item[\\\"answerA\\\"],item[\\\"answerB\\\"],item[\\\"answerC\\\"] ]\\n label = item[\\\"correct\\\"]\\n #race_id = \\\"%s-%s\\\" % (set_type, data_raw[\\\"race_id\\\"])\\n #article = data_raw[\\\"article\\\"]\\n #for i in range(len(data_raw[\\\"answers\\\"])):\\n #truth = str(ord(data_raw[\\\"answers\\\"][i]) - ord(\\\"A\\\"))\\n #question = data_raw[\\\"questions\\\"][i]\\n #options = data_raw[\\\"options\\\"][i]\\n\\n examples.append(\\n InputExample(\\n example_id=question_id,\\n question=question,\\n contexts=[context,context,context],\\n endings=[endings[0], endings[1], endings[2]],#, options[3]\\n label=label,\\n )\\n )\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n if i <= 3:\\n print(\\\"i={}, line={}\\\".format(i, line))\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\r\\n examples = []\\r\\n for (i, line) in enumerate(lines):\\r\\n if i == 0:\\r\\n continue\\r\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\r\\n text_a = line[1]\\r\\n text_b = line[2]\\r\\n if set_type != 'test_matched':\\r\\n label = line[-1]\\r\\n else:\\r\\n label = self.get_labels()[0]\\r\\n examples.append(\\r\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\r\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (_, data) in enumerate(lines):\\n passage = data[\\\"passage\\\"]\\n ents_pos = [(pos[\\\"start\\\"], pos[\\\"end\\\"])\\n for pos in passage[\\\"entities\\\"]]\\n ents = [passage[\\\"text\\\"][start:end+1] for start, end in ents_pos]\\n for qa in data[\\\"qas\\\"]:\\n qa_id = f\\\"{set_type}-{data['idx']}-{qa['idx']}\\\"\\n answers = set([ans[\\\"text\\\"] for ans in qa[\\\"answers\\\"]])\\n for ent_idx, ent in enumerate(ents):\\n is_answer = ent in answers\\n guid = f\\\"{qa_id}-{ent_idx}\\\"\\n examples.append(\\n InputExample(\\n guid=guid,\\n text_a=passage[\\\"text\\\"],\\n # Insert entity in query\\n text_b=qa[\\\"query\\\"].replace(\\\"@placeholder\\\", ent),\\n label=\\\"1\\\" if is_answer else \\\"0\\\",\\n )\\n )\\n return examples\",\n \"def run_prediction(question_texts, context_text):\\r\\n examples = []\\r\\n\\r\\n for i, question_text in enumerate(question_texts):\\r\\n example = SquadExample(\\r\\n qas_id=str(i),\\r\\n question_text=question_text,\\r\\n context_text=context_text,\\r\\n answer_text=None,\\r\\n start_position_character=None,\\r\\n title=\\\"Predict\\\",\\r\\n is_impossible=False,\\r\\n answers=None,\\r\\n )\\r\\n\\r\\n examples.append(example)\\r\\n\\r\\n features, dataset = squad_convert_examples_to_features(\\r\\n examples=examples,\\r\\n tokenizer=tokenizer,\\r\\n max_seq_length=384,\\r\\n doc_stride=128,\\r\\n max_query_length=64,\\r\\n is_training=False,\\r\\n return_dataset=\\\"pt\\\",\\r\\n threads=1,\\r\\n )\\r\\n\\r\\n eval_sampler = SequentialSampler(dataset)\\r\\n eval_dataloader = DataLoader(dataset, sampler=eval_sampler, batch_size=10)\\r\\n\\r\\n all_results = []\\r\\n\\r\\n for batch in eval_dataloader:\\r\\n model.eval()\\r\\n batch = tuple(t.to(device) for t in batch)\\r\\n\\r\\n with torch.no_grad():\\r\\n inputs = {\\r\\n \\\"input_ids\\\": batch[0],\\r\\n \\\"attention_mask\\\": batch[1],\\r\\n \\\"token_type_ids\\\": batch[2],\\r\\n }\\r\\n\\r\\n example_indices = batch[3]\\r\\n\\r\\n outputs = model(**inputs)\\r\\n\\r\\n for i, example_index in enumerate(example_indices):\\r\\n eval_feature = features[example_index.item()]\\r\\n unique_id = int(eval_feature.unique_id)\\r\\n\\r\\n output = [to_list(output[i]) for output in outputs]\\r\\n\\r\\n start_logits, end_logits = output\\r\\n result = SquadResult(unique_id, start_logits, end_logits)\\r\\n all_results.append(result)\\r\\n\\r\\n output_prediction_file = \\\"predictions.json\\\"\\r\\n output_nbest_file = \\\"nbest_predictions.json\\\"\\r\\n output_null_log_odds_file = \\\"null_predictions.json\\\"\\r\\n\\r\\n predictions = compute_predictions_logits(\\r\\n examples,\\r\\n features,\\r\\n all_results,\\r\\n n_best_size,\\r\\n max_answer_length,\\r\\n do_lower_case,\\r\\n output_prediction_file,\\r\\n output_nbest_file,\\r\\n output_null_log_odds_file,\\r\\n False, # verbose_logging\\r\\n True, # version_2_with_negative\\r\\n null_score_diff_threshold,\\r\\n tokenizer,\\r\\n )\\r\\n\\r\\n return predictions\",\n \"def get_transformed_io(data_path, data_dir):\\n sents, labels = read_line_examples_from_file(data_path)\\n\\n # the input is just the raw sentence\\n inputs = [s.copy() for s in sents]\\n\\n task = 'asqp'\\n if task == 'aste':\\n targets = get_para_aste_targets(sents, labels)\\n elif task == 'tasd':\\n targets = get_para_tasd_targets(sents, labels)\\n elif task == 'asqp':\\n targets = get_para_asqp_targets(sents, labels)\\n else:\\n raise NotImplementedError\\n\\n return inputs, targets\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n text_b = line[4]\\n label = line[0]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, line[0])\\n text_a = line[7]\\n text_b = line[8]\\n label = line[-1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def _create_examples(self, lines, type):\\n examples = []\\n\\n for i in range(0, len(lines), self.interval):\\n text_a = lines[i]\\n label = lines[i + 2]\\n\\n examples.append(\\n InputExample(guid=len(examples), text_a=text_a, pos=None, label=label))\\n return examples\",\n \"def _create_examples(self, df, set_type):\\n examples = []\\n for i, row in df.iterrows():\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = row[4]\\n label = row[2]\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type, dom=-1):\\n examples = []\\n for (i, line) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n text_a = line[3]\\n label = line[1]\\n if dom != -1:\\n label = [label, str(dom)]\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, ids) in enumerate(lines):\\n guid = \\\"%s-%s\\\" % (set_type, ids )\\n text_a = lines[ids]['term']\\n text_b = lines[ids]['sentence']\\n label = lines[ids]['polarity']\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def convert_examples_to_features(examples, label_list, max_seq_length, tokenizer):\\n\\n label_map = {label: i for i, label in enumerate(label_list)}\\n\\n features = []\\n for (ex_index, example) in enumerate(examples):\\n tokens_a = tokenizer.tokenize(example.text_a)\\n\\n tokens_b = None\\n if example.text_b:\\n tokens_b = tokenizer.tokenize(example.text_b)\\n # Modifies `tokens_a` and `tokens_b` in place so that the total\\n # length is less than the specified length.\\n # Account for [CLS], [SEP], [SEP] with \\\"- 3\\\"\\n _truncate_seq_pair(tokens_a, tokens_b, max_seq_length - 3)\\n else:\\n # Account for [CLS] and [SEP] with \\\"- 2\\\"\\n if len(tokens_a) > max_seq_length - 2:\\n tokens_a = tokens_a[:(max_seq_length - 2)]\\n\\n # The convention in BERT is:\\n # (a) For sequence pairs:\\n # tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\\n # type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1\\n # (b) For single sequences:\\n # tokens: [CLS] the dog is hairy . [SEP]\\n # type_ids: 0 0 0 0 0 0 0\\n #\\n # Where \\\"type_ids\\\" are used to indicate whether this is the first\\n # sequence or the second sequence. The embedding vectors for `type=0` and\\n # `type=1` were learned during pre-training and are added to the wordpiece\\n # embedding vector (and position vector). This is not *strictly* necessary\\n # since the [SEP] token unambigiously separates the sequences, but it makes\\n # it easier for the model to learn the concept of sequences.\\n #\\n # For classification tasks, the first vector (corresponding to [CLS]) is\\n # used as as the \\\"sentence vector\\\". Note that this only makes sense because\\n # the entire model is fine-tuned.\\n tokens = [\\\"[CLS]\\\"] + tokens_a + [\\\"[SEP]\\\"]\\n segment_ids = [0] * len(tokens)\\n\\n if tokens_b:\\n tokens += tokens_b + [\\\"[SEP]\\\"]\\n segment_ids += [1] * (len(tokens_b) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n\\n label_id = label_map[example.label]\\n features.append(\\n InputFeatures(input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n label_id=label_id))\\n return features\",\n \"def _create_examples(self, lines, set_type):\\n examples = []\\n for (i, line) in enumerate(lines):\\n # Only the test set has a header\\n if set_type == \\\"test\\\" and i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (set_type, i)\\n if set_type == \\\"test\\\":\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = \\\"0\\\"\\n else:\\n text_a = tokenization.convert_to_unicode(line[1])\\n label = tokenization.convert_to_unicode(line[0])\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\\n return examples\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6111713","0.5924071","0.58839375","0.5859931","0.5800309","0.5781618","0.5774486","0.57522273","0.57205606","0.56961256","0.56917894","0.5685472","0.5684877","0.5684489","0.5622114","0.56032103","0.5577944","0.55711997","0.5566548","0.555741","0.55527824","0.55345577","0.5530338","0.5518854","0.5518089","0.55169445","0.55169445","0.5511586","0.55056286","0.5500359","0.54940194","0.54912585","0.5487304","0.5478574","0.54711366","0.5471066","0.5470501","0.5465104","0.54564923","0.54564923","0.5454603","0.5454121","0.5450557","0.54496026","0.54470515","0.5443643","0.5443049","0.5443049","0.5437053","0.54369944","0.5434196","0.5423586","0.54234666","0.5422409","0.54148626","0.54126024","0.5410403","0.540156","0.53946924","0.53684497","0.5364544","0.535289","0.53457034","0.5344018","0.5342755","0.5338888","0.5338693","0.53342134","0.5334035","0.5331439","0.53299665","0.53270173","0.5324919","0.5322709","0.5319762","0.5315595","0.53123057","0.5288355","0.5285381","0.52848047","0.52809787","0.5280526","0.5279603","0.52790946","0.52790946","0.52790946","0.5277419","0.52757096","0.5275489","0.5273472","0.5271849","0.52700144","0.52647907","0.52646774","0.52610165","0.5258706","0.5256669","0.5252593","0.52471566","0.52442247","0.52408445"],"string":"[\n \"0.6111713\",\n \"0.5924071\",\n \"0.58839375\",\n \"0.5859931\",\n \"0.5800309\",\n \"0.5781618\",\n \"0.5774486\",\n \"0.57522273\",\n \"0.57205606\",\n \"0.56961256\",\n \"0.56917894\",\n \"0.5685472\",\n \"0.5684877\",\n \"0.5684489\",\n \"0.5622114\",\n \"0.56032103\",\n \"0.5577944\",\n \"0.55711997\",\n \"0.5566548\",\n \"0.555741\",\n \"0.55527824\",\n \"0.55345577\",\n \"0.5530338\",\n \"0.5518854\",\n \"0.5518089\",\n \"0.55169445\",\n \"0.55169445\",\n \"0.5511586\",\n \"0.55056286\",\n \"0.5500359\",\n \"0.54940194\",\n \"0.54912585\",\n \"0.5487304\",\n \"0.5478574\",\n \"0.54711366\",\n \"0.5471066\",\n \"0.5470501\",\n \"0.5465104\",\n \"0.54564923\",\n \"0.54564923\",\n \"0.5454603\",\n \"0.5454121\",\n \"0.5450557\",\n \"0.54496026\",\n \"0.54470515\",\n \"0.5443643\",\n \"0.5443049\",\n \"0.5443049\",\n \"0.5437053\",\n \"0.54369944\",\n \"0.5434196\",\n \"0.5423586\",\n \"0.54234666\",\n \"0.5422409\",\n \"0.54148626\",\n \"0.54126024\",\n \"0.5410403\",\n \"0.540156\",\n \"0.53946924\",\n \"0.53684497\",\n \"0.5364544\",\n \"0.535289\",\n \"0.53457034\",\n \"0.5344018\",\n \"0.5342755\",\n \"0.5338888\",\n \"0.5338693\",\n \"0.53342134\",\n \"0.5334035\",\n \"0.5331439\",\n \"0.53299665\",\n \"0.53270173\",\n \"0.5324919\",\n \"0.5322709\",\n \"0.5319762\",\n \"0.5315595\",\n \"0.53123057\",\n \"0.5288355\",\n \"0.5285381\",\n \"0.52848047\",\n \"0.52809787\",\n \"0.5280526\",\n \"0.5279603\",\n \"0.52790946\",\n \"0.52790946\",\n \"0.52790946\",\n \"0.5277419\",\n \"0.52757096\",\n \"0.5275489\",\n \"0.5273472\",\n \"0.5271849\",\n \"0.52700144\",\n \"0.52647907\",\n \"0.52646774\",\n \"0.52610165\",\n \"0.5258706\",\n \"0.5256669\",\n \"0.5252593\",\n \"0.52471566\",\n \"0.52442247\",\n \"0.52408445\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":95597,"cells":{"query":{"kind":"string","value":"Export the settings as a DOM node."},"document":{"kind":"string","value":"def _exportNode(self):\n node = ZCatalogXMLAdapter._exportNode(self)\n\n self._logger.info('Person Catalog settings exported.')\n return node"},"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 _exportNode(self):\n node = self._extractProperties()\n self._logger.info('settings exported.')\n return node","def saveToXml(self) -> org.jdom.Element:\n ...","def to_xml(self):\r\n element = ET.Element(\"node\")\r\n\r\n element.attrib['name'] = self.name\r\n element.attrib['description'] = self.description\r\n\r\n return element","def get_dom(self) -> str:\n\n if self.is_running:\n return self.dumps()\n\n if self.dom is not None:\n return self.dom\n\n dom = self.dumps()\n self.dom = dom\n return dom","def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()","def quick_set_html_conversion_settings(self):\n self.logger.debug(\"HTML conversion settings\")\n self.export_format = 'html'\n self.quick_setting = 'html'\n self.front_matter_format = 'yaml'\n self.metadata_schema = []\n if self.conversion_input == 'nsx':\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\n self.spaces_in_tags = False\n self.split_tags = False\n self.first_row_as_header = True\n self.first_column_as_header = True\n self.chart_image = True\n self.chart_csv = True\n self.chart_data_table = True","def to_xml(self) -> str:\n # default name and stuff setup\n element_root, xml_tree = super()._add_basics()\n element_root = element_root.find('elementProp')\n element_root = element_root.find('collectionProp')\n for element in list(element_root):\n try:\n if element.attrib['name'] == 'influxdbUrl':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\n elem.text = self.influx_db_url\n elif element.attrib['name'] == 'application':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.application:\n elem.text = self.application\n elif element.attrib['name'] == 'measurement':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\n elem.text = self.application\n elif element.attrib['name'] == 'summaryOnly':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value':\n elem.text = str(self.summary_only).lower()\n elif element.attrib['name'] == 'samplersRegex':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\n elem.text = self.samplers_regexp\n elif element.attrib['name'] == 'percentiles':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\n elem.text = self.percentiles\n elif element.attrib['name'] == 'testTitle':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\n elem.text = self.test_title\n elif element.attrib['name'] == 'eventTags':\n for elem in list(element):\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\n elem.text = self.event_tags\n except Exception:\n raise Exception(f'Unable to render xml from {type(self).__class__}')\n return tree_to_str(xml_tree, hashtree=True)","def write(self):\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\"UTF-8\")\n with open(self.xml_file, 'w') as f:\n f.write(temp_string)\n # f = open(self.xml_file, \"w\")\n # f.write(temp_string)\n # f.close()","def exportElements(self):\n fname = os.path.join(\".\", \"atoms-exported.IN\")\n fname = QtWidgets.QFileDialog.getSaveFileName(self, \"Atoman - Export element properties\", fname,\n \"IN files (*.IN)\",\n options=QtWidgets.QFileDialog.DontUseNativeDialog)[0]\n\n if fname:\n if \".\" not in fname or fname[-3:] != \".IN\":\n fname += \".IN\"\n\n self.logger.info(\"Exporting elements settings to '%s'\", fname)\n elements.write(fname)","def toxml(self) :\n\t\treturn self.doc.toxml()","def config_html(output_file=''):\n if output_file:\n f = open(output_file, 'w')\n else:\n f = sys.stdout\n create_config_html(f)","def dump(self, path, mode='standalone'):\n if mode == 'standalone':\n with open(path+\"/export_grid_standalone\"+str(self._id)+\".html\", 'w+') as f:\n f.write(self.export_html(build=True))\n elif mode == 'all':\n widget_export = self.export_html(build=False)\n with open(path+\"/export_scripts.html\", \"w+\") as f:\n f.write(widget_export['script_tags'])\n with open(path+\"/export_html_state.html\", \"w+\") as f:\n f.write(widget_export['html_state'])\n with open(path+\"/export_state_\"+str(self._id)+\".json\", \"w+\") as f:\n f.write(json.dumps(widget_export['manager_state']))\n with open(path+\"/export_grid_\"+str(self._id)+\".html\", \"w+\") as f:\n f.write(widget_export['grid_div'])","def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()","def settings_view():\n return template('settings.html')","def save(self):\n with self.open(self.filename, 'wt') as fd:\n for node in self.elements:\n fd.write(node.text)","def to_etree(self):\n\n # Format connections\n text = []\n for i in range(self.width):\n if i in self.connections:\n text.append(str(self.connections[i]))\n else:\n text.append(\"open\")\n\n elem = ET.Element(\"port\", attrib={\"name\": self.name})\n elem.text = \" \".join(text)\n return elem","def xml(self):\n rough_string = ElementTree.tostring(self.dom, \"utf-8\")\n reparsed = minidom.parseString(rough_string)\n return reparsed.toprettyxml(indent=\" \")","def xml(self, indent):\n if self.__commentOut:\n prefix = \"<!--\"\n suffix = \" -->\"\n else:\n prefix = \"\"\n suffix = \"\"\n hubs = self.__stringMap.keys()\n if self.OMIT_HUB_NUMBER or len(hubs) != 1:\n nStr = \"\"\n else:\n nStr = \" hub=\\\"%d\\\"\" % hubs[0]\n return \"%s%s<domConfigList%s>%s</domConfigList>%s\" % \\\n (prefix, indent, nStr, self.__fileName, suffix)","def __init__(self, settings_xml):\n # The list of setting ids.\n #\n # XXX This is redundant. We could just get the ids from\n # getting the values of any of our dicts.\n #\n self.ids = []\n self.values = { }\n self.types = { }\n self.defaults = { }\n self.labels = { }\n\n if settings_xml:\n dom = parseString(settings_xml)\n s = dom.firstChild\n\n setting = first_child(s, \"setting\")\n while setting:\n setting_id = setting.getAttribute(\"id\")\n\n # I know the 'sep' setting has no id. I am not sure what it is\n # used for so I am just going to skip it.\n #\n if setting_id != \"\":\n self.ids.append(setting_id)\n self.labels[setting_id] = setting.getAttribute(\"label\")\n self.types[setting_id] = setting.getAttribute(\"type\")\n\n # For bool's actually set the default value to True or\n # False. otherwise it is all strings to us.\n #\n default = setting.getAttribute(\"default\")\n if self.types[setting_id] == \"bool\":\n self.defaults[setting_id] = (default.lower() == 'true')\n else:\n self.defaults[setting_id] = default\n\n # Settings start out with their default value.\n #\n self.values[setting_id] = self.defaults[setting_id]\n setting = next_sibling(setting, \"setting\")\n\n dom.unlink()\n dom = None\n\n # There is always an 'override' setting - \"override\", which is\n # set based on the Language Override setting in the scraper.\n #\n if 'override' not in self.ids:\n self.ids.append(\"override\")\n self.values[\"override\"] = False\n self.types[\"override\"] = \"bool\"\n self.defaults[\"override\"] = False\n self.labels[\"override\"] = \"Language Override\"\n\n # The default language for now is english!\n #\n if 'language' not in self.ids:\n self.ids.append(\"language\")\n self.values[\"language\"] = \"en\"\n self.types[\"language\"] = \"string\"\n self.defaults[\"language\"] = \"en\"\n self.labels[\"language\"] = \"Language\"\n\n return","def __repr__(self) -> str:\n view = {\n \"server\": self.server,\n \"access-token\": 'yes' if self.token is not None else 'no',\n \"insecure\": self.insecure,\n \"output\": self.output,\n \"verbose\": self.verbose,\n }\n\n return \"<Configuration({})\".format(view)","def create_dd_settings(xml_document, parent_element):\n dd_properties_element = xml_document.createElement(\"dd_properties\")\n parent_element.appendChild(dd_properties_element)\n\n option_element = xml_document.createElement(\"Option\")\n option_element.setAttribute('type', 'Map')\n dd_properties_element.appendChild(option_element)\n\n option_child1_element = xml_document.createElement(\"Option\")\n option_child1_element.setAttribute('type', 'QString')\n option_child1_element.setAttribute('name', 'name')\n option_child1_element.setAttribute('value', '')\n option_element.appendChild(option_child1_element)\n\n option_child2_element = xml_document.createElement(\"Option\")\n option_child2_element.setAttribute('name', 'properties')\n option_element.appendChild(option_child2_element)\n\n option_child3_element = xml_document.createElement(\"Option\")\n option_child3_element.setAttribute('type', 'QString')\n option_child3_element.setAttribute('name', 'type')\n option_child3_element.setAttribute('value', 'collection')\n option_element.appendChild(option_child3_element)","def export(self, package):\n self.style = package.style\n self.copyFiles(package)\n self.html = self.renderHeader(package.name)\n self.html += u\"<body>\\n\"\n self.html += u\"<div id=\\\"content\\\">\\n\"\n self.html += u\"<div id=\\\"header\\\">\\n\"\n self.html += escape(package.title)\n self.html += u\"</div>\\n\"\n self.html += u\"<div id=\\\"main\\\">\\n\"\n self.renderNode(package.root)\n self.html += u\"</div>\\n\"\n self.html += u\"</div>\\n\"\n self.html += u\"</body></html>\\n\"\n self.save(self.outputDir/\"index.html\")","def setup_render(\n self, options: Dict[str, Any], env: MutableMapping[str, Any]\n ) -> None:\n self.md_env = env\n self.config: Dict[str, Any] = options\n self.document: nodes.document = self.config.get(\"document\", make_document())\n self.current_node: nodes.Element = self.config.get(\n \"current_node\", self.document\n )\n self.reporter: Reporter = self.document.reporter\n # note there are actually two possible language modules:\n # one from docutils.languages, and one from docutils.parsers.rst.languages\n self.language_module_rst: ModuleType = get_language_rst(\n self.document.settings.language_code\n )\n self._level_to_elem: Dict[int, nodes.Element] = {0: self.document}","def get_html(self):\r\n\r\n # these 3 will be used in class methods\r\n self.html_id = self.location.html_id()\r\n self.html_class = self.location.category\r\n\r\n self.configuration_json = self.build_configuration_json()\r\n params = {\r\n 'gst_html': self.substitute_controls(self.render),\r\n 'element_id': self.html_id,\r\n 'element_class': self.html_class,\r\n 'configuration_json': self.configuration_json\r\n }\r\n content = self.system.render_template(\r\n 'graphical_slider_tool.html', params\r\n )\r\n return content","def to_dom_element(self, doc):\n string = \"This should never be printed. - EGCryptoSystem.py\"\n return self.to_stub(string, string).to_dom_element(doc)","def build_configuration_json(self):\r\n # <root> added for interface compatibility with xmltodict.parse\r\n # class added for javascript's part purposes\r\n root = '<root class=\"{}\">{}</root>'.format(\r\n self.html_class,\r\n self.configuration)\r\n return json.dumps(xmltodict.parse(root))","def save_settings(self):\r\n self.QtSettings.beginGroup(\"MainWindow\")\r\n self.QtSettings.setValue(\"geometry\",self.saveGeometry())\r\n self.QtSettings.setValue(\"state\",self.saveState())\r\n self.QtSettings.endGroup()\r\n \r\n #save element content\r\n self.QtSettings.beginGroup(\"Settings\")\r\n pyguitools.gui_save(self.ui,self.QtSettings)\r\n self.QtSettings.endGroup()","def build_configuration_json(self):\n # <root> added for interface compatibility with xmltodict.parse\n # class added for javascript's part purposes\n return json.dumps(xmltodict.parse('<root class=\"' + self.html_class +\n '\">' + self.configuration + '</root>'))","def toXMLNode(self):\n return _libsbml.SBase_toXMLNode(self)","def serialize_settings(node_settings, current_user):\n user_settings = node_settings.user_settings\n user_is_owner = user_settings is not None and (\n user_settings.owner._primary_key == current_user._primary_key\n )\n current_user_settings = current_user.get_addon('menbib')\n rv = {\n 'nodeHasAuth': node_settings.has_auth,\n 'userIsOwner': user_is_owner,\n 'userHasAuth': current_user_settings is not None and current_user_settings.has_auth,\n 'urls': serialize_urls(node_settings)\n }\n if node_settings.has_auth:\n # Add owner's profile URL\n rv['urls']['owner'] = web_url_for('profile_view_id',\n uid=user_settings.owner._primary_key)\n rv['ownerName'] = user_settings.owner.fullname\n path = node_settings.folder\n if path is None:\n rv['folder'] = {'name': None, 'path': None}\n else:\n rv['folder'] = {\n 'name': 'Menbib' + path,\n 'path': path\n }\n return rv","def write_config():\n\n e = Element(\"Configuration\")\n r = SubElement(e, \"RepositoryList\")\n r = SubElement(r, \"Repository\", name = \"default\")\n SubElement(r, \"Module\").text = args.driver\n SubElement(r, \"TokenLabel\").text = args.token_label\n SubElement(r, \"PIN\").text = args.pin\n ElementTree(e).write(args.write_config)\n args.write_config.flush()","def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')","def addOutputsNode():\n return render_template(\"addOutputsNode.html\")","def write(self, fd):\n indent = \" \"\n in2 = indent + indent\n print >>fd, \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\"\n if self.__topComment is not None:\n print >>fd, \"<!--%s-->\" % self.__topComment\n print >>fd, \"<runConfig>\"\n for d in self.__domCfgList:\n print >>fd, d.xml(indent)\n for n in self.__domCfgNames:\n print >>fd, n.xml(indent)\n if self.__replayBaseDir is not None:\n print >>fd, \"%s<hubFiles baseDir=\\\"%s\\\">\" % \\\n (indent, self.__replayBaseDir)\n for r in self.__replayHubList:\n print >>fd, r.xml(in2)\n print >>fd, \"%s</hubFiles>\" % indent\n print >>fd, \"%s<triggerConfig>%s</triggerConfig>\" % \\\n (indent, self.__trigCfg)\n for c in self.__comps:\n if not c.isHub():\n print >>fd, \"%s<runComponent name=\\\"%s\\\"/>\" % \\\n (indent, c.name())\n\n if self.__strayStream is not None:\n (name, prescale) = self.__strayStream\n in3 = in2 + indent\n\n print >>fd, \"%s<stream name=\\\"%s\\\">\" % (in2, name)\n print >>fd, \"%s<prescale>%d</prescale>\" % (in3, prescale)\n print >>fd, \"%s</stream>\" % in2\n\n if self.__senderOption is not None:\n (hub, fwdIsolatedHits) = self.__senderOption\n fwdName = \"forwardIsolatedHitsToTrigger\"\n if fwdIsolatedHits:\n fwdVal = \"true\"\n else:\n fwdVal = \"false\"\n\n in3 = in2 + indent\n in4 = in3 + indent\n\n print >>fd, \"%s<stringHub hubId=\\\"%d\\\">\" % (in2, hub)\n print >>fd, \"%s<sender>\" % in3\n print >>fd, \"%s<%s>%s</%s>\" % (in4, fwdName, fwdVal, fwdName)\n print >>fd, \"%s</sender>\" % in3\n print >>fd, \"%s</stringHub>\" % in2\n\n print >>fd, \"</runConfig>\"","def write_settings(f, settings, name, embedded_flag):\n f.write(\"// Define settings structure\\n\")\n f.write(\"OSQPSettings %s = {\" % name)\n f.write(\"(c_float)%.20f, \" % settings['rho'])\n f.write(\"(c_float)%.20f, \" % settings['sigma'])\n f.write(\"%d, \" % settings['scaling'])\n\n # EMBEDDED == 2\n if embedded_flag != 1:\n f.write(\"%d, \" % settings['scaling_iter'])\n\n f.write(\"%d, \" % settings['max_iter'])\n f.write(\"(c_float)%.20f, \" % settings['eps_abs'])\n f.write(\"(c_float)%.20f, \" % settings['eps_rel'])\n f.write(\"(c_float)%.20f, \" % settings['eps_prim_inf'])\n f.write(\"(c_float)%.20f, \" % settings['eps_dual_inf'])\n f.write(\"(c_float)%.20f, \" % settings['alpha'])\n\n f.write(\"%d, \" % settings['scaled_termination'])\n f.write(\"%d, \" % settings['early_terminate'])\n f.write(\"%d, \" %\n settings['early_terminate_interval'])\n f.write(\"%d\" % settings['warm_start'])\n\n f.write(\"};\\n\\n\")","def to_dom_element(self, doc): # pragma: no cover\n cs_scheme_element = doc.createElement(\"CryptoSystemScheme\")\n \n nbits_element = doc.createElement(\"nbits\")\n nbits_element.appendChild(doc.createTextNode(str(self.nbits)))\n cs_scheme_element.appendChild(nbits_element)\n \n prime_element = doc.createElement(\"prime\")\n prime_str = hex(self.prime)[2:] # Remove leading '0x'\n if(prime_str[-1] == 'L'): \n prime_str = prime_str[0:-1] # Remove trailing 'L'\n prime_element.appendChild(doc.createTextNode(prime_str))\n cs_scheme_element.appendChild(prime_element)\n \n generator_element = doc.createElement(\"generator\")\n generator_str = hex(self.generator)[2:] # Remove leading '0x'\n if(generator_str[-1] == 'L'): \n generator_str = generator_str[0:-1] # Remove trailing 'L'\n generator_element.appendChild(doc.createTextNode(generator_str))\n cs_scheme_element.appendChild(generator_element)\n \n return cs_scheme_element","def export_to_file(self, filename):\n if len(filename.split(\".\")) == 1:\n filename += \".xml\"\n xmlstring = self._dommodel.toprettyxml(\" \", \"\\n\")\n with open(filename, \"w\") as f:\n f.write(xmlstring)","def showSettings():\n cq = dz()\n cq.abag()","def render_settings_view():\n return render_template('settings_screen.html', realsense_device_status=realsense_enabled, detector_enabled=enabled_detector)","def get_xml(self):\n return etree.tostring(self.get_etree())","def node():\n return render_template('nodes.html')","def get_settings(self):\n return self.request({\n \"path\": \"/\" + UUID + \"/setting\"\n })","def exportHtmlSingle(self, filePath=''):\n if not filePath:\n filePath = self.getFileName(_('TreeLine - Export HTML'), 'html')\n if not filePath:\n return False\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\n if ExportDialog.exportWhat == ExportDialog.entireTree:\n self.selectedNodes = [self.rootNode]\n outputGroup = treeoutput.OutputGroup(self.selectedNodes,\n ExportDialog.includeRoot,\n ExportDialog.exportWhat !=\n ExportDialog.selectNode,\n ExportDialog.openOnly, True)\n outputGroup.addBlanksBetween()\n outputGroup.addIndents()\n outputGroup.addSiblingPrefixes()\n outGroups = outputGroup.splitColumns(ExportDialog.numColumns)\n htmlTitle = os.path.splitext(os.path.basename(filePath))[0]\n indent = globalref.genOptions.getValue('IndentOffset')\n lines = ['<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 '\n 'Transitional//EN\">', '<html>', '<head>',\n '<meta http-equiv=\"Content-Type\" content=\"text/html; '\n 'charset=utf-8\">', '<title>{0}</title>'.format(htmlTitle),\n '<style type=\"text/css\"><!--',\n 'div {{margin-left: {0}em}}'.format(indent),\n 'td {padding: 10px}', 'tr {vertical-align: top}',\n '--></style>', '</head>', '<body>']\n if ExportDialog.addHeader:\n headerText = (globalref.mainControl.activeControl.printData.\n formatHeaderFooter(True))\n if headerText:\n lines.append(headerText)\n lines.extend(['<table>', '<tr><td>'])\n lines.extend(outGroups[0].getLines())\n for group in outGroups[1:]:\n lines.append('</td><td>')\n lines.extend(group.getLines())\n lines.extend(['</td></tr>', '</table>'])\n if ExportDialog.addHeader:\n footerText = (globalref.mainControl.activeControl.printData.\n formatHeaderFooter(False))\n if footerText:\n lines.append(footerText)\n lines.extend(['</body>', '</html>'])\n with open(filePath, 'w', encoding='utf-8') as f:\n f.writelines([(line + '\\n') for line in lines])\n return True","def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\n raise NotImplementedError","def _save_settings(self):\n # data to be save :\n # -----------------\n # futurePivot node\n\n # create attributes\n self._create_data_attribute()\n\n # connect futurePivot node\n pm.connectAttr(\n \"%s%s\" % (self._futurePivot.name(), \".message\"),\n self._object.attr(\"pivotData.futurePivot\"),\n f=True,\n )","def view_to_config(self):\n raise NotImplementedError","def node_config():\r\n paragraph = document.add_paragraph('')\r\n document.add_heading('Server node details', 1)\r\n node_metrics = ['host name','central','purpose', 'engine', 'proxy', 'printing', 'scheduler']\r\n nodes = get_qlik_sense.get_nodeconfig()\r\n num_of_nodes = len(nodes)\r\n num_of_node_metrics = len(node_metrics)\r\n table = document.add_table(rows=num_of_node_metrics+1, cols=num_of_nodes+1)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'Metric'\r\n for item in range(0, num_of_nodes):\r\n row.cells[item+1].text = nodes[item][7]\r\n for item in range(num_of_node_metrics):\r\n row = table.rows[item+1]\r\n row.cells[0].text = str(node_metrics[item])\r\n\r\n for node in range(num_of_nodes):\r\n row.cells[node+1].text = str(nodes[node][item])\r\n document.add_page_break()","def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )","def dom(self):\n raise NotImplementedError(\"base class called\")","def build_settings(self, settings):\n \n settings.add_json_panel(\"Network\", self.config, data=network_json)\n settings.add_json_panel(\"Camera\", self.config, data=camera_json)\n settings.add_json_panel(\"CV\", self.config, data=cv_json)\n settings.add_json_panel(\"Admin\", self.config, data=admin_json)","def load_settings(self):\n\n self.std = settings.settings","def jssettings(self):\n self.update()\n return \"var %s = %s\" % (self.js_var_settings_name,\n json.dumps(self.settings))","def writeFile(self, filename):\n s = ET.tostring(self._root)\n\n #Remove all formatting\n s = s.replace('\\n','')\n s = s.replace('\\t','')\n s = s.replace('\\r','')\n\n f = open(filename, 'w')\n f.write(minidom.parseString(s).toprettyxml())\n f.close()","def serialize(self):\n return self.xmlnode.serialize(encoding=\"utf-8\")","def setting():\n return render_template('setting.html', year=datetime.now().year)","def build_settings(self, settings):\n settings.add_json_panel('Makesmith Settings', self.config, data=self.json)","def saveSessionToXML(self, filename):\r\n xmlStr = self.createXMLStr()\r\n \r\n #Write to the file\r\n #xml.dom.ext.PrettyPrint(doc, open(filename, 'w'))\r\n xmlFile = open(filename, 'w')\r\n xmlFile.write(xmlStr)\r\n xmlFile.close()","def export_html(self, build=False):\n if build:\n html = export_html_code(self)\n return (html['script_tags'] +\n (html['html_state']).format(manager_state=json.dumps(html['manager_state'])) +\n html['grid_div'])\n return export_html_code(self)","def print_settings(self, title=None):\n if title:\n print(title)\n print('Contents of imagenode.yaml:')\n pprint.pprint(self.config)\n print()","def exportHtmlPages(self, filePath=''):\n if not filePath:\n filePath = QtGui.QFileDialog.getExistingDirectory(QtGui.\n QApplication.activeWindow(),\n _('TreeLine - Export HTML'),\n self.defaultFilePath)\n if not filePath:\n return False\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\n oldDir = os.getcwd()\n os.chdir(filePath)\n indent = globalref.genOptions.getValue('IndentOffset')\n cssLines = ['#sidebar {',\n ' width: 16em;',\n ' float: left;',\n ' border-right: 1px solid black;',\n '}',\n '#sidebar div {{margin-left: {0}em;}}'.format(indent),\n '#content {',\n ' margin-left: 16em;',\n ' border-left: 1px solid black;',\n ' padding-left: 6px;',\n '}']\n with open('default.css', 'w', encoding='utf-8') as f:\n f.writelines([(line + '\\n') for line in cssLines])\n if ExportDialog.exportWhat == ExportDialog.entireTree:\n self.selectedNodes = [self.rootNode]\n if len(self.selectedNodes) > 1:\n modelRef = self.selectedNodes[0].modelRef\n dummyFormat = modelRef.formats.addDummyRootType()\n root = treenode.TreeNode(None, dummyFormat.name, modelRef)\n name = os.path.basename(self.defaultFilePath)\n if not name:\n name = treemodel.defaultRootName\n root.setTitle(name)\n for node in self.selectedNodes:\n root.childList.append(copy.copy(node))\n root.childList[-1].parent = root\n else:\n root = self.selectedNodes[0]\n root.exportHtmlPage()\n root.modelRef.formats.removeDummyRootType()\n os.chdir(oldDir)\n return True","def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u' prefix=\"%s\"' % escape(self.prefix, treedoc.escDict)\n if self.suffix:\n text += u' suffix=\"%s\"' % escape(self.suffix, treedoc.escDict)\n if self.html:\n text += u' html=\"y\"'\n if self.isRequired:\n text += u' required=\"y\"'\n if self.hidden:\n text += u' hidden=\"y\"'\n if self.numLines > 1:\n text += u' lines=\"%d\"' % self.numLines\n if self.initDefault:\n text += u' init=\"%s\"' % escape(self.initDefault, treedoc.escDict)\n if self.linkAltField:\n text += u' linkalt=\"%s\"' % escape(self.linkAltField,\n treedoc.escDict)\n return text","def get(self) :\n self.generate('export.html', {\n 'xml' : export(),\n 'title' : \"Admin Export\"})","def save_output_node(out):\n out_wc = out.clone()\n return out_wc","def writeDoc(self, out, displayOptions=None):\n if displayOptions is None:\n displayOptions = {}\n tw = textwrap.TextWrapper(initial_indent='# ',\n subsequent_indent='# ', width=70)\n out.write('# %s (Default: %s)\\n' % (self.name,\n ', '.join(self.valueType.toStrings(self.getDefault(), displayOptions))))\n if self.doc:\n out.write('\\n'.join(tw.wrap(self.doc)))\n out.write('\\n')","def get_html(self):\n\n # these 3 will be used in class methods\n self.html_id = self.location.html_id()\n self.html_class = self.location.category\n self.configuration_json = self.build_configuration_json()\n params = {\n 'gst_html': self.substitute_controls(self.render),\n 'element_id': self.html_id,\n 'element_class': self.html_class,\n 'configuration_json': self.configuration_json\n }\n content = self.system.render_template(\n 'graphical_slider_tool.html', params)\n return content","def write_to(self, fp):\n fp.write('<')\n fp.write(self.tag)\n for k, v in self.attrs.iteritems():\n fp.write(' ')\n fp.write(k),\n fp.write('=\"')\n fp.write(xml_escape(v))\n fp.write('\"')\n if len(self.contents) == 0:\n fp.write(' />')\n else:\n fp.write('>')\n for item in self.contents:\n if isinstance(item, basestring):\n item = xml_escape(item)\n fp.write(item)\n elif isinstance(item, Markup) or isinstance(item, Element):\n item.write_to(fp)\n else:\n raise TypeError('Item %r must be either a string, '\n '``Element``, or ``Markup``' % item)\n fp.write('</')\n fp.write(self.tag)\n fp.write('>')","def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml","def create_html(self):\n # Add html content to the self.doc\n self.doc.asis('<!DOCTYPE html>')\n with self.tag('html'):\n self.design_header()\n self.design_body()\n # Write html content from self.doc\n with codecs.open(self.filestream.name, 'w', 'utf-8') as f:\n html_content = indent(\n self.doc.getvalue(),\n indentation=' ',\n newline='\\r\\n'\n )\n f.write(html_content)","def SaveSettings(self, settingsFile):\n with codecs.open(settingsFile, encoding='utf-8-sig', mode='w+') as f:\n json.dump(self.__dict__, f, encoding='utf-8-sig')\n with codecs.open(settingsFile.replace(\"json\", \"js\"), encoding='utf-8-sig', mode='w+') as f:\n f.write(\"var settings = {0};\".format(json.dumps(self.__dict__, encoding='utf-8-sig')))\n return","def XMLWriter(\n fd,\n encoding=\"utf-8\",\n pretty=True,\n compactempty=True,\n indentation=_DEFAULT_INDENTATION\n):\n return _document(fd, encoding, pretty, compactempty, indentation)","def writeSettings(self):\n settings = QtCore.QSettings()\n output_directory = self.ui.outputDirLineEdit.text()\n settings.setValue(\"output_directory\", output_directory)","def prettify(self):\n re_parsed = minidom.parseString(tostring(self.dom))\n return re_parsed.toprettyxml()","def export_toml(self): # type: () -> str\n return self._config_to_toml(self._config, self._toml)","def toxml(self) -> ET.Element:\n # Dummy element that ElementTree extend() will strip\n root = ET.Element('root')\n\n connection = ET.SubElement(root, 'Connection')\n\n origin = ET.SubElement(connection, 'Origin')\n origin.set('ToolID', self.origin_tool.tool_id)\n origin.set('Connection', self.origin_output)\n\n destination = ET.SubElement(connection, 'Destination')\n destination.set('ToolID', self.destination_tool.tool_id)\n destination.set('Connection', self.destination_input)\n\n return root","def htmlNodeDumpFile(self, out, cur):\n if cur is None: cur__o = None\n else: cur__o = cur._o\n libxml2mod.htmlNodeDumpFile(out, self._o, cur__o)","def exportZendoc(self,ofile):\n value = self.getZendoc()\n if not value: return\n ofile.write(\"<property id='zendoc' type='string'>\\n\")\n if not isinstance(value, basestring):\n value = unicode(value)\n elif isinstance(value, str):\n value = value.decode('latin-1')\n ofile.write(saxutils.escape(value).encode('utf-8')+\"\\n\")\n ofile.write(\"</property>\\n\")","def config_to_view(self):\n raise NotImplementedError","def exportHtmlNavSingle(self, filePath=''):\n if not filePath:\n filePath = self.getFileName(_('TreeLine - Export HTML'), 'html')\n if not filePath:\n return False\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\n if ExportDialog.exportWhat == ExportDialog.entireTree:\n self.selectedNodes = [self.rootNode]\n outputGroup = treeoutput.OutputGroup(self.selectedNodes,\n ExportDialog.includeRoot, True,\n ExportDialog.openOnly, True,\n ExportDialog.navPaneLevels)\n outputGroup.addBlanksBetween()\n outputGroup.addIndents()\n outputGroup.addSiblingPrefixes()\n htmlTitle = os.path.splitext(os.path.basename(filePath))[0]\n indent = globalref.genOptions.getValue('IndentOffset')\n lines = ['<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 '\n 'Transitional//EN\">', '<html>', '<head>',\n '<meta http-equiv=\"Content-Type\" content=\"text/html; '\n 'charset=utf-8\">', '<title>{0}</title>'.format(htmlTitle),\n '<style type=\"text/css\"><!--',\n ' #sidebar {',\n ' width: 16em;',\n ' float: left;',\n ' border-right: 1px solid black;',\n ' }',\n ' #sidebar div {{margin-left: {0}em;}}'.format(indent),\n ' #content {',\n ' margin-left: 16em;',\n ' border-left: 1px solid black;',\n ' padding-left: 6px;',\n ' }',\n ' #content div {{margin-left: {0}em;}}'.format(indent),\n '--></style>',\n '</head>', '<body>', '<div id=\"sidebar\">']\n prevLevel = 0\n for parent in self.selectedNodes:\n for node, level in parent.levelDescendantGen(ExportDialog.\n includeRoot,\n ExportDialog.\n navPaneLevels,\n ExportDialog.\n openOnly):\n if level > prevLevel:\n lines.append('<div>')\n while level < prevLevel:\n lines.append('</div>')\n prevLevel -= 1\n lines.append('• <a href=\"#{0}\">{1}</a><br />'.\n format(node.uniqueId, node.title()))\n prevLevel = level\n while level > 0:\n lines.append('</div>')\n level -= 1\n lines.extend(['</div>', '<div id=\"content\">'])\n if ExportDialog.addHeader:\n headerText = (globalref.mainControl.activeControl.printData.\n formatHeaderFooter(True))\n if headerText:\n lines.append(headerText)\n lines.extend(outputGroup.getLines())\n if ExportDialog.addHeader:\n footerText = (globalref.mainControl.activeControl.printData.\n formatHeaderFooter(False))\n if footerText:\n lines.append(footerText)\n lines.extend(['</div>', '</body>', '</html>'])\n with open(filePath, 'w', encoding='utf-8') as f:\n f.writelines([(line + '\\n') for line in lines])\n return True","def get_xml(self):\n profile = self.profile\n version = self.version\n #self.attribs['xmlns'] = \"http://www.w3.org/2000/svg\"\n self.attribs['xmlns:xlink'] = \"http://www.w3.org/1999/xlink\"\n self.attribs['xmlns:ev'] = \"http://www.w3.org/2001/xml-events\"\n\n self.attribs['baseProfile'] = profile\n self.attribs['version'] = version\n return super(Drawing, self).get_xml()","def serialize(self, root):","def settings(self):\r\n return settings.Settings(self)","def export_html(self, model_view='gapd'):\n '''\n <?xml version=\"1.0\" ?>\n <ROWSET>\n <ROW>\n <SURVEYID>921</SURVEYID>\n <SURVEYNAME>Goomalling, WA, 1996</SURVEYNAME>\n <STATE>WA</STATE>\n <OPERATOR>Stockdale Prospecting Ltd.</OPERATOR>\n <CONTRACTOR>Kevron Geophysics Pty Ltd</CONTRACTOR>\n <PROCESSOR>Kevron Geophysics Pty Ltd</PROCESSOR>\n <SURVEY_TYPE>Detailed</SURVEY_TYPE>\n <DATATYPES>MAG,RAL,ELE</DATATYPES>\n <VESSEL>Aero Commander</VESSEL>\n <VESSEL_TYPE>Plane</VESSEL_TYPE>\n <RELEASEDATE/>\n <ONSHORE_OFFSHORE>Onshore</ONSHORE_OFFSHORE>\n <STARTDATE>05-DEC-96</STARTDATE>\n <ENDDATE>22-DEC-96</ENDDATE>\n <WLONG>116.366662</WLONG>\n <ELONG>117.749996</ELONG>\n <SLAT>-31.483336</SLAT>\n <NLAT>-30.566668</NLAT>\n <LINE_KM>35665</LINE_KM>\n <TOTAL_KM/>\n <LINE_SPACING>250</LINE_SPACING>\n <LINE_DIRECTION>180</LINE_DIRECTION>\n <TIE_SPACING/>\n <SQUARE_KM/>\n <CRYSTAL_VOLUME>33.6</CRYSTAL_VOLUME>\n <UP_CRYSTAL_VOLUME>4.2</UP_CRYSTAL_VOLUME>\n <DIGITAL_DATA>MAG,RAL,ELE</DIGITAL_DATA>\n <GEODETIC_DATUM>WGS84</GEODETIC_DATUM>\n <ASL/>\n <AGL>60</AGL>\n <MAG_INSTRUMENT>Scintrex CS2</MAG_INSTRUMENT>\n <RAD_INSTRUMENT>Exploranium GR820</RAD_INSTRUMENT>\n </ROW>\n </ROWSET>\n '''\n if model_view == 'prov':\n prov_turtle = self.export_rdf('prov', 'text/turtle')\n g = Graph().parse(data=prov_turtle, format='turtle')\n\n view_html = render_template(\n 'survey_prov.html',\n visjs=self._make_vsjs(g),\n prov_turtle=prov_turtle,\n )\n else: # model_view == 'gapd':\n view_html = render_template(\n 'survey_gapd.html',\n survey_no=self.survey_no,\n survey_name=self.survey_name,\n state=self.state,\n operator=self.operator,\n contractor=self.contractor,\n processor=self.processor,\n survey_type=self.survey_type,\n data_types=self.data_types,\n vessel=self.vessel,\n vessel_type=self.vessel_type,\n release_date=self.release_date,\n onshore_offshore=self.onshore_offshore,\n start_date=self.start_date,\n end_date=self.end_date,\n line_km=self.line_km,\n total_km=self.total_km,\n line_spacing=self.line_spacing,\n line_direction=self.line_direction,\n tie_spacing=self.tie_spacing,\n area=self.square_km,\n crystal_volume=self.crystal_volume,\n up_crystal_volume=self.up_crystal_volume,\n digital_data=self.digital_data,\n geodetic_datum=self.geodetic_datum,\n asl=self.asl,\n agl=self.agl,\n mag_instrument=self.mag_instrument,\n rad_instrument=self.rad_instrument,\n wkt_polygon=self.wkt_polygon\n )\n\n return render_template(\n 'page_survey.html',\n view_html=view_html,\n survey_no=self.survey_no,\n end_date=self.end_date,\n survey_type=self.survey_type,\n date_now=datetime.now().strftime('%Y-%m-%d'),\n centroid_lat=self.centroid_lat,\n centroid_lon=self.centroid_lon,\n n_lat=self.n_lat,\n s_lat=self.s_lat,\n w_long=self.w_long,\n e_long=self.e_long,\n gm_key=config.GOOGLE_MAPS_API_KEY\n )","def __str__(self):\n result = xml.dom.minidom.parseString(\n xml.etree.ElementTree.tostring(\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\n\n return result","def project_settings(request):\n webnode_settings = kakocase_settings(request)\n webnode_settings['settings']['IS_WEBNODE'] = True\n return webnode_settings","def build(self):\n root = ET.Element(\"html\", xmlns=self.xmlns)\n self.build_head(root)\n self.build_body(root)\n return root","def save_settings(self, plugin_settings, instance_settings):\n instance_settings.set_value(\"output_directory\", self.output_directory)\n instance_settings.set_value(\"labels\", self.labels)\n if self._sub:\n instance_settings.set_value(\"topic_name\", self._sub.name)","def pretty_print_content(self):\n\n return lxml.etree.tostring(self.get_content(),\n pretty_print = True,\n encoding = self.encoding,\n xml_declaration = True)","def settings() -> Settings:\n return Settings()","def settings(self) -> Any:\n self.ensure_initialized()\n return SettingsItem(self._data, self, FragmentPath())","def saveSettings():\t\n\tglobal settings\n\tfout = open(config_file,'w')\n\tfout.write(json.dumps(settings, sort_keys=True, indent=4))\n\tfout.close()","def exportMasterLayerSettings(self):\n\t\tmaster = rlayer.RenderLayer( 'defaultRenderLayer' )\n\t\tmaster.makeCurrent()\n\t\tmasterData = {}\n\t\tnodes = ['defaultArnoldRenderOptions','defaultResolution','defaultRenderGlobals']\n\t\tmnNodes =[ mn.Node( n ) for n in nodes ]\n\t\tfor n in mnNodes:\n\t\t\tfor a in n.listAttr( se = True, v = True, w = True ):\n\t\t\t\ttry:\n\t\t\t\t\tmasterData[a] = a.v\n\t\t\t\texcept:\n\t\t\t\t\tcontinue\n\t\tpickle.dump( masterData, open( self.masterPath.path, \"wb\" ) )","def __repr__(self):\n string = ''\n for key, val in self.setting().items():\n string += '{}({})\\n'.format(key, val)\n return string","def _ds(elem):\n _indent(elem)\n return ElementTree.tostring(elem)","def AddElement(self):\n if not self.exportStructureViewer:\n raise TypeError(\"Please connect the shot processor's export \"\n \"structure viewer to this header instance.\")\n \n # Don't discard double slashes at end to allow for unnamed nodes.\n segments = [seg for seg in self.nodePathEdit.text().split('/')]\n hostname = SplitHostname(segments[0])[0] # drop \"IFFFS\"\n \n # Require a clip name\n # NOTE: The actual path requirements for uploading to a Wiretap IFFFS\n # server are more strict, but path validation happens elsewhere.\n clipName = self.clipNameEdit.text().strip()\n if clipName:\n segments.append(clipName)\n elementPath = Path.Join(hostname, *segments[1:])\n \n # Populate export structure\n root = self.exportTemplate.rootElement()\n if clipName:\n root.createChild(elementPath, True)\n leaf = root[elementPath]\n \n # Add preset to leaf element\n # NOTE: Be sure to update the string representation of the Stonify\n # task if the module or class name changes.\n preset = FnStonify.StonifyPreset(name='FnStonify.StonifyTask',\n properties={})\n if leaf is not None:\n leaf.setPreset(preset)\n else:\n print(\"WARNING: Unable to set Stonify content on element \" +\n elementPath)\n elif elementPath:\n root.createChild(elementPath, False)\n\n self.exportStructureViewer.refresh()","def toXML(self):\n return _libsbml.Layout_toXML(self)","def createxmlmall():\r\n\r\n root = ET.Element(\"state\")\r\n model = ET.SubElement(root, \"model\")\r\n model.text = r\"\"\r\n\r\n dataid = ET.SubElement(root, \"dataids\")\r\n application = ET.SubElement(root, \"application\")\r\n\r\n application.text = \"SIBS Configurator\"\r\n safecookie = ET.SubElement(root, \"safecookie\")\r\n steps = ET.SubElement(root, \"steps\")\r\n prev = ET.SubElement(steps, \"prev\")\r\n\r\n lastproxy = ET.SubElement(root, \"last-proxy\").text = \"tcserver0\"\r\n\r\n tree = ET.ElementTree(root) # saves tree in variable \"tree\"\r\n return tree, safecookie, steps, prev","def write(self):\r\n for prop in self.prpnames:\r\n elem = SubElement(self._root, prop)\r\n data = self.__getattribute__(prop)\r\n if self.prpnames[prop]['type'] == \"text\":\r\n elem.text = data\r\n elif self.prpnames[prop]['type'] == 'list':\r\n for x in data:\r\n SubElement(elem, 'regel').text = x\r\n elif self.prpnames[prop]['type'] == 'attr':\r\n elem.set(self.prpnames[prop]['naam'], data)\r\n tree = ElementTree(self._root)\r\n tree.write(self._fn)\r\n if not self.exists:\r\n self.exists = True","def htmlNodeDumpFileFormat(self, out, cur, encoding, format):\n if cur is None: cur__o = None\n else: cur__o = cur._o\n ret = libxml2mod.htmlNodeDumpFileFormat(out, self._o, cur__o, encoding, format)\n return ret","def toXMLString(self):\n return _libsbml.XMLNode_toXMLString(self)","def write_view_settings(self, key, settings=None):\n logger.debug(\"Writing view settings for: {}\".format(key))"],"string":"[\n \"def _exportNode(self):\\n node = self._extractProperties()\\n self._logger.info('settings exported.')\\n return node\",\n \"def saveToXml(self) -> org.jdom.Element:\\n ...\",\n \"def to_xml(self):\\r\\n element = ET.Element(\\\"node\\\")\\r\\n\\r\\n element.attrib['name'] = self.name\\r\\n element.attrib['description'] = self.description\\r\\n\\r\\n return element\",\n \"def get_dom(self) -> str:\\n\\n if self.is_running:\\n return self.dumps()\\n\\n if self.dom is not None:\\n return self.dom\\n\\n dom = self.dumps()\\n self.dom = dom\\n return dom\",\n \"def getXML(self):\\n\\n def _getElementForMappingEntry(entry, mappingStyle):\\n xmlDocTmp = Document()\\n element = xmlDocTmp.createElement(mappingStyle)\\n for k, v in viewitems(entry):\\n # ignore empty, None or compiled regexp items into output\\n if not v or (k == \\\"path-match-expr\\\"):\\n continue\\n element.setAttribute(k, str(v))\\n return element\\n\\n xmlDoc = Document()\\n root = xmlDoc.createElement(\\\"storage-mapping\\\") # root element name\\n for mappingStyle, mappings in viewitems(self):\\n for mapping in mappings:\\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\\n root.appendChild(mapElem)\\n return root.toprettyxml()\",\n \"def quick_set_html_conversion_settings(self):\\n self.logger.debug(\\\"HTML conversion settings\\\")\\n self.export_format = 'html'\\n self.quick_setting = 'html'\\n self.front_matter_format = 'yaml'\\n self.metadata_schema = []\\n if self.conversion_input == 'nsx':\\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\\n self.spaces_in_tags = False\\n self.split_tags = False\\n self.first_row_as_header = True\\n self.first_column_as_header = True\\n self.chart_image = True\\n self.chart_csv = True\\n self.chart_data_table = True\",\n \"def to_xml(self) -> str:\\n # default name and stuff setup\\n element_root, xml_tree = super()._add_basics()\\n element_root = element_root.find('elementProp')\\n element_root = element_root.find('collectionProp')\\n for element in list(element_root):\\n try:\\n if element.attrib['name'] == 'influxdbUrl':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.influx_db_url:\\n elem.text = self.influx_db_url\\n elif element.attrib['name'] == 'application':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.application:\\n elem.text = self.application\\n elif element.attrib['name'] == 'measurement':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.measurement:\\n elem.text = self.application\\n elif element.attrib['name'] == 'summaryOnly':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value':\\n elem.text = str(self.summary_only).lower()\\n elif element.attrib['name'] == 'samplersRegex':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.samplers_regexp:\\n elem.text = self.samplers_regexp\\n elif element.attrib['name'] == 'percentiles':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.percentiles:\\n elem.text = self.percentiles\\n elif element.attrib['name'] == 'testTitle':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.test_title:\\n elem.text = self.test_title\\n elif element.attrib['name'] == 'eventTags':\\n for elem in list(element):\\n if elem.attrib['name'] == 'Argument.value' and self.event_tags:\\n elem.text = self.event_tags\\n except Exception:\\n raise Exception(f'Unable to render xml from {type(self).__class__}')\\n return tree_to_str(xml_tree, hashtree=True)\",\n \"def write(self):\\n temp_string = minidom.parseString(ET.tostring(self.root)).toprettyxml(encoding=\\\"UTF-8\\\")\\n with open(self.xml_file, 'w') as f:\\n f.write(temp_string)\\n # f = open(self.xml_file, \\\"w\\\")\\n # f.write(temp_string)\\n # f.close()\",\n \"def exportElements(self):\\n fname = os.path.join(\\\".\\\", \\\"atoms-exported.IN\\\")\\n fname = QtWidgets.QFileDialog.getSaveFileName(self, \\\"Atoman - Export element properties\\\", fname,\\n \\\"IN files (*.IN)\\\",\\n options=QtWidgets.QFileDialog.DontUseNativeDialog)[0]\\n\\n if fname:\\n if \\\".\\\" not in fname or fname[-3:] != \\\".IN\\\":\\n fname += \\\".IN\\\"\\n\\n self.logger.info(\\\"Exporting elements settings to '%s'\\\", fname)\\n elements.write(fname)\",\n \"def toxml(self) :\\n\\t\\treturn self.doc.toxml()\",\n \"def config_html(output_file=''):\\n if output_file:\\n f = open(output_file, 'w')\\n else:\\n f = sys.stdout\\n create_config_html(f)\",\n \"def dump(self, path, mode='standalone'):\\n if mode == 'standalone':\\n with open(path+\\\"/export_grid_standalone\\\"+str(self._id)+\\\".html\\\", 'w+') as f:\\n f.write(self.export_html(build=True))\\n elif mode == 'all':\\n widget_export = self.export_html(build=False)\\n with open(path+\\\"/export_scripts.html\\\", \\\"w+\\\") as f:\\n f.write(widget_export['script_tags'])\\n with open(path+\\\"/export_html_state.html\\\", \\\"w+\\\") as f:\\n f.write(widget_export['html_state'])\\n with open(path+\\\"/export_state_\\\"+str(self._id)+\\\".json\\\", \\\"w+\\\") as f:\\n f.write(json.dumps(widget_export['manager_state']))\\n with open(path+\\\"/export_grid_\\\"+str(self._id)+\\\".html\\\", \\\"w+\\\") as f:\\n f.write(widget_export['grid_div'])\",\n \"def get_xml(self):\\n with io.StringIO() as string:\\n string.write(ET.tostring(self.root, encoding=\\\"unicode\\\"))\\n return string.getvalue()\",\n \"def settings_view():\\n return template('settings.html')\",\n \"def save(self):\\n with self.open(self.filename, 'wt') as fd:\\n for node in self.elements:\\n fd.write(node.text)\",\n \"def to_etree(self):\\n\\n # Format connections\\n text = []\\n for i in range(self.width):\\n if i in self.connections:\\n text.append(str(self.connections[i]))\\n else:\\n text.append(\\\"open\\\")\\n\\n elem = ET.Element(\\\"port\\\", attrib={\\\"name\\\": self.name})\\n elem.text = \\\" \\\".join(text)\\n return elem\",\n \"def xml(self):\\n rough_string = ElementTree.tostring(self.dom, \\\"utf-8\\\")\\n reparsed = minidom.parseString(rough_string)\\n return reparsed.toprettyxml(indent=\\\" \\\")\",\n \"def xml(self, indent):\\n if self.__commentOut:\\n prefix = \\\"<!--\\\"\\n suffix = \\\" -->\\\"\\n else:\\n prefix = \\\"\\\"\\n suffix = \\\"\\\"\\n hubs = self.__stringMap.keys()\\n if self.OMIT_HUB_NUMBER or len(hubs) != 1:\\n nStr = \\\"\\\"\\n else:\\n nStr = \\\" hub=\\\\\\\"%d\\\\\\\"\\\" % hubs[0]\\n return \\\"%s%s<domConfigList%s>%s</domConfigList>%s\\\" % \\\\\\n (prefix, indent, nStr, self.__fileName, suffix)\",\n \"def __init__(self, settings_xml):\\n # The list of setting ids.\\n #\\n # XXX This is redundant. We could just get the ids from\\n # getting the values of any of our dicts.\\n #\\n self.ids = []\\n self.values = { }\\n self.types = { }\\n self.defaults = { }\\n self.labels = { }\\n\\n if settings_xml:\\n dom = parseString(settings_xml)\\n s = dom.firstChild\\n\\n setting = first_child(s, \\\"setting\\\")\\n while setting:\\n setting_id = setting.getAttribute(\\\"id\\\")\\n\\n # I know the 'sep' setting has no id. I am not sure what it is\\n # used for so I am just going to skip it.\\n #\\n if setting_id != \\\"\\\":\\n self.ids.append(setting_id)\\n self.labels[setting_id] = setting.getAttribute(\\\"label\\\")\\n self.types[setting_id] = setting.getAttribute(\\\"type\\\")\\n\\n # For bool's actually set the default value to True or\\n # False. otherwise it is all strings to us.\\n #\\n default = setting.getAttribute(\\\"default\\\")\\n if self.types[setting_id] == \\\"bool\\\":\\n self.defaults[setting_id] = (default.lower() == 'true')\\n else:\\n self.defaults[setting_id] = default\\n\\n # Settings start out with their default value.\\n #\\n self.values[setting_id] = self.defaults[setting_id]\\n setting = next_sibling(setting, \\\"setting\\\")\\n\\n dom.unlink()\\n dom = None\\n\\n # There is always an 'override' setting - \\\"override\\\", which is\\n # set based on the Language Override setting in the scraper.\\n #\\n if 'override' not in self.ids:\\n self.ids.append(\\\"override\\\")\\n self.values[\\\"override\\\"] = False\\n self.types[\\\"override\\\"] = \\\"bool\\\"\\n self.defaults[\\\"override\\\"] = False\\n self.labels[\\\"override\\\"] = \\\"Language Override\\\"\\n\\n # The default language for now is english!\\n #\\n if 'language' not in self.ids:\\n self.ids.append(\\\"language\\\")\\n self.values[\\\"language\\\"] = \\\"en\\\"\\n self.types[\\\"language\\\"] = \\\"string\\\"\\n self.defaults[\\\"language\\\"] = \\\"en\\\"\\n self.labels[\\\"language\\\"] = \\\"Language\\\"\\n\\n return\",\n \"def __repr__(self) -> str:\\n view = {\\n \\\"server\\\": self.server,\\n \\\"access-token\\\": 'yes' if self.token is not None else 'no',\\n \\\"insecure\\\": self.insecure,\\n \\\"output\\\": self.output,\\n \\\"verbose\\\": self.verbose,\\n }\\n\\n return \\\"<Configuration({})\\\".format(view)\",\n \"def create_dd_settings(xml_document, parent_element):\\n dd_properties_element = xml_document.createElement(\\\"dd_properties\\\")\\n parent_element.appendChild(dd_properties_element)\\n\\n option_element = xml_document.createElement(\\\"Option\\\")\\n option_element.setAttribute('type', 'Map')\\n dd_properties_element.appendChild(option_element)\\n\\n option_child1_element = xml_document.createElement(\\\"Option\\\")\\n option_child1_element.setAttribute('type', 'QString')\\n option_child1_element.setAttribute('name', 'name')\\n option_child1_element.setAttribute('value', '')\\n option_element.appendChild(option_child1_element)\\n\\n option_child2_element = xml_document.createElement(\\\"Option\\\")\\n option_child2_element.setAttribute('name', 'properties')\\n option_element.appendChild(option_child2_element)\\n\\n option_child3_element = xml_document.createElement(\\\"Option\\\")\\n option_child3_element.setAttribute('type', 'QString')\\n option_child3_element.setAttribute('name', 'type')\\n option_child3_element.setAttribute('value', 'collection')\\n option_element.appendChild(option_child3_element)\",\n \"def export(self, package):\\n self.style = package.style\\n self.copyFiles(package)\\n self.html = self.renderHeader(package.name)\\n self.html += u\\\"<body>\\\\n\\\"\\n self.html += u\\\"<div id=\\\\\\\"content\\\\\\\">\\\\n\\\"\\n self.html += u\\\"<div id=\\\\\\\"header\\\\\\\">\\\\n\\\"\\n self.html += escape(package.title)\\n self.html += u\\\"</div>\\\\n\\\"\\n self.html += u\\\"<div id=\\\\\\\"main\\\\\\\">\\\\n\\\"\\n self.renderNode(package.root)\\n self.html += u\\\"</div>\\\\n\\\"\\n self.html += u\\\"</div>\\\\n\\\"\\n self.html += u\\\"</body></html>\\\\n\\\"\\n self.save(self.outputDir/\\\"index.html\\\")\",\n \"def setup_render(\\n self, options: Dict[str, Any], env: MutableMapping[str, Any]\\n ) -> None:\\n self.md_env = env\\n self.config: Dict[str, Any] = options\\n self.document: nodes.document = self.config.get(\\\"document\\\", make_document())\\n self.current_node: nodes.Element = self.config.get(\\n \\\"current_node\\\", self.document\\n )\\n self.reporter: Reporter = self.document.reporter\\n # note there are actually two possible language modules:\\n # one from docutils.languages, and one from docutils.parsers.rst.languages\\n self.language_module_rst: ModuleType = get_language_rst(\\n self.document.settings.language_code\\n )\\n self._level_to_elem: Dict[int, nodes.Element] = {0: self.document}\",\n \"def get_html(self):\\r\\n\\r\\n # these 3 will be used in class methods\\r\\n self.html_id = self.location.html_id()\\r\\n self.html_class = self.location.category\\r\\n\\r\\n self.configuration_json = self.build_configuration_json()\\r\\n params = {\\r\\n 'gst_html': self.substitute_controls(self.render),\\r\\n 'element_id': self.html_id,\\r\\n 'element_class': self.html_class,\\r\\n 'configuration_json': self.configuration_json\\r\\n }\\r\\n content = self.system.render_template(\\r\\n 'graphical_slider_tool.html', params\\r\\n )\\r\\n return content\",\n \"def to_dom_element(self, doc):\\n string = \\\"This should never be printed. - EGCryptoSystem.py\\\"\\n return self.to_stub(string, string).to_dom_element(doc)\",\n \"def build_configuration_json(self):\\r\\n # <root> added for interface compatibility with xmltodict.parse\\r\\n # class added for javascript's part purposes\\r\\n root = '<root class=\\\"{}\\\">{}</root>'.format(\\r\\n self.html_class,\\r\\n self.configuration)\\r\\n return json.dumps(xmltodict.parse(root))\",\n \"def save_settings(self):\\r\\n self.QtSettings.beginGroup(\\\"MainWindow\\\")\\r\\n self.QtSettings.setValue(\\\"geometry\\\",self.saveGeometry())\\r\\n self.QtSettings.setValue(\\\"state\\\",self.saveState())\\r\\n self.QtSettings.endGroup()\\r\\n \\r\\n #save element content\\r\\n self.QtSettings.beginGroup(\\\"Settings\\\")\\r\\n pyguitools.gui_save(self.ui,self.QtSettings)\\r\\n self.QtSettings.endGroup()\",\n \"def build_configuration_json(self):\\n # <root> added for interface compatibility with xmltodict.parse\\n # class added for javascript's part purposes\\n return json.dumps(xmltodict.parse('<root class=\\\"' + self.html_class +\\n '\\\">' + self.configuration + '</root>'))\",\n \"def toXMLNode(self):\\n return _libsbml.SBase_toXMLNode(self)\",\n \"def serialize_settings(node_settings, current_user):\\n user_settings = node_settings.user_settings\\n user_is_owner = user_settings is not None and (\\n user_settings.owner._primary_key == current_user._primary_key\\n )\\n current_user_settings = current_user.get_addon('menbib')\\n rv = {\\n 'nodeHasAuth': node_settings.has_auth,\\n 'userIsOwner': user_is_owner,\\n 'userHasAuth': current_user_settings is not None and current_user_settings.has_auth,\\n 'urls': serialize_urls(node_settings)\\n }\\n if node_settings.has_auth:\\n # Add owner's profile URL\\n rv['urls']['owner'] = web_url_for('profile_view_id',\\n uid=user_settings.owner._primary_key)\\n rv['ownerName'] = user_settings.owner.fullname\\n path = node_settings.folder\\n if path is None:\\n rv['folder'] = {'name': None, 'path': None}\\n else:\\n rv['folder'] = {\\n 'name': 'Menbib' + path,\\n 'path': path\\n }\\n return rv\",\n \"def write_config():\\n\\n e = Element(\\\"Configuration\\\")\\n r = SubElement(e, \\\"RepositoryList\\\")\\n r = SubElement(r, \\\"Repository\\\", name = \\\"default\\\")\\n SubElement(r, \\\"Module\\\").text = args.driver\\n SubElement(r, \\\"TokenLabel\\\").text = args.token_label\\n SubElement(r, \\\"PIN\\\").text = args.pin\\n ElementTree(e).write(args.write_config)\\n args.write_config.flush()\",\n \"def xml(self):\\n raise NotImplementedError('must be implemented by all subclasses')\",\n \"def addOutputsNode():\\n return render_template(\\\"addOutputsNode.html\\\")\",\n \"def write(self, fd):\\n indent = \\\" \\\"\\n in2 = indent + indent\\n print >>fd, \\\"<?xml version=\\\\\\\"1.0\\\\\\\" encoding=\\\\\\\"UTF-8\\\\\\\"?>\\\"\\n if self.__topComment is not None:\\n print >>fd, \\\"<!--%s-->\\\" % self.__topComment\\n print >>fd, \\\"<runConfig>\\\"\\n for d in self.__domCfgList:\\n print >>fd, d.xml(indent)\\n for n in self.__domCfgNames:\\n print >>fd, n.xml(indent)\\n if self.__replayBaseDir is not None:\\n print >>fd, \\\"%s<hubFiles baseDir=\\\\\\\"%s\\\\\\\">\\\" % \\\\\\n (indent, self.__replayBaseDir)\\n for r in self.__replayHubList:\\n print >>fd, r.xml(in2)\\n print >>fd, \\\"%s</hubFiles>\\\" % indent\\n print >>fd, \\\"%s<triggerConfig>%s</triggerConfig>\\\" % \\\\\\n (indent, self.__trigCfg)\\n for c in self.__comps:\\n if not c.isHub():\\n print >>fd, \\\"%s<runComponent name=\\\\\\\"%s\\\\\\\"/>\\\" % \\\\\\n (indent, c.name())\\n\\n if self.__strayStream is not None:\\n (name, prescale) = self.__strayStream\\n in3 = in2 + indent\\n\\n print >>fd, \\\"%s<stream name=\\\\\\\"%s\\\\\\\">\\\" % (in2, name)\\n print >>fd, \\\"%s<prescale>%d</prescale>\\\" % (in3, prescale)\\n print >>fd, \\\"%s</stream>\\\" % in2\\n\\n if self.__senderOption is not None:\\n (hub, fwdIsolatedHits) = self.__senderOption\\n fwdName = \\\"forwardIsolatedHitsToTrigger\\\"\\n if fwdIsolatedHits:\\n fwdVal = \\\"true\\\"\\n else:\\n fwdVal = \\\"false\\\"\\n\\n in3 = in2 + indent\\n in4 = in3 + indent\\n\\n print >>fd, \\\"%s<stringHub hubId=\\\\\\\"%d\\\\\\\">\\\" % (in2, hub)\\n print >>fd, \\\"%s<sender>\\\" % in3\\n print >>fd, \\\"%s<%s>%s</%s>\\\" % (in4, fwdName, fwdVal, fwdName)\\n print >>fd, \\\"%s</sender>\\\" % in3\\n print >>fd, \\\"%s</stringHub>\\\" % in2\\n\\n print >>fd, \\\"</runConfig>\\\"\",\n \"def write_settings(f, settings, name, embedded_flag):\\n f.write(\\\"// Define settings structure\\\\n\\\")\\n f.write(\\\"OSQPSettings %s = {\\\" % name)\\n f.write(\\\"(c_float)%.20f, \\\" % settings['rho'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['sigma'])\\n f.write(\\\"%d, \\\" % settings['scaling'])\\n\\n # EMBEDDED == 2\\n if embedded_flag != 1:\\n f.write(\\\"%d, \\\" % settings['scaling_iter'])\\n\\n f.write(\\\"%d, \\\" % settings['max_iter'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['eps_abs'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['eps_rel'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['eps_prim_inf'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['eps_dual_inf'])\\n f.write(\\\"(c_float)%.20f, \\\" % settings['alpha'])\\n\\n f.write(\\\"%d, \\\" % settings['scaled_termination'])\\n f.write(\\\"%d, \\\" % settings['early_terminate'])\\n f.write(\\\"%d, \\\" %\\n settings['early_terminate_interval'])\\n f.write(\\\"%d\\\" % settings['warm_start'])\\n\\n f.write(\\\"};\\\\n\\\\n\\\")\",\n \"def to_dom_element(self, doc): # pragma: no cover\\n cs_scheme_element = doc.createElement(\\\"CryptoSystemScheme\\\")\\n \\n nbits_element = doc.createElement(\\\"nbits\\\")\\n nbits_element.appendChild(doc.createTextNode(str(self.nbits)))\\n cs_scheme_element.appendChild(nbits_element)\\n \\n prime_element = doc.createElement(\\\"prime\\\")\\n prime_str = hex(self.prime)[2:] # Remove leading '0x'\\n if(prime_str[-1] == 'L'): \\n prime_str = prime_str[0:-1] # Remove trailing 'L'\\n prime_element.appendChild(doc.createTextNode(prime_str))\\n cs_scheme_element.appendChild(prime_element)\\n \\n generator_element = doc.createElement(\\\"generator\\\")\\n generator_str = hex(self.generator)[2:] # Remove leading '0x'\\n if(generator_str[-1] == 'L'): \\n generator_str = generator_str[0:-1] # Remove trailing 'L'\\n generator_element.appendChild(doc.createTextNode(generator_str))\\n cs_scheme_element.appendChild(generator_element)\\n \\n return cs_scheme_element\",\n \"def export_to_file(self, filename):\\n if len(filename.split(\\\".\\\")) == 1:\\n filename += \\\".xml\\\"\\n xmlstring = self._dommodel.toprettyxml(\\\" \\\", \\\"\\\\n\\\")\\n with open(filename, \\\"w\\\") as f:\\n f.write(xmlstring)\",\n \"def showSettings():\\n cq = dz()\\n cq.abag()\",\n \"def render_settings_view():\\n return render_template('settings_screen.html', realsense_device_status=realsense_enabled, detector_enabled=enabled_detector)\",\n \"def get_xml(self):\\n return etree.tostring(self.get_etree())\",\n \"def node():\\n return render_template('nodes.html')\",\n \"def get_settings(self):\\n return self.request({\\n \\\"path\\\": \\\"/\\\" + UUID + \\\"/setting\\\"\\n })\",\n \"def exportHtmlSingle(self, filePath=''):\\n if not filePath:\\n filePath = self.getFileName(_('TreeLine - Export HTML'), 'html')\\n if not filePath:\\n return False\\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\\n if ExportDialog.exportWhat == ExportDialog.entireTree:\\n self.selectedNodes = [self.rootNode]\\n outputGroup = treeoutput.OutputGroup(self.selectedNodes,\\n ExportDialog.includeRoot,\\n ExportDialog.exportWhat !=\\n ExportDialog.selectNode,\\n ExportDialog.openOnly, True)\\n outputGroup.addBlanksBetween()\\n outputGroup.addIndents()\\n outputGroup.addSiblingPrefixes()\\n outGroups = outputGroup.splitColumns(ExportDialog.numColumns)\\n htmlTitle = os.path.splitext(os.path.basename(filePath))[0]\\n indent = globalref.genOptions.getValue('IndentOffset')\\n lines = ['<!DOCTYPE html PUBLIC \\\"-//W3C//DTD HTML 4.01 '\\n 'Transitional//EN\\\">', '<html>', '<head>',\\n '<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; '\\n 'charset=utf-8\\\">', '<title>{0}</title>'.format(htmlTitle),\\n '<style type=\\\"text/css\\\"><!--',\\n 'div {{margin-left: {0}em}}'.format(indent),\\n 'td {padding: 10px}', 'tr {vertical-align: top}',\\n '--></style>', '</head>', '<body>']\\n if ExportDialog.addHeader:\\n headerText = (globalref.mainControl.activeControl.printData.\\n formatHeaderFooter(True))\\n if headerText:\\n lines.append(headerText)\\n lines.extend(['<table>', '<tr><td>'])\\n lines.extend(outGroups[0].getLines())\\n for group in outGroups[1:]:\\n lines.append('</td><td>')\\n lines.extend(group.getLines())\\n lines.extend(['</td></tr>', '</table>'])\\n if ExportDialog.addHeader:\\n footerText = (globalref.mainControl.activeControl.printData.\\n formatHeaderFooter(False))\\n if footerText:\\n lines.append(footerText)\\n lines.extend(['</body>', '</html>'])\\n with open(filePath, 'w', encoding='utf-8') as f:\\n f.writelines([(line + '\\\\n') for line in lines])\\n return True\",\n \"def to_xml(self, scene_dir: str) -> Tuple[Et.Element, bool]:\\n raise NotImplementedError\",\n \"def _save_settings(self):\\n # data to be save :\\n # -----------------\\n # futurePivot node\\n\\n # create attributes\\n self._create_data_attribute()\\n\\n # connect futurePivot node\\n pm.connectAttr(\\n \\\"%s%s\\\" % (self._futurePivot.name(), \\\".message\\\"),\\n self._object.attr(\\\"pivotData.futurePivot\\\"),\\n f=True,\\n )\",\n \"def view_to_config(self):\\n raise NotImplementedError\",\n \"def node_config():\\r\\n paragraph = document.add_paragraph('')\\r\\n document.add_heading('Server node details', 1)\\r\\n node_metrics = ['host name','central','purpose', 'engine', 'proxy', 'printing', 'scheduler']\\r\\n nodes = get_qlik_sense.get_nodeconfig()\\r\\n num_of_nodes = len(nodes)\\r\\n num_of_node_metrics = len(node_metrics)\\r\\n table = document.add_table(rows=num_of_node_metrics+1, cols=num_of_nodes+1)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'Metric'\\r\\n for item in range(0, num_of_nodes):\\r\\n row.cells[item+1].text = nodes[item][7]\\r\\n for item in range(num_of_node_metrics):\\r\\n row = table.rows[item+1]\\r\\n row.cells[0].text = str(node_metrics[item])\\r\\n\\r\\n for node in range(num_of_nodes):\\r\\n row.cells[node+1].text = str(nodes[node][item])\\r\\n document.add_page_break()\",\n \"def generateXML(self):\\n return self.formatEval(\\n self.TEMPLATES[self.attrs['name']]['XML'],\\n self.attrs\\n )\",\n \"def dom(self):\\n raise NotImplementedError(\\\"base class called\\\")\",\n \"def build_settings(self, settings):\\n \\n settings.add_json_panel(\\\"Network\\\", self.config, data=network_json)\\n settings.add_json_panel(\\\"Camera\\\", self.config, data=camera_json)\\n settings.add_json_panel(\\\"CV\\\", self.config, data=cv_json)\\n settings.add_json_panel(\\\"Admin\\\", self.config, data=admin_json)\",\n \"def load_settings(self):\\n\\n self.std = settings.settings\",\n \"def jssettings(self):\\n self.update()\\n return \\\"var %s = %s\\\" % (self.js_var_settings_name,\\n json.dumps(self.settings))\",\n \"def writeFile(self, filename):\\n s = ET.tostring(self._root)\\n\\n #Remove all formatting\\n s = s.replace('\\\\n','')\\n s = s.replace('\\\\t','')\\n s = s.replace('\\\\r','')\\n\\n f = open(filename, 'w')\\n f.write(minidom.parseString(s).toprettyxml())\\n f.close()\",\n \"def serialize(self):\\n return self.xmlnode.serialize(encoding=\\\"utf-8\\\")\",\n \"def setting():\\n return render_template('setting.html', year=datetime.now().year)\",\n \"def build_settings(self, settings):\\n settings.add_json_panel('Makesmith Settings', self.config, data=self.json)\",\n \"def saveSessionToXML(self, filename):\\r\\n xmlStr = self.createXMLStr()\\r\\n \\r\\n #Write to the file\\r\\n #xml.dom.ext.PrettyPrint(doc, open(filename, 'w'))\\r\\n xmlFile = open(filename, 'w')\\r\\n xmlFile.write(xmlStr)\\r\\n xmlFile.close()\",\n \"def export_html(self, build=False):\\n if build:\\n html = export_html_code(self)\\n return (html['script_tags'] +\\n (html['html_state']).format(manager_state=json.dumps(html['manager_state'])) +\\n html['grid_div'])\\n return export_html_code(self)\",\n \"def print_settings(self, title=None):\\n if title:\\n print(title)\\n print('Contents of imagenode.yaml:')\\n pprint.pprint(self.config)\\n print()\",\n \"def exportHtmlPages(self, filePath=''):\\n if not filePath:\\n filePath = QtGui.QFileDialog.getExistingDirectory(QtGui.\\n QApplication.activeWindow(),\\n _('TreeLine - Export HTML'),\\n self.defaultFilePath)\\n if not filePath:\\n return False\\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\\n oldDir = os.getcwd()\\n os.chdir(filePath)\\n indent = globalref.genOptions.getValue('IndentOffset')\\n cssLines = ['#sidebar {',\\n ' width: 16em;',\\n ' float: left;',\\n ' border-right: 1px solid black;',\\n '}',\\n '#sidebar div {{margin-left: {0}em;}}'.format(indent),\\n '#content {',\\n ' margin-left: 16em;',\\n ' border-left: 1px solid black;',\\n ' padding-left: 6px;',\\n '}']\\n with open('default.css', 'w', encoding='utf-8') as f:\\n f.writelines([(line + '\\\\n') for line in cssLines])\\n if ExportDialog.exportWhat == ExportDialog.entireTree:\\n self.selectedNodes = [self.rootNode]\\n if len(self.selectedNodes) > 1:\\n modelRef = self.selectedNodes[0].modelRef\\n dummyFormat = modelRef.formats.addDummyRootType()\\n root = treenode.TreeNode(None, dummyFormat.name, modelRef)\\n name = os.path.basename(self.defaultFilePath)\\n if not name:\\n name = treemodel.defaultRootName\\n root.setTitle(name)\\n for node in self.selectedNodes:\\n root.childList.append(copy.copy(node))\\n root.childList[-1].parent = root\\n else:\\n root = self.selectedNodes[0]\\n root.exportHtmlPage()\\n root.modelRef.formats.removeDummyRootType()\\n os.chdir(oldDir)\\n return True\",\n \"def writeXml(self):\\n text = u' type=\\\"%s\\\"' % self.typeName\\n if self.format:\\n text += u' format=\\\"%s\\\"' % escape(self.format, treedoc.escDict)\\n if self.prefix:\\n text += u' prefix=\\\"%s\\\"' % escape(self.prefix, treedoc.escDict)\\n if self.suffix:\\n text += u' suffix=\\\"%s\\\"' % escape(self.suffix, treedoc.escDict)\\n if self.html:\\n text += u' html=\\\"y\\\"'\\n if self.isRequired:\\n text += u' required=\\\"y\\\"'\\n if self.hidden:\\n text += u' hidden=\\\"y\\\"'\\n if self.numLines > 1:\\n text += u' lines=\\\"%d\\\"' % self.numLines\\n if self.initDefault:\\n text += u' init=\\\"%s\\\"' % escape(self.initDefault, treedoc.escDict)\\n if self.linkAltField:\\n text += u' linkalt=\\\"%s\\\"' % escape(self.linkAltField,\\n treedoc.escDict)\\n return text\",\n \"def get(self) :\\n self.generate('export.html', {\\n 'xml' : export(),\\n 'title' : \\\"Admin Export\\\"})\",\n \"def save_output_node(out):\\n out_wc = out.clone()\\n return out_wc\",\n \"def writeDoc(self, out, displayOptions=None):\\n if displayOptions is None:\\n displayOptions = {}\\n tw = textwrap.TextWrapper(initial_indent='# ',\\n subsequent_indent='# ', width=70)\\n out.write('# %s (Default: %s)\\\\n' % (self.name,\\n ', '.join(self.valueType.toStrings(self.getDefault(), displayOptions))))\\n if self.doc:\\n out.write('\\\\n'.join(tw.wrap(self.doc)))\\n out.write('\\\\n')\",\n \"def get_html(self):\\n\\n # these 3 will be used in class methods\\n self.html_id = self.location.html_id()\\n self.html_class = self.location.category\\n self.configuration_json = self.build_configuration_json()\\n params = {\\n 'gst_html': self.substitute_controls(self.render),\\n 'element_id': self.html_id,\\n 'element_class': self.html_class,\\n 'configuration_json': self.configuration_json\\n }\\n content = self.system.render_template(\\n 'graphical_slider_tool.html', params)\\n return content\",\n \"def write_to(self, fp):\\n fp.write('<')\\n fp.write(self.tag)\\n for k, v in self.attrs.iteritems():\\n fp.write(' ')\\n fp.write(k),\\n fp.write('=\\\"')\\n fp.write(xml_escape(v))\\n fp.write('\\\"')\\n if len(self.contents) == 0:\\n fp.write(' />')\\n else:\\n fp.write('>')\\n for item in self.contents:\\n if isinstance(item, basestring):\\n item = xml_escape(item)\\n fp.write(item)\\n elif isinstance(item, Markup) or isinstance(item, Element):\\n item.write_to(fp)\\n else:\\n raise TypeError('Item %r must be either a string, '\\n '``Element``, or ``Markup``' % item)\\n fp.write('</')\\n fp.write(self.tag)\\n fp.write('>')\",\n \"def get_xml(self):\\n xml = svgwrite.etree.etree.Element(self.elementname)\\n if self.debug:\\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\\n for attribute, value in self.attribs.items():\\n # filter 'None' values\\n if value is not None:\\n value = self.value_to_string(value)\\n if value: # just add not empty attributes\\n xml.set(attribute, value)\\n \\n for element in self.elements:\\n xml.append(element)\\n return xml\",\n \"def create_html(self):\\n # Add html content to the self.doc\\n self.doc.asis('<!DOCTYPE html>')\\n with self.tag('html'):\\n self.design_header()\\n self.design_body()\\n # Write html content from self.doc\\n with codecs.open(self.filestream.name, 'w', 'utf-8') as f:\\n html_content = indent(\\n self.doc.getvalue(),\\n indentation=' ',\\n newline='\\\\r\\\\n'\\n )\\n f.write(html_content)\",\n \"def SaveSettings(self, settingsFile):\\n with codecs.open(settingsFile, encoding='utf-8-sig', mode='w+') as f:\\n json.dump(self.__dict__, f, encoding='utf-8-sig')\\n with codecs.open(settingsFile.replace(\\\"json\\\", \\\"js\\\"), encoding='utf-8-sig', mode='w+') as f:\\n f.write(\\\"var settings = {0};\\\".format(json.dumps(self.__dict__, encoding='utf-8-sig')))\\n return\",\n \"def XMLWriter(\\n fd,\\n encoding=\\\"utf-8\\\",\\n pretty=True,\\n compactempty=True,\\n indentation=_DEFAULT_INDENTATION\\n):\\n return _document(fd, encoding, pretty, compactempty, indentation)\",\n \"def writeSettings(self):\\n settings = QtCore.QSettings()\\n output_directory = self.ui.outputDirLineEdit.text()\\n settings.setValue(\\\"output_directory\\\", output_directory)\",\n \"def prettify(self):\\n re_parsed = minidom.parseString(tostring(self.dom))\\n return re_parsed.toprettyxml()\",\n \"def export_toml(self): # type: () -> str\\n return self._config_to_toml(self._config, self._toml)\",\n \"def toxml(self) -> ET.Element:\\n # Dummy element that ElementTree extend() will strip\\n root = ET.Element('root')\\n\\n connection = ET.SubElement(root, 'Connection')\\n\\n origin = ET.SubElement(connection, 'Origin')\\n origin.set('ToolID', self.origin_tool.tool_id)\\n origin.set('Connection', self.origin_output)\\n\\n destination = ET.SubElement(connection, 'Destination')\\n destination.set('ToolID', self.destination_tool.tool_id)\\n destination.set('Connection', self.destination_input)\\n\\n return root\",\n \"def htmlNodeDumpFile(self, out, cur):\\n if cur is None: cur__o = None\\n else: cur__o = cur._o\\n libxml2mod.htmlNodeDumpFile(out, self._o, cur__o)\",\n \"def exportZendoc(self,ofile):\\n value = self.getZendoc()\\n if not value: return\\n ofile.write(\\\"<property id='zendoc' type='string'>\\\\n\\\")\\n if not isinstance(value, basestring):\\n value = unicode(value)\\n elif isinstance(value, str):\\n value = value.decode('latin-1')\\n ofile.write(saxutils.escape(value).encode('utf-8')+\\\"\\\\n\\\")\\n ofile.write(\\\"</property>\\\\n\\\")\",\n \"def config_to_view(self):\\n raise NotImplementedError\",\n \"def exportHtmlNavSingle(self, filePath=''):\\n if not filePath:\\n filePath = self.getFileName(_('TreeLine - Export HTML'), 'html')\\n if not filePath:\\n return False\\n QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\\n if ExportDialog.exportWhat == ExportDialog.entireTree:\\n self.selectedNodes = [self.rootNode]\\n outputGroup = treeoutput.OutputGroup(self.selectedNodes,\\n ExportDialog.includeRoot, True,\\n ExportDialog.openOnly, True,\\n ExportDialog.navPaneLevels)\\n outputGroup.addBlanksBetween()\\n outputGroup.addIndents()\\n outputGroup.addSiblingPrefixes()\\n htmlTitle = os.path.splitext(os.path.basename(filePath))[0]\\n indent = globalref.genOptions.getValue('IndentOffset')\\n lines = ['<!DOCTYPE html PUBLIC \\\"-//W3C//DTD HTML 4.01 '\\n 'Transitional//EN\\\">', '<html>', '<head>',\\n '<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; '\\n 'charset=utf-8\\\">', '<title>{0}</title>'.format(htmlTitle),\\n '<style type=\\\"text/css\\\"><!--',\\n ' #sidebar {',\\n ' width: 16em;',\\n ' float: left;',\\n ' border-right: 1px solid black;',\\n ' }',\\n ' #sidebar div {{margin-left: {0}em;}}'.format(indent),\\n ' #content {',\\n ' margin-left: 16em;',\\n ' border-left: 1px solid black;',\\n ' padding-left: 6px;',\\n ' }',\\n ' #content div {{margin-left: {0}em;}}'.format(indent),\\n '--></style>',\\n '</head>', '<body>', '<div id=\\\"sidebar\\\">']\\n prevLevel = 0\\n for parent in self.selectedNodes:\\n for node, level in parent.levelDescendantGen(ExportDialog.\\n includeRoot,\\n ExportDialog.\\n navPaneLevels,\\n ExportDialog.\\n openOnly):\\n if level > prevLevel:\\n lines.append('<div>')\\n while level < prevLevel:\\n lines.append('</div>')\\n prevLevel -= 1\\n lines.append('• <a href=\\\"#{0}\\\">{1}</a><br />'.\\n format(node.uniqueId, node.title()))\\n prevLevel = level\\n while level > 0:\\n lines.append('</div>')\\n level -= 1\\n lines.extend(['</div>', '<div id=\\\"content\\\">'])\\n if ExportDialog.addHeader:\\n headerText = (globalref.mainControl.activeControl.printData.\\n formatHeaderFooter(True))\\n if headerText:\\n lines.append(headerText)\\n lines.extend(outputGroup.getLines())\\n if ExportDialog.addHeader:\\n footerText = (globalref.mainControl.activeControl.printData.\\n formatHeaderFooter(False))\\n if footerText:\\n lines.append(footerText)\\n lines.extend(['</div>', '</body>', '</html>'])\\n with open(filePath, 'w', encoding='utf-8') as f:\\n f.writelines([(line + '\\\\n') for line in lines])\\n return True\",\n \"def get_xml(self):\\n profile = self.profile\\n version = self.version\\n #self.attribs['xmlns'] = \\\"http://www.w3.org/2000/svg\\\"\\n self.attribs['xmlns:xlink'] = \\\"http://www.w3.org/1999/xlink\\\"\\n self.attribs['xmlns:ev'] = \\\"http://www.w3.org/2001/xml-events\\\"\\n\\n self.attribs['baseProfile'] = profile\\n self.attribs['version'] = version\\n return super(Drawing, self).get_xml()\",\n \"def serialize(self, root):\",\n \"def settings(self):\\r\\n return settings.Settings(self)\",\n \"def export_html(self, model_view='gapd'):\\n '''\\n <?xml version=\\\"1.0\\\" ?>\\n <ROWSET>\\n <ROW>\\n <SURVEYID>921</SURVEYID>\\n <SURVEYNAME>Goomalling, WA, 1996</SURVEYNAME>\\n <STATE>WA</STATE>\\n <OPERATOR>Stockdale Prospecting Ltd.</OPERATOR>\\n <CONTRACTOR>Kevron Geophysics Pty Ltd</CONTRACTOR>\\n <PROCESSOR>Kevron Geophysics Pty Ltd</PROCESSOR>\\n <SURVEY_TYPE>Detailed</SURVEY_TYPE>\\n <DATATYPES>MAG,RAL,ELE</DATATYPES>\\n <VESSEL>Aero Commander</VESSEL>\\n <VESSEL_TYPE>Plane</VESSEL_TYPE>\\n <RELEASEDATE/>\\n <ONSHORE_OFFSHORE>Onshore</ONSHORE_OFFSHORE>\\n <STARTDATE>05-DEC-96</STARTDATE>\\n <ENDDATE>22-DEC-96</ENDDATE>\\n <WLONG>116.366662</WLONG>\\n <ELONG>117.749996</ELONG>\\n <SLAT>-31.483336</SLAT>\\n <NLAT>-30.566668</NLAT>\\n <LINE_KM>35665</LINE_KM>\\n <TOTAL_KM/>\\n <LINE_SPACING>250</LINE_SPACING>\\n <LINE_DIRECTION>180</LINE_DIRECTION>\\n <TIE_SPACING/>\\n <SQUARE_KM/>\\n <CRYSTAL_VOLUME>33.6</CRYSTAL_VOLUME>\\n <UP_CRYSTAL_VOLUME>4.2</UP_CRYSTAL_VOLUME>\\n <DIGITAL_DATA>MAG,RAL,ELE</DIGITAL_DATA>\\n <GEODETIC_DATUM>WGS84</GEODETIC_DATUM>\\n <ASL/>\\n <AGL>60</AGL>\\n <MAG_INSTRUMENT>Scintrex CS2</MAG_INSTRUMENT>\\n <RAD_INSTRUMENT>Exploranium GR820</RAD_INSTRUMENT>\\n </ROW>\\n </ROWSET>\\n '''\\n if model_view == 'prov':\\n prov_turtle = self.export_rdf('prov', 'text/turtle')\\n g = Graph().parse(data=prov_turtle, format='turtle')\\n\\n view_html = render_template(\\n 'survey_prov.html',\\n visjs=self._make_vsjs(g),\\n prov_turtle=prov_turtle,\\n )\\n else: # model_view == 'gapd':\\n view_html = render_template(\\n 'survey_gapd.html',\\n survey_no=self.survey_no,\\n survey_name=self.survey_name,\\n state=self.state,\\n operator=self.operator,\\n contractor=self.contractor,\\n processor=self.processor,\\n survey_type=self.survey_type,\\n data_types=self.data_types,\\n vessel=self.vessel,\\n vessel_type=self.vessel_type,\\n release_date=self.release_date,\\n onshore_offshore=self.onshore_offshore,\\n start_date=self.start_date,\\n end_date=self.end_date,\\n line_km=self.line_km,\\n total_km=self.total_km,\\n line_spacing=self.line_spacing,\\n line_direction=self.line_direction,\\n tie_spacing=self.tie_spacing,\\n area=self.square_km,\\n crystal_volume=self.crystal_volume,\\n up_crystal_volume=self.up_crystal_volume,\\n digital_data=self.digital_data,\\n geodetic_datum=self.geodetic_datum,\\n asl=self.asl,\\n agl=self.agl,\\n mag_instrument=self.mag_instrument,\\n rad_instrument=self.rad_instrument,\\n wkt_polygon=self.wkt_polygon\\n )\\n\\n return render_template(\\n 'page_survey.html',\\n view_html=view_html,\\n survey_no=self.survey_no,\\n end_date=self.end_date,\\n survey_type=self.survey_type,\\n date_now=datetime.now().strftime('%Y-%m-%d'),\\n centroid_lat=self.centroid_lat,\\n centroid_lon=self.centroid_lon,\\n n_lat=self.n_lat,\\n s_lat=self.s_lat,\\n w_long=self.w_long,\\n e_long=self.e_long,\\n gm_key=config.GOOGLE_MAPS_API_KEY\\n )\",\n \"def __str__(self):\\n result = xml.dom.minidom.parseString(\\n xml.etree.ElementTree.tostring(\\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\\n\\n return result\",\n \"def project_settings(request):\\n webnode_settings = kakocase_settings(request)\\n webnode_settings['settings']['IS_WEBNODE'] = True\\n return webnode_settings\",\n \"def build(self):\\n root = ET.Element(\\\"html\\\", xmlns=self.xmlns)\\n self.build_head(root)\\n self.build_body(root)\\n return root\",\n \"def save_settings(self, plugin_settings, instance_settings):\\n instance_settings.set_value(\\\"output_directory\\\", self.output_directory)\\n instance_settings.set_value(\\\"labels\\\", self.labels)\\n if self._sub:\\n instance_settings.set_value(\\\"topic_name\\\", self._sub.name)\",\n \"def pretty_print_content(self):\\n\\n return lxml.etree.tostring(self.get_content(),\\n pretty_print = True,\\n encoding = self.encoding,\\n xml_declaration = True)\",\n \"def settings() -> Settings:\\n return Settings()\",\n \"def settings(self) -> Any:\\n self.ensure_initialized()\\n return SettingsItem(self._data, self, FragmentPath())\",\n \"def saveSettings():\\t\\n\\tglobal settings\\n\\tfout = open(config_file,'w')\\n\\tfout.write(json.dumps(settings, sort_keys=True, indent=4))\\n\\tfout.close()\",\n \"def exportMasterLayerSettings(self):\\n\\t\\tmaster = rlayer.RenderLayer( 'defaultRenderLayer' )\\n\\t\\tmaster.makeCurrent()\\n\\t\\tmasterData = {}\\n\\t\\tnodes = ['defaultArnoldRenderOptions','defaultResolution','defaultRenderGlobals']\\n\\t\\tmnNodes =[ mn.Node( n ) for n in nodes ]\\n\\t\\tfor n in mnNodes:\\n\\t\\t\\tfor a in n.listAttr( se = True, v = True, w = True ):\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tmasterData[a] = a.v\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\tpickle.dump( masterData, open( self.masterPath.path, \\\"wb\\\" ) )\",\n \"def __repr__(self):\\n string = ''\\n for key, val in self.setting().items():\\n string += '{}({})\\\\n'.format(key, val)\\n return string\",\n \"def _ds(elem):\\n _indent(elem)\\n return ElementTree.tostring(elem)\",\n \"def AddElement(self):\\n if not self.exportStructureViewer:\\n raise TypeError(\\\"Please connect the shot processor's export \\\"\\n \\\"structure viewer to this header instance.\\\")\\n \\n # Don't discard double slashes at end to allow for unnamed nodes.\\n segments = [seg for seg in self.nodePathEdit.text().split('/')]\\n hostname = SplitHostname(segments[0])[0] # drop \\\"IFFFS\\\"\\n \\n # Require a clip name\\n # NOTE: The actual path requirements for uploading to a Wiretap IFFFS\\n # server are more strict, but path validation happens elsewhere.\\n clipName = self.clipNameEdit.text().strip()\\n if clipName:\\n segments.append(clipName)\\n elementPath = Path.Join(hostname, *segments[1:])\\n \\n # Populate export structure\\n root = self.exportTemplate.rootElement()\\n if clipName:\\n root.createChild(elementPath, True)\\n leaf = root[elementPath]\\n \\n # Add preset to leaf element\\n # NOTE: Be sure to update the string representation of the Stonify\\n # task if the module or class name changes.\\n preset = FnStonify.StonifyPreset(name='FnStonify.StonifyTask',\\n properties={})\\n if leaf is not None:\\n leaf.setPreset(preset)\\n else:\\n print(\\\"WARNING: Unable to set Stonify content on element \\\" +\\n elementPath)\\n elif elementPath:\\n root.createChild(elementPath, False)\\n\\n self.exportStructureViewer.refresh()\",\n \"def toXML(self):\\n return _libsbml.Layout_toXML(self)\",\n \"def createxmlmall():\\r\\n\\r\\n root = ET.Element(\\\"state\\\")\\r\\n model = ET.SubElement(root, \\\"model\\\")\\r\\n model.text = r\\\"\\\"\\r\\n\\r\\n dataid = ET.SubElement(root, \\\"dataids\\\")\\r\\n application = ET.SubElement(root, \\\"application\\\")\\r\\n\\r\\n application.text = \\\"SIBS Configurator\\\"\\r\\n safecookie = ET.SubElement(root, \\\"safecookie\\\")\\r\\n steps = ET.SubElement(root, \\\"steps\\\")\\r\\n prev = ET.SubElement(steps, \\\"prev\\\")\\r\\n\\r\\n lastproxy = ET.SubElement(root, \\\"last-proxy\\\").text = \\\"tcserver0\\\"\\r\\n\\r\\n tree = ET.ElementTree(root) # saves tree in variable \\\"tree\\\"\\r\\n return tree, safecookie, steps, prev\",\n \"def write(self):\\r\\n for prop in self.prpnames:\\r\\n elem = SubElement(self._root, prop)\\r\\n data = self.__getattribute__(prop)\\r\\n if self.prpnames[prop]['type'] == \\\"text\\\":\\r\\n elem.text = data\\r\\n elif self.prpnames[prop]['type'] == 'list':\\r\\n for x in data:\\r\\n SubElement(elem, 'regel').text = x\\r\\n elif self.prpnames[prop]['type'] == 'attr':\\r\\n elem.set(self.prpnames[prop]['naam'], data)\\r\\n tree = ElementTree(self._root)\\r\\n tree.write(self._fn)\\r\\n if not self.exists:\\r\\n self.exists = True\",\n \"def htmlNodeDumpFileFormat(self, out, cur, encoding, format):\\n if cur is None: cur__o = None\\n else: cur__o = cur._o\\n ret = libxml2mod.htmlNodeDumpFileFormat(out, self._o, cur__o, encoding, format)\\n return ret\",\n \"def toXMLString(self):\\n return _libsbml.XMLNode_toXMLString(self)\",\n \"def write_view_settings(self, key, settings=None):\\n logger.debug(\\\"Writing view settings for: {}\\\".format(key))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7224327","0.56396407","0.5610303","0.55762726","0.5313067","0.5309712","0.5301959","0.5281795","0.52664566","0.5236637","0.52181643","0.5208334","0.51855683","0.517911","0.51764274","0.51666445","0.5144142","0.5129619","0.5117044","0.51037055","0.5100118","0.5091269","0.5077694","0.5074275","0.50737214","0.5066217","0.5065415","0.5061878","0.50473577","0.50441843","0.5041363","0.50257874","0.50112456","0.50078577","0.5005025","0.49848586","0.49807614","0.4978994","0.49580222","0.4951547","0.4947395","0.49447188","0.49374518","0.4933343","0.49292153","0.4924695","0.4919242","0.49148557","0.49104267","0.4905973","0.48888797","0.48855475","0.4885398","0.48804998","0.487947","0.48719457","0.48709732","0.48666906","0.4863784","0.48635322","0.4850537","0.48403504","0.4833306","0.4831462","0.48283774","0.48257557","0.48239073","0.48214415","0.4818914","0.48106736","0.47947487","0.47908393","0.4781297","0.47804484","0.47796544","0.47791895","0.47755042","0.4771167","0.47553036","0.474816","0.47373566","0.47362173","0.47340444","0.4718602","0.47069892","0.47052392","0.4702123","0.4696956","0.4691864","0.46890047","0.4684087","0.46839866","0.4680165","0.4678766","0.46738762","0.46735504","0.46687403","0.4667095","0.4666293","0.46644348"],"string":"[\n \"0.7224327\",\n \"0.56396407\",\n \"0.5610303\",\n \"0.55762726\",\n \"0.5313067\",\n \"0.5309712\",\n \"0.5301959\",\n \"0.5281795\",\n \"0.52664566\",\n \"0.5236637\",\n \"0.52181643\",\n \"0.5208334\",\n \"0.51855683\",\n \"0.517911\",\n \"0.51764274\",\n \"0.51666445\",\n \"0.5144142\",\n \"0.5129619\",\n \"0.5117044\",\n \"0.51037055\",\n \"0.5100118\",\n \"0.5091269\",\n \"0.5077694\",\n \"0.5074275\",\n \"0.50737214\",\n \"0.5066217\",\n \"0.5065415\",\n \"0.5061878\",\n \"0.50473577\",\n \"0.50441843\",\n \"0.5041363\",\n \"0.50257874\",\n \"0.50112456\",\n \"0.50078577\",\n \"0.5005025\",\n \"0.49848586\",\n \"0.49807614\",\n \"0.4978994\",\n \"0.49580222\",\n \"0.4951547\",\n \"0.4947395\",\n \"0.49447188\",\n \"0.49374518\",\n \"0.4933343\",\n \"0.49292153\",\n \"0.4924695\",\n \"0.4919242\",\n \"0.49148557\",\n \"0.49104267\",\n \"0.4905973\",\n \"0.48888797\",\n \"0.48855475\",\n \"0.4885398\",\n \"0.48804998\",\n \"0.487947\",\n \"0.48719457\",\n \"0.48709732\",\n \"0.48666906\",\n \"0.4863784\",\n \"0.48635322\",\n \"0.4850537\",\n \"0.48403504\",\n \"0.4833306\",\n \"0.4831462\",\n \"0.48283774\",\n \"0.48257557\",\n \"0.48239073\",\n \"0.48214415\",\n \"0.4818914\",\n \"0.48106736\",\n \"0.47947487\",\n \"0.47908393\",\n \"0.4781297\",\n \"0.47804484\",\n \"0.47796544\",\n \"0.47791895\",\n \"0.47755042\",\n \"0.4771167\",\n \"0.47553036\",\n \"0.474816\",\n \"0.47373566\",\n \"0.47362173\",\n \"0.47340444\",\n \"0.4718602\",\n \"0.47069892\",\n \"0.47052392\",\n \"0.4702123\",\n \"0.4696956\",\n \"0.4691864\",\n \"0.46890047\",\n \"0.4684087\",\n \"0.46839866\",\n \"0.4680165\",\n \"0.4678766\",\n \"0.46738762\",\n \"0.46735504\",\n \"0.46687403\",\n \"0.4667095\",\n \"0.4666293\",\n \"0.46644348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63378537"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":95598,"cells":{"query":{"kind":"string","value":"Import the settings from the DOM node."},"document":{"kind":"string","value":"def _importNode(self, node):\n ZCatalogXMLAdapter._importNode(self, node)\n\n self._logger.info('Person Catalog settings imported.')"},"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 _importNode(self, node):\n if self.environ.shouldPurge():\n self._purgeProperties()\n self._initProperties(node)\n self._logger.info('settings imported.')","def load_settings(self):\n\n self.std = settings.settings","def __init__(self, settings_xml):\n # The list of setting ids.\n #\n # XXX This is redundant. We could just get the ids from\n # getting the values of any of our dicts.\n #\n self.ids = []\n self.values = { }\n self.types = { }\n self.defaults = { }\n self.labels = { }\n\n if settings_xml:\n dom = parseString(settings_xml)\n s = dom.firstChild\n\n setting = first_child(s, \"setting\")\n while setting:\n setting_id = setting.getAttribute(\"id\")\n\n # I know the 'sep' setting has no id. I am not sure what it is\n # used for so I am just going to skip it.\n #\n if setting_id != \"\":\n self.ids.append(setting_id)\n self.labels[setting_id] = setting.getAttribute(\"label\")\n self.types[setting_id] = setting.getAttribute(\"type\")\n\n # For bool's actually set the default value to True or\n # False. otherwise it is all strings to us.\n #\n default = setting.getAttribute(\"default\")\n if self.types[setting_id] == \"bool\":\n self.defaults[setting_id] = (default.lower() == 'true')\n else:\n self.defaults[setting_id] = default\n\n # Settings start out with their default value.\n #\n self.values[setting_id] = self.defaults[setting_id]\n setting = next_sibling(setting, \"setting\")\n\n dom.unlink()\n dom = None\n\n # There is always an 'override' setting - \"override\", which is\n # set based on the Language Override setting in the scraper.\n #\n if 'override' not in self.ids:\n self.ids.append(\"override\")\n self.values[\"override\"] = False\n self.types[\"override\"] = \"bool\"\n self.defaults[\"override\"] = False\n self.labels[\"override\"] = \"Language Override\"\n\n # The default language for now is english!\n #\n if 'language' not in self.ids:\n self.ids.append(\"language\")\n self.values[\"language\"] = \"en\"\n self.types[\"language\"] = \"string\"\n self.defaults[\"language\"] = \"en\"\n self.labels[\"language\"] = \"Language\"\n\n return","def loadSettings(self, e):\n if e.tag == self.type:\n c = e\n else:\n c = e.find(\".//\" + self.type)\n if c is not None:\n g = c.get(\"enabled\")\n self.enabled = (g == 'true')\n g = c.get(\"mode\")\n self.setMode((GRANT if g == 'grant' else LIMIT))\n g = c.get(\"priority\")\n try:\n self.setPriority(int(g))\n except:\n self.setPriority(0)\n self.name = c.get(\"name\")\n else:\n print \"Error: no settings found for constrain %s\" % self.name\n return c","def load_from_settings(self):\n for param, value in self.settings['swan'].items():\n # Some settings do not have a GUI element, continue if encountered\n if param not in self.input_elements.keys():\n continue\n\n # Check if parameter is not empty before filling in\n if self.validate_parameter(value):\n self.input_elements[param].set_value(value)\n\n # Validate\n self.validate(check_empty=False)","def load_from_settings(self):\n for group_name, group in self.settings['pharos'].items():\n # Some settings do not have a GUI element, continue if encountered\n if group_name not in self.input_elements.keys():\n continue\n\n for param, value in group.items():\n # Some settings do not have a GUI element, continue if encountered\n if param not in self.input_elements[group_name].keys():\n continue\n # Check if parameter is not empty before filling in\n if self.validate_parameter(value):\n self.input_elements[group_name][param].set_value(value)\n\n # Validate\n self.validate(check_empty=False)","def load_from_settings(self):\n for param, value in self.settings['hares'].items():\n # Some settings do not have a GUI element, continue if encountered\n if param not in self.input_elements.keys():\n continue\n\n # Check if parameter is not empty before filling in\n if self.validate_parameter(value):\n self.input_elements[param].set_value(value)\n\n # Validate\n self.validate(check_empty=False)","def from_settings(settings):","def loadSettings(home_dir,pd_dir):\n\n settingsXML = os.path.join(pd_dir,\"settings.xml\")\n\n #print(\"Loading settings from {0}\".format(settingsXML))\n\n global installationTree\n global installationSettings\n global domainPath\n global userEmail\n global userToken\n\n if os.path.isfile(settingsXML):\n installationTree = etree.parse(settingsXML)\n installationSettings = installationTree.getroot()\n\n for child in installationSettings:\n if child.tag == \"domain_path\":\n domainPath = child.text\n\n if not os.path.isdir(domainPath):\n fetchPlanningDomains(domainPath)\n\n if child.tag == \"email\":\n userEmail = child.text\n\n if child.tag == \"token\":\n userToken = child.text\n\n return\n\n if installationSettings is None:\n installationSettings = etree.Element(\"{http://settings.planning.domains}settings\")\n installationTree = etree.ElementTree(installationSettings)\n\n domainPath = input(\"Enter path for installing files (or hit enter to use {0}): \".format(os.path.join(home_dir,\"planning.domains\")))\n\n domainPath = domainPath.lstrip()\n domainpath = domainPath.rstrip()\n\n if domainPath == \"\":\n domainPath = os.path.join(home_dir,\"planning.domains\")\n\n if os.path.isfile(domainPath):\n print(\"Fatal error: there is already a file called {0}\".format(domainPath))\n exit(1)\n\n if not os.path.isdir(domainPath):\n fetchPlanningDomains(domainPath)\n\n etree.SubElement(installationSettings,\"domain_path\").text = domainPath\n\n userEmail = input(\"Enter email for API updates: \")\n userToken = input(\"Enter token for API updates (leave blank if none provided): \")\n\n etree.SubElement(installationSettings,\"email\").text = userEmail\n etree.SubElement(installationSettings,\"token\").text = userToken\n\n saveSettings()","def read_node_settings(node_xml):\n workflow_template_information = node_xml.find(xmlns + \"config[@key='workflow_template_information']\")\n if workflow_template_information is not None:\n workflow_template_information = elementtree_to_dict(workflow_template_information)\n return { 'workflow_template_information': workflow_template_information}","def step_3(self, browser):\n xml_file = '../../src/imio.project.pst/src/imio/project/pst/model/demo_import_pst_from_ecomptes_201805V1.xsd'\n mytree = ET.parse(xml_file)\n myroot = mytree.getroot()\n # Update ElementId\n self.assertEqual(myroot[1][1][0][10][1][10][1][13][1].get('ElementId'), 'b07ec94c0e804690a9ef971db84e12b1')\n myroot[1][1][0][10][1][10][1][13][1].set('ElementId', self.sa17.UID())\n mytree.write('ecomptes_pst.xml')\n # select xml file\n file_field = browser.find(u'Document XML exporté depuis eComptes')\n with open('ecomptes_pst.xml', 'r') as f:\n file_field.set('value', (f.read(), 'ecomptes_pst.xml'))\n # import xml file\n browser.find_button_by_label('Importer').click()\n # write browser contents\n # with open('browser_contents', 'w') as f:\n # f.write(browser.contents)","def loadFromDom(self, root):\n if hasattr(root, \"documentElement\"):\n self.xml = root\n else:\n # Encase the given tree fragment in a Document\n self.xml = createRootNode()\n self.xml.appendChild(self.xml.importNode(root, True))\n self.preprocess()","def load_frontend_xml(xml_path):\n frontend_setting = open(xml_path, \"r\").read()\n return frontend_setting","def fromElement(self, element):\n from comoonics.ComProperties import Properties\n props=element.getElementsByTagName(Properties.TAGNAME)\n #log.debug(\"fromElement: %s, %u\" %(element, len(props)))\n if len(props)>=1:\n self.properties=Properties(props[0])\n for propertyname in self.properties.keys():\n self.log.debug(\"fromElement: Setting attribute %s, %s\" %(propertyname, self.properties[propertyname].getAttribute(\"value\")))\n setattr(self, propertyname, self.properties[propertyname].getAttribute(\"value\"))\n for attribute in element.attributes:\n self.__dict__[attribute.name]=attribute.value","def importElements(self):\n msg = \"This will overwrite the current element properties file. You should create a backup first!\\n\\n\"\n msg += \"Do you wish to continue?\"\n reply = QtWidgets.QMessageBox.question(self, \"Message\", msg,\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\n QtWidgets.QMessageBox.No)\n\n if reply == QtWidgets.QMessageBox.Yes:\n # open file dialog\n title = \"Atoman - Import element properties\"\n fname = QtWidgets.QFileDialog.getOpenFileName(self, title, \".\", \"IN files (*.IN)\")[0]\n\n if fname:\n self.logger.info(\"Importing elements settings from '%s'\", fname)\n\n # read in new file\n elements.read(fname)\n\n # overwrite current file\n elements.write(dataPath(\"atoms.IN\"))\n\n # set on Lattice objects too\n self.inputState.refreshElementProperties()\n self.refState.refreshElementProperties()","def load_inasafe_settings():\n # Load default settings\n from safe.definitions import default_settings\n from safe.utilities.settings import set_setting\n\n for key, value in default_settings.inasafe_default_settings.iteritems():\n set_setting(key, value)\n\n # Override settings from INASAFE_SETTINGS_PATH\n if headless_settings.INASAFE_SETTINGS_PATH:\n # Load from custom headless settings\n import_setting(headless_settings.INASAFE_SETTINGS_PATH)","def parseFromFile(self, filePath):\n\t\ttry:\n\t\t\twith open(filePath) as fhd:\n\t\t\t\tpsXMLStr = reduce(lambda x,y: x+' '+y, fhd.xreadlines())\n\t\texcept IOError as e:\n\t\t\traise ImproperlyConfigured, \"Can not find setting file '%s', please check your setting of ``ANAFORA_PROJECT_FILE_ROOT'' and ``ANAFORA_PROJECT_SETTING_FILENAME'' in your setting file\" % (filePath)\n\t\tpsDOM = parseString(psXMLStr).childNodes[0]\n\t\tif psDOM.tagName != \"setting\":\n\t\t\traise Exception(\"Project Setting XML Dom parse error: \" + psDOM.toxml())\n\n\t\tfor childNode in [tNode for tNode in psDOM.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\n\t\t\tif childNode.tagName == \"projects\":\n\t\t\t\tfor projectNode in [tNode for tNode in childNode.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\n\t\t\t\t\tproject = Project.parseFromXMLDOM(projectNode)\n\t\t\t\t\tif os.path.isdir(os.path.join(settings.ANAFORA_PROJECT_FILE_ROOT, project.name)):\n\t\t\t\t\t\tself.projectList[project.name] = project\n\t\t\telif childNode.tagName == \"schemas\":\n\t\t\t\tfor schemaNode in [tNode for tNode in childNode.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\n\t\t\t\t\tschema = Schema.parseFromXMLDOM(schemaNode)\n\t\t\t\t\tself.schemaList[str(schema.name)] = schema\n\t\t\telse:\n\t\t\t\traise Exception(\"unhandle tag: \" + childNode.tagName)\n\n\t\t#link schema in project\n\t\tfor projectName in self.projectList:\n\t\t\tproject = self.projectList[projectName]\n\t\t\tfor (idx, schemaName) in enumerate(project.allowedSchemas):\n\t\t\t\tif isinstance(schemaName, Schema):\n\t\t\t\t\tpass\n\t\t\t\telse:\n\t\t\t\t\tif schemaName not in self.schemaList:\n\t\t\t\t\t\traise Exception('schema name \"' + str(schemaName) + '\" in project \"' + projectName + '\" is not exist')\n\t\t\t\t\tproject.allowedSchemas[idx] = self.schemaList[schemaName]\n\n\t\t#link preannotationFromMode in schema\n\t\tfor schemaName in self.schemaList:\n\t\t\tschema = self.schemaList[schemaName]\n\t\t\tfor modeName in schema.modes:\n\t\t\t\tmode = schema.modes[modeName]\n\n\t\t\t\tif mode.needPreannotation:\n\t\t\t\t\t#if mode.preannotationFromMode not in schema.modes:\n\t\t\t\t\t#\traise Exception('Preannotation mode name \"' + str(mode.preannotationFromMode) + '\" from mode \"' + mode.name + '\" of schema \"' + schemaName + '\" is not exists')\n\t\t\t\t\tif mode.preannotationFromMode.strip() == \"\":\n\t\t\t\t\t\tmode.preannotationFromMode = None\n\t\t\t\t\telse:\n\t\t\t\t\t\tmode.preannotationFromMode = schema.getMode(mode.preannotationFromMode)","def load_settings(self):\r\n #create a QSettings object to store the settings\r\n self.QtSettings=QtCore.QSettings(\"OncoRay\",\"EBT Evaluation\")\r\n #self.QtSettings=QtCore.QSettings(\"settings.ini\",QtCore.QSettings.IniFormat)\r\n\r\n #load window settings \r\n self.QtSettings.beginGroup(\"MainWindow\")\r\n self.restoreGeometry(self.QtSettings.value(\"geometry\",QtCore.QByteArray(),type=QtCore.QByteArray))\r\n self.restoreState(self.QtSettings.value(\"state\",QtCore.QByteArray(),type=QtCore.QByteArray))\r\n# self.resize(self.QtSettings.value(\"windowSize\",QtCore.QSize(1024,1280),\r\n# type=QtCore.QSize))\r\n self.QtSettings.endGroup() \r\n\r\n #load values for various elements \r\n self.QtSettings.beginGroup(\"Settings\")\r\n pyguitools.gui_restore(self.ui,self.QtSettings)\r\n self.QtSettings.endGroup()","def read_settings(self):\n config = ConfigParser.SafeConfigParser()\n config.read(os.path.dirname(os.path.realpath(__file__)) + '/linode.ini')\n\n # Cache related\n cache_path = config.get('linode', 'cache_path')\n self.cache_path_cache = cache_path + \"/ansible-linode.cache\"\n self.cache_path_index = cache_path + \"/ansible-linode.index\"\n self.cache_max_age = config.getint('linode', 'cache_max_age')","def _exportNode(self):\n node = self._extractProperties()\n self._logger.info('settings exported.')\n return node","def read_settings(self):\n self.settings = read_settings(self.settings_path)","def upgrade_markup_controlpanel_settings(context):\n # get the old site properties\n portal_properties = getToolByName(context, \"portal_properties\")\n site_properties = portal_properties.site_properties\n # get the new registry\n registry = getUtility(IRegistry)\n # XXX: Somehow this code is executed for old migration steps as well\n # ( < Plone 4 ) and breaks because there is no registry. Looking up the\n # registry interfaces with 'check=False' will not work, because it will\n # return a settings object and then fail when we try to access the\n # attributes.\n try:\n settings = registry.forInterface(\n IMarkupSchema,\n prefix='plone',\n )\n except KeyError:\n settings = False\n if settings:\n settings.default_type = site_properties.default_contenttype\n\n forbidden_types = site_properties.getProperty('forbidden_contenttypes')\n forbidden_types = list(forbidden_types) if forbidden_types else []\n\n portal_transforms = getToolByName(context, 'portal_transforms')\n allowable_types = portal_transforms.listAvailableTextInputs()\n\n settings.allowed_types = tuple([\n _type for _type in allowable_types\n if _type not in forbidden_types\n and _type not in 'text/x-plone-outputfilters-html' # removed, as in plone.app.vocabularies.types # noqa\n ])","def load_settings(self):\n raise NotImplemented(\"load_settings method should be implemented.\")","def load_init(self):\n\t\tself.init_et = ET.parse(self.init_in_fn)","def import_settings(path_to_settings=None):\n\n file_path = 'settings.json' if path_to_settings is None else path_to_settings\n\n if not os.path.isfile(file_path):\n # settings file doesn't exist\n raise IOError(errno.ENOENT, os.strerror(errno.ENOENT), 'settings.json')\n\n with open(file_path) as in_file:\n data = json.load(in_file)\n settings = Settings()\n\n # required attributes, fail if missing\n try:\n settings.input_file_path = os.path.join(os.path.dirname(sys.argv[0]), data['input_folder'], data['input_file'])\n settings.output_file_path = os.path.join(os.path.dirname(sys.argv[0]), data['output_folder'], data['output_file'])\n settings.default_timezone = data['default_timezone']\n settings.output_timezone = data['output_timezone']\n settings.custom_column_headers = data.get('custom_column_headers', [])\n settings.app_id = data['app_id']\n except KeyError as e:\n print(\"Key not found in {}: \".format(file_path) + str(e))\n sys.exit(1)\n\n return settings","def restoreFromXml(self, root: org.jdom.Element) -> None:\n ...","def install(*args, **kwds):\n ns = utils.ns_prepare(args + (kwds,), install=True)\n settings = utils.settings_from_ns(ns, update=True)\n return settings","def initialize(self):\n my_setting = self.settings.get('my_setting')","def prepare_node_attrs(self):","def load_theme_values(self): \n pass","def load_settings(self):\n # Set the default settings. In case in a later version of this script the settings change, new default variables will be added automatically\n self.settings = {\n # Connection settings to OBS Studio websockets plugin\n \"host\": \"localhost\",\n \"port\": 4444,\n \"password\": \"\",\n \"update_frequency\": 1, # seconds, how often the script loads the SC2 UI location\n }\n if os.path.isfile(self.settings_path):\n with open(self.settings_path) as f:\n self.settings.update(json.load(f))","def test_existing_attribute(self):\n self.assertEqual(import_from_setting('TEST_SETTING'), 1)","def _load_settings_to_jinja_env(self) :\n\t\t# Load filters if exists\n\t\tif hasattr(self.settings, 'FILTERS') :\n\t\t\tfor name, cls in utils.load_module(self.settings.FILTERS).__dict__.items() :\n\t\t\t\tself.jinja_env.filters[name] = cls\n\n\n\t\t# Load globals if exists\n\t\tif hasattr(self.settings, 'GLOBALS') :\n\t\t\tfor name, cls in utils.load_module(self.settings.GLOBALS).__dict__.items() :\n\t\t\t\tself.jinja_env.globals[name] = cls","def merge_onto(cls, settings):\r\n for key, value in cls.SETTINGS.iteritems():\r\n setattr(settings, key, value)","def importWebSocketClientSettings(context):\n site = context.getSite()\n utility = queryUtility(IWebSocketConnectionConfig, context=site)\n if utility is None:\n logger = context.getLogger('collective.websocketclient')\n logger.info('Nothing to import.')\n return\n if IPersistent.providedBy(utility):\n importObjects(utility, '', context)","def settings(self, settings):\n\n self._settings = settings","async def load(cls, document: str) -> Dict[str, Any]:\n return await cls.from_html(document)","def __init__(self, settings):\n self._read_config(settings)","def import_(self, node):\n yamal_name = os.path.join(self._root, self.construct_scalar(node))\n\n with open(yamal_name, 'r') as yamal_file:\n return yaml.load(yamal_file, ImportLoader)","def __load_settings(self):\n\n self.app_settings = sublime.load_settings(self.SETTINGS_FILE)\n self.__refresh_settings(True)\n\n # The settings may change during execution so we need to listen for changes\n self.app_settings.add_on_change(self.SETTINGS_CALLBACK_KEY, self.__refresh_settings)","def patch(cls):\n cls._original_element = xml.dom.minidom.Element\n xml.dom.minidom.Element = KmlElement","def load_into_settings_module(self, settings_module):\n\n if self._api_token:\n settings_module.API_TOKEN = self._api_token\n\n if self._bot_emoji:\n settings_module.BOT_EMOJI = self._bot_emoji\n\n if self._bot_icon:\n settings_module.BOT_ICON = self._bot_icon\n\n if self._errors_to:\n settings_module.ERRORS_TO = self._errors_to\n\n # TODO: Perhaps figure out a better way to do this...\n settings_module.PLUGINS = set(self._slackbot_plugins)","def load(self):\n if not path.isfile(self.SETTINGS_FILE):\n return\n data = load_json_from_disk(self.SETTINGS_FILE)\n for (key, value) in data.items():\n self.__dict__[key] = value","def _load_settings(self):\n self._dll.LS_LoadSettings(self._serial_number)\n return None","async def settings(self, ctx: BBContext):\n pass","def updateSettings(self):\n self.parser.read(self.file)\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\n self.verbose = self.parser.getboolean('Settings', 'verbose')\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')","def settings_load(self):\n self.ui.spinBox_ATSP.setValue(self.default['ATSP'])\n\n if self.default['serialLabel'] == 'bt':\n self.ui.btRadio.setChecked(True)\n try:\n os.system(\"blueman-manager\")\n except:\n print \"Please install 'blueman' package\"\n elif self.default['serialLabel'] == 'usb':\n self.ui.usbRadio.setChecked(True)\n else:\n self.ui.devRadio.setChecked(True)\n\n if self.default['units'] == 'metric':\n self.ui.units_metric_radio.setChecked(True)\n else:\n self.ui.units_US_radio.setChecked(True)\n\n return","def __init__(self) -> None:\n self._settings = {}\n\n # Load values from global_settings (only uppercase)\n self.filter_and_set(global_settings)\n\n settings_env_value: str = os.environ.get(SETTINGS_ENV)\n if settings_env_value:\n # Load values from custom settings\n try:\n module = importlib.import_module(settings_env_value)\n except ModuleNotFoundError:\n msg = \"Can't import custom settings. Is it under PYTHONPATH?\"\n raise ModuleError(msg)\n self.filter_and_set(module)","def parse(cls, dom, configDir, fileName, strict=True):\n topComment = None\n rcNode = None\n for kid in dom.childNodes:\n if kid.nodeType == Node.TEXT_NODE:\n continue\n\n if kid.nodeType == Node.COMMENT_NODE:\n topComment = kid.nodeValue\n continue\n\n if kid.nodeType == Node.ELEMENT_NODE:\n if kid.nodeName == \"runConfig\":\n if rcNode is None:\n rcNode = kid\n else:\n msg = \"Found multiple <runConfig> tags in %s\" % \\\n fileName\n raise ProcessError(msg)\n\n if rcNode is None:\n raise ProcessError(\"No <runConfig> tag found in %s\" % fileName)\n\n domcfgDir = os.path.join(configDir, \"domconfigs\")\n\n runCfg = DAQConfig(fileName)\n if topComment is not None:\n runCfg.setTopComment(topComment)\n\n for kid in rcNode.childNodes:\n if kid.nodeType == Node.TEXT_NODE:\n continue\n\n if kid.nodeType == Node.COMMENT_NODE:\n continue\n\n if kid.nodeType == Node.ELEMENT_NODE:\n if kid.nodeName == \"domConfigList\":\n if kid.attributes is None or len(kid.attributes) == 0:\n hub = None\n else:\n if len(kid.attributes) != 1:\n raise ProcessError((\"<%s> node has extra\" +\n \" attributes\") % kid.nodeName)\n attrName = \"hub\"\n if not kid.attributes.has_key(attrName):\n raise ProcessError((\"<%s> node should have\" +\n \" \\\"%s\\\" attribute, not\" +\n \" \\\"%s\\\"\") %\n (kid.nodeName, attrName,\n kid.attributes.keys()[0]))\n\n hub = int(kid.attributes[attrName].value)\n\n dcName = cls.getChildText(kid).strip()\n if hub is None or cls.PARSE_DOM_CONFIG:\n domCfg = DomConfigParser.load(dcName, domcfgDir,\n strict)\n runCfg.addDomConfig(domCfg, hub)\n else:\n runCfg.addDomConfigName(dcName, hub)\n elif kid.nodeName == \"triggerConfig\":\n trigCfg = cls.getChildText(kid)\n cls.__parseTriggerConfig(configDir, trigCfg)\n runCfg.setTriggerConfig(trigCfg)\n elif kid.nodeName == \"hubFiles\":\n if kid.attributes is None or len(kid.attributes) == 0:\n raise ProcessError(\"<%s> node has no attributes\" %\n kid.nodeName)\n if len(kid.attributes) != 1:\n raise ProcessError(\"<%s> node has extra attributes\" %\n kid.nodeName)\n attrName = \"baseDir\"\n if not kid.attributes.has_key(attrName):\n raise ProcessError((\"<%s> node should have \\\"%s\\\"\" +\n \" attribute, not \\\"%s\\\"\") %\n (kid.nodeName, attrName,\n kid.attributes.keys()[0]))\n\n runCfg.setReplayBaseDir(kid.attributes[attrName].value)\n\n cls.__parseHubFiles(kid, runCfg)\n elif kid.nodeName == \"stringHub\":\n cls.__parseSenderOption(kid, runCfg)\n elif kid.nodeName == \"runComponent\":\n if kid.attributes is None or len(kid.attributes) == 0:\n raise ProcessError(\"<%s> node has no attributes\" %\n kid.nodeName)\n if len(kid.attributes) != 1:\n raise ProcessError(\"<%s> node has extra attributes\" %\n kid.nodeName)\n if not kid.attributes.has_key(\"name\"):\n raise ProcessError((\"<%s> node should have \\\"name\\\"\" +\n \" attribute, not \\\"%s\\\"\") %\n (kid.nodeName,\n kid.attributes.keys()[0]))\n\n runCfg.addComponent(kid.attributes[\"name\"].value, strict)\n elif kid.nodeName == \"watchdog\":\n valStr = kid.attributes[\"period\"].value\n try:\n period = int(valStr)\n except:\n raise ProcessError((\"<%s> node has invalid\" +\n \" \\\"period\\\" value \\\"%s\\\"\") %\n (kid.nodeName, valStr))\n runCfg.setWatchdogPeriod(period)\n elif kid.nodeName == \"monitor\":\n valStr = kid.attributes[\"period\"].value\n try:\n period = int(valStr)\n except:\n raise ProcessError((\"<%s> node has invalid\" +\n \" \\\"period\\\" value \\\"%s\\\"\") %\n (kid.nodeName, valStr))\n runCfg.setMonitorPeriod(period)\n elif kid.nodeName == \"defaultLogLevel\":\n pass\n elif kid.nodeName == \"stream\":\n if cls.STRAY_STREAM_HACK:\n cls.__parseStrayStream(kid, runCfg)\n else:\n print >>sys.stderr, \"Ignoring stray <stream> in %s\" % \\\n fileName\n else:\n raise ProcessError(\"Unknown runConfig node <%s> in %s\" %\n (kid.nodeName, fileName))\n continue\n\n raise ProcessError(\"Found unknown runConfig node <%s>\" %\n kid.nodeName)\n\n if strict:\n runCfg.validate()\n\n return runCfg","def __init__(self, element):\n self._element = element\n self._element.SetTemplateValue('importManager', self)\n self._class_name_to_qualified_name = {}\n self._google_imports = set()\n self._other_imports = set()\n self._java_imports = set()","def setUp(self):\n self.scraped = SimpleContent(Selector.from_text(SIMPLE_HTML))","def project_settings(request):\n webnode_settings = kakocase_settings(request)\n webnode_settings['settings']['IS_WEBNODE'] = True\n return webnode_settings","def load(self):\n for field in self.fields:\n value = self.siteconfig.get(field)\n self.fields[field].initial = value\n\n if field in self.disabled_fields:\n self.fields[field].widget.attrs['disabled'] = 'disabled'","def load_settings(self, outfile='settings.p'):\n settings = pickle.load(open(path,'rb'))\n self.__dict__.update(settings)","def _import():\n global webbrowser, contextlib, yaml, psutil, snakemake, logger, setup_logger, xdg, datetime, _logging\n import yaml\n import psutil\n import webbrowser\n import contextlib\n import datetime\n\n import snakemake\n from snakemake.logging import logger, setup_logger, _logging\n import xdg","def load_form_settings(self, group, item):\n settings = QSettings(self._company, self._section)\n settings.beginGroup(group)\n self.restoreState(settings.value(item, QByteArray()))\n self.restoreGeometry(settings.value(item, QByteArray()))\n settings.endGroup()","def setup(self):\r\n self.text_input_values = {}\r\n if self.tag == 'radiotextgroup':\r\n self.html_input_type = \"radio\"\r\n elif self.tag == 'checkboxtextgroup':\r\n self.html_input_type = \"checkbox\"\r\n else:\r\n raise Exception(\"ChoiceGroup: unexpected tag {0}\".format(self.tag))\r\n\r\n if self.value == '':\r\n # Make `value` an empty dictionary, if it currently has an empty\r\n # value. This is necessary because the template expects a\r\n # dictionary.\r\n self.value = {}\r\n self.choices = self.extract_choices(self.xml)","def from_xml_node(cls, xml_node):\n from_ = get_xml_text_value(xml_node, xml_tags.Elements.FROM)\n to = get_xml_text_value(xml_node, xml_tags.Elements.TO)\n return cls(xml_tags.Elements.SRC, from_, to)","def __load(self, node):\n\n self.tiles = node['data']\n self.name = node['name']\n self.opacity = node['opacity']\n self.visible = node['visible']","def importMasterSettings(self):\n\t\tpickleData = pickle.load( open( self.masterPath.path, \"rb\" ) )\n\t\tmaster = rlayer.RenderLayer( 'defaultRenderLayer' )\n\t\tmaster.makeCurrent()\n\t\tfor a in pickleData.keys():\n\t\t\ttry:\n\t\t\t\ta.v = pickleData[a]\n\t\t\texcept:\n\t\t\t\tcontinue","def parseDomNode(self,node):\n if node.nodeType != dom.Node.ELEMENT_NODE and node.nodeType != dom.Node.DOCUMENT_NODE:\n return\n name=node.tagName\n handler=avnav_handlerList.findHandlerByConfigName(name)\n if handler is not None:\n AVNLog.info(\"parsing entry for handler %s\",name)\n self.parseHandler(node,handler)\n else:\n nextElement=node.firstChild\n while nextElement is not None:\n self.parseDomNode(nextElement)\n nextElement=nextElement.nextSibling","def parseDomNode(self,node):\n if node.nodeType != dom.Node.ELEMENT_NODE and node.nodeType != dom.Node.DOCUMENT_NODE:\n return\n name=node.tagName\n handler=avnav_handlerList.findHandlerByConfigName(name)\n if handler is not None:\n AVNLog.info(\"parsing entry for handler %s\",name)\n self.parseHandler(node,handler)\n else:\n nextElement=node.firstChild\n while nextElement is not None:\n self.parseDomNode(nextElement)\n nextElement=nextElement.nextSibling","def from_html(self, content):\r\n pass","def _parse_preset(self, xmldata):\r\n\r\n raise NotImplementedError","def startup(self):\n self.settings = sublime.load_settings(self.settings_base)\n self.sublime_settings = sublime.load_settings(self.sublime_base)","def import_registry_settings(site):\n PROFILE_ID = 'profile-interlegis.portalmodelo.policy:default'\n setup = api.portal.get_tool('portal_setup')\n setup.runImportStepFromProfile(PROFILE_ID, 'plone.app.registry')","def FromXML(cls, doc, element, default=\"absolute\"):\n return cls(element.get(\"type\", default), NumberDef(element.text))","def from_xml_node(cls, xml_node):\n raise NotImplementedError(\"from_xml_node must be implemented by derived classes.\")","def importXml ( r ):\n rawText = r.read ()\n rawText = rawText.strip ()\n pattern = re.compile (r'[^\\S ]+')\n text = re.sub ( pattern, '', rawText )\n xml = ET.fromstring ( text )\n assert str ( type ( xml ) ) == \"<type 'instance'>\"\n return xml","def loadSettings(self, filename='short_240.settings'):\n global master_run_no\n self.settingsFilename = filename\n # print 'self.settingsFilename = ', self.settingsFilename\n if os.path.exists(filename):\n stream = open(filename, 'r')\n else:\n stream = open(master_lattice_location+filename, 'r')\n self.settings = yaml.load(stream, Loader=yaml.UnsafeLoader)\n self.globalSettings = self.settings['global']\n master_run_no = self.globalSettings['run_no'] if 'run_no' in self.globalSettings else 1\n self.fileSettings = self.settings['files']\n elements = self.settings['elements']\n self.groups = self.settings['groups'] if 'groups' in self.settings and self.settings['groups'] is not None else {}\n stream.close()\n\n # for name, elem in list(self.groups.items()):\n # group = globals()[elem['type']](name, self.elementObjects, **elem)\n # self.groupObjects[name] = group\n\n for name, elem in list(elements.items()):\n self.read_Element(name, elem)\n\n # for name, lattice in list(self.fileSettings.items()):\n # self.read_Lattice(name, lattice)","def __setup(self, SETTINGS_FILE):\n config = ConfigParser()\n try:\n config.read(SETTINGS_FILE)\n self.settings = Settings(config)\n self.data = Data()\n except IOError:\n raise FileMissing(SETTINGS_FILE)\n except Exception as e:\n raise e","def load_settings(env=\"prod\"):\n global config\n config = configparser.SafeConfigParser()\n config.read(CONFIG_FILES.get(env))","def __enter__(self):\n self.root = ET.parse(self.manifest).getroot()\n self._parse_content()\n return self","def parser(self):\n\t\tdom = ET.parse(self.input_filename)\n\t\tself.doc = dom.getroot()","def _init_node_attributes(self):\n assert False","def create_dd_settings(xml_document, parent_element):\n dd_properties_element = xml_document.createElement(\"dd_properties\")\n parent_element.appendChild(dd_properties_element)\n\n option_element = xml_document.createElement(\"Option\")\n option_element.setAttribute('type', 'Map')\n dd_properties_element.appendChild(option_element)\n\n option_child1_element = xml_document.createElement(\"Option\")\n option_child1_element.setAttribute('type', 'QString')\n option_child1_element.setAttribute('name', 'name')\n option_child1_element.setAttribute('value', '')\n option_element.appendChild(option_child1_element)\n\n option_child2_element = xml_document.createElement(\"Option\")\n option_child2_element.setAttribute('name', 'properties')\n option_element.appendChild(option_child2_element)\n\n option_child3_element = xml_document.createElement(\"Option\")\n option_child3_element.setAttribute('type', 'QString')\n option_child3_element.setAttribute('name', 'type')\n option_child3_element.setAttribute('value', 'collection')\n option_element.appendChild(option_child3_element)","def load_cElementTree(finder, module):\n finder.IncludeModule(\"elementtree.ElementTree\")","def load_data(self):\n with open(self.FILE, 'r') as html_file:\n document = html_file.read()\n self.HTML = document","def __init__( settings={} ):","def import_from_string(val, setting_name):\n try:\n return import_string(val)\n except ImportError as e:\n raise e","def setup_parser(self, parser):","def perform_import(val, setting_name):\n if val is None:\n return None\n elif isinstance(val, str):\n return import_from_string(val, setting_name)\n elif isinstance(val, (list, tuple)):\n return [import_from_string(item, setting_name) for item in val]\n return val","def load(self):\n\n from django.conf import settings as st\n\n loaded: namedtuple = default\n\n if hasattr(st, 'AUTOMATED_LOGGING'):\n loaded = ConfigSchema().load(st.AUTOMATED_LOGGING)\n\n # be sure `loaded` has globals as we're working with those,\n # if that is not the case early return.\n if not hasattr(loaded, 'globals'):\n return loaded\n\n # use the binary **or** operator to apply globals to Set() attributes\n values = {}\n for name in loaded._fields:\n field = getattr(loaded, name)\n values[name] = field\n\n if not isinstance(field, tuple) or name == 'globals':\n continue\n\n values[name] = field | loaded.globals\n\n self.loaded = loaded._replace(**values)\n return self","def from_node(self, root):\n \n self.set_at_from_string(root.getAttribute(\"at\"))\n self.action = root.getAttribute(\"action\")\n self.actor = root.getAttribute(\"actor\")\n self.regarding = root.getAttribute(\"regarding\")\n self.source = root.getAttribute(\"source\")\n self.tags = root.getAttribute(\"tags\").split(\",\")\n self.to = root.getAttribute(\"to\")\n self.url = root.getAttribute(\"url\")\n\n for node in root.childNodes:\n if node.tagName == 'payload':\n for subnode in node.childNodes:\n if subnode.tagName == 'body':\n self.body = subnode.childNodes[0].nodeValue\n elif subnode.tagName == 'raw':\n self.raw = subnode.childNodes[0].nodeValue","def Import(content: bytes):\n config_set = _ParseConfigSet(content)\n\n # Remove any older data\n info = config_set.info\n if info and info.key.get():\n Delete(info.url)\n\n config_encoder.Load(config_set)\n info.put()\n return mtt_messages.Convert(info, mtt_messages.ConfigSetInfo)","def read(self):\r\n tree = ElementTree(file=self._fn)\r\n self._root = tree.getroot()\r\n for prop in self.prpnames:\r\n self.__setattr__(prop, DocItem.get_attr(self, prop))","def replace(*args, **kwds):\n ns = utils.ns_prepare(args + (kwds,), install=False)\n settings = utils.settings_from_ns(ns, update=True)\n return settings","def und_add_setting(udb_file, configuration_path_file):\n subprocess.call(f\"und import {configuration_path_file} {udb_file}\")","def manual_import_prop(self, path):\n dtu = DtuLoader.DtuLoader(path)\n fbx_path = dtu.get_fbx_path()\n self.prop_import(fbx_path, dtu)","def initParser():\n libxml2mod.xmlInitParser()","def parse_element(self, element):\n if element.firstChild:\n self.url = element.firstChild.data\n else:\n # This happens with these 'cache' url's. Need to figure\n # out where the cache _comes from_\n #\n self.url = None\n\n self.spoof_url = element.getAttribute(\"spoof\")\n if element.hasAttribute(\"post\"):\n self.use_post = True\n self.function = element.getAttribute(\"function\")\n self.cache_key = element.getAttribute(\"cache\")\n return","def merge_into_settings(self, settings):\n if not self._meta_dict:\n self._load_from_file()\n\n settings.chat_name = self._meta_dict[DumpMetadata.CHAT_NAME]\n settings.last_message_id = self._meta_dict[DumpMetadata.LAST_MESSAGE_ID]\n settings.exporter = self._meta_dict[DumpMetadata.EXPORTER]","def __init__(self, element, parent):\n super(XMLObj, self).__setattr__('element', element)\n super(XMLObj, self).__setattr__('parent', parent)","def update(self):\n registry = getUtility(IRegistry)\n site_settings = registry.forInterface(\n ISiteSchema, prefix=\"plone\", check=False)\n try:\n if site_settings.webstats_js:\n self.webstats_js = site_settings.webstats_js\n except AttributeError:\n pass","def _local_settings(cls):\n # type: () -> QSettings\n filename = \"{}.ini\".format(qname(cls))\n fname = os.path.join(settings.widget_settings_dir(), filename)\n return QSettings(fname, QSettings.IniFormat)","def load_settings(self):\n # config file from branch's asdf\n config_exists = os.path.isfile(self.config_path)\n\n if config_exists:\n\n config_file = open(self.config_path, 'r')\n self.config_json = json.load(config_file)\n config_file.close()\n\n else:\n raise Exception(\"Error BranchConfig: could not find config json\")\n\n\n try:\n self.branch_settings = self.config_json[self.branch]\n\n self.branch_keys = self.branch_settings.keys()\n\n for attr in self.branch_keys:\n setattr(self, attr, self.branch_settings[attr])\n\n except:\n raise Exception(\"Error BranchConfig: could not add config settings to BranchConfig\")","def loadState(self, e, force=False):\n if e.tag == self.type and e.get('name') == self.name:\n c = e\n else:\n c = e.find(\".//\" + self.type + \"[@name='\" + self.name + \"']\")\n if c is None:\n print \"Error: no settings found for constrain %s\" % self.name\n return c","def settings(self):\n if self._settings is not None:\n return self._settings\n\n settings = self.binaries['KeeAgent.settings'].content\n self._settings = objectify.fromstring(settings)\n return self._settings","def loadSettings(self, e):\n c = constrain.loadSettings(self, e)\n g = c.get(\"status\")\n self.status = (g == 'true')\n return c","def initialize_from_config(self):"],"string":"[\n \"def _importNode(self, node):\\n if self.environ.shouldPurge():\\n self._purgeProperties()\\n self._initProperties(node)\\n self._logger.info('settings imported.')\",\n \"def load_settings(self):\\n\\n self.std = settings.settings\",\n \"def __init__(self, settings_xml):\\n # The list of setting ids.\\n #\\n # XXX This is redundant. We could just get the ids from\\n # getting the values of any of our dicts.\\n #\\n self.ids = []\\n self.values = { }\\n self.types = { }\\n self.defaults = { }\\n self.labels = { }\\n\\n if settings_xml:\\n dom = parseString(settings_xml)\\n s = dom.firstChild\\n\\n setting = first_child(s, \\\"setting\\\")\\n while setting:\\n setting_id = setting.getAttribute(\\\"id\\\")\\n\\n # I know the 'sep' setting has no id. I am not sure what it is\\n # used for so I am just going to skip it.\\n #\\n if setting_id != \\\"\\\":\\n self.ids.append(setting_id)\\n self.labels[setting_id] = setting.getAttribute(\\\"label\\\")\\n self.types[setting_id] = setting.getAttribute(\\\"type\\\")\\n\\n # For bool's actually set the default value to True or\\n # False. otherwise it is all strings to us.\\n #\\n default = setting.getAttribute(\\\"default\\\")\\n if self.types[setting_id] == \\\"bool\\\":\\n self.defaults[setting_id] = (default.lower() == 'true')\\n else:\\n self.defaults[setting_id] = default\\n\\n # Settings start out with their default value.\\n #\\n self.values[setting_id] = self.defaults[setting_id]\\n setting = next_sibling(setting, \\\"setting\\\")\\n\\n dom.unlink()\\n dom = None\\n\\n # There is always an 'override' setting - \\\"override\\\", which is\\n # set based on the Language Override setting in the scraper.\\n #\\n if 'override' not in self.ids:\\n self.ids.append(\\\"override\\\")\\n self.values[\\\"override\\\"] = False\\n self.types[\\\"override\\\"] = \\\"bool\\\"\\n self.defaults[\\\"override\\\"] = False\\n self.labels[\\\"override\\\"] = \\\"Language Override\\\"\\n\\n # The default language for now is english!\\n #\\n if 'language' not in self.ids:\\n self.ids.append(\\\"language\\\")\\n self.values[\\\"language\\\"] = \\\"en\\\"\\n self.types[\\\"language\\\"] = \\\"string\\\"\\n self.defaults[\\\"language\\\"] = \\\"en\\\"\\n self.labels[\\\"language\\\"] = \\\"Language\\\"\\n\\n return\",\n \"def loadSettings(self, e):\\n if e.tag == self.type:\\n c = e\\n else:\\n c = e.find(\\\".//\\\" + self.type)\\n if c is not None:\\n g = c.get(\\\"enabled\\\")\\n self.enabled = (g == 'true')\\n g = c.get(\\\"mode\\\")\\n self.setMode((GRANT if g == 'grant' else LIMIT))\\n g = c.get(\\\"priority\\\")\\n try:\\n self.setPriority(int(g))\\n except:\\n self.setPriority(0)\\n self.name = c.get(\\\"name\\\")\\n else:\\n print \\\"Error: no settings found for constrain %s\\\" % self.name\\n return c\",\n \"def load_from_settings(self):\\n for param, value in self.settings['swan'].items():\\n # Some settings do not have a GUI element, continue if encountered\\n if param not in self.input_elements.keys():\\n continue\\n\\n # Check if parameter is not empty before filling in\\n if self.validate_parameter(value):\\n self.input_elements[param].set_value(value)\\n\\n # Validate\\n self.validate(check_empty=False)\",\n \"def load_from_settings(self):\\n for group_name, group in self.settings['pharos'].items():\\n # Some settings do not have a GUI element, continue if encountered\\n if group_name not in self.input_elements.keys():\\n continue\\n\\n for param, value in group.items():\\n # Some settings do not have a GUI element, continue if encountered\\n if param not in self.input_elements[group_name].keys():\\n continue\\n # Check if parameter is not empty before filling in\\n if self.validate_parameter(value):\\n self.input_elements[group_name][param].set_value(value)\\n\\n # Validate\\n self.validate(check_empty=False)\",\n \"def load_from_settings(self):\\n for param, value in self.settings['hares'].items():\\n # Some settings do not have a GUI element, continue if encountered\\n if param not in self.input_elements.keys():\\n continue\\n\\n # Check if parameter is not empty before filling in\\n if self.validate_parameter(value):\\n self.input_elements[param].set_value(value)\\n\\n # Validate\\n self.validate(check_empty=False)\",\n \"def from_settings(settings):\",\n \"def loadSettings(home_dir,pd_dir):\\n\\n settingsXML = os.path.join(pd_dir,\\\"settings.xml\\\")\\n\\n #print(\\\"Loading settings from {0}\\\".format(settingsXML))\\n\\n global installationTree\\n global installationSettings\\n global domainPath\\n global userEmail\\n global userToken\\n\\n if os.path.isfile(settingsXML):\\n installationTree = etree.parse(settingsXML)\\n installationSettings = installationTree.getroot()\\n\\n for child in installationSettings:\\n if child.tag == \\\"domain_path\\\":\\n domainPath = child.text\\n\\n if not os.path.isdir(domainPath):\\n fetchPlanningDomains(domainPath)\\n\\n if child.tag == \\\"email\\\":\\n userEmail = child.text\\n\\n if child.tag == \\\"token\\\":\\n userToken = child.text\\n\\n return\\n\\n if installationSettings is None:\\n installationSettings = etree.Element(\\\"{http://settings.planning.domains}settings\\\")\\n installationTree = etree.ElementTree(installationSettings)\\n\\n domainPath = input(\\\"Enter path for installing files (or hit enter to use {0}): \\\".format(os.path.join(home_dir,\\\"planning.domains\\\")))\\n\\n domainPath = domainPath.lstrip()\\n domainpath = domainPath.rstrip()\\n\\n if domainPath == \\\"\\\":\\n domainPath = os.path.join(home_dir,\\\"planning.domains\\\")\\n\\n if os.path.isfile(domainPath):\\n print(\\\"Fatal error: there is already a file called {0}\\\".format(domainPath))\\n exit(1)\\n\\n if not os.path.isdir(domainPath):\\n fetchPlanningDomains(domainPath)\\n\\n etree.SubElement(installationSettings,\\\"domain_path\\\").text = domainPath\\n\\n userEmail = input(\\\"Enter email for API updates: \\\")\\n userToken = input(\\\"Enter token for API updates (leave blank if none provided): \\\")\\n\\n etree.SubElement(installationSettings,\\\"email\\\").text = userEmail\\n etree.SubElement(installationSettings,\\\"token\\\").text = userToken\\n\\n saveSettings()\",\n \"def read_node_settings(node_xml):\\n workflow_template_information = node_xml.find(xmlns + \\\"config[@key='workflow_template_information']\\\")\\n if workflow_template_information is not None:\\n workflow_template_information = elementtree_to_dict(workflow_template_information)\\n return { 'workflow_template_information': workflow_template_information}\",\n \"def step_3(self, browser):\\n xml_file = '../../src/imio.project.pst/src/imio/project/pst/model/demo_import_pst_from_ecomptes_201805V1.xsd'\\n mytree = ET.parse(xml_file)\\n myroot = mytree.getroot()\\n # Update ElementId\\n self.assertEqual(myroot[1][1][0][10][1][10][1][13][1].get('ElementId'), 'b07ec94c0e804690a9ef971db84e12b1')\\n myroot[1][1][0][10][1][10][1][13][1].set('ElementId', self.sa17.UID())\\n mytree.write('ecomptes_pst.xml')\\n # select xml file\\n file_field = browser.find(u'Document XML exporté depuis eComptes')\\n with open('ecomptes_pst.xml', 'r') as f:\\n file_field.set('value', (f.read(), 'ecomptes_pst.xml'))\\n # import xml file\\n browser.find_button_by_label('Importer').click()\\n # write browser contents\\n # with open('browser_contents', 'w') as f:\\n # f.write(browser.contents)\",\n \"def loadFromDom(self, root):\\n if hasattr(root, \\\"documentElement\\\"):\\n self.xml = root\\n else:\\n # Encase the given tree fragment in a Document\\n self.xml = createRootNode()\\n self.xml.appendChild(self.xml.importNode(root, True))\\n self.preprocess()\",\n \"def load_frontend_xml(xml_path):\\n frontend_setting = open(xml_path, \\\"r\\\").read()\\n return frontend_setting\",\n \"def fromElement(self, element):\\n from comoonics.ComProperties import Properties\\n props=element.getElementsByTagName(Properties.TAGNAME)\\n #log.debug(\\\"fromElement: %s, %u\\\" %(element, len(props)))\\n if len(props)>=1:\\n self.properties=Properties(props[0])\\n for propertyname in self.properties.keys():\\n self.log.debug(\\\"fromElement: Setting attribute %s, %s\\\" %(propertyname, self.properties[propertyname].getAttribute(\\\"value\\\")))\\n setattr(self, propertyname, self.properties[propertyname].getAttribute(\\\"value\\\"))\\n for attribute in element.attributes:\\n self.__dict__[attribute.name]=attribute.value\",\n \"def importElements(self):\\n msg = \\\"This will overwrite the current element properties file. You should create a backup first!\\\\n\\\\n\\\"\\n msg += \\\"Do you wish to continue?\\\"\\n reply = QtWidgets.QMessageBox.question(self, \\\"Message\\\", msg,\\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\\n QtWidgets.QMessageBox.No)\\n\\n if reply == QtWidgets.QMessageBox.Yes:\\n # open file dialog\\n title = \\\"Atoman - Import element properties\\\"\\n fname = QtWidgets.QFileDialog.getOpenFileName(self, title, \\\".\\\", \\\"IN files (*.IN)\\\")[0]\\n\\n if fname:\\n self.logger.info(\\\"Importing elements settings from '%s'\\\", fname)\\n\\n # read in new file\\n elements.read(fname)\\n\\n # overwrite current file\\n elements.write(dataPath(\\\"atoms.IN\\\"))\\n\\n # set on Lattice objects too\\n self.inputState.refreshElementProperties()\\n self.refState.refreshElementProperties()\",\n \"def load_inasafe_settings():\\n # Load default settings\\n from safe.definitions import default_settings\\n from safe.utilities.settings import set_setting\\n\\n for key, value in default_settings.inasafe_default_settings.iteritems():\\n set_setting(key, value)\\n\\n # Override settings from INASAFE_SETTINGS_PATH\\n if headless_settings.INASAFE_SETTINGS_PATH:\\n # Load from custom headless settings\\n import_setting(headless_settings.INASAFE_SETTINGS_PATH)\",\n \"def parseFromFile(self, filePath):\\n\\t\\ttry:\\n\\t\\t\\twith open(filePath) as fhd:\\n\\t\\t\\t\\tpsXMLStr = reduce(lambda x,y: x+' '+y, fhd.xreadlines())\\n\\t\\texcept IOError as e:\\n\\t\\t\\traise ImproperlyConfigured, \\\"Can not find setting file '%s', please check your setting of ``ANAFORA_PROJECT_FILE_ROOT'' and ``ANAFORA_PROJECT_SETTING_FILENAME'' in your setting file\\\" % (filePath)\\n\\t\\tpsDOM = parseString(psXMLStr).childNodes[0]\\n\\t\\tif psDOM.tagName != \\\"setting\\\":\\n\\t\\t\\traise Exception(\\\"Project Setting XML Dom parse error: \\\" + psDOM.toxml())\\n\\n\\t\\tfor childNode in [tNode for tNode in psDOM.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\\n\\t\\t\\tif childNode.tagName == \\\"projects\\\":\\n\\t\\t\\t\\tfor projectNode in [tNode for tNode in childNode.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\\n\\t\\t\\t\\t\\tproject = Project.parseFromXMLDOM(projectNode)\\n\\t\\t\\t\\t\\tif os.path.isdir(os.path.join(settings.ANAFORA_PROJECT_FILE_ROOT, project.name)):\\n\\t\\t\\t\\t\\t\\tself.projectList[project.name] = project\\n\\t\\t\\telif childNode.tagName == \\\"schemas\\\":\\n\\t\\t\\t\\tfor schemaNode in [tNode for tNode in childNode.childNodes if tNode.nodeType == tNode.ELEMENT_NODE]:\\n\\t\\t\\t\\t\\tschema = Schema.parseFromXMLDOM(schemaNode)\\n\\t\\t\\t\\t\\tself.schemaList[str(schema.name)] = schema\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise Exception(\\\"unhandle tag: \\\" + childNode.tagName)\\n\\n\\t\\t#link schema in project\\n\\t\\tfor projectName in self.projectList:\\n\\t\\t\\tproject = self.projectList[projectName]\\n\\t\\t\\tfor (idx, schemaName) in enumerate(project.allowedSchemas):\\n\\t\\t\\t\\tif isinstance(schemaName, Schema):\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif schemaName not in self.schemaList:\\n\\t\\t\\t\\t\\t\\traise Exception('schema name \\\"' + str(schemaName) + '\\\" in project \\\"' + projectName + '\\\" is not exist')\\n\\t\\t\\t\\t\\tproject.allowedSchemas[idx] = self.schemaList[schemaName]\\n\\n\\t\\t#link preannotationFromMode in schema\\n\\t\\tfor schemaName in self.schemaList:\\n\\t\\t\\tschema = self.schemaList[schemaName]\\n\\t\\t\\tfor modeName in schema.modes:\\n\\t\\t\\t\\tmode = schema.modes[modeName]\\n\\n\\t\\t\\t\\tif mode.needPreannotation:\\n\\t\\t\\t\\t\\t#if mode.preannotationFromMode not in schema.modes:\\n\\t\\t\\t\\t\\t#\\traise Exception('Preannotation mode name \\\"' + str(mode.preannotationFromMode) + '\\\" from mode \\\"' + mode.name + '\\\" of schema \\\"' + schemaName + '\\\" is not exists')\\n\\t\\t\\t\\t\\tif mode.preannotationFromMode.strip() == \\\"\\\":\\n\\t\\t\\t\\t\\t\\tmode.preannotationFromMode = None\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tmode.preannotationFromMode = schema.getMode(mode.preannotationFromMode)\",\n \"def load_settings(self):\\r\\n #create a QSettings object to store the settings\\r\\n self.QtSettings=QtCore.QSettings(\\\"OncoRay\\\",\\\"EBT Evaluation\\\")\\r\\n #self.QtSettings=QtCore.QSettings(\\\"settings.ini\\\",QtCore.QSettings.IniFormat)\\r\\n\\r\\n #load window settings \\r\\n self.QtSettings.beginGroup(\\\"MainWindow\\\")\\r\\n self.restoreGeometry(self.QtSettings.value(\\\"geometry\\\",QtCore.QByteArray(),type=QtCore.QByteArray))\\r\\n self.restoreState(self.QtSettings.value(\\\"state\\\",QtCore.QByteArray(),type=QtCore.QByteArray))\\r\\n# self.resize(self.QtSettings.value(\\\"windowSize\\\",QtCore.QSize(1024,1280),\\r\\n# type=QtCore.QSize))\\r\\n self.QtSettings.endGroup() \\r\\n\\r\\n #load values for various elements \\r\\n self.QtSettings.beginGroup(\\\"Settings\\\")\\r\\n pyguitools.gui_restore(self.ui,self.QtSettings)\\r\\n self.QtSettings.endGroup()\",\n \"def read_settings(self):\\n config = ConfigParser.SafeConfigParser()\\n config.read(os.path.dirname(os.path.realpath(__file__)) + '/linode.ini')\\n\\n # Cache related\\n cache_path = config.get('linode', 'cache_path')\\n self.cache_path_cache = cache_path + \\\"/ansible-linode.cache\\\"\\n self.cache_path_index = cache_path + \\\"/ansible-linode.index\\\"\\n self.cache_max_age = config.getint('linode', 'cache_max_age')\",\n \"def _exportNode(self):\\n node = self._extractProperties()\\n self._logger.info('settings exported.')\\n return node\",\n \"def read_settings(self):\\n self.settings = read_settings(self.settings_path)\",\n \"def upgrade_markup_controlpanel_settings(context):\\n # get the old site properties\\n portal_properties = getToolByName(context, \\\"portal_properties\\\")\\n site_properties = portal_properties.site_properties\\n # get the new registry\\n registry = getUtility(IRegistry)\\n # XXX: Somehow this code is executed for old migration steps as well\\n # ( < Plone 4 ) and breaks because there is no registry. Looking up the\\n # registry interfaces with 'check=False' will not work, because it will\\n # return a settings object and then fail when we try to access the\\n # attributes.\\n try:\\n settings = registry.forInterface(\\n IMarkupSchema,\\n prefix='plone',\\n )\\n except KeyError:\\n settings = False\\n if settings:\\n settings.default_type = site_properties.default_contenttype\\n\\n forbidden_types = site_properties.getProperty('forbidden_contenttypes')\\n forbidden_types = list(forbidden_types) if forbidden_types else []\\n\\n portal_transforms = getToolByName(context, 'portal_transforms')\\n allowable_types = portal_transforms.listAvailableTextInputs()\\n\\n settings.allowed_types = tuple([\\n _type for _type in allowable_types\\n if _type not in forbidden_types\\n and _type not in 'text/x-plone-outputfilters-html' # removed, as in plone.app.vocabularies.types # noqa\\n ])\",\n \"def load_settings(self):\\n raise NotImplemented(\\\"load_settings method should be implemented.\\\")\",\n \"def load_init(self):\\n\\t\\tself.init_et = ET.parse(self.init_in_fn)\",\n \"def import_settings(path_to_settings=None):\\n\\n file_path = 'settings.json' if path_to_settings is None else path_to_settings\\n\\n if not os.path.isfile(file_path):\\n # settings file doesn't exist\\n raise IOError(errno.ENOENT, os.strerror(errno.ENOENT), 'settings.json')\\n\\n with open(file_path) as in_file:\\n data = json.load(in_file)\\n settings = Settings()\\n\\n # required attributes, fail if missing\\n try:\\n settings.input_file_path = os.path.join(os.path.dirname(sys.argv[0]), data['input_folder'], data['input_file'])\\n settings.output_file_path = os.path.join(os.path.dirname(sys.argv[0]), data['output_folder'], data['output_file'])\\n settings.default_timezone = data['default_timezone']\\n settings.output_timezone = data['output_timezone']\\n settings.custom_column_headers = data.get('custom_column_headers', [])\\n settings.app_id = data['app_id']\\n except KeyError as e:\\n print(\\\"Key not found in {}: \\\".format(file_path) + str(e))\\n sys.exit(1)\\n\\n return settings\",\n \"def restoreFromXml(self, root: org.jdom.Element) -> None:\\n ...\",\n \"def install(*args, **kwds):\\n ns = utils.ns_prepare(args + (kwds,), install=True)\\n settings = utils.settings_from_ns(ns, update=True)\\n return settings\",\n \"def initialize(self):\\n my_setting = self.settings.get('my_setting')\",\n \"def prepare_node_attrs(self):\",\n \"def load_theme_values(self): \\n pass\",\n \"def load_settings(self):\\n # Set the default settings. In case in a later version of this script the settings change, new default variables will be added automatically\\n self.settings = {\\n # Connection settings to OBS Studio websockets plugin\\n \\\"host\\\": \\\"localhost\\\",\\n \\\"port\\\": 4444,\\n \\\"password\\\": \\\"\\\",\\n \\\"update_frequency\\\": 1, # seconds, how often the script loads the SC2 UI location\\n }\\n if os.path.isfile(self.settings_path):\\n with open(self.settings_path) as f:\\n self.settings.update(json.load(f))\",\n \"def test_existing_attribute(self):\\n self.assertEqual(import_from_setting('TEST_SETTING'), 1)\",\n \"def _load_settings_to_jinja_env(self) :\\n\\t\\t# Load filters if exists\\n\\t\\tif hasattr(self.settings, 'FILTERS') :\\n\\t\\t\\tfor name, cls in utils.load_module(self.settings.FILTERS).__dict__.items() :\\n\\t\\t\\t\\tself.jinja_env.filters[name] = cls\\n\\n\\n\\t\\t# Load globals if exists\\n\\t\\tif hasattr(self.settings, 'GLOBALS') :\\n\\t\\t\\tfor name, cls in utils.load_module(self.settings.GLOBALS).__dict__.items() :\\n\\t\\t\\t\\tself.jinja_env.globals[name] = cls\",\n \"def merge_onto(cls, settings):\\r\\n for key, value in cls.SETTINGS.iteritems():\\r\\n setattr(settings, key, value)\",\n \"def importWebSocketClientSettings(context):\\n site = context.getSite()\\n utility = queryUtility(IWebSocketConnectionConfig, context=site)\\n if utility is None:\\n logger = context.getLogger('collective.websocketclient')\\n logger.info('Nothing to import.')\\n return\\n if IPersistent.providedBy(utility):\\n importObjects(utility, '', context)\",\n \"def settings(self, settings):\\n\\n self._settings = settings\",\n \"async def load(cls, document: str) -> Dict[str, Any]:\\n return await cls.from_html(document)\",\n \"def __init__(self, settings):\\n self._read_config(settings)\",\n \"def import_(self, node):\\n yamal_name = os.path.join(self._root, self.construct_scalar(node))\\n\\n with open(yamal_name, 'r') as yamal_file:\\n return yaml.load(yamal_file, ImportLoader)\",\n \"def __load_settings(self):\\n\\n self.app_settings = sublime.load_settings(self.SETTINGS_FILE)\\n self.__refresh_settings(True)\\n\\n # The settings may change during execution so we need to listen for changes\\n self.app_settings.add_on_change(self.SETTINGS_CALLBACK_KEY, self.__refresh_settings)\",\n \"def patch(cls):\\n cls._original_element = xml.dom.minidom.Element\\n xml.dom.minidom.Element = KmlElement\",\n \"def load_into_settings_module(self, settings_module):\\n\\n if self._api_token:\\n settings_module.API_TOKEN = self._api_token\\n\\n if self._bot_emoji:\\n settings_module.BOT_EMOJI = self._bot_emoji\\n\\n if self._bot_icon:\\n settings_module.BOT_ICON = self._bot_icon\\n\\n if self._errors_to:\\n settings_module.ERRORS_TO = self._errors_to\\n\\n # TODO: Perhaps figure out a better way to do this...\\n settings_module.PLUGINS = set(self._slackbot_plugins)\",\n \"def load(self):\\n if not path.isfile(self.SETTINGS_FILE):\\n return\\n data = load_json_from_disk(self.SETTINGS_FILE)\\n for (key, value) in data.items():\\n self.__dict__[key] = value\",\n \"def _load_settings(self):\\n self._dll.LS_LoadSettings(self._serial_number)\\n return None\",\n \"async def settings(self, ctx: BBContext):\\n pass\",\n \"def updateSettings(self):\\n self.parser.read(self.file)\\n self.showTicker = self.parser.getboolean('Settings', 'showTicker')\\n self.verbose = self.parser.getboolean('Settings', 'verbose')\\n self.sleepTime = self.parser.getint('Settings', 'sleeptime')\\n self.saveGraph = self.parser.getboolean('Settings', 'saveGraph')\\n self.graphDPI = self.parser.getint('Settings', 'graphDPI')\",\n \"def settings_load(self):\\n self.ui.spinBox_ATSP.setValue(self.default['ATSP'])\\n\\n if self.default['serialLabel'] == 'bt':\\n self.ui.btRadio.setChecked(True)\\n try:\\n os.system(\\\"blueman-manager\\\")\\n except:\\n print \\\"Please install 'blueman' package\\\"\\n elif self.default['serialLabel'] == 'usb':\\n self.ui.usbRadio.setChecked(True)\\n else:\\n self.ui.devRadio.setChecked(True)\\n\\n if self.default['units'] == 'metric':\\n self.ui.units_metric_radio.setChecked(True)\\n else:\\n self.ui.units_US_radio.setChecked(True)\\n\\n return\",\n \"def __init__(self) -> None:\\n self._settings = {}\\n\\n # Load values from global_settings (only uppercase)\\n self.filter_and_set(global_settings)\\n\\n settings_env_value: str = os.environ.get(SETTINGS_ENV)\\n if settings_env_value:\\n # Load values from custom settings\\n try:\\n module = importlib.import_module(settings_env_value)\\n except ModuleNotFoundError:\\n msg = \\\"Can't import custom settings. Is it under PYTHONPATH?\\\"\\n raise ModuleError(msg)\\n self.filter_and_set(module)\",\n \"def parse(cls, dom, configDir, fileName, strict=True):\\n topComment = None\\n rcNode = None\\n for kid in dom.childNodes:\\n if kid.nodeType == Node.TEXT_NODE:\\n continue\\n\\n if kid.nodeType == Node.COMMENT_NODE:\\n topComment = kid.nodeValue\\n continue\\n\\n if kid.nodeType == Node.ELEMENT_NODE:\\n if kid.nodeName == \\\"runConfig\\\":\\n if rcNode is None:\\n rcNode = kid\\n else:\\n msg = \\\"Found multiple <runConfig> tags in %s\\\" % \\\\\\n fileName\\n raise ProcessError(msg)\\n\\n if rcNode is None:\\n raise ProcessError(\\\"No <runConfig> tag found in %s\\\" % fileName)\\n\\n domcfgDir = os.path.join(configDir, \\\"domconfigs\\\")\\n\\n runCfg = DAQConfig(fileName)\\n if topComment is not None:\\n runCfg.setTopComment(topComment)\\n\\n for kid in rcNode.childNodes:\\n if kid.nodeType == Node.TEXT_NODE:\\n continue\\n\\n if kid.nodeType == Node.COMMENT_NODE:\\n continue\\n\\n if kid.nodeType == Node.ELEMENT_NODE:\\n if kid.nodeName == \\\"domConfigList\\\":\\n if kid.attributes is None or len(kid.attributes) == 0:\\n hub = None\\n else:\\n if len(kid.attributes) != 1:\\n raise ProcessError((\\\"<%s> node has extra\\\" +\\n \\\" attributes\\\") % kid.nodeName)\\n attrName = \\\"hub\\\"\\n if not kid.attributes.has_key(attrName):\\n raise ProcessError((\\\"<%s> node should have\\\" +\\n \\\" \\\\\\\"%s\\\\\\\" attribute, not\\\" +\\n \\\" \\\\\\\"%s\\\\\\\"\\\") %\\n (kid.nodeName, attrName,\\n kid.attributes.keys()[0]))\\n\\n hub = int(kid.attributes[attrName].value)\\n\\n dcName = cls.getChildText(kid).strip()\\n if hub is None or cls.PARSE_DOM_CONFIG:\\n domCfg = DomConfigParser.load(dcName, domcfgDir,\\n strict)\\n runCfg.addDomConfig(domCfg, hub)\\n else:\\n runCfg.addDomConfigName(dcName, hub)\\n elif kid.nodeName == \\\"triggerConfig\\\":\\n trigCfg = cls.getChildText(kid)\\n cls.__parseTriggerConfig(configDir, trigCfg)\\n runCfg.setTriggerConfig(trigCfg)\\n elif kid.nodeName == \\\"hubFiles\\\":\\n if kid.attributes is None or len(kid.attributes) == 0:\\n raise ProcessError(\\\"<%s> node has no attributes\\\" %\\n kid.nodeName)\\n if len(kid.attributes) != 1:\\n raise ProcessError(\\\"<%s> node has extra attributes\\\" %\\n kid.nodeName)\\n attrName = \\\"baseDir\\\"\\n if not kid.attributes.has_key(attrName):\\n raise ProcessError((\\\"<%s> node should have \\\\\\\"%s\\\\\\\"\\\" +\\n \\\" attribute, not \\\\\\\"%s\\\\\\\"\\\") %\\n (kid.nodeName, attrName,\\n kid.attributes.keys()[0]))\\n\\n runCfg.setReplayBaseDir(kid.attributes[attrName].value)\\n\\n cls.__parseHubFiles(kid, runCfg)\\n elif kid.nodeName == \\\"stringHub\\\":\\n cls.__parseSenderOption(kid, runCfg)\\n elif kid.nodeName == \\\"runComponent\\\":\\n if kid.attributes is None or len(kid.attributes) == 0:\\n raise ProcessError(\\\"<%s> node has no attributes\\\" %\\n kid.nodeName)\\n if len(kid.attributes) != 1:\\n raise ProcessError(\\\"<%s> node has extra attributes\\\" %\\n kid.nodeName)\\n if not kid.attributes.has_key(\\\"name\\\"):\\n raise ProcessError((\\\"<%s> node should have \\\\\\\"name\\\\\\\"\\\" +\\n \\\" attribute, not \\\\\\\"%s\\\\\\\"\\\") %\\n (kid.nodeName,\\n kid.attributes.keys()[0]))\\n\\n runCfg.addComponent(kid.attributes[\\\"name\\\"].value, strict)\\n elif kid.nodeName == \\\"watchdog\\\":\\n valStr = kid.attributes[\\\"period\\\"].value\\n try:\\n period = int(valStr)\\n except:\\n raise ProcessError((\\\"<%s> node has invalid\\\" +\\n \\\" \\\\\\\"period\\\\\\\" value \\\\\\\"%s\\\\\\\"\\\") %\\n (kid.nodeName, valStr))\\n runCfg.setWatchdogPeriod(period)\\n elif kid.nodeName == \\\"monitor\\\":\\n valStr = kid.attributes[\\\"period\\\"].value\\n try:\\n period = int(valStr)\\n except:\\n raise ProcessError((\\\"<%s> node has invalid\\\" +\\n \\\" \\\\\\\"period\\\\\\\" value \\\\\\\"%s\\\\\\\"\\\") %\\n (kid.nodeName, valStr))\\n runCfg.setMonitorPeriod(period)\\n elif kid.nodeName == \\\"defaultLogLevel\\\":\\n pass\\n elif kid.nodeName == \\\"stream\\\":\\n if cls.STRAY_STREAM_HACK:\\n cls.__parseStrayStream(kid, runCfg)\\n else:\\n print >>sys.stderr, \\\"Ignoring stray <stream> in %s\\\" % \\\\\\n fileName\\n else:\\n raise ProcessError(\\\"Unknown runConfig node <%s> in %s\\\" %\\n (kid.nodeName, fileName))\\n continue\\n\\n raise ProcessError(\\\"Found unknown runConfig node <%s>\\\" %\\n kid.nodeName)\\n\\n if strict:\\n runCfg.validate()\\n\\n return runCfg\",\n \"def __init__(self, element):\\n self._element = element\\n self._element.SetTemplateValue('importManager', self)\\n self._class_name_to_qualified_name = {}\\n self._google_imports = set()\\n self._other_imports = set()\\n self._java_imports = set()\",\n \"def setUp(self):\\n self.scraped = SimpleContent(Selector.from_text(SIMPLE_HTML))\",\n \"def project_settings(request):\\n webnode_settings = kakocase_settings(request)\\n webnode_settings['settings']['IS_WEBNODE'] = True\\n return webnode_settings\",\n \"def load(self):\\n for field in self.fields:\\n value = self.siteconfig.get(field)\\n self.fields[field].initial = value\\n\\n if field in self.disabled_fields:\\n self.fields[field].widget.attrs['disabled'] = 'disabled'\",\n \"def load_settings(self, outfile='settings.p'):\\n settings = pickle.load(open(path,'rb'))\\n self.__dict__.update(settings)\",\n \"def _import():\\n global webbrowser, contextlib, yaml, psutil, snakemake, logger, setup_logger, xdg, datetime, _logging\\n import yaml\\n import psutil\\n import webbrowser\\n import contextlib\\n import datetime\\n\\n import snakemake\\n from snakemake.logging import logger, setup_logger, _logging\\n import xdg\",\n \"def load_form_settings(self, group, item):\\n settings = QSettings(self._company, self._section)\\n settings.beginGroup(group)\\n self.restoreState(settings.value(item, QByteArray()))\\n self.restoreGeometry(settings.value(item, QByteArray()))\\n settings.endGroup()\",\n \"def setup(self):\\r\\n self.text_input_values = {}\\r\\n if self.tag == 'radiotextgroup':\\r\\n self.html_input_type = \\\"radio\\\"\\r\\n elif self.tag == 'checkboxtextgroup':\\r\\n self.html_input_type = \\\"checkbox\\\"\\r\\n else:\\r\\n raise Exception(\\\"ChoiceGroup: unexpected tag {0}\\\".format(self.tag))\\r\\n\\r\\n if self.value == '':\\r\\n # Make `value` an empty dictionary, if it currently has an empty\\r\\n # value. This is necessary because the template expects a\\r\\n # dictionary.\\r\\n self.value = {}\\r\\n self.choices = self.extract_choices(self.xml)\",\n \"def from_xml_node(cls, xml_node):\\n from_ = get_xml_text_value(xml_node, xml_tags.Elements.FROM)\\n to = get_xml_text_value(xml_node, xml_tags.Elements.TO)\\n return cls(xml_tags.Elements.SRC, from_, to)\",\n \"def __load(self, node):\\n\\n self.tiles = node['data']\\n self.name = node['name']\\n self.opacity = node['opacity']\\n self.visible = node['visible']\",\n \"def importMasterSettings(self):\\n\\t\\tpickleData = pickle.load( open( self.masterPath.path, \\\"rb\\\" ) )\\n\\t\\tmaster = rlayer.RenderLayer( 'defaultRenderLayer' )\\n\\t\\tmaster.makeCurrent()\\n\\t\\tfor a in pickleData.keys():\\n\\t\\t\\ttry:\\n\\t\\t\\t\\ta.v = pickleData[a]\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tcontinue\",\n \"def parseDomNode(self,node):\\n if node.nodeType != dom.Node.ELEMENT_NODE and node.nodeType != dom.Node.DOCUMENT_NODE:\\n return\\n name=node.tagName\\n handler=avnav_handlerList.findHandlerByConfigName(name)\\n if handler is not None:\\n AVNLog.info(\\\"parsing entry for handler %s\\\",name)\\n self.parseHandler(node,handler)\\n else:\\n nextElement=node.firstChild\\n while nextElement is not None:\\n self.parseDomNode(nextElement)\\n nextElement=nextElement.nextSibling\",\n \"def parseDomNode(self,node):\\n if node.nodeType != dom.Node.ELEMENT_NODE and node.nodeType != dom.Node.DOCUMENT_NODE:\\n return\\n name=node.tagName\\n handler=avnav_handlerList.findHandlerByConfigName(name)\\n if handler is not None:\\n AVNLog.info(\\\"parsing entry for handler %s\\\",name)\\n self.parseHandler(node,handler)\\n else:\\n nextElement=node.firstChild\\n while nextElement is not None:\\n self.parseDomNode(nextElement)\\n nextElement=nextElement.nextSibling\",\n \"def from_html(self, content):\\r\\n pass\",\n \"def _parse_preset(self, xmldata):\\r\\n\\r\\n raise NotImplementedError\",\n \"def startup(self):\\n self.settings = sublime.load_settings(self.settings_base)\\n self.sublime_settings = sublime.load_settings(self.sublime_base)\",\n \"def import_registry_settings(site):\\n PROFILE_ID = 'profile-interlegis.portalmodelo.policy:default'\\n setup = api.portal.get_tool('portal_setup')\\n setup.runImportStepFromProfile(PROFILE_ID, 'plone.app.registry')\",\n \"def FromXML(cls, doc, element, default=\\\"absolute\\\"):\\n return cls(element.get(\\\"type\\\", default), NumberDef(element.text))\",\n \"def from_xml_node(cls, xml_node):\\n raise NotImplementedError(\\\"from_xml_node must be implemented by derived classes.\\\")\",\n \"def importXml ( r ):\\n rawText = r.read ()\\n rawText = rawText.strip ()\\n pattern = re.compile (r'[^\\\\S ]+')\\n text = re.sub ( pattern, '', rawText )\\n xml = ET.fromstring ( text )\\n assert str ( type ( xml ) ) == \\\"<type 'instance'>\\\"\\n return xml\",\n \"def loadSettings(self, filename='short_240.settings'):\\n global master_run_no\\n self.settingsFilename = filename\\n # print 'self.settingsFilename = ', self.settingsFilename\\n if os.path.exists(filename):\\n stream = open(filename, 'r')\\n else:\\n stream = open(master_lattice_location+filename, 'r')\\n self.settings = yaml.load(stream, Loader=yaml.UnsafeLoader)\\n self.globalSettings = self.settings['global']\\n master_run_no = self.globalSettings['run_no'] if 'run_no' in self.globalSettings else 1\\n self.fileSettings = self.settings['files']\\n elements = self.settings['elements']\\n self.groups = self.settings['groups'] if 'groups' in self.settings and self.settings['groups'] is not None else {}\\n stream.close()\\n\\n # for name, elem in list(self.groups.items()):\\n # group = globals()[elem['type']](name, self.elementObjects, **elem)\\n # self.groupObjects[name] = group\\n\\n for name, elem in list(elements.items()):\\n self.read_Element(name, elem)\\n\\n # for name, lattice in list(self.fileSettings.items()):\\n # self.read_Lattice(name, lattice)\",\n \"def __setup(self, SETTINGS_FILE):\\n config = ConfigParser()\\n try:\\n config.read(SETTINGS_FILE)\\n self.settings = Settings(config)\\n self.data = Data()\\n except IOError:\\n raise FileMissing(SETTINGS_FILE)\\n except Exception as e:\\n raise e\",\n \"def load_settings(env=\\\"prod\\\"):\\n global config\\n config = configparser.SafeConfigParser()\\n config.read(CONFIG_FILES.get(env))\",\n \"def __enter__(self):\\n self.root = ET.parse(self.manifest).getroot()\\n self._parse_content()\\n return self\",\n \"def parser(self):\\n\\t\\tdom = ET.parse(self.input_filename)\\n\\t\\tself.doc = dom.getroot()\",\n \"def _init_node_attributes(self):\\n assert False\",\n \"def create_dd_settings(xml_document, parent_element):\\n dd_properties_element = xml_document.createElement(\\\"dd_properties\\\")\\n parent_element.appendChild(dd_properties_element)\\n\\n option_element = xml_document.createElement(\\\"Option\\\")\\n option_element.setAttribute('type', 'Map')\\n dd_properties_element.appendChild(option_element)\\n\\n option_child1_element = xml_document.createElement(\\\"Option\\\")\\n option_child1_element.setAttribute('type', 'QString')\\n option_child1_element.setAttribute('name', 'name')\\n option_child1_element.setAttribute('value', '')\\n option_element.appendChild(option_child1_element)\\n\\n option_child2_element = xml_document.createElement(\\\"Option\\\")\\n option_child2_element.setAttribute('name', 'properties')\\n option_element.appendChild(option_child2_element)\\n\\n option_child3_element = xml_document.createElement(\\\"Option\\\")\\n option_child3_element.setAttribute('type', 'QString')\\n option_child3_element.setAttribute('name', 'type')\\n option_child3_element.setAttribute('value', 'collection')\\n option_element.appendChild(option_child3_element)\",\n \"def load_cElementTree(finder, module):\\n finder.IncludeModule(\\\"elementtree.ElementTree\\\")\",\n \"def load_data(self):\\n with open(self.FILE, 'r') as html_file:\\n document = html_file.read()\\n self.HTML = document\",\n \"def __init__( settings={} ):\",\n \"def import_from_string(val, setting_name):\\n try:\\n return import_string(val)\\n except ImportError as e:\\n raise e\",\n \"def setup_parser(self, parser):\",\n \"def perform_import(val, setting_name):\\n if val is None:\\n return None\\n elif isinstance(val, str):\\n return import_from_string(val, setting_name)\\n elif isinstance(val, (list, tuple)):\\n return [import_from_string(item, setting_name) for item in val]\\n return val\",\n \"def load(self):\\n\\n from django.conf import settings as st\\n\\n loaded: namedtuple = default\\n\\n if hasattr(st, 'AUTOMATED_LOGGING'):\\n loaded = ConfigSchema().load(st.AUTOMATED_LOGGING)\\n\\n # be sure `loaded` has globals as we're working with those,\\n # if that is not the case early return.\\n if not hasattr(loaded, 'globals'):\\n return loaded\\n\\n # use the binary **or** operator to apply globals to Set() attributes\\n values = {}\\n for name in loaded._fields:\\n field = getattr(loaded, name)\\n values[name] = field\\n\\n if not isinstance(field, tuple) or name == 'globals':\\n continue\\n\\n values[name] = field | loaded.globals\\n\\n self.loaded = loaded._replace(**values)\\n return self\",\n \"def from_node(self, root):\\n \\n self.set_at_from_string(root.getAttribute(\\\"at\\\"))\\n self.action = root.getAttribute(\\\"action\\\")\\n self.actor = root.getAttribute(\\\"actor\\\")\\n self.regarding = root.getAttribute(\\\"regarding\\\")\\n self.source = root.getAttribute(\\\"source\\\")\\n self.tags = root.getAttribute(\\\"tags\\\").split(\\\",\\\")\\n self.to = root.getAttribute(\\\"to\\\")\\n self.url = root.getAttribute(\\\"url\\\")\\n\\n for node in root.childNodes:\\n if node.tagName == 'payload':\\n for subnode in node.childNodes:\\n if subnode.tagName == 'body':\\n self.body = subnode.childNodes[0].nodeValue\\n elif subnode.tagName == 'raw':\\n self.raw = subnode.childNodes[0].nodeValue\",\n \"def Import(content: bytes):\\n config_set = _ParseConfigSet(content)\\n\\n # Remove any older data\\n info = config_set.info\\n if info and info.key.get():\\n Delete(info.url)\\n\\n config_encoder.Load(config_set)\\n info.put()\\n return mtt_messages.Convert(info, mtt_messages.ConfigSetInfo)\",\n \"def read(self):\\r\\n tree = ElementTree(file=self._fn)\\r\\n self._root = tree.getroot()\\r\\n for prop in self.prpnames:\\r\\n self.__setattr__(prop, DocItem.get_attr(self, prop))\",\n \"def replace(*args, **kwds):\\n ns = utils.ns_prepare(args + (kwds,), install=False)\\n settings = utils.settings_from_ns(ns, update=True)\\n return settings\",\n \"def und_add_setting(udb_file, configuration_path_file):\\n subprocess.call(f\\\"und import {configuration_path_file} {udb_file}\\\")\",\n \"def manual_import_prop(self, path):\\n dtu = DtuLoader.DtuLoader(path)\\n fbx_path = dtu.get_fbx_path()\\n self.prop_import(fbx_path, dtu)\",\n \"def initParser():\\n libxml2mod.xmlInitParser()\",\n \"def parse_element(self, element):\\n if element.firstChild:\\n self.url = element.firstChild.data\\n else:\\n # This happens with these 'cache' url's. Need to figure\\n # out where the cache _comes from_\\n #\\n self.url = None\\n\\n self.spoof_url = element.getAttribute(\\\"spoof\\\")\\n if element.hasAttribute(\\\"post\\\"):\\n self.use_post = True\\n self.function = element.getAttribute(\\\"function\\\")\\n self.cache_key = element.getAttribute(\\\"cache\\\")\\n return\",\n \"def merge_into_settings(self, settings):\\n if not self._meta_dict:\\n self._load_from_file()\\n\\n settings.chat_name = self._meta_dict[DumpMetadata.CHAT_NAME]\\n settings.last_message_id = self._meta_dict[DumpMetadata.LAST_MESSAGE_ID]\\n settings.exporter = self._meta_dict[DumpMetadata.EXPORTER]\",\n \"def __init__(self, element, parent):\\n super(XMLObj, self).__setattr__('element', element)\\n super(XMLObj, self).__setattr__('parent', parent)\",\n \"def update(self):\\n registry = getUtility(IRegistry)\\n site_settings = registry.forInterface(\\n ISiteSchema, prefix=\\\"plone\\\", check=False)\\n try:\\n if site_settings.webstats_js:\\n self.webstats_js = site_settings.webstats_js\\n except AttributeError:\\n pass\",\n \"def _local_settings(cls):\\n # type: () -> QSettings\\n filename = \\\"{}.ini\\\".format(qname(cls))\\n fname = os.path.join(settings.widget_settings_dir(), filename)\\n return QSettings(fname, QSettings.IniFormat)\",\n \"def load_settings(self):\\n # config file from branch's asdf\\n config_exists = os.path.isfile(self.config_path)\\n\\n if config_exists:\\n\\n config_file = open(self.config_path, 'r')\\n self.config_json = json.load(config_file)\\n config_file.close()\\n\\n else:\\n raise Exception(\\\"Error BranchConfig: could not find config json\\\")\\n\\n\\n try:\\n self.branch_settings = self.config_json[self.branch]\\n\\n self.branch_keys = self.branch_settings.keys()\\n\\n for attr in self.branch_keys:\\n setattr(self, attr, self.branch_settings[attr])\\n\\n except:\\n raise Exception(\\\"Error BranchConfig: could not add config settings to BranchConfig\\\")\",\n \"def loadState(self, e, force=False):\\n if e.tag == self.type and e.get('name') == self.name:\\n c = e\\n else:\\n c = e.find(\\\".//\\\" + self.type + \\\"[@name='\\\" + self.name + \\\"']\\\")\\n if c is None:\\n print \\\"Error: no settings found for constrain %s\\\" % self.name\\n return c\",\n \"def settings(self):\\n if self._settings is not None:\\n return self._settings\\n\\n settings = self.binaries['KeeAgent.settings'].content\\n self._settings = objectify.fromstring(settings)\\n return self._settings\",\n \"def loadSettings(self, e):\\n c = constrain.loadSettings(self, e)\\n g = c.get(\\\"status\\\")\\n self.status = (g == 'true')\\n return c\",\n \"def initialize_from_config(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6894675","0.54793346","0.5375706","0.5349439","0.5210967","0.50370497","0.4952911","0.49231037","0.48926273","0.48800564","0.48647884","0.48480543","0.4817451","0.48003417","0.47981542","0.4741064","0.47284755","0.4716894","0.46843192","0.46814933","0.46778256","0.46706027","0.46440727","0.4634674","0.4625217","0.4621957","0.45781228","0.4509231","0.44961867","0.4485351","0.4480031","0.44643733","0.44509986","0.44103476","0.44033888","0.44006848","0.44006535","0.4397514","0.43944123","0.43914422","0.43876126","0.43835935","0.43554395","0.43430358","0.43424395","0.4314916","0.43039533","0.43020722","0.43002424","0.42918053","0.42823103","0.42788786","0.42771068","0.42737967","0.42620355","0.42548457","0.4247327","0.4230496","0.42266855","0.42262256","0.42236567","0.42236567","0.4222754","0.42200315","0.4213155","0.42118838","0.42090464","0.42079955","0.42071232","0.42018622","0.4200755","0.4199474","0.41993335","0.41938096","0.419037","0.41894284","0.4185671","0.41811442","0.4180572","0.4175985","0.41755456","0.41657242","0.4155714","0.41553324","0.41524252","0.41489792","0.4144594","0.41417894","0.4133762","0.41258964","0.41214764","0.41185024","0.41177705","0.41177008","0.41171342","0.41052985","0.41025075","0.41022035","0.4095539","0.40901476"],"string":"[\n \"0.6894675\",\n \"0.54793346\",\n \"0.5375706\",\n \"0.5349439\",\n \"0.5210967\",\n \"0.50370497\",\n \"0.4952911\",\n \"0.49231037\",\n \"0.48926273\",\n \"0.48800564\",\n \"0.48647884\",\n \"0.48480543\",\n \"0.4817451\",\n \"0.48003417\",\n \"0.47981542\",\n \"0.4741064\",\n \"0.47284755\",\n \"0.4716894\",\n \"0.46843192\",\n \"0.46814933\",\n \"0.46778256\",\n \"0.46706027\",\n \"0.46440727\",\n \"0.4634674\",\n \"0.4625217\",\n \"0.4621957\",\n \"0.45781228\",\n \"0.4509231\",\n \"0.44961867\",\n \"0.4485351\",\n \"0.4480031\",\n \"0.44643733\",\n \"0.44509986\",\n \"0.44103476\",\n \"0.44033888\",\n \"0.44006848\",\n \"0.44006535\",\n \"0.4397514\",\n \"0.43944123\",\n \"0.43914422\",\n \"0.43876126\",\n \"0.43835935\",\n \"0.43554395\",\n \"0.43430358\",\n \"0.43424395\",\n \"0.4314916\",\n \"0.43039533\",\n \"0.43020722\",\n \"0.43002424\",\n \"0.42918053\",\n \"0.42823103\",\n \"0.42788786\",\n \"0.42771068\",\n \"0.42737967\",\n \"0.42620355\",\n \"0.42548457\",\n \"0.4247327\",\n \"0.4230496\",\n \"0.42266855\",\n \"0.42262256\",\n \"0.42236567\",\n \"0.42236567\",\n \"0.4222754\",\n \"0.42200315\",\n \"0.4213155\",\n \"0.42118838\",\n \"0.42090464\",\n \"0.42079955\",\n \"0.42071232\",\n \"0.42018622\",\n \"0.4200755\",\n \"0.4199474\",\n \"0.41993335\",\n \"0.41938096\",\n \"0.419037\",\n \"0.41894284\",\n \"0.4185671\",\n \"0.41811442\",\n \"0.4180572\",\n \"0.4175985\",\n \"0.41755456\",\n \"0.41657242\",\n \"0.4155714\",\n \"0.41553324\",\n \"0.41524252\",\n \"0.41489792\",\n \"0.4144594\",\n \"0.41417894\",\n \"0.4133762\",\n \"0.41258964\",\n \"0.41214764\",\n \"0.41185024\",\n \"0.41177705\",\n \"0.41177008\",\n \"0.41171342\",\n \"0.41052985\",\n \"0.41025075\",\n \"0.41022035\",\n \"0.4095539\",\n \"0.40901476\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58705205"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":95599,"cells":{"query":{"kind":"string","value":"Label watersheds based on Barnes' priority flood algorithm"},"document":{"kind":"string","value":"def watersheds(np.ndarray[dtype=float_t, ndim=2, mode=\"c\"] z, missing_value = 0):\n cdef np.ndarray[dtype=int_t, ndim=2, mode=\"c\"] output\n output = np.empty_like(z, dtype='i')\n \n priority_flood_c.priority_flood_watersheds_wrapper(z.shape[1], z.shape[0], <float*>z.data, <int*>output.data, missing_value)\n return output"},"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 watershed_supervised(graph, seeds):\n \n size_data = graph.shape[0]\n \n u, v, w = sp.sparse.find(graph)\n list_edges = list(zip(u,v,w))\n list_edges.sort(key = lambda x : x[2])\n \n UF = unionfind(size_data)\n labels = np.array(seeds, dtype=np.int32, copy=True)\n \n for e in list_edges:\n ex, ey, ew = e\n px, py = UF.find(ex), UF.find(ey)\n if px != py:\n lx, ly = labels[px], labels[py]\n if (lx != 0) and (ly !=0 ):\n # Both are labelled. Do nothing\n pass\n else:\n max_label = max(lx, ly) # Pick the non-zero label!!\n labels[px], labels[py] = max_label, max_label\n UF.union(ex, ey)\n \n \n ans = np.array([labels[UF.find(x)] for x in range(size_data) ] )\n \n# assert np.all(ans>0)\n \n return ans","def powerWatershed_multipleLabels(graph, seeds, bucketing='kmeans', eps=1e-2, k=3, beta=5., eps_weight=1e-6):\n\n ans = []\n for i in np.sort(np.unique(seeds)):\n if i > 0:\n seed_tmp = np.array((seeds == i)*1, dtype=np.int32) + 1\n seed_tmp[np.where(seeds == 0)] = 0\n ans.append(powerWatershed(graph, seed_tmp, bucketing, eps, k, beta, eps_weight))\n return np.argmax(ans, 0) + 1","def powerWatershed(graph, seeds, bucketing='kmeans', eps=1e-2, k=3, beta=5., eps_weight=1e-6):\n\n size = graph.shape[0]\n\n graph_tmp = csr_matrix(graph, copy=True)\n graph_tmp.data = np.exp(-1*beta*graph_tmp.data/graph_tmp.data.std()) + eps_weight\n \n labels = np.array(seeds, dtype=np.float64) - 1\n\n uf = unionfind(size)\n\n edge_generator = generate_edges(graph_tmp, bucketing, eps, k)\n edges_till_now = []\n for edges in edge_generator:\n\n # Add all the edges to the graph\n for e in edges:\n uf.union(e[0], e[1])\n\n edges_till_now += edges\n\n for (_, comp) in uf.generate_comps():\n label_unique = set(np.unique(labels[comp]))\n\n # continue if all points in the component are labelled\n if -1 not in label_unique:\n continue\n\n # othwerwise solve rw\n if len(label_unique) <= 2:\n l = max(label_unique)\n labels[comp] = l\n\n if len(label_unique) > 2:\n _randomwalkV2(graph, labels, comp, beta, eps_weight)\n\n return labels","def watershed(img):\n\ttmp = img.copy()\n\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n\tkernel = np.ones((3,3), np.uint8)\n\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\n\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\n\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\n\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\n\tsure_fg = np.uint8(sure_fg)\n\tunknown = cv2.subtract(sure_bg, sure_fg)\n\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\n\tmarkers = markers+1\n\tmarkers[unknown==255] = 0\n\tmarkers = cv2.watershed(tmp, markers)\n\ttmp[markers == -1] = [255,0,0]\n\treturn tmp","def heuristic2B_label_OBD(n, P, label, critical=None):\n nodes_labeled = []\n\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\n new_label = label + 1\n \n neighbors = P.neighbors(n)\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys(): # if it has a label\n if P.node[neigh]['OBDlabel'] > new_label: # and it is higher than what I would use for labeling\n new_label = P.node[neigh]['OBDlabel']\n # we got maximum of current label or any node that neighbors have - now we label them all with that\n \n neighbors_to_label = []\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\n neighbors_to_label.append(neigh)\n else: # if set and smaller than mine, leave them alone\n pass\n else: # if not set, then not lower and not labelled\n neighbors_to_label.append(neigh)\n # now we have all the neighbors that need to be labeled\n \n if len(neighbors_to_label) > 1:\n flag_critical = True\n # and now labeling all these nodes\n \n for neigh in neighbors_to_label:\n if ('critical' in P.node[neigh].keys()) and (P.node[neigh]['critical']==True) and (P.node[neigh]['OBDlabel'] != new_label) :\n return (False, nodes_labeled) # being critical, we could avoid failure only if the label to set would be the same (it happens)\n else:\n P.node[neigh]['OBDlabel'] = new_label\n nodes_labeled.append(neigh) # this is a list that gets passed through recursions\n if flag_critical == True:\n P.node[neigh]['critical'] = True\n # labeling part done\n \n # and now recursive step - going into each neighbor to continue, in any order if necessary\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\n for perm in permutations:\n this_run_success = True\n this_run_labeled = []\n for el in perm:\n (s, nl) = heuristic2B_label_OBD(el, P, new_label, flag_critical)\n this_run_labeled = this_run_labeled + nl\n if s == False:\n this_run_success = False\n if this_run_success == False:\n # then unlabel all that were labelled up to now\n for nn in this_run_labeled:\n P.node[nn]['OBDlabel'] = None\n P.node[nn]['critical'] = False\n else: # obviously success is True, we managed to label all others...\n nodes_labeled = nodes_labeled + this_run_labeled\n return (True, nodes_labeled)\n break\n # if no permutation is successful, we end up returning the last line\n return (False, nodes_labeled)","def propagate_labels_majority(image,labels):\n rlabels,_ = label(image)\n cors = correspondences(rlabels,labels)\n outputs = zeros(amax(rlabels)+1,'i')\n counts = zeros(amax(rlabels)+1,'i')\n for rlabel, label_, count in cors.T:\n if not rlabel or not label_:\n # ignore background correspondences\n continue\n if counts[rlabel] < count:\n outputs[rlabel] = label_\n counts[rlabel] = count\n outputs[0] = 0\n return outputs[rlabels]","def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\n\n kernel = np.ones((5, 5), np.float32)\n\n # Use a distance transform to find the seed points for watershed\n tmp = class_mask\n tmp[tmp>0] = 1 # here\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\n dist = (dist / np.max(dist)) * 255.\n\n # Since there may be multiple peaks, we use dilation to find them\n dilate = cv2.dilate(dist, kernel, iterations=3)\n peaks = np.float32(np.where(dilate == dist, 1, 0))\n peaks = peaks * class_mask * 255\n\n sure_fg = np.where(peaks > 125, 255., 0.)\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\n sure_fg = np.uint8(sure_fg)\n\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\n unknown = sure_bg - sure_fg\n\n # Add one to all labels so that known background is not 0, but 1\n _, markers = cv2.connectedComponents(sure_fg)\n markers = markers + 1\n\n markers[unknown == 255] = 0\n\n markers = cv2.watershed(self.image, markers)\n\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\n watershed_superpixels[markers == -1] = 255\n\n return watershed_superpixels","def kohonen():\n# plb.close('all')\n \n dim = 28*28\n data_range = 255.0\n \n # load in data and labels \n data = np.array(np.loadtxt('data.txt'))\n labels = np.loadtxt('labels.txt')\n\n # select 4 digits \n name = \"Stettler\"\n targetdigits = name2digits(name) # assign the four digits that should be used\n print(targetdigits) # output the digits that were selected\n\n # this selects all data vectors that corresponds to one of the four digits\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\n \n dy, dx = data.shape\n \n #set the size of the Kohonen map. In this case it will be 6 X 6\n size_k = 6\n \n #set the width of the neighborhood via the width of the gaussian that\n #describes it\n sigma = 2.0\n \n #initialise the centers randomly\n centers = np.random.rand(size_k**2, dim) * data_range\n \n #build a neighborhood matrix\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\n\n #set the learning rate\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\n \n #set the maximal iteration count\n tmax = 5000 # this might or might not work; use your own convergence criterion\n \n #set the random order in which the datapoints should be presented\n i_random = np.arange(tmax) % dy\n np.random.shuffle(i_random)\n \n for t, i in enumerate(i_random):\n som_step(centers, data[i,:],neighbor,eta,sigma)\n\n # for visualization, you can use this:\n for i in range(size_k**2):\n plb.subplot(size_k,size_k,i)\n \n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\n plb.axis('off')\n \n # leave the window open at the end of the loop\n plb.show()\n plb.draw()","def labelNeighbours26(data, label, x0,y0,z0, index):\n shape = label.shape;\n for xp in range(max(0,-1+x0),min(2+x0, shape[0])):\n for yp in range(max(0,-1+y0),min(2+y0, shape[1])):\n for zp in range(max(0,-1+z0),min(2+z0, shape[2])):\n if data[xp,yp,zp] and label[xp,yp,zp] == 0:\n label[xp,yp,zp] = index;\n label = labelNeighbours26(data, label, xp,yp,zp, index);\n return label;","def heuristic2_label_OBD(n, P, label, critical=None):\n print \"trying to label \" + str(n) + \" with \" + str(label)\n nodes_labeled = []\n if ('critical' in P.node[n].keys()) and (P.node[n]['critical']==True) and (P.node[n]['OBDlabel'] != label) :\n print \"FAIL on critical and not the same label.\"\n return (False, []) # being critical, we could avoid failure only if the label to set would be the same (it happens)\n else:\n P.node[n]['OBDlabel'] = label\n nodes_labeled.append(n) # this is a list that gets passed through recursions\n if critical == True:\n P.node[n]['critical'] = True\n # labeling part done\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\n new_label = label + 1\n neighbors = P.neighbors(n)\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if P.node[neigh]['OBDlabel'] > new_label:\n new_label = P.node[neigh]['OBDlabel']\n # we got maximum of current label or any node that neighbors have - now we label them all with that\n neighbors_to_label = []\n for neigh in neighbors:\n if 'OBDlabel' in P.node[neigh].keys():\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\n neighbors_to_label.append(neigh)\n else: # if set and smaller than mine, leave them alone\n pass\n else: # if not set, then not lower and not labelled\n neighbors_to_label.append(neigh)\n # now we have all the neighbors that need to be labeled\n if len(neighbors_to_label) > 1:\n flag_critical = True\n # and now the recursive step - labeling all these nodes\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\n for perm in permutations:\n print \"trying perm: \" + str(perm)\n this_run_success = True\n this_run_labeled = []\n for el in perm:\n (s, nl) = heuristic2_label_OBD(el, P, new_label, flag_critical)\n this_run_labeled = this_run_labeled + nl\n if s == False:\n this_run_success = False\n break\n if this_run_success == False:\n # then unlabel all that were labelled up to now\n for nn in this_run_labeled:\n print \"removing label of \" + str(nn)\n P.node[nn]['OBDlabel'] = None\n P.node[nn]['critical'] = False\n else: # obviously success is True, we managed to label all others...\n nodes_labeled = nodes_labeled + this_run_labeled\n print \"Win in labeling neighbors of \" + str(n)\n return (True, nodes_labeled)\n break\n # if no permutation is successful, we end up returning the last line\n return (False, nodes_labeled)\n print \"FAIL of all permutations from \" + str(n)","def watershed(mask, img, plotImage = False, kernelSize = None):\n imgCopy = img.copy()\n maskCopy = np.array(mask.copy(), dtype=np.uint8)\n \n if kernelSize is None:\n kernelSize = 2\n\n # Finding sure foreground area\n #dist_transform = cv2.distanceTransform(mask, cv2.DIST_L2, 5)\n #ret, sure_fg = cv2.threshold(dist_transform,0.3*dist_transform.max(),255,0) #change the second argument to change the sensitivity \n maskClosed = skimage.morphology.closing(np.array(maskCopy, dtype=np.uint8))\n maskClosed = skimage.morphology.closing(np.array(maskClosed, dtype=np.uint8))\n kernel = np.ones((kernelSize,kernelSize), np.uint8)\n # maskCopy = img_as_bool(maskCopy)\n sure_fg = cv2.erode(maskClosed, kernel, iterations = 2) ###\n sure_fg = skimage.morphology.closing(np.array(sure_fg, dtype=np.uint8))\n # kernel = np.ones((2,2), np.uint8)\n # sure_fg = binary_closing(sure_fg, kernel)\n \n # sure background area\n #kernel = np.ones((5, 5), np.uint8)\n #sure_bg = cv2.dilate(mask, kernel, iterations = 1)\n sure_fg_bool = 1 - img_as_bool(sure_fg)\n # sure_bg = np.uint8(1 - morphology.medial_axis(sure_fg_bool)) ### \n sure_bg = np.uint8(1 - morphology.skeletonize(sure_fg_bool))\n sure_bg[0, :] = 1\n sure_bg[-1, :] = 1\n sure_bg[:, 0] = 1\n sure_bg[:, -1] = 1\n \n # Finding unknown region\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n \n if plotImage:\n plt.figure()\n plt.imshow(sure_fg)\n plt.title(\"Inner Marker\")\n plt.figure()\n plt.imshow(sure_bg)\n plt.title(\"Outer Marker\")\n plt.figure()\n plt.imshow(unknown)\n plt.title(\"Unknown\")\n \n # Marker labelling\n ret, markers = cv2.connectedComponents(sure_fg)\n\n # Add one to all labels so that sure background is not 0, but 1\n markers = markers+1\n\n # Now, mark the region of unknown with zero\n markers[unknown==1] = 0\n \n if plotImage:\n plt.figure()\n plt.imshow(markers, cmap='jet')\n plt.title(\"Markers\")\n \n # Do watershed\n markers = cv2.watershed(imgCopy, markers)\n \n imgCopy[markers == -1] = [0, 255 ,0]\n\n if plotImage:\n plt.figure()\n plt.imshow(markers,cmap='jet')\n plt.title(\"Mask\")\n plt.figure()\n plt.imshow(img)\n plt.title(\"Original Image\")\n plt.figure()\n plt.imshow(imgCopy)\n plt.title(\"Marked Image\")\n plt.show()\n\n return markers","def cwatershed(f, g, Bc=None, LINEREG=\"LINES\"):\n from numpy import ones, zeros, nonzero, array, put, take, argmin, transpose, compress, concatenate\n if Bc is None: Bc = secross()\n return g\n print 'starting'\n withline = (LINEREG == 'LINES')\n if isbinary(g):\n g = label(g,Bc)\n print 'before 1. pad4n'\n status = pad4n(to_uint8(zeros(f.shape)),Bc, 3)\n f = pad4n( f,Bc,0) #pad input image\n print 'before 2. pad4n'\n y = pad4n( g,Bc,0) # pad marker image with 0\n if withline:\n y1 = intersec(binary(y), 0)\n costM = limits(f)[1] * ones(f.shape) # cuulative cost function image\n mi = nonzero(gradm(y,sebox(0),Bc).ravel()) # 1D index of internal contour of marker\n print 'before put costM'\n put(costM.ravel(),mi, 0)\n HQueue=transpose([mi, take(costM.ravel(), mi)]) # init hierarquical queue: index,value\n print 'before se2list0'\n Bi=se2list0(f,Bc) # get 1D displacement neighborhood pixels\n x,v = mat2set(Bc)\n while HQueue:\n print 'Hq=',HQueue\n i = argmin(HQueue[:,1]) # i is the index of minimum value\n print 'imin=',i\n pi = HQueue[i,0]\n print 'pi=',pi\n ii = ones(HQueue.shape[0])\n ii[i] = 0\n print 'ii=',ii\n HQueue = transpose(array([compress(ii,HQueue[:,0]),\n compress(ii,HQueue[:,1])])) # remove this pixel from queue\n print 'H=',HQueue\n put(status.ravel(), pi, 1) # make it a permanent label\n for qi in pi+Bi : # for each neighbor of pi\n if (status.flat[qi] != 3): # not image border\n if (status.flat[qi] != 1): # if not permanent\n cost_M = max(costM.flat[pi], f.flat[qi])\n if cost_M < costM.flat[qi]:\n print 'qi=',qi\n costM.flat[qi] = cost_M\n y.flat[qi] = y.flat[pi] # propagate the label\n aux = zeros(array(HQueue.shape) + [1,0])\n aux[:-1,:] = HQueue\n aux[-1,:]=[qi, cost_M]\n HQueue = aux # insert pixel in the queue\n print 'insert H=',HQueue\n elif (withline and\n (y.flat[qi] != y.flat[pi]) and\n (y1.flat[pi] == 0) and\n (y1.flat[qi] == 0) ):\n y1.flat[pi] = 1\n if withline:\n Y = y1\n else:\n Y = y\n return Y","def convert_to_original_labels(array, threshold=0.5, initialization_value=999):\r\n \r\n binarized, belief = get_binarized_and_belief(array=array, threshold=threshold)\r\n \r\n #sanity check\r\n if binarized.shape != belief.shape:\r\n raise ValueError('Sanity check did not pass.')\r\n \r\n # initialize with a crazy label we will be sure is gone in the end\r\n slice_all_but_last_channel = tuple([slice(None) for _ in array.shape[:-1]] + [0])\r\n original_labels = initialization_value * np.ones_like(array[slice_all_but_last_channel])\r\n \r\n # the outer keys correspond to the binarized values\r\n # the inner keys correspond to the order of indices comingn from argsort(ascending) on suspicion, i.e. \r\n # how far the binarized sigmoid outputs were from the original sigmoid outputs \r\n # for example, (2, 1, 0) means the suspicion from least to greatest was: 'WT', 'TC', 'ET'\r\n # (recall that the order of the last three channels is expected to be: 'ET', 'TC', and 'WT')\r\n mapper = {(0, 0, 0): 0, \r\n (1, 1, 1): 4,\r\n (0, 1, 1): 1,\r\n (0, 0, 1): 2,\r\n (0, 1, 0): {(2, 0, 1): 0,\r\n (2, 1, 0): 0, \r\n (1, 0, 2): 1,\r\n (1, 2, 0): 1,\r\n (0, 2, 1): 0,\r\n (0, 1, 2): 1}, \r\n (1, 1, 0): {(2, 0, 1): 0,\r\n (2, 1, 0): 0, \r\n (1, 0, 2): 4,\r\n (1, 2, 0): 4,\r\n (0, 2, 1): 4,\r\n (0, 1, 2): 4},\r\n (1, 0, 1): {(2, 0, 1): 4,\r\n (2, 1, 0): 2, \r\n (1, 0, 2): 2,\r\n (1, 2, 0): 2,\r\n (0, 2, 1): 4,\r\n (0, 1, 2): 4}, \r\n (1, 0, 0): {(2, 0, 1): 0,\r\n (2, 1, 0): 0, \r\n (1, 0, 2): 0,\r\n (1, 2, 0): 0,\r\n (0, 2, 1): 4,\r\n (0, 1, 2): 4}}\r\n \r\n \r\n \r\n done_replacing = False\r\n \r\n for binary_key, inner in mapper.items():\r\n mask1 = check_subarray(array1=binarized, array2=np.array(binary_key))\r\n if isinstance(inner, int):\r\n original_labels, done_replacing = replace_initializations(done_replacing=done_replacing, \r\n array=original_labels, \r\n mask=mask1, \r\n replacement_value=inner, \r\n initialization_value=initialization_value)\r\n else:\r\n for inner_key, inner_value in inner.items():\r\n mask2 = np.logical_and(mask1, check_subarray(array1=belief, array2=np.array(inner_key)))\r\n original_labels, done_replacing = replace_initializations(done_replacing=done_replacing,\r\n array=original_labels, \r\n mask=mask2, \r\n replacement_value=inner_value, \r\n initialization_value=initialization_value)\r\n \r\n if not done_replacing:\r\n raise ValueError('About to return so should have been done replacing but told otherwise.')\r\n \r\n return original_labels.astype(np.uint8)","def island_loss_of_weight(self):\n for y in self.island_map:\n for cell in y:\n cell.loss_of_weight()","def compute_wl_subtree_kernel(graphs, h):\n for G in graphs:\n for node in G.nodes():\n G.node[node]['label'] = G.degree(node)\n\n start_time = time.time()\n\n labels = {}\n label_lookup = {}\n label_counter = 0\n\n N = len(graphs)\n\n orig_graph_map = {it: {i: defaultdict(lambda: 0) for i in range(N)} for it in range(-1, h)}\n\n # initial labeling\n ind = 0\n for G in graphs:\n labels[ind] = np.zeros(G.number_of_nodes(), dtype=np.int32)\n node2index = {}\n for node in G.nodes():\n node2index[node] = len(node2index)\n\n for node in G.nodes():\n label = G.node[node]['label']\n if not label_lookup.has_key(label):\n label_lookup[label] = len(label_lookup)\n\n labels[ind][node2index[node]] = label_lookup[label]\n orig_graph_map[-1][ind][label] = orig_graph_map[-1][ind].get(label, 0) + 1\n\n ind += 1\n\n compressed_labels = copy.deepcopy(labels)\n\n # WL iterations\n for it in range(h):\n unique_labels_per_h = set()\n label_lookup = {}\n ind = 0\n for G in graphs:\n node2index = {}\n for node in G.nodes():\n node2index[node] = len(node2index)\n\n for node in G.nodes():\n node_label = tuple([labels[ind][node2index[node]]])\n neighbors = G.neighbors(node)\n if len(neighbors) > 0:\n neighbors_label = tuple([labels[ind][node2index[neigh]] for neigh in neighbors])\n node_label = str(node_label) + \"-\" + str(sorted(neighbors_label))\n if not label_lookup.has_key(node_label):\n label_lookup[node_label] = len(label_lookup)\n\n compressed_labels[ind][node2index[node]] = label_lookup[node_label]\n orig_graph_map[it][ind][node_label] = orig_graph_map[it][ind].get(node_label, 0) + 1\n\n ind += 1\n\n print \"Number of compressed labels at iteration %s: %s\" % (it, len(label_lookup))\n labels = copy.deepcopy(compressed_labels)\n\n K = np.zeros((N, N))\n\n for it in range(-1, h):\n for i in range(N):\n for j in range(N):\n common_keys = set(orig_graph_map[it][i].keys()) & set(orig_graph_map[it][j].keys())\n K[i][j] += sum([orig_graph_map[it][i].get(k, 0) * orig_graph_map[it][j].get(k, 0) for k in common_keys])\n\n end_time = time.time()\n print \"Total time for WL subtree kernel: \", (end_time - start_time)\n\n return K","def labels(self, threshold, segment=True, exclude_border=0):\n data = self.unmasked_data\n isfin = numpy.isfinite(data)\n data[~isfin] = numpy.amin(data[isfin])\n regions = (data > threshold)\n if segment:\n local_max = peak_local_max(data, indices=False,\n exclude_border=0,\n footprint=numpy.ones((3, 3)),\n labels=regions)\n markers = measurements.label(local_max)[0]\n labels = watershed(-data, markers, mask=regions)\n if exclude_border > 0:\n # Remove basins originating from edge peaks\n diff = numpy.zeros_like(local_max)\n for i in range(local_max.ndim):\n local_max = local_max.swapaxes(0, i)\n diff = diff.swapaxes(0, i)\n diff[:exclude_border] = local_max[:exclude_border]\n diff[-exclude_border:] = local_max[-exclude_border:]\n diff = diff.swapaxes(0, i)\n local_max = local_max.swapaxes(0, i)\n \n for l in numpy.sort(labels[diff])[::-1]:\n labels[labels == l] = 0\n labels[labels > l] -= 1\n ulabels = numpy.unique(labels)\n n = ulabels[ulabels != 0].size\n else:\n data_thres = numpy.zeros_like(data)\n data_thres[regions] = data[regions]\n labels, n = measurements.label(data_thres)\n return labels, n","def voronoi_labelling(self, seed):\n import heapq\n if hasattr(seed, '__iter__') == False:\n seed = [seed]\n try:\n if (self.weights < 0).any():\n raise ValueError('some weights are non-positive')\n except:\n raise ValueError('undefined weights')\n dist, active = np.inf * np.ones(self.V), np.ones(self.V)\n label = - np.ones(self.V, np.int_)\n idx, neighb, weight = self.compact_neighb()\n dist[seed] = 0\n label[seed] = np.arange(len(seed))\n dg = list(zip(np.zeros_like(seed), seed))\n heapq.heapify(dg)\n for j in range(self.V):\n end = False\n while True:\n if len(dg) == 0:\n end = True\n break\n node = heapq.heappop(dg)\n if active[node[1]]:\n break\n if end:\n break\n dwin, win = node\n active[win] = False\n # the folllowing loop might be vectorized\n for i in range(idx[win], idx[win + 1]):\n l, newdist = neighb[i], dwin + weight[i]\n if newdist < dist[l]:\n heapq.heappush(dg, (newdist, l))\n dist[l] = newdist\n label[l] = label[win]\n return label","def watershed(self, debug=False):\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n ret, markers = cv2.connectedComponents(sure_fg)\n markers += 1\n markers[unknown == 255] = 0\n markers = cv2.watershed(self.img, markers)\n self.add_color(markers)\n if debug:\n cv2.imshow(\"fg\", unknown)\n cv2.imshow(\"op\", opening)\n cv2.imshow(\"o3\", sure_bg)","def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\n mask = pred\n\n # noise removal\n if k > 1 and n_iters > 0:\n kernel = np.ones((k, k), np.uint8)\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\n iterations=n_iters)\n\n if watershed:\n from clab.live import filters\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\n\n mask = mask.astype(np.uint8)\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\n return cc_labels","def beam_search(X, u, w, b, relLabels):\n\n candidate_paths = [[] for _ in range(10)] # contains the candidate label sets\n candidate_vals =[[] for _ in range(10)] # contains the label values (-1/1) for each candidate set\n candidate_scores = [0. for _ in range(10)]\n min_score = -1000\n\n iter = 0\n start = 0\n while True:\n # print(\"Iter: \", iter)\n intermediate_paths = {}\n # intermediate_paths_val = []\n interim_scores = []\n hash_table = {}\n\n cnt_paths = 0\n for cp in range(5):\n labels_curr = candidate_paths[cp]\n labels_val_curr = candidate_vals[cp]\n scores_curr = candidate_scores[cp]\n Y = -np.ones((10, 1))\n for lv in range(len(labels_val_curr)):\n Y[labels_curr[lv]] = labels_val_curr[lv]\n\n for l in range(10):\n candidate_interim = labels_curr[:]\n candidate_vals_interim = labels_val_curr[:]\n # if l in labels_curr:\n # continue\n\n temp_relLabels = []\n for lc in range(len(labels_curr)):\n temp_relLabels.extend(relLabels[labels_curr[lc]])\n\n # temp_relLabels = np.array(list(set(temp_relLabels)))\n temp_relLabels = np.array(list(set(relLabels[l]).intersection(set(labels_curr))))\n model_pos = returnModelVal(X, Y, 1.0, u[l], u[l], b[l][0], np.array(temp_relLabels))\n candidate_interim.append(l)\n\n if model_pos < 0:\n # print('hello')\n candidate_vals_interim.append(-1)\n interim_scores.append(-model_pos)\n else:\n candidate_vals_interim.append(1)\n interim_scores.append(model_pos)\n\n hash_table[cnt_paths] = candidate_interim\n intermediate_paths[cnt_paths] = candidate_vals_interim\n cnt_paths += 1\n # For the first iteration, just iterate once - all labels in one iteration\n if start == 0:\n start = 1\n break\n\n temp_paths = intermediate_paths\n interim_zip = zip(intermediate_paths, interim_scores)\n sorted_scores = sorted(interim_zip, key=lambda x: x[1], reverse=True)[:5]\n intermediate_paths, scores = zip(*sorted_scores)\n\n temp_cand = []\n temp_val = []\n for i in range(len(intermediate_paths)):\n temp_cand.append(hash_table[intermediate_paths[i]])\n temp_val.append(temp_paths[intermediate_paths[i]])\n # candidate_scores[i] += scores[i]\n\n candidate_paths = temp_cand\n candidate_vals = temp_val\n print(candidate_paths)\n print(candidate_vals)\n # print(scores)\n # candidate_scores = scores\n\n # Exit condition from loop\n # if max(interim_scores) < min_score:\n # break\n #\n # min_score = min(interim_scores)\n\n iter += 1\n if iter > 5:\n break\n\n candidate_dict = {}\n for i in range(5):\n for c in range(len(candidate_paths[i])):\n if candidate_paths[i][c] not in candidate_dict:\n candidate_dict[candidate_paths[i][c]] = candidate_vals[i][c]\n elif candidate_dict[candidate_paths[i][c]] != 2:\n if candidate_dict[candidate_paths[i][c]] != candidate_vals[i][c]:\n candidate_dict[candidate_paths[i][c]] = 2.\n\n print(candidate_dict)\n exit()\n return candidate_dict","def from_minimal_schnyder_wood(graph):\n from sage.graphs.digraph import DiGraph\n from sage.combinat.dyck_word import DyckWord\n color_a = graph.incoming_edges('a')[0][2]\n color_b = graph.incoming_edges('b')[0][2]\n\n embedding = graph.get_embedding()\n graph0 = DiGraph([e for e in graph.edges() if e[2] == color_a],\n format='list_of_edges')\n restricted_embedding = {u: [v for v in embedding[u]\n if v in graph0.neighbors_in(u) or\n v in graph0.neighbors_out(u)]\n for u in graph0}\n\n voisins_in = {}\n for u in graph0:\n if u != 'a':\n bad_emb = restricted_embedding[u]\n sortie = graph0.neighbors_out(u)[0]\n idx = bad_emb.index(sortie)\n restricted_embedding[u] = bad_emb[idx:] + bad_emb[:idx]\n voisins_in[u] = restricted_embedding[u][1:]\n else:\n voisins_in[u] = list(restricted_embedding[u])\n voisins_in[u].reverse() # pour les avoir dans le bon sens\n\n graph0.set_embedding(restricted_embedding)\n\n def clockwise_labelling(gr, vertex):\n if len(gr) == 1:\n return [vertex]\n else:\n lbl = [vertex]\n for w in voisins_in[vertex]:\n lbl += clockwise_labelling(gr, w)\n return lbl\n\n def profil(gr, vertex):\n if len(gr) == 1:\n return []\n else:\n lbl = []\n for w in voisins_in[vertex]:\n lbl += [1] + profil(gr, w) + [0]\n return lbl\n\n dyckword_bottom = profil(graph0, 'a')\n # this is the profile of the planar graph graph0\n\n liste = clockwise_labelling(graph0, 'a')[1:]\n relabelling = {l: i for i, l in enumerate(liste)}\n for l in ['a', 'b', 'c']:\n relabelling[l] = l\n new_graph = graph.relabel(relabelling, inplace=False)\n\n dyckword_top = []\n for i in range(1, len(graph) - 3):\n indegree1 = len([u for u in new_graph.incoming_edges(i)\n if u[2] == color_b])\n dyckword_top += [1] + [0] * indegree1\n indegree1 = len([u for u in new_graph.incoming_edges('b')\n if u[2] == color_b])\n dyckword_top += [1] + [0] * indegree1\n\n dyckword_bottom = DyckWord(dyckword_bottom)\n dyckword_top = DyckWord(dyckword_top)\n TIP = TamariIntervalPosets(len(dyckword_bottom) // 2)\n return TIP.from_dyck_words(dyckword_bottom, dyckword_top)","def propagate_labels(image,labels,conflict=0):\n rlabels,_ = label(image)\n cors = correspondences(rlabels,labels,False)\n outputs = zeros(amax(rlabels)+1,'i')\n oops = -(1<<30)\n for o,i in cors.T:\n if outputs[o]!=0: outputs[o] = oops\n else: outputs[o] = i\n outputs[outputs==oops] = conflict\n outputs[0] = 0\n return outputs[rlabels]","def leaf_count(args: Dict[str, Union[bool, str]],\n model: str = \"PLANTCV\") -> JSON_TYPE:\n threshold: int = 116\n # Code from PlantCV Watershed:\n # https://plantcv.readthedocs.io/en/stable/tutorials/watershed_segmentation_tutorial/\n pcv_args = options(image=args.input)\n pcv.params.debug = pcv_args.debug\n\n # Read in image to apply watershedding to\n ##img, path, filename = pcv.readimage(filename=pcv_args.image)\n img = cv2.imread(pcv_args.image)\n # Converting from RGB to LAB and keep green-magenta channel\n a = pcv.rgb2gray_lab(rgb_img=img, channel='a')\n # Set up a binary threshold image\n img_binary = pcv.threshold.binary(gray_img=a, threshold=threshold,\n max_value=255, object_type='dark')\n # Blur image to reduce noise\n img_binary = pcv.median_blur(gray_img=img_binary, ksize=20)\n # Overlay of mask onto image\n id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=img_binary)\n\n while (not id_objects):\n threshold += 4\n img_binary = pcv.threshold.binary(gray_img=a, threshold=threshold,\n max_value=255, object_type='dark')\n # Blur image to reduce noise\n img_binary = pcv.median_blur(gray_img=img_binary, ksize=20)\n # Overlay of mask onto image\n id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=img_binary)\n # Reset threshold\n threshold = 116\n\n # Combine objects\n obj, mask = pcv.object_composition(img=img,\n contours=id_objects,\n hierarchy=obj_hierarchy)\n # Apply mask\n masked = pcv.apply_mask(img=img, mask=mask, mask_color=\"black\")\n\n # Using OpenCV for thresholding\n if model == \"OPENCV\":\n return opencv_watershed(masked, mask)\n\n # Using ML model for thresholding\n if model == \"ML\":\n mask_path: str = \"temp/mask.png\"\n cv2.imwrite(mask_path, masked)\n print(\"masked: \", masked)\n return ml_watershed(pcv_args.image, mask_path)\n\n # Using PlantCV watershed functionality\n return plantcv_watershed(masked, mask)","def preprocessing(image, smooth_size, folder):\n from skimage.restoration import denoise_tv_chambolle\n \n dim = int(image.shape[0] / 50.)\n smoothed = rank.median(image, disk(smooth_size))\n #smoothed = denoise_tv_chambolle(image, weight=0.002)\n smoothed = rank.enhance_contrast(smoothed, disk(smooth_size))\n \n pl.subplot(2, 3, 1)\n pl.title(\"after median\")\n pl.imshow(smoothed)\n pl.gray()\n # If after smoothing the \"dot\" disappears\n # use the image value\n \n # TODO: wat do with thresh?\n try:\n im_max = smoothed.max()\n thresh = threshold_otsu(image)\n except:\n im_max = image.max()\n thresh = threshold_otsu(image)\n\n \n if im_max < thresh:\n labeled = np.zeros(smoothed.shape, dtype=np.int32)\n \n else:\n binary = smoothed > thresh\n \n # TODO: this array size is the fault of errors\n bin_open = binary_opening(binary, np.ones((dim, dim)), iterations=5)\n bin_close = binary_closing(bin_open, np.ones((5,5)), iterations=5)\n \n pl.subplot(2, 3, 2)\n pl.title(\"threshold\")\n pl.imshow(binary, interpolation='nearest')\n pl.subplot(2, 3, 3)\n pl.title(\"opening\")\n pl.imshow(bin_open, interpolation='nearest')\n pl.subplot(2, 3, 4)\n pl.title(\"closing\")\n pl.imshow(bin_close, interpolation='nearest')\n \n distance = ndimage.distance_transform_edt(bin_open)\n local_maxi = peak_local_max(distance,\n indices=False, labels=bin_open)\n \n markers = ndimage.label(local_maxi)[0]\n \n labeled = watershed(-distance, markers, mask=bin_open)\n pl.subplot(2, 3, 5)\n pl.title(\"label\")\n pl.imshow(labeled)\n #pl.show()\n pl.savefig(folder)\n pl.close('all')\n\n #misc.imsave(folder, labeled)\n# labels_rw = random_walker(bin_close, markers, mode='cg_mg')\n# \n# pl.imshow(labels_rw, interpolation='nearest')\n# pl.show()\n\n return labeled","def watershed_segment_2(M,click_coords):\n \n # todo: choose these structures based on aspect ratio of M and input parameters\n sel = np.ones((4,10)) # for opening\n sel2 = np.ones((15,75)) # for local thresholding\n sel3 = np.ones((2,5)) # for erosion\n # get a few points in the center of each blob\n \n # threshold\n #bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)) & (M>=scoreatpercentile(M.flatten(),60)))\n \n score = stats.percentileofscore(M.flatten(),M[int(click_coords[0][1]),int(click_coords[0][0])])\n bw = (M>=stats.scoreatpercentile(M.flatten(),score))\n\n # open and erode\n #bools = sp.zeros((M.shape[0],M.shape[1]),int)\n #bools[int(click_coords[0]),int(click_coords[1])] = 1\n #blobs = sp.where(bools == 1,True,False)\n blobs = snm.binary_opening(bw,structure=sel)\n blobs = snm.binary_dilation(blobs,iterations=3)\n blobs = snm.binary_erosion(blobs,structure=sel3)\n \n \n # label\n labels,_ = ndi.label(blobs)\n labels[labels > 0] += 1\n #labels[0,0] = 1\n\n # rescale and cast to int16, then use watershed\n M2 = rescaled(M,0,65000).astype(np.uint16)\n newlabels = ndi.watershed_ift(M2,labels)\n \n # get rid of groups unless they have the right number of pixels\n counts = np.bincount(newlabels.flatten())\n old2new = np.arange(len(counts))\n old2new[(counts < 100) | (counts > 600)] = 0\n newlabels = old2new[newlabels]\n \n return newlabels","def watershed_segment(M,xM=None,yM=None):\n\n if xM != None and yM != None:\n sel = np.ones((int(ceil(23.9*xM)),int(ceil(23.9*yM)))) # for opening\n sel2 = np.ones((int(ceil(127.2*xM)),int(ceil(127.2*yM)))) # for local thresholding\n sel3 = np.ones((int(ceil(11.9*xM)),int(ceil(11.9*yM)))) # for erosion\n ma,mi =(44245.21*xM*yM),(316.037*xM*yM) \n else:\n selD = np.array([int(M.shape[0]*.012),int(M.shape[1]*.012)])\n selD = np.where(selD!=0,selD,1)\n \n sel2D = np.array([int(M.shape[0]*.12),int(M.shape[1]*.12)])\n sel2D = np.where(sel2D!=0,sel2D,1)\n\n sel3D = np.array([int(M.shape[0]*.01),int(M.shape[1]*.01)])\n sel3D = np.where(sel3D!=0,sel3D,1)\n\n\n sel = np.ones(selD) # for opening\n sel2 = np.ones(sel2D) # for local thresholding\n sel3 = np.ones(sel3D) # for erosion\n ma,mi = (M.shape[0]*M.shape[1]*.0075),(M.shape[0]*M.shape[1]*.0003)\n\n # get a few points in the center of each blob\n \n # threshold\n bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)))\n #& (M>=stats.scoreatpercentile(M.flatten(),80)))\n\n # open and erode\n blobs = snm.binary_opening(bw,structure=sel)\n blobs = snm.binary_erosion(blobs,structure=sel3,iterations=2)\n \n # label\n labels,_ = ndi.label(blobs)\n labels[labels > 0] += 1\n labels[0,0] = 1\n\n # rescale and cast to int16, then use watershed\n #M2 = rescaled(M,0,65000).astype(np.uint16)\n #newlabels = ndi.watershed_ift(M2,labels)\n newlabels = labels\n \n # get rid of groups unless they have the right number of pixels\n\n counts = np.bincount(newlabels.flatten())\n old2new = np.arange(len(counts)) \n old2new[(counts < int(mi)) | (counts > int(ma))] = 0\n newlabels = old2new[newlabels]\n\n return newlabels","def label_simplex(grid, simplex, thresh):\n coords = [grid[:,x] for x in simplex]\n dist = squareform(pdist(coords,'euclidean'))\n adjacency = dist<thresh\n adjacency = adjacency.astype(int) \n graph = csr_matrix(adjacency)\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n\n return n_components","def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\n labeled_volumes = dict()\n labeled_cells = dict()\n #Use global density and reduce the size of gt_dataset here\n global_density = labeling_params[\"global_density\"]\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\n #Label in the order specified in the configuration\n layers = sorted(labeling_params.keys())\n #Remove global_density\n layers.remove(\"global_density\")\n for layer in layers:\n print \"Labeling {}\".format(layer)\n fluorophore = labeling_params[layer]['fluorophore']\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\n if fluorophore in labeled_volumes:\n labeled_volumes[fluorophore] += volume\n labeled_cells[fluorophore] |= cells\n else:\n labeled_volumes[fluorophore] = volume\n labeled_cells[fluorophore] = cells\n return labeled_volumes, labeled_cells","def label_building_polys(burnt_polys, building_polys):\n\n for b in building_polys:\n for r in burnt_polys:\n if b[0].intersects(r):\n b[1] = [b[1][0], 'blue', True] # mark building polygon as 'blue' if found in burnt region\n continue","def textDetectWatershed(thresh, original):\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\n img = resize(original, 3000)\n thresh = resize(thresh, 3000)\n # noise removal\n kernel = np.ones((3,3),np.uint8)\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\n \n # sure background area\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\n\n # Finding sure foreground area\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\n\n # Finding unknown region\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg,sure_fg)\n \n # Marker labelling\n ret, markers = cv2.connectedComponents(sure_fg)\n\n # Add one to all labels so that sure background is not 0, but 1\n markers += 1\n\n # Now, mark the region of unknown with zero\n markers[unknown == 255] = 0\n \n markers = cv2.watershed(img, markers)\n implt(markers, t='Markers')\n image = img.copy()\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n \n # Creating result array\n boxes = []\n for mark in np.unique(markers):\n # mark == 0 --> background\n if mark == 0:\n continue\n\n # Draw it on mask and detect biggest contour\n mask = np.zeros(gray.shape, dtype=\"uint8\")\n mask[markers == mark] = 255\n\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\n c = max(cnts, key=cv2.contourArea)\n \n # Draw a bounding rectangle if it contains text\n x,y,w,h = cv2.boundingRect(c)\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\n maskROI = mask[y:y+h, x:x+w]\n # Ratio of white pixels to area of bounding rectangle\n r = cv2.countNonZero(maskROI) / (w * h)\n \n # Limits for text\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\n boxes += [[x, y, w, h]]\n \n # Group intersecting rectangles\n boxes = group_rectangles(boxes)\n bounding_boxes = np.array([0,0,0,0])\n for (x, y, w, h) in boxes:\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\n \n implt(image)\n\n # Recalculate coordinates to original size\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\n return boxes[1:]","def detection(test_img):\n # TODO: Step 2 : Your Detection code should go here.\n no_row = len(test_img)\n no_col = len(test_img[0])\n thresh = 100\n label_img = np.zeros((no_row, no_col))\n uf = []\n \n #first pass\n l = 1\n for i in range(0, no_row):\n for j in range(0, no_col):\n if test_img[i,j] < 255 - thresh:\n if i == 0 and j == 0:\n label_img[i,j] = l\n l = l+1\n elif i == 0 and j != 0:\n if label_img[i,j-1] == 0:\n label_img[i,j] = l\n l = l+1\n else:\n label_img[i,j] = label_img[i,j-1]\n elif i != 0 and j == 0:\n if label_img[i-1,j] == 0:\n label_img[i,j] = l\n l = l+1\n else:\n label_img[i,j] = label_img[i-1,j]\n else:\n if label_img[i-1,j] == 0 and label_img[i,j-1] == 0:\n label_img[i,j] = l\n l = l+1\n elif label_img[i-1,j] == 0 and label_img[i,j-1] != 0:\n label_img[i,j] = label_img[i,j-1]\n elif label_img[i-1,j] != 0 and label_img[i,j-1] == 0:\n label_img[i,j] = label_img[i-1,j]\n else:\n if label_img[i,j-1] == label_img[i-1,j]:\n label_img[i,j] = label_img[i,j-1]\n else:\n label_img[i,j] = min(label_img[i-1,j],label_img[i,j-1])\n uf.append([min(label_img[i,j-1],label_img[i-1,j]),max(label_img[i,j-1],label_img[i-1,j])])\n l = l - 1\n \n #2nd pass\n def ufds(x,l):\n b = []\n for i in range(1,l+1):\n b.append([i])\n for j in x:\n i1 = 0\n i2 = 0\n for k in range(0,len(b)):\n if j[0] in b[k]:\n i1 = k\n if j[1] in b[k]:\n i2 = k\n if i1 != i2:\n b[i1] = b[i1] + b[i2]\n del b[i2]\n return b\n \n bman = ufds(uf,l)\n \n #3rd pass\n uf_arr = np.zeros(l)\n for i in range(0,len(uf_arr)):\n for j in bman:\n if i+1 in j:\n uf_arr[i] = min(j) \n \n fin_img = np.zeros((no_row, no_col))\n for i in range(0, no_row):\n for j in range(0, no_col):\n if label_img[i,j] != 0:\n fin_img[i,j] = uf_arr[int(label_img[i,j] - 1)]\n \n all_label = []\n '''\n for i in bman:\n all_label.append(min(i))\n ''' \n for i in range(0, no_row):\n for j in range(0, no_col):\n if fin_img[i,j] !=0 and fin_img[i,j] not in all_label:\n all_label.append(fin_img[i,j])\n \n # main image\n k_img = np.zeros((no_row, no_col))\n for i in range(0, no_row):\n for j in range(0, no_col):\n if fin_img[i,j] != 0:\n k_img[i,j] = (all_label.index(fin_img[i,j]) + 1)\n \n k_list = []\n for i in range(1,len(all_label)+1):\n x = None\n y = None\n hx = None\n hy = None\n for j in range(0,no_row):\n for k in range(0,no_col):\n if k_img[j,k] == i:\n if y == None and x == None:\n y = j\n hy = j\n x = k\n hx = k\n else:\n if y > j:\n y = j\n if hy < j:\n hy = j\n if x > k:\n x = k\n if hx < k:\n hx = k\n k_list.append({\"bbox\": [x, y, hx-x, hy-y]})\n \n return k_list\n \n #raise NotImplementedError","def wetting(lgca):\n if hasattr(lgca, 'spheroid'):\n birth = npr.random(lgca.nodes[lgca.spheroid].shape) < lgca.r_b\n ds = (1 - lgca.nodes[lgca.spheroid]) * birth\n lgca.nodes[lgca.spheroid, :] = np.add(lgca.nodes[lgca.spheroid, :], ds, casting='unsafe')\n lgca.update_dynamic_fields()\n newnodes = lgca.nodes.copy()\n relevant = (lgca.cell_density[lgca.nonborder] > 0)\n coords = [a[relevant] for a in lgca.nonborder]\n nbs = lgca.nb_sum(lgca.cell_density) # + lgca.cell_density\n nbs *= np.clip(1 - nbs / lgca.n_crit, a_min=0, a_max=None) / lgca.n_crit * 2\n g_adh = lgca.gradient(nbs)\n pressure = np.clip(lgca.cell_density - lgca.rho_0, a_min=0., a_max=None) / (lgca.K - lgca.rho_0)\n g_pressure = -lgca.gradient(pressure)\n\n resting = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\n resting = lgca.nb_sum(resting) / lgca.velocitychannels / lgca.rho_0\n g = lgca.calc_flux(lgca.nodes)\n g = lgca.nb_sum(g)\n\n for coord in zip(*coords):\n n = lgca.cell_density[coord]\n permutations = lgca.permutations[n]\n restc = permutations[:, lgca.velocitychannels:].sum(-1)\n j = lgca.j[n]\n j_nb = g[coord]\n weights = np.exp(\n lgca.beta * (j_nb[0] * j[0] + j_nb[1] * j[1]) / lgca.velocitychannels / 2\n + lgca.beta * resting[coord] * restc #* np.clip(1 - restc / lgca.rho_0 / 2, a_min=0, a_max=None) * 2\n + lgca.beta * np.einsum('i,ij', g_adh[coord], j)\n # + lgca.alpha * np.einsum('i,ij', g_subs[coord], j)\n + restc * lgca.ecm[coord]\n + lgca.gamma * np.einsum('i,ij', g_pressure[coord], j)\n ).cumsum()\n ind = bisect_left(weights, random() * weights[-1])\n newnodes[coord] = permutations[ind]\n\n lgca.nodes = newnodes\n lgca.ecm -= lgca.alpha * lgca.ecm * lgca.cell_density / lgca.K","def detect_labels(img: np.ndarray):\n \n # Create a range of allowed colors.\n lower_color = np.array([20, 50, 0])\n upper_color = np.array([255, 255, 255])\n\n # Keep the pixels that lie within the range.\n color_filtered = cv.inRange(\n cv.cvtColor(img, cv.COLOR_RGB2HSV),\n lower_color,\n upper_color\n )\n \n # Keeping only the really bright pixels (converted to 255), change the dull ones to 0.\n # Helps distinguish the labels from other dull colors.\n _, thresholded = cv.threshold(color_filtered, 254, 255, cv.THRESH_BINARY)\n\n # Reduce the thickness of regions. Every 30x30 sliding window of 255 in the image gets replaced by a white pixel.\n # The stronger the erosion, the more the noise is removed, with a chance of removal of good pixels as well.\n eroded = cv.erode(thresholded, np.ones((30, 30)))\n\n # Now find outlines of the bright regions that remain after the thickness reduction.\n contours, _ = cv.findContours(eroded, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)\n \n # Identify the contours that represent our labels.\n # Gotta be the two largest ones in terms of area.\n contour_areas = [(cv.contourArea(c), idx) for (idx, c) in enumerate(contours)]\n\n contour_largest_idx = max(contour_areas)[1]\n contour_second_largest_idx = max(filter(lambda item: item[1] != contour_largest_idx, contour_areas))[1]\n\n # Since the labels are sorta rectangular, find the mean of the contours' y-axes to approximate the vertical center of the labels.\n largest_vertical_center = np.mean(contours[contour_largest_idx][:, :, 1])\n second_largest_vertical_center = np.mean(contours[contour_second_largest_idx][:, :, 1])\n\n # Higher center implies the value is more towards the bottom of the image, and hence the vertical center of the bottom label.\n bottom_label = min(largest_vertical_center, second_largest_vertical_center)\n \n # Lower center implies the value is more towards the top of the image, and hence the vertical center of the top label.\n top_label = max(largest_vertical_center, second_largest_vertical_center)\n\n return bottom_label, top_label","def region_labeling(image, th=None, black_blobs=True, set_recursion_limit=True,\n recursion_limit=10000):\n\n # Setup\n shape = np.shape(image)\n old_recursion_limit = sys.getrecursionlimit()\n if set_recursion_limit:\n sys.setrecursionlimit(recursion_limit)\n\n if len(shape) == 3:\n image = image.mean(axis=2)\n elif len(shape) > 3:\n raise ValueError('Must be at 2D image')\n\n # Threshold image\n labeled = threshold(image, th=th).astype(int)\n labeled = 255-labeled if black_blobs else labeled\n labeled[labeled == 255] = -1\n\n # Label blobs\n blobs = 0\n for i in range(shape[0]):\n for j in range(shape[1]):\n if labeled[i, j] == -1:\n blobs += 1\n flood_fill(labeled, y=i, x=j, colour=blobs)\n\n # Cleanup\n sys.setrecursionlimit(old_recursion_limit)\n\n return labeled","def _get_label_weight(opts, data):\n experiments = data[\"exp_names\"].value\n label_mat = numpy.zeros((experiments.size, 7))\n vid_lengths = numpy.zeros((experiments.size,))\n for i in range(experiments.size):\n exp_key = experiments[i]\n exp = data[\"exps\"][exp_key]\n for j in range(6):\n # label_counts[j] += exp[\"org_labels\"].value[:, j].sum()\n label_mat[i, j] = exp[\"org_labels\"].value[:, j].sum()\n # label_counts[-1] +=\\\n # exp[\"org_labels\"].shape[0] - exp[\"org_labels\"].value.sum()\n label_mat[i, -1] =\\\n exp[\"org_labels\"].shape[0] - exp[\"org_labels\"].value.sum()\n\n # vid_lengths[i] = exp[\"hoghof\"].shape[0]\n vid_lengths[i] = exp[\"org_labels\"].shape[0]\n\n # label_counts = label_mat.sum(axis=0)\n label_weight = 1.0 / numpy.mean(label_mat, axis=0)\n # label_weight[-2] = label_weight[-2] * 10\n if opts[\"flags\"].reweight is False:\n label_weight = [5, 5, 5, 5, 5, 5, .01]\n # import pdb; pdb.set_trace()\n return label_weight","def hebb_rule(dados):\n # Passo 0: Inicializar todos os pesos\n n = len(dados[0][0]) - 1\n weight = zeros(n + 1)\n print(weight)\n\n # Passo 1: Para cada vetor de treinamento na entrada e par de objetivos na saída (e : s)\n for _, dado in enumerate(dados):\n # Passo 2: Ajuste as ativações para as unidades de entrada\n x = dado[0]\n # Passo 3: Ajuste a ativação para a unidade de saída\n y = dado[1]\n # Passo 4: Ajuste os pesos e o bias\n for j in range(n):\n weight[j] += x[j] * y\n weight[n] += + y # Bias é weight[n]\n print(weight)","def labelComponents26(cube):\n x,y,z = np.where(cube);\n label = np.zeros(cube.shape, dtype = 'uint8');\n ncomp = 0;\n for xp,yp,zp in zip(x,y,z):\n if label[xp,yp,zp] == 0:\n ncomp += 1;\n label = labelNeighbours26(cube, label, xp,yp,zp, ncomp);\n return ncomp, label","def _refinement_random_walker(\n self,\n ds_labels,\n ds_maskROI,\n ds_mask,\n target_label):\n\n ds_labels[(ds_maskROI == False) & ds_mask] = target_label\n ds_labels[(ds_maskROI == False) & (ds_mask == False)] = -1\n\n labels = zoom(\n ds_labels,\n zoom=np.float32(\n self.size) /\n self.ds_size,\n order=0)\n maskROI = zoom(\n ds_maskROI,\n zoom=np.float32(\n self.size) /\n self.ds_size,\n order=0).astype(\n np.bool)\n\n # Extract labelled and unlabelled vertices\n m_unlabeled = (labels == 0) & (maskROI)\n m_foreground = (labels == target_label)\n\n unlabeled = np.ravel_multi_index(np.where(m_unlabeled), self.size)\n labeled = np.ravel_multi_index(np.where(labels != 0), self.size)\n #labeled = np.ravel_multi_index(np.where((m_foreground) | (labels > 0)), self.size)\n\n # Preparing the right handside of the equation BT xs\n B = self.L[unlabeled][:, labeled]\n mask = (labels[labels != 0]).flatten() == target_label\n fs = sparse.csr_matrix(mask).transpose()\n rhs = B * fs\n\n # Preparing the left handside of the equation Lu\n Lu = self.L[unlabeled][:, unlabeled]\n\n # Solve the linear equation Lu xu = -BT xs\n if self._pyamg_found:\n ml = ruge_stuben_solver(Lu)\n M = ml.aspreconditioner(cycle='V')\n else:\n M = None\n xu = cg(Lu, -rhs.todense(), tol=1e-3, M=M, maxiter=120)[0]\n\n probability = np.zeros(self.size, dtype=np.float32)\n probability[m_unlabeled] = xu\n probability[m_foreground] = 1\n\n return probability","def watershed(f, Bc=None, LINEREG=\"LINES\"):\n from string import upper\n if Bc is None: Bc = secross()\n return cwatershed(f,regmin(f,Bc),upper(LINEREG))\n return y","def ray_label_simplex(grid, simplex, thresh):\n coords = [grid[:,x] for x in simplex]\n dist = squareform(pdist(coords,'euclidean'))\n adjacency = dist<thresh\n adjacency = adjacency.astype(int) \n graph = csr_matrix(adjacency)\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n\n return n_components","def calculate_class_weights(label_data):\n neg, pos = np.bincount(label_data)\n weight_for_0 = 1 / neg\n weight_for_1 = 1 / pos\n return {0: weight_for_0, 1: weight_for_1}","def opencv_watershed(masked, mask) -> JSON_TYPE:\n # For code and detailed explanation see:\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\n threshold: int = 30\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n\n n_increases: int = 0\n while local_max_location.shape[0] < 30 and n_increases < 15:\n threshold += 20\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\n # Noise removal\n kernel = np.ones((3), np.uint8)\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\n # Noise removal\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\n n_increases += 1\n # Reset threshold\n threshold = 30\n\n num_clusters: int = 30\n if n_increases >= 15:\n num_clusters = local_max_location.shape[0]\n kmeans = KMeans(n_clusters=num_clusters)\n # If local_max_location size is 0, return 0 predictions\n if not local_max_location.size:\n return {\n \"count\": 0\n }\n kmeans.fit(local_max_location)\n local_max_location = kmeans.cluster_centers_.copy()\n # Kmeans is returning a float data type so we need to convert it to an int. \n local_max_location = local_max_location.astype(int)\n dist_transform_copy = dist_transform.copy()\n for i in range(local_max_location.shape[0]):\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\n # markers = np.zeros_like(dist_transform)\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\n sure = np.uint8(sure)\n ret, markers = cv2.connectedComponents(sure)\n labels = np.arange(kmeans.n_clusters)\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \n markers = markers.astype(int)\n markers_copy = markers.copy()\n index_non_zero_markers = np.argwhere(markers != 0)\n markers_copy = markers_copy.astype(np.uint8)\n font = cv2.FONT_HERSHEY_SIMPLEX\n for i in range(index_non_zero_markers.shape[0]):\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\n markers = markers.astype(np.int32)\n segmented = cv2.watershed(masked, markers)\n count_segments(markers)\n #return {\n # \"count\": local_max_location.shape[0]\n #}\n return {\n \"count\": count_segments(markers),\n }","def cross_junctions(I, bounds, Wpts):\n #--- FILL ME IN ---\n\n Ipts = np.zeros((2, 48))\n\n#parameters\n alpha = 0.15 #typically 0.04 to 0.06\n threshold = 1500 #default 2000\n sigma = 2\n ws = 12 #window size for saddle point\n\n#building Harris Detecter\n I = I/255.0\n gradx, grady = np.gradient(I)\n IxIx = gaussian_filter(gradx*gradx,sigma)\n IxIy = gaussian_filter(gradx*grady,sigma)\n IyIy = gaussian_filter(grady*grady,sigma)\n print(I.shape)\n\n #get harris score\n cand_score = []\n cand_index = []\n cand = []\n s_cand = []\n\n for j in range(len(I)):\n for i in range(len(I[0])):\n a11 = IxIx[j][i]\n a12 = IxIy[j][i]\n a21 = a12\n a22 = IyIy[j][i]\n A = np.array([[a11, a12],[a21, a22]])\n ev0, ev1 = np.linalg.eigvals(A)\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\n cand_score.append(-h_score)\n cand_index.append([i, j])\n\n #get the coordinates of the top 5000 scores\n sorted_ind = np.argsort(cand_score)\n sorted_score = np.sort(cand_score).tolist()\n\n for ind in sorted_ind[:threshold]:\n cand.append(cand_index[ind])\n s_cand = sorted_score[:threshold]\n\n\n#clustering\n #using homography to project candidate points to a up-front view\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\n H = dlt_homography(bounds, new_bbox)\n cand = np.array(cand).T\n cand = np.vstack((cand, np.ones(cand.shape[1])))\n Ho_cand = np.matmul(H,cand).T\n for pt in Ho_cand:\n pt[0] = pt[0]/pt[2]\n pt[1] = pt[1]/pt[2]\n Ho_cand = Ho_cand[:,:2]\n Ho_cand = Ho_cand.tolist()\n\n #get rid of points that are not in the boundry\n temp_Ho_cand = []\n temp_s_cand = []\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\n continue\n else:\n temp_Ho_cand.append(pt)\n temp_s_cand.append(s_cand[i])\n Ho_cand = np.array(temp_Ho_cand)\n s_cand = temp_s_cand\n #divide candidates into clusters\n assignment = []\n assignment_score = []\n\n #first put in the point that has the highest score\n assignment.append([Ho_cand[0]])\n assignment_score.append([s_cand[0]])\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n if min(dist) > 6:\n assignment.append([pt])\n assignment_score.append([s_cand[i]])\n\n assignment = np.array(assignment)\n\n #assign points to clusters\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\n continue\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n index = np.argsort(dist)[-1]\n np.append(assignment[index], pt)\n assignment_score[index].append(s_cand[i])\n\n #get centroids for each cluster\n Ho_centroids = []\n for i in range(len(assignment)):\n cl = assignment[i]\n cl = np.array(cl)\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\n assignment_score[i] = sum(assignment_score[i])\n\n print(len(assignment_score))\n\n Ho_centroids = np.array(Ho_centroids)\n #get rid of edge points\n\n xmin = np.amin(Ho_centroids.T[0])\n xmax = np.amax(Ho_centroids.T[0]) \n ymin = np.amin(Ho_centroids.T[1])\n ymax = np.amax(Ho_centroids.T[1])\n\n final_cand = []\n final_score = []\n for i in range(len(Ho_centroids)):\n pt = Ho_centroids[i]\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\n continue\n else:\n final_cand.append(pt)\n final_score.append(assignment_score[i])\n print(\"Number of corner found: \")\n print(len(final_cand))\n\n #get rid of fake corners\n if (len(final_cand)>48):\n ultimate_cand =[]\n for ind in np.argsort(final_score)[:48]:\n ultimate_cand.append(final_cand[ind])\n final_cand = ultimate_cand\n print(\"real corners count:\", len(ultimate_cand))\n\n\n #sort the points\n final_cand = np.array(final_cand)\n y_sort_ind = np.argsort(final_cand.T[1])\n final_cand = final_cand.tolist()\n rows = []\n for i in range(6):\n row = []\n for ind in y_sort_ind[i*8:(i+1)*8]:\n row.append(final_cand[ind])\n rows.append(row)\n\n ordered = []\n for row in rows:\n r = []\n x_sort_ind = np.argsort(np.array(row).T[0])\n for ind in x_sort_ind:\n r.append(row[ind])\n ordered.append(r)\n\n final_cand = []\n for row in ordered:\n for pt in row:\n final_cand.append(pt)\n \n\n\n #get coordinates of the centroids in the original frame\n Ho_centroids = np.array(final_cand)\n\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\n centroids = np.matmul(np.linalg.inv(H), centroids).T\n for pt in centroids:\n pt[0] = int(pt[0]/pt[2])\n pt[1] = int(pt[1]/pt[2])\n centroids = centroids[:,:2]\n\n#finding saddle points around the centroids\n saddle_points = []\n for pt in centroids:\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\n saddle = saddle_point(img)\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\n saddle_points.append(saddle)\n\n saddle_points = np.array(saddle_points)\n #------------------\n print(saddle_points.T)\n return saddle_points.T","def classify(k, sorted_labels):\n k_neighbors = sorted_labels[:k]\n men_occurencies = np.count_nonzero(k_neighbors == 'M')\n women_occurencies = np.count_nonzero(k_neighbors == 'W')\n\n return 'M' if men_occurencies > women_occurencies else 'W'","def bridge_problem3(here):\r\n\r\n def all_over(state):\r\n here, _ = state\r\n return not here or here == set([\"light\"])\r\n\r\n start = (frozenset(here) | frozenset([\"light\"]), frozenset())\r\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)","def cell_merge(wsh, pred):\n wshshape=wsh.shape\n \n # masks for the original cells\n objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\t\n \n # masks for dilated cells\n dil_objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\n \n # bounding box coordinates\t\n obj_coords = np.zeros((wsh.max()+1,4))\n \n # cleaned watershed, output of function\t\n wshclean = np.zeros((wshshape[0],wshshape[1]))\n \n # kernel to dilate objects\n kernel = np.ones((3,3), dtype=bool)\t\n \n for obj1 in range(wsh.max()):\n # create masks and dilated masks for obj\n objs[obj1,:,:] = wsh==(obj1+1)\t\n dil_objs[obj1,:,:] = dilation(objs[obj1,:,:], kernel)\t\n \n # bounding box\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n objcounter = 0\t# counter for new watershed objects\n \n for obj1 in range(wsh.max()):\t\n dil1 = dil_objs[obj1,:,:]\n\n # check if mask has been deleted\n if np.sum(dil1) == 0:\n continue\n \n objcounter = objcounter + 1\n orig1 = objs[obj1,:,:]\n\n for obj2 in range(obj1+1,wsh.max()):\n dil2 = dil_objs[obj2,:,:]\n \n # only check border if bounding box overlaps, and second mask \n # is not yet deleted\n if (do_box_overlap(obj_coords[obj1,:], obj_coords[obj2,:])\n and np.sum(dil2) > 0):\n \n border = dil1 * dil2\t\n border_pred = pred[border]\n \n # Border is too small to be considered\n if len(border_pred) < 32:\n continue\n \n # Sum of top 25% of predicted border values\n q75 = np.quantile(border_pred, .75)\n top_border_pred = border_pred[border_pred >= q75]\n top_border_height = top_border_pred.sum()\n top_border_area = len(top_border_pred)\n \n # merge cells\n if top_border_height / top_border_area > .99:\n orig1 = np.logical_or(orig1, objs[obj2,:,:])\n dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)\n dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\n \n wshclean = wshclean + orig1*objcounter\n \n return wshclean","def propagateLabel(self, l1, l2):\n\n if l1 != l2:\n winner = min(l1, l2)\n loser = max(l1, l2)\n loserN = 0\n superiorN = 0\n for i,l in enumerate(self.labels):\n if l == loser:\n loserN += 1\n self.labels[i] = winner\n if l > loser:\n superiorN += 1\n self.labels[i] = l - 1\n\n # print('Loser Label is ' + str(loser) + ' . With ' + str(loserN) + ' associated cells. Winner label is ' + str(winner))","def BFTM_(adj_list,labels):\n G_prime = nx.Graph()\n num_clusters = list(np.unique(labels))\n clusters = {i:[] for i in num_clusters}\n hood = {n.id:[i for i in num_clusters if i != labels[n.id]] for n in adj_list}\n \n #Add nodes to clusters\n for idx,n in enumerate(adj_list):\n clusters[labels[idx]].append(n.id)\n \n root_cluster = random.choice(num_clusters)\n root_id = random.choice(list(clusters[root_cluster]))\n queue = [adj_list[root_id]]\n clusters[labels[root_id]].remove(root_id)\n \n \n #BFTM\n while len(queue) > 0:\n node = queue.pop(0)\n for c_id in hood[node.id]:\n if len(clusters[c_id]) > 0:\n sample_id = random.choice(clusters[c_id])\n clusters[labels[sample_id]].remove(sample_id)\n queue.append(adj_list[sample_id])\n hood[sample_id].remove(labels[node.id])\n G_prime.add_edge(node,adj_list[sample_id])\n hood[node.id] = None\n #Handle leftover nodes\n if len(queue) == 0:\n remaining = [c for i,c in clusters.items() if len(c) > 0]\n for rem_cluster in remaining:\n for n in rem_cluster:\n added = False\n while not added:\n rand_n = random.choice(list(G_prime.nodes))\n if labels[rand_n.id] != labels[n.id]:\n G_prime.add_edge(n,rand_n)\n added = True\n \n \n #Cliqify\n for node in list(G_prime.nodes):\n if G_prime.degree(node) < len(num_clusters) - 1:\n for _1_hop in list(G_prime.neighbors(node)):\n for _2_hop in list(G_prime.neighbors(_1_hop)):\n if _2_hop != node and G_prime.degree(_2_hop) < len(num_clusters) - 1:\n G_prime.add_edge(node,_2_hop)\n \n return G_prime","def update_labels(mask1, mask2):\n # Find the object in mask2 that has maximum overlap with an object in max1,\n # (as a fraction of the objects pixels in mask1)\n def get_max_overlap(mask1, mask2, label1):\n # Count overlapping pixels.\n labels, counts = np.unique(mask2[mask1 == label1], return_counts=True)\n # Sort labels by counts (ascending).\n labels_sorted = labels[np.argsort(counts)]\n counts_sorted = counts[np.argsort(counts)]\n # Select new label with maximum overlap.\n max_overlap = labels_sorted[-1]\n return max_overlap\n \n def main(mask1, mask2):\n if not (mask1.shape == mask2.shape):\n raise ValueError(\"Masks do not have the same shape.\")\n # Initialize blank mask.\n updated_mask = np.zeros(mask2.shape)\n # Go one-by-one through the labels in mask2\n for label in np.unique(mask2)[1:]:\n # Find label in mask1 with maximum overlap with nuc from mask2.\n mask1_besthit = get_max_overlap(mask2, mask1, label)\n # Find reverse: best hit for the mask1 label in mask2.\n mask2_besthit = get_max_overlap(mask1, mask2, mask1_besthit)\n # If the labels are reciprocal best hits, update label in \n # new mask to have the shape of the object in mask 2 with \n # the label propagated from mask1.\n if ((mask2_besthit == label) and (mask1_besthit != 0)):\n updated_mask[mask2 == label] = mask1_besthit\n\n return updated_mask\n return main(mask1, mask2)","def swatershed(f, g, B=None, LINEREG=\"LINES\"):\n\n if B is None: B = secross()\n print 'Not implemented yet'\n return None\n return y","def flood_fill():\n global CURRENT_LABEL\n global mouse_pos\n\n im_mask = (source_msk==CURRENT_LABEL).astype(np.uint8)\n cv.floodFill(im_mask, None, mouse_pos, CURRENT_LABEL)\n source_msk[im_mask!=0] = CURRENT_LABEL","def segment_func2(self):\n # computing neighboors graph\n A = self.boundaryprob_graph()\n\n # SpectralClustering segmentation\n sc = SpectralClustering(3, affinity='precomputed', n_init=10, assign_labels='discretize')\n labels = sc.fit_predict(A)\n\n return labels","def compute_patch_loss(self, inputs, outputs, next_to_prev_weight = [1.0, 1.0]):\n bsz, w, h, __ = inputs['input_image'].shape \n\n pred_next_image = outputs[\"next_position\"]\n\n path_state = inputs['path_state'].reshape(bsz, 1, w, h).float() \n true_next_image = image_to_tiles(path_state, self.patch_size) \n\n # binarize patches\n next_sum_image = torch.sum(true_next_image, dim = 2, keepdim=True) \n next_patches = torch.zeros_like(next_sum_image)\n # any patch that has a 1 pixel in it gets 1 \n next_patches[next_sum_image != 0] = 1\n\n pred_next_image = pred_next_image.squeeze(-1)\n next_patches = next_patches.squeeze(-1).to(self.device).long() \n\n pred_next_image = rearrange(pred_next_image, 'b n c -> b c n')\n\n next_pixel_loss = self.weighted_xent_loss_fxn(pred_next_image, next_patches) \n\n total_loss = next_pixel_loss \n print(f\"loss {total_loss.item()}\")\n\n return total_loss","def test_lcwa_label_smoothing(self):\n # Create dummy dense labels\n labels = torch.zeros(self.batch_size, self.num_entities)\n for i in range(self.batch_size):\n labels[i, self.random.randint(self.num_entities)] = 1.0\n # Check if labels form a probability distribution\n np.testing.assert_allclose(torch.sum(labels, dim=1).numpy(), 1.0)\n\n # Apply label smoothing\n smooth_labels = apply_label_smoothing(labels=labels, epsilon=self.epsilon, num_classes=self.num_entities)\n # Check if smooth labels form probability distribution\n np.testing.assert_allclose(torch.sum(smooth_labels, dim=1).numpy(), 1.0, rtol=self.relative_tolerance)","def pad_edges(self, pad):\n weights=[]\n for dim, xy in zip([0, 1], [self.x, self.y]):\n xy0 = np.mean(xy)\n W = xy[-1]-xy[0]\n dist = np.abs(xy-xy0)\n wt=np.ones_like(dist)\n wt[ dist >= W/2 - pad] = 0\n weights += [wt]\n self.weight *= weights[0][:,None].dot(weights[1][None,:])","def label_smooth_pcc(f):\n n = f.shape[0]\n labels = tf.eye(n)\n labels = tf.reshape(labels,[-1,1])\n labels = (1.0 - args.smoothing) * labels + args.smoothing / 2\n pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])\n bce = tf.keras.losses.BinaryCrossentropy()\n return -bce(labels, pre_prob)","def b4Wan():\n \n tors, edges = tp.mesh_topo()\n G = build_graph(edges)\n \n # Get the routing path of all nodes\n table_file_name = '../outputs/mesh_routing_table.txt'\n table = all_routing(G, tors, table_file_name)\n if((os.path.isfile(table_file_name)) == False):\n table = all_routing(G, tors, table_file_name)\n else:\n json_data = open(table_file_name).read()\n table = json.loads(json_data)\n \n seeds, polys = cf.get_seeds_table(tors) #\n\n return G, tors, edges, table, seeds, polys","def label_image(image):\n \n #Label the blobs using ndimage\n labeled_blobs, n_features = ndimage.label(b_image)\n \n #calculate the center of mass of each labelled feature\n centers = ndimage.center_of_mass(b_image, labeled_blobs, np.arange(n_features) + 1)\n \n return labeled_blobs, n_features, centers","def label_smoothing_regularization(self, chars_labels, weight=0.1):\n one_hot_labels = tf.one_hot(\n chars_labels, depth=self.num_char_classes, axis=-1)\n pos_weight = 1.0 - weight\n neg_weight = weight / self.num_char_classes\n return one_hot_labels * pos_weight + neg_weight","def feature_dist(input_labels, struct=np.ones((3, 3))):\n # remove the pixels inside the coherent\n input_errosion = binary_erosion(input_labels, structure=struct)\n input_labels[input_errosion] = 0\n I, J = np.nonzero(input_labels)\n labels = input_labels[I, J]\n coords = np.column_stack((I, J))\n sorter = np.argsort(labels)\n labels = labels[sorter]\n coords = coords[sorter]\n I = I[sorter]\n J = J[sorter]\n sq_dists = cdist(coords, coords, 'sqeuclidean')\n start_idx = np.flatnonzero(np.r_[1, np.diff(labels)])\n nonzero_vs_feat = np.minimum.reduceat(sq_dists, start_idx, axis=1)\n feat_vs_feat = np.minimum.reduceat(nonzero_vs_feat, start_idx, axis=0)\n # calculate the distance between every two coherent areas\n # distance factor for one pixel to meter: 100\n distance_matrix = 100 * np.sqrt(feat_vs_feat)\n nRow, nCol = sq_dists.shape[0], start_idx.shape[0]\n # add the index of the final element to the slice array\n slice_indices = np.concatenate((start_idx, np.array([nRow])))\n col_args = np.zeros((nRow, nCol)).astype(int)\n row_index = np.zeros((nCol, nCol)).astype(int)\n '''\n How the following commands work:\n find closest pixel from label A to label B:\n Label A --> Label B\n row_index[A-1, B-1] = alpha\n col_index[A-1, B-1] = col_args[alpha, B-1] = beta\n index of pixel from Label A: input_labels[ I[alpha], J[alpha]]\n index of pixel from Label B: input_labels[ I[beta], J[beta]]\n '''\n for i in range(nCol):\n col_args[:, i] = start_idx[i] + \\\n np.argmin(sq_dists[:, slice_indices[i]:\n slice_indices[i+1]], axis=1)\n elements = sq_dists[np.arange(nRow).reshape((nRow, 1)), col_args]\n for i in range(nCol):\n row_index[i, :] = start_idx[i] + \\\n np.argmin(elements[slice_indices[i]:\n slice_indices[i+1], :], axis=0)\n col_index = col_args[row_index, np.arange(nCol).reshape((1, nCol))]\n # Change col_index and row_index to input array index.\n row_index_from_label = I[row_index]\n col_index_from_label = J[row_index]\n row_index_to_label = I[col_index]\n col_index_to_label = J[col_index]\n return distance_matrix, row_index_from_label, col_index_from_label, \\\n row_index_to_label, col_index_to_label","def bwdiagfill(bwimage):\n # fills pixels matching the following neighborhoods:\n hoods = [[[0, 1, 0],\n [1, 0, 0],\n [0, 0, 0]],\n [[0, 0, 0],\n [1, 0, 0],\n [0, 1, 0]],\n [[0, 0, 0],\n [0, 0, 1],\n [0, 1, 0]],\n [[0, 1, 0],\n [0, 0, 1],\n [0, 0, 0]]]\n output = bwimage.copy()\n # for each neighborhood, find matching pixels and set them to 1 in the img\n for hood in hoods:\n output = np.logical_or(output,\n ndimage.binary_hit_or_miss(bwimage, hood))\n return output","def _get_bbox_regression_labels(bbox_target_data, num_classes, front_2_1_points_targets_data, front_2_2_points_targets_data, front_center_targets_data, back_2_1_points_targets_data, back_2_2_points_targets_data, back_center_targets_data, center_targets_data):\n # Inputs are tensor\n\n clss = bbox_target_data[:, 0]\n bbox_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\n \n front_2_1_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\n front_2_2_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\n front_center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\n\n back_2_1_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\n back_2_2_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\n back_center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\n\n center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\n\n front_center_inside_weights = clss.new(front_center_targets.shape).zero_()\n\n bbox_inside_weights = clss.new(bbox_targets.shape).zero_()\n \n inds = (clss > 0).nonzero().view(-1)\n if inds.numel() > 0:\n clss = clss[inds].contiguous().view(-1,1)\n\n dim1_inds = inds.unsqueeze(1).expand(inds.size(0), 4)\n dim2_inds = torch.cat([4*clss, 4*clss+1, 4*clss+2, 4*clss+3], 1).long()\n # print(dim2_inds) # e.g. dim 16 * 4\n\n dim3_inds = inds.unsqueeze(1).expand(inds.size(0), 2)\n dim4_inds = torch.cat([2*clss, 2*clss+1], 1).long()\n\n # fang[-1]\n bbox_targets[dim1_inds, dim2_inds] = bbox_target_data[inds][:, 1:]\n\n front_2_1_points_targets[dim1_inds, dim2_inds] = front_2_1_points_targets_data[inds][:, 0:]\n front_2_2_points_targets[dim1_inds, dim2_inds] = front_2_2_points_targets_data[inds][:, 0:]\n front_center_targets[dim3_inds, dim4_inds] = front_center_targets_data[inds][:, 0:]\n\n back_2_1_points_targets[dim1_inds, dim2_inds] = back_2_1_points_targets_data[inds][:, 0:]\n back_2_2_points_targets[dim1_inds, dim2_inds] = back_2_2_points_targets_data[inds][:, 0:]\n back_center_targets[dim3_inds, dim4_inds] = back_center_targets_data[inds][:, 0:]\n\n center_targets[dim3_inds, dim4_inds] = center_targets_data[inds][:, 0:]\n\n bbox_inside_weights[dim1_inds, dim2_inds] = bbox_targets.new(cfg.TRAIN.BBOX_INSIDE_WEIGHTS).view(-1, 4).expand_as(dim1_inds)\n\n front_center_inside_weights[dim3_inds, dim4_inds] = front_center_targets.new(cfg.TRAIN.CENTER_INSIDE_WEIGHTS).view(-1, 2).expand_as(dim3_inds)\n\n return bbox_targets, bbox_inside_weights, front_2_1_points_targets, front_2_2_points_targets, front_center_targets, back_2_1_points_targets, \\\n back_2_2_points_targets, back_center_targets, center_targets, front_center_inside_weights","def slicing(features, seeds_features, seeds_label, label_map, adjacency,\n sigma=1., resize_shape=(480, 854)):\n label_map_flatten = np.reshape(label_map, [-1])\n num_seeds = np.max(label_map)+1\n # Label_map_one_hot [num_pixels, num_seeds_current]\n label_map_one_hot = np.zeros((label_map_flatten.shape[0], num_seeds), dtype=np.int16)\n label_map_one_hot[np.arange(label_map_flatten.shape[0]), label_map_flatten] = 1\n # weight_idx: [num_pixels, num_seeds_cur_prev_following_frame]\n # Only neighbouring seeds have weights > 0\n weight_idx = np.matmul(label_map_one_hot, adjacency)\n feature_dim = features.shape[2]\n\n # This implementation is not very efficient\n # It computes pairwise distance between all pixels and all seeds (from 3 frames)\n # dist: [num_pixels, num_seeds_cur_prev_following_frame]\n dist = euclidean_distances(np.reshape(features, [-1, feature_dim]), seeds_features)\n weight = np.exp(-dist*dist/sigma/sigma)\n weight *= weight_idx\n fg_votes = np.max(weight*np.expand_dims(seeds_label==1, 0), axis=1)\n bg_votes = np.max(weight*np.expand_dims(seeds_label==0, 0), axis=1)\n height = features.shape[0]\n width = features.shape[1]\n fg_votes = fg_votes.reshape((height, width))+1e-8\n bg_votes = bg_votes.reshape((height, width))+1e-8\n fg_votes = cv2.resize(fg_votes, (resize_shape[1], resize_shape[0]),\n interpolation=cv2.INTER_LINEAR)\n bg_votes = cv2.resize(bg_votes, (resize_shape[1], resize_shape[0]),\n interpolation=cv2.INTER_LINEAR)\n\n prob = np.stack([bg_votes, fg_votes], axis=2)\n dist_vis = utils.get_heatmap(np.concatenate([fg_votes, bg_votes], axis=0))\n prob = prob/np.sum(prob, axis=2, keepdims=True)\n\n return prob, dist_vis","def analyze_belief_strength_with_bias(self, G):\r\n n = []\r\n nbs_list = []\r\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\r\n n.append(node) #appends each node to a list that will be put into a dictionary\r\n pbs_list = []\r\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\r\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\r\n prob = G.nodes[node]['probability']\r\n for pre in G.predecessors(node):\r\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\r\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\r\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\r\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\r\n if len(pbs_list) == 0:\r\n nbs = og_bs\r\n nbs = int(nbs)\r\n else:\r\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\r\n if apbs*og_bs > 0:\r\n if apbs > 0:\r\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100)\r\n else:\r\n nbs = max(og_bs + (0.1*prob*unc*apbs), -100)\r\n nbs = int(nbs)\r\n else:\r\n nbs = og_bs\r\n nbs = int(nbs)\r\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\r\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\r\n print(change)\r\n return change #this will be used to update the list in a different function\r","def get_classification_simulator(self, image):\n\n r_channel = image[:,:,2]\n g_channel = image[:,:,1]\n\n\n\n # Threshold color channel\n s_rgy_min = 50\n s_thresh_min = 245\n s_thresh_max = 255\n \n #s_binary = np.zeros_like(r_channel)\n r_binary = np.zeros_like(r_channel)\n g_binary = np.zeros_like(r_channel)\n y_binary = np.zeros_like(r_channel)\n \n #s_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) | ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\n \n \n r_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & (g_channel <= s_rgy_min)] = 1\n g_binary[((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max)) & (r_channel <= s_rgy_min)] = 1\n y_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\n \n\n #res = cv2.bitwise_and(img,img,mask = s_binary)\n \n #maxx=image.shape[1]\n maxy=image.shape[0]\n \n y_top=0\n window_size_y=50\n y_bottom=y_top+window_size_y\n \n max_color=0\n tf_color=TrafficLight.UNKNOWN\n \n while (y_bottom< maxy):\n #print(img[y_top:y_bottom,:,:])\n rs= r_binary[y_top:y_bottom,:].sum()\n gs= g_binary[y_top:y_bottom,:].sum()\n ys= y_binary[y_top:y_bottom,:].sum()\n if (rs>max_color):\n max_color=rs\n tf_color=TrafficLight.RED\n if (gs>max_color):\n max_color=gs\n tf_color=TrafficLight.GREEN\n if (ys>max_color):\n max_color=ys\n tf_color=TrafficLight.YELLOW\n y_top+=window_size_y\n y_bottom+=window_size_y\n \n if (max_color<100):\n tf_color=TrafficLight.UNKNOWN\n \n\n\n return tf_color","def watershed(image, markers=None, connectivity=1, offset=None, mask=None,\n compactness=0, watershed_line=False):\n from ..segmentation import watershed as _watershed\n return _watershed(image, markers, connectivity, offset, mask,\n compactness, watershed_line)","def make_graph(imageAnnotated, imageGaussian):\n nodeNumber = imageAnnotated.max() - 1\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\n imagePropagatedNodes = imageAnnotated.copy()\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\n dimensionY, dimensionX = imageAnnotated.shape\n filament = (imagePropagatedNodes == 1).sum()\n while (filament > 0):\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\n for posY, posX in nodePixel:\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\n filament = (imagePropagatedNodes == 1).sum()\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\n for posY, posX in zip(filamentY, filamentX):\n nodeIndex = imagePropagatedNodes[posY, posX]\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\n for index, pixel in enumerate(filamentNeighborhood):\n if (pixel != nodeIndex and pixel > 1):\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\n edgeConnectivity = 0\n edgeJump = 0\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\n return(graph, nodePositions)","def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\n\n max_scores = []\n for query, target in itertools.product(flanking_reads, flanking_reads):\n\n if str(query + target) in paf_dict:\n overlap_info = paf_dict[query+target]\n elif str(target + query) in paf_dict:\n # get info and swap them\n overlap_info = paf_dict[target+query]\n query, target = target, query\n else:\n continue\n\n query_start = overlap_info['query_start']\n query_end = overlap_info['query_end']\n target_start = overlap_info['target_start']\n target_end = overlap_info['target_end']\n\n query_seq = fasta_dict[query][query_start:query_end]\n target_seq = fasta_dict[target][target_start:target_end]\n\n # Get scores for this pair; store in cur_scores\n cur_scores = []\n if window_size:\n # Use rolling window\n min_len = min(len(query_seq), len(target_seq))\n for start, end in utils.pairwise(range(0, min_len, window_size)):\n qs = query_seq[start:end]\n ts = target_seq[start:end]\n score = smith_waterman.smith_waterman(qs, ts)\n cur_scores.append(score)\n\n if cur_scores:\n score = max(cur_scores)\n max_scores.append(score)\n else:\n # No rolling window\n score = smith_waterman.smith_waterman(query_seq, target_seq)\n max_scores.append(score)\n\n threshold = 0.9 * max(max_scores)\n\n print(\"using {} as threshold\".format(threshold))\n\n plt.subplot(2, 3, 2)\n plt.hist(max_scores)\n plt.title(\"FLANKING READS\\nhistogram of num_gaps / len(aligned_sequence)\\nthreshold = {}\\nwindow_size = {}\\nshowing {} scores\"\n .format(threshold, window_size, len(max_scores)))\n\n\n\n return threshold","def spread_labels(labels,maxdist=9999999):\n #distances,features = morphology.distance_transform_edt(labels==0,return_distances=1,return_indices=1)\n #indexes = features[0]*labels.shape[1]+features[1]\n #spread = labels.ravel()[indexes.ravel()].reshape(*labels.shape)\n if not labels.any():\n return labels\n distances,indexes = cv2.distanceTransformWithLabels(array(labels==0,uint8),cv2.DIST_L2,cv2.DIST_MASK_PRECISE,labelType=cv2.DIST_LABEL_PIXEL)\n spread = labels[where(labels>0)][indexes-1]\n if maxdist is None:\n return spread, distances\n spread *= (distances<maxdist)\n return spread","def heuristic(self):\r\n # 1.\r\n blacks, whites = 0, 0\r\n weights = [0 for _ in range(6)]\r\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\r\n user_dir = directions[:2] if self.current_player == 'n' else directions[2:]\r\n for i in range(8):\r\n for j in range(8):\r\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\r\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\r\n if self.matrix[i][j] == self.current_player or self.matrix[i][j] == self.current_player.upper():\r\n\r\n # numarul de piese rege\r\n if self.matrix[i][j] == self.current_player.upper():\r\n weights[1] += 7.75\r\n\r\n # numarul de piese normale\r\n else:\r\n weights[0] += 5\r\n\r\n # numarul de piese de pe baseline in functie de tipul de piesa\r\n # conform strategiilor de joc este o strategie buna sa ai cat mai multe\r\n # piesa pe baseline pentru a preveni creare de piese de tip rege ale adversarului\r\n if self.current_player in ['n', 'N']:\r\n if i == 7:\r\n weights[2] += 4\r\n elif self.current_player in ['a', 'A']:\r\n if i == 0:\r\n weights[2] += 4\r\n\r\n # numarul de piese din mijlocul tablei\r\n # la fel este o strategie buna pentru atac\r\n if 3 <= i <= 4 and 3 <= j <= 4:\r\n weights[3] += 2\r\n\r\n # numar piese vulnerabile\r\n # adica piese ce pot fi capturate de oponent la urmatoare tura\r\n for d in user_dir:\r\n\r\n vx = d[0] + i\r\n vy = d[1] + j\r\n back_x = i - d[0]\r\n back_y = j - d[1]\r\n next_x, next_y = vx + d[0], vy + d[1]\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\r\n weights[4] -= 3\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\r\n # daca elimin o piesa rege este o mutare mai buna\r\n if self.matrix[vx][vy] == self.opponent().upper():\r\n weights[5] += 10\r\n else:\r\n weights[5] += 7\r\n\r\n diff = (blacks - whites) if self.current_player == 'n' else (whites - blacks)\r\n # cand sunt mai putin piese, AI adopta o tactica mai ofensiva\r\n if blacks + whites <= 10:\r\n return sum(weights) + diff\r\n return sum(weights)","def predict_boosting_example(x, h_ens):\r\n\r\n arr = []\r\n sum_alpha = 0\r\n\r\n for y in h_ens:\r\n # splitting hypothesis, weight pairs\r\n alpha, tree = h_ens[y]\r\n tst_pred = predict_example(x, tree)\r\n # appending prediction\r\n arr.append(tst_pred*alpha)\r\n sum_alpha += alpha\r\n predict_egz = np.sum(arr) / sum_alpha\r\n # weak learner\r\n if predict_egz >= 0.5:\r\n return 1\r\n else:\r\n return 0","def assignLabels(self):\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\n self.clusterV = self.volumes_sorted[clusters]\n clusters = self.oldOrder[clusters] #indexes volumes\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\n self.easyLabel = np.zeros(len(self.data))\n self.easyLabel[self.clusters] = 1\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')","def labelled_attachment(gold_trees, pred_trees):\n count_match, count_total = 0, 0\n for gold, pred in zip(gold_trees, pred_trees):\n triples_pairs = zip(\n gold.get_triples(include_root=True),\n pred.get_triples(include_root=True),\n )\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\n assert g_src == p_src\n count_total += 1\n if g_trg == p_trg and g_rel == p_rel:\n count_match += 1\n if count_match == 0 or count_total == 0:\n return 0.0\n else:\n return float(count_match) / count_total","def cell(x, y):\n try:\n if cells[y][x]['filled'] == 1:\n return # this has already been processed\n except IndexError:\n return\n cells[y][x]['filled'] = 1 # this cell is now filled\n\n nn = []\n for nx, ny in neighbours(x, y):\n try:\n if cells[ny][nx]['filled']:\n nn.append(cells[ny][nx])\n except IndexError:\n continue\n \n c = 0 # colour weighting\n \n #------ Flippedness\n flipped = sum([i['inverted'] for i in nn if i['inverted']])\n cells[y][x]['inverted'] = (randint(0, 3) + flipped) % 4\n \n #------- Colour calculation\n avg_colour = sum([i['colour'][0] for i in nn]) / len(nn)\n avg_sat = sum([i['colour'][1] for i in nn]) / len(nn)\n avg_bri = sum([i['colour'][2] for i in nn]) / len(nn)\n \n # small chance of going totally random otherwise small variation from neighbours\n if random(100) > 90:\n h = randint(0, 100)\n s = randint(0, 100)\n b = randint(0, 100)\n else:\n h = (avg_colour + randint(-15, 15)) % 100\n s = (avg_sat + randint(-15, 15)) % 100\n b = (avg_bri + randint(-15, 15)) % 100\n cells[y][x]['colour'] = (h, s, b)\n \n #------- Alpha calculation\n d = sqrt((x*cell_size - rx)**2 + (y*cell_size - ry)**2) # distance from epicenter\n mx = sqrt((w-rx*cell_size)**2 + (h-ry*cell_size)**2)\n a = d/sqrt(w**2+h**2)*255\n cells[y][x]['alpha'] = a\n \n for cx,cy in neighbours(x, y):\n cell(cx, cy)","def clusterbatplacement(b, h, cluster, connectedhomes):\n for batt in b:\n b[batt].posx = cluster[batt][0]\n b[batt].posy = cluster[batt][1]\n for house in connectedhomes[batt]:\n b[batt].connected.append(h[house])","def count_blood_cells(image_path):\n\n # TODO - Prebrojati crvena i bela krvna zrnca i vratiti njihov broj kao povratnu vrednost ove procedure\n \"\"\"\n White cells\n \"\"\"\n # Getting image\n white_cells_img = cv2.imread(image_path)\n gray_img = cv2.cvtColor(white_cells_img, cv2.COLOR_BGR2GRAY)\n\n # Apply median filter for smoothing\n smooth_img_white = cv2.medianBlur(gray_img, 5)\n\n # Morphological operations\n kernel = np.ones((5, 5), np.uint8)\n closing_img = cv2.morphologyEx(smooth_img_white, cv2.MORPH_CLOSE, kernel)\n\n # Adaptive threshold gaussian filter\n threshold_img = cv2.adaptiveThreshold(closing_img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\n cv2.THRESH_BINARY, 9, 2)\n\n # Segmentation of white cells\n circles_a = cv2.HoughCircles(threshold_img, cv2.HOUGH_GRADIENT, 1.2, 105,\n param1=50, param2=28, minRadius=2, maxRadius=28)\n\n # Getting count of white cells\n cell_count_a = []\n if circles_a is not None:\n circles_a = np.round(circles_a[0, :]).astype(\"int\")\n for (r) in circles_a:\n cell_count_a.append(r)\n # print(len(cell_count_a))\n white_blood_cell_count = len(cell_count_a)\n\n \"\"\"\n Red cells\n \"\"\"\n # Getting image\n red_cells_img = cv2.imread(image_path)\n\n # Getting red color\n red = [(150, 137, 168), (218, 209, 208)] # (lower), (upper)\n colors = [red]\n\n # Apply median filter for smoothing\n smooth_img_red = cv2.medianBlur(red_cells_img, 3)\n\n cell_count_b = 0\n output = red_cells_img.copy()\n for lower, upper in colors:\n mask = cv2.inRange(smooth_img_red, lower, upper)\n\n # Segmentation of red cells\n circles_b = cv2.HoughCircles(mask, cv2.HOUGH_GRADIENT, 1, 20, param1=15, param2=17,\n minRadius=2, maxRadius=60)\n\n # Getting count of red cells\n if circles_b is not None:\n circles_b = np.round(circles_b[0, :]).astype(\"int\")\n\n for (x, y, r) in circles_b:\n cv2.circle(output, (x, y), r, (255, 0, 255), 2)\n cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (255, 0, 255), -1)\n cell_count_b += 1\n\n # cv2.imwrite('output.png', output)\n # print(cell_count_b)\n red_blood_cell_count = cell_count_b\n\n # TODO - Odrediti da li na osnovu broja krvnih zrnaca pacijent ima leukemiju i vratiti True/False kao povratnu\n # vrednost ove procedure\n\n if (white_blood_cell_count > 2\n or\n white_blood_cell_count >= (red_blood_cell_count / 3)):\n has_leukemia = True\n else:\n has_leukemia = False\n\n return red_blood_cell_count, white_blood_cell_count, has_leukemia","def fill_holes(img):\n neg = 1 - img\n s = ndimage.generate_binary_structure(3,1) # iterate structure\n labeled_array, numpatches = ndimage.label(neg,s) # labeling\n sizes = ndimage.sum(neg,labeled_array,range(1,numpatches+1)) \n sizes_list = [sizes[i] for i in range(len(sizes))]\n sizes_list.sort()\n max_size = sizes_list[-1]\n max_label = np.where(sizes == max_size)[0] + 1\n component = labeled_array == max_label\n return 1 - component","def get_hardwired_speed_weights(self):\n \n phase_shift=self.speed_phase_shift\n \n # row 1 has the weights of speed cells to grid cell 1\n self.W_speed_east=np.zeros_like(self.W_ee) \n self.W_speed_west=np.zeros_like(self.W_ee) \n self.W_speed_north=np.zeros_like(self.W_ee) \n self.W_speed_south=np.zeros_like(self.W_ee) \n\n if self.use_eight_directions is True:\n self.W_speed_north_east=np.zeros_like(self.W_ee) \n self.W_speed_north_west=np.zeros_like(self.W_ee) \n self.W_speed_south_east=np.zeros_like(self.W_ee) \n self.W_speed_south_west=np.zeros_like(self.W_ee) \n\n\n for phase_idx,phase in enumerate(self.gp.phases):\n shifted_north_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi/2.),self.gp.phases)\n shifted_south_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi/2.),self.gp.phases)\n shifted_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(0),self.gp.phases)\n shifted_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi),self.gp.phases)\n\n self.W_speed_north[phase_idx,:]=self.W_ee[shifted_north_phase_idx,:]\n self.W_speed_south[phase_idx,:]=self.W_ee[shifted_south_phase_idx,:]\n self.W_speed_east[phase_idx,:]=self.W_ee[shifted_east_phase_idx,:]\n self.W_speed_west[phase_idx,:]=self.W_ee[shifted_west_phase_idx,:] \n \n if self.use_eight_directions is True:\n shifted_north_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi/4),self.gp.phases)\n shifted_north_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi*3/4),self.gp.phases)\n shifted_south_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi/4),self.gp.phases)\n shifted_south_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi*3/4),self.gp.phases)\n \n self.W_speed_north_east[phase_idx,:]=self.W_ee[shifted_north_east_phase_idx,:]\n self.W_speed_north_west[phase_idx,:]=self.W_ee[shifted_north_west_phase_idx,:]\n self.W_speed_south_east[phase_idx,:]=self.W_ee[shifted_south_east_phase_idx,:]\n self.W_speed_south_west[phase_idx,:]=self.W_ee[shifted_south_west_phase_idx,:]","def weights_walls(pc, boundary_indx, n_action, n_neurons):\n # find index on a 40 point circle \n boundary_cells = pc[boundary_indx, :]\n angles = (np.arctan2(boundary_cells[:, 0], boundary_cells[:, 1]) + 2*np.pi) % (2*np.pi)\n \n # find index of boundary cell (in a ring of 40 action neurons)\n thetas = theta_action(n_action)\n diff = np.abs(angles[:, np.newaxis] - thetas[np.newaxis, :])\n indx = np.argmin(diff, axis=1) # the closest match\n\n w_walls = np.ones((n_action, n_neurons))\n \n for ii in np.arange(len(boundary_indx)):\n cell_ind = boundary_indx[ii]\n \n d = collections.deque(np.arange(n_action))\n w_walls[:, cell_ind] = 0 # first set all weights to 0\n d.rotate(n_action-(indx[ii]+ 13)) # 1st permitted action is 13 segments away\n actions_ind = list(itertools.islice(d, 0, 14))\n w_walls[actions_ind, cell_ind] = 1\n \n return w_walls","def learn_with_bootstrapping(self, sample_count=10000):\n tic = time.clock()\n training_set_size = 150 # TODO: change to 1000, 500 or something\n sample_pool = self.training_stream.extract_training_patches(sample_count, negative_ratio=1.)\n # initialize weights\n weighted_patches = []\n for patch in sample_pool: # weight all patches: training pool P\n weighted_patches.append([patch, 1. / len(sample_pool)])\n # if patch.label == +1:\n # pos_patch = patch # PRESENTATION, REPORT\n # shuffle training pool\n weighted_patches = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\n\n if self.algorithm == 'adaboost': # Shuffle the training data\n training_data = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\n elif self.algorithm == 'wald': # Sample training_set_size samples\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\n\n for t in range(self.layers): # choose the weak classifier with the minimum error\n print \"Learn with bootstrapping using %s, layer #%d\" % (self.algorithm.title(), t+1)\n\n if self.algorithm == 'adaboost':\n h_t = self._fetch_best_weak_classifier(weighted_patches)\n elif self.algorithm == 'wald':\n h_t = self._fetch_best_weak_classifier(training_data)\n # h_t.visualize(pos_patch) # PRESENTATION, REPORT\n self.classifiers.append(copy.deepcopy(h_t)) # add it to the strong classifier\n\n if self.algorithm == 'adaboost':\n self.classifiers[-1].update_alpha(weighted_patches)\n weighted_patches = self._adaboost_reweight(weighted_patches, t)\n elif self.algorithm == 'wald':\n kde_n, kde_p, xs_n, xs_p = self._estimate_ratios(training_data, t)\n # find decision thresholds for the strong classifier\n self._tune_thresholds(kde_n, kde_p, xs_n, xs_p, t)\n # throw away training samples that fall in our thresholds\n weighted_patches = self._reweight_and_discard_irrelevant(weighted_patches, t)\n # sample new training data\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\n if len(training_data) == 0:\n print \"no more training data!\"\n break\n toc = time.clock()\n print toc - tic\n print self","def train_label_weigthed(self, train_dataset, validation_dataset, label, lr = 0.02, epochs_num = 100, batch_size = 40, alpha = 0, momentum = 0.9):\n \n def get_proportions(dataset):\n \n positive_label = dataset.labels_tensor[:,label].sum()\n \n negative_label = (1 - dataset.labels_tensor[:,label]).sum()\n \n total_examples = positive_label + negative_label\n \n imbalance = abs(positive_label - 0.5) > 0.4\n \n if imbalance:\n \n if positive_label < negative_label:\n \n w_p = 1\n \n w_n = positive_label / negative_label\n \n else:\n \n w_p = negative_label / positive_label\n \n w_n = 1\n \n else:\n \n w_p = w_n = 1\n \n return w_p, w_n\n \n def get_w(labels, w_p, w_n):\n \n positives = labels\n \n negatives = 1 - labels\n \n w = w_p * positives + w_n * negatives\n \n return w\n \n# positive_label = train_dataset.labels_tensor[:,label].sum()\n \n# negative_label = (1 - train_dataset.labels_tensor[:,label]).sum()\n \n# total_examples = positive_label + negative_label\n \n# print('num examples {}'.format(positive_label + negative_label))\n \n# print('% positive labels: {}'.format(positive_label/total_examples))\n \n# print('% negative labels: {}'.format(negative_label/total_examples))\n \n# imbalance = abs(positive_label - 0.5) > 0.4\n \n# if imbalance:\n \n# if positive_label < negative_label:\n \n# w_p = 1\n \n# w_n = positive_label / negative_label\n \n# else:\n \n# w_p = negative_label / positive_label\n \n# w_n = 1\n \n# else:\n \n# w_p = w_n = 1\n \n# print('w_p: {}'.format(w_p))\n \n# print('w_n: {}'.format(w_n))\n\n w_p, w_n = get_proportions(train_dataset) \n \n label_name = train_dataset.labels.items()[label][0]\n \n print(\"Training label {} ... \".format(label_name))\n \n optimizer = SGD(self.parameters(), lr = lr, weight_decay = alpha, momentum = momentum)\n\n train_losses = []\n\n validation_losses = []\n\n epochs = []\n\n start = time.time()\n\n remaining_time = 0\n\n train_dataloader = DataLoader(train_dataset, batch_size = batch_size, collate_fn = PPD.collate_data)\n \n validation_segments, validation_labels = PPD.collate_data(validation_dataset)\n \n weight_matrix_v = get_w(validation_labels[:,label].unsqueeze(1), w_p, w_n)\n \n criterion_v = nn.BCELoss(weight=weight_matrix_v.float())\n \n print('w_p: {} and w_n: {}'.format(w_p, w_n))\n\n for epoch in range(epochs_num):\n\n for i_batch, sample_batched in enumerate(train_dataloader):\n\n input = sample_batched[0]\n\n target = sample_batched[1][:,label].unsqueeze(1)\n \n weight_matrix = w_p * target + w_n * (1 - target)\n \n criterion = nn.BCELoss(weight=weight_matrix.float())\n\n self.zero_grad()\n\n output = self(input)\n\n train_loss = criterion(output, target.float())\n\n train_loss.backward()\n\n optimizer.step()\n\n validation_loss = criterion_v(self(validation_segments.long()), validation_labels[:,label].unsqueeze(1).float())\n\n end = time.time()\n\n remaining_time = remaining_time * 0.90 + ((end - start) * (epochs_num - epoch + 1) / (epoch + 1)) * 0.1\n\n remaining_time_corrected = remaining_time / (1 - (0.9 ** (epoch + 1)))\n\n epoch_str = \"last epoch finished: \" + str(epoch)\n\n progress_str = \"progress: \" + str((epoch + 1) * 100 / epochs_num) + \"%\"\n\n time_str = \"time: \" + str(remaining_time_corrected / 60) + \" mins\"\n\n sys.stdout.write(\"\\r\" + epoch_str + \" -- \" + progress_str + \" -- \" + time_str)\n\n sys.stdout.flush()\n\n train_losses.append(train_loss.item())\n\n validation_losses.append(validation_loss.item())\n\n epochs.append(epoch)\n\n print(\"\\n\" + \"Training completed. Total training time: \" + str(round((end - start) / 60, 2)) + \" mins\")\n\n return epochs, train_losses, validation_losses","def joint_bilateral(filename,flash_image,noflash_image,sigma_spatial,sigma_intensity):\n\t# make a simple Gaussian function taking the squared radius\n\tgaussian = lambda r2, sigma: np.exp(-0.5*r2/sigma**2)\n\tflash_image = cv2.cvtColor(flash_image,cv2.COLOR_BGR2RGB)\n\tnoflash_image = cv2.cvtColor(noflash_image,cv2.COLOR_BGR2RGB)\n\n\t# define the window width to be the 2 time the spatial std. dev. to\n\t# be sure that most of the spatial kernel is actually captured\n\twin_width = int(3*sigma_spatial +1)\n\twgt_sum = np.zeros_like(flash_image).astype(np.float64)\n\tresult = np.zeros_like(flash_image).astype(np.float64)\n\tout= np.zeros_like(flash_image).astype(np.float64)\n\t\n\t\n\tfor i in tqdm(range(flash_image.shape[-1]),desc=\"Going through color channels\"):\n\t\tnorm_flash_image = normalize(flash_image[:,:,i])\n\t\tnorm_noflash_image = normalize(noflash_image[:,:,i])\n\t\tfor shft_x in range(-win_width,win_width+1):\n\t\t\tfor shft_y in range(-win_width,win_width+1):\n\t\t\t\t# compute the spatial contribution\n\t\t\t\tspatial = gaussian(shft_x**2+shft_y**2, sigma_spatial )\n\t\n\t\t\t\t# shift by the offsets to get image window\n\t\t\t\twindow = np.roll(norm_flash_image, [shft_y, shft_x], axis=[0,1])\n\t\t\t\twindow1 = np.roll(norm_noflash_image, [shft_y, shft_x], axis=[0,1])\n\t\t\t\t# compute the intensity contribution\n\t\t\t\tcombined_filter = spatial*gaussian((window-norm_flash_image)**2, sigma_intensity )\n\t\n\t\t\t\t# result stores the mult. between combined filter and image window\n\t\t\t\tresult[:,:,i] += window1*combined_filter\n\t\t\t\twgt_sum[:,:,i] += combined_filter\n\tout = normalize(result/wgt_sum)\n\t# normalize the result and return\n\tplt.imsave(\"outputImages/JointBilateral_\"+filename+\"_\"+str(sigma_spatial)+\"_\"+ str(sigma_intensity) + \".png\" ,out,dpi=600)\n\treturn out","def create_labelled_dataset(self):\n\n print(\"-------------------------------------------------------------------\")\n print(\" How to Use the Pole Hull Label Tool\")\n print(\"-------------------------------------------------------------------\")\n print(\"- If a hull is NOT associated to a pole: press the 1 button\")\n print(\"- If a hull IS associated to a pole: press the 2 button\")\n print(\"\\n- If any other key is pressed, the program EXITS\")\n print(\"-------------------------------------------------------------------\")\n\n detector = gate_detector.GateDetector(im_resize=3.0/4)\n\n imgs = []\n labels = []\n directory = os.path.dirname(os.getcwd())\n \n # Get absolute path of all images in the images folder\n for dirpath,_,filenames in os.walk(os.path.join(directory, 'images', 'gate')):\n for f in filenames:\n imgs.append(os.path.abspath(os.path.join(dirpath, f)))\n\n # Get the hulls from the segmented image and run the display and label program for each image\n for img in imgs:\n src = cv.imread(img, 1)\n pre = detector.preprocess(src)\n seg = detector.segment(pre)\n mor = detector.morphological(seg)\n hulls = detector.create_convex_hulls(seg)\n labels += self.display_and_label_hulls(hulls, pre)\n return labels","def worker(i):\n res_read = read_dicom(os.path.join(DIR, fnames[i]))\n if res_read is None:\n print(\"failed on {0}, {1}\".format(i, fnames[i]))\n return ' '.join(map(str,[fnames[i]] + [-1]*4 +[-1]*4))\n\n img, spacing = res_read\n R, C = img.shape\n split_point = C/2\n\n right_l = img[:,:split_point]\n left_l = img[:,split_point:]\n\n prop = get_joint_y_proposals(right_l)\n\n # We will store the coordinates of the top left and the bottom right corners of the bounding box\n hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins)\n\n\n # Making proposals for the right leg\n R, C = right_l.shape\n displacements = range(-C//4,1*C//4+1,step)\n best_score = -999999999\n sizepx = int(sizemm/spacing) # Proposal size\n\n for y_coord in prop:\n for x_displ in displacements:\n for scale in scales:\n if C/2+x_displ-R/scale/2 >= 0:\n # Candidate ROI\n roi = np.array([C/2+x_displ-R/scale/2, y_coord-R/scale/2, R/scale, R/scale]).astype(int)\n x1, y1 = roi[0], roi[1]\n x2, y2 = roi[0]+roi[2], roi[1]+roi[3]\n patch = cv2.resize(img[y1:y2,x1:x2],(64, 64))\n\n hog_descr = hog.compute(patch,winStride,padding)\n score = np.inner(w,hog_descr.ravel())+b\n\n if score > best_score:\n jc = np.array([C/2+x_displ, y_coord])\n best_score = score\n\n\n roi_R = np.array([jc[0]-sizepx//2, jc[1]-sizepx//2, jc[0]+sizepx//2, jc[1]+sizepx//2])\n # Making proposals for the left leg\n R, C = left_l.shape\n displacements = range(-C//4,1*C//4+1,step)\n prop = get_joint_y_proposals(left_l)\n best_score = -999999999\n for y_coord in prop:\n for x_displ in displacements:\n for scale in scales:\n if split_point+x_displ+R/scale/2 < img.shape[1]:\n roi = np.array([split_point+C/2+x_displ-R/scale/2, y_coord-R/scale/2, R/scale, R/scale]).astype(int)\n\n x1, y1 = roi[0], roi[1]\n x2, y2 = roi[0]+roi[2], roi[1]+roi[3]\n patch = np.fliplr(cv2.resize(img[y1:y2,x1:x2],(64, 64)))\n\n hog_descr = hog.compute(patch,winStride,padding)\n score = np.inner(w,hog_descr.ravel())+b\n\n if score > best_score:\n jc = np.array([split_point+C/2+x_displ, y_coord])\n best_score = score\n\n roi_L = np.array([jc[0]-sizepx//2, jc[1]-sizepx//2, jc[0]+sizepx//2, jc[1]+sizepx//2])\n\n print(\"Done with {}, {}\".format(i, fnames[i]))\n return ' '.join(map(str,[fnames[i]] + np.round(roi_L).astype(int).tolist() + np.round(roi_R).astype(int).tolist()))","def kmerNeighbors(text,k):\r\n L=set()\r\n for i in range(0,len(text)-k+1):\r\n for d in range(0,k+1):\r\n L.update(Neighbors(kmer(text,i,k),d))\r\n D=dict()\r\n for l in L:\r\n D[l]=minHamm(text,l)\r\n return D","def compute_gradient_saliency_maps(samples: torch.tensor,\n true_labels: torch.tensor,\n model: nn.Module):\n \"\"\"INSERT YOUR CODE HERE, overrun return.\"\"\"\n return torch.rand(6, 256, 256)","def do_a_propagation(self):\n random.seed(self.seeding)\n random.shuffle(self.nodes)\n for node in tqdm(self.nodes):\n neighbors = nx.neighbors(self.graph, node)\n pick = self.make_a_pick(node, neighbors)\n self.labels[node] = pick\n current_label_count = len(set(self.labels.values()))\n if self.label_count == current_label_count:\n self.flag = False\n else:\n self.label_count = current_label_count","def findHighWeightFeatures(self, label):\n featuresWeights = []\n\n \"*** YOUR CODE HERE ***\"\n\n return featuresWeights","def get_action(self, state):\n\n \"\"\"\n XXX: DO NOT MODIFY THAT FUNCTION !!!\n Doing so will result in a 0 grade.\n \"\"\"\n\n # XXX : You shouldn't care on what is going on below.\n # Variables are specified in constructor.\n if self.beliefGhostStates is None:\n self.beliefGhostStates = state.getGhostBeliefStates()\n if self.walls is None:\n self.walls = state.getWalls()\n\n # @TODO Put this back to normal\n ret = self.updateAndGetBeliefStates(\n self._computeNoisyPositions(state))\n\n if self.i < 25:\n debug = ret[0]\n self.l.append(np.max(debug))\n self.i += 1\n #if debug == 1: # To Stop as soon as convergence happens\n #self.i = 25\n\n prefix = 'data/' # To indicate path\n\n if self.i == 25:\n\n if os.path.exists(os.path.join(prefix, str(self.w) + \"-\" + str(self.p) + \".txt\")):\n os.remove(os.path.join(prefix, str(self.w) + \"-\" + str(self.p) + \".txt\"))\n\n f = open(os.path.join(prefix, str(self.w) + \"-\" + str(self.p) + \".txt\"), \"a\")\n first = True\n for data in self.l:\n if first:\n first = False\n f.write(str(data))\n else:\n f.write(\",\" + str(data))\n self.i += 1\n f.close()\n print(\"Done\")\n plt.plot(range(1, len(self.l)+1), self.l)\n plt.xlabel('Time step')\n plt.ylabel('Maximum probability')\n plt.title('Bayes Filter')\n plt.axis([0, self.i, 0, 1])\n plt.savefig(os.path.join(prefix, str(self.w) + \"-\" + str(self.p) + \".pdf\"), bbox_inches='tight')\n plt.show()\n\n return ret","def build_labels():\n l_title = GLabel('Which one is Karel?')\n l_title.font = 'Courier-25'\n l_title.color = 'black'\n window.add(l_title, x=260, y=60)\n l_num = GLabel('19')\n l_num.font = 'Courier-50'\n l_num.color = 'whitesmoke'\n window.add(l_num, x=37, y=242)\n l_skip = GLabel('skip')\n l_skip.font = 'Courier-20'\n l_skip.color = 'whitesmoke'\n window.add(l_skip, x=726, y=152)\n l_ans1 = GLabel('Answers')\n l_ans1.font = 'Courier-20-italic'\n l_ans1.color = 'black'\n window.add(l_ans1, x=698, y=270)\n l_ans2 = GLabel('0')\n l_ans2.font = 'Courier-50-italic'\n l_ans2.color = 'black'\n window.add(l_ans2, x=722, y=252)\n l_game_pin = GLabel('Game PIN: SC101')\n l_game_pin.font = 'Courier-20'\n l_game_pin.color = 'black'\n window.add(l_game_pin, x=20, y=540)\n l_1 = GPolygon()\n l_1.add_vertex((210, 360))\n l_1.add_vertex((197, 380))\n l_1.add_vertex((221, 380))\n l_1.filled = True\n l_1.color = 'whitesmoke'\n l_1.fill_color= 'whitesmoke'\n window.add(l_1)\n l_2_1 = GPolygon()\n l_2_1.add_vertex((210+380, 359))\n l_2_1.add_vertex((198+380, 370))\n l_2_1.add_vertex((221+380, 370))\n l_2_1.filled = True\n l_2_1.fill_color = 'whitesmoke'\n l_2_1.color = 'whitesmoke'\n window.add(l_2_1)\n l_2_2 = GPolygon()\n l_2_2.add_vertex((210+380, 381))\n l_2_2.add_vertex((198+380, 370))\n l_2_2.add_vertex((221+380, 370))\n l_2_2.filled = True\n l_2_2.fill_color = 'whitesmoke'\n l_2_2.color = 'whitesmoke'\n window.add(l_2_2)\n l_3 = GOval(23, 23, x=198, y=450)\n l_3.filled = True\n l_3.fill_color = 'whitesmoke'\n l_3.color = 'whitesmoke'\n window.add(l_3)\n l_4 = GRect(20, 20, x=583, y=450)\n l_4.filled = True\n l_4.fill_color = 'whitesmoke'\n l_4.color = 'whitesmoke'\n window.add(l_4)","def neighbors(pattern, d):\n\n if d == 0:\n return [pattern]\n if len(pattern) == 1:\n return ['A', 'C', 'G', 'T']\n neighborhood = []\n suffix_pattern = pattern[1:]\n suffix_neighbors = neighbors(suffix_pattern, d)\n for text in suffix_neighbors:\n hdist = compute_hamming_distance(suffix_pattern, text)\n if hdist < d:\n for n in ['A', 'C', 'G', 'T']:\n neighbor = n + text\n neighborhood.append(neighbor)\n else:\n neighbor = pattern[0] + text\n neighborhood.append(neighbor)\n return neighborhood","def agglo_from_labelmask(\n h5path_in,\n h5path_lv='',\n ratio_threshold=0,\n h5path_out='',\n save_steps=False,\n protective=False,\n ):\n\n # check output paths\n outpaths = {'out': h5path_out}\n status = utils.output_check(outpaths, save_steps, protective)\n if status == \"CANCELLED\":\n return\n\n # open data for reading\n h5file_in, ds_in, elsize, axlab = utils.h5_load(h5path_in)\n h5file_lv, ds_lv, _, _ = utils.h5_load(h5path_lv)\n\n # open data for writing\n h5file_out, ds_out = utils.h5_write(None, ds_in.shape, ds_in.dtype,\n h5path_out,\n element_size_um=elsize,\n axislabels=axlab)\n\n ulabels = np.unique(ds_in)\n maxlabel = np.amax(ulabels)\n print(\"number of labels in watershed: {:d}\".format(maxlabel))\n\n fwmap = np.zeros(maxlabel + 1, dtype='i')\n\n areas_ws = np.bincount(ds_in.ravel())\n\n labelsets = {}\n rp_lw = regionprops(ds_lv, ds_in)\n for prop in rp_lw:\n\n maskedregion = prop.intensity_image[prop.image]\n counts = np.bincount(maskedregion)\n svoxs_in_label = [l for sl in np.argwhere(counts) for l in sl]\n\n ratios_svox_in_label = [float(counts[svox]) / float(areas_ws[svox])\n for svox in svoxs_in_label]\n fwmask = np.greater(ratios_svox_in_label, ratio_threshold)\n labelset = np.array(svoxs_in_label)[fwmask]\n labelsets[prop.label] = set(labelset) - set([0])\n\n basepath = h5path_in.split('.h5/')[0]\n utils.write_labelsets(labelsets, basepath + \"_svoxsets\",\n filetypes=['pickle'])\n\n ds_out[:] = utils.forward_map(np.array(fwmap), ds_in, labelsets)\n\n # close and return\n h5file_in.close()\n h5file_lv.close()\n try:\n h5file_out.close()\n except (ValueError, AttributeError):\n return ds_out","def binarize(img, s_thres=(170, 255), l_thres=(50, 255), sobel_thres=(30, 80)):\n hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)\n\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\n hls[:, :, 1] = clahe.apply(hls[:, :, 1])\n\n l_image = hls[:, :, 1]\n l_blur = cv2.GaussianBlur(l_image, (0, 0), 9)\n l_image = cv2.addWeighted(l_image, 1, l_blur, -1, 0)\n l_image = cv2.normalize(l_image, np.zeros_like(l_image), 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1)\n l_binary = np.zeros_like(l_image)\n l_binary[(l_image >= l_thres[0]) & (l_image <= l_thres[1])] = 1\n\n # Sobel x\n # gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n # gray = hls[:, :, 1]\n # sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0) # Take the derivative in x\n # abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal\n # scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))\n # sxbinary = np.zeros_like(scaled_sobel)\n # sxbinary[(scaled_sobel >= sobel_thres[0]) & (scaled_sobel <= sobel_thres[1])] = 1\n # sxbinary = s_binary\n\n s_channel = hls[:, :, 2]\n s_channel = cv2.normalize(s_channel, np.zeros_like(s_channel), 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1)\n s_binary = np.zeros_like(s_channel)\n s_binary[(s_channel >= s_thres[0]) & (s_channel <= s_thres[1])] = 1\n\n # Combine the two binary thresholds\n combined_binary = np.zeros_like(s_binary)\n combined_binary[(s_binary == 1) | (l_binary == 1)] = 1\n\n # we filter out the lines with too many active pixels\n combined_binary_rows = combined_binary.sum(1)\n combined_binary[combined_binary_rows > (combined_binary.shape[1] / 2)] = 0\n\n return combined_binary","def calc_w_inference(g1, inf_g1, g2, inf_g2, consider_label):\n edges_g1 = np.count_nonzero(g1)\n edges_g2 = np.count_nonzero(g2)\n\n overlap_r1 = 0\n overlap_r2 = 0\n n_nodes = len(g1)\n for i in range(n_nodes):\n for j in range(n_nodes):\n if consider_label:\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL) and (g1[i][j] == inf_g2[i][j]):\n overlap_r1 += 1 # how much g1 recalls \"populated\"-g2\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL) and (inf_g1[i][j] == g2[i][j]):\n overlap_r2 += 1 # how much g2 recalls \"populated\"-g2\n else:\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL):\n overlap_r1 += 1\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL):\n overlap_r2 += 1\n\n r1 = float(overlap_r1) / float(edges_g1)\n r2 = float(overlap_r2) / float(edges_g2)\n return (r1 + r2) / float(2)","def prefix_beam_search(ctc, labels, blank_index=0, lm=None,k=5,alpha=0.3,beta=5,prune=0.001,end_char='>',return_weights=False):\n assert (ctc.shape[1] == len(labels)), \"ctc size:%d, labels: %d\" % (ctc.shape[1], len(labels))\n assert ctc.shape[0] > 1, \"ctc length: %d was too short\" % ctc.shape[0]\n assert (ctc >= 0).all(), 'ctc output contains negative numbers'\n lm = (lambda l: 1) if lm is None else lm # if no LM is provided, just set to function returning 1\n word_count_re = re.compile(r'\\w+[\\s|>]')\n W = lambda l: word_count_re.findall(l)\n F = ctc.shape[1]\n \n ctc = np.vstack((np.zeros(F), ctc)) # just add an imaginative zero'th step (will make indexing more intuitive)\n T = ctc.shape[0]\n blank_char = labels[blank_index]\n\n # STEP 1: Initiliazation\n O = ''\n Pb, Pnb = defaultdict(Counter), defaultdict(Counter)\n Pb[0][O] = 1\n Pnb[0][O] = 0\n A_prev = [O]\n # END: STEP 1\n\n # STEP 2: Iterations and pruning\n for t in range(1, T):\n pruned_alphabet = [labels[i] for i in np.where(ctc[t] > prune)[0]]\n for l in A_prev:\n \n if len(l) > 0 and l[-1] == end_char:\n Pb[t][l] = Pb[t - 1][l]\n Pnb[t][l] = Pnb[t - 1][l]\n continue \n\n for c in pruned_alphabet:\n c_ix = labels.index(c)\n # END: STEP 2\n \n # STEP 3: “Extending” with a blank\n if c == blank_char:\n Pb[t][l] += ctc[t][blank_index] * (Pb[t - 1][l] + Pnb[t - 1][l])\n # END: STEP 3\n \n # STEP 4: Extending with the end character\n else:\n l_plus = l + c\n if len(l) > 0 and c == l[-1]:\n Pnb[t][l_plus] += ctc[t][c_ix] * Pb[t - 1][l]\n Pnb[t][l] += ctc[t][c_ix] * Pnb[t - 1][l]\n # END: STEP 4\n\n # STEP 5: Extending with any other non-blank character and LM constraints\n elif len(l.replace(' ', '')) > 0 and c in (' ', end_char):\n lm_prob = lm(l_plus.strip(' '+end_char)) ** alpha\n Pnb[t][l_plus] += lm_prob * ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])\n else:\n Pnb[t][l_plus] += ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])\n # END: STEP 5\n\n # STEP 6: Make use of discarded prefixes\n if l_plus not in A_prev:\n Pb[t][l_plus] += ctc[t][blank_index] * (Pb[t - 1][l_plus] + Pnb[t - 1][l_plus])\n Pnb[t][l_plus] += ctc[t][c_ix] * Pnb[t - 1][l_plus]\n # END: STEP 6\n\n # STEP 7: Select most probable prefixes\n A_next = Pb[t] + Pnb[t]\n sorter = lambda l: A_next[l] * (len(W(l)) + 1) ** beta\n A_prev = sorted(A_next, key=sorter, reverse=True)[:k]\n # END: STEP 7\n if len(A_prev) ==0:\n A_prev=['']\n if return_weights:\n return A_prev[0],A_next[A_prev[0]] * (len(W(A_prev[0])) + 1) ** beta\n return A_prev[0]\n #For N-best decode, return A_prev[0:N] - not tested yet.","def label_users(self):\n record_unit = 1000\n print self.friendship_graph.number_of_nodes()\n print self.friendship_graph.number_of_edges()\n\n for num, node in enumerate(self.friendship_graph.nodes()):\n fake_flag = self.determine_spammer_by_percentage(node)\n self.friendship_graph.node[node]['fake'] = fake_flag\n # print self.friendship_graph.node[node]\n if num % record_unit == 0:\n print num\n print time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))\n nx.write_gpickle(self.friendship_graph, \"graph/firendship_new_label%d.pickle\" % num)\n if num != 0:\n os.remove(\"graph/firendship_new_label%d.pickle\" % (num - record_unit))\n\n nx.write_gpickle(self.friendship_graph, \"graph/firendship_0.8fake_%d.pickle\" % num)","def process_label(self, foreground_labels):\n # Find the unique (nonnegative) foreground_labels, map them to {0, ..., K-1}\n unique_nonnegative_indices = np.unique(foreground_labels)\n mapped_labels = foreground_labels.copy()\n for k in range(unique_nonnegative_indices.shape[0]):\n mapped_labels[foreground_labels == unique_nonnegative_indices[k]] = k\n foreground_labels = mapped_labels\n return foreground_labels","def find_connected_components(thresh_image):\n\n rows, cols = thresh_image.shape\n\n # First find the connected components of the image\n # num_labels: the number of connected components found in the image\n # labels: a matrix with the labels for each pixel\n # stats: [top_left_x_coord, top_left_y_coord, width, height, area] statistics for each component\n # centroids: [x_coord, y_coord] of the centroid of each component\n num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh_image)\n\n # Do some filtering based on the characteristics of a shuttle\n for i in range(num_labels):\n\n # Filters out shapes that are too long\n size_ratio = stats[i, 2] / stats[i, 3]\n if size_ratio < 0.5 or size_ratio > 2:\n labels[labels == i] = 0\n\n # Filters out shapes that fit the bounding box too well (likely noise) or too bad (sparse structure)\n area_ratio = stats[i, 4] / (stats[i, 2] * stats[i, 3])\n if area_ratio < 0.4 or area_ratio > 0.9:\n labels[labels == i] = 0\n\n # Filters out shapes too small (in proportion to image size)\n if stats[i, 2] < (rows / 60) or stats[i, 3] < (cols / 60):\n labels[labels == i] = 0\n\n return labels","def learn_pattern_Hebb(self, pattern):\n if pattern.shape != self.shape:\n # TODO: this could be written in a clearer way\n ValueError(\"The pattern shape does not match the network one.\")\n\n pattern_flat = pattern.flatten()\n\n # Convert the bool array to an array with +-1\n pattern_pm = 2*pattern_flat.astype(bool) - 1\n\n # Update adjacency matrix according to Hebb's rule \n adjmatrix_change = np.outer(pattern_pm, pattern_pm).astype(float)\n self.network.adjmatrix = np.average(\n [self.network.adjmatrix, adjmatrix_change], axis=0,\n weights=[self.npatterns, 1])\n\n # Update neighbour lists (isingmodel.Ising method)\n self.update_neighbours()\n\n # Store the pattern in the patterns list\n self.patterns.append(pattern)","def splitCell(buff,index,ref_label,new_label):\n cell_before = np.copy(buff[:,:,index-1])\n cell_after = np.copy(buff[:,:,index])\n \n mask_after = cell_after ==ref_label\n \n cell_before[np.logical_not(mask_after)] = 0\n \n mask_ref_label = cell_before ==ref_label\n mask_new_label = cell_before==new_label\n \n after_sure_ref = np.logical_and(mask_ref_label,mask_after)\n after_sure_new = np.logical_and(mask_new_label,mask_after)\n after_unsure = np.logical_and(mask_after,np.logical_not(np.logical_or(after_sure_ref,after_sure_new) ) )\n\n xref,yref = np.where(after_sure_ref)\n ref_pts = np.concatenate((xref.reshape(-1,1),yref.reshape(-1,1)),axis=1)\n xnew,ynew = np.where(after_sure_new)\n new_pts = np.concatenate((xnew.reshape(-1,1),ynew.reshape(-1,1)),axis=1)\n \n labels_ref = np.ones(xref.shape[0])\n labels_new = np.zeros(xnew.shape[0])\n labels = np.concatenate((labels_ref,labels_new),axis=0)\n labels.reshape(-1,1)\n X= np.concatenate((ref_pts,new_pts),axis = 0)\n \n xu,yu = np.where(after_unsure)\n u_pts = np.concatenate((xu.reshape(-1,1),yu.reshape(-1,1)),axis=1)\n neigh = KNeighborsClassifier(n_neighbors=5)\n neigh.fit(X, labels)\n pred = neigh.predict(u_pts)\n for i in range(pred.shape[0]):\n #if pred is 1 goes to ref if 0 goes to new\n if pred[i]==1:\n after_sure_ref[u_pts[i,0],u_pts[i,1]]=True\n else:\n after_sure_new[u_pts[i,0],u_pts[i,1]]=True\n #Assigning the new values to the thing:\n buff[after_sure_ref,index] = ref_label\n buff[after_sure_new,index] = new_label"],"string":"[\n \"def watershed_supervised(graph, seeds):\\n \\n size_data = graph.shape[0]\\n \\n u, v, w = sp.sparse.find(graph)\\n list_edges = list(zip(u,v,w))\\n list_edges.sort(key = lambda x : x[2])\\n \\n UF = unionfind(size_data)\\n labels = np.array(seeds, dtype=np.int32, copy=True)\\n \\n for e in list_edges:\\n ex, ey, ew = e\\n px, py = UF.find(ex), UF.find(ey)\\n if px != py:\\n lx, ly = labels[px], labels[py]\\n if (lx != 0) and (ly !=0 ):\\n # Both are labelled. Do nothing\\n pass\\n else:\\n max_label = max(lx, ly) # Pick the non-zero label!!\\n labels[px], labels[py] = max_label, max_label\\n UF.union(ex, ey)\\n \\n \\n ans = np.array([labels[UF.find(x)] for x in range(size_data) ] )\\n \\n# assert np.all(ans>0)\\n \\n return ans\",\n \"def powerWatershed_multipleLabels(graph, seeds, bucketing='kmeans', eps=1e-2, k=3, beta=5., eps_weight=1e-6):\\n\\n ans = []\\n for i in np.sort(np.unique(seeds)):\\n if i > 0:\\n seed_tmp = np.array((seeds == i)*1, dtype=np.int32) + 1\\n seed_tmp[np.where(seeds == 0)] = 0\\n ans.append(powerWatershed(graph, seed_tmp, bucketing, eps, k, beta, eps_weight))\\n return np.argmax(ans, 0) + 1\",\n \"def powerWatershed(graph, seeds, bucketing='kmeans', eps=1e-2, k=3, beta=5., eps_weight=1e-6):\\n\\n size = graph.shape[0]\\n\\n graph_tmp = csr_matrix(graph, copy=True)\\n graph_tmp.data = np.exp(-1*beta*graph_tmp.data/graph_tmp.data.std()) + eps_weight\\n \\n labels = np.array(seeds, dtype=np.float64) - 1\\n\\n uf = unionfind(size)\\n\\n edge_generator = generate_edges(graph_tmp, bucketing, eps, k)\\n edges_till_now = []\\n for edges in edge_generator:\\n\\n # Add all the edges to the graph\\n for e in edges:\\n uf.union(e[0], e[1])\\n\\n edges_till_now += edges\\n\\n for (_, comp) in uf.generate_comps():\\n label_unique = set(np.unique(labels[comp]))\\n\\n # continue if all points in the component are labelled\\n if -1 not in label_unique:\\n continue\\n\\n # othwerwise solve rw\\n if len(label_unique) <= 2:\\n l = max(label_unique)\\n labels[comp] = l\\n\\n if len(label_unique) > 2:\\n _randomwalkV2(graph, labels, comp, beta, eps_weight)\\n\\n return labels\",\n \"def watershed(img):\\n\\ttmp = img.copy()\\n\\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n\\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n\\tkernel = np.ones((3,3), np.uint8)\\n\\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\\n\\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\\n\\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\\n\\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\\n\\tsure_fg = np.uint8(sure_fg)\\n\\tunknown = cv2.subtract(sure_bg, sure_fg)\\n\\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\\n\\tmarkers = markers+1\\n\\tmarkers[unknown==255] = 0\\n\\tmarkers = cv2.watershed(tmp, markers)\\n\\ttmp[markers == -1] = [255,0,0]\\n\\treturn tmp\",\n \"def heuristic2B_label_OBD(n, P, label, critical=None):\\n nodes_labeled = []\\n\\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\\n new_label = label + 1\\n \\n neighbors = P.neighbors(n)\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys(): # if it has a label\\n if P.node[neigh]['OBDlabel'] > new_label: # and it is higher than what I would use for labeling\\n new_label = P.node[neigh]['OBDlabel']\\n # we got maximum of current label or any node that neighbors have - now we label them all with that\\n \\n neighbors_to_label = []\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\\n neighbors_to_label.append(neigh)\\n else: # if set and smaller than mine, leave them alone\\n pass\\n else: # if not set, then not lower and not labelled\\n neighbors_to_label.append(neigh)\\n # now we have all the neighbors that need to be labeled\\n \\n if len(neighbors_to_label) > 1:\\n flag_critical = True\\n # and now labeling all these nodes\\n \\n for neigh in neighbors_to_label:\\n if ('critical' in P.node[neigh].keys()) and (P.node[neigh]['critical']==True) and (P.node[neigh]['OBDlabel'] != new_label) :\\n return (False, nodes_labeled) # being critical, we could avoid failure only if the label to set would be the same (it happens)\\n else:\\n P.node[neigh]['OBDlabel'] = new_label\\n nodes_labeled.append(neigh) # this is a list that gets passed through recursions\\n if flag_critical == True:\\n P.node[neigh]['critical'] = True\\n # labeling part done\\n \\n # and now recursive step - going into each neighbor to continue, in any order if necessary\\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\\n for perm in permutations:\\n this_run_success = True\\n this_run_labeled = []\\n for el in perm:\\n (s, nl) = heuristic2B_label_OBD(el, P, new_label, flag_critical)\\n this_run_labeled = this_run_labeled + nl\\n if s == False:\\n this_run_success = False\\n if this_run_success == False:\\n # then unlabel all that were labelled up to now\\n for nn in this_run_labeled:\\n P.node[nn]['OBDlabel'] = None\\n P.node[nn]['critical'] = False\\n else: # obviously success is True, we managed to label all others...\\n nodes_labeled = nodes_labeled + this_run_labeled\\n return (True, nodes_labeled)\\n break\\n # if no permutation is successful, we end up returning the last line\\n return (False, nodes_labeled)\",\n \"def propagate_labels_majority(image,labels):\\n rlabels,_ = label(image)\\n cors = correspondences(rlabels,labels)\\n outputs = zeros(amax(rlabels)+1,'i')\\n counts = zeros(amax(rlabels)+1,'i')\\n for rlabel, label_, count in cors.T:\\n if not rlabel or not label_:\\n # ignore background correspondences\\n continue\\n if counts[rlabel] < count:\\n outputs[rlabel] = label_\\n counts[rlabel] = count\\n outputs[0] = 0\\n return outputs[rlabels]\",\n \"def _get_watershed_boundaries(self, class_mask, dist_thresh=0.6):\\n\\n kernel = np.ones((5, 5), np.float32)\\n\\n # Use a distance transform to find the seed points for watershed\\n tmp = class_mask\\n tmp[tmp>0] = 1 # here\\n dist = cv2.distanceTransform(tmp, cv2.DIST_L2, 5) # here .astype(np.uint8), cv2.DIST_L2, 5)\\n dist = (dist / np.max(dist)) * 255.\\n\\n # Since there may be multiple peaks, we use dilation to find them\\n dilate = cv2.dilate(dist, kernel, iterations=3)\\n peaks = np.float32(np.where(dilate == dist, 1, 0))\\n peaks = peaks * class_mask * 255\\n\\n sure_fg = np.where(peaks > 125, 255., 0.)\\n sure_fg = cv2.dilate(sure_fg, kernel, iterations=2)\\n sure_fg = np.uint8(sure_fg)\\n\\n sure_bg = cv2.dilate(class_mask, kernel, iterations=3) * 255\\n unknown = sure_bg - sure_fg\\n\\n # Add one to all labels so that known background is not 0, but 1\\n _, markers = cv2.connectedComponents(sure_fg)\\n markers = markers + 1\\n\\n markers[unknown == 255] = 0\\n\\n markers = cv2.watershed(self.image, markers)\\n\\n watershed_superpixels = np.zeros(class_mask.shape, dtype=np.uint8)\\n watershed_superpixels[markers == -1] = 255\\n\\n return watershed_superpixels\",\n \"def kohonen():\\n# plb.close('all')\\n \\n dim = 28*28\\n data_range = 255.0\\n \\n # load in data and labels \\n data = np.array(np.loadtxt('data.txt'))\\n labels = np.loadtxt('labels.txt')\\n\\n # select 4 digits \\n name = \\\"Stettler\\\"\\n targetdigits = name2digits(name) # assign the four digits that should be used\\n print(targetdigits) # output the digits that were selected\\n\\n # this selects all data vectors that corresponds to one of the four digits\\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\\n \\n dy, dx = data.shape\\n \\n #set the size of the Kohonen map. In this case it will be 6 X 6\\n size_k = 6\\n \\n #set the width of the neighborhood via the width of the gaussian that\\n #describes it\\n sigma = 2.0\\n \\n #initialise the centers randomly\\n centers = np.random.rand(size_k**2, dim) * data_range\\n \\n #build a neighborhood matrix\\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\\n\\n #set the learning rate\\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\\n \\n #set the maximal iteration count\\n tmax = 5000 # this might or might not work; use your own convergence criterion\\n \\n #set the random order in which the datapoints should be presented\\n i_random = np.arange(tmax) % dy\\n np.random.shuffle(i_random)\\n \\n for t, i in enumerate(i_random):\\n som_step(centers, data[i,:],neighbor,eta,sigma)\\n\\n # for visualization, you can use this:\\n for i in range(size_k**2):\\n plb.subplot(size_k,size_k,i)\\n \\n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\\n plb.axis('off')\\n \\n # leave the window open at the end of the loop\\n plb.show()\\n plb.draw()\",\n \"def labelNeighbours26(data, label, x0,y0,z0, index):\\n shape = label.shape;\\n for xp in range(max(0,-1+x0),min(2+x0, shape[0])):\\n for yp in range(max(0,-1+y0),min(2+y0, shape[1])):\\n for zp in range(max(0,-1+z0),min(2+z0, shape[2])):\\n if data[xp,yp,zp] and label[xp,yp,zp] == 0:\\n label[xp,yp,zp] = index;\\n label = labelNeighbours26(data, label, xp,yp,zp, index);\\n return label;\",\n \"def heuristic2_label_OBD(n, P, label, critical=None):\\n print \\\"trying to label \\\" + str(n) + \\\" with \\\" + str(label)\\n nodes_labeled = []\\n if ('critical' in P.node[n].keys()) and (P.node[n]['critical']==True) and (P.node[n]['OBDlabel'] != label) :\\n print \\\"FAIL on critical and not the same label.\\\"\\n return (False, []) # being critical, we could avoid failure only if the label to set would be the same (it happens)\\n else:\\n P.node[n]['OBDlabel'] = label\\n nodes_labeled.append(n) # this is a list that gets passed through recursions\\n if critical == True:\\n P.node[n]['critical'] = True\\n # labeling part done\\n flag_critical = False # if I will label more than one neighbor from now on, then the labels will be critical (not to be changed by others)\\n new_label = label + 1\\n neighbors = P.neighbors(n)\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if P.node[neigh]['OBDlabel'] > new_label:\\n new_label = P.node[neigh]['OBDlabel']\\n # we got maximum of current label or any node that neighbors have - now we label them all with that\\n neighbors_to_label = []\\n for neigh in neighbors:\\n if 'OBDlabel' in P.node[neigh].keys():\\n if (P.node[neigh]['OBDlabel'] >= P.node[n]['OBDlabel']) or (P.node[neigh]['OBDlabel'] == None): # now they can have it, but set to None (because of removal in failers)\\n neighbors_to_label.append(neigh)\\n else: # if set and smaller than mine, leave them alone\\n pass\\n else: # if not set, then not lower and not labelled\\n neighbors_to_label.append(neigh)\\n # now we have all the neighbors that need to be labeled\\n if len(neighbors_to_label) > 1:\\n flag_critical = True\\n # and now the recursive step - labeling all these nodes\\n permutations = itertools.permutations(neighbors_to_label) # iterator : gets exhausted as we access elements\\n for perm in permutations:\\n print \\\"trying perm: \\\" + str(perm)\\n this_run_success = True\\n this_run_labeled = []\\n for el in perm:\\n (s, nl) = heuristic2_label_OBD(el, P, new_label, flag_critical)\\n this_run_labeled = this_run_labeled + nl\\n if s == False:\\n this_run_success = False\\n break\\n if this_run_success == False:\\n # then unlabel all that were labelled up to now\\n for nn in this_run_labeled:\\n print \\\"removing label of \\\" + str(nn)\\n P.node[nn]['OBDlabel'] = None\\n P.node[nn]['critical'] = False\\n else: # obviously success is True, we managed to label all others...\\n nodes_labeled = nodes_labeled + this_run_labeled\\n print \\\"Win in labeling neighbors of \\\" + str(n)\\n return (True, nodes_labeled)\\n break\\n # if no permutation is successful, we end up returning the last line\\n return (False, nodes_labeled)\\n print \\\"FAIL of all permutations from \\\" + str(n)\",\n \"def watershed(mask, img, plotImage = False, kernelSize = None):\\n imgCopy = img.copy()\\n maskCopy = np.array(mask.copy(), dtype=np.uint8)\\n \\n if kernelSize is None:\\n kernelSize = 2\\n\\n # Finding sure foreground area\\n #dist_transform = cv2.distanceTransform(mask, cv2.DIST_L2, 5)\\n #ret, sure_fg = cv2.threshold(dist_transform,0.3*dist_transform.max(),255,0) #change the second argument to change the sensitivity \\n maskClosed = skimage.morphology.closing(np.array(maskCopy, dtype=np.uint8))\\n maskClosed = skimage.morphology.closing(np.array(maskClosed, dtype=np.uint8))\\n kernel = np.ones((kernelSize,kernelSize), np.uint8)\\n # maskCopy = img_as_bool(maskCopy)\\n sure_fg = cv2.erode(maskClosed, kernel, iterations = 2) ###\\n sure_fg = skimage.morphology.closing(np.array(sure_fg, dtype=np.uint8))\\n # kernel = np.ones((2,2), np.uint8)\\n # sure_fg = binary_closing(sure_fg, kernel)\\n \\n # sure background area\\n #kernel = np.ones((5, 5), np.uint8)\\n #sure_bg = cv2.dilate(mask, kernel, iterations = 1)\\n sure_fg_bool = 1 - img_as_bool(sure_fg)\\n # sure_bg = np.uint8(1 - morphology.medial_axis(sure_fg_bool)) ### \\n sure_bg = np.uint8(1 - morphology.skeletonize(sure_fg_bool))\\n sure_bg[0, :] = 1\\n sure_bg[-1, :] = 1\\n sure_bg[:, 0] = 1\\n sure_bg[:, -1] = 1\\n \\n # Finding unknown region\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n \\n if plotImage:\\n plt.figure()\\n plt.imshow(sure_fg)\\n plt.title(\\\"Inner Marker\\\")\\n plt.figure()\\n plt.imshow(sure_bg)\\n plt.title(\\\"Outer Marker\\\")\\n plt.figure()\\n plt.imshow(unknown)\\n plt.title(\\\"Unknown\\\")\\n \\n # Marker labelling\\n ret, markers = cv2.connectedComponents(sure_fg)\\n\\n # Add one to all labels so that sure background is not 0, but 1\\n markers = markers+1\\n\\n # Now, mark the region of unknown with zero\\n markers[unknown==1] = 0\\n \\n if plotImage:\\n plt.figure()\\n plt.imshow(markers, cmap='jet')\\n plt.title(\\\"Markers\\\")\\n \\n # Do watershed\\n markers = cv2.watershed(imgCopy, markers)\\n \\n imgCopy[markers == -1] = [0, 255 ,0]\\n\\n if plotImage:\\n plt.figure()\\n plt.imshow(markers,cmap='jet')\\n plt.title(\\\"Mask\\\")\\n plt.figure()\\n plt.imshow(img)\\n plt.title(\\\"Original Image\\\")\\n plt.figure()\\n plt.imshow(imgCopy)\\n plt.title(\\\"Marked Image\\\")\\n plt.show()\\n\\n return markers\",\n \"def cwatershed(f, g, Bc=None, LINEREG=\\\"LINES\\\"):\\n from numpy import ones, zeros, nonzero, array, put, take, argmin, transpose, compress, concatenate\\n if Bc is None: Bc = secross()\\n return g\\n print 'starting'\\n withline = (LINEREG == 'LINES')\\n if isbinary(g):\\n g = label(g,Bc)\\n print 'before 1. pad4n'\\n status = pad4n(to_uint8(zeros(f.shape)),Bc, 3)\\n f = pad4n( f,Bc,0) #pad input image\\n print 'before 2. pad4n'\\n y = pad4n( g,Bc,0) # pad marker image with 0\\n if withline:\\n y1 = intersec(binary(y), 0)\\n costM = limits(f)[1] * ones(f.shape) # cuulative cost function image\\n mi = nonzero(gradm(y,sebox(0),Bc).ravel()) # 1D index of internal contour of marker\\n print 'before put costM'\\n put(costM.ravel(),mi, 0)\\n HQueue=transpose([mi, take(costM.ravel(), mi)]) # init hierarquical queue: index,value\\n print 'before se2list0'\\n Bi=se2list0(f,Bc) # get 1D displacement neighborhood pixels\\n x,v = mat2set(Bc)\\n while HQueue:\\n print 'Hq=',HQueue\\n i = argmin(HQueue[:,1]) # i is the index of minimum value\\n print 'imin=',i\\n pi = HQueue[i,0]\\n print 'pi=',pi\\n ii = ones(HQueue.shape[0])\\n ii[i] = 0\\n print 'ii=',ii\\n HQueue = transpose(array([compress(ii,HQueue[:,0]),\\n compress(ii,HQueue[:,1])])) # remove this pixel from queue\\n print 'H=',HQueue\\n put(status.ravel(), pi, 1) # make it a permanent label\\n for qi in pi+Bi : # for each neighbor of pi\\n if (status.flat[qi] != 3): # not image border\\n if (status.flat[qi] != 1): # if not permanent\\n cost_M = max(costM.flat[pi], f.flat[qi])\\n if cost_M < costM.flat[qi]:\\n print 'qi=',qi\\n costM.flat[qi] = cost_M\\n y.flat[qi] = y.flat[pi] # propagate the label\\n aux = zeros(array(HQueue.shape) + [1,0])\\n aux[:-1,:] = HQueue\\n aux[-1,:]=[qi, cost_M]\\n HQueue = aux # insert pixel in the queue\\n print 'insert H=',HQueue\\n elif (withline and\\n (y.flat[qi] != y.flat[pi]) and\\n (y1.flat[pi] == 0) and\\n (y1.flat[qi] == 0) ):\\n y1.flat[pi] = 1\\n if withline:\\n Y = y1\\n else:\\n Y = y\\n return Y\",\n \"def convert_to_original_labels(array, threshold=0.5, initialization_value=999):\\r\\n \\r\\n binarized, belief = get_binarized_and_belief(array=array, threshold=threshold)\\r\\n \\r\\n #sanity check\\r\\n if binarized.shape != belief.shape:\\r\\n raise ValueError('Sanity check did not pass.')\\r\\n \\r\\n # initialize with a crazy label we will be sure is gone in the end\\r\\n slice_all_but_last_channel = tuple([slice(None) for _ in array.shape[:-1]] + [0])\\r\\n original_labels = initialization_value * np.ones_like(array[slice_all_but_last_channel])\\r\\n \\r\\n # the outer keys correspond to the binarized values\\r\\n # the inner keys correspond to the order of indices comingn from argsort(ascending) on suspicion, i.e. \\r\\n # how far the binarized sigmoid outputs were from the original sigmoid outputs \\r\\n # for example, (2, 1, 0) means the suspicion from least to greatest was: 'WT', 'TC', 'ET'\\r\\n # (recall that the order of the last three channels is expected to be: 'ET', 'TC', and 'WT')\\r\\n mapper = {(0, 0, 0): 0, \\r\\n (1, 1, 1): 4,\\r\\n (0, 1, 1): 1,\\r\\n (0, 0, 1): 2,\\r\\n (0, 1, 0): {(2, 0, 1): 0,\\r\\n (2, 1, 0): 0, \\r\\n (1, 0, 2): 1,\\r\\n (1, 2, 0): 1,\\r\\n (0, 2, 1): 0,\\r\\n (0, 1, 2): 1}, \\r\\n (1, 1, 0): {(2, 0, 1): 0,\\r\\n (2, 1, 0): 0, \\r\\n (1, 0, 2): 4,\\r\\n (1, 2, 0): 4,\\r\\n (0, 2, 1): 4,\\r\\n (0, 1, 2): 4},\\r\\n (1, 0, 1): {(2, 0, 1): 4,\\r\\n (2, 1, 0): 2, \\r\\n (1, 0, 2): 2,\\r\\n (1, 2, 0): 2,\\r\\n (0, 2, 1): 4,\\r\\n (0, 1, 2): 4}, \\r\\n (1, 0, 0): {(2, 0, 1): 0,\\r\\n (2, 1, 0): 0, \\r\\n (1, 0, 2): 0,\\r\\n (1, 2, 0): 0,\\r\\n (0, 2, 1): 4,\\r\\n (0, 1, 2): 4}}\\r\\n \\r\\n \\r\\n \\r\\n done_replacing = False\\r\\n \\r\\n for binary_key, inner in mapper.items():\\r\\n mask1 = check_subarray(array1=binarized, array2=np.array(binary_key))\\r\\n if isinstance(inner, int):\\r\\n original_labels, done_replacing = replace_initializations(done_replacing=done_replacing, \\r\\n array=original_labels, \\r\\n mask=mask1, \\r\\n replacement_value=inner, \\r\\n initialization_value=initialization_value)\\r\\n else:\\r\\n for inner_key, inner_value in inner.items():\\r\\n mask2 = np.logical_and(mask1, check_subarray(array1=belief, array2=np.array(inner_key)))\\r\\n original_labels, done_replacing = replace_initializations(done_replacing=done_replacing,\\r\\n array=original_labels, \\r\\n mask=mask2, \\r\\n replacement_value=inner_value, \\r\\n initialization_value=initialization_value)\\r\\n \\r\\n if not done_replacing:\\r\\n raise ValueError('About to return so should have been done replacing but told otherwise.')\\r\\n \\r\\n return original_labels.astype(np.uint8)\",\n \"def island_loss_of_weight(self):\\n for y in self.island_map:\\n for cell in y:\\n cell.loss_of_weight()\",\n \"def compute_wl_subtree_kernel(graphs, h):\\n for G in graphs:\\n for node in G.nodes():\\n G.node[node]['label'] = G.degree(node)\\n\\n start_time = time.time()\\n\\n labels = {}\\n label_lookup = {}\\n label_counter = 0\\n\\n N = len(graphs)\\n\\n orig_graph_map = {it: {i: defaultdict(lambda: 0) for i in range(N)} for it in range(-1, h)}\\n\\n # initial labeling\\n ind = 0\\n for G in graphs:\\n labels[ind] = np.zeros(G.number_of_nodes(), dtype=np.int32)\\n node2index = {}\\n for node in G.nodes():\\n node2index[node] = len(node2index)\\n\\n for node in G.nodes():\\n label = G.node[node]['label']\\n if not label_lookup.has_key(label):\\n label_lookup[label] = len(label_lookup)\\n\\n labels[ind][node2index[node]] = label_lookup[label]\\n orig_graph_map[-1][ind][label] = orig_graph_map[-1][ind].get(label, 0) + 1\\n\\n ind += 1\\n\\n compressed_labels = copy.deepcopy(labels)\\n\\n # WL iterations\\n for it in range(h):\\n unique_labels_per_h = set()\\n label_lookup = {}\\n ind = 0\\n for G in graphs:\\n node2index = {}\\n for node in G.nodes():\\n node2index[node] = len(node2index)\\n\\n for node in G.nodes():\\n node_label = tuple([labels[ind][node2index[node]]])\\n neighbors = G.neighbors(node)\\n if len(neighbors) > 0:\\n neighbors_label = tuple([labels[ind][node2index[neigh]] for neigh in neighbors])\\n node_label = str(node_label) + \\\"-\\\" + str(sorted(neighbors_label))\\n if not label_lookup.has_key(node_label):\\n label_lookup[node_label] = len(label_lookup)\\n\\n compressed_labels[ind][node2index[node]] = label_lookup[node_label]\\n orig_graph_map[it][ind][node_label] = orig_graph_map[it][ind].get(node_label, 0) + 1\\n\\n ind += 1\\n\\n print \\\"Number of compressed labels at iteration %s: %s\\\" % (it, len(label_lookup))\\n labels = copy.deepcopy(compressed_labels)\\n\\n K = np.zeros((N, N))\\n\\n for it in range(-1, h):\\n for i in range(N):\\n for j in range(N):\\n common_keys = set(orig_graph_map[it][i].keys()) & set(orig_graph_map[it][j].keys())\\n K[i][j] += sum([orig_graph_map[it][i].get(k, 0) * orig_graph_map[it][j].get(k, 0) for k in common_keys])\\n\\n end_time = time.time()\\n print \\\"Total time for WL subtree kernel: \\\", (end_time - start_time)\\n\\n return K\",\n \"def labels(self, threshold, segment=True, exclude_border=0):\\n data = self.unmasked_data\\n isfin = numpy.isfinite(data)\\n data[~isfin] = numpy.amin(data[isfin])\\n regions = (data > threshold)\\n if segment:\\n local_max = peak_local_max(data, indices=False,\\n exclude_border=0,\\n footprint=numpy.ones((3, 3)),\\n labels=regions)\\n markers = measurements.label(local_max)[0]\\n labels = watershed(-data, markers, mask=regions)\\n if exclude_border > 0:\\n # Remove basins originating from edge peaks\\n diff = numpy.zeros_like(local_max)\\n for i in range(local_max.ndim):\\n local_max = local_max.swapaxes(0, i)\\n diff = diff.swapaxes(0, i)\\n diff[:exclude_border] = local_max[:exclude_border]\\n diff[-exclude_border:] = local_max[-exclude_border:]\\n diff = diff.swapaxes(0, i)\\n local_max = local_max.swapaxes(0, i)\\n \\n for l in numpy.sort(labels[diff])[::-1]:\\n labels[labels == l] = 0\\n labels[labels > l] -= 1\\n ulabels = numpy.unique(labels)\\n n = ulabels[ulabels != 0].size\\n else:\\n data_thres = numpy.zeros_like(data)\\n data_thres[regions] = data[regions]\\n labels, n = measurements.label(data_thres)\\n return labels, n\",\n \"def voronoi_labelling(self, seed):\\n import heapq\\n if hasattr(seed, '__iter__') == False:\\n seed = [seed]\\n try:\\n if (self.weights < 0).any():\\n raise ValueError('some weights are non-positive')\\n except:\\n raise ValueError('undefined weights')\\n dist, active = np.inf * np.ones(self.V), np.ones(self.V)\\n label = - np.ones(self.V, np.int_)\\n idx, neighb, weight = self.compact_neighb()\\n dist[seed] = 0\\n label[seed] = np.arange(len(seed))\\n dg = list(zip(np.zeros_like(seed), seed))\\n heapq.heapify(dg)\\n for j in range(self.V):\\n end = False\\n while True:\\n if len(dg) == 0:\\n end = True\\n break\\n node = heapq.heappop(dg)\\n if active[node[1]]:\\n break\\n if end:\\n break\\n dwin, win = node\\n active[win] = False\\n # the folllowing loop might be vectorized\\n for i in range(idx[win], idx[win + 1]):\\n l, newdist = neighb[i], dwin + weight[i]\\n if newdist < dist[l]:\\n heapq.heappush(dg, (newdist, l))\\n dist[l] = newdist\\n label[l] = label[win]\\n return label\",\n \"def watershed(self, debug=False):\\n kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))\\n opening = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_OPEN, kernel, iterations=2)\\n sure_bg = cv2.dilate(self.th[:, :, 0], kernel, iterations=3)\\n dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)\\n ret, sure_fg = cv2.threshold(dist_transform, 0.1 * dist_transform.max(), 255, 0)\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n ret, markers = cv2.connectedComponents(sure_fg)\\n markers += 1\\n markers[unknown == 255] = 0\\n markers = cv2.watershed(self.img, markers)\\n self.add_color(markers)\\n if debug:\\n cv2.imshow(\\\"fg\\\", unknown)\\n cv2.imshow(\\\"op\\\", opening)\\n cv2.imshow(\\\"o3\\\", sure_bg)\",\n \"def instance_label(task, pred, k=15, n_iters=1, dist_thresh=5, watershed=False):\\n mask = pred\\n\\n # noise removal\\n if k > 1 and n_iters > 0:\\n kernel = np.ones((k, k), np.uint8)\\n mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel,\\n iterations=n_iters)\\n\\n if watershed:\\n from clab.live import filters\\n mask = filters.watershed_filter(mask, dist_thresh=dist_thresh)\\n\\n mask = mask.astype(np.uint8)\\n n_ccs, cc_labels = cv2.connectedComponents(mask, connectivity=4)\\n return cc_labels\",\n \"def beam_search(X, u, w, b, relLabels):\\n\\n candidate_paths = [[] for _ in range(10)] # contains the candidate label sets\\n candidate_vals =[[] for _ in range(10)] # contains the label values (-1/1) for each candidate set\\n candidate_scores = [0. for _ in range(10)]\\n min_score = -1000\\n\\n iter = 0\\n start = 0\\n while True:\\n # print(\\\"Iter: \\\", iter)\\n intermediate_paths = {}\\n # intermediate_paths_val = []\\n interim_scores = []\\n hash_table = {}\\n\\n cnt_paths = 0\\n for cp in range(5):\\n labels_curr = candidate_paths[cp]\\n labels_val_curr = candidate_vals[cp]\\n scores_curr = candidate_scores[cp]\\n Y = -np.ones((10, 1))\\n for lv in range(len(labels_val_curr)):\\n Y[labels_curr[lv]] = labels_val_curr[lv]\\n\\n for l in range(10):\\n candidate_interim = labels_curr[:]\\n candidate_vals_interim = labels_val_curr[:]\\n # if l in labels_curr:\\n # continue\\n\\n temp_relLabels = []\\n for lc in range(len(labels_curr)):\\n temp_relLabels.extend(relLabels[labels_curr[lc]])\\n\\n # temp_relLabels = np.array(list(set(temp_relLabels)))\\n temp_relLabels = np.array(list(set(relLabels[l]).intersection(set(labels_curr))))\\n model_pos = returnModelVal(X, Y, 1.0, u[l], u[l], b[l][0], np.array(temp_relLabels))\\n candidate_interim.append(l)\\n\\n if model_pos < 0:\\n # print('hello')\\n candidate_vals_interim.append(-1)\\n interim_scores.append(-model_pos)\\n else:\\n candidate_vals_interim.append(1)\\n interim_scores.append(model_pos)\\n\\n hash_table[cnt_paths] = candidate_interim\\n intermediate_paths[cnt_paths] = candidate_vals_interim\\n cnt_paths += 1\\n # For the first iteration, just iterate once - all labels in one iteration\\n if start == 0:\\n start = 1\\n break\\n\\n temp_paths = intermediate_paths\\n interim_zip = zip(intermediate_paths, interim_scores)\\n sorted_scores = sorted(interim_zip, key=lambda x: x[1], reverse=True)[:5]\\n intermediate_paths, scores = zip(*sorted_scores)\\n\\n temp_cand = []\\n temp_val = []\\n for i in range(len(intermediate_paths)):\\n temp_cand.append(hash_table[intermediate_paths[i]])\\n temp_val.append(temp_paths[intermediate_paths[i]])\\n # candidate_scores[i] += scores[i]\\n\\n candidate_paths = temp_cand\\n candidate_vals = temp_val\\n print(candidate_paths)\\n print(candidate_vals)\\n # print(scores)\\n # candidate_scores = scores\\n\\n # Exit condition from loop\\n # if max(interim_scores) < min_score:\\n # break\\n #\\n # min_score = min(interim_scores)\\n\\n iter += 1\\n if iter > 5:\\n break\\n\\n candidate_dict = {}\\n for i in range(5):\\n for c in range(len(candidate_paths[i])):\\n if candidate_paths[i][c] not in candidate_dict:\\n candidate_dict[candidate_paths[i][c]] = candidate_vals[i][c]\\n elif candidate_dict[candidate_paths[i][c]] != 2:\\n if candidate_dict[candidate_paths[i][c]] != candidate_vals[i][c]:\\n candidate_dict[candidate_paths[i][c]] = 2.\\n\\n print(candidate_dict)\\n exit()\\n return candidate_dict\",\n \"def from_minimal_schnyder_wood(graph):\\n from sage.graphs.digraph import DiGraph\\n from sage.combinat.dyck_word import DyckWord\\n color_a = graph.incoming_edges('a')[0][2]\\n color_b = graph.incoming_edges('b')[0][2]\\n\\n embedding = graph.get_embedding()\\n graph0 = DiGraph([e for e in graph.edges() if e[2] == color_a],\\n format='list_of_edges')\\n restricted_embedding = {u: [v for v in embedding[u]\\n if v in graph0.neighbors_in(u) or\\n v in graph0.neighbors_out(u)]\\n for u in graph0}\\n\\n voisins_in = {}\\n for u in graph0:\\n if u != 'a':\\n bad_emb = restricted_embedding[u]\\n sortie = graph0.neighbors_out(u)[0]\\n idx = bad_emb.index(sortie)\\n restricted_embedding[u] = bad_emb[idx:] + bad_emb[:idx]\\n voisins_in[u] = restricted_embedding[u][1:]\\n else:\\n voisins_in[u] = list(restricted_embedding[u])\\n voisins_in[u].reverse() # pour les avoir dans le bon sens\\n\\n graph0.set_embedding(restricted_embedding)\\n\\n def clockwise_labelling(gr, vertex):\\n if len(gr) == 1:\\n return [vertex]\\n else:\\n lbl = [vertex]\\n for w in voisins_in[vertex]:\\n lbl += clockwise_labelling(gr, w)\\n return lbl\\n\\n def profil(gr, vertex):\\n if len(gr) == 1:\\n return []\\n else:\\n lbl = []\\n for w in voisins_in[vertex]:\\n lbl += [1] + profil(gr, w) + [0]\\n return lbl\\n\\n dyckword_bottom = profil(graph0, 'a')\\n # this is the profile of the planar graph graph0\\n\\n liste = clockwise_labelling(graph0, 'a')[1:]\\n relabelling = {l: i for i, l in enumerate(liste)}\\n for l in ['a', 'b', 'c']:\\n relabelling[l] = l\\n new_graph = graph.relabel(relabelling, inplace=False)\\n\\n dyckword_top = []\\n for i in range(1, len(graph) - 3):\\n indegree1 = len([u for u in new_graph.incoming_edges(i)\\n if u[2] == color_b])\\n dyckword_top += [1] + [0] * indegree1\\n indegree1 = len([u for u in new_graph.incoming_edges('b')\\n if u[2] == color_b])\\n dyckword_top += [1] + [0] * indegree1\\n\\n dyckword_bottom = DyckWord(dyckword_bottom)\\n dyckword_top = DyckWord(dyckword_top)\\n TIP = TamariIntervalPosets(len(dyckword_bottom) // 2)\\n return TIP.from_dyck_words(dyckword_bottom, dyckword_top)\",\n \"def propagate_labels(image,labels,conflict=0):\\n rlabels,_ = label(image)\\n cors = correspondences(rlabels,labels,False)\\n outputs = zeros(amax(rlabels)+1,'i')\\n oops = -(1<<30)\\n for o,i in cors.T:\\n if outputs[o]!=0: outputs[o] = oops\\n else: outputs[o] = i\\n outputs[outputs==oops] = conflict\\n outputs[0] = 0\\n return outputs[rlabels]\",\n \"def leaf_count(args: Dict[str, Union[bool, str]],\\n model: str = \\\"PLANTCV\\\") -> JSON_TYPE:\\n threshold: int = 116\\n # Code from PlantCV Watershed:\\n # https://plantcv.readthedocs.io/en/stable/tutorials/watershed_segmentation_tutorial/\\n pcv_args = options(image=args.input)\\n pcv.params.debug = pcv_args.debug\\n\\n # Read in image to apply watershedding to\\n ##img, path, filename = pcv.readimage(filename=pcv_args.image)\\n img = cv2.imread(pcv_args.image)\\n # Converting from RGB to LAB and keep green-magenta channel\\n a = pcv.rgb2gray_lab(rgb_img=img, channel='a')\\n # Set up a binary threshold image\\n img_binary = pcv.threshold.binary(gray_img=a, threshold=threshold,\\n max_value=255, object_type='dark')\\n # Blur image to reduce noise\\n img_binary = pcv.median_blur(gray_img=img_binary, ksize=20)\\n # Overlay of mask onto image\\n id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=img_binary)\\n\\n while (not id_objects):\\n threshold += 4\\n img_binary = pcv.threshold.binary(gray_img=a, threshold=threshold,\\n max_value=255, object_type='dark')\\n # Blur image to reduce noise\\n img_binary = pcv.median_blur(gray_img=img_binary, ksize=20)\\n # Overlay of mask onto image\\n id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=img_binary)\\n # Reset threshold\\n threshold = 116\\n\\n # Combine objects\\n obj, mask = pcv.object_composition(img=img,\\n contours=id_objects,\\n hierarchy=obj_hierarchy)\\n # Apply mask\\n masked = pcv.apply_mask(img=img, mask=mask, mask_color=\\\"black\\\")\\n\\n # Using OpenCV for thresholding\\n if model == \\\"OPENCV\\\":\\n return opencv_watershed(masked, mask)\\n\\n # Using ML model for thresholding\\n if model == \\\"ML\\\":\\n mask_path: str = \\\"temp/mask.png\\\"\\n cv2.imwrite(mask_path, masked)\\n print(\\\"masked: \\\", masked)\\n return ml_watershed(pcv_args.image, mask_path)\\n\\n # Using PlantCV watershed functionality\\n return plantcv_watershed(masked, mask)\",\n \"def preprocessing(image, smooth_size, folder):\\n from skimage.restoration import denoise_tv_chambolle\\n \\n dim = int(image.shape[0] / 50.)\\n smoothed = rank.median(image, disk(smooth_size))\\n #smoothed = denoise_tv_chambolle(image, weight=0.002)\\n smoothed = rank.enhance_contrast(smoothed, disk(smooth_size))\\n \\n pl.subplot(2, 3, 1)\\n pl.title(\\\"after median\\\")\\n pl.imshow(smoothed)\\n pl.gray()\\n # If after smoothing the \\\"dot\\\" disappears\\n # use the image value\\n \\n # TODO: wat do with thresh?\\n try:\\n im_max = smoothed.max()\\n thresh = threshold_otsu(image)\\n except:\\n im_max = image.max()\\n thresh = threshold_otsu(image)\\n\\n \\n if im_max < thresh:\\n labeled = np.zeros(smoothed.shape, dtype=np.int32)\\n \\n else:\\n binary = smoothed > thresh\\n \\n # TODO: this array size is the fault of errors\\n bin_open = binary_opening(binary, np.ones((dim, dim)), iterations=5)\\n bin_close = binary_closing(bin_open, np.ones((5,5)), iterations=5)\\n \\n pl.subplot(2, 3, 2)\\n pl.title(\\\"threshold\\\")\\n pl.imshow(binary, interpolation='nearest')\\n pl.subplot(2, 3, 3)\\n pl.title(\\\"opening\\\")\\n pl.imshow(bin_open, interpolation='nearest')\\n pl.subplot(2, 3, 4)\\n pl.title(\\\"closing\\\")\\n pl.imshow(bin_close, interpolation='nearest')\\n \\n distance = ndimage.distance_transform_edt(bin_open)\\n local_maxi = peak_local_max(distance,\\n indices=False, labels=bin_open)\\n \\n markers = ndimage.label(local_maxi)[0]\\n \\n labeled = watershed(-distance, markers, mask=bin_open)\\n pl.subplot(2, 3, 5)\\n pl.title(\\\"label\\\")\\n pl.imshow(labeled)\\n #pl.show()\\n pl.savefig(folder)\\n pl.close('all')\\n\\n #misc.imsave(folder, labeled)\\n# labels_rw = random_walker(bin_close, markers, mode='cg_mg')\\n# \\n# pl.imshow(labels_rw, interpolation='nearest')\\n# pl.show()\\n\\n return labeled\",\n \"def watershed_segment_2(M,click_coords):\\n \\n # todo: choose these structures based on aspect ratio of M and input parameters\\n sel = np.ones((4,10)) # for opening\\n sel2 = np.ones((15,75)) # for local thresholding\\n sel3 = np.ones((2,5)) # for erosion\\n # get a few points in the center of each blob\\n \\n # threshold\\n #bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)) & (M>=scoreatpercentile(M.flatten(),60)))\\n \\n score = stats.percentileofscore(M.flatten(),M[int(click_coords[0][1]),int(click_coords[0][0])])\\n bw = (M>=stats.scoreatpercentile(M.flatten(),score))\\n\\n # open and erode\\n #bools = sp.zeros((M.shape[0],M.shape[1]),int)\\n #bools[int(click_coords[0]),int(click_coords[1])] = 1\\n #blobs = sp.where(bools == 1,True,False)\\n blobs = snm.binary_opening(bw,structure=sel)\\n blobs = snm.binary_dilation(blobs,iterations=3)\\n blobs = snm.binary_erosion(blobs,structure=sel3)\\n \\n \\n # label\\n labels,_ = ndi.label(blobs)\\n labels[labels > 0] += 1\\n #labels[0,0] = 1\\n\\n # rescale and cast to int16, then use watershed\\n M2 = rescaled(M,0,65000).astype(np.uint16)\\n newlabels = ndi.watershed_ift(M2,labels)\\n \\n # get rid of groups unless they have the right number of pixels\\n counts = np.bincount(newlabels.flatten())\\n old2new = np.arange(len(counts))\\n old2new[(counts < 100) | (counts > 600)] = 0\\n newlabels = old2new[newlabels]\\n \\n return newlabels\",\n \"def watershed_segment(M,xM=None,yM=None):\\n\\n if xM != None and yM != None:\\n sel = np.ones((int(ceil(23.9*xM)),int(ceil(23.9*yM)))) # for opening\\n sel2 = np.ones((int(ceil(127.2*xM)),int(ceil(127.2*yM)))) # for local thresholding\\n sel3 = np.ones((int(ceil(11.9*xM)),int(ceil(11.9*yM)))) # for erosion\\n ma,mi =(44245.21*xM*yM),(316.037*xM*yM) \\n else:\\n selD = np.array([int(M.shape[0]*.012),int(M.shape[1]*.012)])\\n selD = np.where(selD!=0,selD,1)\\n \\n sel2D = np.array([int(M.shape[0]*.12),int(M.shape[1]*.12)])\\n sel2D = np.where(sel2D!=0,sel2D,1)\\n\\n sel3D = np.array([int(M.shape[0]*.01),int(M.shape[1]*.01)])\\n sel3D = np.where(sel3D!=0,sel3D,1)\\n\\n\\n sel = np.ones(selD) # for opening\\n sel2 = np.ones(sel2D) # for local thresholding\\n sel3 = np.ones(sel3D) # for erosion\\n ma,mi = (M.shape[0]*M.shape[1]*.0075),(M.shape[0]*M.shape[1]*.0003)\\n\\n # get a few points in the center of each blob\\n \\n # threshold\\n bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)))\\n #& (M>=stats.scoreatpercentile(M.flatten(),80)))\\n\\n # open and erode\\n blobs = snm.binary_opening(bw,structure=sel)\\n blobs = snm.binary_erosion(blobs,structure=sel3,iterations=2)\\n \\n # label\\n labels,_ = ndi.label(blobs)\\n labels[labels > 0] += 1\\n labels[0,0] = 1\\n\\n # rescale and cast to int16, then use watershed\\n #M2 = rescaled(M,0,65000).astype(np.uint16)\\n #newlabels = ndi.watershed_ift(M2,labels)\\n newlabels = labels\\n \\n # get rid of groups unless they have the right number of pixels\\n\\n counts = np.bincount(newlabels.flatten())\\n old2new = np.arange(len(counts)) \\n old2new[(counts < int(mi)) | (counts > int(ma))] = 0\\n newlabels = old2new[newlabels]\\n\\n return newlabels\",\n \"def label_simplex(grid, simplex, thresh):\\n coords = [grid[:,x] for x in simplex]\\n dist = squareform(pdist(coords,'euclidean'))\\n adjacency = dist<thresh\\n adjacency = adjacency.astype(int) \\n graph = csr_matrix(adjacency)\\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\\n\\n return n_components\",\n \"def label(gt_dataset, volume_dim, voxel_dim, labeling_params):\\n labeled_volumes = dict()\\n labeled_cells = dict()\\n #Use global density and reduce the size of gt_dataset here\\n global_density = labeling_params[\\\"global_density\\\"]\\n gt_dataset = {k: v for k,v in gt_dataset.items() if random_sample() < global_density}\\n #Label in the order specified in the configuration\\n layers = sorted(labeling_params.keys())\\n #Remove global_density\\n layers.remove(\\\"global_density\\\")\\n for layer in layers:\\n print \\\"Labeling {}\\\".format(layer)\\n fluorophore = labeling_params[layer]['fluorophore']\\n volume, cells = brainbow(gt_dataset, volume_dim, voxel_dim, **labeling_params[layer])\\n if fluorophore in labeled_volumes:\\n labeled_volumes[fluorophore] += volume\\n labeled_cells[fluorophore] |= cells\\n else:\\n labeled_volumes[fluorophore] = volume\\n labeled_cells[fluorophore] = cells\\n return labeled_volumes, labeled_cells\",\n \"def label_building_polys(burnt_polys, building_polys):\\n\\n for b in building_polys:\\n for r in burnt_polys:\\n if b[0].intersects(r):\\n b[1] = [b[1][0], 'blue', True] # mark building polygon as 'blue' if found in burnt region\\n continue\",\n \"def textDetectWatershed(thresh, original):\\n # According to: http://docs.opencv.org/trunk/d3/db4/tutorial_py_watershed.html\\n img = resize(original, 3000)\\n thresh = resize(thresh, 3000)\\n # noise removal\\n kernel = np.ones((3,3),np.uint8)\\n opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 3)\\n \\n # sure background area\\n sure_bg = cv2.dilate(opening,kernel,iterations=3)\\n\\n # Finding sure foreground area\\n dist_transform = cv2.distanceTransform(opening,cv2.DIST_L2,5)\\n ret, sure_fg = cv2.threshold(dist_transform,0.01*dist_transform.max(),255,0)\\n\\n # Finding unknown region\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg,sure_fg)\\n \\n # Marker labelling\\n ret, markers = cv2.connectedComponents(sure_fg)\\n\\n # Add one to all labels so that sure background is not 0, but 1\\n markers += 1\\n\\n # Now, mark the region of unknown with zero\\n markers[unknown == 255] = 0\\n \\n markers = cv2.watershed(img, markers)\\n implt(markers, t='Markers')\\n image = img.copy()\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n \\n # Creating result array\\n boxes = []\\n for mark in np.unique(markers):\\n # mark == 0 --> background\\n if mark == 0:\\n continue\\n\\n # Draw it on mask and detect biggest contour\\n mask = np.zeros(gray.shape, dtype=\\\"uint8\\\")\\n mask[markers == mark] = 255\\n\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n c = max(cnts, key=cv2.contourArea)\\n \\n # Draw a bounding rectangle if it contains text\\n x,y,w,h = cv2.boundingRect(c)\\n cv2.drawContours(mask, c, 0, (255, 255, 255), cv2.FILLED)\\n maskROI = mask[y:y+h, x:x+w]\\n # Ratio of white pixels to area of bounding rectangle\\n r = cv2.countNonZero(maskROI) / (w * h)\\n \\n # Limits for text\\n if r > 0.1 and 2000 > w > 15 and 1500 > h > 15:\\n boxes += [[x, y, w, h]]\\n \\n # Group intersecting rectangles\\n boxes = group_rectangles(boxes)\\n bounding_boxes = np.array([0,0,0,0])\\n for (x, y, w, h) in boxes:\\n cv2.rectangle(image, (x, y),(x+w,y+h), (0, 255, 0), 8)\\n bounding_boxes = np.vstack((bounding_boxes, np.array([x, y, x+w, y+h])))\\n \\n implt(image)\\n\\n # Recalculate coordinates to original size\\n boxes = bounding_boxes.dot(ratio(original, img.shape[0])).astype(np.int64)\\n return boxes[1:]\",\n \"def detection(test_img):\\n # TODO: Step 2 : Your Detection code should go here.\\n no_row = len(test_img)\\n no_col = len(test_img[0])\\n thresh = 100\\n label_img = np.zeros((no_row, no_col))\\n uf = []\\n \\n #first pass\\n l = 1\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if test_img[i,j] < 255 - thresh:\\n if i == 0 and j == 0:\\n label_img[i,j] = l\\n l = l+1\\n elif i == 0 and j != 0:\\n if label_img[i,j-1] == 0:\\n label_img[i,j] = l\\n l = l+1\\n else:\\n label_img[i,j] = label_img[i,j-1]\\n elif i != 0 and j == 0:\\n if label_img[i-1,j] == 0:\\n label_img[i,j] = l\\n l = l+1\\n else:\\n label_img[i,j] = label_img[i-1,j]\\n else:\\n if label_img[i-1,j] == 0 and label_img[i,j-1] == 0:\\n label_img[i,j] = l\\n l = l+1\\n elif label_img[i-1,j] == 0 and label_img[i,j-1] != 0:\\n label_img[i,j] = label_img[i,j-1]\\n elif label_img[i-1,j] != 0 and label_img[i,j-1] == 0:\\n label_img[i,j] = label_img[i-1,j]\\n else:\\n if label_img[i,j-1] == label_img[i-1,j]:\\n label_img[i,j] = label_img[i,j-1]\\n else:\\n label_img[i,j] = min(label_img[i-1,j],label_img[i,j-1])\\n uf.append([min(label_img[i,j-1],label_img[i-1,j]),max(label_img[i,j-1],label_img[i-1,j])])\\n l = l - 1\\n \\n #2nd pass\\n def ufds(x,l):\\n b = []\\n for i in range(1,l+1):\\n b.append([i])\\n for j in x:\\n i1 = 0\\n i2 = 0\\n for k in range(0,len(b)):\\n if j[0] in b[k]:\\n i1 = k\\n if j[1] in b[k]:\\n i2 = k\\n if i1 != i2:\\n b[i1] = b[i1] + b[i2]\\n del b[i2]\\n return b\\n \\n bman = ufds(uf,l)\\n \\n #3rd pass\\n uf_arr = np.zeros(l)\\n for i in range(0,len(uf_arr)):\\n for j in bman:\\n if i+1 in j:\\n uf_arr[i] = min(j) \\n \\n fin_img = np.zeros((no_row, no_col))\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if label_img[i,j] != 0:\\n fin_img[i,j] = uf_arr[int(label_img[i,j] - 1)]\\n \\n all_label = []\\n '''\\n for i in bman:\\n all_label.append(min(i))\\n ''' \\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if fin_img[i,j] !=0 and fin_img[i,j] not in all_label:\\n all_label.append(fin_img[i,j])\\n \\n # main image\\n k_img = np.zeros((no_row, no_col))\\n for i in range(0, no_row):\\n for j in range(0, no_col):\\n if fin_img[i,j] != 0:\\n k_img[i,j] = (all_label.index(fin_img[i,j]) + 1)\\n \\n k_list = []\\n for i in range(1,len(all_label)+1):\\n x = None\\n y = None\\n hx = None\\n hy = None\\n for j in range(0,no_row):\\n for k in range(0,no_col):\\n if k_img[j,k] == i:\\n if y == None and x == None:\\n y = j\\n hy = j\\n x = k\\n hx = k\\n else:\\n if y > j:\\n y = j\\n if hy < j:\\n hy = j\\n if x > k:\\n x = k\\n if hx < k:\\n hx = k\\n k_list.append({\\\"bbox\\\": [x, y, hx-x, hy-y]})\\n \\n return k_list\\n \\n #raise NotImplementedError\",\n \"def wetting(lgca):\\n if hasattr(lgca, 'spheroid'):\\n birth = npr.random(lgca.nodes[lgca.spheroid].shape) < lgca.r_b\\n ds = (1 - lgca.nodes[lgca.spheroid]) * birth\\n lgca.nodes[lgca.spheroid, :] = np.add(lgca.nodes[lgca.spheroid, :], ds, casting='unsafe')\\n lgca.update_dynamic_fields()\\n newnodes = lgca.nodes.copy()\\n relevant = (lgca.cell_density[lgca.nonborder] > 0)\\n coords = [a[relevant] for a in lgca.nonborder]\\n nbs = lgca.nb_sum(lgca.cell_density) # + lgca.cell_density\\n nbs *= np.clip(1 - nbs / lgca.n_crit, a_min=0, a_max=None) / lgca.n_crit * 2\\n g_adh = lgca.gradient(nbs)\\n pressure = np.clip(lgca.cell_density - lgca.rho_0, a_min=0., a_max=None) / (lgca.K - lgca.rho_0)\\n g_pressure = -lgca.gradient(pressure)\\n\\n resting = lgca.nodes[..., lgca.velocitychannels:].sum(-1)\\n resting = lgca.nb_sum(resting) / lgca.velocitychannels / lgca.rho_0\\n g = lgca.calc_flux(lgca.nodes)\\n g = lgca.nb_sum(g)\\n\\n for coord in zip(*coords):\\n n = lgca.cell_density[coord]\\n permutations = lgca.permutations[n]\\n restc = permutations[:, lgca.velocitychannels:].sum(-1)\\n j = lgca.j[n]\\n j_nb = g[coord]\\n weights = np.exp(\\n lgca.beta * (j_nb[0] * j[0] + j_nb[1] * j[1]) / lgca.velocitychannels / 2\\n + lgca.beta * resting[coord] * restc #* np.clip(1 - restc / lgca.rho_0 / 2, a_min=0, a_max=None) * 2\\n + lgca.beta * np.einsum('i,ij', g_adh[coord], j)\\n # + lgca.alpha * np.einsum('i,ij', g_subs[coord], j)\\n + restc * lgca.ecm[coord]\\n + lgca.gamma * np.einsum('i,ij', g_pressure[coord], j)\\n ).cumsum()\\n ind = bisect_left(weights, random() * weights[-1])\\n newnodes[coord] = permutations[ind]\\n\\n lgca.nodes = newnodes\\n lgca.ecm -= lgca.alpha * lgca.ecm * lgca.cell_density / lgca.K\",\n \"def detect_labels(img: np.ndarray):\\n \\n # Create a range of allowed colors.\\n lower_color = np.array([20, 50, 0])\\n upper_color = np.array([255, 255, 255])\\n\\n # Keep the pixels that lie within the range.\\n color_filtered = cv.inRange(\\n cv.cvtColor(img, cv.COLOR_RGB2HSV),\\n lower_color,\\n upper_color\\n )\\n \\n # Keeping only the really bright pixels (converted to 255), change the dull ones to 0.\\n # Helps distinguish the labels from other dull colors.\\n _, thresholded = cv.threshold(color_filtered, 254, 255, cv.THRESH_BINARY)\\n\\n # Reduce the thickness of regions. Every 30x30 sliding window of 255 in the image gets replaced by a white pixel.\\n # The stronger the erosion, the more the noise is removed, with a chance of removal of good pixels as well.\\n eroded = cv.erode(thresholded, np.ones((30, 30)))\\n\\n # Now find outlines of the bright regions that remain after the thickness reduction.\\n contours, _ = cv.findContours(eroded, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)\\n \\n # Identify the contours that represent our labels.\\n # Gotta be the two largest ones in terms of area.\\n contour_areas = [(cv.contourArea(c), idx) for (idx, c) in enumerate(contours)]\\n\\n contour_largest_idx = max(contour_areas)[1]\\n contour_second_largest_idx = max(filter(lambda item: item[1] != contour_largest_idx, contour_areas))[1]\\n\\n # Since the labels are sorta rectangular, find the mean of the contours' y-axes to approximate the vertical center of the labels.\\n largest_vertical_center = np.mean(contours[contour_largest_idx][:, :, 1])\\n second_largest_vertical_center = np.mean(contours[contour_second_largest_idx][:, :, 1])\\n\\n # Higher center implies the value is more towards the bottom of the image, and hence the vertical center of the bottom label.\\n bottom_label = min(largest_vertical_center, second_largest_vertical_center)\\n \\n # Lower center implies the value is more towards the top of the image, and hence the vertical center of the top label.\\n top_label = max(largest_vertical_center, second_largest_vertical_center)\\n\\n return bottom_label, top_label\",\n \"def region_labeling(image, th=None, black_blobs=True, set_recursion_limit=True,\\n recursion_limit=10000):\\n\\n # Setup\\n shape = np.shape(image)\\n old_recursion_limit = sys.getrecursionlimit()\\n if set_recursion_limit:\\n sys.setrecursionlimit(recursion_limit)\\n\\n if len(shape) == 3:\\n image = image.mean(axis=2)\\n elif len(shape) > 3:\\n raise ValueError('Must be at 2D image')\\n\\n # Threshold image\\n labeled = threshold(image, th=th).astype(int)\\n labeled = 255-labeled if black_blobs else labeled\\n labeled[labeled == 255] = -1\\n\\n # Label blobs\\n blobs = 0\\n for i in range(shape[0]):\\n for j in range(shape[1]):\\n if labeled[i, j] == -1:\\n blobs += 1\\n flood_fill(labeled, y=i, x=j, colour=blobs)\\n\\n # Cleanup\\n sys.setrecursionlimit(old_recursion_limit)\\n\\n return labeled\",\n \"def _get_label_weight(opts, data):\\n experiments = data[\\\"exp_names\\\"].value\\n label_mat = numpy.zeros((experiments.size, 7))\\n vid_lengths = numpy.zeros((experiments.size,))\\n for i in range(experiments.size):\\n exp_key = experiments[i]\\n exp = data[\\\"exps\\\"][exp_key]\\n for j in range(6):\\n # label_counts[j] += exp[\\\"org_labels\\\"].value[:, j].sum()\\n label_mat[i, j] = exp[\\\"org_labels\\\"].value[:, j].sum()\\n # label_counts[-1] +=\\\\\\n # exp[\\\"org_labels\\\"].shape[0] - exp[\\\"org_labels\\\"].value.sum()\\n label_mat[i, -1] =\\\\\\n exp[\\\"org_labels\\\"].shape[0] - exp[\\\"org_labels\\\"].value.sum()\\n\\n # vid_lengths[i] = exp[\\\"hoghof\\\"].shape[0]\\n vid_lengths[i] = exp[\\\"org_labels\\\"].shape[0]\\n\\n # label_counts = label_mat.sum(axis=0)\\n label_weight = 1.0 / numpy.mean(label_mat, axis=0)\\n # label_weight[-2] = label_weight[-2] * 10\\n if opts[\\\"flags\\\"].reweight is False:\\n label_weight = [5, 5, 5, 5, 5, 5, .01]\\n # import pdb; pdb.set_trace()\\n return label_weight\",\n \"def hebb_rule(dados):\\n # Passo 0: Inicializar todos os pesos\\n n = len(dados[0][0]) - 1\\n weight = zeros(n + 1)\\n print(weight)\\n\\n # Passo 1: Para cada vetor de treinamento na entrada e par de objetivos na saída (e : s)\\n for _, dado in enumerate(dados):\\n # Passo 2: Ajuste as ativações para as unidades de entrada\\n x = dado[0]\\n # Passo 3: Ajuste a ativação para a unidade de saída\\n y = dado[1]\\n # Passo 4: Ajuste os pesos e o bias\\n for j in range(n):\\n weight[j] += x[j] * y\\n weight[n] += + y # Bias é weight[n]\\n print(weight)\",\n \"def labelComponents26(cube):\\n x,y,z = np.where(cube);\\n label = np.zeros(cube.shape, dtype = 'uint8');\\n ncomp = 0;\\n for xp,yp,zp in zip(x,y,z):\\n if label[xp,yp,zp] == 0:\\n ncomp += 1;\\n label = labelNeighbours26(cube, label, xp,yp,zp, ncomp);\\n return ncomp, label\",\n \"def _refinement_random_walker(\\n self,\\n ds_labels,\\n ds_maskROI,\\n ds_mask,\\n target_label):\\n\\n ds_labels[(ds_maskROI == False) & ds_mask] = target_label\\n ds_labels[(ds_maskROI == False) & (ds_mask == False)] = -1\\n\\n labels = zoom(\\n ds_labels,\\n zoom=np.float32(\\n self.size) /\\n self.ds_size,\\n order=0)\\n maskROI = zoom(\\n ds_maskROI,\\n zoom=np.float32(\\n self.size) /\\n self.ds_size,\\n order=0).astype(\\n np.bool)\\n\\n # Extract labelled and unlabelled vertices\\n m_unlabeled = (labels == 0) & (maskROI)\\n m_foreground = (labels == target_label)\\n\\n unlabeled = np.ravel_multi_index(np.where(m_unlabeled), self.size)\\n labeled = np.ravel_multi_index(np.where(labels != 0), self.size)\\n #labeled = np.ravel_multi_index(np.where((m_foreground) | (labels > 0)), self.size)\\n\\n # Preparing the right handside of the equation BT xs\\n B = self.L[unlabeled][:, labeled]\\n mask = (labels[labels != 0]).flatten() == target_label\\n fs = sparse.csr_matrix(mask).transpose()\\n rhs = B * fs\\n\\n # Preparing the left handside of the equation Lu\\n Lu = self.L[unlabeled][:, unlabeled]\\n\\n # Solve the linear equation Lu xu = -BT xs\\n if self._pyamg_found:\\n ml = ruge_stuben_solver(Lu)\\n M = ml.aspreconditioner(cycle='V')\\n else:\\n M = None\\n xu = cg(Lu, -rhs.todense(), tol=1e-3, M=M, maxiter=120)[0]\\n\\n probability = np.zeros(self.size, dtype=np.float32)\\n probability[m_unlabeled] = xu\\n probability[m_foreground] = 1\\n\\n return probability\",\n \"def watershed(f, Bc=None, LINEREG=\\\"LINES\\\"):\\n from string import upper\\n if Bc is None: Bc = secross()\\n return cwatershed(f,regmin(f,Bc),upper(LINEREG))\\n return y\",\n \"def ray_label_simplex(grid, simplex, thresh):\\n coords = [grid[:,x] for x in simplex]\\n dist = squareform(pdist(coords,'euclidean'))\\n adjacency = dist<thresh\\n adjacency = adjacency.astype(int) \\n graph = csr_matrix(adjacency)\\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\\n\\n return n_components\",\n \"def calculate_class_weights(label_data):\\n neg, pos = np.bincount(label_data)\\n weight_for_0 = 1 / neg\\n weight_for_1 = 1 / pos\\n return {0: weight_for_0, 1: weight_for_1}\",\n \"def opencv_watershed(masked, mask) -> JSON_TYPE:\\n # For code and detailed explanation see:\\n # http://datahacker.rs/007-opencv-projects-image-segmentation-with-watershed-algorithm/\\n threshold: int = 30\\n gray = cv2.cvtColor(masked, cv2.COLOR_RGB2GRAY)\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n\\n n_increases: int = 0\\n while local_max_location.shape[0] < 30 and n_increases < 15:\\n threshold += 20\\n ret, thresh_img = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)\\n # Noise removal\\n kernel = np.ones((3), np.uint8)\\n opening_img = cv2.morphologyEx(thresh_img, cv2.MORPH_OPEN, kernel, iterations=9)\\n # Noise removal\\n closing_img = cv2.morphologyEx(thresh_img, cv2.MORPH_CLOSE, kernel, iterations=4)\\n dist_transform = cv2.distanceTransform(255 - closing_img, cv2.DIST_L2, 3)\\n local_max_location = peak_local_max(dist_transform, min_distance=1, indices=True)\\n n_increases += 1\\n # Reset threshold\\n threshold = 30\\n\\n num_clusters: int = 30\\n if n_increases >= 15:\\n num_clusters = local_max_location.shape[0]\\n kmeans = KMeans(n_clusters=num_clusters)\\n # If local_max_location size is 0, return 0 predictions\\n if not local_max_location.size:\\n return {\\n \\\"count\\\": 0\\n }\\n kmeans.fit(local_max_location)\\n local_max_location = kmeans.cluster_centers_.copy()\\n # Kmeans is returning a float data type so we need to convert it to an int. \\n local_max_location = local_max_location.astype(int)\\n dist_transform_copy = dist_transform.copy()\\n for i in range(local_max_location.shape[0]):\\n cv2.circle(dist_transform_copy, (local_max_location[i][1], local_max_location[i][0]), 5, 255)\\n # markers = np.zeros_like(dist_transform)\\n ret, sure = cv2.threshold(dist_transform, 0.01*dist_transform.max(), 255, 0)\\n sure = np.uint8(sure)\\n ret, markers = cv2.connectedComponents(sure)\\n labels = np.arange(kmeans.n_clusters)\\n markers[local_max_location[:,0], local_max_location[:,1]] = labels + 1\\n # Convert all local markers to an integer. This because cluster centers will be float numbers. \\n markers = markers.astype(int)\\n markers_copy = markers.copy()\\n index_non_zero_markers = np.argwhere(markers != 0)\\n markers_copy = markers_copy.astype(np.uint8)\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n for i in range(index_non_zero_markers.shape[0]):\\n string_text = str(markers[index_non_zero_markers[i][0], index_non_zero_markers[i][1]])\\n cv2.putText(markers_copy, string_text, (index_non_zero_markers[i][1], index_non_zero_markers[i][0]), font, 1, 255)\\n markers = markers.astype(np.int32)\\n segmented = cv2.watershed(masked, markers)\\n count_segments(markers)\\n #return {\\n # \\\"count\\\": local_max_location.shape[0]\\n #}\\n return {\\n \\\"count\\\": count_segments(markers),\\n }\",\n \"def cross_junctions(I, bounds, Wpts):\\n #--- FILL ME IN ---\\n\\n Ipts = np.zeros((2, 48))\\n\\n#parameters\\n alpha = 0.15 #typically 0.04 to 0.06\\n threshold = 1500 #default 2000\\n sigma = 2\\n ws = 12 #window size for saddle point\\n\\n#building Harris Detecter\\n I = I/255.0\\n gradx, grady = np.gradient(I)\\n IxIx = gaussian_filter(gradx*gradx,sigma)\\n IxIy = gaussian_filter(gradx*grady,sigma)\\n IyIy = gaussian_filter(grady*grady,sigma)\\n print(I.shape)\\n\\n #get harris score\\n cand_score = []\\n cand_index = []\\n cand = []\\n s_cand = []\\n\\n for j in range(len(I)):\\n for i in range(len(I[0])):\\n a11 = IxIx[j][i]\\n a12 = IxIy[j][i]\\n a21 = a12\\n a22 = IyIy[j][i]\\n A = np.array([[a11, a12],[a21, a22]])\\n ev0, ev1 = np.linalg.eigvals(A)\\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\\n cand_score.append(-h_score)\\n cand_index.append([i, j])\\n\\n #get the coordinates of the top 5000 scores\\n sorted_ind = np.argsort(cand_score)\\n sorted_score = np.sort(cand_score).tolist()\\n\\n for ind in sorted_ind[:threshold]:\\n cand.append(cand_index[ind])\\n s_cand = sorted_score[:threshold]\\n\\n\\n#clustering\\n #using homography to project candidate points to a up-front view\\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\\n H = dlt_homography(bounds, new_bbox)\\n cand = np.array(cand).T\\n cand = np.vstack((cand, np.ones(cand.shape[1])))\\n Ho_cand = np.matmul(H,cand).T\\n for pt in Ho_cand:\\n pt[0] = pt[0]/pt[2]\\n pt[1] = pt[1]/pt[2]\\n Ho_cand = Ho_cand[:,:2]\\n Ho_cand = Ho_cand.tolist()\\n\\n #get rid of points that are not in the boundry\\n temp_Ho_cand = []\\n temp_s_cand = []\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\\n continue\\n else:\\n temp_Ho_cand.append(pt)\\n temp_s_cand.append(s_cand[i])\\n Ho_cand = np.array(temp_Ho_cand)\\n s_cand = temp_s_cand\\n #divide candidates into clusters\\n assignment = []\\n assignment_score = []\\n\\n #first put in the point that has the highest score\\n assignment.append([Ho_cand[0]])\\n assignment_score.append([s_cand[0]])\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n if min(dist) > 6:\\n assignment.append([pt])\\n assignment_score.append([s_cand[i]])\\n\\n assignment = np.array(assignment)\\n\\n #assign points to clusters\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\\n continue\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n index = np.argsort(dist)[-1]\\n np.append(assignment[index], pt)\\n assignment_score[index].append(s_cand[i])\\n\\n #get centroids for each cluster\\n Ho_centroids = []\\n for i in range(len(assignment)):\\n cl = assignment[i]\\n cl = np.array(cl)\\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\\n assignment_score[i] = sum(assignment_score[i])\\n\\n print(len(assignment_score))\\n\\n Ho_centroids = np.array(Ho_centroids)\\n #get rid of edge points\\n\\n xmin = np.amin(Ho_centroids.T[0])\\n xmax = np.amax(Ho_centroids.T[0]) \\n ymin = np.amin(Ho_centroids.T[1])\\n ymax = np.amax(Ho_centroids.T[1])\\n\\n final_cand = []\\n final_score = []\\n for i in range(len(Ho_centroids)):\\n pt = Ho_centroids[i]\\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\\n continue\\n else:\\n final_cand.append(pt)\\n final_score.append(assignment_score[i])\\n print(\\\"Number of corner found: \\\")\\n print(len(final_cand))\\n\\n #get rid of fake corners\\n if (len(final_cand)>48):\\n ultimate_cand =[]\\n for ind in np.argsort(final_score)[:48]:\\n ultimate_cand.append(final_cand[ind])\\n final_cand = ultimate_cand\\n print(\\\"real corners count:\\\", len(ultimate_cand))\\n\\n\\n #sort the points\\n final_cand = np.array(final_cand)\\n y_sort_ind = np.argsort(final_cand.T[1])\\n final_cand = final_cand.tolist()\\n rows = []\\n for i in range(6):\\n row = []\\n for ind in y_sort_ind[i*8:(i+1)*8]:\\n row.append(final_cand[ind])\\n rows.append(row)\\n\\n ordered = []\\n for row in rows:\\n r = []\\n x_sort_ind = np.argsort(np.array(row).T[0])\\n for ind in x_sort_ind:\\n r.append(row[ind])\\n ordered.append(r)\\n\\n final_cand = []\\n for row in ordered:\\n for pt in row:\\n final_cand.append(pt)\\n \\n\\n\\n #get coordinates of the centroids in the original frame\\n Ho_centroids = np.array(final_cand)\\n\\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\\n centroids = np.matmul(np.linalg.inv(H), centroids).T\\n for pt in centroids:\\n pt[0] = int(pt[0]/pt[2])\\n pt[1] = int(pt[1]/pt[2])\\n centroids = centroids[:,:2]\\n\\n#finding saddle points around the centroids\\n saddle_points = []\\n for pt in centroids:\\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\\n saddle = saddle_point(img)\\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\\n saddle_points.append(saddle)\\n\\n saddle_points = np.array(saddle_points)\\n #------------------\\n print(saddle_points.T)\\n return saddle_points.T\",\n \"def classify(k, sorted_labels):\\n k_neighbors = sorted_labels[:k]\\n men_occurencies = np.count_nonzero(k_neighbors == 'M')\\n women_occurencies = np.count_nonzero(k_neighbors == 'W')\\n\\n return 'M' if men_occurencies > women_occurencies else 'W'\",\n \"def bridge_problem3(here):\\r\\n\\r\\n def all_over(state):\\r\\n here, _ = state\\r\\n return not here or here == set([\\\"light\\\"])\\r\\n\\r\\n start = (frozenset(here) | frozenset([\\\"light\\\"]), frozenset())\\r\\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)\",\n \"def cell_merge(wsh, pred):\\n wshshape=wsh.shape\\n \\n # masks for the original cells\\n objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\\t\\n \\n # masks for dilated cells\\n dil_objs = np.zeros((wsh.max()+1,wshshape[0],wshshape[1]), dtype=bool)\\n \\n # bounding box coordinates\\t\\n obj_coords = np.zeros((wsh.max()+1,4))\\n \\n # cleaned watershed, output of function\\t\\n wshclean = np.zeros((wshshape[0],wshshape[1]))\\n \\n # kernel to dilate objects\\n kernel = np.ones((3,3), dtype=bool)\\t\\n \\n for obj1 in range(wsh.max()):\\n # create masks and dilated masks for obj\\n objs[obj1,:,:] = wsh==(obj1+1)\\t\\n dil_objs[obj1,:,:] = dilation(objs[obj1,:,:], kernel)\\t\\n \\n # bounding box\\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\\n \\n objcounter = 0\\t# counter for new watershed objects\\n \\n for obj1 in range(wsh.max()):\\t\\n dil1 = dil_objs[obj1,:,:]\\n\\n # check if mask has been deleted\\n if np.sum(dil1) == 0:\\n continue\\n \\n objcounter = objcounter + 1\\n orig1 = objs[obj1,:,:]\\n\\n for obj2 in range(obj1+1,wsh.max()):\\n dil2 = dil_objs[obj2,:,:]\\n \\n # only check border if bounding box overlaps, and second mask \\n # is not yet deleted\\n if (do_box_overlap(obj_coords[obj1,:], obj_coords[obj2,:])\\n and np.sum(dil2) > 0):\\n \\n border = dil1 * dil2\\t\\n border_pred = pred[border]\\n \\n # Border is too small to be considered\\n if len(border_pred) < 32:\\n continue\\n \\n # Sum of top 25% of predicted border values\\n q75 = np.quantile(border_pred, .75)\\n top_border_pred = border_pred[border_pred >= q75]\\n top_border_height = top_border_pred.sum()\\n top_border_area = len(top_border_pred)\\n \\n # merge cells\\n if top_border_height / top_border_area > .99:\\n orig1 = np.logical_or(orig1, objs[obj2,:,:])\\n dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)\\n dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))\\n obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])\\n \\n wshclean = wshclean + orig1*objcounter\\n \\n return wshclean\",\n \"def propagateLabel(self, l1, l2):\\n\\n if l1 != l2:\\n winner = min(l1, l2)\\n loser = max(l1, l2)\\n loserN = 0\\n superiorN = 0\\n for i,l in enumerate(self.labels):\\n if l == loser:\\n loserN += 1\\n self.labels[i] = winner\\n if l > loser:\\n superiorN += 1\\n self.labels[i] = l - 1\\n\\n # print('Loser Label is ' + str(loser) + ' . With ' + str(loserN) + ' associated cells. Winner label is ' + str(winner))\",\n \"def BFTM_(adj_list,labels):\\n G_prime = nx.Graph()\\n num_clusters = list(np.unique(labels))\\n clusters = {i:[] for i in num_clusters}\\n hood = {n.id:[i for i in num_clusters if i != labels[n.id]] for n in adj_list}\\n \\n #Add nodes to clusters\\n for idx,n in enumerate(adj_list):\\n clusters[labels[idx]].append(n.id)\\n \\n root_cluster = random.choice(num_clusters)\\n root_id = random.choice(list(clusters[root_cluster]))\\n queue = [adj_list[root_id]]\\n clusters[labels[root_id]].remove(root_id)\\n \\n \\n #BFTM\\n while len(queue) > 0:\\n node = queue.pop(0)\\n for c_id in hood[node.id]:\\n if len(clusters[c_id]) > 0:\\n sample_id = random.choice(clusters[c_id])\\n clusters[labels[sample_id]].remove(sample_id)\\n queue.append(adj_list[sample_id])\\n hood[sample_id].remove(labels[node.id])\\n G_prime.add_edge(node,adj_list[sample_id])\\n hood[node.id] = None\\n #Handle leftover nodes\\n if len(queue) == 0:\\n remaining = [c for i,c in clusters.items() if len(c) > 0]\\n for rem_cluster in remaining:\\n for n in rem_cluster:\\n added = False\\n while not added:\\n rand_n = random.choice(list(G_prime.nodes))\\n if labels[rand_n.id] != labels[n.id]:\\n G_prime.add_edge(n,rand_n)\\n added = True\\n \\n \\n #Cliqify\\n for node in list(G_prime.nodes):\\n if G_prime.degree(node) < len(num_clusters) - 1:\\n for _1_hop in list(G_prime.neighbors(node)):\\n for _2_hop in list(G_prime.neighbors(_1_hop)):\\n if _2_hop != node and G_prime.degree(_2_hop) < len(num_clusters) - 1:\\n G_prime.add_edge(node,_2_hop)\\n \\n return G_prime\",\n \"def update_labels(mask1, mask2):\\n # Find the object in mask2 that has maximum overlap with an object in max1,\\n # (as a fraction of the objects pixels in mask1)\\n def get_max_overlap(mask1, mask2, label1):\\n # Count overlapping pixels.\\n labels, counts = np.unique(mask2[mask1 == label1], return_counts=True)\\n # Sort labels by counts (ascending).\\n labels_sorted = labels[np.argsort(counts)]\\n counts_sorted = counts[np.argsort(counts)]\\n # Select new label with maximum overlap.\\n max_overlap = labels_sorted[-1]\\n return max_overlap\\n \\n def main(mask1, mask2):\\n if not (mask1.shape == mask2.shape):\\n raise ValueError(\\\"Masks do not have the same shape.\\\")\\n # Initialize blank mask.\\n updated_mask = np.zeros(mask2.shape)\\n # Go one-by-one through the labels in mask2\\n for label in np.unique(mask2)[1:]:\\n # Find label in mask1 with maximum overlap with nuc from mask2.\\n mask1_besthit = get_max_overlap(mask2, mask1, label)\\n # Find reverse: best hit for the mask1 label in mask2.\\n mask2_besthit = get_max_overlap(mask1, mask2, mask1_besthit)\\n # If the labels are reciprocal best hits, update label in \\n # new mask to have the shape of the object in mask 2 with \\n # the label propagated from mask1.\\n if ((mask2_besthit == label) and (mask1_besthit != 0)):\\n updated_mask[mask2 == label] = mask1_besthit\\n\\n return updated_mask\\n return main(mask1, mask2)\",\n \"def swatershed(f, g, B=None, LINEREG=\\\"LINES\\\"):\\n\\n if B is None: B = secross()\\n print 'Not implemented yet'\\n return None\\n return y\",\n \"def flood_fill():\\n global CURRENT_LABEL\\n global mouse_pos\\n\\n im_mask = (source_msk==CURRENT_LABEL).astype(np.uint8)\\n cv.floodFill(im_mask, None, mouse_pos, CURRENT_LABEL)\\n source_msk[im_mask!=0] = CURRENT_LABEL\",\n \"def segment_func2(self):\\n # computing neighboors graph\\n A = self.boundaryprob_graph()\\n\\n # SpectralClustering segmentation\\n sc = SpectralClustering(3, affinity='precomputed', n_init=10, assign_labels='discretize')\\n labels = sc.fit_predict(A)\\n\\n return labels\",\n \"def compute_patch_loss(self, inputs, outputs, next_to_prev_weight = [1.0, 1.0]):\\n bsz, w, h, __ = inputs['input_image'].shape \\n\\n pred_next_image = outputs[\\\"next_position\\\"]\\n\\n path_state = inputs['path_state'].reshape(bsz, 1, w, h).float() \\n true_next_image = image_to_tiles(path_state, self.patch_size) \\n\\n # binarize patches\\n next_sum_image = torch.sum(true_next_image, dim = 2, keepdim=True) \\n next_patches = torch.zeros_like(next_sum_image)\\n # any patch that has a 1 pixel in it gets 1 \\n next_patches[next_sum_image != 0] = 1\\n\\n pred_next_image = pred_next_image.squeeze(-1)\\n next_patches = next_patches.squeeze(-1).to(self.device).long() \\n\\n pred_next_image = rearrange(pred_next_image, 'b n c -> b c n')\\n\\n next_pixel_loss = self.weighted_xent_loss_fxn(pred_next_image, next_patches) \\n\\n total_loss = next_pixel_loss \\n print(f\\\"loss {total_loss.item()}\\\")\\n\\n return total_loss\",\n \"def test_lcwa_label_smoothing(self):\\n # Create dummy dense labels\\n labels = torch.zeros(self.batch_size, self.num_entities)\\n for i in range(self.batch_size):\\n labels[i, self.random.randint(self.num_entities)] = 1.0\\n # Check if labels form a probability distribution\\n np.testing.assert_allclose(torch.sum(labels, dim=1).numpy(), 1.0)\\n\\n # Apply label smoothing\\n smooth_labels = apply_label_smoothing(labels=labels, epsilon=self.epsilon, num_classes=self.num_entities)\\n # Check if smooth labels form probability distribution\\n np.testing.assert_allclose(torch.sum(smooth_labels, dim=1).numpy(), 1.0, rtol=self.relative_tolerance)\",\n \"def pad_edges(self, pad):\\n weights=[]\\n for dim, xy in zip([0, 1], [self.x, self.y]):\\n xy0 = np.mean(xy)\\n W = xy[-1]-xy[0]\\n dist = np.abs(xy-xy0)\\n wt=np.ones_like(dist)\\n wt[ dist >= W/2 - pad] = 0\\n weights += [wt]\\n self.weight *= weights[0][:,None].dot(weights[1][None,:])\",\n \"def label_smooth_pcc(f):\\n n = f.shape[0]\\n labels = tf.eye(n)\\n labels = tf.reshape(labels,[-1,1])\\n labels = (1.0 - args.smoothing) * labels + args.smoothing / 2\\n pre_prob = tf.reshape(tf.sigmoid(f), [-1,1])\\n bce = tf.keras.losses.BinaryCrossentropy()\\n return -bce(labels, pre_prob)\",\n \"def b4Wan():\\n \\n tors, edges = tp.mesh_topo()\\n G = build_graph(edges)\\n \\n # Get the routing path of all nodes\\n table_file_name = '../outputs/mesh_routing_table.txt'\\n table = all_routing(G, tors, table_file_name)\\n if((os.path.isfile(table_file_name)) == False):\\n table = all_routing(G, tors, table_file_name)\\n else:\\n json_data = open(table_file_name).read()\\n table = json.loads(json_data)\\n \\n seeds, polys = cf.get_seeds_table(tors) #\\n\\n return G, tors, edges, table, seeds, polys\",\n \"def label_image(image):\\n \\n #Label the blobs using ndimage\\n labeled_blobs, n_features = ndimage.label(b_image)\\n \\n #calculate the center of mass of each labelled feature\\n centers = ndimage.center_of_mass(b_image, labeled_blobs, np.arange(n_features) + 1)\\n \\n return labeled_blobs, n_features, centers\",\n \"def label_smoothing_regularization(self, chars_labels, weight=0.1):\\n one_hot_labels = tf.one_hot(\\n chars_labels, depth=self.num_char_classes, axis=-1)\\n pos_weight = 1.0 - weight\\n neg_weight = weight / self.num_char_classes\\n return one_hot_labels * pos_weight + neg_weight\",\n \"def feature_dist(input_labels, struct=np.ones((3, 3))):\\n # remove the pixels inside the coherent\\n input_errosion = binary_erosion(input_labels, structure=struct)\\n input_labels[input_errosion] = 0\\n I, J = np.nonzero(input_labels)\\n labels = input_labels[I, J]\\n coords = np.column_stack((I, J))\\n sorter = np.argsort(labels)\\n labels = labels[sorter]\\n coords = coords[sorter]\\n I = I[sorter]\\n J = J[sorter]\\n sq_dists = cdist(coords, coords, 'sqeuclidean')\\n start_idx = np.flatnonzero(np.r_[1, np.diff(labels)])\\n nonzero_vs_feat = np.minimum.reduceat(sq_dists, start_idx, axis=1)\\n feat_vs_feat = np.minimum.reduceat(nonzero_vs_feat, start_idx, axis=0)\\n # calculate the distance between every two coherent areas\\n # distance factor for one pixel to meter: 100\\n distance_matrix = 100 * np.sqrt(feat_vs_feat)\\n nRow, nCol = sq_dists.shape[0], start_idx.shape[0]\\n # add the index of the final element to the slice array\\n slice_indices = np.concatenate((start_idx, np.array([nRow])))\\n col_args = np.zeros((nRow, nCol)).astype(int)\\n row_index = np.zeros((nCol, nCol)).astype(int)\\n '''\\n How the following commands work:\\n find closest pixel from label A to label B:\\n Label A --> Label B\\n row_index[A-1, B-1] = alpha\\n col_index[A-1, B-1] = col_args[alpha, B-1] = beta\\n index of pixel from Label A: input_labels[ I[alpha], J[alpha]]\\n index of pixel from Label B: input_labels[ I[beta], J[beta]]\\n '''\\n for i in range(nCol):\\n col_args[:, i] = start_idx[i] + \\\\\\n np.argmin(sq_dists[:, slice_indices[i]:\\n slice_indices[i+1]], axis=1)\\n elements = sq_dists[np.arange(nRow).reshape((nRow, 1)), col_args]\\n for i in range(nCol):\\n row_index[i, :] = start_idx[i] + \\\\\\n np.argmin(elements[slice_indices[i]:\\n slice_indices[i+1], :], axis=0)\\n col_index = col_args[row_index, np.arange(nCol).reshape((1, nCol))]\\n # Change col_index and row_index to input array index.\\n row_index_from_label = I[row_index]\\n col_index_from_label = J[row_index]\\n row_index_to_label = I[col_index]\\n col_index_to_label = J[col_index]\\n return distance_matrix, row_index_from_label, col_index_from_label, \\\\\\n row_index_to_label, col_index_to_label\",\n \"def bwdiagfill(bwimage):\\n # fills pixels matching the following neighborhoods:\\n hoods = [[[0, 1, 0],\\n [1, 0, 0],\\n [0, 0, 0]],\\n [[0, 0, 0],\\n [1, 0, 0],\\n [0, 1, 0]],\\n [[0, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0]],\\n [[0, 1, 0],\\n [0, 0, 1],\\n [0, 0, 0]]]\\n output = bwimage.copy()\\n # for each neighborhood, find matching pixels and set them to 1 in the img\\n for hood in hoods:\\n output = np.logical_or(output,\\n ndimage.binary_hit_or_miss(bwimage, hood))\\n return output\",\n \"def _get_bbox_regression_labels(bbox_target_data, num_classes, front_2_1_points_targets_data, front_2_2_points_targets_data, front_center_targets_data, back_2_1_points_targets_data, back_2_2_points_targets_data, back_center_targets_data, center_targets_data):\\n # Inputs are tensor\\n\\n clss = bbox_target_data[:, 0]\\n bbox_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\\n \\n front_2_1_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\\n front_2_2_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\\n front_center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\\n\\n back_2_1_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\\n back_2_2_points_targets = clss.new(clss.numel(), 4 * num_classes).zero_()\\n back_center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\\n\\n center_targets = clss.new(clss.numel(), 2 * num_classes).zero_()\\n\\n front_center_inside_weights = clss.new(front_center_targets.shape).zero_()\\n\\n bbox_inside_weights = clss.new(bbox_targets.shape).zero_()\\n \\n inds = (clss > 0).nonzero().view(-1)\\n if inds.numel() > 0:\\n clss = clss[inds].contiguous().view(-1,1)\\n\\n dim1_inds = inds.unsqueeze(1).expand(inds.size(0), 4)\\n dim2_inds = torch.cat([4*clss, 4*clss+1, 4*clss+2, 4*clss+3], 1).long()\\n # print(dim2_inds) # e.g. dim 16 * 4\\n\\n dim3_inds = inds.unsqueeze(1).expand(inds.size(0), 2)\\n dim4_inds = torch.cat([2*clss, 2*clss+1], 1).long()\\n\\n # fang[-1]\\n bbox_targets[dim1_inds, dim2_inds] = bbox_target_data[inds][:, 1:]\\n\\n front_2_1_points_targets[dim1_inds, dim2_inds] = front_2_1_points_targets_data[inds][:, 0:]\\n front_2_2_points_targets[dim1_inds, dim2_inds] = front_2_2_points_targets_data[inds][:, 0:]\\n front_center_targets[dim3_inds, dim4_inds] = front_center_targets_data[inds][:, 0:]\\n\\n back_2_1_points_targets[dim1_inds, dim2_inds] = back_2_1_points_targets_data[inds][:, 0:]\\n back_2_2_points_targets[dim1_inds, dim2_inds] = back_2_2_points_targets_data[inds][:, 0:]\\n back_center_targets[dim3_inds, dim4_inds] = back_center_targets_data[inds][:, 0:]\\n\\n center_targets[dim3_inds, dim4_inds] = center_targets_data[inds][:, 0:]\\n\\n bbox_inside_weights[dim1_inds, dim2_inds] = bbox_targets.new(cfg.TRAIN.BBOX_INSIDE_WEIGHTS).view(-1, 4).expand_as(dim1_inds)\\n\\n front_center_inside_weights[dim3_inds, dim4_inds] = front_center_targets.new(cfg.TRAIN.CENTER_INSIDE_WEIGHTS).view(-1, 2).expand_as(dim3_inds)\\n\\n return bbox_targets, bbox_inside_weights, front_2_1_points_targets, front_2_2_points_targets, front_center_targets, back_2_1_points_targets, \\\\\\n back_2_2_points_targets, back_center_targets, center_targets, front_center_inside_weights\",\n \"def slicing(features, seeds_features, seeds_label, label_map, adjacency,\\n sigma=1., resize_shape=(480, 854)):\\n label_map_flatten = np.reshape(label_map, [-1])\\n num_seeds = np.max(label_map)+1\\n # Label_map_one_hot [num_pixels, num_seeds_current]\\n label_map_one_hot = np.zeros((label_map_flatten.shape[0], num_seeds), dtype=np.int16)\\n label_map_one_hot[np.arange(label_map_flatten.shape[0]), label_map_flatten] = 1\\n # weight_idx: [num_pixels, num_seeds_cur_prev_following_frame]\\n # Only neighbouring seeds have weights > 0\\n weight_idx = np.matmul(label_map_one_hot, adjacency)\\n feature_dim = features.shape[2]\\n\\n # This implementation is not very efficient\\n # It computes pairwise distance between all pixels and all seeds (from 3 frames)\\n # dist: [num_pixels, num_seeds_cur_prev_following_frame]\\n dist = euclidean_distances(np.reshape(features, [-1, feature_dim]), seeds_features)\\n weight = np.exp(-dist*dist/sigma/sigma)\\n weight *= weight_idx\\n fg_votes = np.max(weight*np.expand_dims(seeds_label==1, 0), axis=1)\\n bg_votes = np.max(weight*np.expand_dims(seeds_label==0, 0), axis=1)\\n height = features.shape[0]\\n width = features.shape[1]\\n fg_votes = fg_votes.reshape((height, width))+1e-8\\n bg_votes = bg_votes.reshape((height, width))+1e-8\\n fg_votes = cv2.resize(fg_votes, (resize_shape[1], resize_shape[0]),\\n interpolation=cv2.INTER_LINEAR)\\n bg_votes = cv2.resize(bg_votes, (resize_shape[1], resize_shape[0]),\\n interpolation=cv2.INTER_LINEAR)\\n\\n prob = np.stack([bg_votes, fg_votes], axis=2)\\n dist_vis = utils.get_heatmap(np.concatenate([fg_votes, bg_votes], axis=0))\\n prob = prob/np.sum(prob, axis=2, keepdims=True)\\n\\n return prob, dist_vis\",\n \"def analyze_belief_strength_with_bias(self, G):\\r\\n n = []\\r\\n nbs_list = []\\r\\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\\r\\n n.append(node) #appends each node to a list that will be put into a dictionary\\r\\n pbs_list = []\\r\\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\\r\\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\\r\\n prob = G.nodes[node]['probability']\\r\\n for pre in G.predecessors(node):\\r\\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\\r\\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\\r\\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\\r\\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\\r\\n if len(pbs_list) == 0:\\r\\n nbs = og_bs\\r\\n nbs = int(nbs)\\r\\n else:\\r\\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\\r\\n if apbs*og_bs > 0:\\r\\n if apbs > 0:\\r\\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100)\\r\\n else:\\r\\n nbs = max(og_bs + (0.1*prob*unc*apbs), -100)\\r\\n nbs = int(nbs)\\r\\n else:\\r\\n nbs = og_bs\\r\\n nbs = int(nbs)\\r\\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\\r\\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\\r\\n print(change)\\r\\n return change #this will be used to update the list in a different function\\r\",\n \"def get_classification_simulator(self, image):\\n\\n r_channel = image[:,:,2]\\n g_channel = image[:,:,1]\\n\\n\\n\\n # Threshold color channel\\n s_rgy_min = 50\\n s_thresh_min = 245\\n s_thresh_max = 255\\n \\n #s_binary = np.zeros_like(r_channel)\\n r_binary = np.zeros_like(r_channel)\\n g_binary = np.zeros_like(r_channel)\\n y_binary = np.zeros_like(r_channel)\\n \\n #s_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) | ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\\n \\n \\n r_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & (g_channel <= s_rgy_min)] = 1\\n g_binary[((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max)) & (r_channel <= s_rgy_min)] = 1\\n y_binary[((r_channel >= s_thresh_min) & (r_channel <= s_thresh_max)) & ((g_channel >= s_thresh_min) & (g_channel <= s_thresh_max))] = 1\\n \\n\\n #res = cv2.bitwise_and(img,img,mask = s_binary)\\n \\n #maxx=image.shape[1]\\n maxy=image.shape[0]\\n \\n y_top=0\\n window_size_y=50\\n y_bottom=y_top+window_size_y\\n \\n max_color=0\\n tf_color=TrafficLight.UNKNOWN\\n \\n while (y_bottom< maxy):\\n #print(img[y_top:y_bottom,:,:])\\n rs= r_binary[y_top:y_bottom,:].sum()\\n gs= g_binary[y_top:y_bottom,:].sum()\\n ys= y_binary[y_top:y_bottom,:].sum()\\n if (rs>max_color):\\n max_color=rs\\n tf_color=TrafficLight.RED\\n if (gs>max_color):\\n max_color=gs\\n tf_color=TrafficLight.GREEN\\n if (ys>max_color):\\n max_color=ys\\n tf_color=TrafficLight.YELLOW\\n y_top+=window_size_y\\n y_bottom+=window_size_y\\n \\n if (max_color<100):\\n tf_color=TrafficLight.UNKNOWN\\n \\n\\n\\n return tf_color\",\n \"def watershed(image, markers=None, connectivity=1, offset=None, mask=None,\\n compactness=0, watershed_line=False):\\n from ..segmentation import watershed as _watershed\\n return _watershed(image, markers, connectivity, offset, mask,\\n compactness, watershed_line)\",\n \"def make_graph(imageAnnotated, imageGaussian):\\n nodeNumber = imageAnnotated.max() - 1\\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\\n imagePropagatedNodes = imageAnnotated.copy()\\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\\n dimensionY, dimensionX = imageAnnotated.shape\\n filament = (imagePropagatedNodes == 1).sum()\\n while (filament > 0):\\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\\n for posY, posX in nodePixel:\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\\n filament = (imagePropagatedNodes == 1).sum()\\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\\n for posY, posX in zip(filamentY, filamentX):\\n nodeIndex = imagePropagatedNodes[posY, posX]\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\\n for index, pixel in enumerate(filamentNeighborhood):\\n if (pixel != nodeIndex and pixel > 1):\\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\\n edgeConnectivity = 0\\n edgeJump = 0\\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\\n return(graph, nodePositions)\",\n \"def compute_sw_threshold(flanking_reads, paf_dict, fasta_dict, window_size):\\n\\n max_scores = []\\n for query, target in itertools.product(flanking_reads, flanking_reads):\\n\\n if str(query + target) in paf_dict:\\n overlap_info = paf_dict[query+target]\\n elif str(target + query) in paf_dict:\\n # get info and swap them\\n overlap_info = paf_dict[target+query]\\n query, target = target, query\\n else:\\n continue\\n\\n query_start = overlap_info['query_start']\\n query_end = overlap_info['query_end']\\n target_start = overlap_info['target_start']\\n target_end = overlap_info['target_end']\\n\\n query_seq = fasta_dict[query][query_start:query_end]\\n target_seq = fasta_dict[target][target_start:target_end]\\n\\n # Get scores for this pair; store in cur_scores\\n cur_scores = []\\n if window_size:\\n # Use rolling window\\n min_len = min(len(query_seq), len(target_seq))\\n for start, end in utils.pairwise(range(0, min_len, window_size)):\\n qs = query_seq[start:end]\\n ts = target_seq[start:end]\\n score = smith_waterman.smith_waterman(qs, ts)\\n cur_scores.append(score)\\n\\n if cur_scores:\\n score = max(cur_scores)\\n max_scores.append(score)\\n else:\\n # No rolling window\\n score = smith_waterman.smith_waterman(query_seq, target_seq)\\n max_scores.append(score)\\n\\n threshold = 0.9 * max(max_scores)\\n\\n print(\\\"using {} as threshold\\\".format(threshold))\\n\\n plt.subplot(2, 3, 2)\\n plt.hist(max_scores)\\n plt.title(\\\"FLANKING READS\\\\nhistogram of num_gaps / len(aligned_sequence)\\\\nthreshold = {}\\\\nwindow_size = {}\\\\nshowing {} scores\\\"\\n .format(threshold, window_size, len(max_scores)))\\n\\n\\n\\n return threshold\",\n \"def spread_labels(labels,maxdist=9999999):\\n #distances,features = morphology.distance_transform_edt(labels==0,return_distances=1,return_indices=1)\\n #indexes = features[0]*labels.shape[1]+features[1]\\n #spread = labels.ravel()[indexes.ravel()].reshape(*labels.shape)\\n if not labels.any():\\n return labels\\n distances,indexes = cv2.distanceTransformWithLabels(array(labels==0,uint8),cv2.DIST_L2,cv2.DIST_MASK_PRECISE,labelType=cv2.DIST_LABEL_PIXEL)\\n spread = labels[where(labels>0)][indexes-1]\\n if maxdist is None:\\n return spread, distances\\n spread *= (distances<maxdist)\\n return spread\",\n \"def heuristic(self):\\r\\n # 1.\\r\\n blacks, whites = 0, 0\\r\\n weights = [0 for _ in range(6)]\\r\\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\\r\\n user_dir = directions[:2] if self.current_player == 'n' else directions[2:]\\r\\n for i in range(8):\\r\\n for j in range(8):\\r\\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\\r\\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\\r\\n if self.matrix[i][j] == self.current_player or self.matrix[i][j] == self.current_player.upper():\\r\\n\\r\\n # numarul de piese rege\\r\\n if self.matrix[i][j] == self.current_player.upper():\\r\\n weights[1] += 7.75\\r\\n\\r\\n # numarul de piese normale\\r\\n else:\\r\\n weights[0] += 5\\r\\n\\r\\n # numarul de piese de pe baseline in functie de tipul de piesa\\r\\n # conform strategiilor de joc este o strategie buna sa ai cat mai multe\\r\\n # piesa pe baseline pentru a preveni creare de piese de tip rege ale adversarului\\r\\n if self.current_player in ['n', 'N']:\\r\\n if i == 7:\\r\\n weights[2] += 4\\r\\n elif self.current_player in ['a', 'A']:\\r\\n if i == 0:\\r\\n weights[2] += 4\\r\\n\\r\\n # numarul de piese din mijlocul tablei\\r\\n # la fel este o strategie buna pentru atac\\r\\n if 3 <= i <= 4 and 3 <= j <= 4:\\r\\n weights[3] += 2\\r\\n\\r\\n # numar piese vulnerabile\\r\\n # adica piese ce pot fi capturate de oponent la urmatoare tura\\r\\n for d in user_dir:\\r\\n\\r\\n vx = d[0] + i\\r\\n vy = d[1] + j\\r\\n back_x = i - d[0]\\r\\n back_y = j - d[1]\\r\\n next_x, next_y = vx + d[0], vy + d[1]\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\\r\\n weights[4] -= 3\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\\r\\n # daca elimin o piesa rege este o mutare mai buna\\r\\n if self.matrix[vx][vy] == self.opponent().upper():\\r\\n weights[5] += 10\\r\\n else:\\r\\n weights[5] += 7\\r\\n\\r\\n diff = (blacks - whites) if self.current_player == 'n' else (whites - blacks)\\r\\n # cand sunt mai putin piese, AI adopta o tactica mai ofensiva\\r\\n if blacks + whites <= 10:\\r\\n return sum(weights) + diff\\r\\n return sum(weights)\",\n \"def predict_boosting_example(x, h_ens):\\r\\n\\r\\n arr = []\\r\\n sum_alpha = 0\\r\\n\\r\\n for y in h_ens:\\r\\n # splitting hypothesis, weight pairs\\r\\n alpha, tree = h_ens[y]\\r\\n tst_pred = predict_example(x, tree)\\r\\n # appending prediction\\r\\n arr.append(tst_pred*alpha)\\r\\n sum_alpha += alpha\\r\\n predict_egz = np.sum(arr) / sum_alpha\\r\\n # weak learner\\r\\n if predict_egz >= 0.5:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def assignLabels(self):\\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\\n self.clusterV = self.volumes_sorted[clusters]\\n clusters = self.oldOrder[clusters] #indexes volumes\\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\\n self.easyLabel = np.zeros(len(self.data))\\n self.easyLabel[self.clusters] = 1\\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')\",\n \"def labelled_attachment(gold_trees, pred_trees):\\n count_match, count_total = 0, 0\\n for gold, pred in zip(gold_trees, pred_trees):\\n triples_pairs = zip(\\n gold.get_triples(include_root=True),\\n pred.get_triples(include_root=True),\\n )\\n for (g_src, g_trg, g_rel), (p_src, p_trg, p_rel) in triples_pairs:\\n assert g_src == p_src\\n count_total += 1\\n if g_trg == p_trg and g_rel == p_rel:\\n count_match += 1\\n if count_match == 0 or count_total == 0:\\n return 0.0\\n else:\\n return float(count_match) / count_total\",\n \"def cell(x, y):\\n try:\\n if cells[y][x]['filled'] == 1:\\n return # this has already been processed\\n except IndexError:\\n return\\n cells[y][x]['filled'] = 1 # this cell is now filled\\n\\n nn = []\\n for nx, ny in neighbours(x, y):\\n try:\\n if cells[ny][nx]['filled']:\\n nn.append(cells[ny][nx])\\n except IndexError:\\n continue\\n \\n c = 0 # colour weighting\\n \\n #------ Flippedness\\n flipped = sum([i['inverted'] for i in nn if i['inverted']])\\n cells[y][x]['inverted'] = (randint(0, 3) + flipped) % 4\\n \\n #------- Colour calculation\\n avg_colour = sum([i['colour'][0] for i in nn]) / len(nn)\\n avg_sat = sum([i['colour'][1] for i in nn]) / len(nn)\\n avg_bri = sum([i['colour'][2] for i in nn]) / len(nn)\\n \\n # small chance of going totally random otherwise small variation from neighbours\\n if random(100) > 90:\\n h = randint(0, 100)\\n s = randint(0, 100)\\n b = randint(0, 100)\\n else:\\n h = (avg_colour + randint(-15, 15)) % 100\\n s = (avg_sat + randint(-15, 15)) % 100\\n b = (avg_bri + randint(-15, 15)) % 100\\n cells[y][x]['colour'] = (h, s, b)\\n \\n #------- Alpha calculation\\n d = sqrt((x*cell_size - rx)**2 + (y*cell_size - ry)**2) # distance from epicenter\\n mx = sqrt((w-rx*cell_size)**2 + (h-ry*cell_size)**2)\\n a = d/sqrt(w**2+h**2)*255\\n cells[y][x]['alpha'] = a\\n \\n for cx,cy in neighbours(x, y):\\n cell(cx, cy)\",\n \"def clusterbatplacement(b, h, cluster, connectedhomes):\\n for batt in b:\\n b[batt].posx = cluster[batt][0]\\n b[batt].posy = cluster[batt][1]\\n for house in connectedhomes[batt]:\\n b[batt].connected.append(h[house])\",\n \"def count_blood_cells(image_path):\\n\\n # TODO - Prebrojati crvena i bela krvna zrnca i vratiti njihov broj kao povratnu vrednost ove procedure\\n \\\"\\\"\\\"\\n White cells\\n \\\"\\\"\\\"\\n # Getting image\\n white_cells_img = cv2.imread(image_path)\\n gray_img = cv2.cvtColor(white_cells_img, cv2.COLOR_BGR2GRAY)\\n\\n # Apply median filter for smoothing\\n smooth_img_white = cv2.medianBlur(gray_img, 5)\\n\\n # Morphological operations\\n kernel = np.ones((5, 5), np.uint8)\\n closing_img = cv2.morphologyEx(smooth_img_white, cv2.MORPH_CLOSE, kernel)\\n\\n # Adaptive threshold gaussian filter\\n threshold_img = cv2.adaptiveThreshold(closing_img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\\n cv2.THRESH_BINARY, 9, 2)\\n\\n # Segmentation of white cells\\n circles_a = cv2.HoughCircles(threshold_img, cv2.HOUGH_GRADIENT, 1.2, 105,\\n param1=50, param2=28, minRadius=2, maxRadius=28)\\n\\n # Getting count of white cells\\n cell_count_a = []\\n if circles_a is not None:\\n circles_a = np.round(circles_a[0, :]).astype(\\\"int\\\")\\n for (r) in circles_a:\\n cell_count_a.append(r)\\n # print(len(cell_count_a))\\n white_blood_cell_count = len(cell_count_a)\\n\\n \\\"\\\"\\\"\\n Red cells\\n \\\"\\\"\\\"\\n # Getting image\\n red_cells_img = cv2.imread(image_path)\\n\\n # Getting red color\\n red = [(150, 137, 168), (218, 209, 208)] # (lower), (upper)\\n colors = [red]\\n\\n # Apply median filter for smoothing\\n smooth_img_red = cv2.medianBlur(red_cells_img, 3)\\n\\n cell_count_b = 0\\n output = red_cells_img.copy()\\n for lower, upper in colors:\\n mask = cv2.inRange(smooth_img_red, lower, upper)\\n\\n # Segmentation of red cells\\n circles_b = cv2.HoughCircles(mask, cv2.HOUGH_GRADIENT, 1, 20, param1=15, param2=17,\\n minRadius=2, maxRadius=60)\\n\\n # Getting count of red cells\\n if circles_b is not None:\\n circles_b = np.round(circles_b[0, :]).astype(\\\"int\\\")\\n\\n for (x, y, r) in circles_b:\\n cv2.circle(output, (x, y), r, (255, 0, 255), 2)\\n cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (255, 0, 255), -1)\\n cell_count_b += 1\\n\\n # cv2.imwrite('output.png', output)\\n # print(cell_count_b)\\n red_blood_cell_count = cell_count_b\\n\\n # TODO - Odrediti da li na osnovu broja krvnih zrnaca pacijent ima leukemiju i vratiti True/False kao povratnu\\n # vrednost ove procedure\\n\\n if (white_blood_cell_count > 2\\n or\\n white_blood_cell_count >= (red_blood_cell_count / 3)):\\n has_leukemia = True\\n else:\\n has_leukemia = False\\n\\n return red_blood_cell_count, white_blood_cell_count, has_leukemia\",\n \"def fill_holes(img):\\n neg = 1 - img\\n s = ndimage.generate_binary_structure(3,1) # iterate structure\\n labeled_array, numpatches = ndimage.label(neg,s) # labeling\\n sizes = ndimage.sum(neg,labeled_array,range(1,numpatches+1)) \\n sizes_list = [sizes[i] for i in range(len(sizes))]\\n sizes_list.sort()\\n max_size = sizes_list[-1]\\n max_label = np.where(sizes == max_size)[0] + 1\\n component = labeled_array == max_label\\n return 1 - component\",\n \"def get_hardwired_speed_weights(self):\\n \\n phase_shift=self.speed_phase_shift\\n \\n # row 1 has the weights of speed cells to grid cell 1\\n self.W_speed_east=np.zeros_like(self.W_ee) \\n self.W_speed_west=np.zeros_like(self.W_ee) \\n self.W_speed_north=np.zeros_like(self.W_ee) \\n self.W_speed_south=np.zeros_like(self.W_ee) \\n\\n if self.use_eight_directions is True:\\n self.W_speed_north_east=np.zeros_like(self.W_ee) \\n self.W_speed_north_west=np.zeros_like(self.W_ee) \\n self.W_speed_south_east=np.zeros_like(self.W_ee) \\n self.W_speed_south_west=np.zeros_like(self.W_ee) \\n\\n\\n for phase_idx,phase in enumerate(self.gp.phases):\\n shifted_north_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi/2.),self.gp.phases)\\n shifted_south_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi/2.),self.gp.phases)\\n shifted_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(0),self.gp.phases)\\n shifted_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi),self.gp.phases)\\n\\n self.W_speed_north[phase_idx,:]=self.W_ee[shifted_north_phase_idx,:]\\n self.W_speed_south[phase_idx,:]=self.W_ee[shifted_south_phase_idx,:]\\n self.W_speed_east[phase_idx,:]=self.W_ee[shifted_east_phase_idx,:]\\n self.W_speed_west[phase_idx,:]=self.W_ee[shifted_west_phase_idx,:] \\n \\n if self.use_eight_directions is True:\\n shifted_north_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi/4),self.gp.phases)\\n shifted_north_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(np.pi*3/4),self.gp.phases)\\n shifted_south_east_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi/4),self.gp.phases)\\n shifted_south_west_phase_idx=gl.get_pos_idx(phase+phase_shift*dir_vect(-np.pi*3/4),self.gp.phases)\\n \\n self.W_speed_north_east[phase_idx,:]=self.W_ee[shifted_north_east_phase_idx,:]\\n self.W_speed_north_west[phase_idx,:]=self.W_ee[shifted_north_west_phase_idx,:]\\n self.W_speed_south_east[phase_idx,:]=self.W_ee[shifted_south_east_phase_idx,:]\\n self.W_speed_south_west[phase_idx,:]=self.W_ee[shifted_south_west_phase_idx,:]\",\n \"def weights_walls(pc, boundary_indx, n_action, n_neurons):\\n # find index on a 40 point circle \\n boundary_cells = pc[boundary_indx, :]\\n angles = (np.arctan2(boundary_cells[:, 0], boundary_cells[:, 1]) + 2*np.pi) % (2*np.pi)\\n \\n # find index of boundary cell (in a ring of 40 action neurons)\\n thetas = theta_action(n_action)\\n diff = np.abs(angles[:, np.newaxis] - thetas[np.newaxis, :])\\n indx = np.argmin(diff, axis=1) # the closest match\\n\\n w_walls = np.ones((n_action, n_neurons))\\n \\n for ii in np.arange(len(boundary_indx)):\\n cell_ind = boundary_indx[ii]\\n \\n d = collections.deque(np.arange(n_action))\\n w_walls[:, cell_ind] = 0 # first set all weights to 0\\n d.rotate(n_action-(indx[ii]+ 13)) # 1st permitted action is 13 segments away\\n actions_ind = list(itertools.islice(d, 0, 14))\\n w_walls[actions_ind, cell_ind] = 1\\n \\n return w_walls\",\n \"def learn_with_bootstrapping(self, sample_count=10000):\\n tic = time.clock()\\n training_set_size = 150 # TODO: change to 1000, 500 or something\\n sample_pool = self.training_stream.extract_training_patches(sample_count, negative_ratio=1.)\\n # initialize weights\\n weighted_patches = []\\n for patch in sample_pool: # weight all patches: training pool P\\n weighted_patches.append([patch, 1. / len(sample_pool)])\\n # if patch.label == +1:\\n # pos_patch = patch # PRESENTATION, REPORT\\n # shuffle training pool\\n weighted_patches = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\\n\\n if self.algorithm == 'adaboost': # Shuffle the training data\\n training_data = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\\n elif self.algorithm == 'wald': # Sample training_set_size samples\\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\\n\\n for t in range(self.layers): # choose the weak classifier with the minimum error\\n print \\\"Learn with bootstrapping using %s, layer #%d\\\" % (self.algorithm.title(), t+1)\\n\\n if self.algorithm == 'adaboost':\\n h_t = self._fetch_best_weak_classifier(weighted_patches)\\n elif self.algorithm == 'wald':\\n h_t = self._fetch_best_weak_classifier(training_data)\\n # h_t.visualize(pos_patch) # PRESENTATION, REPORT\\n self.classifiers.append(copy.deepcopy(h_t)) # add it to the strong classifier\\n\\n if self.algorithm == 'adaboost':\\n self.classifiers[-1].update_alpha(weighted_patches)\\n weighted_patches = self._adaboost_reweight(weighted_patches, t)\\n elif self.algorithm == 'wald':\\n kde_n, kde_p, xs_n, xs_p = self._estimate_ratios(training_data, t)\\n # find decision thresholds for the strong classifier\\n self._tune_thresholds(kde_n, kde_p, xs_n, xs_p, t)\\n # throw away training samples that fall in our thresholds\\n weighted_patches = self._reweight_and_discard_irrelevant(weighted_patches, t)\\n # sample new training data\\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\\n if len(training_data) == 0:\\n print \\\"no more training data!\\\"\\n break\\n toc = time.clock()\\n print toc - tic\\n print self\",\n \"def train_label_weigthed(self, train_dataset, validation_dataset, label, lr = 0.02, epochs_num = 100, batch_size = 40, alpha = 0, momentum = 0.9):\\n \\n def get_proportions(dataset):\\n \\n positive_label = dataset.labels_tensor[:,label].sum()\\n \\n negative_label = (1 - dataset.labels_tensor[:,label]).sum()\\n \\n total_examples = positive_label + negative_label\\n \\n imbalance = abs(positive_label - 0.5) > 0.4\\n \\n if imbalance:\\n \\n if positive_label < negative_label:\\n \\n w_p = 1\\n \\n w_n = positive_label / negative_label\\n \\n else:\\n \\n w_p = negative_label / positive_label\\n \\n w_n = 1\\n \\n else:\\n \\n w_p = w_n = 1\\n \\n return w_p, w_n\\n \\n def get_w(labels, w_p, w_n):\\n \\n positives = labels\\n \\n negatives = 1 - labels\\n \\n w = w_p * positives + w_n * negatives\\n \\n return w\\n \\n# positive_label = train_dataset.labels_tensor[:,label].sum()\\n \\n# negative_label = (1 - train_dataset.labels_tensor[:,label]).sum()\\n \\n# total_examples = positive_label + negative_label\\n \\n# print('num examples {}'.format(positive_label + negative_label))\\n \\n# print('% positive labels: {}'.format(positive_label/total_examples))\\n \\n# print('% negative labels: {}'.format(negative_label/total_examples))\\n \\n# imbalance = abs(positive_label - 0.5) > 0.4\\n \\n# if imbalance:\\n \\n# if positive_label < negative_label:\\n \\n# w_p = 1\\n \\n# w_n = positive_label / negative_label\\n \\n# else:\\n \\n# w_p = negative_label / positive_label\\n \\n# w_n = 1\\n \\n# else:\\n \\n# w_p = w_n = 1\\n \\n# print('w_p: {}'.format(w_p))\\n \\n# print('w_n: {}'.format(w_n))\\n\\n w_p, w_n = get_proportions(train_dataset) \\n \\n label_name = train_dataset.labels.items()[label][0]\\n \\n print(\\\"Training label {} ... \\\".format(label_name))\\n \\n optimizer = SGD(self.parameters(), lr = lr, weight_decay = alpha, momentum = momentum)\\n\\n train_losses = []\\n\\n validation_losses = []\\n\\n epochs = []\\n\\n start = time.time()\\n\\n remaining_time = 0\\n\\n train_dataloader = DataLoader(train_dataset, batch_size = batch_size, collate_fn = PPD.collate_data)\\n \\n validation_segments, validation_labels = PPD.collate_data(validation_dataset)\\n \\n weight_matrix_v = get_w(validation_labels[:,label].unsqueeze(1), w_p, w_n)\\n \\n criterion_v = nn.BCELoss(weight=weight_matrix_v.float())\\n \\n print('w_p: {} and w_n: {}'.format(w_p, w_n))\\n\\n for epoch in range(epochs_num):\\n\\n for i_batch, sample_batched in enumerate(train_dataloader):\\n\\n input = sample_batched[0]\\n\\n target = sample_batched[1][:,label].unsqueeze(1)\\n \\n weight_matrix = w_p * target + w_n * (1 - target)\\n \\n criterion = nn.BCELoss(weight=weight_matrix.float())\\n\\n self.zero_grad()\\n\\n output = self(input)\\n\\n train_loss = criterion(output, target.float())\\n\\n train_loss.backward()\\n\\n optimizer.step()\\n\\n validation_loss = criterion_v(self(validation_segments.long()), validation_labels[:,label].unsqueeze(1).float())\\n\\n end = time.time()\\n\\n remaining_time = remaining_time * 0.90 + ((end - start) * (epochs_num - epoch + 1) / (epoch + 1)) * 0.1\\n\\n remaining_time_corrected = remaining_time / (1 - (0.9 ** (epoch + 1)))\\n\\n epoch_str = \\\"last epoch finished: \\\" + str(epoch)\\n\\n progress_str = \\\"progress: \\\" + str((epoch + 1) * 100 / epochs_num) + \\\"%\\\"\\n\\n time_str = \\\"time: \\\" + str(remaining_time_corrected / 60) + \\\" mins\\\"\\n\\n sys.stdout.write(\\\"\\\\r\\\" + epoch_str + \\\" -- \\\" + progress_str + \\\" -- \\\" + time_str)\\n\\n sys.stdout.flush()\\n\\n train_losses.append(train_loss.item())\\n\\n validation_losses.append(validation_loss.item())\\n\\n epochs.append(epoch)\\n\\n print(\\\"\\\\n\\\" + \\\"Training completed. Total training time: \\\" + str(round((end - start) / 60, 2)) + \\\" mins\\\")\\n\\n return epochs, train_losses, validation_losses\",\n \"def joint_bilateral(filename,flash_image,noflash_image,sigma_spatial,sigma_intensity):\\n\\t# make a simple Gaussian function taking the squared radius\\n\\tgaussian = lambda r2, sigma: np.exp(-0.5*r2/sigma**2)\\n\\tflash_image = cv2.cvtColor(flash_image,cv2.COLOR_BGR2RGB)\\n\\tnoflash_image = cv2.cvtColor(noflash_image,cv2.COLOR_BGR2RGB)\\n\\n\\t# define the window width to be the 2 time the spatial std. dev. to\\n\\t# be sure that most of the spatial kernel is actually captured\\n\\twin_width = int(3*sigma_spatial +1)\\n\\twgt_sum = np.zeros_like(flash_image).astype(np.float64)\\n\\tresult = np.zeros_like(flash_image).astype(np.float64)\\n\\tout= np.zeros_like(flash_image).astype(np.float64)\\n\\t\\n\\t\\n\\tfor i in tqdm(range(flash_image.shape[-1]),desc=\\\"Going through color channels\\\"):\\n\\t\\tnorm_flash_image = normalize(flash_image[:,:,i])\\n\\t\\tnorm_noflash_image = normalize(noflash_image[:,:,i])\\n\\t\\tfor shft_x in range(-win_width,win_width+1):\\n\\t\\t\\tfor shft_y in range(-win_width,win_width+1):\\n\\t\\t\\t\\t# compute the spatial contribution\\n\\t\\t\\t\\tspatial = gaussian(shft_x**2+shft_y**2, sigma_spatial )\\n\\t\\n\\t\\t\\t\\t# shift by the offsets to get image window\\n\\t\\t\\t\\twindow = np.roll(norm_flash_image, [shft_y, shft_x], axis=[0,1])\\n\\t\\t\\t\\twindow1 = np.roll(norm_noflash_image, [shft_y, shft_x], axis=[0,1])\\n\\t\\t\\t\\t# compute the intensity contribution\\n\\t\\t\\t\\tcombined_filter = spatial*gaussian((window-norm_flash_image)**2, sigma_intensity )\\n\\t\\n\\t\\t\\t\\t# result stores the mult. between combined filter and image window\\n\\t\\t\\t\\tresult[:,:,i] += window1*combined_filter\\n\\t\\t\\t\\twgt_sum[:,:,i] += combined_filter\\n\\tout = normalize(result/wgt_sum)\\n\\t# normalize the result and return\\n\\tplt.imsave(\\\"outputImages/JointBilateral_\\\"+filename+\\\"_\\\"+str(sigma_spatial)+\\\"_\\\"+ str(sigma_intensity) + \\\".png\\\" ,out,dpi=600)\\n\\treturn out\",\n \"def create_labelled_dataset(self):\\n\\n print(\\\"-------------------------------------------------------------------\\\")\\n print(\\\" How to Use the Pole Hull Label Tool\\\")\\n print(\\\"-------------------------------------------------------------------\\\")\\n print(\\\"- If a hull is NOT associated to a pole: press the 1 button\\\")\\n print(\\\"- If a hull IS associated to a pole: press the 2 button\\\")\\n print(\\\"\\\\n- If any other key is pressed, the program EXITS\\\")\\n print(\\\"-------------------------------------------------------------------\\\")\\n\\n detector = gate_detector.GateDetector(im_resize=3.0/4)\\n\\n imgs = []\\n labels = []\\n directory = os.path.dirname(os.getcwd())\\n \\n # Get absolute path of all images in the images folder\\n for dirpath,_,filenames in os.walk(os.path.join(directory, 'images', 'gate')):\\n for f in filenames:\\n imgs.append(os.path.abspath(os.path.join(dirpath, f)))\\n\\n # Get the hulls from the segmented image and run the display and label program for each image\\n for img in imgs:\\n src = cv.imread(img, 1)\\n pre = detector.preprocess(src)\\n seg = detector.segment(pre)\\n mor = detector.morphological(seg)\\n hulls = detector.create_convex_hulls(seg)\\n labels += self.display_and_label_hulls(hulls, pre)\\n return labels\",\n \"def worker(i):\\n res_read = read_dicom(os.path.join(DIR, fnames[i]))\\n if res_read is None:\\n print(\\\"failed on {0}, {1}\\\".format(i, fnames[i]))\\n return ' '.join(map(str,[fnames[i]] + [-1]*4 +[-1]*4))\\n\\n img, spacing = res_read\\n R, C = img.shape\\n split_point = C/2\\n\\n right_l = img[:,:split_point]\\n left_l = img[:,split_point:]\\n\\n prop = get_joint_y_proposals(right_l)\\n\\n # We will store the coordinates of the top left and the bottom right corners of the bounding box\\n hog = cv2.HOGDescriptor(winSize,blockSize,blockStride,cellSize,nbins)\\n\\n\\n # Making proposals for the right leg\\n R, C = right_l.shape\\n displacements = range(-C//4,1*C//4+1,step)\\n best_score = -999999999\\n sizepx = int(sizemm/spacing) # Proposal size\\n\\n for y_coord in prop:\\n for x_displ in displacements:\\n for scale in scales:\\n if C/2+x_displ-R/scale/2 >= 0:\\n # Candidate ROI\\n roi = np.array([C/2+x_displ-R/scale/2, y_coord-R/scale/2, R/scale, R/scale]).astype(int)\\n x1, y1 = roi[0], roi[1]\\n x2, y2 = roi[0]+roi[2], roi[1]+roi[3]\\n patch = cv2.resize(img[y1:y2,x1:x2],(64, 64))\\n\\n hog_descr = hog.compute(patch,winStride,padding)\\n score = np.inner(w,hog_descr.ravel())+b\\n\\n if score > best_score:\\n jc = np.array([C/2+x_displ, y_coord])\\n best_score = score\\n\\n\\n roi_R = np.array([jc[0]-sizepx//2, jc[1]-sizepx//2, jc[0]+sizepx//2, jc[1]+sizepx//2])\\n # Making proposals for the left leg\\n R, C = left_l.shape\\n displacements = range(-C//4,1*C//4+1,step)\\n prop = get_joint_y_proposals(left_l)\\n best_score = -999999999\\n for y_coord in prop:\\n for x_displ in displacements:\\n for scale in scales:\\n if split_point+x_displ+R/scale/2 < img.shape[1]:\\n roi = np.array([split_point+C/2+x_displ-R/scale/2, y_coord-R/scale/2, R/scale, R/scale]).astype(int)\\n\\n x1, y1 = roi[0], roi[1]\\n x2, y2 = roi[0]+roi[2], roi[1]+roi[3]\\n patch = np.fliplr(cv2.resize(img[y1:y2,x1:x2],(64, 64)))\\n\\n hog_descr = hog.compute(patch,winStride,padding)\\n score = np.inner(w,hog_descr.ravel())+b\\n\\n if score > best_score:\\n jc = np.array([split_point+C/2+x_displ, y_coord])\\n best_score = score\\n\\n roi_L = np.array([jc[0]-sizepx//2, jc[1]-sizepx//2, jc[0]+sizepx//2, jc[1]+sizepx//2])\\n\\n print(\\\"Done with {}, {}\\\".format(i, fnames[i]))\\n return ' '.join(map(str,[fnames[i]] + np.round(roi_L).astype(int).tolist() + np.round(roi_R).astype(int).tolist()))\",\n \"def kmerNeighbors(text,k):\\r\\n L=set()\\r\\n for i in range(0,len(text)-k+1):\\r\\n for d in range(0,k+1):\\r\\n L.update(Neighbors(kmer(text,i,k),d))\\r\\n D=dict()\\r\\n for l in L:\\r\\n D[l]=minHamm(text,l)\\r\\n return D\",\n \"def compute_gradient_saliency_maps(samples: torch.tensor,\\n true_labels: torch.tensor,\\n model: nn.Module):\\n \\\"\\\"\\\"INSERT YOUR CODE HERE, overrun return.\\\"\\\"\\\"\\n return torch.rand(6, 256, 256)\",\n \"def do_a_propagation(self):\\n random.seed(self.seeding)\\n random.shuffle(self.nodes)\\n for node in tqdm(self.nodes):\\n neighbors = nx.neighbors(self.graph, node)\\n pick = self.make_a_pick(node, neighbors)\\n self.labels[node] = pick\\n current_label_count = len(set(self.labels.values()))\\n if self.label_count == current_label_count:\\n self.flag = False\\n else:\\n self.label_count = current_label_count\",\n \"def findHighWeightFeatures(self, label):\\n featuresWeights = []\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n return featuresWeights\",\n \"def get_action(self, state):\\n\\n \\\"\\\"\\\"\\n XXX: DO NOT MODIFY THAT FUNCTION !!!\\n Doing so will result in a 0 grade.\\n \\\"\\\"\\\"\\n\\n # XXX : You shouldn't care on what is going on below.\\n # Variables are specified in constructor.\\n if self.beliefGhostStates is None:\\n self.beliefGhostStates = state.getGhostBeliefStates()\\n if self.walls is None:\\n self.walls = state.getWalls()\\n\\n # @TODO Put this back to normal\\n ret = self.updateAndGetBeliefStates(\\n self._computeNoisyPositions(state))\\n\\n if self.i < 25:\\n debug = ret[0]\\n self.l.append(np.max(debug))\\n self.i += 1\\n #if debug == 1: # To Stop as soon as convergence happens\\n #self.i = 25\\n\\n prefix = 'data/' # To indicate path\\n\\n if self.i == 25:\\n\\n if os.path.exists(os.path.join(prefix, str(self.w) + \\\"-\\\" + str(self.p) + \\\".txt\\\")):\\n os.remove(os.path.join(prefix, str(self.w) + \\\"-\\\" + str(self.p) + \\\".txt\\\"))\\n\\n f = open(os.path.join(prefix, str(self.w) + \\\"-\\\" + str(self.p) + \\\".txt\\\"), \\\"a\\\")\\n first = True\\n for data in self.l:\\n if first:\\n first = False\\n f.write(str(data))\\n else:\\n f.write(\\\",\\\" + str(data))\\n self.i += 1\\n f.close()\\n print(\\\"Done\\\")\\n plt.plot(range(1, len(self.l)+1), self.l)\\n plt.xlabel('Time step')\\n plt.ylabel('Maximum probability')\\n plt.title('Bayes Filter')\\n plt.axis([0, self.i, 0, 1])\\n plt.savefig(os.path.join(prefix, str(self.w) + \\\"-\\\" + str(self.p) + \\\".pdf\\\"), bbox_inches='tight')\\n plt.show()\\n\\n return ret\",\n \"def build_labels():\\n l_title = GLabel('Which one is Karel?')\\n l_title.font = 'Courier-25'\\n l_title.color = 'black'\\n window.add(l_title, x=260, y=60)\\n l_num = GLabel('19')\\n l_num.font = 'Courier-50'\\n l_num.color = 'whitesmoke'\\n window.add(l_num, x=37, y=242)\\n l_skip = GLabel('skip')\\n l_skip.font = 'Courier-20'\\n l_skip.color = 'whitesmoke'\\n window.add(l_skip, x=726, y=152)\\n l_ans1 = GLabel('Answers')\\n l_ans1.font = 'Courier-20-italic'\\n l_ans1.color = 'black'\\n window.add(l_ans1, x=698, y=270)\\n l_ans2 = GLabel('0')\\n l_ans2.font = 'Courier-50-italic'\\n l_ans2.color = 'black'\\n window.add(l_ans2, x=722, y=252)\\n l_game_pin = GLabel('Game PIN: SC101')\\n l_game_pin.font = 'Courier-20'\\n l_game_pin.color = 'black'\\n window.add(l_game_pin, x=20, y=540)\\n l_1 = GPolygon()\\n l_1.add_vertex((210, 360))\\n l_1.add_vertex((197, 380))\\n l_1.add_vertex((221, 380))\\n l_1.filled = True\\n l_1.color = 'whitesmoke'\\n l_1.fill_color= 'whitesmoke'\\n window.add(l_1)\\n l_2_1 = GPolygon()\\n l_2_1.add_vertex((210+380, 359))\\n l_2_1.add_vertex((198+380, 370))\\n l_2_1.add_vertex((221+380, 370))\\n l_2_1.filled = True\\n l_2_1.fill_color = 'whitesmoke'\\n l_2_1.color = 'whitesmoke'\\n window.add(l_2_1)\\n l_2_2 = GPolygon()\\n l_2_2.add_vertex((210+380, 381))\\n l_2_2.add_vertex((198+380, 370))\\n l_2_2.add_vertex((221+380, 370))\\n l_2_2.filled = True\\n l_2_2.fill_color = 'whitesmoke'\\n l_2_2.color = 'whitesmoke'\\n window.add(l_2_2)\\n l_3 = GOval(23, 23, x=198, y=450)\\n l_3.filled = True\\n l_3.fill_color = 'whitesmoke'\\n l_3.color = 'whitesmoke'\\n window.add(l_3)\\n l_4 = GRect(20, 20, x=583, y=450)\\n l_4.filled = True\\n l_4.fill_color = 'whitesmoke'\\n l_4.color = 'whitesmoke'\\n window.add(l_4)\",\n \"def neighbors(pattern, d):\\n\\n if d == 0:\\n return [pattern]\\n if len(pattern) == 1:\\n return ['A', 'C', 'G', 'T']\\n neighborhood = []\\n suffix_pattern = pattern[1:]\\n suffix_neighbors = neighbors(suffix_pattern, d)\\n for text in suffix_neighbors:\\n hdist = compute_hamming_distance(suffix_pattern, text)\\n if hdist < d:\\n for n in ['A', 'C', 'G', 'T']:\\n neighbor = n + text\\n neighborhood.append(neighbor)\\n else:\\n neighbor = pattern[0] + text\\n neighborhood.append(neighbor)\\n return neighborhood\",\n \"def agglo_from_labelmask(\\n h5path_in,\\n h5path_lv='',\\n ratio_threshold=0,\\n h5path_out='',\\n save_steps=False,\\n protective=False,\\n ):\\n\\n # check output paths\\n outpaths = {'out': h5path_out}\\n status = utils.output_check(outpaths, save_steps, protective)\\n if status == \\\"CANCELLED\\\":\\n return\\n\\n # open data for reading\\n h5file_in, ds_in, elsize, axlab = utils.h5_load(h5path_in)\\n h5file_lv, ds_lv, _, _ = utils.h5_load(h5path_lv)\\n\\n # open data for writing\\n h5file_out, ds_out = utils.h5_write(None, ds_in.shape, ds_in.dtype,\\n h5path_out,\\n element_size_um=elsize,\\n axislabels=axlab)\\n\\n ulabels = np.unique(ds_in)\\n maxlabel = np.amax(ulabels)\\n print(\\\"number of labels in watershed: {:d}\\\".format(maxlabel))\\n\\n fwmap = np.zeros(maxlabel + 1, dtype='i')\\n\\n areas_ws = np.bincount(ds_in.ravel())\\n\\n labelsets = {}\\n rp_lw = regionprops(ds_lv, ds_in)\\n for prop in rp_lw:\\n\\n maskedregion = prop.intensity_image[prop.image]\\n counts = np.bincount(maskedregion)\\n svoxs_in_label = [l for sl in np.argwhere(counts) for l in sl]\\n\\n ratios_svox_in_label = [float(counts[svox]) / float(areas_ws[svox])\\n for svox in svoxs_in_label]\\n fwmask = np.greater(ratios_svox_in_label, ratio_threshold)\\n labelset = np.array(svoxs_in_label)[fwmask]\\n labelsets[prop.label] = set(labelset) - set([0])\\n\\n basepath = h5path_in.split('.h5/')[0]\\n utils.write_labelsets(labelsets, basepath + \\\"_svoxsets\\\",\\n filetypes=['pickle'])\\n\\n ds_out[:] = utils.forward_map(np.array(fwmap), ds_in, labelsets)\\n\\n # close and return\\n h5file_in.close()\\n h5file_lv.close()\\n try:\\n h5file_out.close()\\n except (ValueError, AttributeError):\\n return ds_out\",\n \"def binarize(img, s_thres=(170, 255), l_thres=(50, 255), sobel_thres=(30, 80)):\\n hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)\\n\\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\\n hls[:, :, 1] = clahe.apply(hls[:, :, 1])\\n\\n l_image = hls[:, :, 1]\\n l_blur = cv2.GaussianBlur(l_image, (0, 0), 9)\\n l_image = cv2.addWeighted(l_image, 1, l_blur, -1, 0)\\n l_image = cv2.normalize(l_image, np.zeros_like(l_image), 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1)\\n l_binary = np.zeros_like(l_image)\\n l_binary[(l_image >= l_thres[0]) & (l_image <= l_thres[1])] = 1\\n\\n # Sobel x\\n # gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n # gray = hls[:, :, 1]\\n # sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0) # Take the derivative in x\\n # abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal\\n # scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))\\n # sxbinary = np.zeros_like(scaled_sobel)\\n # sxbinary[(scaled_sobel >= sobel_thres[0]) & (scaled_sobel <= sobel_thres[1])] = 1\\n # sxbinary = s_binary\\n\\n s_channel = hls[:, :, 2]\\n s_channel = cv2.normalize(s_channel, np.zeros_like(s_channel), 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1)\\n s_binary = np.zeros_like(s_channel)\\n s_binary[(s_channel >= s_thres[0]) & (s_channel <= s_thres[1])] = 1\\n\\n # Combine the two binary thresholds\\n combined_binary = np.zeros_like(s_binary)\\n combined_binary[(s_binary == 1) | (l_binary == 1)] = 1\\n\\n # we filter out the lines with too many active pixels\\n combined_binary_rows = combined_binary.sum(1)\\n combined_binary[combined_binary_rows > (combined_binary.shape[1] / 2)] = 0\\n\\n return combined_binary\",\n \"def calc_w_inference(g1, inf_g1, g2, inf_g2, consider_label):\\n edges_g1 = np.count_nonzero(g1)\\n edges_g2 = np.count_nonzero(g2)\\n\\n overlap_r1 = 0\\n overlap_r2 = 0\\n n_nodes = len(g1)\\n for i in range(n_nodes):\\n for j in range(n_nodes):\\n if consider_label:\\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL) and (g1[i][j] == inf_g2[i][j]):\\n overlap_r1 += 1 # how much g1 recalls \\\"populated\\\"-g2\\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL) and (inf_g1[i][j] == g2[i][j]):\\n overlap_r2 += 1 # how much g2 recalls \\\"populated\\\"-g2\\n else:\\n if (g1[i][j] != NO_REL_SYMBOL and inf_g2[i][j]!= NO_REL_SYMBOL):\\n overlap_r1 += 1\\n if (inf_g1[i][j] != NO_REL_SYMBOL and g2[i][j]!= NO_REL_SYMBOL):\\n overlap_r2 += 1\\n\\n r1 = float(overlap_r1) / float(edges_g1)\\n r2 = float(overlap_r2) / float(edges_g2)\\n return (r1 + r2) / float(2)\",\n \"def prefix_beam_search(ctc, labels, blank_index=0, lm=None,k=5,alpha=0.3,beta=5,prune=0.001,end_char='>',return_weights=False):\\n assert (ctc.shape[1] == len(labels)), \\\"ctc size:%d, labels: %d\\\" % (ctc.shape[1], len(labels))\\n assert ctc.shape[0] > 1, \\\"ctc length: %d was too short\\\" % ctc.shape[0]\\n assert (ctc >= 0).all(), 'ctc output contains negative numbers'\\n lm = (lambda l: 1) if lm is None else lm # if no LM is provided, just set to function returning 1\\n word_count_re = re.compile(r'\\\\w+[\\\\s|>]')\\n W = lambda l: word_count_re.findall(l)\\n F = ctc.shape[1]\\n \\n ctc = np.vstack((np.zeros(F), ctc)) # just add an imaginative zero'th step (will make indexing more intuitive)\\n T = ctc.shape[0]\\n blank_char = labels[blank_index]\\n\\n # STEP 1: Initiliazation\\n O = ''\\n Pb, Pnb = defaultdict(Counter), defaultdict(Counter)\\n Pb[0][O] = 1\\n Pnb[0][O] = 0\\n A_prev = [O]\\n # END: STEP 1\\n\\n # STEP 2: Iterations and pruning\\n for t in range(1, T):\\n pruned_alphabet = [labels[i] for i in np.where(ctc[t] > prune)[0]]\\n for l in A_prev:\\n \\n if len(l) > 0 and l[-1] == end_char:\\n Pb[t][l] = Pb[t - 1][l]\\n Pnb[t][l] = Pnb[t - 1][l]\\n continue \\n\\n for c in pruned_alphabet:\\n c_ix = labels.index(c)\\n # END: STEP 2\\n \\n # STEP 3: “Extending” with a blank\\n if c == blank_char:\\n Pb[t][l] += ctc[t][blank_index] * (Pb[t - 1][l] + Pnb[t - 1][l])\\n # END: STEP 3\\n \\n # STEP 4: Extending with the end character\\n else:\\n l_plus = l + c\\n if len(l) > 0 and c == l[-1]:\\n Pnb[t][l_plus] += ctc[t][c_ix] * Pb[t - 1][l]\\n Pnb[t][l] += ctc[t][c_ix] * Pnb[t - 1][l]\\n # END: STEP 4\\n\\n # STEP 5: Extending with any other non-blank character and LM constraints\\n elif len(l.replace(' ', '')) > 0 and c in (' ', end_char):\\n lm_prob = lm(l_plus.strip(' '+end_char)) ** alpha\\n Pnb[t][l_plus] += lm_prob * ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])\\n else:\\n Pnb[t][l_plus] += ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])\\n # END: STEP 5\\n\\n # STEP 6: Make use of discarded prefixes\\n if l_plus not in A_prev:\\n Pb[t][l_plus] += ctc[t][blank_index] * (Pb[t - 1][l_plus] + Pnb[t - 1][l_plus])\\n Pnb[t][l_plus] += ctc[t][c_ix] * Pnb[t - 1][l_plus]\\n # END: STEP 6\\n\\n # STEP 7: Select most probable prefixes\\n A_next = Pb[t] + Pnb[t]\\n sorter = lambda l: A_next[l] * (len(W(l)) + 1) ** beta\\n A_prev = sorted(A_next, key=sorter, reverse=True)[:k]\\n # END: STEP 7\\n if len(A_prev) ==0:\\n A_prev=['']\\n if return_weights:\\n return A_prev[0],A_next[A_prev[0]] * (len(W(A_prev[0])) + 1) ** beta\\n return A_prev[0]\\n #For N-best decode, return A_prev[0:N] - not tested yet.\",\n \"def label_users(self):\\n record_unit = 1000\\n print self.friendship_graph.number_of_nodes()\\n print self.friendship_graph.number_of_edges()\\n\\n for num, node in enumerate(self.friendship_graph.nodes()):\\n fake_flag = self.determine_spammer_by_percentage(node)\\n self.friendship_graph.node[node]['fake'] = fake_flag\\n # print self.friendship_graph.node[node]\\n if num % record_unit == 0:\\n print num\\n print time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))\\n nx.write_gpickle(self.friendship_graph, \\\"graph/firendship_new_label%d.pickle\\\" % num)\\n if num != 0:\\n os.remove(\\\"graph/firendship_new_label%d.pickle\\\" % (num - record_unit))\\n\\n nx.write_gpickle(self.friendship_graph, \\\"graph/firendship_0.8fake_%d.pickle\\\" % num)\",\n \"def process_label(self, foreground_labels):\\n # Find the unique (nonnegative) foreground_labels, map them to {0, ..., K-1}\\n unique_nonnegative_indices = np.unique(foreground_labels)\\n mapped_labels = foreground_labels.copy()\\n for k in range(unique_nonnegative_indices.shape[0]):\\n mapped_labels[foreground_labels == unique_nonnegative_indices[k]] = k\\n foreground_labels = mapped_labels\\n return foreground_labels\",\n \"def find_connected_components(thresh_image):\\n\\n rows, cols = thresh_image.shape\\n\\n # First find the connected components of the image\\n # num_labels: the number of connected components found in the image\\n # labels: a matrix with the labels for each pixel\\n # stats: [top_left_x_coord, top_left_y_coord, width, height, area] statistics for each component\\n # centroids: [x_coord, y_coord] of the centroid of each component\\n num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh_image)\\n\\n # Do some filtering based on the characteristics of a shuttle\\n for i in range(num_labels):\\n\\n # Filters out shapes that are too long\\n size_ratio = stats[i, 2] / stats[i, 3]\\n if size_ratio < 0.5 or size_ratio > 2:\\n labels[labels == i] = 0\\n\\n # Filters out shapes that fit the bounding box too well (likely noise) or too bad (sparse structure)\\n area_ratio = stats[i, 4] / (stats[i, 2] * stats[i, 3])\\n if area_ratio < 0.4 or area_ratio > 0.9:\\n labels[labels == i] = 0\\n\\n # Filters out shapes too small (in proportion to image size)\\n if stats[i, 2] < (rows / 60) or stats[i, 3] < (cols / 60):\\n labels[labels == i] = 0\\n\\n return labels\",\n \"def learn_pattern_Hebb(self, pattern):\\n if pattern.shape != self.shape:\\n # TODO: this could be written in a clearer way\\n ValueError(\\\"The pattern shape does not match the network one.\\\")\\n\\n pattern_flat = pattern.flatten()\\n\\n # Convert the bool array to an array with +-1\\n pattern_pm = 2*pattern_flat.astype(bool) - 1\\n\\n # Update adjacency matrix according to Hebb's rule \\n adjmatrix_change = np.outer(pattern_pm, pattern_pm).astype(float)\\n self.network.adjmatrix = np.average(\\n [self.network.adjmatrix, adjmatrix_change], axis=0,\\n weights=[self.npatterns, 1])\\n\\n # Update neighbour lists (isingmodel.Ising method)\\n self.update_neighbours()\\n\\n # Store the pattern in the patterns list\\n self.patterns.append(pattern)\",\n \"def splitCell(buff,index,ref_label,new_label):\\n cell_before = np.copy(buff[:,:,index-1])\\n cell_after = np.copy(buff[:,:,index])\\n \\n mask_after = cell_after ==ref_label\\n \\n cell_before[np.logical_not(mask_after)] = 0\\n \\n mask_ref_label = cell_before ==ref_label\\n mask_new_label = cell_before==new_label\\n \\n after_sure_ref = np.logical_and(mask_ref_label,mask_after)\\n after_sure_new = np.logical_and(mask_new_label,mask_after)\\n after_unsure = np.logical_and(mask_after,np.logical_not(np.logical_or(after_sure_ref,after_sure_new) ) )\\n\\n xref,yref = np.where(after_sure_ref)\\n ref_pts = np.concatenate((xref.reshape(-1,1),yref.reshape(-1,1)),axis=1)\\n xnew,ynew = np.where(after_sure_new)\\n new_pts = np.concatenate((xnew.reshape(-1,1),ynew.reshape(-1,1)),axis=1)\\n \\n labels_ref = np.ones(xref.shape[0])\\n labels_new = np.zeros(xnew.shape[0])\\n labels = np.concatenate((labels_ref,labels_new),axis=0)\\n labels.reshape(-1,1)\\n X= np.concatenate((ref_pts,new_pts),axis = 0)\\n \\n xu,yu = np.where(after_unsure)\\n u_pts = np.concatenate((xu.reshape(-1,1),yu.reshape(-1,1)),axis=1)\\n neigh = KNeighborsClassifier(n_neighbors=5)\\n neigh.fit(X, labels)\\n pred = neigh.predict(u_pts)\\n for i in range(pred.shape[0]):\\n #if pred is 1 goes to ref if 0 goes to new\\n if pred[i]==1:\\n after_sure_ref[u_pts[i,0],u_pts[i,1]]=True\\n else:\\n after_sure_new[u_pts[i,0],u_pts[i,1]]=True\\n #Assigning the new values to the thing:\\n buff[after_sure_ref,index] = ref_label\\n buff[after_sure_new,index] = new_label\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7240329","0.65720975","0.62097526","0.6137392","0.6120207","0.5910127","0.5895485","0.585058","0.58383656","0.5824214","0.57871556","0.5696335","0.5649472","0.5627702","0.5602631","0.5593537","0.5549893","0.55149436","0.5510126","0.54956084","0.54879755","0.5461544","0.54063094","0.54040754","0.539537","0.53839386","0.53625154","0.53600675","0.5355649","0.535127","0.53449005","0.534269","0.5324569","0.5324493","0.5313296","0.5293137","0.5285607","0.5284158","0.5276383","0.5254221","0.5252661","0.52357966","0.5230905","0.5229232","0.5226448","0.5224193","0.5216202","0.5204197","0.5202104","0.5196458","0.5193162","0.5180036","0.51765734","0.5166866","0.51629066","0.51618814","0.51582855","0.51477516","0.51439613","0.51412123","0.5140584","0.51358086","0.5135741","0.5126402","0.512575","0.51190895","0.5109461","0.51092434","0.510354","0.5097495","0.50957406","0.50925905","0.5088258","0.5087214","0.5085658","0.50842154","0.5077548","0.50769097","0.5076529","0.50757176","0.5072657","0.50665426","0.50583917","0.5056687","0.5056079","0.5051099","0.5050393","0.5050317","0.5049864","0.5044294","0.5044216","0.5040614","0.50345165","0.50326306","0.503155","0.50280255","0.5026652","0.5026211","0.5021653","0.50191706"],"string":"[\n \"0.7240329\",\n \"0.65720975\",\n \"0.62097526\",\n \"0.6137392\",\n \"0.6120207\",\n \"0.5910127\",\n \"0.5895485\",\n \"0.585058\",\n \"0.58383656\",\n \"0.5824214\",\n \"0.57871556\",\n \"0.5696335\",\n \"0.5649472\",\n \"0.5627702\",\n \"0.5602631\",\n \"0.5593537\",\n \"0.5549893\",\n \"0.55149436\",\n \"0.5510126\",\n \"0.54956084\",\n \"0.54879755\",\n \"0.5461544\",\n \"0.54063094\",\n \"0.54040754\",\n \"0.539537\",\n \"0.53839386\",\n \"0.53625154\",\n \"0.53600675\",\n \"0.5355649\",\n \"0.535127\",\n \"0.53449005\",\n \"0.534269\",\n \"0.5324569\",\n \"0.5324493\",\n \"0.5313296\",\n \"0.5293137\",\n \"0.5285607\",\n \"0.5284158\",\n \"0.5276383\",\n \"0.5254221\",\n \"0.5252661\",\n \"0.52357966\",\n \"0.5230905\",\n \"0.5229232\",\n \"0.5226448\",\n \"0.5224193\",\n \"0.5216202\",\n \"0.5204197\",\n \"0.5202104\",\n \"0.5196458\",\n \"0.5193162\",\n \"0.5180036\",\n \"0.51765734\",\n \"0.5166866\",\n \"0.51629066\",\n \"0.51618814\",\n \"0.51582855\",\n \"0.51477516\",\n \"0.51439613\",\n \"0.51412123\",\n \"0.5140584\",\n \"0.51358086\",\n \"0.5135741\",\n \"0.5126402\",\n \"0.512575\",\n \"0.51190895\",\n \"0.5109461\",\n \"0.51092434\",\n \"0.510354\",\n \"0.5097495\",\n \"0.50957406\",\n \"0.50925905\",\n \"0.5088258\",\n \"0.5087214\",\n \"0.5085658\",\n \"0.50842154\",\n \"0.5077548\",\n \"0.50769097\",\n \"0.5076529\",\n \"0.50757176\",\n \"0.5072657\",\n \"0.50665426\",\n \"0.50583917\",\n \"0.5056687\",\n \"0.5056079\",\n \"0.5051099\",\n \"0.5050393\",\n \"0.5050317\",\n \"0.5049864\",\n \"0.5044294\",\n \"0.5044216\",\n \"0.5040614\",\n \"0.50345165\",\n \"0.50326306\",\n \"0.503155\",\n \"0.50280255\",\n \"0.5026652\",\n \"0.5026211\",\n \"0.5021653\",\n \"0.50191706\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51125866"},"document_rank":{"kind":"string","value":"66"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":955,"numItemsPerPage":100,"numTotalItems":95772,"offset":95500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzU4ODMzMSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM1OTE5MzEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.USy6TcrUDuNV6CNIAEdGF2EVw9aYIT4eWT1W07_YhRegHcZ8YF59Tocm8-mFMqwhbq-QqO9rDYfCom0nPa7JAQ","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 |
|---|---|---|---|---|---|---|
Get a rule violators who have been ejected. | def get_violators(self):
return self.violators | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def affecteds(self):\n return [m for m in self.members if m.disease == PedigreeMember.AFFECTED]",
"def get_victors(self):\n if self.is_game_over():\n scores = [p.get_score() for p in self.state.get_players()]\n if len(scores) == 0:\n return []\n max_s... | [
"0.6156995",
"0.59065264",
"0.5629059",
"0.5474041",
"0.53551775",
"0.52045214",
"0.5177488",
"0.50929904",
"0.5079941",
"0.5059264",
"0.5059264",
"0.5011072",
"0.4973407",
"0.49627775",
"0.4929745",
"0.4920347",
"0.4912848",
"0.4911266",
"0.4906332",
"0.48964974",
"0.4874137... | 0.61693317 | 0 |
Get a copy of the current state. | def get_current_state(self):
return deepcopy(self.state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_state(self):\n return copy.deepcopy(self._state)",
"def __getstate__(self):\n state = self.__dict__.copy()\n self.__cleanState__(state)\n return state",
"def state(self):\n return self._state.copy()",
"def get_state(self, deepcopy: bool = True):\n s = self.cache_... | [
"0.8455732",
"0.79240113",
"0.78669524",
"0.78233796",
"0.76678777",
"0.76537627",
"0.7607961",
"0.75942713",
"0.7512252",
"0.74859667",
"0.74796313",
"0.7326282",
"0.7263944",
"0.7236717",
"0.7214216",
"0.7181021",
"0.7169202",
"0.71566755",
"0.715247",
"0.7142748",
"0.71140... | 0.81724 | 1 |
A decorator that wraps the passed in function and raises exception if headers with token is missing | def require_auth(function):
@functools.wraps(function)
def wrapper(self, *args, **kwargs):
if not self.headers:
raise LoginRequiredError
return function(self, *args, **kwargs)
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def token_required(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n try:\n token = request.headers['token']\n try:\n decoded = decode_token(token)\n except jwt.ExpiredSignatureError:\n return jsonify({\"message\": \"token expired\"}... | [
"0.8132438",
"0.7699005",
"0.7501329",
"0.74680185",
"0.7427506",
"0.742177",
"0.7420473",
"0.7285155",
"0.7139443",
"0.7120114",
"0.7101173",
"0.70718706",
"0.7041331",
"0.7013722",
"0.70107657",
"0.70075893",
"0.67916787",
"0.6714881",
"0.6710947",
"0.6683059",
"0.6663674",... | 0.7472541 | 3 |
Sigmoid backward (derivative) implementation | def sigmoid_backward(dA, Z):
dsig = sigmoid(Z) * (1 - sigmoid(Z))
return dA * dsig | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigmoid_derivative(x):\n return x * (1-x)",
"def sigmoid_derivative(x):\n return x * (1.0 - x)",
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def sigmoid_derivative(x):\n\n return sigmoid(x) * (1 - sigmoid(x))",
"def sigmoid_bac... | [
"0.85681444",
"0.8473839",
"0.831426",
"0.831426",
"0.8309925",
"0.8075164",
"0.80000556",
"0.79696095",
"0.79516095",
"0.7931595",
"0.7929404",
"0.7801728",
"0.7743298",
"0.7714867",
"0.7661006",
"0.76579946",
"0.7626087",
"0.76228863",
"0.7605027",
"0.753502",
"0.75197905",... | 0.82721937 | 5 |
RELU backward (derivative) implementation | def relu_backward(dA, Z):
dZ = np.array(dA, copy=True)
dZ[Z <= 0] = 0
return dZ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relu_backward(dout, cache):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # ... | [
"0.72977805",
"0.715568",
"0.7135363",
"0.7078485",
"0.6929383",
"0.69284886",
"0.6913763",
"0.69110596",
"0.69005686",
"0.69005686",
"0.6865896",
"0.6833532",
"0.682018",
"0.6802795",
"0.6802623",
"0.6784269",
"0.6782692",
"0.67817545",
"0.6776672",
"0.6749691",
"0.6739863",... | 0.69511014 | 4 |
Given a pool name, returns a storage driver. | def _init_driver(self, pool_id, pool_conf=None):
if pool_id is not None:
pool = self._pools_ctrl.get(pool_id, detailed=True)
else:
pool = pool_conf
conf = utils.dynamic_conf(pool['uri'], pool['options'],
conf=self._conf)
storage = utils.load_storage_driver(conf,
self._cache,
control_driver=self.control)
return pipeline.DataDriver(conf, storage, self.control) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_driver(self, pool_id, pool_conf=None):\n\n try:\n return self._drivers[pool_id]\n except KeyError:\n # NOTE(cpp-cabrera): cache storage driver connection\n self._drivers[pool_id] = self._init_driver(pool_id, pool_conf)\n\n return self._drivers[pool_... | [
"0.70222354",
"0.6526476",
"0.6414902",
"0.63886523",
"0.6257161",
"0.6163656",
"0.6162145",
"0.61483705",
"0.61444455",
"0.61236185",
"0.5998005",
"0.59904814",
"0.5983413",
"0.58813095",
"0.58759",
"0.58657277",
"0.58505595",
"0.58058536",
"0.5719337",
"0.56997657",
"0.5679... | 0.548844 | 29 |
Get the ID for the pool assigned to the given queue. | def _pool_id(self, queue, project=None):
return self._catalogue_ctrl.get(project, queue)['pool'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _get_work_pool_queue_id_from_name(\n self, session: AsyncSession, work_pool_name: str, work_pool_queue_name: str\n ) -> UUID:\n work_pool_queue = await models.workers.read_work_pool_queue_by_name(\n session=session,\n work_pool_name=work_pool_name,\n work... | [
"0.7236343",
"0.7009467",
"0.6953268",
"0.6914265",
"0.6697232",
"0.66893286",
"0.6669339",
"0.6644398",
"0.65078753",
"0.6422109",
"0.63314754",
"0.63168746",
"0.63056153",
"0.62965095",
"0.6249178",
"0.6227463",
"0.62212545",
"0.61551255",
"0.61551255",
"0.6059136",
"0.6049... | 0.8461307 | 0 |
Register a new queue in the pool catalog. This method should be called whenever a new queue is being created, and will create an entry in the pool catalog for the given queue. After using this method to register the queue in the catalog, the caller should call `lookup()` to get a reference to a storage driver which will allow interacting with the queue's assigned backend pool. | def register(self, queue, project=None, flavor=None):
# NOTE(gengchc): if exist, get queue's pool.flavor:
# if queue's pool.flavor is different, first delete it and add it.
# Otherwise, if the flavor in the meteredata of the queue is
# modified, the catalog will be inconsistent.
if self._catalogue_ctrl.exists(project, queue):
catalogue = self._catalogue_ctrl.get(project, queue)
oldpoolids = catalogue['pool']
oldpool = self._pools_ctrl.get(oldpoolids)
oldflavor = oldpool['flavor']
msgtmpl = _(u'register queue to pool: old flavor: %(oldflavor)s '
', new flavor: %(flavor)s')
LOG.info(msgtmpl,
{'oldflavor': oldflavor, 'flavor': flavor})
if oldpool['flavor'] != flavor:
self._catalogue_ctrl.delete(project, queue)
if not self._catalogue_ctrl.exists(project, queue):
if flavor is not None:
flavor = self._flavor_ctrl.get(flavor, project=project)
pools = self._pools_ctrl.get_pools_by_flavor(
flavor=flavor,
detailed=True)
pool = select.weighted(pools)
pool = pool and pool['name'] or None
msgtmpl = _(u'register queue to pool: new flavor:%(flavor)s')
LOG.info(msgtmpl,
{'flavor': flavor.get('name', None)})
else:
# NOTE(flaper87): Get pools assigned to the default
# group `None`. We should consider adding a `default_group`
# option in the future.
pools = self._pools_ctrl.get_pools_by_flavor(detailed=True)
pool = select.weighted(pools)
pool = pool and pool['name'] or None
if not pool:
# NOTE(flaper87): We used to raise NoPoolFound in this
# case but we've decided to support automatic pool
# creation. Note that we're now returning and the queue
# is not being registered in the catalogue. This is done
# on purpose since no pool exists and the "dummy" pool
# doesn't exist in the storage
if self.lookup(queue, project) is not None:
return
raise errors.NoPoolFound()
msgtmpl = _(u'register queue to pool: new flavor: None')
LOG.info(msgtmpl)
msgtmpl = _(u'register queue: project:%(project)s'
' queue:%(queue)s pool:%(pool)s')
LOG.info(msgtmpl,
{'project': project,
'queue': queue,
'pool': pool})
self._catalogue_ctrl.insert(project, queue, pool) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register(self, queue, project=None):\n # NOTE(cpp-cabrera): only register a queue if the entry\n # doesn't exist\n if not self._catalogue_ctrl.exists(project, queue):\n # NOTE(cpp-cabrera): limit=0 implies unlimited - select from\n # all shards\n shard = se... | [
"0.71361166",
"0.6695945",
"0.64565563",
"0.6338736",
"0.6160316",
"0.6083422",
"0.5962883",
"0.59370244",
"0.5895258",
"0.5773519",
"0.5767887",
"0.5727844",
"0.5669611",
"0.5621137",
"0.55773187",
"0.5558326",
"0.5552847",
"0.55482846",
"0.55192804",
"0.5471164",
"0.5442383... | 0.7536504 | 0 |
Removes a queue from the pool catalog. Call this method after successfully deleting it from a backend pool. | def deregister(self, queue, project=None):
self._catalogue_ctrl.delete(project, queue) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_queue(self):\n self.work_queue_client.delete_queue()",
"def _queue_delete(self, queue):\n\n queue.delete()",
"def remove_queue(self, queue) -> None:\r\n self.receive_queues.remove(queue)",
"def remove_queue(self, queue):\n with self.mutex:\n self.queues.remov... | [
"0.72310483",
"0.7100992",
"0.70777076",
"0.70770454",
"0.6994525",
"0.699254",
"0.6895938",
"0.6883569",
"0.68662935",
"0.6845864",
"0.6806441",
"0.68028337",
"0.67998916",
"0.6713241",
"0.67060405",
"0.66622037",
"0.64299446",
"0.6404603",
"0.63555455",
"0.6346353",
"0.6262... | 0.70685136 | 4 |
Lookup the queue controller for the given queue and project. | def get_queue_controller(self, queue, project=None):
target = self.lookup(queue, project)
return target and target.queue_controller | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_claim_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.claim_controller",
"def get_message_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.message_controller",
"d... | [
"0.77063626",
"0.7698841",
"0.76416427",
"0.7288941",
"0.6930836",
"0.6912205",
"0.60668814",
"0.606344",
"0.60406834",
"0.594424",
"0.5849223",
"0.5683665",
"0.5642507",
"0.560627",
"0.559546",
"0.55402505",
"0.55328107",
"0.5492972",
"0.54287374",
"0.5398488",
"0.539153",
... | 0.86451554 | 0 |
Lookup the message controller for the given queue and project. | def get_message_controller(self, queue, project=None):
target = self.lookup(queue, project)
return target and target.message_controller | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.queue_controller",
"def get_claim_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.claim_controller",
"def g... | [
"0.80495954",
"0.73924774",
"0.73809624",
"0.6577108",
"0.6438663",
"0.6041202",
"0.5956915",
"0.5211523",
"0.5192648",
"0.5166102",
"0.5160857",
"0.5156492",
"0.5145304",
"0.51198655",
"0.51061904",
"0.50889635",
"0.49702215",
"0.49656522",
"0.49377242",
"0.49108028",
"0.487... | 0.8593036 | 0 |
Lookup the claim controller for the given queue and project. | def get_claim_controller(self, queue, project=None):
target = self.lookup(queue, project)
return target and target.claim_controller | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.queue_controller",
"def get_subscription_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.subscription_control... | [
"0.7787301",
"0.7567917",
"0.7170647",
"0.62005764",
"0.6165711",
"0.5723963",
"0.5608801",
"0.5049111",
"0.5029624",
"0.48735002",
"0.48166627",
"0.4790605",
"0.47787577",
"0.47474897",
"0.47414377",
"0.4711115",
"0.47098687",
"0.47030538",
"0.4683094",
"0.46805832",
"0.4673... | 0.8776693 | 0 |
Lookup the subscription controller for the given queue and project. | def get_subscription_controller(self, queue, project=None):
target = self.lookup(queue, project)
return target and target.subscription_controller | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.queue_controller",
"def get_claim_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.claim_controller",
"def g... | [
"0.76404476",
"0.7447651",
"0.69627404",
"0.63039684",
"0.62465614",
"0.6126285",
"0.60098344",
"0.5344913",
"0.52650946",
"0.5261455",
"0.5224008",
"0.51507324",
"0.51497537",
"0.5039444",
"0.5002221",
"0.4991361",
"0.49808443",
"0.49703738",
"0.4967121",
"0.4910888",
"0.487... | 0.8589521 | 0 |
Lookup the topic controller for the given queue and project. | def get_topic_controller(self, topic, project=None):
target = self.lookup(topic, project)
return target and target.topic_controller | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.queue_controller",
"def get_subscription_controller(self, queue, project=None):\n target = self.lookup(queue, project)\n return target and target.subscription_control... | [
"0.7733818",
"0.7603851",
"0.74324155",
"0.728382",
"0.63744485",
"0.6344827",
"0.57456493",
"0.5728621",
"0.56051105",
"0.55933976",
"0.55091506",
"0.5342035",
"0.5326094",
"0.53004175",
"0.5222844",
"0.520292",
"0.5191208",
"0.51723534",
"0.5128026",
"0.5117455",
"0.508792"... | 0.7806749 | 0 |
Lookup a pool driver for the given queue and project. | def lookup(self, queue, project=None):
try:
pool_id = self._pool_id(queue, project)
except errors.QueueNotMapped as ex:
LOG.debug(ex)
return self.get_default_pool(use_listing=False)
return self.get_driver(pool_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup(self, queue, project=None):\n\n try:\n shard_id = self._shard_id(queue, project)\n except errors.QueueNotMapped as ex:\n LOG.debug(ex)\n\n # NOTE(kgriffs): Return `None`, rather than letting the\n # exception bubble up, so that the higher layer d... | [
"0.7773466",
"0.6421427",
"0.61614996",
"0.58672553",
"0.58434623",
"0.5762848",
"0.56201243",
"0.5590634",
"0.5587302",
"0.5487426",
"0.54723954",
"0.5447157",
"0.5354828",
"0.5348546",
"0.53464115",
"0.52886975",
"0.5276325",
"0.5234317",
"0.521486",
"0.518824",
"0.51820177... | 0.8907264 | 0 |
Get storage driver, preferably cached, from a pool name. | def get_driver(self, pool_id, pool_conf=None):
try:
return self._drivers[pool_id]
except KeyError:
# NOTE(cpp-cabrera): cache storage driver connection
self._drivers[pool_id] = self._init_driver(pool_id, pool_conf)
return self._drivers[pool_id] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_storage_backend(self):\n return self.client.info()['Driver']",
"def storage_backend_get_by_name(context, name, inactive=False):\n return _find_storage_backend(context, dict(name = name), True, None, inactive=inactive)",
"def _get_driver(self, driver_name):\n driver = lb_const.SERVICE_T... | [
"0.6834399",
"0.68316096",
"0.6733757",
"0.67019266",
"0.66133344",
"0.6580576",
"0.65020525",
"0.63906044",
"0.6277041",
"0.6253371",
"0.6227523",
"0.6190082",
"0.6147456",
"0.61158353",
"0.60346544",
"0.60328054",
"0.60253716",
"0.6005569",
"0.5980574",
"0.5942194",
"0.5914... | 0.7380291 | 0 |
Open the URL for the given DOI in the default browser | def open_doi(doi):
webbrowser.open_new_tab(DOI_URL % doi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_in_browser(self):\n webbrowser.open(self.url)",
"def open(url):\r\n webbrowser.open(url)",
"def browser_open(story_id, arguments):\r\n\r\n story = load_story(story_id, arguments)\r\n\r\n webbrowser.open(story.url)",
"def open_url(name):\n url = localReadConfig.get_webServer(name)\... | [
"0.7175303",
"0.70528334",
"0.6925984",
"0.68447846",
"0.66982275",
"0.6694972",
"0.654901",
"0.65459543",
"0.64876926",
"0.6484498",
"0.6445093",
"0.64057773",
"0.63870794",
"0.6381969",
"0.63739616",
"0.6357972",
"0.6353263",
"0.62887174",
"0.62686133",
"0.6265236",
"0.6234... | 0.82702404 | 0 |
Given a FireBrowser object will then check to see if there are notifications then will go through the list and respond appropriately to them. | def run(browser: FireBrowser):
midline("STATUS UPDATING")
if browser.find_tab("Portal") is not -1:
browser.switch_tab("Portal")
elif not browser.tab_names:
login.run(browser)
else:
login.run(browser)
file = FileHandle("status")
data = file.read_to_data()
browser.remind_me_later()
if browser.check_selector(data['notify_check']):
write("Looking at Notifications...")
while delete_notifications(browser, data):
browser.click(data['notify_dropdown_click'])
while __find_updateable_notification(browser, data):
"""Check to see if asurion or if appointment."""
browser.click(data['lead_textarea'])
headings = browser.get_elements_text(data['lead_type_heading'])
if contain_list("Appointment", headings):
browser.click(data['status_select'])
browser.click(data['status_select_awaiting'])
browser.send_text(data['appointment_text'], 'lead_textarea')
elif contain_list("Asurion", headings):
browser.send_text(data['asurion_text'], 'lead_textarea') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notifications(self):\r\n return notifications.Notifications(self)",
"def notifications(self):\r\n return notifications.Notifications(self)",
"def get_user_notifications(self, login):",
"async def update_cache_from_notification(self) -> List[Notification]:\n new_notifications = []\n ... | [
"0.5953895",
"0.5953895",
"0.5901647",
"0.584553",
"0.5815878",
"0.58042645",
"0.5801946",
"0.5765564",
"0.57637656",
"0.5749498",
"0.5722716",
"0.5661563",
"0.5660522",
"0.56066173",
"0.5565932",
"0.55315346",
"0.55289805",
"0.5522268",
"0.5481762",
"0.54630154",
"0.5443189"... | 0.6035755 | 0 |
figure out filename (or eventually URI) of pregenerated NEMSformat recording for a given cell/batch/loader string very baphyspecific. Needs to be coordinated with loader processing in nems0.xform_helper | def generate_recording_uri(cellid, batch, loader):
options = {}
if loader in ["ozgf100ch18", "ozgf100ch18n"]:
options = {'rasterfs': 100, 'includeprestim': True,
'stimfmt': 'ozgf', 'chancount': 18}
elif loader in ["ozgf100ch18pup", "ozgf100ch18npup"]:
options = {'rasterfs': 100, 'stimfmt': 'ozgf',
'chancount': 18, 'pupil': True, 'stim': True,
'pupil_deblink': True, 'pupil_median': 2}
elif (loader.startswith("nostim200pup") or loader.startswith("psth200pup")
or loader.startswith("psths200pup")):
options = {'rasterfs': 200, 'stimfmt': 'parm',
'chancount': 0, 'pupil': True, 'stim': False,
'pupil_deblink': 1, 'pupil_median': 0.5}
elif loader.startswith("nostim10pup") or loader.startswith("psth10pup"):
options = {'rasterfs': 10, 'stimfmt': 'parm',
'chancount': 0, 'pupil': True, 'stim': False,
'pupil_deblink': True, 'pupil_median': 2}
elif (loader.startswith("nostim20pup") or loader.startswith("psth20pup")
or loader.startswith("psths20pup")
or loader.startswith("evt20pup")):
options = {'rasterfs': 20, 'stimfmt': 'parm',
'chancount': 0, 'pupil': True, 'stim': False,
'pupil_deblink': 1, 'pupil_median': 0.5}
elif (loader.startswith("nostim20") or loader.startswith("psth20")
or loader.startswith("psthm20") or loader.startswith("psths20")):
options = {'rasterfs': 20, 'stimfmt': 'parm',
'chancount': 0, 'pupil': False, 'stim': False}
elif (loader.startswith("env100") or loader.startswith("envm100")):
options = {'rasterfs': 100, 'stimfmt': 'envelope', 'chancount': 0}
elif loader.startswith("env200"):
options = {'rasterfs': 200, 'stimfmt': 'envelope', 'chancount': 0}
else:
raise ValueError('unknown loader string')
recording_uri = get_recording_file(cellid, batch, options)
return recording_uri | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getWaveformFileName(self):\n return self.waveform_info.split(\":\")[1][:20]",
"def _get_output_filename(dataset_dir, split_name):\n return '%s/fer_%s.tfrecord' % (dataset_dir, split_name)",
"def parse_rarefaction_fname(name_string):\r\n\r\n root, ext = os.path.splitext(name_string)\r\n root_l... | [
"0.58643293",
"0.57457685",
"0.5731537",
"0.5680883",
"0.5600236",
"0.55516845",
"0.55441797",
"0.55333227",
"0.5529272",
"0.55155426",
"0.54681367",
"0.5426146",
"0.541352",
"0.5407",
"0.54030865",
"0.537808",
"0.5370207",
"0.53593916",
"0.53360903",
"0.5330803",
"0.5321981"... | 0.6297846 | 0 |
Pipeline for process of scraping new data Each step in the pipeline has corresponding directory of plugins. Plugins are dynamically loaded based on files in the corresponding dir. | def scrape_pipeline(args):
kickoff = args.kickoff
fname = args.fname
d = DbHelper()
s = Scraper()
c = Crawler(20)
if fname is not None:
app_names = pd.read_csv(fname)['packageName'].tolist()
apps = [list(a) for a in zip(app_names, d.app_names_to_uuids(app_names))]
else:
apps = None
# start by updating top apps
if not args.skip_top:
logger.info("getting top apps...")
new_top_list = c.get_top_apps_list()
logger.info("scraping top apps not in DB...")
s.scrape_missing(new_top_list, compare_top=True)
logger.info("updating top apps...")
d.update_top_apps(new_top_list)
if kickoff == True:
s = None
if fname is None:
# use crawler to get list of package names
logger.error("Crawler for package names not implemented yet")
return
else:
# use specified file of package names
s = Scraper(input_file=fname)
# use scraper
logger.info("Starting efficient scrape...")
s.efficient_scrape()
logger.info("...efficient scrape done")
else:
# use updater
logger.info("Starting updater...")
if fname is None:
u = Updater()
else:
u = Updater(input_file=fname)
u.update_apps()
logger.info("...update done")
# crawl privacy policies
c.crawl_app_privacy_policies(app_list=apps)
if args.no_decompile:
# download only
logger.info("Starting download...")
downloader = Downloader()
if apps is None:
downloader.download_all_from_db(top=True)
else:
downloader.download(apps)
logger.info("...done")
else:
# download/decompile
logger.info("Starting download and decompile...")
download_decompile_all()
logger.info("...download and decompile done")
logger.info("run analysis pipeline now") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collectPlugins(self):\n\t\tself.locatePlugins()\n\t\tself.loadPlugins()",
"async def load_plugins(self):\n for plug in os.listdir('plugins'):\n if plug.startswith('.'):\n continue\n if not os.path.isdir('plugins/%s' % plug) or not os.path.isfile('plugins/%s/hook.py... | [
"0.6368807",
"0.63078946",
"0.5957224",
"0.59520274",
"0.5943972",
"0.59165645",
"0.58626246",
"0.5809751",
"0.5809528",
"0.57702124",
"0.57576746",
"0.5738377",
"0.5659071",
"0.5647176",
"0.56273735",
"0.55972546",
"0.55384547",
"0.55326164",
"0.5529749",
"0.55208814",
"0.55... | 0.5151529 | 55 |
Test if the add operation returns the correct result for a test case | def test_add_int(self):
self.assertEqual(operations.add(3,4), 7) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_returns_correct_result(self):\n result = self.calc.add(2, 2)\n self.assertEqual(4, result)",
"def test_add(self):\n self.assertEqual(add(1, 1), 2, \"Wrong answer\")\n self.assertEqual(add(10, 1), 11, \"Wrong answer\")\n self.assertEqual(add(15, 15), 30, \"Wrong ans... | [
"0.87641716",
"0.8728581",
"0.85901284",
"0.83460325",
"0.8322828",
"0.82488525",
"0.82488525",
"0.82488525",
"0.8183821",
"0.8175811",
"0.80814475",
"0.8047177",
"0.8006275",
"0.79732543",
"0.79165095",
"0.7913617",
"0.7900404",
"0.77927405",
"0.7747016",
"0.774245",
"0.7690... | 0.8132406 | 10 |
Test if the devide operation returns the correct result for a test case | def test_devide_int(self):
self.assertEqual(operations.devide(8,4), 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_four_divided_by_two():\n assert divide(4, 2) == 2",
"def test_call_decompose(self):\n dec = TwoQubitDecomposeUpToDiagonal()\n u4 = scipy.stats.unitary_group.rvs(4, random_state=47)\n dmat, circ2cx = dec(u4)\n dec_diag = dmat @ Operator(circ2cx).data\n self.assertTru... | [
"0.6033728",
"0.60241795",
"0.5930758",
"0.5923345",
"0.59231955",
"0.5863153",
"0.5844059",
"0.58171606",
"0.5786536",
"0.575913",
"0.5739477",
"0.5738475",
"0.5738475",
"0.57308537",
"0.5692235",
"0.56907034",
"0.5671279",
"0.56524765",
"0.56412613",
"0.5602296",
"0.5571406... | 0.56738025 | 16 |
Test if the equation 1 + 2 is parsed and calculated correctly | def test_parse_add(self):
self.assertEqual(parse_input.parse(["1", "+", "2"]), 3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autosolve(equation):\n\n try:\n # Try to set a variable to an integer\n num1 = int(equation.split(\" \")[0])\n\n except ValueError:\n # Try to set a variable to a decimal\n num1 = float(equation.split(\" \")[0])\n\n try:\n # Try to set a variable to an integer\n ... | [
"0.69371355",
"0.69028455",
"0.68847096",
"0.68847096",
"0.6814599",
"0.6751683",
"0.6709436",
"0.6692912",
"0.66831404",
"0.66694516",
"0.6641257",
"0.66409284",
"0.6588774",
"0.6569552",
"0.6498368",
"0.649347",
"0.64901173",
"0.6489638",
"0.64841825",
"0.6454213",
"0.64497... | 0.59757686 | 62 |
Test if the equation 3 / 2 is parsed and calculated correctly | def test_parse_devide(self):
self.assertEqual(parse_input.parse(["8", "/", "4"]), 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_calculate_three_operations_in_bracket(self):\n result = self.calcuate.calcuate('(2x2+1+7)x3-2')\n expected_result = \"34\"\n self.assertEqual(expected_result, result)",
"def is_equation(self): \n return False",
"def is_equation(self):\n return True",
"def is... | [
"0.6916226",
"0.68524635",
"0.67907655",
"0.67907655",
"0.66762483",
"0.66166973",
"0.6573047",
"0.6543683",
"0.6413765",
"0.62079144",
"0.61546904",
"0.60421985",
"0.603584",
"0.60189974",
"0.6009543",
"0.6008097",
"0.5994459",
"0.5980641",
"0.5955912",
"0.59496975",
"0.5947... | 0.0 | -1 |
Load PTB raw data from data directory "data_path". Reads PTB text files, converts strings to integer ids, and performs minibatching of the inputs. | def ptb_raw_data(data_path=None):
train_path = os.path.join(data_path, "ptb.train.txt")
valid_path = os.path.join(data_path, "ptb.valid.txt")
test_path = os.path.join(data_path, "ptb.test.txt")
word_to_id = _build_vocab(train_path)
train_data = _file_to_word_ids(train_path, word_to_id)
valid_data = _file_to_word_ids(valid_path, word_to_id)
test_data = _file_to_word_ids(test_path, word_to_id)
vocabulary = len(word_to_id)
return train_data, valid_data, test_data, vocabulary | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ptb_raw_data(data_path=None):\n\n\t# train_path = os.path.join(data_path, \"ptb.train.txt\")\n\t# valid_path = os.path.join(data_path, \"ptb.valid.txt\")\n\t# test_path = os.path.join(data_path, \"ptb.test.txt\")\n\n\tdata = np.load(data_path)\n\t# data = np.load(data_path).item()\n\t# f = open(data_path)\n\t#... | [
"0.67146957",
"0.6536038",
"0.6505355",
"0.6482044",
"0.62835264",
"0.62004197",
"0.61886907",
"0.6138994",
"0.6122752",
"0.6041423",
"0.6030121",
"0.5910836",
"0.58546567",
"0.5850749",
"0.5726605",
"0.5721663",
"0.5707934",
"0.5683992",
"0.5656485",
"0.5635938",
"0.56157595... | 0.6501877 | 3 |
Load raw data from data directory "data_path". | def europarl_raw_data(
data_path='bigdata/training',
lang1='de-en-german.txt',
lang2='de-en-english.txt',
max_train_len=32,
train_size=1600000,
val_size=160000,
):
lang1_path = os.path.join(data_path, lang1)
lang2_path = os.path.join(data_path, lang2)
split_data = _train_val_test_split(
[_read_lines(lang1_path), _read_lines(lang2_path)],
train_size, val_size
)
lang1_train, lang1_val, lang1_test = split_data[0]
lang2_train, lang2_val, lang2_test = split_data[1]
lang1_idx2word, lang1_word2idx = _build_vocab_from_sentences(lang1_train)
lang2_idx2word, lang2_word2idx = _build_vocab_from_sentences(lang2_train)
lang1_train_vectorized = _convert_sentences_to_ids(
lang1_train,
lang1_word2idx
)
lang1_val_vectorized = _convert_sentences_to_ids(
lang1_val,
lang1_word2idx
)
lang1_test_vectorized = _convert_sentences_to_ids(
lang1_test,
lang1_word2idx
)
lang2_train_vectorized = _convert_sentences_to_ids(
lang2_train,
lang2_word2idx
)
X_train, y_train = _convert_to_numpy_by_length(
lang1_train_vectorized,
lang2_train_vectorized,
max_train_len,
)
X_val = _convert_to_numpy(lang1_val_vectorized)
X_test = _convert_to_numpy(lang1_test_vectorized)
return {
'vocab': {
'lang1_idx2word': lang1_idx2word,
'lang1_word2idx': lang1_word2idx,
'lang2_idx2word': lang2_idx2word,
'lang2_word2idx': lang2_word2idx,
},
'train': {
'X': X_train,
'y': y_train,
},
'val': {
'X': X_val,
'y': lang2_val,
},
'test': {
'X': X_test,
'y': lang2_test,
},
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_data(self, path):\n with open(self.path_to_file, \"r\") as f:\n data = f.read()\n\n return data",
"def load_data(path):\n input_file = os.path.join(path)\n with open(input_file, 'r', encoding='utf-8') as f:\n return f.read()",
"def load_data(path):\n with open... | [
"0.7591733",
"0.7125923",
"0.70399314",
"0.70078355",
"0.69444233",
"0.6751344",
"0.67399246",
"0.6689886",
"0.6673148",
"0.66665107",
"0.66659683",
"0.6657956",
"0.6638113",
"0.654055",
"0.64056915",
"0.63831306",
"0.6358966",
"0.6358966",
"0.63364625",
"0.6292081",
"0.62728... | 0.0 | -1 |
Iterate on the raw PTB data. This chunks up raw_data into batches of examples and returns Tensors that are drawn from these batches. | def ptb_producer(raw_data, batch_size, num_steps, name=None):
with tf.name_scope(name, "PTBProducer", [raw_data, batch_size, num_steps]):
raw_data = tf.convert_to_tensor(raw_data, name="raw_data", dtype=tf.int32)
data_len = tf.size(raw_data)
batch_len = data_len // batch_size
data = tf.reshape(raw_data[0 : batch_size * batch_len],
[batch_size, batch_len])
epoch_size = (batch_len - 1) // num_steps
assertion = tf.assert_positive(
epoch_size,
message="epoch_size == 0, decrease batch_size or num_steps")
with tf.control_dependencies([assertion]):
epoch_size = tf.identity(epoch_size, name="epoch_size")
i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()
x = tf.strided_slice(data, [0, i * num_steps],
[batch_size, (i + 1) * num_steps])
x.set_shape([batch_size, num_steps])
y = tf.strided_slice(data, [0, i * num_steps + 1],
[batch_size, (i + 1) * num_steps + 1])
y.set_shape([batch_size, num_steps])
return x, y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ptb_iterator(raw_data, batch_size, num_steps):\n raw_data = np.array(raw_data, dtype=np.int32)\n\n data_len = len(raw_data)\n batch_len = data_len // batch_size\n data = np.zeros([batch_size, batch_len], dtype=np.int32)\n for i in range(batch_size):\n data[i] = raw_data[batch_len * i:batch_len * (i + 1... | [
"0.6978561",
"0.6902418",
"0.63087994",
"0.61956096",
"0.61338556",
"0.6096684",
"0.60834736",
"0.60573965",
"0.6056362",
"0.6045705",
"0.60360193",
"0.6022146",
"0.601624",
"0.6003096",
"0.59680426",
"0.5925938",
"0.59207135",
"0.5913195",
"0.59102833",
"0.5889849",
"0.58750... | 0.54554814 | 77 |
Return the notify service. | def get_service(
hass: HomeAssistant,
config: ConfigType,
discovery_info: DiscoveryInfoType | None = None,
) -> RocketChatNotificationService | None:
username = config.get(CONF_USERNAME)
password = config.get(CONF_PASSWORD)
url = config.get(CONF_URL)
room = config.get(CONF_ROOM)
try:
return RocketChatNotificationService(url, username, password, room)
except RocketConnectionException:
_LOGGER.warning("Unable to connect to Rocket.Chat server at %s", url)
except RocketAuthenticationException:
_LOGGER.warning("Rocket.Chat authentication failed for user %s", username)
_LOGGER.info("Please check your username/password")
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_service(hass, config, discovery_info=None):\n\n sender_nr = config[CONF_SENDER_NR]\n recp_nrs = config[CONF_RECP_NR]\n signal_cli_rest_api_url = config[CONF_SIGNAL_CLI_REST_API]\n\n signal_cli_rest_api = SignalCliRestApi(signal_cli_rest_api_url, sender_nr)\n\n return SignalNotificationServic... | [
"0.6690221",
"0.6181973",
"0.6181973",
"0.6181973",
"0.6116812",
"0.60631627",
"0.6032626",
"0.6008227",
"0.5919631",
"0.5903544",
"0.5897824",
"0.5842087",
"0.5824085",
"0.5796516",
"0.5742724",
"0.5742724",
"0.57323897",
"0.5706646",
"0.56921333",
"0.5666572",
"0.56374615",... | 0.5747234 | 14 |
Send a message to Rocket.Chat. | def send_message(self, message="", **kwargs):
data = kwargs.get(ATTR_DATA) or {}
resp = self._server.chat_post_message(message, channel=self._room, **data)
if resp.status_code == HTTPStatus.OK:
if not resp.json()["success"]:
_LOGGER.error("Unable to post Rocket.Chat message")
else:
_LOGGER.error(
"Incorrect status code when posting message: %d", resp.status_code
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendChatMessage(self, msg):\n self.transport.write(msg)",
"def send_message(self, message):\n \n msgPacket = serverbound.play.ChatPacket()\n msgPacket.message = message\n self.connection.write_packet(msgPacket)",
"def send(self, msg):\n self.message('Me', msg)",
"def... | [
"0.79602695",
"0.7867005",
"0.7461435",
"0.74155366",
"0.73181975",
"0.72749156",
"0.72387594",
"0.72059983",
"0.71983445",
"0.71811515",
"0.7162376",
"0.71472645",
"0.7142168",
"0.7140404",
"0.70665747",
"0.7054692",
"0.704193",
"0.70210105",
"0.69757414",
"0.69357747",
"0.6... | 0.6836778 | 31 |
Unit test for Roybal_Student_Analytics constructor. | def test_init(self):
s = Student_Analytics()
self.assertEqual(len(s.data),89) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, student):\n pass",
"def __init__(self, student, start_date, day_periods):\n self.student = student\n self.start_date = start_date\n self.day_periods = day_periods\n self.student_name = student.full_name_lastname_first(\n show_middle_name=False)\n ... | [
"0.6371787",
"0.6314157",
"0.6181478",
"0.6096545",
"0.6089736",
"0.60254514",
"0.5956355",
"0.59550136",
"0.594131",
"0.58837605",
"0.58226454",
"0.5809876",
"0.57946306",
"0.5790085",
"0.578611",
"0.57836026",
"0.57833344",
"0.57766145",
"0.5764777",
"0.5755531",
"0.574614"... | 0.75536776 | 0 |
Unit test for Roybal_Student_Analytics classify_grade method. | def test_classify_grade(self):
s = Student_Analytics()
self.assertEqual(s.classify_grade(5.00),"A+") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_avg_grade(self):\n\t\ts = Student_Analytics()\n\t\tself.assertEqual(s.classify_grade(s.avg_grade(3)),\"B\")",
"def classification_score(self, x, y):\t\n\t\tpass",
"def test_classify(self):\n classifiers, estimates =\\\n ada_boost.train_dataset(self.larger_matrix,\n ... | [
"0.8039397",
"0.65274847",
"0.640173",
"0.6289307",
"0.6219212",
"0.5914755",
"0.5887433",
"0.5776925",
"0.5719986",
"0.56444573",
"0.56377053",
"0.56352776",
"0.56190753",
"0.56097853",
"0.5556611",
"0.55541223",
"0.55449235",
"0.5517405",
"0.55008376",
"0.54830605",
"0.5482... | 0.8334534 | 0 |
Unit test for Roybal_Student_Analytics element_count method. | def test_element_count(self):
s = Student_Analytics()
self.assertEqual(s.element_count(2,"F"),6) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_elements_count():\n # GIVEN\n bboxes = [8.67066,49.41423,8.68177,49.4204]\n time = \"2010-01-01/2011-01-01/P1Y\"\n keys = [\"building\"]\n values = [\"\"]\n\n timestamps = [\"2010-01-01T00:00:00Z\", \"2011-01-01T00:00:00Z\"]\n counts = [53.0, 256.0]\n expected = pd.DataFrame({\"tim... | [
"0.68616205",
"0.6832444",
"0.67097497",
"0.66983885",
"0.667081",
"0.66494507",
"0.66494507",
"0.66494507",
"0.66494507",
"0.6644853",
"0.66385466",
"0.6608439",
"0.6572097",
"0.64722455",
"0.64489216",
"0.6442627",
"0.6383579",
"0.63805336",
"0.6367451",
"0.63651866",
"0.63... | 0.8672462 | 0 |
Unit test for Roybal_Student_Analytics avg_grade method. | def test_avg_grade(self):
s = Student_Analytics()
self.assertEqual(s.classify_grade(s.avg_grade(3)),"B") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_classify_grade(self):\n\t\ts = Student_Analytics()\n\t\tself.assertEqual(s.classify_grade(5.00),\"A+\")",
"def test_multiple_averages(self):\n user = self.make_user()\n enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)\n GradeFactory(\n score=50... | [
"0.7095265",
"0.6956697",
"0.68770933",
"0.68014836",
"0.68014836",
"0.6484994",
"0.6410727",
"0.6400051",
"0.63546544",
"0.63439816",
"0.627917",
"0.62735564",
"0.62159175",
"0.6123687",
"0.6123593",
"0.6098858",
"0.6067414",
"0.60544163",
"0.5998449",
"0.59840584",
"0.59782... | 0.8476935 | 0 |
Unit test for Roybal_Student_Analytics grade_change method. | def test_grade_change(self):
s = Student_Analytics()
self.assertEqual(int(s.grade_change()),0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_avg_grade(self):\n\t\ts = Student_Analytics()\n\t\tself.assertEqual(s.classify_grade(s.avg_grade(3)),\"B\")",
"def test_grade(self, grade):\n self.client.login(username=self.student.username, password=self.password)\n with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactor... | [
"0.6894253",
"0.67889714",
"0.6747671",
"0.6735463",
"0.65195036",
"0.63752735",
"0.63277483",
"0.6276599",
"0.62044054",
"0.6194973",
"0.6135887",
"0.6101513",
"0.6052034",
"0.5957101",
"0.5942507",
"0.59255475",
"0.58964777",
"0.5884683",
"0.58781224",
"0.58647764",
"0.5830... | 0.8471558 | 0 |
Return true if the socket managed by this connection is connected | def is_connected(self):
return self.socket is not None and self.socket.connected and super(WebsocketTransport, self).is_connected() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_connected(self):\n if self._socket:\n return True\n else:\n return False",
"def is_connected(self):\r\n return self.__socket is not None",
"def is_connected(self):\n return self._socket is not None",
"def getIsConnected(self):\n if self._socket ... | [
"0.9105765",
"0.8836678",
"0.8816751",
"0.8545325",
"0.8359238",
"0.82961154",
"0.82776904",
"0.8272576",
"0.82721364",
"0.82631487",
"0.82311773",
"0.8210377",
"0.8137813",
"0.80617905",
"0.80345",
"0.80271804",
"0.79471153",
"0.79411083",
"0.7917166",
"0.7908697",
"0.790361... | 0.82416207 | 10 |
Disconnect the underlying socket connection | def disconnect_socket(self):
self.running = False
if self.socket is not None:
self.socket.close()
self.current_host_and_port = None
self.socket = None
self.notify('disconnected') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disconnect(self):\n self.connected = False\n self.socket.close()",
"def disconnect(self):\n self.connected = False\n try:\n self.protocol.send_message(self.sock, '__!goodbye__')\n data = self.protocol.recover_message(self.sock)\n except:\n p... | [
"0.8091306",
"0.8073663",
"0.8069597",
"0.7900187",
"0.7873242",
"0.7846093",
"0.7717508",
"0.7700298",
"0.7663556",
"0.76379234",
"0.75356364",
"0.7519973",
"0.7475285",
"0.74681747",
"0.74621254",
"0.7447179",
"0.74322003",
"0.74192196",
"0.7402269",
"0.7398234",
"0.7384707... | 0.81088334 | 0 |
Close the socket and clear the current host and port details. | def cleanup(self):
try:
self.socket.close()
except:
pass # ignore errors when attempting to close socket
self.socket = None
self.current_host_and_port = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close(self):\n print('Closing server socket (host {}, port {})'.format(self.host, self.port))\n if self.sock:\n self.sock.close()\n self.sock = None",
"def close(self):\n self.socket.close()",
"def close(self):\n self.socket.close()",
"def close(self):\n ... | [
"0.75493366",
"0.747122",
"0.747122",
"0.747122",
"0.747122",
"0.747122",
"0.747122",
"0.7457175",
"0.7457175",
"0.7422063",
"0.7360431",
"0.73594326",
"0.7347399",
"0.7302408",
"0.72775865",
"0.7206107",
"0.71936274",
"0.7185615",
"0.7109103",
"0.7105997",
"0.70846534",
"0... | 0.779209 | 0 |
Try connecting to the (host, port) tuples specified at construction time. | def attempt_connection(self):
self.connection_error = False
sleep_exp = 1
connect_count = 0
while self.running and self.socket is None and connect_count < self.__reconnect_attempts_max:
for host_and_port in self.__hosts_and_ports:
try:
log.info("Attempting connection to websocket %s", host_and_port)
self.socket = websocket.WebSocket()
proto, host, port, path = host_and_port[3], host_and_port[0], host_and_port[1], host_and_port[2]
if port:
ws_uri = '{}://{}:{}/{}'.format(proto, host, port, path)
else:
ws_uri = '{}://{}/{}'.format(proto, host, path)
self.socket.connect(ws_uri,
timeout=self.__timeout)
self.current_host_and_port = host_and_port
log.info("Established connection to %s", ws_uri)
break
except WebSocketException:
self.socket = None
connect_count += 1
log.warning("Could not connect to host %s, port %s", host_and_port[0], host_and_port[1], exc_info=1)
if self.socket is None:
sleep_duration = (min(self.__reconnect_sleep_max,
((self.__reconnect_sleep_initial / (1.0 + self.__reconnect_sleep_increase))
* math.pow(1.0 + self.__reconnect_sleep_increase, sleep_exp)))
* (1.0 + random.random() * self.__reconnect_sleep_jitter))
sleep_end = monotonic() + sleep_duration
log.debug("Sleeping for %.1f seconds before attempting reconnect", sleep_duration)
while self.running and monotonic() < sleep_end:
time.sleep(0.2)
if sleep_duration < self.__reconnect_sleep_max:
sleep_exp += 1
if not self.socket:
raise exception.ConnectFailedException() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self, host, port):\n pass",
"def connect(self):\n \n try:\n self.__sock.connect((self.__host, self.__port))\n\n except socket.error,e:\n print 'Oops, unable to connect. Try again!',e\n sys.exit(1)",
"async def _connect(self, host_loc):\n ... | [
"0.73735076",
"0.69012636",
"0.6894325",
"0.6791065",
"0.67294514",
"0.6698651",
"0.66936195",
"0.665516",
"0.6614224",
"0.66082466",
"0.6591837",
"0.65764606",
"0.65412575",
"0.64659244",
"0.64588004",
"0.642933",
"0.6411092",
"0.64094645",
"0.63941145",
"0.6381039",
"0.6369... | 0.0 | -1 |
Call the protocol disconnection, and then stop the transport itself. | def disconnect(self, receipt=None, headers=None, **keyword_headers):
Protocol11.disconnect(self, receipt, headers, **keyword_headers)
self.transport.stop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop(self):\n self._transport = None\n self._cleanup()\n self._disconnected_callback = None",
"def transportProtocolDisconnected(self, obj):\n if obj:\n log.msg(\"Protocol disconnected, losing connection..\")\n self.connection.loseConnection()\n tr... | [
"0.76196885",
"0.73054206",
"0.7146738",
"0.7062836",
"0.70271856",
"0.6989695",
"0.6907226",
"0.6885972",
"0.6851431",
"0.67708176",
"0.6740143",
"0.6737467",
"0.6714717",
"0.6714717",
"0.66998696",
"0.6699246",
"0.6678658",
"0.66435677",
"0.66178954",
"0.66106606",
"0.66057... | 0.633989 | 47 |
Returns the network connected to the tenant router. Assumes a single router with a single tenant network connected. | def _tenant_network(self):
port = self._connection.network.ports.find_by_device_owner('network:router_interface')
if port:
return self._connection.network.networks.get(port.network_id)
else:
raise errors.ImproperlyConfiguredError('Could not find tenancy network') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _external_network(self):\n try:\n router = next(self._connection.network.routers.all())\n except StopIteration:\n raise errors.ImproperlyConfiguredError('Could not find tenancy router.')\n return self._connection.network.networks.get(router.external_gateway_info['netw... | [
"0.77449316",
"0.7281764",
"0.7092121",
"0.70122546",
"0.6769052",
"0.6733666",
"0.6733666",
"0.6733666",
"0.6582788",
"0.65117043",
"0.6201502",
"0.61733115",
"0.6108502",
"0.60738486",
"0.60403067",
"0.6020271",
"0.600645",
"0.5939682",
"0.5937701",
"0.5896336",
"0.58795285... | 0.796581 | 0 |
Returns the external network that connects the tenant router to the outside world. | def _external_network(self):
try:
router = next(self._connection.network.routers.all())
except StopIteration:
raise errors.ImproperlyConfiguredError('Could not find tenancy router.')
return self._connection.network.networks.get(router.external_gateway_info['network_id']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _tenant_network(self):\n port = self._connection.network.ports.find_by_device_owner('network:router_interface')\n if port:\n return self._connection.network.networks.get(port.network_id)\n else:\n raise errors.ImproperlyConfiguredError('Could not find tenancy network'... | [
"0.7765178",
"0.7262986",
"0.6995677",
"0.6902639",
"0.6894767",
"0.67648536",
"0.6673926",
"0.66279644",
"0.6617179",
"0.6617179",
"0.6617179",
"0.64150774",
"0.64139897",
"0.6407208",
"0.63487035",
"0.6331511",
"0.6266315",
"0.6229477",
"0.6182302",
"0.6143386",
"0.61390054... | 0.8163727 | 0 |
Returns the cluster manager for the tenancy. | def cluster_manager(self):
# Lazily instantiate the cluster manager the first time it is asked for.
if not hasattr(self, '_cluster_manager'):
if self._cluster_engine:
self._cluster_manager = self._cluster_engine.create_manager(
self._username,
self._tenancy
)
else:
self._cluster_manager = None
# If there is still no cluster manager, clusters are not supported
if not self._cluster_manager:
raise errors.UnsupportedOperationError(
'Clusters are not supported for this tenancy.'
)
return self._cluster_manager | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetManager(self):\r\n\r\n return self.manager",
"def cluster(self):\n return self._cluster",
"def cluster(self):\n return self._cluster",
"def get_manager(api_version=None):\n from manager import get_keystone_manager\n return get_keystone_manager(get_local_endpoint(), get_admin... | [
"0.66724825",
"0.665754",
"0.665754",
"0.66434646",
"0.663374",
"0.6481853",
"0.6345078",
"0.6344062",
"0.62795883",
"0.6278968",
"0.62144953",
"0.60009164",
"0.59885573",
"0.5977996",
"0.59189504",
"0.5905458",
"0.5904256",
"0.5867709",
"0.5859221",
"0.58005214",
"0.5737495"... | 0.85531485 | 0 |
Fix up the cluster with any OpenStackspecific changes. | def _fixup_cluster(self, cluster):
# Remove injected parameters from the cluster params
params = {
k: v
for k, v in cluster.parameter_values.items()
if k != 'cluster_network'
}
# Add any tags attached to the stack
try:
stack = self._connection.orchestration.stacks.find_by_stack_name(cluster.name)
except rackit.NotFound:
stack = None
# We use this format because tags might exist on the stack but be None
stack_tags = tuple(getattr(stack, 'tags', None) or [])
original_error = (cluster.error_message or '').lower()
# Convert quota-related error messages based on known OpenStack errors
if any(m in original_error for m in {'quota exceeded', 'exceedsavailablequota'}):
if 'floatingip' in original_error:
error_message = (
'Could not find an external IP for deployment. '
'Please ensure an external IP is available and try again.'
)
else:
error_message = (
'Requested resources exceed at least one quota. '
'Please check your tenancy quotas and try again.'
)
elif cluster.error_message:
error_message = (
'Error during cluster configuration. '
'Please contact support.'
)
else:
error_message = None
return cluster._replace(
parameter_values = params,
tags = cluster.tags + stack_tags,
error_message = error_message
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def two_clusters_reconfiguration(self):\n\n self.show_step(1)\n self.env.revert_snapshot(\"ready_with_5_slaves\")\n\n self.show_step(2)\n cluster_id_1 = self.fuel_web.create_cluster(\n name=\"env1\",\n mode=settings.DEPLOYMENT_MODE,\n settings={\n ... | [
"0.656177",
"0.6422964",
"0.64025843",
"0.61629826",
"0.61626065",
"0.60646015",
"0.6063085",
"0.6026249",
"0.59341043",
"0.59069663",
"0.5800315",
"0.57841843",
"0.57784903",
"0.5644694",
"0.5628729",
"0.5616941",
"0.56099975",
"0.56072444",
"0.55292267",
"0.5507146",
"0.549... | 0.5728941 | 13 |
Route for front end to obtain the data for the Location of choice. | async def location_data(location: LocationDataRequest):
# Make sure location paramater is a string in the form of "City, State"
location = str(location)
location = location.replace('location=', "")
location = location.replace("'", "")
# Queries for data response
#pop_query = """SELECT "2019 Population" FROM CitySpire WHERE "Location" = %s""", [location]
#rent_query = """SELECT "2019 Rental Rates" FROM CitySpire WHERE "Location" = %s""", [location]
#walk_query = """SELECT "2019 Walk Score" FROM CitySpire WHERE "Location" = %s""", [location]
#live_query = """SELECT "2019 Livability Score" FROM CitySpire WHERE "Location" = %s""", [location]
cursor.execute("""SELECT "2019 Population" FROM cityspire WHERE "Location" = %s;""", [location])
pop = cursor.fetchone()
#pop = pop[0][0] # This is slice slice the tuple value from the list of tuples
cursor.execute("""SELECT "2019 Rental Rates" FROM cityspire WHERE "Location" = %s;""", [location])
rent = cursor.fetchone()
#rent = rent[0][0] # This is slice slice the tuple value from the list of tuples
cursor.execute("""SELECT "Walk Score" FROM cityspire WHERE "Location" = %s;""", [location])
walk = cursor.fetchone()
#walk = walk[0][0] # This is slice slice the tuple value from the list of tuples
cursor.execute("""SELECT "Livability Score" FROM cityspire WHERE "Location" = %s;""", [location])
live = cursor.fetchone()
#live = live[0][0] # This is slice slice the tuple value from the list of tuples
# Close the cursor and connection (this breaks the API)
#cursor.close()
#connection.close()
# Return the data that was requested and queried
return {
"city_name": str(location),
"population": int(pop[0]),
"rent_per_month": int(rent[0]),
"walk_score": int(walk[0]),
"livability_score": int(live[0])
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_location(self):\n return self.request({\n \"path\": \"/\" + UUID + \"/location\"\n })",
"def carslocation():\n # Check if user is loggedin\n if 'loggedin' in session:\n\n response = requests.get(\"http://localhost:8080/api/carslocation\")\n print(response.text... | [
"0.6643356",
"0.6501124",
"0.62959623",
"0.6232448",
"0.62138563",
"0.6093613",
"0.60217726",
"0.59801704",
"0.59584683",
"0.58436835",
"0.5829568",
"0.57859164",
"0.577833",
"0.5771708",
"0.56856674",
"0.56406236",
"0.5606987",
"0.5575436",
"0.55724984",
"0.5565517",
"0.5565... | 0.52397954 | 64 |
Computes the forward pass for a fullyconnected layer. The input x has shape (N, Din) and contains a minibatch of N examples, where each example x[i] has shape (Din,). | def fc_forward(x, w, b):
out = None
###########################################################################
# TODO: Implement the forward pass. Store the result in out. #
###########################################################################
N = x.shape[0]
x2d = x.reshape(N, -1)
out = x2d.dot(w) + b
###########################################################################
# END OF YOUR CODE #
###########################################################################
cache = (x, w, b)
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x): \n # Layer 1\n x = F.elu(self.conv1(x)) # bsize x l1_channels x 1 x Nsamples\n x = self.batchnorm1(x)\n x = F.dropout(x, 0.25)\n x = x.permute(0, 2, 1, 3) # bsize x 1 x l1_channels x Nsamples\n\n # Layer 2\n x = ... | [
"0.7153318",
"0.6853486",
"0.682324",
"0.67808783",
"0.6726576",
"0.67157876",
"0.66740847",
"0.66715527",
"0.6665411",
"0.6663272",
"0.6636702",
"0.66286105",
"0.6605179",
"0.65966856",
"0.6590063",
"0.65451944",
"0.6540172",
"0.6539711",
"0.6511885",
"0.64758414",
"0.645289... | 0.0 | -1 |
Computes the backward pass for a fully_connected layer. | def fc_backward(dout, cache):
x, w, b = cache
dx, dw, db = None, None, None
###########################################################################
# TODO: Implement the affine backward pass. #
###########################################################################
N = x.shape[0]
x2d = x.reshape(N, -1)
dx = dout.dot(w.T)
dx = dx.reshape(x.shape)
dw = x2d.T.dot(dout)
db = dout.sum(axis=0) #add from top to down
###########################################################################
# END OF YOUR CODE #
###########################################################################
return dx, dw, db | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward_pass(self):\r\n # the gradient of cross-entropy on top of softmax is (t-y)\r\n back_output = (self.targets - self.y) / self.y.shape[0]\r\n\r\n for layer in reversed(self.layers):\r\n back_output = layer.backward_pass(back_output)",
"def backward_pass(self, loss):\n\n ... | [
"0.75506145",
"0.74210715",
"0.708932",
"0.7074831",
"0.7008279",
"0.69728214",
"0.6948082",
"0.69344884",
"0.69324756",
"0.6914606",
"0.6914606",
"0.687406",
"0.68707025",
"0.68107206",
"0.67995775",
"0.67714584",
"0.67714584",
"0.67669773",
"0.67323184",
"0.67095137",
"0.67... | 0.6278595 | 73 |
Computes the forward pass for a layer of rectified linear units (ReLUs). | def relu_forward(x):
out = None
###########################################################################
# TODO: Implement the ReLU forward pass. #
###########################################################################
#out = np.zeros(x.shape)
#np.clip(x, 0, None, out)
out = np.empty_like(x) #faster than zeros
np.clip(x, 0, None, out)
#out = x
#out [out < 0] = 0
#print(x)
#print(out)
###########################################################################
# END OF YOUR CODE #
###########################################################################
cache = x
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_relus(self):\n\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n ... | [
"0.6775336",
"0.6629373",
"0.6602302",
"0.6523369",
"0.6508466",
"0.64465874",
"0.63842785",
"0.626676",
"0.620465",
"0.6178559",
"0.61525744",
"0.613782",
"0.60611176",
"0.6054329",
"0.6047199",
"0.6046748",
"0.59962803",
"0.5989819",
"0.596913",
"0.5962442",
"0.5948833",
... | 0.60177517 | 16 |
Computes the backward pass for a layer of rectified linear units (ReLUs). | def relu_backward(dout, cache):
dx, x = None, cache
###########################################################################
# TODO: Implement the ReLU backward pass. #
###########################################################################
#print(dout)
dx = np.empty_like(dout)
np.copyto(dx, dout)
dx[x < 0] = 0
#print(dx)
###########################################################################
# END OF YOUR CODE #
###########################################################################
return dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relu_backward(self, dUpper, cache):\n x = cache\n #############################################################################\n # TODO: Implement the ReLU backward pass. #\n #########################################################################... | [
"0.70412636",
"0.694716",
"0.6897693",
"0.6847592",
"0.6847592",
"0.6846935",
"0.6841099",
"0.68178034",
"0.6766849",
"0.6754919",
"0.67536426",
"0.67530656",
"0.67419785",
"0.6739244",
"0.6713423",
"0.6708748",
"0.6699276",
"0.6696307",
"0.6696307",
"0.66860896",
"0.6665928"... | 0.66615254 | 25 |
Forward pass for batch normalization. During training the sample mean and (uncorrected) sample variance are computed from minibatch statistics and used to normalize the incoming data. During training we also keep an exponentially decaying running mean of the mean and variance of each feature, and these averages are used to normalize data at testtime. At each timestep we update the running averages for mean and variance using | def batchnorm_forward(x, gamma, beta, bn_param):
mode = bn_param['mode']
eps = bn_param.get('eps', 1e-5)
momentum = bn_param.get('momentum', 0.9)
N, D = x.shape
running_mean = bn_param.get('running_mean', np.zeros(D, dtype=x.dtype))
running_var = bn_param.get('running_var', np.zeros(D, dtype=x.dtype))
out, cache = None, None
mu = np.mean(x, axis=0)
var = np.var(x, axis=0)
sigma = np.sqrt(var+eps)
if mode == 'train':
#######################################################################
# TODO: Implement the training-time forward pass for batch norm. #
# Use minibatch statistics to compute the mean and variance, use #
# these statistics to normalize the incoming data, and scale and #
# shift the normalized data using gamma and beta. #
# #
# You should store the output in the variable out. Any intermediates #
# that you need for the backward pass should be stored in the cache #
# variable. #
# #
# You should also use your computed sample mean and variance together #
# with the momentum variable to update the running mean and running #
# variance, storing your result in the running_mean and running_var #
# variables. #
# #
# Note that though you should be keeping track of the running #
# variance, you should normalize the data based on the standard #
# deviation (square root of variance) instead! #
# Referencing the original paper (https://arxiv.org/abs/1502.03167) #
# might prove to be helpful. #
#######################################################################
out = gamma * (x - mu)/sigma + beta
#out = (x - mu)/sigma
#out = out * gamma.T + beta.T
#print(gamma.shape)
#out = out * gamma + beta
#print(out.shape)
running_mean = momentum * running_mean + (1 - momentum) * mu
running_var = momentum * running_var + (1 - momentum) * (var+eps)
#######################################################################
# END OF YOUR CODE #
#######################################################################
elif mode == 'test':
#######################################################################
# TODO: Implement the test-time forward pass for batch normalization. #
# Use the running mean and variance to normalize the incoming data, #
# then scale and shift the normalized data using gamma and beta. #
# Store the result in the out variable. #
#######################################################################
out = (x - running_mean) / np.sqrt(running_var) * gamma + beta
#######################################################################
# END OF YOUR CODE #
#######################################################################
else:
raise ValueError('Invalid forward batchnorm mode "%s"' % mode)
# Store the updated running means back into bn_param
bn_param['running_mean'] = running_mean
bn_param['running_var'] = running_var
cache = (x, mu, sigma, gamma, beta)
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(self, x, train=True):\n if train is not None:\n mean, variance = tf.nn.moments(x, [0,1,2])\n assign_mean = self.mean.assign(mean)\n assign_variance = self.variance.assign(variance)\n with tf.control_dependencies([assign_mean, assign_variance]):\n return tf.nn.batch_norm_... | [
"0.73375744",
"0.7016016",
"0.69402426",
"0.6930308",
"0.6890035",
"0.6870713",
"0.6845096",
"0.6766321",
"0.67575425",
"0.6714171",
"0.67051464",
"0.6647627",
"0.65995526",
"0.65970504",
"0.65763676",
"0.6518246",
"0.6511042",
"0.6459731",
"0.64524907",
"0.64098454",
"0.6387... | 0.6935189 | 3 |
Backward pass for batch normalization. For this implementation, you should write out a computation graph for batch normalization on paper and propagate gradients backward through intermediate nodes. | def batchnorm_backward(dout, cache):
dx, dgamma, dbeta = None, None, None
###########################################################################
# TODO: Implement the backward pass for batch normalization. Store the #
# results in the dx, dgamma, and dbeta variables. #
# Referencing the original paper (https://arxiv.org/abs/1502.03167) #
# might prove to be helpful. #
###########################################################################
x, mu, sigma, gamma, beta = cache
N = dout.shape[0]
X_mu = x - mu
var_inv = 1./sigma
dX_norm = dout * gamma
dvar = np.sum(dX_norm * X_mu,axis=0) * -0.5 * sigma**(-3)
dmu = np.sum(dX_norm * -var_inv ,axis=0) + dvar * 1/N * np.sum(-2.* X_mu, axis=0)
dx = (dX_norm * var_inv) + (dmu / N) + (dvar * 2/N * X_mu)
dbeta = np.sum(dout, axis=0)
dgamma = np.sum(dout * X_mu/sigma, axis=0)
###########################################################################
# END OF YOUR CODE #
###########################################################################
return dx, dgamma, dbeta | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batchnorm_backward(dout, cache):\n dx, dgamma, dbeta = None, None, None\n ###########################################################################\n # TODO: Implement the backward pass for batch normalization. Store the #\n # results in the dx, dgamma, and dbeta variables. ... | [
"0.71418196",
"0.6997701",
"0.6994699",
"0.69764066",
"0.69122756",
"0.6845697",
"0.68414086",
"0.67535686",
"0.6739037",
"0.65906703",
"0.6587759",
"0.6582729",
"0.65654385",
"0.65509117",
"0.65476483",
"0.6520883",
"0.65095323",
"0.65002865",
"0.647348",
"0.6422956",
"0.641... | 0.6634307 | 9 |
Performs the forward pass for dropout. | def dropout_forward(x, dropout_param):
p, mode = dropout_param['p'], dropout_param['mode']
if 'seed' in dropout_param:
np.random.seed(dropout_param['seed'])
mask = None
out = None
if mode == 'train':
#######################################################################
# TODO: Implement training phase forward pass for inverted dropout. #
# Store the dropout mask in the mask variable. #
#######################################################################
mask = np.random.random_sample(x.shape)
mask = mask < p
out = x * mask
#######################################################################
# END OF YOUR CODE #
#######################################################################
elif mode == 'test':
#######################################################################
# TODO: Implement the test phase forward pass for inverted dropout. #
#######################################################################
out = np.empty_like(x)
np.copyto(out,x)
#######################################################################
# END OF YOUR CODE #
#######################################################################
cache = (dropout_param, mask)
out = out.astype(x.dtype, copy=False)
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward( self, x ):\n x = x + self.pe[ :x.size(0), : ]\n return self.dropout( x )",
"def forward(self, x):\n x = x + self.pe[: x.size(0), :]\n return self.dropout(x)",
"def forward(self, x):\n\n x = x + self.pe[:x.size(0), :]\n return self.dropout(x)",
"d... | [
"0.6779948",
"0.66298467",
"0.6543176",
"0.6543176",
"0.6543176",
"0.6543176",
"0.65413773",
"0.64989567",
"0.64989567",
"0.6470937",
"0.64692926",
"0.64219373",
"0.6366126",
"0.635455",
"0.6328682",
"0.6312325",
"0.6288312",
"0.623391",
"0.623391",
"0.623391",
"0.6223676",
... | 0.6543027 | 6 |
Perform the backward pass for dropout. | def dropout_backward(dout, cache):
dropout_param, mask = cache
mode = dropout_param['mode']
dx = None
if mode == 'train':
#######################################################################
# TODO: Implement training phase backward pass for inverted dropout #
#######################################################################
dx = dout * mask
#######################################################################
# END OF YOUR CODE #
#######################################################################
elif mode == 'test':
dx = dout
return dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dropout_backward(dout, cache):\n dropout_param, mask = cache\n mode = dropout_param['mode']\n p = dropout_param['p']\n dx = None\n if mode == 'train':\n #######################################################################\n # TODO: Implement training phase backward pass for inve... | [
"0.7518181",
"0.7460461",
"0.74584544",
"0.7332788",
"0.7288746",
"0.71464086",
"0.7143232",
"0.69664955",
"0.69397676",
"0.69232845",
"0.69232845",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345",
"0.6907345... | 0.7471565 | 2 |
The input consists of N data points, each with C channels, height H and width W. We convolve each input with F different filters, where each filter spans all C channels and has height HH and width WW. Assume that stride=1 and there is no padding. You can ignore the bias term in your implementation. | def conv_forward(x, w):
out = None
###########################################################################
# TODO: Implement the convolutional forward pass. #
# Hint: you can use the function np.pad for padding. #
###########################################################################
N, C, H, W = x.shape
F, C, HH, WW = w.shape
H_prime = H - (HH - 1)
W_prime = W - (WW - 1)
out = np.zeros((N, F, H_prime, W_prime))
for n in range(N):
for f in range(F):
for i in range(H_prime):
for j in range(W_prime):
out[n, f, i, j] = np.sum(x[n, :, i:i+HH, j:j+WW] * w[f])
###########################################################################
# END OF YOUR CODE #
###########################################################################
cache = (x, w)
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop_conv(X, W):\n # Go over all five dimensions \n # (#batches x #channels x #height x #width x #dur/length )\n # with filter that has\n # #filters x #channels x #height x #width x #dur/length \n num_filters = W.shape[0]\n filt_channels = W.shape[1]\n filt_height = W.shape[2]\n filt_wi... | [
"0.77974457",
"0.68532217",
"0.6843606",
"0.68252665",
"0.6792097",
"0.6787238",
"0.6778164",
"0.6764888",
"0.67277294",
"0.66646516",
"0.6578862",
"0.65779644",
"0.6572897",
"0.65086555",
"0.64898103",
"0.6478974",
"0.6441421",
"0.64312285",
"0.6427597",
"0.6360412",
"0.6359... | 0.62824273 | 27 |
A naive implementation of the forward pass for a maxpooling layer. | def max_pool_forward(x, pool_param):
out = None
###########################################################################
# TODO: Implement the max-pooling forward pass #
###########################################################################
N, C, H, W = x.shape
pool_height = pool_param['pool_height']
pool_width = pool_param['pool_width']
stride = pool_param['stride']
H_prime = int(1 + (H - pool_height) / stride)
W_prime = int(1 + (W - pool_width) / stride) #python 3 / is just float number division
out = np.zeros((N,C,H_prime,W_prime))
for n in range(N):
for i in range(H_prime):
for j in range(W_prime):
h_start = i * stride
h_end = h_start + pool_height
w_start = j * stride
w_end = w_start + pool_width
pool_window = x[n, :, h_start:h_end, w_start:w_end]
pool_window = pool_window.reshape((C,-1))
out[n,:,i,j] = np.max(pool_window, axis=1)
###########################################################################
# END OF YOUR CODE #
###########################################################################
cache = (x, pool_param)
return out, cache | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_pool_forward_naive(x, pool_param):\n out = None\n ###########################################################################\n # TODO: Implement the max pooling forward pass #\n ###########################################################################\n N,C,H,W ... | [
"0.78478473",
"0.77464086",
"0.7588915",
"0.75831836",
"0.75474185",
"0.74184185",
"0.7378611",
"0.7318571",
"0.72232896",
"0.71326613",
"0.7098723",
"0.70758176",
"0.6990659",
"0.69255495",
"0.69221073",
"0.68792313",
"0.68130654",
"0.68058133",
"0.6792034",
"0.6792034",
"0.... | 0.74050933 | 6 |
A naive implementation of the backward pass for a maxpooling layer. | def max_pool_backward(dout, cache):
dx = None
###########################################################################
# TODO: Implement the max-pooling backward pass #
###########################################################################
x, pool_param = cache
N, C, H, W = x.shape
pool_height = pool_param['pool_height']
pool_width = pool_param['pool_width']
stride = pool_param['stride']
H_prime = int(1 + (H - pool_height) / stride)
W_prime = int(1 + (W - pool_width) / stride) #python 3 / is just float number division
dx = np.zeros((N, C, H, W))
for n in range(N):
for c in range(C):
for i in range(H_prime):
for j in range(W_prime):
h_start = i * stride
h_end = h_start + pool_height
w_start = j * stride
w_end = w_start + pool_width
pool_window = x[n, c, h_start:h_end, w_start:w_end]
maxValue = np.max(pool_window)
dx[n,c,h_start:h_end,w_start:w_end] += dout[n,c,i,j] * (pool_window == maxValue)
###########################################################################
# END OF YOUR CODE #
###########################################################################
return dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_pool_backward_naive(dout, cache):\n dx = None\n #############################################################################\n # TODO: Implement the max pooling backward pass #\n #############################################################################\n pass\n ######... | [
"0.78717184",
"0.7527569",
"0.74360836",
"0.742322",
"0.74153745",
"0.74050575",
"0.736715",
"0.73291767",
"0.71188295",
"0.71188295",
"0.7104715",
"0.7095607",
"0.7016401",
"0.69276273",
"0.6922222",
"0.68295985",
"0.67844594",
"0.67377377",
"0.6726962",
"0.6720057",
"0.6710... | 0.73897725 | 6 |
Computes the loss and gradient for binary SVM classification. | def svm_loss(x, y):
N = x.shape[0]
x = np.squeeze(x)
loss = np.sum(((1-x*y)>0)*(1-x*y))/N
dx = ((1-x*y)>0)*(-y)/N
return loss, dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svm_loss(x, y):\n loss, dx = None, None\n ###########################################################################\n # TODO: Implement loss and gradient for multiclass SVM classification. #\n # This will be similar to the svm loss vectorized implementation in #\n # cs231n/classifiers... | [
"0.7909253",
"0.7767066",
"0.7405515",
"0.7281215",
"0.7261097",
"0.7241102",
"0.7210721",
"0.7159015",
"0.7136917",
"0.7069623",
"0.70671463",
"0.7060711",
"0.7044991",
"0.69557554",
"0.6928465",
"0.6869657",
"0.68506974",
"0.6844779",
"0.6830456",
"0.6820079",
"0.67838556",... | 0.6714259 | 21 |
Computes the loss and gradient for binary classification with logistic regression. | def logistic_loss(x, y):
N = x.shape[0]
x = np.squeeze(x)
y_prime = (y + 1)/2
h = 1 /(1 + np.exp(-x))
loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N
dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N
return loss, dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logistic(weights, data, targets, hyperparameters):\n y = logistic_predict(weights, data)\n\n #####################################################################\n # TODO: #\n # Given weights and data, return the averaged loss over all da... | [
"0.70904523",
"0.7072484",
"0.6969767",
"0.6957916",
"0.6951513",
"0.6896685",
"0.68876517",
"0.683848",
"0.6820088",
"0.6813277",
"0.68107325",
"0.6786551",
"0.6774134",
"0.6744257",
"0.6732447",
"0.673168",
"0.6722383",
"0.67222416",
"0.6706524",
"0.66843295",
"0.66585207",... | 0.6678023 | 20 |
Computes the loss and gradient for softmax classification. | def softmax_loss(x, y):
N, C = x.shape
loss, dx = 0, np.zeros(x.shape)
for i in range(N):
loss += -np.log(np.exp(x[i,y[i]])/np.sum(np.exp(x[i,:])))
dx[i,:] = np.exp(x[i,:])/np.sum(np.exp(x[i,:]))
dx[i,y[i]] += (-1)
loss /= N
dx /= N
return loss, dx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ==================================================... | [
"0.8163197",
"0.7849804",
"0.7754222",
"0.7720902",
"0.7686208",
"0.7658823",
"0.7655289",
"0.75943136",
"0.75897485",
"0.75817245",
"0.758024",
"0.75620025",
"0.753615",
"0.7510059",
"0.7506491",
"0.75061125",
"0.7504011",
"0.74645996",
"0.73846763",
"0.7381628",
"0.7378212"... | 0.6929496 | 54 |
When cache is enabled, records the current request response json content in the cache file. | def set_cached_response(self) -> None:
if self.get_caching_duration() > 0: # if caching is enabled for this request
json_response = self._request_result.json()
with open(self.cache_file_name, 'w') as json_file:
json.dump(json_response, json_file, indent=4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache():\n if request.method == 'GET':\n cache_info = in_water.cache_info()\n return json.dumps({\n 'hits': cache_info.hits,\n 'misses': cache_info.misses,\n 'maxsize': cache_info.maxsize,\n 'currsize': cache_info.currsize,\n })",
"def saveC... | [
"0.7289211",
"0.71144605",
"0.7006052",
"0.68958193",
"0.688203",
"0.68352675",
"0.66610754",
"0.6637904",
"0.6591506",
"0.6493748",
"0.64900154",
"0.6430256",
"0.6393354",
"0.62931097",
"0.6260045",
"0.62439954",
"0.62336665",
"0.6196039",
"0.6179128",
"0.615851",
"0.6150054... | 0.83422124 | 0 |
Method processing the json content of a request, and returning a valid RestoRequestResult. | def process_json_result(self, json_result: dict) -> RestoRequestResult:
try:
resto_response = self.resto_response_cls(self, json_result)
except RestoResponseError:
msg = 'Response to {} from {} resto server cannot be understood.'
# TOOD: move elsewhere ?
raise IncomprehensibleResponse(msg.format(self.get_server_name()))
return resto_response.as_resto_object() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process(self, request, processor, operation):\n \n params = request.REQUEST.get('json', None)\n if params is None :\n params = ApiFacade._convertMergeDict(request.REQUEST)\n else :\n params=params\n params = json.loads(params)\n \n resp_bo... | [
"0.60520667",
"0.5982503",
"0.585078",
"0.5832222",
"0.5702895",
"0.5620679",
"0.55594456",
"0.55570936",
"0.555036",
"0.547908",
"0.54710627",
"0.54656655",
"0.542057",
"0.54201967",
"0.54093033",
"0.5404972",
"0.53861696",
"0.534103",
"0.534082",
"0.5264856",
"0.5264153",
... | 0.6597384 | 0 |
Recommended maximum number of datapoints Returns int | def recommended_max_num_datapoints(self) -> int:
# very large number, essentially no limit by default
return 1e9 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def graph_data_size_max(self) -> int:\n return int(self.graph_tuple_stats.graph_data_size_max or 0)",
"def get_minimum_number_of_data_points(cls):\n return cls._MINIMUM_NUMBER_OF_DATA_POINTS",
"def numberOfPoints(self):\n return 20000",
"def data_edge_count_max(self) -> int:\n return int(... | [
"0.74292016",
"0.74018806",
"0.7281152",
"0.7237732",
"0.7090521",
"0.6958116",
"0.6913622",
"0.68758655",
"0.6854837",
"0.68302363",
"0.67935854",
"0.6772748",
"0.6769792",
"0.67452073",
"0.67428017",
"0.67161715",
"0.66959566",
"0.668196",
"0.66803277",
"0.6658686",
"0.6651... | 0.87322336 | 0 |
Fits function y=f(x) given training pairs (x_train, y_train). | def _fit(self, x_train, y_train, x_valid, y_valid, regressor_callback=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, X, y):",
"def train(self, x_train, y_train, x_val, y_val):\n pass",
"def train(self, X, y):\n pass",
"def train(self, X, y):\n lagrange_multipliers = self._compute_multipliers(X, y)\n return self._construct_predictor(X, y, lagrange_multipliers)",
"def fit(self, X... | [
"0.7322144",
"0.71384645",
"0.71244806",
"0.69531596",
"0.6825773",
"0.6776183",
"0.6776183",
"0.67015135",
"0.6648316",
"0.6648316",
"0.6648316",
"0.66165537",
"0.6569884",
"0.65607",
"0.64630246",
"0.6440666",
"0.6422532",
"0.6422532",
"0.63722926",
"0.6364112",
"0.6359813"... | 0.6362209 | 20 |
Fits function y=f(x) given training pairs (x_train, y_train). | def fit(
self, x_train, y_train, x_valid=None, y_valid=None, regressor_callback=None
):
has_more_than_one_channel = len(y_train.shape) > 1
if x_valid is None:
x_valid = x_train
y_valid = y_train
# to the multi-channel form, but with just one chanel;
if not has_more_than_one_channel:
y_train = y_train[numpy.newaxis, ...]
y_valid = y_valid[numpy.newaxis, ...]
self.models = []
self._stop_fit = False
for y_train_channel, y_valid_channel in zip(y_train, y_valid):
gc.collect()
model_channel = self._fit(
x_train, y_train_channel, x_valid, y_valid_channel, regressor_callback
)
self.models.append(model_channel)
self.loss_history.append(model_channel.loss_history)
self.num_channels = len(self.models) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, X, y):",
"def train(self, x_train, y_train, x_val, y_val):\n pass",
"def train(self, X, y):\n pass",
"def train(self, X, y):\n lagrange_multipliers = self._compute_multipliers(X, y)\n return self._construct_predictor(X, y, lagrange_multipliers)",
"def fit(self, X... | [
"0.73206455",
"0.7135874",
"0.7122955",
"0.6952598",
"0.682414",
"0.6773915",
"0.6773915",
"0.6700229",
"0.6648014",
"0.6648014",
"0.6648014",
"0.66138375",
"0.65697306",
"0.6558614",
"0.64612556",
"0.6438456",
"0.6420302",
"0.6420302",
"0.6370733",
"0.6363991",
"0.6362005",
... | 0.0 | -1 |
Stops training (can be called by another thread) | def stop_fit(self):
self._stop_fit = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_training(self):\n self.training = False",
"def stop_training_job(TrainingJobName=None):\n pass",
"def stop(self):\n self.requested_state = 'Stopped'\n self.ml_interface.stop()",
"def stop(self):\n self._state.transit(sitcpy.THREAD_STOPPING)",
"def stop(self):\n ... | [
"0.8000698",
"0.759568",
"0.73393655",
"0.72586185",
"0.72586185",
"0.71302235",
"0.7112129",
"0.70853776",
"0.7046241",
"0.70452595",
"0.70376647",
"0.70376647",
"0.70227903",
"0.70227903",
"0.70227903",
"0.70227903",
"0.7018452",
"0.70008683",
"0.70008683",
"0.69937384",
"0... | 0.0 | -1 |
Saves an 'allbatteriesincluded' regressor at a given path (folder). | def save(self, path: str):
os.makedirs(path, exist_ok=True)
frozen = encode_indent(self)
lprint(f"Saving regressor to: {path}")
with open(join(path, "regressor.json"), "w") as json_file:
json_file.write(frozen)
for i, model in enumerate(self.models):
channel_path = join(path, f"channel{i}")
os.makedirs(channel_path, exist_ok=True)
frozen_model = encode_indent(model)
with open(join(channel_path, "regressor_model.json"), "w") as json_file:
json_file.write(frozen_model)
model._save_internals(channel_path)
return frozen | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, folder):\n self.generator.save_weights('%s/generator.h5'%folder)\n self.critic.save_weights('%s/critic.h5'%folder)",
"def save(self, path):\n individual = self.population.fittest_individual()\n order = [int(l) for l in individual.label_order]\n fitness = individu... | [
"0.56438905",
"0.5583958",
"0.5536748",
"0.5505436",
"0.5465258",
"0.5457156",
"0.5457156",
"0.5457156",
"0.5444318",
"0.54246444",
"0.54233265",
"0.5392205",
"0.53767943",
"0.53724295",
"0.5370799",
"0.5340823",
"0.5336824",
"0.53367984",
"0.5329921",
"0.5313599",
"0.530012"... | 0.59676516 | 0 |
Returns an 'allbatteriesincluded' regressor from a given path (folder). | def load(path: str):
lprint(f"Loading regressor from: {path}")
with open(join(path, "regressor.json"), "r") as json_file:
frozen = json_file.read()
thawed = jsonpickle.decode(frozen)
thawed.models = []
for i in range(thawed.num_channels):
channel_path = join(path, f"channel{i}")
lprint(f"Loading regressor model for channel {i} from: {path}")
with open(join(channel_path, "regressor_model.json"), "r") as json_file:
frozen_model = json_file.read()
thawed_model = jsonpickle.decode(frozen_model)
thawed_model._load_internals(channel_path)
thawed.models.append(thawed_model)
return thawed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_drivers(dirpath):\n\n return all_drivers",
"def get_all(folder, filter_funs = []) :\n\n def apply_funs(x, funs) :\n \"\"\"Applies the filter functions.\"\"\"\n res = True\n for f in funs :\n res = f(x)\n if not res :\n break\n return res\n \n final = {}\n files = listd... | [
"0.5379837",
"0.5044664",
"0.49726188",
"0.49551898",
"0.4940935",
"0.4874986",
"0.48747087",
"0.47927487",
"0.47669888",
"0.47309345",
"0.46937668",
"0.46731636",
"0.4670935",
"0.46418554",
"0.46351552",
"0.45951054",
"0.45918998",
"0.45842183",
"0.4548384",
"0.45425668",
"0... | 0.5162948 | 1 |
simulation of a single game | def mc_trial(board, player):
if len(board.get_empty_squares()) > 0:
gra_w_toku = True
else:
gra_w_toku = False
while gra_w_toku:
tupka = random.choice(board.get_empty_squares())
board.move(tupka[0], tupka[1], player)
status = board.check_win()
if status == player or status == provided.DRAW:
gra_w_toku = not gra_w_toku
player = provided.switch_player(player)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_simulation(self, state):\n \"*** YOUR CODE HERE ***\"\n player = 0\n visited_states = [(player, state)]\n depth_limited = self.depth != -1\n depth = self.depth\n expand = True\n while not visited_states[-1][1].isWin() and not visited_states[-1][1].isLose():\... | [
"0.76476705",
"0.7423586",
"0.7248727",
"0.69607615",
"0.6947179",
"0.6916251",
"0.69077504",
"0.6889119",
"0.68533415",
"0.6840715",
"0.68284386",
"0.6805519",
"0.6801347",
"0.6782698",
"0.67796993",
"0.6775046",
"0.66829413",
"0.6681817",
"0.6652152",
"0.66504765",
"0.66499... | 0.0 | -1 |
return nothing but updating a score | def mc_update_scores(scores, board, player):
status = board.check_win()
if status == provided.DRAW:
pass
if status == player:
for row in range(board.get_dim()):
for col in range(board.get_dim()):
znak = board.square(row, col)
helper(True, znak, player, scores, row, col)
if status == provided.switch_player(player):
for row in range(board.get_dim()):
for col in range(board.get_dim()):
znak = board.square(row, col)
helper(False, znak, player, scores, row, col)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_score():\n pass",
"def updateScore(score):\n return score + 1",
"def update_score(self, score: int) -> int:\n self.score += score\n return self.score",
"def score(self):",
"def update_score(self):\n self.score = TurboMQ.calculate_fitness(self.result, self.g... | [
"0.88064134",
"0.8144664",
"0.77495396",
"0.76195884",
"0.7563196",
"0.74926865",
"0.7427741",
"0.73870414",
"0.7202365",
"0.7133871",
"0.710654",
"0.7085516",
"0.70635676",
"0.706069",
"0.7026134",
"0.7020511",
"0.70177984",
"0.7006921",
"0.70053643",
"0.6973539",
"0.6971714... | 0.63917595 | 82 |
return a move for the machine player in the form of a (row, column) tuple. | def mc_move(board, player, trials):
grid_of_scores = [[0 for dummy_i in range(board.get_dim())] for dummy_j in range(board.get_dim())]
test_board = board.clone()
for dummy_i in range(trials):
mc_trial(test_board, player)
mc_update_scores(grid_of_scores, test_board, player)
test_board = board.clone()
best_move = get_best_move(board, grid_of_scores)
return best_move | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_move(board, player):\r\n row, col = 0, 0\r\n return row, col",
"def get_move(board, player):\n row, col = 0, 0\n return row, col",
"def get_ai_move(board, player):\r\n row, col = 0, 0\r\n return row, col",
"def get_ai_move(board, player):\n row, col = 0, 0\n return row, col",
... | [
"0.84373444",
"0.8416715",
"0.7964209",
"0.79255193",
"0.72848445",
"0.7280993",
"0.7246106",
"0.7221404",
"0.7153344",
"0.7151742",
"0.70832056",
"0.7001192",
"0.689266",
"0.6870447",
"0.6862894",
"0.6862894",
"0.6854077",
"0.684734",
"0.684734",
"0.6843987",
"0.68329155",
... | 0.0 | -1 |
Train the crf tagger based on the training data. | def _train_model(self, df_train):
# type: (List[List[Tuple[Text, Text, Text, Text]]]) -> None
import sklearn_crfsuite
X_train = [self._sentence_to_features(sent) for sent in df_train]
y_train = [self._sentence_to_labels(sent) for sent in df_train]
from itertools import chain
import nltk
import sklearn
import scipy.stats
from sklearn.metrics import make_scorer
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RandomizedSearchCV
import sklearn_crfsuite
from sklearn_crfsuite import scorers
from sklearn_crfsuite import metrics
X_train = [self._sentence_to_features(sent) for sent in df_train]
y_train = [self._sentence_to_labels(sent) for sent in df_train]
if self.component_config["grid_search"]:
self.ent_tagger = sklearn_crfsuite.CRF(
algorithm='lbfgs',
# stop earlier
max_iterations=self.component_config["max_iterations"],
# include transitions that are possible, but not observed
all_possible_transitions=True
)
self.ent_tagger.fit(X_train, y_train)
params_space = {
'c1': scipy.stats.expon(scale=0.5),
'c2': scipy.stats.expon(scale=0.5),
}
labels = self.ent_tagger.classes_
# use the same metric for evaluation
f1_scorer = make_scorer(metrics.flat_f1_score,
average='weighted', labels=labels)
# search
rs = RandomizedSearchCV(self.ent_tagger, params_space,
cv=10,
verbose=1,
n_jobs=-1,
n_iter=100,
scoring=f1_scorer)
rs.fit(X_train, y_train)
print('best params:', rs.best_params_)
print('best CV score:', rs.best_score_)
print('model size: {:0.2f}M'.format(rs.best_estimator_.size_ / 1000000))
try:
import json
with open("tunning_score.json", "w") as f:
json.dump(rs.best_params_, f, sort_keys=True, indent=4)
except Exception:
pass
self.ent_tagger = sklearn_crfsuite.CRF(
algorithm='lbfgs',
c1=rs.best_params_["c1"],
c2=rs.best_params_["c2"],
# stop earlier
max_iterations=self.component_config["max_iterations"],
# include transitions that are possible, but not observed
all_possible_transitions=True
)
else:
print("L1_c", self.component_config["L1_c"])
print("L2_c", self.component_config["L2_c"])
self.ent_tagger = sklearn_crfsuite.CRF(
algorithm='lbfgs',
# coefficient for L1 penalty
c1=self.component_config["L1_c"],
# coefficient for L2 penalty
c2=self.component_config["L2_c"],
# stop earlier
max_iterations=self.component_config["max_iterations"],
# include transitions that are possible, but not observed
all_possible_transitions=True
)
self.ent_tagger.fit(X_train, y_train) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_crf(ctx, input, output, clusters):\n click.echo('chemdataextractor.crf.train')\n sentences = []\n for line in input:\n sentence = []\n for t in line.split():\n token, tag, iob = t.rsplit('/', 2)\n sentence.append(((token, tag), iob))\n if sentence:\n ... | [
"0.70876074",
"0.7059196",
"0.6855058",
"0.6802832",
"0.6785829",
"0.67681587",
"0.67512184",
"0.6747457",
"0.67143035",
"0.6711",
"0.66792077",
"0.66118145",
"0.660746",
"0.66058165",
"0.66058165",
"0.66058165",
"0.66058165",
"0.66058165",
"0.65927374",
"0.6588397",
"0.65883... | 0.6713298 | 9 |
Excludes where learners played against learners | def get_reward_lists(f):
with open(f, 'r',newline='') as f:
lines = f.readlines()
return lines | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exclude_words(self, words):\n idcs = []\n for i in range(len(self)):\n if not self.transcript(i) in words:\n idcs.append(i)\n subset = self.sub_set(idcs)\n return subset",
"def prune_teachers(self):\n self.teacher_policies = self.teacher_policies[:... | [
"0.65722376",
"0.5929489",
"0.58905196",
"0.5826653",
"0.58197314",
"0.5794661",
"0.5784924",
"0.5743494",
"0.5724692",
"0.56861764",
"0.5636551",
"0.56264764",
"0.5577885",
"0.5564499",
"0.5544913",
"0.5514717",
"0.55069286",
"0.55069286",
"0.5471333",
"0.5468246",
"0.545329... | 0.0 | -1 |
loads the next N images from the binary mraw file into a numpy array. | def load_images(mraw, h, w, N, bit=16, roll_axis=True):
if int(bit) == 16:
images = np.memmap(mraw, dtype=np.uint16, mode='r', shape=(N, h, w))
elif int(bit) == 8:
images = np.memmap(mraw, dtype=np.uint8, mode='r', shape=(N, h, w))
elif int(bit) == 12:
warnings.warn("12bit images will be loaded into memory!")
#images = _read_uint12_video(mraw, (N, h, w))
images = _read_uint12_video_prec(mraw, (N, h, w))
else:
raise Exception(f"Unsupported bit depth: {bit}")
#images=np.fromfile(mraw, dtype=np.uint16, count=h * w * N).reshape(N, h, w) # about a 1/3 slower than memmap when loading to RAM. Also memmap doesn't need to read to RAM but can read from disc when needed.
if roll_axis:
return np.rollaxis(images, 0, 3)
else:
return images | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readData():\n\tN = 800\n\tD = 28*28\n\tX = np.zeros((N, D), dtype=np.uint8)\n\n\tf = open(\"data/a012_images.dat\", 'rb')\n\n\tfor i in range(0, N):\n\t\tX[i, :] = np.fromstring(f.read(D), dtype='uint8')\n\n\tf.close()\n\n\treturn X",
"def le_binario_mgbq(filebin,nt,nc):\n return np.fromfile(fileb... | [
"0.6541903",
"0.63630474",
"0.6321544",
"0.63167053",
"0.6276605",
"0.6192698",
"0.6192698",
"0.6186343",
"0.61686295",
"0.61686295",
"0.61686295",
"0.61686295",
"0.61686295",
"0.61686295",
"0.61289364",
"0.61266387",
"0.61094004",
"0.6033004",
"0.60216844",
"0.59940916",
"0.... | 0.68674904 | 0 |
Loads and returns images and a cih info dict. | def load_video(cih_file):
cih = get_cih(cih_file)
mraw_file = path.splitext(cih_file)[0] + '.mraw'
N = cih['Total Frame']
h = cih['Image Height']
w = cih['Image Width']
bit = cih['Color Bit']
images = load_images(mraw_file, h, w, N, bit, roll_axis=False)
return images, cih | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_metadata(self):\n\n cub_dir = self.root / \"CUB_200_2011\"\n images_list: Dict[int, List] = OrderedDict()\n\n with open(str(cub_dir / \"train_test_split.txt\")) as csv_file:\n csv_reader = csv.reader(csv_file, delimiter=\" \")\n for row in csv_reader:\n ... | [
"0.69167143",
"0.67644393",
"0.65785575",
"0.64346397",
"0.64260566",
"0.6405014",
"0.6335255",
"0.630171",
"0.63005936",
"0.62530017",
"0.6173102",
"0.61003965",
"0.6039576",
"0.60270804",
"0.6020482",
"0.6004541",
"0.59933895",
"0.59829694",
"0.59729624",
"0.5952639",
"0.59... | 0.0 | -1 |
Saves given sequence of images into .mraw file. | def save_mraw(images, save_path, bit_depth=16, ext='mraw', info_dict={}):
filename, extension = path.splitext(save_path)
mraw_path = '{:s}.{:s}'.format(filename, ext)
cih_path = '{:s}.{:s}'.format(filename, '.cih')
directory_path = path.split(save_path)[0]
if not path.exists(directory_path):
os.makedirs(directory_path)
bit_depth_dtype_map = {
8: np.uint8,
16: np.uint16
}
if bit_depth not in bit_depth_dtype_map.keys():
raise ValueError('Currently supported bit depths are 8 and 16.')
if bit_depth < 16:
effective_bit = bit_depth
else:
effective_bit = 12
if np.max(images) > 2**bit_depth-1:
raise ValueError(
'The input image data does not match the selected bit depth. ' +
'Consider normalizing the image data before saving.')
# Generate .mraw file
with open(mraw_path, 'wb') as file:
for image in images:
image = image.astype(bit_depth_dtype_map[bit_depth])
image.tofile(file)
file_shape = (int(len(images)), image.shape[0], image.shape[1])
file_format = 'MRaw'
image_info = {'Record Rate(fps)': '{:d}'.format(1),
'Shutter Speed(s)': '{:.6f}'.format(1),
'Total Frame': '{:d}'.format(file_shape[0]),
'Original Total Frame': '{:d}'.format(file_shape[0]),
'Start Frame': '{:d}'.format(0),
'Image Width': '{:d}'.format(file_shape[2]),
'Image Height': '{:d}'.format(file_shape[1]),
'Color Type': 'Mono',
'Color Bit': bit_depth,
'File Format' : file_format,
'EffectiveBit Depth': effective_bit,
'Comment Text': 'Generated sequence. Modify measurement info in created .cih file if necessary.',
'EffectiveBit Side': 'Lower'}
image_info.update(info_dict)
cih_path = '{:s}.{:s}'.format(filename, 'cih')
with open(cih_path, 'w') as file:
file.write('#Camera Information Header\n')
for key in image_info.keys():
file.write('{:s} : {:s}\n'.format(key, str(image_info[key])))
return mraw_path, cih_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(images, output):\n for image, frame in images:\n image.save(output(frame))",
"def save_step_1(imgs, output_path='./output/step1'):\n # ... your code here ...\n i=0\n for each in imgs:\n i+=1\n cv2.imwrite(output_path+\"/output\"+str(i)+\".jpg\", each)",
"def saveFrames... | [
"0.711835",
"0.70112777",
"0.6918421",
"0.6822654",
"0.6764862",
"0.6758189",
"0.67128646",
"0.67098147",
"0.6670487",
"0.665418",
"0.66379416",
"0.6584189",
"0.6560411",
"0.651001",
"0.6488647",
"0.6457336",
"0.6429019",
"0.6422496",
"0.6414986",
"0.638881",
"0.6349937",
"... | 0.67297393 | 6 |
Utility function to read 12bit packed mraw files into uint16 array Will store entire array in memory! | def _read_uint12_video(data, shape):
data = np.memmap(data, dtype=np.uint8, mode="r")
fst_uint8, mid_uint8, lst_uint8 = np.reshape(data, (data.shape[0] // 3, 3)).astype(np.uint16).T
fst_uint12 = (fst_uint8 << 4) + (mid_uint8 >> 4)
snd_uint12 = ((mid_uint8 % 16) << 8) + lst_uint8
return np.reshape(np.concatenate((fst_uint12[:, None], snd_uint12[:, None]), axis=1), shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unpack_mraw_frame_12bit(file,n_pixels,start_frame=0):\n \n start_byte = start_frame*n_pixels*12/8\n file.seek(start_byte)\n image = []\n \n n_bytes = n_pixels*12/8\n \n int_array = np.fromfile(file,count=n_bytes,dtype=np.uint8)\n \n bytes_1 = int_array[::3]\n bytes_2 = int_arra... | [
"0.68789697",
"0.68381524",
"0.66513246",
"0.6528",
"0.6359484",
"0.6214181",
"0.6206337",
"0.6118009",
"0.60529387",
"0.60003304",
"0.5936918",
"0.593421",
"0.59340906",
"0.5930919",
"0.58940655",
"0.5846712",
"0.58181554",
"0.5809074",
"0.5799255",
"0.5763211",
"0.5753879",... | 0.70496243 | 0 |
Utility function to read 12bit packed mraw files into uint16 array Will store entire array in memory! | def _read_uint12_video_prec(data, shape):
data = np.memmap(data, dtype=np.uint8, mode="r")
return nb_read_uint12(data).reshape(shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_uint12_video(data, shape):\n data = np.memmap(data, dtype=np.uint8, mode=\"r\")\n fst_uint8, mid_uint8, lst_uint8 = np.reshape(data, (data.shape[0] // 3, 3)).astype(np.uint16).T\n fst_uint12 = (fst_uint8 << 4) + (mid_uint8 >> 4)\n snd_uint12 = ((mid_uint8 % 16) << 8) + lst_uint8\n return ... | [
"0.7049365",
"0.6879431",
"0.6836875",
"0.65290755",
"0.6360394",
"0.621499",
"0.6207839",
"0.61189526",
"0.60546416",
"0.60031",
"0.59370583",
"0.5934907",
"0.5933406",
"0.5932318",
"0.5895518",
"0.5847376",
"0.5819832",
"0.5810755",
"0.5799669",
"0.5764724",
"0.5755548",
... | 0.66510236 | 3 |
precompiled function to efficiently covnert from 12bit packed video to 16bit video it splits 3 bytes into two 16 bit words data_chunk is a contigous 1D array of uint8 data, e.g. the 12bit video loaded as 8bit array | def nb_read_uint12(data_chunk):
#ensure that the data_chunk has the right length
assert np.mod(data_chunk.shape[0],3)==0
out = np.empty(data_chunk.size//3*2, dtype=np.uint16)
for i in nb.prange(data_chunk.shape[0]//3):
fst_uint8=np.uint16(data_chunk[i*3])
mid_uint8=np.uint16(data_chunk[i*3+1])
lst_uint8=np.uint16(data_chunk[i*3+2])
out[i*2] = (fst_uint8 << 4) + (mid_uint8 >> 4)
out[i*2+1] = ((mid_uint8 % 16) << 8) + lst_uint8
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_uint12_video(data, shape):\n data = np.memmap(data, dtype=np.uint8, mode=\"r\")\n fst_uint8, mid_uint8, lst_uint8 = np.reshape(data, (data.shape[0] // 3, 3)).astype(np.uint16).T\n fst_uint12 = (fst_uint8 << 4) + (mid_uint8 >> 4)\n snd_uint12 = ((mid_uint8 % 16) << 8) + lst_uint8\n return ... | [
"0.6967046",
"0.61986065",
"0.6189992",
"0.61811805",
"0.6017552",
"0.60136306",
"0.59860003",
"0.5980767",
"0.58180374",
"0.5771538",
"0.5734991",
"0.5357844",
"0.53522146",
"0.53145593",
"0.52839905",
"0.52355176",
"0.5201002",
"0.5169548",
"0.51465833",
"0.5143027",
"0.513... | 0.6670928 | 1 |
Get item from self.human_data. | def prepare_raw_data(self, idx: int):
info = super().prepare_raw_data(idx)
if self.cache_reader is not None:
self.human_data = self.cache_reader.get_item(idx)
idx = idx % self.cache_reader.slice_size
if 'smplx' in self.human_data:
smplx_dict = self.human_data['smplx']
info['has_smplx'] = 1
else:
smplx_dict = {}
info['has_smplx'] = 0
if 'global_orient' in smplx_dict:
info['smplx_global_orient'] = smplx_dict['global_orient'][idx]
info['has_smplx_global_orient'] = 1
else:
info['smplx_global_orient'] = np.zeros((3), dtype=np.float32)
info['has_smplx_global_orient'] = 0
if 'body_pose' in smplx_dict:
info['smplx_body_pose'] = smplx_dict['body_pose'][idx]
info['has_smplx_body_pose'] = 1
else:
info['smplx_body_pose'] = np.zeros((21, 3), dtype=np.float32)
info['has_smplx_body_pose'] = 0
if 'right_hand_pose' in smplx_dict:
info['smplx_right_hand_pose'] = smplx_dict['right_hand_pose'][idx]
info['has_smplx_right_hand_pose'] = 1
else:
info['smplx_right_hand_pose'] = np.zeros((15, 3), dtype=np.float32)
info['has_smplx_right_hand_pose'] = 0
if 'left_hand_pose' in smplx_dict:
info['smplx_left_hand_pose'] = smplx_dict['left_hand_pose'][idx]
info['has_smplx_left_hand_pose'] = 1
else:
info['smplx_left_hand_pose'] = np.zeros((15, 3), dtype=np.float32)
info['has_smplx_left_hand_pose'] = 0
if 'jaw_pose' in smplx_dict:
info['smplx_jaw_pose'] = smplx_dict['jaw_pose'][idx]
info['has_smplx_jaw_pose'] = 1
else:
info['smplx_jaw_pose'] = np.zeros((3), dtype=np.float32)
info['has_smplx_jaw_pose'] = 0
if 'betas' in smplx_dict:
info['smplx_betas'] = smplx_dict['betas'][idx]
info['has_smplx_betas'] = 1
else:
info['smplx_betas'] = np.zeros((self.num_betas), dtype=np.float32)
info['has_smplx_betas'] = 0
if 'expression' in smplx_dict:
info['smplx_expression'] = smplx_dict['expression'][idx]
info['has_smplx_expression'] = 1
else:
info['smplx_expression'] = np.zeros((self.num_expression),
dtype=np.float32)
info['has_smplx_expression'] = 0
return info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_item(self):\n return self.item",
"def get_item(self):\n return self.item",
"def __getitem__(self, item):\n return self._data[item]",
"def __getitem__(self, item):\n return self.data[item]",
"def __getitem__(self, item):\n return self.data[item]",
"def __getitem_... | [
"0.7406864",
"0.7406864",
"0.73144776",
"0.7309078",
"0.7309078",
"0.7309078",
"0.7219982",
"0.71420383",
"0.71420383",
"0.71420383",
"0.70934916",
"0.70712644",
"0.7018385",
"0.7018385",
"0.70036954",
"0.70014024",
"0.7000123",
"0.6842417",
"0.6842417",
"0.6842417",
"0.67811... | 0.0 | -1 |
compute the 3DRMSE between a predicted 3D face shape and the 3D ground truth scan. | def _report_3d_rmse(self, res_file):
pred_vertices, gt_vertices, _ = self._parse_result(
res_file, mode='vertice')
pred_keypoints3d, gt_keypoints3d, _ = self._parse_result(
res_file, mode='keypoint')
errors = []
for pred_vertice, gt_vertice, pred_points, gt_points in zip(
pred_vertices, gt_vertices, pred_keypoints3d, gt_keypoints3d):
error = fg_vertices_to_mesh_distance(gt_vertice, gt_points,
pred_vertice,
self.body_model.faces,
pred_points)
errors.append(error)
error = np.array(errors).mean()
name_value_tuples = [('3DRMSE', error)]
return name_value_tuples | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_3d(self, box_point_3d, instance):\n azimuth_error, polar_error = self.evaluate_viewpoint(box_point_3d, instance)\n iou = self.evaluate_iou(box_point_3d, instance)\n return azimuth_error, polar_error, iou",
"def get_3d_points(preds_3d):\n for i,p in enumerate(preds_3d):\n preds_3d[... | [
"0.57921743",
"0.5499897",
"0.5472451",
"0.52560514",
"0.5251211",
"0.52303135",
"0.51892173",
"0.518625",
"0.5166288",
"0.5151563",
"0.514771",
"0.511312",
"0.5067872",
"0.50428575",
"0.5011078",
"0.49873042",
"0.49712166",
"0.49459213",
"0.49200428",
"0.4919663",
"0.4918488... | 0.60341465 | 0 |
Evaluate 3D keypoint results. | def evaluate(self,
outputs: list,
res_folder: str,
metric: Optional[Union[str, List[str]]] = 'pa-mpjpe',
**kwargs: dict):
metrics = metric if isinstance(metric, list) else [metric]
for metric in metrics:
if metric not in self.ALLOWED_METRICS:
raise KeyError(f'metric {metric} is not supported')
# for keeping correctness during multi-gpu test, we sort all results
res_dict = {}
for out in outputs:
target_id = out['image_idx']
batch_size = len(out['keypoints_3d'])
for i in range(batch_size):
res_dict[int(target_id[i])] = dict(
keypoints=out['keypoints_3d'][i],
vertices=out['vertices'][i],
)
keypoints, vertices = [], []
for i in range(self.num_data):
keypoints.append(res_dict[i]['keypoints'])
vertices.append(res_dict[i]['vertices'])
keypoints = np.stack(keypoints)
vertices = np.stack(vertices)
res = dict(keypoints=keypoints, vertices=vertices)
name_value_tuples = []
for index, _metric in enumerate(metrics):
if 'body_part' in kwargs:
body_parts = kwargs['body_part'][index]
for body_part in body_parts:
if _metric == 'pa-mpjpe':
_nv_tuples = self._report_mpjpe(
res, metric='pa-mpjpe', body_part=body_part)
elif _metric == 'pa-pve':
_nv_tuples = self._report_pve(
res, metric='pa-pve', body_part=body_part)
else:
raise NotImplementedError
name_value_tuples.extend(_nv_tuples)
else:
if _metric == 'mpjpe':
_nv_tuples = self._report_mpjpe(res)
elif _metric == 'pa-mpjpe':
_nv_tuples = self._report_mpjpe(res, metric='pa-mpjpe')
elif _metric == '3dpck':
_nv_tuples = self._report_3d_pck(res)
elif _metric == 'pa-3dpck':
_nv_tuples = self._report_3d_pck(res, metric='pa-3dpck')
elif _metric == '3dauc':
_nv_tuples = self._report_3d_auc(res)
elif _metric == 'pa-3dauc':
_nv_tuples = self._report_3d_auc(res, metric='pa-3dauc')
elif _metric == 'pve':
_nv_tuples = self._report_pve(res)
elif _metric == 'pa-pve':
_nv_tuples = self._report_pve(res, metric='pa-pve')
elif _metric == '3DRMSE':
_nv_tuples = self._report_3d_rmse(res)
else:
raise NotImplementedError
name_value_tuples.extend(_nv_tuples)
name_value = OrderedDict(name_value_tuples)
return name_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_3d(self, box_point_3d, instance):\n azimuth_error, polar_error = self.evaluate_viewpoint(box_point_3d, instance)\n iou = self.evaluate_iou(box_point_3d, instance)\n return azimuth_error, polar_error, iou",
"def _get_data_on_3d_points(self, varname, record, points):\n if self.get_mesh... | [
"0.7018151",
"0.6458969",
"0.6291701",
"0.618679",
"0.6173702",
"0.6046015",
"0.59891486",
"0.59870636",
"0.59073186",
"0.5893742",
"0.58693314",
"0.5850453",
"0.57705677",
"0.57656455",
"0.57517314",
"0.5728884",
"0.5630404",
"0.561461",
"0.5612338",
"0.5607166",
"0.5588802"... | 0.0 | -1 |
Print lots of basic information about the given presentation. | def debug_dump(prs:Presentation):
print("Presentation has", len(prs.slides), "slides")
# Print summary of all slides, plus text
n = 0
for slide in prs.slides:
n += 1
print("========== slide {} ========== [{}]".format(n, slide.slide_layout.name))
for shape in slide.shapes:
if not shape.has_text_frame:
continue
print(shape.name)
for paragraph in shape.text_frame.paragraphs:
for run in paragraph.runs:
print(" " + run.text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Print(self):\n\n\t\tif self.verbose:\n\n\t\t print (\"\\033[1m[HEADER]\\033[0m\")\n\t\t print (\"code:\\t\\t%s\" % self.kod)\n\t \tprint (\"version:\\t%s\" % self.ver)\n\t\t print (\"date and time:\\t%s\" % self.probid)\n\t\t print (\"dump number:\\t%s\" % self.knod)\n\t ... | [
"0.6639509",
"0.6288107",
"0.6238363",
"0.62220323",
"0.6204376",
"0.6180137",
"0.6151986",
"0.61489",
"0.6128701",
"0.6115834",
"0.6007176",
"0.59872526",
"0.59838665",
"0.596641",
"0.59656215",
"0.59383917",
"0.59287095",
"0.5924039",
"0.590953",
"0.5906681",
"0.5902103",
... | 0.7133029 | 0 |
Count the amount of text in each slide. | def get_word_counts(slides) -> List[int]:
word_count = []
for slide in slides:
# print(f"========== slide {len(text_count)+1} ========== [{slide.slide_layout.name}]")
words = 0
# find all text
for shape in slide.shapes:
if not shape.has_text_frame:
continue
# print(shape.name)
for paragraph in shape.text_frame.paragraphs:
for run in paragraph.runs:
# print(" " + run.text)
words += len(run.text.split())
word_count.append(words)
return word_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_slide_analytics_new(slides) -> List[int]:\n word_count = []\n for slide in slides:\n print(slide)\n words = 0\n for shape in slide.shapes:\n if not shape.has_text_frame:\n continue\n print(shape.name)\n for paragraph in shape.text_f... | [
"0.7645021",
"0.699523",
"0.6631901",
"0.65998024",
"0.65277624",
"0.65032226",
"0.63644123",
"0.63634205",
"0.6349974",
"0.6309825",
"0.6171061",
"0.6156245",
"0.6148901",
"0.60785764",
"0.60774815",
"0.6072669",
"0.603562",
"0.59676707",
"0.59530956",
"0.59443533",
"0.59265... | 0.75697744 | 1 |
Calculates a onetofive star ranking for presentations that are not too textheavy. | def calculate_text_stars(word_counts) -> int:
if word_counts == []:
return 3
words_per_slide = sum(word_counts) / len(word_counts)
stars = 5 - abs(words_per_slide - 35) / 8
# print(stars)
return max(0, min(5, int(stars + 0.5))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sentiment(text):\n words = pattern_split.split(text.lower())\n sentiments = map(lambda word: afinn.get(word, 0), words)\n if sentiments:\n # How should you weight the individual word sentiments? \n # You could do N, sqrt(N) or 1 for example. Here I use sqrt(N)\n sentiment = float(... | [
"0.5887334",
"0.57918924",
"0.57401806",
"0.5696041",
"0.56602454",
"0.56410843",
"0.5623116",
"0.5621459",
"0.55914843",
"0.5587887",
"0.55824214",
"0.55516285",
"0.553804",
"0.55314225",
"0.5495516",
"0.54903185",
"0.5481853",
"0.5480828",
"0.54778075",
"0.54706895",
"0.546... | 0.5987914 | 0 |
Counts how many times each PPT layout is used. Returns the total number of interactive layouts, plus a dictionary of the layout counts. | def count_layouts(prs:Presentation) -> Tuple[int, Dict[str, int]]:
layouts = collections.defaultdict(int)
layouts_interactive = 0
for slide in prs.slides:
layouts[slide.slide_layout.name] += 1
if slide.slide_layout.name in INTERACTIVE:
layouts_interactive += 1
return (layouts_interactive, layouts) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNumLayouts(self):\n return _libsbml.LayoutModelPlugin_getNumLayouts(self)",
"def pobj_counts(pcode_obj):\n pcode = (pcode_obj.asDict())['pcode'][0] # no multiple pcode blocks - no delimiter\n counts = {'galleries': 0, 'spreads': 0, 'layouts': 0, 'panelgroups': 0}\n # , 'panels': 0, 'skips... | [
"0.6073172",
"0.60642576",
"0.5786426",
"0.57859993",
"0.57683474",
"0.5574106",
"0.54529566",
"0.5449059",
"0.539238",
"0.53353953",
"0.5332541",
"0.53282636",
"0.53045416",
"0.52998465",
"0.5298258",
"0.52905923",
"0.5276604",
"0.52639884",
"0.5256031",
"0.52523476",
"0.523... | 0.8039856 | 0 |
Count the amount of text in each slide. | def get_slide_analytics_new(slides) -> List[int]:
word_count = []
for slide in slides:
print(slide)
words = 0
for shape in slide.shapes:
if not shape.has_text_frame:
continue
print(shape.name)
for paragraph in shape.text_frame.paragraphs:
for run in paragraph.runs:
print(" " + run.text)
words += len(run.text.split())
word_count.append(words)
return word_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_word_counts(slides) -> List[int]:\n word_count = []\n for slide in slides:\n # print(f\"========== slide {len(text_count)+1} ========== [{slide.slide_layout.name}]\")\n words = 0\n # find all text\n for shape in slide.shapes:\n if not shape.has_text_frame:\n ... | [
"0.75697744",
"0.699523",
"0.6631901",
"0.65998024",
"0.65277624",
"0.65032226",
"0.63644123",
"0.63634205",
"0.6349974",
"0.6309825",
"0.6171061",
"0.6156245",
"0.6148901",
"0.60785764",
"0.60774815",
"0.6072669",
"0.603562",
"0.59676707",
"0.59530956",
"0.59443533",
"0.5926... | 0.7645021 | 0 |
Analyses a presentation and returns a dictionary of starratings, plus extra details. Works best on presentations that use the LIFTS template, with known layout names. | def analyse_presentation(pres_name:str, verbose=False) -> Dict[str, Any]:
prs = Presentation(pres_name)
if verbose:
debug_dump(prs)
(layouts_interactive, layouts) = count_layouts(prs)
interaction_stars = min(layouts_interactive, 5)
topic_stars = ([1,1,3,5,5,4,3,2,1]+[1]*100)[layouts["Section Header"]]
pres_properties = get_presentation_properties(prs)
word_count = get_word_counts(prs.slides)
words_per_slide = sum(word_count) / len(word_count)
# ideal words/slide is 30-40 (5 stars)
text_stars = calculate_text_stars(word_count)
# print("word counts:", word_count)
# Create a list of warnings about very text-heavy slides
heavy_warnings = []
for slide, words in enumerate(word_count):
if words > MAX_WORDS_PER_SLIDE:
heavy_warnings.append(f"WARNING: slide {slide} has {words} words!")
slides = get_slide_analytics(prs.slides)
print(slides)
result = {
"presentation_rating_stars_interaction": interaction_stars,
"presentation_rating_stars_section": topic_stars,
"presentation_rating_stars_accessibility": 3, # not implemented yet!
"presentation_rating_stars_text": text_stars,
"presentation_count_slide": len(prs.slides),
"presentation_count_layout": layouts, # dictionary that maps layout name to count
"presentation_total_words": words_per_slide, # a float
"presentation_warning_text_heavy": heavy_warnings, # a list of warning strings
"presentation_data_slides": slides, # a list of slides and analytics
"filename": pres_name, # TODO: strip any Path and just return file name?
"name": "ICT999",
"description": "Introduction to ICT"
}
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def analyze_pptx(template_file):\n prs = Presentation(template_file)\n # Each powerpoint file has multiple layouts\n # Loop through them all and see where the various elements are\n slide_masters = prs.slide_masters\n for index, slide_master in enumerate(prs.slide_masters):\n print('--------... | [
"0.57579595",
"0.5754335",
"0.55619776",
"0.545294",
"0.5446325",
"0.51942104",
"0.51507777",
"0.51323617",
"0.5105886",
"0.5052227",
"0.5037823",
"0.49726292",
"0.4881835",
"0.4851375",
"0.48495308",
"0.48304343",
"0.48082933",
"0.47642702",
"0.4755273",
"0.47469255",
"0.474... | 0.74647856 | 0 |
Return size of the dataset | def __len__(self):
return self.get_num_sequence() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataset_size(self):\n return self.dataset.size",
"def __len__(self):\n return self._dataset.size(dirs=self._dirs)",
"def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n ... | [
"0.8979698",
"0.8526949",
"0.82585645",
"0.81426746",
"0.8124066",
"0.81118333",
"0.8078935",
"0.80428666",
"0.8037988",
"0.8028507",
"0.8013156",
"0.80074346",
"0.80074346",
"0.80074346",
"0.80074346",
"0.7973197",
"0.7925562",
"0.7925562",
"0.7925562",
"0.7925562",
"0.79255... | 0.0 | -1 |
Number of studies in a dataset. | def get_num_sequence(self):
return len(self.study_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_datasets(self, data):\n dsets = set()\n for items in data:\n dsetid = items[3]\n dsets.add(dsetid)\n return len(dsets)",
"def count_elements_in_dataset(dataset):\n return dataset.count()",
"def num_students(self,dd=\"\"):\n\t\tif dd==\"\":\n\t\t\tdd=dat... | [
"0.6843366",
"0.67893463",
"0.6728229",
"0.64195675",
"0.62901825",
"0.6255575",
"0.6206059",
"0.6124002",
"0.61171126",
"0.6110871",
"0.6106557",
"0.6096237",
"0.607423",
"0.60537356",
"0.6051849",
"0.60323846",
"0.6030147",
"0.60260516",
"0.5990028",
"0.59870434",
"0.596654... | 0.55716085 | 89 |
Name of the dataset. | def get_name(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataset_name(self):\n return self.dataset.name",
"def dataset_name(self):\n return self._dataset_name",
"def get_dataset_name(self):\n raise NotImplementedError",
"def get_dataset_name(self):\n return self.dataset_name",
"def __get_dataset_name(self):\n d = gdal.Open(... | [
"0.919469",
"0.8976905",
"0.87083614",
"0.8686752",
"0.7850114",
"0.7471211",
"0.7451666",
"0.74262846",
"0.7378664",
"0.73779565",
"0.7199527",
"0.70992815",
"0.70992815",
"0.70992815",
"0.6962095",
"0.6886322",
"0.6757635",
"0.6693697",
"0.667641",
"0.6673114",
"0.6660524",... | 0.0 | -1 |
Not to be used! Check get_frames() instead. | def __getitem__(self, item):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def frames():\n raise RuntimeError('Must be implemented by subclasses.')",
"def process_frames(self, data):\n pass",
"def process_frames(self, data):\n pass",
"def process_frames(self, data):\n pass",
"def process_frames(self, data):\n pass",
"def process_frames(self, d... | [
"0.7640561",
"0.69378716",
"0.69378716",
"0.69378716",
"0.69378716",
"0.69378716",
"0.69195557",
"0.67941016",
"0.67867607",
"0.6755174",
"0.6755174",
"0.6755174",
"0.6755174",
"0.6722964",
"0.6581867",
"0.6483949",
"0.6414792",
"0.6398254",
"0.63598907",
"0.63598907",
"0.635... | 0.0 | -1 |
Return information about a particular squences. | def get_study_info(self,std_id):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSongTextInfo():\n sids = []\n documents = []\n sFile = open('../txt/two__Lastfm_song_Docs.txt')\n lines = sFile.readlines()\n index = 0\n for line in lines:\n line.strip('\\n')\n line.strip('\\r\\n')\n items = line.split('>>')\n sid = int(items[0])\n text = items[1]\n documents.appen... | [
"0.5863178",
"0.5489143",
"0.54585916",
"0.5428158",
"0.536509",
"0.53436375",
"0.53430116",
"0.53390235",
"0.532284",
"0.529443",
"0.52938986",
"0.5290507",
"0.52477586",
"0.5244924",
"0.5206089",
"0.5205835",
"0.5202415",
"0.51880074",
"0.51695544",
"0.513454",
"0.51211977"... | 0.55018765 | 1 |
Get a set of frames from a particular study. | def get_frames(self,std_id, frame_ids, anno=None):
raise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_frames_for_sample(sample):\n path = os.path.join('data', sample[0])\n filename = sample[1]\n images = sorted(glob.glob(os.path.join(path, filename + '*jpg')))\n return images",
"def getFrames():\n\t\tfor cam in Camera.CAMERAS: cam.getFrame()",
"def getQiimeSffSamples(self, s... | [
"0.6049885",
"0.59706116",
"0.57190984",
"0.5599101",
"0.5508475",
"0.55001473",
"0.54696465",
"0.5453543",
"0.5443962",
"0.54344064",
"0.5425413",
"0.53727776",
"0.53502667",
"0.53314114",
"0.5238596",
"0.5207204",
"0.51428056",
"0.5139112",
"0.51072145",
"0.509223",
"0.5054... | 0.58449024 | 2 |
Returns definitions of module output ports. | def output_types(self) -> Optional[Dict[str, NeuralType]]:
return {
'input_ids': NeuralType(('B', 'T'), ChannelType()),
'segment_ids': NeuralType(('B', 'T'), ChannelType()),
'input_mask': NeuralType(('B', 'T'), MaskType()),
"labels": NeuralType(
tuple('B'), RegressionValuesType() if self.task_name == 'sts-b' else CategoricalValuesType()
),
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOutputPortsInfo(self):\n return [(gport.parentItem().module, gport.port, gport.controller.get_connections_from(gport.controller.current_pipeline, [gport.parentItem().module.id], gport.port.name), (gport.parentItem().boundingRect().right()-gport.parentItem().boundingRect().left())/2) for gport in self... | [
"0.7231068",
"0.7108193",
"0.7017519",
"0.698227",
"0.68667525",
"0.6826521",
"0.6819943",
"0.67742664",
"0.6712915",
"0.6690715",
"0.66691464",
"0.6668941",
"0.66622776",
"0.66509235",
"0.6629479",
"0.66278684",
"0.6618243",
"0.6612363",
"0.6601604",
"0.6582517",
"0.65754664... | 0.0 | -1 |
Loads a data file into a list of `InputBatch`s. | def convert_examples_to_features(
self,
examples: List[str],
label_list: List[int],
max_seq_length: int,
tokenizer: TokenizerSpec,
output_mode: str,
bos_token: str = None,
eos_token: str = '[SEP]',
pad_token: str = '[PAD]',
cls_token: str = '[CLS]',
sep_token_extra: str = None,
cls_token_at_end: bool = False,
cls_token_segment_id: int = 0,
pad_token_segment_id: int = 0,
pad_on_left: bool = False,
mask_padding_with_zero: bool = True,
sequence_a_segment_id: int = 0,
sequence_b_segment_id: int = 1,
):
label_map = {label: i for i, label in enumerate(label_list)}
features = []
for ex_index, example in enumerate(examples):
if example.label == "-": # skip examples without a consensus label (e.g. in SNLI data set)
continue
if ex_index % 10000 == 0:
logging.info("Writing example %d of %d" % (ex_index, len(examples)))
tokens_a = tokenizer.text_to_tokens(example.text_a)
tokens_b = None
if example.text_b:
tokens_b = tokenizer.text_to_tokens(example.text_b)
special_tokens_count = 2 if eos_token else 0
special_tokens_count += 1 if sep_token_extra else 0
special_tokens_count += 2 if bos_token else 0
special_tokens_count += 1 if cls_token else 0
self._truncate_seq_pair(tokens_a, tokens_b, max_seq_length - special_tokens_count)
else:
special_tokens_count = 1 if eos_token else 0
special_tokens_count += 1 if sep_token_extra else 0
special_tokens_count += 1 if bos_token else 0
if len(tokens_a) > max_seq_length - special_tokens_count:
tokens_a = tokens_a[: max_seq_length - special_tokens_count]
# Add special tokens to sequence_a
tokens = tokens_a
if bos_token:
tokens = [bos_token] + tokens
if eos_token:
tokens += [eos_token]
segment_ids = [sequence_a_segment_id] * len(tokens)
# Add sequence separator between sequences
if tokens_b and sep_token_extra:
tokens += [sep_token_extra]
segment_ids += [sequence_a_segment_id]
# Add special tokens to sequence_b
if tokens_b:
if bos_token:
tokens += [bos_token]
segment_ids += [sequence_b_segment_id]
tokens += tokens_b
segment_ids += [sequence_b_segment_id] * (len(tokens_b))
if eos_token:
tokens += [eos_token]
segment_ids += [sequence_b_segment_id]
# Add classification token - for BERT models
if cls_token:
if cls_token_at_end:
tokens += [cls_token]
segment_ids += [cls_token_segment_id]
else:
tokens = [cls_token] + tokens
segment_ids = [cls_token_segment_id] + segment_ids
input_ids = tokenizer.tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)
# Zero-pad up to the sequence length.
padding_length = max_seq_length - len(input_ids)
pad_token_id = tokenizer.tokens_to_ids([pad_token])[0]
if pad_on_left:
input_ids = ([pad_token_id] * padding_length) + input_ids
input_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask
segment_ids = ([pad_token_segment_id] * padding_length) + segment_ids
else:
input_ids = input_ids + ([pad_token_id] * padding_length)
input_mask = input_mask + ([0 if mask_padding_with_zero else 1] * padding_length)
segment_ids = segment_ids + ([pad_token_segment_id] * padding_length)
if len(input_ids) != max_seq_length:
raise ValueError("input_ids must be of length max_seq_length")
if len(input_mask) != max_seq_length:
raise ValueError("input_mask must be of length max_seq_length")
if len(segment_ids) != max_seq_length:
raise ValueError("segment_ids must be of length max_seq_length")
if output_mode == "classification":
label_id = label_map[example.label]
elif output_mode == "regression":
label_id = np.float32(example.label)
else:
raise KeyError(output_mode)
if ex_index < 5:
logging.info("*** Example ***")
logging.info("guid: %s" % (example.guid))
logging.info("tokens: %s" % " ".join(list(map(str, tokens))))
logging.info("input_ids: %s" % " ".join(list(map(str, input_ids))))
logging.info("input_mask: %s" % " ".join(list(map(str, input_mask))))
logging.info("segment_ids: %s" % " ".join(list(map(str, segment_ids))))
logging.info("label: %s (id = %d)" % (example.label, label_id))
features.append(
InputFeatures(input_ids=input_ids, input_mask=input_mask, segment_ids=segment_ids, label_id=label_id)
)
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LoadBatch(filename):",
"def load_batch(fpath, label_key='labels'):\n f = open(fpath, 'rb')\n if sys.version_info < (3,):\n d = cPickle.load(f)\n else:\n d = cPickle.load(f, encoding='bytes')\n # decode utf8\n d_decoded = {}\n for k, v in d.items():\n d_d... | [
"0.7116717",
"0.6971949",
"0.6867253",
"0.66187465",
"0.65909564",
"0.6522058",
"0.6507134",
"0.6502703",
"0.6472176",
"0.64224887",
"0.64197946",
"0.64197946",
"0.6409885",
"0.6405037",
"0.638099",
"0.6297901",
"0.62916416",
"0.6273321",
"0.6232164",
"0.6228044",
"0.62100035... | 0.0 | -1 |
Truncates a sequence pair in place to the maximum length. This will always truncate the longer sequence one token at a time. This makes more sense than truncating an equal percent of tokens from each, since if one sequence is very short then each token that's truncated likely contains more information than a longer sequence. | def _truncate_seq_pair(self, tokens_a: str, tokens_b: str, max_length: int):
while True:
total_length = len(tokens_a) + len(tokens_b)
if total_length <= max_length:
break
if len(tokens_a) > len(tokens_b):
tokens_a.pop()
else:
tokens_b.pop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _truncate_seq_pair(self, tokens_a, tokens_b, max_length):\r\n # This is a simple heuristic which will always truncate the longer sequence\r\n # one token at a time. This makes more sense than truncating an equal percent\r\n # of tokens from each, since if one sequence is very short then ea... | [
"0.8350219",
"0.8350219",
"0.8350219",
"0.8334177",
"0.83308214",
"0.83209616",
"0.8302651",
"0.83008575",
"0.8299758",
"0.8299758",
"0.8289869",
"0.82892597",
"0.8288885",
"0.8280558",
"0.82622397",
"0.82547146",
"0.8251895",
"0.8251895",
"0.8251895",
"0.8251895",
"0.8251895... | 0.78222877 | 41 |
Converts examples into TexttoText batches to be used with a model like T5. Inputs are prefixed with a text prompt that indicates the task to perform. | def convert_examples_to_features(self):
features = []
for ex_index, example in enumerate(self.examples):
if ex_index % 10000 == 0:
logging.info(f"Writing example {ex_index} of {len(self.examples)}")
text_to_text_query = self.processor.get_t5_prompted_query(example.text_a, example.text_b)
enc_query = self.tokenizer.text_to_ids(text_to_text_query)
if len(enc_query) > self.max_seq_length:
enc_query = enc_query[: self.max_seq_length]
dec_query = (
[self.tokenizer.bos_id]
+ self.tokenizer.text_to_ids(self.processor.label2string(example.label))
+ [self.tokenizer.eos_id]
)
dec_input = dec_query[:-1]
labels = dec_query[1:]
features.append([enc_query, dec_input, labels])
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_tokenize_fn(examples):\n sources = examples[config.source_lang]\n targets = examples[config.target_lang]\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\n\n # setup the tokenizer for targets,\n # huggingface expects the target tokenized ids ... | [
"0.61118716",
"0.592422",
"0.58838516",
"0.585979",
"0.5801184",
"0.5781311",
"0.57746387",
"0.57520574",
"0.57209575",
"0.56961864",
"0.5692046",
"0.5686498",
"0.5684553",
"0.5684334",
"0.56032795",
"0.5577988",
"0.55708474",
"0.55665946",
"0.55582416",
"0.5552899",
"0.55346... | 0.56218064 | 14 |
Converts examples into TexttoText batches to be used with a model like T5. Inputs are prefixed with a text prompt that indicates the task to perform. | def convert_xnli_examples_to_features(self):
features = self.features
lang_filtered_features = []
for ex_index, example in enumerate(self.examples):
language = example.guid.split('-')[1]
if language in self.lang_list:
lang_filtered_features.append(features[ex_index] + [language])
return lang_filtered_features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_tokenize_fn(examples):\n sources = examples[config.source_lang]\n targets = examples[config.target_lang]\n model_inputs = config.tokenizer(sources, max_length=config.max_source_length, truncation=True)\n\n # setup the tokenizer for targets,\n # huggingface expects the target tokenized ids ... | [
"0.6111713",
"0.5924071",
"0.58839375",
"0.5859931",
"0.5800309",
"0.5781618",
"0.5774486",
"0.57522273",
"0.57205606",
"0.56961256",
"0.56917894",
"0.5685472",
"0.5684877",
"0.5684489",
"0.5622114",
"0.56032103",
"0.5577944",
"0.55711997",
"0.5566548",
"0.555741",
"0.5552782... | 0.0 | -1 |
Export the settings as a DOM node. | def _exportNode(self):
node = ZCatalogXMLAdapter._exportNode(self)
self._logger.info('Person Catalog settings exported.')
return node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _exportNode(self):\n node = self._extractProperties()\n self._logger.info('settings exported.')\n return node",
"def saveToXml(self) -> org.jdom.Element:\n ...",
"def to_xml(self):\r\n element = ET.Element(\"node\")\r\n\r\n element.attrib['name'] = self.name\r\n ... | [
"0.7224327",
"0.56396407",
"0.5610303",
"0.55762726",
"0.5313067",
"0.5309712",
"0.5301959",
"0.5281795",
"0.52664566",
"0.5236637",
"0.52181643",
"0.5208334",
"0.51855683",
"0.517911",
"0.51764274",
"0.51666445",
"0.5144142",
"0.5129619",
"0.5117044",
"0.51037055",
"0.510011... | 0.63378537 | 1 |
Import the settings from the DOM node. | def _importNode(self, node):
ZCatalogXMLAdapter._importNode(self, node)
self._logger.info('Person Catalog settings imported.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _importNode(self, node):\n if self.environ.shouldPurge():\n self._purgeProperties()\n self._initProperties(node)\n self._logger.info('settings imported.')",
"def load_settings(self):\n\n self.std = settings.settings",
"def __init__(self, settings_xml):\n # The list... | [
"0.6894675",
"0.54793346",
"0.5375706",
"0.5349439",
"0.5210967",
"0.50370497",
"0.4952911",
"0.49231037",
"0.48926273",
"0.48800564",
"0.48647884",
"0.48480543",
"0.4817451",
"0.48003417",
"0.47981542",
"0.4741064",
"0.47284755",
"0.4716894",
"0.46843192",
"0.46814933",
"0.4... | 0.58705205 | 1 |
Label watersheds based on Barnes' priority flood algorithm | def watersheds(np.ndarray[dtype=float_t, ndim=2, mode="c"] z, missing_value = 0):
cdef np.ndarray[dtype=int_t, ndim=2, mode="c"] output
output = np.empty_like(z, dtype='i')
priority_flood_c.priority_flood_watersheds_wrapper(z.shape[1], z.shape[0], <float*>z.data, <int*>output.data, missing_value)
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def watershed_supervised(graph, seeds):\n \n size_data = graph.shape[0]\n \n u, v, w = sp.sparse.find(graph)\n list_edges = list(zip(u,v,w))\n list_edges.sort(key = lambda x : x[2])\n \n UF = unionfind(size_data)\n labels = np.array(seeds, dtype=np.int32, copy=True)\n \n for e in l... | [
"0.7240329",
"0.65720975",
"0.62097526",
"0.6137392",
"0.6120207",
"0.5910127",
"0.5895485",
"0.585058",
"0.58383656",
"0.5824214",
"0.57871556",
"0.5696335",
"0.5649472",
"0.5627702",
"0.5602631",
"0.5593537",
"0.5549893",
"0.55149436",
"0.5510126",
"0.54956084",
"0.54879755... | 0.51125866 | 66 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.