Union[AnyStr, Any]:\n pass","def _parse_attributes(self, attributes, node):\n for attr in attributes:\n if attr.value.ByteSize() > self.MAX_NODE_ATTRIBUTE_VALUE_BYTES:\n message = f\"The attribute value of node({node.name}) \" \\\n f\"is over {self.MAX_NODE_ATTRIBUTE_VALUE_BYTES} Bytes, will ignore.\"\n logger.warning(message)\n continue\n if attr.name in ('input_is_dynamic_shape', 'output_is_dynamic_shape') and not \\\n node.is_dynamic_shape_node and attr.value.bool_val:\n node.is_dynamic_shape_node = True\n node.add_attr({attr.name: str(attr.value)})","def SetAttribute(self, *args):\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUL2_SetAttribute(self, *args)","def __setattr__(self, name, value):\n if name in ['parameters', 'program_name']: # Allowed attributes\n self.__dict__[name] = value\n else:\n self.set_parameter(name, value) # treat as a parameter","def copyAttr(*args, attribute: Union[AnyStr, List[AnyStr]]=\"\", containerParentChild: bool=True,\n inConnections: bool=True, keepSourceConnections: bool=True, outConnections:\n bool=True, renameTargetContainer: bool=True, values: bool=True, q=True, query=True,\n e=True, edit=True, **kwargs)->Union[None, Any]:\n pass","def __init__(self):\n\n try:\n # read attributes from attributes file\n with open(const.Storage.ATTRIBUTES) as attributes_file:\n # read the file and parse it to JSON data\n json_data = attributes_file.read()\n attributes = json.loads(json_data)\n\n # set attributes\n self.id = str(attributes[\"id\"])\n self.length = float(attributes[\"length\"])\n self.width = float(attributes[\"width\"])\n except OSError:\n raise OSError(\"The attributes file could not be opened.\")","def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices = None) -> None:\n raise NotImplementedError()","def __init__(self,\n *,\n attributes: List['Attribute'] = None) -> None:\n self.attributes = attributes","def __init__(self, *args):\n this = _libsbml.new_XMLAttributes(*args)\n try: self.this.append(this)\n except: self.this = this","def set_attrs(self, **kwargs) -> None:\n self._obj.coords[GEO_MAP_COORD].attrs.update(**kwargs)","def __init__(self, manifest, mode='train'):\n self.audio_links = [line.rstrip('\\n').split(' ')[0] for line in open(manifest)]\n self.labels_emotion = [int(line.rstrip('\\n').split(' ')[1]) for line in open(manifest)]\n self.labels_gender = [int(line.rstrip('\\n').split(' ')[2]) for line in open(manifest)]","def set_alembic_effect_attributes(self, geo_nodes, attribute_data):\n data = zip(\n geo_nodes,\n attribute_data['render_attrs'],\n attribute_data['shaders'],\n attribute_data['parents'],\n attribute_data['visibility_curves'],\n attribute_data['visibility_values'],\n )\n for node, render_attr, shader, parent, vis_curve, vis_value in data:\n # Get transform node for parenting and setting visibility\n transform = node\n if mc.nodeType(transform) != 'transform':\n transform = mc.listRelatives(\n node, parent=True, fullPath=True\n )[0]\n\n # Set visbility value\n mc.setAttr('{}.visibility'.format(transform), vis_value)\n # Attach visibility curve\n if vis_curve is not None:\n mc.connectAttr(\n '{}.output'.format(vis_curve),\n '{}.visibility'.format(transform)\n )\n\n # Set attribute values\n errors = []\n for attribute, value in render_attr.items():\n if not self.set_attribute(node, attribute, value):\n errors.append(\n \"Couldn't set the attribute {} on {}\".format(\n attribute, node\n )\n )\n if errors:\n DisplayMayaDialog.displayMayaDialog(\n 'Error setting attributes',\n '\\n'.join(errors),\n severity=DisplayMayaDialog.SeverityTypes.WARNING\n )\n\n # Set shader\n if len(shader):\n mc.sets(node, e=True, forceElement=shader[0])\n\n # Parent node (done at the end to avoid naming problems caused by\n # changing hierarchy)\n mc.parent(transform, parent)[0]","def add_attributes(data, **kwargs):\n for key in kwargs:\n data[key] = kwargs[key]","def update(self, *args, **kwargs):\n if args and len(args) > 0:\n keys = [\"id\", \"width\", \"height\", \"x\", \"y\"]\n for i, v in enumerate(args):\n setattr(self, keys[i], v)\n else:\n for k, v in kwargs.items():\n setattr(self, k, v)","def update(self, *args, **kwargs):\n assign = ('id', 'width', 'height', 'x', 'y')\n if args:\n for key, idx in zip(assign, range(len(args))):\n exec('self.{} = {}'.format(key, args[idx]))\n else:\n for key, val in kwargs.items():\n if key in ('id', 'width', 'height', 'x', 'y'):\n exec('self.{} = {}'.format(key, val))","def set(self, **attrs):\n self.graph._setattrs(handle=self.handle, **attrs)","def SetAttribute(self, *args):\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUC3_SetAttribute(self, *args)","def configure_args(self):\n super(InstaApriori, self).configure_args()\n self.add_passthru_arg('-iteration', type=int, help=\"The current iteration. Not used as a command line argument\")\n self.add_passthru_arg('--k', type=int, default=3, help=\"Specify the maximum size of itemsets to find\")\n self.add_passthru_arg('--s', type=float, help=\"Specify the minimum support threshold\")\n self.add_passthru_arg('--c', type=float, default=0, help=\"Specify the minimum confidence threshold\")\n self.add_file_arg('--f', default='frequent.txt',\n help=\"Specify the name of the file used to store frequent itemsets\")","def generate_attributes(self):\n for group in self.dict:\n for param in self.dict[group]:\n if group in self.group_douplicate and param in self.name_douplicate:\n setattr(self, group+'_'+param, self(group, param))\n else:\n setattr(self, param, self(group, param))","def setAttr(*args, alteredValue: bool=True, caching: bool=True, capacityHint: int=0,\n channelBox: bool=True, clamp: bool=True, keyable: bool=True, lock: bool=True, size:\n int=0, type: AnyStr=\"\", q=True, query=True, e=True, edit=True,\n **kwargs)->Union[None, Any]:\n pass","def artAttrCtx(*args, accopacity: bool=False, activeListChangedProc: Union[AnyStr, bool]=\"\",\n afterStrokeCmd: Union[AnyStr, bool]=\"\", alphaclamp: Union[AnyStr, bool]=\"none\",\n alphaclamplower: Union[float, bool]=0.0, alphaclampupper: Union[float, bool]=1.0,\n attrSelected: Union[AnyStr, bool]=\"\", beforeStrokeCmd: Union[AnyStr, bool]=\"\",\n brushalignment: bool=True, brushfeedback: bool=True, clamp: Union[AnyStr,\n bool]=\"none\", clamplower: Union[float, bool]=0.0, clampupper: Union[float,\n bool]=1.0, clear: bool=True, colorAlphaValue: Union[float, bool]=0.0,\n colorRGBAValue: Union[List[float, float, float, float], bool]=None,\n colorRGBValue: Union[List[float, float, float], bool]=None, colorRamp:\n Union[AnyStr, bool]=\"\", colorfeedback: bool=False, colorfeedbackOverride:\n bool=False, colorrangelower: Union[float, bool]=0.0, colorrangeupper:\n Union[float, bool]=1.0, dataTypeIndex: Union[int, bool]=0, disablelighting:\n bool=False, dragSlider: AnyStr=\"\", duringStrokeCmd: Union[AnyStr, bool]=\"\",\n dynclonemode: bool=True, exists: bool=True, expandfilename: bool=True,\n exportaspectratio: Union[float, bool]=0.0, exportfilemode: Union[AnyStr,\n bool]=\"luminance/rgb\", exportfilesave: AnyStr=\"\", exportfilesizex: Union[int,\n bool]=0, exportfilesizey: Union[int, bool]=0, exportfiletype: Union[AnyStr,\n bool]=\"\", filterNodes: bool=True, history: bool=True, image1: Union[AnyStr,\n bool]=\"\", image2: Union[AnyStr, bool]=\"\", image3: Union[AnyStr, bool]=\"\",\n importfileload: AnyStr=\"\", importfilemode: Union[AnyStr, bool]=\"alpha\",\n importreassign: bool=False, interactiveUpdate: bool=True, lastRecorderCmd:\n Union[AnyStr, bool]=\"\", lastStampName: Union[AnyStr, bool]=\"\", lowerradius:\n Union[float, bool]=0.0, makeStroke: Union[int, List[int], bool]=0, mappressure:\n Union[AnyStr, bool]=\"none\", maxvalue: Union[float, bool]=1.0, minvalue:\n Union[float, bool]=0.0, name: AnyStr=\"\", objattrArray: Union[AnyStr, bool]=\"\",\n opacity: Union[float, bool]=1.0, outline: bool=True, outwhilepaint: bool=False,\n paintNodeArray: Union[AnyStr, bool]=\"\", paintattrselected: AnyStr=\"\", paintmode:\n Union[AnyStr, bool]=\"screen\", paintoperationtype: Union[AnyStr, bool]=\"Paint\",\n pickColor: bool=True, pickValue: bool=True, playbackCursor: Union[List[float,\n float], List[List[float, float]], bool]=None, playbackPressure: Union[float,\n List[float], bool]=0.0, preserveclonesource: bool=True, profileShapeFile:\n Union[AnyStr, bool]=\"\", projective: bool=False, radius: Union[float, bool]=1.0,\n rampMaxColor: Union[List[float, float, float], bool]=None, rampMinColor:\n Union[List[float, float, float], bool]=None, record: bool=True, reflection:\n bool=False, reflectionaboutorigin: bool=True, reflectionaxis: Union[AnyStr,\n bool]=\"x\", screenRadius: Union[float, bool]=0.0, selectclonesource: bool=True,\n selectedattroper: Union[AnyStr, bool]=\"absolute\", showactive: bool=True,\n stampDepth: Union[float, bool]=0.0, stampProfile: Union[AnyStr, bool]=\"\",\n stampSpacing: Union[float, bool]=1.0, strokesmooth: Union[AnyStr, bool]=\"\",\n surfaceConformedBrushVertices: bool=True, tablet: bool=True, tangentOutline:\n bool=True, toolOffProc: Union[AnyStr, bool]=\"\", toolOnProc: Union[AnyStr,\n bool]=\"\", useColorRamp: bool=True, useMaxMinColor: bool=True, usepressure:\n bool=False, value: Union[float, bool]=0.0, whichTool: Union[AnyStr, bool]=\"\",\n worldRadius: Union[float, bool]=0.0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass","def process_all(fileinfos, args):\n # create overall figure\n count_and_draw(fileinfos,args)\n # create figures for all the files\n for key in fileinfos:\n count_and_draw(fileinfos,args,key)\n # create figures for all the elements\n els_processed = []\n for key in fileinfos:\n for key in fileinfos[key][\"usage_el\"]:\n if key not in els_processed:\n count_and_draw(fileinfos,args,key)\n els_processed.append(key)\n # create figures for all the attributes\n atts_processed = []\n for key in fileinfos:\n for key in fileinfos[key][\"usage_att\"]:\n if key not in atts_processed:\n count_and_draw(fileinfos,args,\"@\"+key)\n atts_processed.append(key)","def set_attribute(self, name, value):\n\n pass","def SetExportAttrs(self, param, attrs):\n parent, unused_name = self.FindExport(param)\n if not hasattr(parent.obj, 'SetAttributes'):\n return False\n parent.obj.SetAttributes(attrs)\n return True","def __init__(self, name, process_step=None, **attributes):\n self.name = name\n self.process_step = process_step\n # Check the config file for the process metadata if process step not provided\n if process_step is None:\n cfg_def = cfg.read_procedures()[name]\n self.process_step = cfg_def['process_step']\n attributes = cfg_def.copy()\n \n\n #self.source = source\n self.attributes = attributes\n #self.attributes['standard_name'] = 'source'","def overwrite_attrs(self, src_detail, attrs):\n case_tile_configuration_list = [\n 'case_tile_template',\n 'persist_tile_on_forms',\n 'persistent_case_tile_from_module',\n 'pull_down_tile',\n 'persist_case_context',\n 'persistent_case_context_xml',\n 'case_tile_group',\n ]\n for attr in attrs:\n if attr == \"case_tile_configuration\":\n for ele in case_tile_configuration_list:\n setattr(self, ele, getattr(src_detail, ele))\n else:\n setattr(self, attr, getattr(src_detail, attr))","def update(self, *argv, **kwargs):\n if argv and len(argv) > 0:\n for counter, arg in enumerate(argv, 0):\n if counter == len(argv):\n break\n if counter == 0 and arg is not None:\n self.id = arg\n elif counter == 1:\n self.size = arg\n elif counter == 2:\n self.x = arg\n elif counter == 3:\n self.y = arg\n elif kwargs and len(kwargs) > 0:\n for k, v in kwargs.items():\n if k == \"id\" and v is not None:\n self.id = v\n elif k == \"size\":\n self.size = v\n elif k == \"x\":\n self.x = v\n elif k == \"y\":\n self.y = v","def add_attributes(self, attributes):\n self.attributes = dict(self.attributes, **attributes)","def add_attribute(self, key, value):\n if key == \"process_step\":\n self.process_step = value\n elif key == \"source\":\n self.source = value\n else:\n self.attributes[key] = value"],"string":"[\n \"def _set_attributes(self):\",\n \"def set_attr(self):\\n\\n # Create a new array\\n self.fileh.create_array('/', 'array', self.a1)\\n for i in range(self.nobjects):\\n # Set an attribute\\n setattr(self.fileh.root.array.attrs, \\\"attr\\\" + str(i), str(self.a1))\\n # Put a mark\\n self.fileh.mark()\\n # Unwind all marks sequentially\\n for i in range(self.niter):\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.undo()\\n if verbose:\\n print(\\\"u\\\", end=' ')\\n if verbose:\\n print()\\n undo = clock() - t1\\n # Rewind all marks sequentially\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.redo()\\n if verbose:\\n print(\\\"r\\\", end=' ')\\n if verbose:\\n print()\\n redo = clock() - t1\\n\\n print(\\\"Time for Undo, Redo (set_attr):\\\", undo, \\\"s, \\\", redo, \\\"s\\\")\",\n \"def setAttributes(self, args):\\n for atr in self.defaultAttributes:\\n if args.has_key(atr):\\n # convert atr to proper type\\n objAttr = getattr(self, atr)\\n myType = type(args[atr])\\n if type(objAttr) == types.IntType and myType <> types.IntType:\\n args[atr] = int(args[atr])\\n elif type(objAttr) == types.StringType and myType <> types.StringType:\\n args[atr] = str(args[atr])\\n elif type(objAttr) == types.ListType and myType <> types.ListType:\\n args[atr] = eval(args[atr])\\n elif type(objAttr) == types.DictType and myType <> types.DictType:\\n args[atr] = eval(args[atr])\\n elif type(objAttr) == types.FloatType and myType <> types.FloatType:\\n args[atr] = float(args[atr])\\n setattr(self, atr, args[atr])\",\n \"def __init__(self, fileName):\\n reader = pcssTools.PcssFileReader(fileName)\\n lines = reader.getLines()\\n self._attributes = {}\\n inputCounter = 0\\n outputCounter = 0\\n for line in lines:\\n\\n [name, attributeType, optional, niceName, featureClass, io] = line.split('\\\\t')\\n att = PcssFileAttribute(name, attributeType, optional, niceName, featureClass, io)\\n if (att.isInputAttribute()):\\n att.setInputOrder(inputCounter)\\n inputCounter += 1\\n if (att.isOutputAttribute()):\\n att.setOutputOrder(outputCounter)\\n outputCounter += 1\\n self.setFileAttribute(att)\",\n \"def set_attr_values(self):\\n ats = self.attributes # convenient short name\\n for aid in ats:\\n value = ats[aid]['nv'] if 'nv' in ats[aid] else (\\n ats[aid]['value'] if 'value' in ats[aid] else None)\\n if value is not None:\\n# self.h5node.attrs[aid] = value\\n #- self.file.file_pointer[self.full_path].attrs[aid] = value\\n self.file.set_attribute(self.full_path, aid, value)\\n #- self.file.h5save_attribute(self.full_path, aid, value)\\n #- self.file.h5commands.append(\\\"set attribute(%s:%s)-%s\\\" % (self.full_path,\\n #- aid, value))\",\n \"def set_attributes(self, attributes):\\n self.attributes = dict(attributes) # overwrite the existing registry of attributes with the input attributes\",\n \"def set_attributes(self, attributes):\\n self.attributes = dict(attributes) # overwrite the existing registry of attributes with the input attributes\",\n \"def set_attributes(self, attributes):\\n self.attributes = dict(attributes) # overwrite the existing registry of attributes with the input attributes\",\n \"def set_attributes(self, attributes):\\n self.attributes = attributes\",\n \"def set_attrs(self, username, attrs):\\n pass\",\n \"def set_attributes(self):\\n\\n self.input_file = None # the InputFile object\\n self.namelist = None # the currently selected namelist\\n self.file_loaded = False # is an input file loaded or not\",\n \"def __init__(self, **attributes):\\n for key, value in attributes.items():\\n setattr(self, key, value)\",\n \"def setAttributes(self, *args):\\n return _libsbml.XMLToken_setAttributes(self, *args)\",\n \"def _yamlSetAttributes(self, attributes):\\n extra = dict([(key, value)\\n for key, value in attributes.items()\\n if key not in self._yamlAttributeKeys])\\n self._preservedExtraAttributes.update(extra)\\n\\n keys = [key for key in attributes.keys()\\n if (key in self._yamlAttributeKeys)\\n and (key not in self._yamlSpeciallyHandledAttributes)]\\n for key in keys:\\n setattr(self, key, attributes[key])\",\n \"def set_attributes(self, argv):\\n if argv[0] == \\\"population\\\" or argv[0] == \\\"pop\\\":\\n if argv[1] == \\\"ttl\\\":\\n self.population[int(argv[2])].ttl = int(argv[3])\",\n \"def _setAttributes(self, primaryAttr, attrs):\\n return False\",\n \"def _set_attr(self):\\n self.as_skeletal = self._import_as_skeleton()\\n self.materials = self._import_materials()\\n self.textures = self._import_textures()\",\n \"def set_attributes(self, attributes: typing.Dict[str, types.AttributeValue]) -> None:\\n if not attributes:\\n return\\n for key, value in attributes.items():\\n self.set_attribute(key, value)\",\n \"def update(self, *args, **kwargs):\\n if args is not () and args is not None:\\n attr_names = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n for index, attr in enumerate(args):\\n setattr(self, attr_names[index], attr)\\n else:\\n for key, value in kwargs.items():\\n if hasattr(self, key):\\n setattr(self, key, value)\",\n \"def set_attributes(object, attributes):\\n for name, attribute in attributes.items():\\n setattr(object, name, attribute)\",\n \"def __init__(self, image_dir, attr_path, selected_attrs, transform, mode):\\n self.image_dir = image_dir\\n self.attr_path = attr_path\\n self.selected_attrs = selected_attrs\\n self.transform = transform\\n self.mode = mode\\n self.train_dataset = []\\n self.test_dataset = []\\n self.attr2idx = {}\\n self.idx2attr = {}\\n self.preprocess()\\n\\n if mode == 'train':\\n self.num_images = len(self.train_dataset)\\n else:\\n self.num_images = len(self.test_dataset)\",\n \"def updateAttrs(self, kwargs):\\n for k, v in kwargs.iteritems():\\n setattr(self, k, v)\",\n \"def set_attr(self, name: str, values: Union[list, tuple, object]):\",\n \"def setattrs(self, data, attrlist, id_array=None):\\n\\t\\tassert len(data) == len(attrlist)\\n\\t\\tfor d, attr in zip(data, attrlist):\\n\\t\\t\\tif id_array == None: setattr(self, attr, d)\\n\\t\\t\\telse:getattr(self, attr)[id_array] = d # Setting 1d array elements\",\n \"def read_attributes(self, dataset):\\n if 'attributes' in self.configs:\\n for key, value in self.configs['attributes'].items():\\n setattr(dataset, key, value)\",\n \"def setAttrMapping(*args, absolute: bool=True, attribute: Union[AnyStr, List[AnyStr]]=\\\"\\\", axis:\\n AnyStr=\\\"\\\", clutch: AnyStr=\\\"\\\", device: AnyStr=\\\"\\\", offset: float=0.0,\\n relative: bool=True, scale: float=0.0, selection: bool=True, q=True,\\n query=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def AssignAttributes(self, attr):\\r\\n \\r\\n self.SetAttributes(attr)\\r\\n self._ownsAttr = True\",\n \"def update(self, *args, **kwargs):\\n if len(args) != 0:\\n i = 0\\n attr = ['id', 'width', 'height', 'x', 'y']\\n for arg in args:\\n setattr(self, attr[i], args[i])\\n i += 1\\n else:\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def setAttributeValue(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n pass\",\n \"def attributes(self, attributes):\\n\\n self._attributes = attributes\",\n \"def attributes(self, attributes):\\n\\n self._attributes = attributes\",\n \"def AttribFile(file, attr=\\\"-R -S -H -I\\\", *params):\\n\\n params = \\\" \\\".join(params).split() # handle tuples and multispaced items\\n if isinstance(attr, (tuple, list, set)):\\n attr = \\\" \\\".join(attr)\\n lines = attr.split() + [file] + params\\n attrib = subprocess.Popen([\\\"C:\\\\\\\\Windows\\\\\\\\System32\\\\\\\\attrib.exe\\\"] + lines)\\n attrib.communicate()\\n return attrib.returncode\",\n \"def __init__(self, **attributes):\\n self.set(**attributes)\",\n \"def setAttributesFromCmdLine(self):\\n try:\\n opts, args = getopt.getopt(sys.argv[1:],\\n \\\"hVv:i:\\\",\\n [\\\"help\\\", \\\"version\\\", \\\"verbose=\\\",\\n \\\"proj1=\\\",\\n \\\"proj2=\\\",\\n \\\"step=\\\",\\n \\\"samples=\\\",\\n \\\"fcln=\\\",\\n \\\"dict=\\\",\\n \\\"schdlr=\\\",\\n \\\"queue=\\\",\\n \\\"enz=\\\",\\n \\\"dmxmet=\\\",\\n \\\"subst=\\\",\\n \\\"ensubst=\\\",\\n \\\"adp=\\\",\\n \\\"errtol=\\\",\\n \\\"minovl=\\\",\\n \\\"minrl=\\\",\\n \\\"minq=\\\",\\n \\\"maxNp=\\\",\\n \\\"ref=\\\",\\n \\\"jgid=\\\",\\n \\\"rat=\\\",\\n \\\"mdp=\\\",\\n \\\"mgq=\\\",\\n \\\"mnfg=\\\",\\n \\\"mffg=\\\",\\n \\\"mnnc=\\\",\\n \\\"mfnc=\\\",\\n \\\"fam=\\\",\\n \\\"mvq=\\\",\\n \\\"xlssf=\\\",\\n \\\"tmpd=\\\",\\n \\\"jvmXms=\\\",\\n \\\"jvmXmx=\\\",\\n \\\"queue2=\\\",\\n \\\"knowni=\\\",\\n \\\"known=\\\",\\n \\\"force\\\",\\n \\\"pird=\\\",\\n \\\"resou=\\\",\\n \\\"rmvb\\\"])\\n except getopt.GetoptError as err:\\n sys.stderr.write(\\\"%s\\\\n\\\\n\\\" % str(err))\\n # self.help()\\n sys.exit(2)\\n for o, a in opts:\\n if o == \\\"-h\\\" or o == \\\"--help\\\":\\n self.help()\\n sys.exit(0)\\n elif o == \\\"-V\\\" or o == \\\"--version\\\":\\n self.version()\\n sys.exit(0)\\n elif o == \\\"-v\\\" or o == \\\"--verbose\\\":\\n self.verbose = int(a)\\n elif o == \\\"--proj1\\\":\\n self.project1Id = a\\n elif o == \\\"--proj2\\\":\\n self.project2Id = a\\n elif o == \\\"--schdlr\\\":\\n self.scheduler = a\\n elif o == \\\"--queue\\\":\\n self.queue = a\\n elif o == \\\"--resou\\\":\\n self.lResources = a.split()\\n elif o == \\\"--rmvb\\\":\\n self.rmvBash = True\\n elif o == \\\"--step\\\":\\n self.lSteps = [a]\\n elif o == \\\"--samples\\\":\\n self.samplesFile = a\\n elif o == \\\"--fcln\\\":\\n self.fclnToKeep = a\\n elif o == \\\"--pird\\\":\\n self.pathToInReadsDir = a\\n elif o == \\\"--enz\\\":\\n self.enzyme = a\\n elif o == \\\"--dmxmet\\\":\\n self.dmxMethod = a\\n elif o == \\\"--subst\\\":\\n self.nbSubstsAllowedDemult = int(a)\\n elif o == \\\"--ensubst\\\":\\n self.enforceSubst = a\\n elif o == \\\"--adp\\\":\\n self.adpFile = a\\n elif o == \\\"--errtol\\\":\\n self.errTol = float(a)\\n elif o == \\\"--minovl\\\":\\n self.minOvl = int(a)\\n elif o == \\\"--minrl\\\":\\n self.minReadLen = int(a)\\n elif o == \\\"--minq\\\":\\n self.minQual = int(a)\\n elif o == \\\"--maxNp\\\":\\n self.maxNPerc = float(a)\\n elif o == \\\"--ref\\\":\\n self.pathToPrefixRefGenome = a\\n elif o == \\\"--dict\\\":\\n self.dictFile = a\\n elif o == \\\"--jgid\\\":\\n self.jointGenoId = a\\n elif o == \\\"--rat\\\":\\n self.restrictAllelesTo = a\\n elif o == \\\"--mdp\\\":\\n self.minDp = int(a)\\n elif o == \\\"--mgq\\\":\\n self.minGq = int(a)\\n elif o == \\\"--mnfg\\\":\\n self.maxNbFilterGenos = int(a)\\n elif o == \\\"--mffg\\\":\\n self.maxFracFilterGenos = float(a)\\n elif o == \\\"--mnnc\\\":\\n self.maxNbNocallGenos = int(a)\\n elif o == \\\"--mfnc\\\":\\n self.maxFracNocallGenos = float(a)\\n elif o == \\\"--fam\\\":\\n self.famFile = a\\n elif o == \\\"--mvq\\\":\\n self.mendelianViolationQualThreshold = int(a)\\n elif o == \\\"--xlssf\\\":\\n self.excludeSampleFile = a\\n elif o == \\\"--tmpd\\\":\\n self.tmpDir = a\\n elif o == \\\"--jvmXms\\\":\\n self.jvmXms = a\\n elif o == \\\"--jvmXmx\\\":\\n self.jvmXmx = a\\n elif o == \\\"--queue2\\\":\\n self.queue2 = a\\n elif o == \\\"--knowni\\\":\\n self.knownIndelsFile = a\\n elif o == \\\"--known\\\":\\n self.knownFile = a\\n elif o == \\\"--force\\\":\\n self.forceRerunSteps = True\\n else:\\n assert False, \\\"invalid option\\\"\",\n \"def SetAttributes(self, attr):\\r\\n \\r\\n if self._ownsAttr:\\r\\n del self._attr\\r\\n \\r\\n self._attr = attr\\r\\n self._ownsAttr = False\",\n \"def setAttributeArray(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads\\n pass\",\n \"def update(self, *args, **kwargs):\\n attributes = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n if len(args) > 0:\\n for i in range(len(args)):\\n setattr(self, attributes[i], args[i])\\n else:\\n self.id = kwargs.get(\\\"id\\\", self.id)\\n self.size = kwargs.get(\\\"size\\\", self.size)\\n self.x = kwargs.get(\\\"x\\\", self.x)\\n self.y = kwargs.get(\\\"y\\\", self.y)\",\n \"def update(self, *args, **kwargs):\\n arg_name = ['id', 'width', 'height', 'x', 'y']\\n \\\"\\\"\\\" If args only, sets attribute to correct arg_name \\\"\\\"\\\"\\n if len(args) > 0:\\n numArgs = 0\\n for attr in range(len(args)):\\n setattr(self, arg_name[numArgs], args[numArgs])\\n numArgs += 1\\n \\\"\\\"\\\" Put kwargs into dict - if key matches arg_name, set to value \\\"\\\"\\\"\\n kwargs_dict = kwargs\\n for key, value in kwargs_dict.items():\\n for attr in range(len(arg_name)):\\n if key == arg_name[attr]:\\n setattr(self, arg_name[attr], value)\",\n \"def __init__(self, **initial_attributes):\\n\\n for attribute_name, attribute_value in initial_attributes.items():\\n setattr(self, attribute_name, attribute_value)\",\n \"def __init__(self, images, attributes, batch_size, v_flip=False, h_flip=True):\\n assert images.size(0) == attributes.size(0), (images.size(), attributes.size())\\n self.images = images\\n self.attributes = attributes\\n self.batch_size = batch_size\\n self.v_flip = v_flip\\n self.h_flip = h_flip\",\n \"def __init__(self, **attrs):\\n \\n # set given attributes\\n for name, value in attrs.items():\\n if hasattr(self, name):\\n setattr(self, name, value)\\n else:\\n raise AttributeError(\\\"Attribute not found! --> %s\\\" % name)\",\n \"def _set_input_for_current_file(self):\\n for attr, obj in self.get_input_from_file(self.file).items():\\n setattr(self, attr, obj)\",\n \"def batch_add(self, *args, **kwargs):\\n new_attrobjs = []\\n strattr = kwargs.get(\\\"strattr\\\", False)\\n for tup in args:\\n if not is_iter(tup) or len(tup) < 2:\\n raise RuntimeError(\\\"batch_add requires iterables as arguments (got %r).\\\" % tup)\\n ntup = len(tup)\\n keystr = str(tup[0]).strip().lower()\\n new_value = tup[1]\\n category = str(tup[2]).strip().lower() if ntup > 2 and tup[2] is not None else None\\n lockstring = tup[3] if ntup > 3 else \\\"\\\"\\n\\n attr_objs = self._getcache(keystr, category)\\n\\n if attr_objs:\\n attr_obj = attr_objs[0]\\n # update an existing attribute object\\n attr_obj.db_category = category\\n attr_obj.db_lock_storage = lockstring or \\\"\\\"\\n attr_obj.save(update_fields=[\\\"db_category\\\", \\\"db_lock_storage\\\"])\\n if strattr:\\n # store as a simple string (will not notify OOB handlers)\\n attr_obj.db_strvalue = new_value\\n attr_obj.save(update_fields=[\\\"db_strvalue\\\"])\\n else:\\n # store normally (this will also notify OOB handlers)\\n attr_obj.value = new_value\\n else:\\n # create a new Attribute (no OOB handlers can be notified)\\n kwargs = {\\n \\\"db_key\\\": keystr,\\n \\\"db_category\\\": category,\\n \\\"db_model\\\": self._model,\\n \\\"db_attrtype\\\": self._attrtype,\\n \\\"db_value\\\": None if strattr else to_pickle(new_value),\\n \\\"db_strvalue\\\": new_value if strattr else None,\\n \\\"db_lock_storage\\\": lockstring or \\\"\\\",\\n }\\n new_attr = Attribute(**kwargs)\\n new_attr.save()\\n new_attrobjs.append(new_attr)\\n self._setcache(keystr, category, new_attr)\\n if new_attrobjs:\\n # Add new objects to m2m field all at once\\n getattr(self.obj, self._m2m_fieldname).add(*new_attrobjs)\",\n \"def preprocess(self):\\n lines = [line.rstrip() for line in open(self.attr_path, 'r')]\\n all_attr_names = lines[1].split()\\n for i, attr_name in enumerate(all_attr_names):\\n self.attr2idx[attr_name] = i\\n self.idx2attr[i] = attr_name\\n\\n lines = lines[2:]\\n random.seed(1234)\\n random.shuffle(lines)\\n for i, line in enumerate(lines):\\n split = line.split()\\n filename = split[0]\\n values = split[1:]\\n\\n label = []\\n for attr_name in self.selected_attrs:\\n idx = self.attr2idx[attr_name]\\n label.append(values[idx] == '1')\\n\\n if (i+1) < 4:\\n self.test_dataset.append([filename, label])\\n else:\\n self.train_dataset.append([filename, label])\",\n \"def _parse_args(self, run_args):\\n for variable, value in run_args.items():\\n self.__setattr__(variable, value)\\n # to tuple\\n self.chunk_shape = [self.chunk_shape, self.chunk_shape]\\n self.tile_shape = [self.tile_shape, self.tile_shape]\\n self.patch_input_shape = [self.patch_input_shape, self.patch_input_shape]\\n self.patch_output_shape = [self.patch_output_shape, self.patch_output_shape]\\n return\",\n \"def set_attributes(self, attributes):\\n\\n _error_code = 0\\n _msg = \\\"RAMSTK SUCCESS: Updating RAMSTKSurvivalData {0:d} attributes.\\\". \\\\\\n format(self.record_id)\\n\\n try:\\n self.name = str(none_to_default(attributes[0], ''))\\n self.source_id = int(none_to_default(attributes[1], 0))\\n self.failure_date = none_to_default(attributes[2], date.today())\\n self.left_interval = float(none_to_default(attributes[3], 0.0))\\n self.right_interval = float(none_to_default(attributes[4], 0.0))\\n self.status_id = int(none_to_default(attributes[5], 0))\\n self.quantity = int(none_to_default(attributes[6], 0))\\n self.tbf = float(none_to_default(attributes[7], 0.0))\\n self.mode_type_id = int(none_to_default(attributes[8], 0))\\n self.nevada_chart = int(none_to_default(attributes[9], 0))\\n self.ship_date = none_to_default(attributes[10], date.today())\\n self.number_shipped = int(none_to_default(attributes[11], 0))\\n self.return_date = none_to_default(attributes[12], date.today())\\n self.number_returned = int(none_to_default(attributes[13], 0))\\n self.user_float_1 = float(none_to_default(attributes[14], 0.0))\\n self.user_float_2 = float(none_to_default(attributes[15], 0.0))\\n self.user_float_3 = float(none_to_default(attributes[16], 0.0))\\n self.user_integer_1 = int(none_to_default(attributes[17], 0))\\n self.user_integer_2 = int(none_to_default(attributes[18], 0))\\n self.user_integer_3 = int(none_to_default(attributes[19], 0))\\n self.user_string_1 = str(none_to_default(attributes[20], ''))\\n self.user_string_2 = str(none_to_default(attributes[21], ''))\\n self.user_string_3 = str(none_to_default(attributes[22], ''))\\n except IndexError as _err:\\n _error_code = error_handler(_err.args)\\n _msg = \\\"RAMSTK ERROR: Insufficient number of input values to \\\" \\\\\\n \\\"RAMSTKSurvivalData.set_attributes().\\\"\\n except (TypeError, ValueError) as _err:\\n _error_code = error_handler(_err.args)\\n _msg = \\\"RAMSTK ERROR: Incorrect data type when converting one or \\\" \\\\\\n \\\"more RAMSTKSurvivalData attributes.\\\"\\n\\n return _error_code, _msg\",\n \"def process_single(fileinfos, args):\\n # does the file name exist?\\n if is_filename(args.name):\\n check_filename(args.name, fileinfos)\\n # does the attribute name exist?\\n elif is_attname(args.name):\\n check_attname(args.name, fileinfos)\\n # does the element name exist? \\n elif args.name != \\\"\\\":\\n check_elname(args.name, fileinfos)\\n \\n count_and_draw(fileinfos, args, args.name)\",\n \"def set_attributes(instance, **attributes):\\n proxy = type('SetAttr', (Proxy,), attributes)\\n return proxy(instance)\",\n \"def args(self, args):\\n self._instructions_setter('ARG', args)\",\n \"def set_attributes(self, attributes):\\n _error_code = 0\\n _msg = \\\"RAMSTK SUCCESS: Updating RAMSTKMode {0:d} attributes.\\\". \\\\\\n format(self.hardware_id)\\n\\n try:\\n self.critical_item = int(\\n none_to_default(attributes['critical_item'], 0))\\n self.description = str(\\n none_to_default(attributes['description'],\\n 'Failure Mode Description'))\\n self.design_provisions = str(\\n none_to_default(attributes['design_provisions'], ''))\\n self.detection_method = str(\\n none_to_default(attributes['detection_method'], ''))\\n self.effect_end = str(\\n none_to_default(attributes['effect_end'], 'End Effect'))\\n self.effect_local = str(\\n none_to_default(attributes['effect_local'], 'Local Effect'))\\n self.effect_next = str(\\n none_to_default(attributes['effect_next'], 'Next Effect'))\\n self.effect_probability = float(\\n none_to_default(attributes['effect_probability'], 0.0))\\n self.hazard_rate_source = str(\\n none_to_default(attributes['hazard_rate_source'], ''))\\n self.isolation_method = str(\\n none_to_default(attributes['isolation_method'], ''))\\n self.mission = str(none_to_default(attributes['mission'], ''))\\n self.mission_phase = str(\\n none_to_default(attributes['mission_phase'], ''))\\n self.mode_criticality = float(\\n none_to_default(attributes['mode_criticality'], 0.0))\\n self.mode_hazard_rate = float(\\n none_to_default(attributes['mode_hazard_rate'], 0.0))\\n self.mode_op_time = float(\\n none_to_default(attributes['mode_op_time'], 0.0))\\n self.mode_probability = str(\\n none_to_default(attributes['mode_probability'], ''))\\n self.mode_ratio = float(\\n none_to_default(attributes['mode_ratio'], 0.0))\\n self.operator_actions = str(\\n none_to_default(attributes['operator_actions'], ''))\\n self.other_indications = str(\\n none_to_default(attributes['other_indications'], ''))\\n self.remarks = str(none_to_default(attributes['remarks'], ''))\\n self.rpn_severity = int(\\n none_to_default(attributes['rpn_severity'], 1))\\n self.rpn_severity_new = int(\\n none_to_default(attributes['rpn_severity_new'], 1))\\n self.severity_class = str(\\n none_to_default(attributes['severity_class'], ''))\\n self.single_point = int(\\n none_to_default(attributes['single_point'], 0))\\n self.type_id = int(none_to_default(attributes['type_id'], 0))\\n except KeyError as _err:\\n _error_code = 40\\n _msg = \\\"RAMSTK ERROR: Missing attribute {0:s} in attribute \\\" \\\\\\n \\\"dictionary passed to \\\" \\\\\\n \\\"RAMSTKMode.set_attributes().\\\".format(_err)\\n\\n return _error_code, _msg\",\n \"def update(self, *args, **kwargs):\\n if args:\\n my_list = ['id', 'width', 'height', 'x', 'y']\\n for i in range(len(args)):\\n setattr(self, my_list[i], args[i])\\n else:\\n for key, value in kwargs.items():\\n setattr(self, key, value)\",\n \"def __init__(self, attributes_names: list):\\r\\n self.attributes_names = attributes_names\",\n \"def __init__(self, attributes_names: list):\\r\\n self.attributes_names = attributes_names\",\n \"def __init__(self,**kwargs):\\n self.attr = ['angle','width','height','m','Fg','Fs','Fd','kf','Ff']\\n # attributes of the incline in order: angle,width,height, mass,Fg(gravity force),Fs(statical force), Fd (dynamical force),kf(friction coefficient), Ff(friction force)\\n self.data = {param: None for param in self.attr}#initialazing data\\n self.given_data = set() #set of data given by user\\n self.add_data(**kwargs)\",\n \"def update(self, *args, **kwargs):\\n if args:\\n li = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n for i in range(len(args)):\\n setattr(self, li[i], args[i])\\n else:\\n for i, j in kwargs.items():\\n setattr(self, i, j)\",\n \"def set_attributes(self, new_attributes=None):\\n self.attributes = new_attributes\",\n \"def SetAttribute(self, *args):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUL3_SetAttribute(self, *args)\",\n \"def update(self, *args, **kwargs):\\n attrs = [\\\"id\\\", \\\"width\\\", \\\"height\\\", \\\"x\\\", \\\"y\\\"]\\n\\n if args:\\n for i in range(len(args)):\\n setattr(self, attrs[i], args[i])\\n elif kwargs is not None:\\n for key, value in kwargs.items():\\n if key in attrs:\\n setattr(self, key, value)\",\n \"def _setAttributes(self, reactor, done):\\n self.reactor = reactor\\n self._done = done\",\n \"def _write_attrs(self, title):\\n # XXX: Should probably all be defined in some header file.\\n self._f.attrs['api_version'] = np.float32([6.30000019])\\n self._f.attrs['version'] = np.float32([6.30000019])\\n self._f.attrs['floating_point_word_size'] = \\\\\\n np.array([self.__f_word_size], dtype=np.int32)\\n self._f.attrs['file_size'] = np.array([1], dtype=np.int32)\\n self._f.attrs['maximum_name_length'] = np.array([32],\\n dtype=np.int32)\\n self._f.attrs['int64_status'] = np.array([0], dtype=np.int32)\\n self._f.attrs['title'] = np.string_(title)\",\n \"def setup(self, **kwargs):\\n\\n for k, v in kwargs.items():\\n setattr(self, k, v)\",\n \"def process(name, attr):\\n\\t\\t\\t\\n\\t\\t\\t# If no name has been defined, define it declaratively.\\n\\t\\t\\tif not getattr(attr, '__name__', None):\\n\\t\\t\\t\\tattr.__name__ = name\\n\\t\\t\\t\\n\\t\\t\\t# If this attribute existed previously, clone the sequence number to preserve order.\\n\\t\\t\\tif name in overridden_sequence:\\n\\t\\t\\t\\tattr.__sequence__ = overridden_sequence[name]\\n\\t\\t\\t\\n\\t\\t\\t# We give attributes a chance to perform additional work.\\n\\t\\t\\tif hasattr(attr, '__fixup__'):\\n\\t\\t\\t\\tfixups.append(attr) # Record the attribute to prevent __get__ transformation later.\\n\\t\\t\\t\\n\\t\\t\\treturn name, attr\",\n \"def set_attrs(self, location, attr_dict):\\r\\n for attr in attr_dict.iterkeys():\\r\\n if attr in ['_id', 'md5', 'uploadDate', 'length']:\\r\\n raise AttributeError(\\\"{} is a protected attribute.\\\".format(attr))\\r\\n asset_db_key = self.asset_db_key(location)\\r\\n # FIXME remove fetch and use a form of update which fails if doesn't exist\\r\\n item = self.fs_files.find_one(asset_db_key)\\r\\n if item is None:\\r\\n raise NotFoundError(asset_db_key)\\r\\n self.fs_files.update(asset_db_key, {\\\"$set\\\": attr_dict})\",\n \"def _setAttribs(self, attribs):\\n if attribs:\\n # force the state\\n self.states.enable('harvested')\\n self.__attribs = []\\n for i, attrib in enumerate(attribs):\\n if isinstance(attrib, dict):\\n if not 'name' in attrib:\\n raise ValueError, \\\\\\n \\\"Harvestable: attribute must be a string or \\\" + \\\\\\n \\\"a dictionary with 'name'\\\"\\n else:\\n attrib = {'name': attrib}\\n\\n # assign default method to copy\\n if not 'copy' in attrib:\\n attrib['copy'] = self.__copy_attribs\\n\\n # check copy method\\n if not attrib['copy'] in self._KNOWN_COPY_METHODS:\\n raise ValueError, \\\"Unknown method %s. Known are %s\\\" % \\\\\\n (attrib['copy'], self._KNOWN_COPY_METHODS)\\n\\n if not ('obj' in attrib or 'attr' in attrib):\\n # Process the item to harvest\\n # split into obj, attr. If obj is empty, then assume self\\n split = attrib['name'].split('.', 1)\\n if len(split)==1:\\n obj, attr = split[0], None\\n else:\\n obj, attr = split\\n attrib.update({'obj':obj, 'attr':attr})\\n\\n if attrib['obj'] == '':\\n attrib['obj'] = 'self'\\n\\n # TODO: may be enabling of the states??\\n\\n self.__attribs.append(attrib) # place value back\\n else:\\n # just to make sure it is not None or 0\\n self.__attribs = []\",\n \"def assign_attrs(elem, attrs):\\n for k, v in attrs:\\n # assign attr k with v\\n # override class\\n elem.set(sanitize_name(k), v)\",\n \"def handleAttributes(text, parent):\\r\\n def attributeCallback(match):\\r\\n parent.set(match.group(1), match.group(2).replace('\\\\n', ' '))\\r\\n return ATTR_RE.sub(attributeCallback, text)\",\n \"def set_attr(zone, attr, line):\\n zone.set_attr(attr, line[attr])\",\n \"def _set_attrs(ds, **attrs_map):\\n for key in attrs_map:\\n val = attrs_map[key] # Use Python 2/3 agnostic style\\n ds.attrs[key] = val\",\n \"def add_attributes(self, attrs):\\n for attr in attrs:\\n self.add_attribute(attr)\",\n \"def set_attr(self, asset_key, attr, value=True):\\r\\n self.set_attrs(asset_key, {attr: value})\",\n \"def set_attrib(self, key, func, func_args):\\n self.aux_attrib[key] = func\\n self.aux_attrib_args[key] = func_args\",\n \"def attrControlGrp(*args, annotation: Union[AnyStr, bool]=\\\"\\\", attribute: Union[name, bool]=None,\\n changeCommand: Union[Script, bool]=None, enable: bool=True, exists:\\n bool=True, handlesAttribute: Union[name, bool]=None, hideMapButton:\\n bool=True, label: Union[AnyStr, bool]=\\\"\\\", preventOverride: bool=True, q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def _parse_attributes(self, attributes, node):\\n for attr in attributes:\\n if attr.value.ByteSize() > self.MAX_NODE_ATTRIBUTE_VALUE_BYTES:\\n message = f\\\"The attribute value of node({node.name}) \\\" \\\\\\n f\\\"is over {self.MAX_NODE_ATTRIBUTE_VALUE_BYTES} Bytes, will ignore.\\\"\\n logger.warning(message)\\n continue\\n if attr.name in ('input_is_dynamic_shape', 'output_is_dynamic_shape') and not \\\\\\n node.is_dynamic_shape_node and attr.value.bool_val:\\n node.is_dynamic_shape_node = True\\n node.add_attr({attr.name: str(attr.value)})\",\n \"def SetAttribute(self, *args):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUL2_SetAttribute(self, *args)\",\n \"def __setattr__(self, name, value):\\n if name in ['parameters', 'program_name']: # Allowed attributes\\n self.__dict__[name] = value\\n else:\\n self.set_parameter(name, value) # treat as a parameter\",\n \"def copyAttr(*args, attribute: Union[AnyStr, List[AnyStr]]=\\\"\\\", containerParentChild: bool=True,\\n inConnections: bool=True, keepSourceConnections: bool=True, outConnections:\\n bool=True, renameTargetContainer: bool=True, values: bool=True, q=True, query=True,\\n e=True, edit=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def __init__(self):\\n\\n try:\\n # read attributes from attributes file\\n with open(const.Storage.ATTRIBUTES) as attributes_file:\\n # read the file and parse it to JSON data\\n json_data = attributes_file.read()\\n attributes = json.loads(json_data)\\n\\n # set attributes\\n self.id = str(attributes[\\\"id\\\"])\\n self.length = float(attributes[\\\"length\\\"])\\n self.width = float(attributes[\\\"width\\\"])\\n except OSError:\\n raise OSError(\\\"The attributes file could not be opened.\\\")\",\n \"def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices = None) -> None:\\n raise NotImplementedError()\",\n \"def __init__(self,\\n *,\\n attributes: List['Attribute'] = None) -> None:\\n self.attributes = attributes\",\n \"def __init__(self, *args):\\n this = _libsbml.new_XMLAttributes(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def set_attrs(self, **kwargs) -> None:\\n self._obj.coords[GEO_MAP_COORD].attrs.update(**kwargs)\",\n \"def __init__(self, manifest, mode='train'):\\n self.audio_links = [line.rstrip('\\\\n').split(' ')[0] for line in open(manifest)]\\n self.labels_emotion = [int(line.rstrip('\\\\n').split(' ')[1]) for line in open(manifest)]\\n self.labels_gender = [int(line.rstrip('\\\\n').split(' ')[2]) for line in open(manifest)]\",\n \"def set_alembic_effect_attributes(self, geo_nodes, attribute_data):\\n data = zip(\\n geo_nodes,\\n attribute_data['render_attrs'],\\n attribute_data['shaders'],\\n attribute_data['parents'],\\n attribute_data['visibility_curves'],\\n attribute_data['visibility_values'],\\n )\\n for node, render_attr, shader, parent, vis_curve, vis_value in data:\\n # Get transform node for parenting and setting visibility\\n transform = node\\n if mc.nodeType(transform) != 'transform':\\n transform = mc.listRelatives(\\n node, parent=True, fullPath=True\\n )[0]\\n\\n # Set visbility value\\n mc.setAttr('{}.visibility'.format(transform), vis_value)\\n # Attach visibility curve\\n if vis_curve is not None:\\n mc.connectAttr(\\n '{}.output'.format(vis_curve),\\n '{}.visibility'.format(transform)\\n )\\n\\n # Set attribute values\\n errors = []\\n for attribute, value in render_attr.items():\\n if not self.set_attribute(node, attribute, value):\\n errors.append(\\n \\\"Couldn't set the attribute {} on {}\\\".format(\\n attribute, node\\n )\\n )\\n if errors:\\n DisplayMayaDialog.displayMayaDialog(\\n 'Error setting attributes',\\n '\\\\n'.join(errors),\\n severity=DisplayMayaDialog.SeverityTypes.WARNING\\n )\\n\\n # Set shader\\n if len(shader):\\n mc.sets(node, e=True, forceElement=shader[0])\\n\\n # Parent node (done at the end to avoid naming problems caused by\\n # changing hierarchy)\\n mc.parent(transform, parent)[0]\",\n \"def add_attributes(data, **kwargs):\\n for key in kwargs:\\n data[key] = kwargs[key]\",\n \"def update(self, *args, **kwargs):\\n if args and len(args) > 0:\\n keys = [\\\"id\\\", \\\"width\\\", \\\"height\\\", \\\"x\\\", \\\"y\\\"]\\n for i, v in enumerate(args):\\n setattr(self, keys[i], v)\\n else:\\n for k, v in kwargs.items():\\n setattr(self, k, v)\",\n \"def update(self, *args, **kwargs):\\n assign = ('id', 'width', 'height', 'x', 'y')\\n if args:\\n for key, idx in zip(assign, range(len(args))):\\n exec('self.{} = {}'.format(key, args[idx]))\\n else:\\n for key, val in kwargs.items():\\n if key in ('id', 'width', 'height', 'x', 'y'):\\n exec('self.{} = {}'.format(key, val))\",\n \"def set(self, **attrs):\\n self.graph._setattrs(handle=self.handle, **attrs)\",\n \"def SetAttribute(self, *args):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUC3_SetAttribute(self, *args)\",\n \"def configure_args(self):\\n super(InstaApriori, self).configure_args()\\n self.add_passthru_arg('-iteration', type=int, help=\\\"The current iteration. Not used as a command line argument\\\")\\n self.add_passthru_arg('--k', type=int, default=3, help=\\\"Specify the maximum size of itemsets to find\\\")\\n self.add_passthru_arg('--s', type=float, help=\\\"Specify the minimum support threshold\\\")\\n self.add_passthru_arg('--c', type=float, default=0, help=\\\"Specify the minimum confidence threshold\\\")\\n self.add_file_arg('--f', default='frequent.txt',\\n help=\\\"Specify the name of the file used to store frequent itemsets\\\")\",\n \"def generate_attributes(self):\\n for group in self.dict:\\n for param in self.dict[group]:\\n if group in self.group_douplicate and param in self.name_douplicate:\\n setattr(self, group+'_'+param, self(group, param))\\n else:\\n setattr(self, param, self(group, param))\",\n \"def setAttr(*args, alteredValue: bool=True, caching: bool=True, capacityHint: int=0,\\n channelBox: bool=True, clamp: bool=True, keyable: bool=True, lock: bool=True, size:\\n int=0, type: AnyStr=\\\"\\\", q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[None, Any]:\\n pass\",\n \"def artAttrCtx(*args, accopacity: bool=False, activeListChangedProc: Union[AnyStr, bool]=\\\"\\\",\\n afterStrokeCmd: Union[AnyStr, bool]=\\\"\\\", alphaclamp: Union[AnyStr, bool]=\\\"none\\\",\\n alphaclamplower: Union[float, bool]=0.0, alphaclampupper: Union[float, bool]=1.0,\\n attrSelected: Union[AnyStr, bool]=\\\"\\\", beforeStrokeCmd: Union[AnyStr, bool]=\\\"\\\",\\n brushalignment: bool=True, brushfeedback: bool=True, clamp: Union[AnyStr,\\n bool]=\\\"none\\\", clamplower: Union[float, bool]=0.0, clampupper: Union[float,\\n bool]=1.0, clear: bool=True, colorAlphaValue: Union[float, bool]=0.0,\\n colorRGBAValue: Union[List[float, float, float, float], bool]=None,\\n colorRGBValue: Union[List[float, float, float], bool]=None, colorRamp:\\n Union[AnyStr, bool]=\\\"\\\", colorfeedback: bool=False, colorfeedbackOverride:\\n bool=False, colorrangelower: Union[float, bool]=0.0, colorrangeupper:\\n Union[float, bool]=1.0, dataTypeIndex: Union[int, bool]=0, disablelighting:\\n bool=False, dragSlider: AnyStr=\\\"\\\", duringStrokeCmd: Union[AnyStr, bool]=\\\"\\\",\\n dynclonemode: bool=True, exists: bool=True, expandfilename: bool=True,\\n exportaspectratio: Union[float, bool]=0.0, exportfilemode: Union[AnyStr,\\n bool]=\\\"luminance/rgb\\\", exportfilesave: AnyStr=\\\"\\\", exportfilesizex: Union[int,\\n bool]=0, exportfilesizey: Union[int, bool]=0, exportfiletype: Union[AnyStr,\\n bool]=\\\"\\\", filterNodes: bool=True, history: bool=True, image1: Union[AnyStr,\\n bool]=\\\"\\\", image2: Union[AnyStr, bool]=\\\"\\\", image3: Union[AnyStr, bool]=\\\"\\\",\\n importfileload: AnyStr=\\\"\\\", importfilemode: Union[AnyStr, bool]=\\\"alpha\\\",\\n importreassign: bool=False, interactiveUpdate: bool=True, lastRecorderCmd:\\n Union[AnyStr, bool]=\\\"\\\", lastStampName: Union[AnyStr, bool]=\\\"\\\", lowerradius:\\n Union[float, bool]=0.0, makeStroke: Union[int, List[int], bool]=0, mappressure:\\n Union[AnyStr, bool]=\\\"none\\\", maxvalue: Union[float, bool]=1.0, minvalue:\\n Union[float, bool]=0.0, name: AnyStr=\\\"\\\", objattrArray: Union[AnyStr, bool]=\\\"\\\",\\n opacity: Union[float, bool]=1.0, outline: bool=True, outwhilepaint: bool=False,\\n paintNodeArray: Union[AnyStr, bool]=\\\"\\\", paintattrselected: AnyStr=\\\"\\\", paintmode:\\n Union[AnyStr, bool]=\\\"screen\\\", paintoperationtype: Union[AnyStr, bool]=\\\"Paint\\\",\\n pickColor: bool=True, pickValue: bool=True, playbackCursor: Union[List[float,\\n float], List[List[float, float]], bool]=None, playbackPressure: Union[float,\\n List[float], bool]=0.0, preserveclonesource: bool=True, profileShapeFile:\\n Union[AnyStr, bool]=\\\"\\\", projective: bool=False, radius: Union[float, bool]=1.0,\\n rampMaxColor: Union[List[float, float, float], bool]=None, rampMinColor:\\n Union[List[float, float, float], bool]=None, record: bool=True, reflection:\\n bool=False, reflectionaboutorigin: bool=True, reflectionaxis: Union[AnyStr,\\n bool]=\\\"x\\\", screenRadius: Union[float, bool]=0.0, selectclonesource: bool=True,\\n selectedattroper: Union[AnyStr, bool]=\\\"absolute\\\", showactive: bool=True,\\n stampDepth: Union[float, bool]=0.0, stampProfile: Union[AnyStr, bool]=\\\"\\\",\\n stampSpacing: Union[float, bool]=1.0, strokesmooth: Union[AnyStr, bool]=\\\"\\\",\\n surfaceConformedBrushVertices: bool=True, tablet: bool=True, tangentOutline:\\n bool=True, toolOffProc: Union[AnyStr, bool]=\\\"\\\", toolOnProc: Union[AnyStr,\\n bool]=\\\"\\\", useColorRamp: bool=True, useMaxMinColor: bool=True, usepressure:\\n bool=False, value: Union[float, bool]=0.0, whichTool: Union[AnyStr, bool]=\\\"\\\",\\n worldRadius: Union[float, bool]=0.0, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def process_all(fileinfos, args):\\n # create overall figure\\n count_and_draw(fileinfos,args)\\n # create figures for all the files\\n for key in fileinfos:\\n count_and_draw(fileinfos,args,key)\\n # create figures for all the elements\\n els_processed = []\\n for key in fileinfos:\\n for key in fileinfos[key][\\\"usage_el\\\"]:\\n if key not in els_processed:\\n count_and_draw(fileinfos,args,key)\\n els_processed.append(key)\\n # create figures for all the attributes\\n atts_processed = []\\n for key in fileinfos:\\n for key in fileinfos[key][\\\"usage_att\\\"]:\\n if key not in atts_processed:\\n count_and_draw(fileinfos,args,\\\"@\\\"+key)\\n atts_processed.append(key)\",\n \"def set_attribute(self, name, value):\\n\\n pass\",\n \"def SetExportAttrs(self, param, attrs):\\n parent, unused_name = self.FindExport(param)\\n if not hasattr(parent.obj, 'SetAttributes'):\\n return False\\n parent.obj.SetAttributes(attrs)\\n return True\",\n \"def __init__(self, name, process_step=None, **attributes):\\n self.name = name\\n self.process_step = process_step\\n # Check the config file for the process metadata if process step not provided\\n if process_step is None:\\n cfg_def = cfg.read_procedures()[name]\\n self.process_step = cfg_def['process_step']\\n attributes = cfg_def.copy()\\n \\n\\n #self.source = source\\n self.attributes = attributes\\n #self.attributes['standard_name'] = 'source'\",\n \"def overwrite_attrs(self, src_detail, attrs):\\n case_tile_configuration_list = [\\n 'case_tile_template',\\n 'persist_tile_on_forms',\\n 'persistent_case_tile_from_module',\\n 'pull_down_tile',\\n 'persist_case_context',\\n 'persistent_case_context_xml',\\n 'case_tile_group',\\n ]\\n for attr in attrs:\\n if attr == \\\"case_tile_configuration\\\":\\n for ele in case_tile_configuration_list:\\n setattr(self, ele, getattr(src_detail, ele))\\n else:\\n setattr(self, attr, getattr(src_detail, attr))\",\n \"def update(self, *argv, **kwargs):\\n if argv and len(argv) > 0:\\n for counter, arg in enumerate(argv, 0):\\n if counter == len(argv):\\n break\\n if counter == 0 and arg is not None:\\n self.id = arg\\n elif counter == 1:\\n self.size = arg\\n elif counter == 2:\\n self.x = arg\\n elif counter == 3:\\n self.y = arg\\n elif kwargs and len(kwargs) > 0:\\n for k, v in kwargs.items():\\n if k == \\\"id\\\" and v is not None:\\n self.id = v\\n elif k == \\\"size\\\":\\n self.size = v\\n elif k == \\\"x\\\":\\n self.x = v\\n elif k == \\\"y\\\":\\n self.y = v\",\n \"def add_attributes(self, attributes):\\n self.attributes = dict(self.attributes, **attributes)\",\n \"def add_attribute(self, key, value):\\n if key == \\\"process_step\\\":\\n self.process_step = value\\n elif key == \\\"source\\\":\\n self.source = value\\n else:\\n self.attributes[key] = value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.663226","0.65376776","0.6433505","0.63417685","0.63057846","0.62907225","0.62907225","0.62907225","0.62564075","0.6250395","0.61584836","0.6117828","0.61080635","0.6101694","0.6066144","0.60353273","0.60230213","0.59905666","0.5890181","0.585173","0.57825947","0.5772087","0.57461137","0.57316065","0.57131493","0.57094556","0.57004464","0.5673111","0.56698054","0.56657386","0.56657386","0.56651235","0.5661252","0.5657888","0.56367755","0.56276464","0.5617263","0.5598188","0.55956554","0.55872995","0.5571253","0.55631393","0.55615836","0.55494165","0.5548168","0.5540955","0.5539958","0.55390173","0.5532393","0.55288213","0.5525014","0.54884195","0.54884195","0.5476698","0.5475997","0.54676443","0.54656976","0.54634047","0.5463309","0.54605836","0.54566115","0.5441053","0.5430394","0.5428654","0.5423862","0.54127324","0.54123545","0.5410265","0.5408594","0.54045194","0.53873456","0.53808385","0.5371597","0.5370415","0.53663844","0.5365806","0.53532225","0.53452","0.53372806","0.5329722","0.5327252","0.53206563","0.5315502","0.5312364","0.5304459","0.52977264","0.52953017","0.5292614","0.52905536","0.52877724","0.5285049","0.52825916","0.5277384","0.527704","0.52725667","0.5271289","0.5269053","0.52644706","0.526338","0.52583367"],"string":"[\n \"0.663226\",\n \"0.65376776\",\n \"0.6433505\",\n \"0.63417685\",\n \"0.63057846\",\n \"0.62907225\",\n \"0.62907225\",\n \"0.62907225\",\n \"0.62564075\",\n \"0.6250395\",\n \"0.61584836\",\n \"0.6117828\",\n \"0.61080635\",\n \"0.6101694\",\n \"0.6066144\",\n \"0.60353273\",\n \"0.60230213\",\n \"0.59905666\",\n \"0.5890181\",\n \"0.585173\",\n \"0.57825947\",\n \"0.5772087\",\n \"0.57461137\",\n \"0.57316065\",\n \"0.57131493\",\n \"0.57094556\",\n \"0.57004464\",\n \"0.5673111\",\n \"0.56698054\",\n \"0.56657386\",\n \"0.56657386\",\n \"0.56651235\",\n \"0.5661252\",\n \"0.5657888\",\n \"0.56367755\",\n \"0.56276464\",\n \"0.5617263\",\n \"0.5598188\",\n \"0.55956554\",\n \"0.55872995\",\n \"0.5571253\",\n \"0.55631393\",\n \"0.55615836\",\n \"0.55494165\",\n \"0.5548168\",\n \"0.5540955\",\n \"0.5539958\",\n \"0.55390173\",\n \"0.5532393\",\n \"0.55288213\",\n \"0.5525014\",\n \"0.54884195\",\n \"0.54884195\",\n \"0.5476698\",\n \"0.5475997\",\n \"0.54676443\",\n \"0.54656976\",\n \"0.54634047\",\n \"0.5463309\",\n \"0.54605836\",\n \"0.54566115\",\n \"0.5441053\",\n \"0.5430394\",\n \"0.5428654\",\n \"0.5423862\",\n \"0.54127324\",\n \"0.54123545\",\n \"0.5410265\",\n \"0.5408594\",\n \"0.54045194\",\n \"0.53873456\",\n \"0.53808385\",\n \"0.5371597\",\n \"0.5370415\",\n \"0.53663844\",\n \"0.5365806\",\n \"0.53532225\",\n \"0.53452\",\n \"0.53372806\",\n \"0.5329722\",\n \"0.5327252\",\n \"0.53206563\",\n \"0.5315502\",\n \"0.5312364\",\n \"0.5304459\",\n \"0.52977264\",\n \"0.52953017\",\n \"0.5292614\",\n \"0.52905536\",\n \"0.52877724\",\n \"0.5285049\",\n \"0.52825916\",\n \"0.5277384\",\n \"0.527704\",\n \"0.52725667\",\n \"0.5271289\",\n \"0.5269053\",\n \"0.52644706\",\n \"0.526338\",\n \"0.52583367\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52937835"},"document_rank":{"kind":"string","value":"87"}}},{"rowIdx":83775,"cells":{"query":{"kind":"string","value":"writes data to tfrecord file"},"document":{"kind":"string","value":"def write_tfrecord(self):\n # build batch of image data\n # self.filepaths is dynamic, is better to call it once outside the loop\n filepaths = self.filepaths\n labels = self.labels\n tfrecord = self.tfrecord\n with tf.io.TFRecordWriter(tfrecord) as writer:\n for fpath, label in tqdm(zip(filepaths, labels), desc='writing images to tfrecords'):\n img = load_img(fpath,\n color_mode=self.color_mode,\n target_size=self.target_size,\n interpolation=self.interpolation)\n x = img_to_array(img, data_format=self.data_format)\n # Pillow images should be closed after `load_img`,\n # but not PIL images.\n if hasattr(img, 'close'):\n img.close()\n if self.image_data_generator:\n for _ in range(self.num_copies):\n x_copy = x.copy()\n params = self.image_data_generator.get_random_transform(\n x_copy.shape)\n x_copy = self.image_data_generator.apply_transform(\n x_copy, params)\n x_copy = self.image_data_generator.standardize(x_copy)\n # convert augmented image\n self._write_image(x_copy, label, writer)\n\n # write th original\n self._write_image(x, label, writer)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _create_tfrecords_file(data, output_file):\n with tf.io.TFRecordWriter(str(output_file)) as writer:\n for image, sign in data:\n with tf.io.gfile.GFile(image, \"rb\") as f:\n image_string = f.read()\n feature = {\n \"image\": tf.train.Feature(\n bytes_list=tf.train.BytesList(value=[image_string])),\n \"label\": tf.train.Feature(\n int64_list=tf.train.Int64List(value=[sign]))\n }\n example = tf.train.Example(features=tf.train.Features(feature=feature))\n writer.write(example.SerializeToString())","def write_record(self, input):\n \"\"\"\n input: dict (dict of key, elem to write to tf-record)\n \"\"\"\n features = collections.OrderedDict()\n for key, value in input.items():\n if self.schema[key][0] == \"fixed_len\":\n if self.schema[key][2] != []:\n shape = self.schema[key][2][0]\n if len(value) != shape:\n raise ValueError(\n \"`{}` has schema shape `{}`, but provided \\\n values `{}` has shape `{}`\".format(\n key, shape, value, len(value) # noqa\n )\n )\n\n if isinstance(value, six.text_type):\n value = six.ensure_binary(value, \"utf-8\")\n features[key] = self.schema_writer_fn[key](value)\n example_proto = tf.train.Example(features=tf.train.Features(feature=features))\n\n if self.tag == \"train\":\n if self.shuffle:\n index = random.choice(range(len(self.all_writer)))\n the_writer = self.all_writer[index]\n the_writer.write(example_proto.SerializeToString())\n self.examples_per_record[self.all_files[index]] += 1\n self.global_counter += 1\n else:\n\n # If global counter(no of individual records processed)\n # exceeds max_files_per_record then increment self.current_writer\n if self.global_counter > (self.current_writer + 1) * self.max_files_per_record:\n self.current_writer += 1\n self.current_file_name = \"{}_{}_{}.tfrecord\".format(self.file_name, self.tag, self.current_writer)\n self.examples_per_record[self.current_file_name] = 0\n self.current_file = tf.io.TFRecordWriter(self.current_file_name)\n self.temp_writers.append(self.current_file)\n\n the_writer = self.current_file\n the_writer.write(example_proto.SerializeToString())\n self.examples_per_record[self.current_file_name] += 1\n self.global_counter += 1\n\n if self.global_counter % self.verbose_counter == 0:\n logging.info(\"Wrote {} tfrecods\".format(self.global_counter))\n else:\n the_writer = self.all_writer[0]\n the_writer.write(example_proto.SerializeToString())\n self.global_counter += 1\n\n if self.global_counter % self.verbose_counter == 0:\n logging.info(\"Wrote {} tfrecods\".format(self.global_counter))","def write_tfrecords(self, records, dataset):\n\n cnt_inc = len(records)\n self.count += cnt_inc\n\n if dataset == 'test':\n self.count_test += cnt_inc\n for s in records:\n self.test.write(s)\n elif dataset == 'train':\n self.count_train += cnt_inc\n for s in records:\n self.train[self.pick_file()].write(s)\n elif dataset == 'valid':\n self.count_eval += cnt_inc\n for s in records:\n self.valid.write(s)\n else:\n raise ValueError(\"invalid dataset: %s\" % dataset)","def dump_to_tfrecord(record_file: str,\n tf_examples: Sequence[Union[tf.train.Example,\n tf.train.SequenceExample]]):\n file_writers.write_small_dataset(tf_examples, record_file, 'tfrecord')","def _writeRecord(self, path, name, data):\n file_path = os.path.join(path, name)\n with open(file_path, 'w') as f:\n for item in data:\n f.write(str(item)+'\\t')\n f.write('\\n')","def write_to_file(writer, data):\n feature = {\n \"text\": _int64_feature(data)\n }\n tf_example = tf.train.Example(features=tf.train.Features(feature=feature))\n writer.write(tf_example.SerializeToString())","def write_to_file(writer, data):\n feature = {\n \"text\": _int64_feature(data)\n }\n tf_example = tf.train.Example(features=tf.train.Features(feature=feature))\n writer.write(tf_example.SerializeToString())","def add_to_tfrecord():\n\n record_path = os.path.join(FLAGS.dataset_dir, \"records\")\n if not os.path.isdir(record_path):\n os.makedirs(record_path)\n\n ####### Path Definition #######\n img_path = \"data/traindata/ccmpred/\"\n ss3_path = \"data/traindata/ss3/\"\n pdb_path = \"data/traindata/pdb/\"\n fasta_path = \"data/traindata/fasta/\"\n\n with open('data/train.list') as fin:\n names = [line.rstrip() for line in fin]\n\n num_shards = int(len(names) / 1000)\n num_per_shard = int(math.ceil(len(names) / float(num_shards)))\n\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)\n with tf.Graph().as_default(), tf.device('/cpu:0'):\n with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n for shard_id in range(num_shards):\n record_filename = os.path.join(record_path, \"new_train_ss3_%d.tfrecord\" %shard_id)\n options = tf.python_io.TFRecordOptions(TFRecordCompressionType.ZLIB)\n with tf.python_io.TFRecordWriter(record_filename) as tfrecord_writer:\n start_ndx = shard_id * num_per_shard\n end_ndx = min((shard_id + 1) * num_per_shard, len(names))\n print \"processing data from %d to %d...\" %(start_ndx, end_ndx)\n for i in range(start_ndx, end_ndx):\n name = names[i]\n img = np.loadtxt(os.path.join(img_path, name+\".ccmpred\"))\n height, width = img.shape\n # load ss3 info\n predss3 = np.loadtxt(os.path.join(ss3_path, name+\".ss3\"))\n if predss3.shape[0] != height:\n continue\n Index = np.mgrid[0: height, 0: width]\n i, j = Index[0], Index[1]\n ss3mat = np.concatenate([predss3[i], predss3[j]], axis=-1)\n # combine ccmpred and ss3\n img = np.concatenate([img[..., np.newaxis], ss3mat], axis=-1)\n\n # box and mask info\n pdb = os.path.join(pdb_path, name+\".pdb\")\n fasta = os.path.join(fasta_path, name+\".fasta\")\n L, gt_boxes, masks, ss3 = LoadNativeBox(name, pdb, fasta)\n gt_boxes = np.array(gt_boxes).astype(np.float32)\n masks = np.array(masks).astype(np.uint8) ### Important ###\n \n # combine all masks in one mask\n mask = np.zeros(shape=(height, width), dtype=np.int8)\n for m in masks:\n mask += m\n\n img = img.astype(np.float64)\n #assert img.size == width * height * 3, '%s' % str(name)\n \n #if gt_boxes.shape[0] > 0:\n example = to_tfexample_raw(\n name, img.tostring(), mask.tostring(),\n height, width, \n gt_boxes.shape[0], gt_boxes.tostring(), masks.tostring())\n \n tfrecord_writer.write(example.SerializeToString())","def test_write_tfrecord(self):\n path = os.path.join(self.tmp_dir, 'foo-train.tfrecord')\n shards_length, total_size = self._write(to_write=self.RECORDS_TO_WRITE)\n self.assertEqual(self.NUM_SHARDS, len(shards_length))\n self.assertEqual(\n shards_length, [len(shard) for shard in self.SHARDS_CONTENT]\n )\n self.assertEqual(total_size, 9)\n written_files, all_recs = _read_records(path)\n written_index_files, all_indices = _read_indices(path)\n self.assertEqual(\n written_files,\n [\n f'foo-train.tfrecord-{i:05d}-of-{self.NUM_SHARDS:05d}'\n for i in range(self.NUM_SHARDS)\n if shards_length[i]\n ],\n )\n self.assertEqual(all_recs, self.SHARDS_CONTENT)\n self.assertEmpty(written_index_files)\n self.assertEmpty(all_indices)","def write_tfrecords(tf_examples: List[tf.train.Example], filename: str):\n with tf.io.TFRecordWriter(filename) as file_writer:\n for example in tf_examples:\n file_writer.write(example)","def test_write_tfrecord(self):\n path = os.path.join(self.tmp_dir, 'foo-train.tfrecord')\n shards_length, total_size = self._write(to_write=self.RECORDS_TO_WRITE)\n self.assertEqual(self.NUM_SHARDS, len(shards_length))\n self.assertEqual(\n shards_length, [len(shard) for shard in self.SHARDS_CONTENT]\n )\n self.assertEqual(total_size, 10)\n written_files, all_recs = _read_records(path)\n written_index_files, all_indices = _read_indices(path)\n self.assertEqual(\n written_files,\n [\n f'foo-train.tfrecord-{i:05d}-of-{self.NUM_SHARDS:05d}'\n for i in range(self.NUM_SHARDS)\n if shards_length[i]\n ],\n )\n self.assertEqual(all_recs, self.SHARDS_CONTENT)\n self.assertEmpty(written_index_files)\n self.assertEmpty(all_indices)","def write_record(dataset, filename):\n writer = tf.python_io.TFRecordWriter(filename)\n print('result dim:')\n print(dataset['images'].shape)\n for image, label, meta in zip(dataset['images'], dataset['labels'],\n dataset['meta']):\n example = tf.train.Example(\n features=tf.train.Features(\n feature={\n 'height': _int64_feature(image.shape[1]),\n 'width': _int64_feature(image.shape[2]),\n 'depth': _int64_feature(2),\n 'label': _int64_feature(label),\n 'meta': _int64_list_feature(meta),\n 'image_raw': _bytes_feature(image.tostring()),\n }))\n writer.write(example.SerializeToString())\n writer.close()","def _add_to_tfrecord(filename, tfrecord_writer,labels_to_class_names, offset=0):\n image = tf.gfile.FastGFile(filename,'r').read()\n label = labels_to_class_names[filename.split('/')[-2]]\n\n with tf.Graph().as_default():\n with tf.Session('') as sess:\n example = dataset_utils.image_to_tfexample(\n image, b'jpg', _IMAGE_SIZE_HEIGHT, _IMAGE_SIZE_WIDTH, label)\n tfrecord_writer.write(example.SerializeToString())\n\n return offset + 1","def _write_tfrecords(X_, y_, n_, output_file, target_type='int'):\n writer = tf.io.TFRecordWriter(output_file)\n\n for X, y, n in zip(X_, y_, n_):\n # print(len(X_), len(y_), X.shape, y.shape)\n X = X.astype(np.float32)\n n = n.astype(np.int64)\n # Feature contains a map of string to feature proto objects\n example = _make_example(X, y, n, target_type=target_type)\n # Serialize the example to a string\n serialized = example.SerializeToString()\n # write the serialized object to the disk\n writer.write(serialized)\n writer.close()","def write_tfrecord(data_list, output_dir, batch_size_per_file=100):\n for data_category in data_list.keys():\n file_basename = os.path.join(output_dir, data_category)\n for i, (image_path, label_path) in tqdm.tqdm(\n enumerate(\n zip(data_list[data_category]['image_list'],\n data_list[data_category]['label_list']))):\n if i % batch_size_per_file == 0:\n if i != 0:\n writer.close()\n filename = file_basename + '_{:04d}.tfrecord'.format(\n int(i / batch_size_per_file))\n writer = tf.python_io.TFRecordWriter(filename)\n logging.info('Start writing {} data to {}'.format(\n data_category, filename))\n\n filename = image_path\n image = np.array(Image.open(image_path))\n label = np.array(Image.open(label_path))\n height = image.shape[0]\n width = image.shape[1]\n image_raw = image.tostring()\n label_raw = label.tostring()\n example = tf.train.Example(\n features=tf.train.Features(\n feature={\n 'height':\n tf.train.Feature(\n int64_list=tf.train.Int64List(value=[height])),\n 'width':\n tf.train.Feature(\n int64_list=tf.train.Int64List(value=[width])),\n 'image_raw':\n tf.train.Feature(\n bytes_list=tf.train.BytesList(value=[image_raw])),\n 'label_raw':\n tf.train.Feature(\n bytes_list=tf.train.BytesList(value=[label_raw])),\n 'filename':\n tf.train.Feature(\n bytes_list=tf.train.BytesList(\n value=[str.encode(filename)]))\n }))\n writer.write(example.SerializeToString())\n writer.close()","def write_data():","def write_tfrecord(examples, encode_fn, file_name):\n def create_feature(example):\n \"\"\"\n Creates a feature list from a document.\n \"\"\"\n input_ids, label_ids = encode_fn(\n example['tokens'], example['labels'])\n\n features = {\n 'input_ids': int64_feature(input_ids),\n 'label_ids': int64_feature(label_ids)\n }\n\n return features\n\n with tf.io.TFRecordWriter(file_name) as writer:\n for example in examples:\n example = tf.train.Example(\n features=tf.train.Features(\n feature=create_feature(example)))\n\n writer.write(example.SerializeToString())\n\n return file_name, len(examples)","def create_tfrecord(self, tfrecord_filename, begin=0, einde=-1):\n # Call imagesToTfRecord class to build dataset and store in TFRecord\n T2.writeRecord(tfrecord_filename, TRAIN_DIR, begin=begin, einde=einde)","def _add_to_tfrecord(filename, tfrecord_writer, offset=0):\n with tf.gfile.Open(filename, 'rb') as f:\n if sys.version_info < (3,):\n data = cPickle.load(f)\n else:\n data = cPickle.load(f, encoding='bytes')\n\n images = data[b'data']\n num_images = images.shape[0]\n\n images = images.reshape((num_images, 3, 32, 32))\n labels = data[b'fine_labels']\n\n with tf.Graph().as_default():\n image_placeholder = tf.placeholder(dtype=tf.uint8)\n encoded_image = tf.image.encode_png(image_placeholder)\n\n with tf.Session('') as sess:\n\n for j in range(num_images):\n sys.stdout.write('\\r>> Reading file [%s] image %d/%d' % (\n filename, offset + j + 1, offset + num_images))\n sys.stdout.flush()\n\n image = np.squeeze(images[j]).transpose((1, 2, 0))\n label = labels[j]\n\n png_string = sess.run(encoded_image,\n feed_dict={image_placeholder: image})\n\n example = dataset_utils.image_to_tfexample(\n png_string, b'png', _IMAGE_SIZE, _IMAGE_SIZE, label)\n tfrecord_writer.write(example.SerializeToString())\n\n return offset + num_images","def write (self, path):\n\t\ts=[]; add=s.append\n\t\tadd ('\\t'.join (self.schema))\n\t\tfor record in self.data:\n\t\t\tadd (record.asTabDelimitedRecord())\n\t\t\n\t\t# f = open (path, 'w')\n\t\tf = codecs.open(path, 'w', 'utf-8')\n\t\tf.write (self.linesep.join (s))\n\t\tf.close()\n\t\tprint (\"data written to \" + path)","def create_tfrecords_file(input_filename, output_filename, example_fn):\n writer = tf.python_io.TFRecordWriter(output_filename) #A class to write records to a TFRecords file.\n print(\"Creating TFRecords file at {}...\".format(output_filename))\n\n for i, row in enumerate(create_csv_iter(input_filename)):\n x = example_fn(row)\n writer.write(x.SerializeToString())\n\n writer.close()\n print(\"Wrote to {}\".format(output_filename))","def convert_to_tfrecord(data_files, label_files, output_file, num_steps, test_flag):\n print('Generating %s' % output_file)\n\n with tf.python_io.TFRecordWriter(output_file) as record_writer:\n\n for idx in enumerate(data_files):\n\n print('Working on %s' % data_files[idx[0]])\n print('Working on %s' % label_files[idx[0]])\n\n #data = _read_data(data_files[idx[0]])\n #label = _read_data(label_files[idx[0]])\n\n #data = loadtxt(data_files[idx[0]])\n label = loadtxt(label_files[idx[0]])\n feat = [0,1,2,3]\n feat.extend(range(6,25))\n if test_flag:\n with open(data_files[idx[0]]) as infile:\n data = np.zeros([num_steps, 25])\n cnt = 0\n for line in infile:\n line = line.split()\n data[0:num_steps-1, :]=data[1:num_steps, :]\n data[num_steps-1,:]=line\n data1 = data\n data1[:,0] = signal.detrend(data1[:,0], axis=0)\n write_to_tfrecord(data1[:,feat], label[cnt:cnt+num_steps], num_steps, record_writer)\n cnt+=1\n else:\n with open(data_files[idx[0]]) as infile:\n data = []\n cnt = 1\n for line in infile:\n data.append(line.split())\n if cnt%num_steps==0:\n data = np.array(data, dtype=float)\n data.reshape(data.shape[0], -1)\n #data = signal.detrend(data, axis=0)\n write_to_tfrecord(data[:,feat], label[cnt-num_steps:cnt], num_steps, record_writer)\n data = []\n cnt=cnt+1","def _add_to_tfrecord(record_dir,num_images,image_h, image_w, split_name):\n dataset_train = ShapesDataset()\n dataset_train.load_shapes(num_images, image_h, image_w)\n\n num_shards = int(num_images /2500 ) # 2500\n num_per_shard = int(math.ceil(num_images / float(num_shards)))\n height, width=image_h, image_w\n\n for shard_id in range(num_shards):\n record_filename = _get_dataset_filename(record_dir, split_name, shard_id, num_shards)\n options = tf.python_io.TFRecordOptions(TFRecordCompressionType.ZLIB)\n\n with tf.python_io.TFRecordWriter(record_filename, options=options) as tfrecord_writer:\n start_ndx = shard_id * num_per_shard\n end_ndx = min((shard_id + 1) * num_per_shard, num_images)\n for i in range(start_ndx, end_ndx):\n if i % 50 == 0:\n sys.stdout.write('\\r>> Converting image %d/%d shard %d\\n' % (\n i + 1, num_images, shard_id))\n sys.stdout.flush()\n\n img= dataset_train.image_info[i]['image']\n gt_boxes= dataset_train.image_info[i]['gt_boxes']\n masks= dataset_train.image_info[i]['mask']\n mask= dataset_train.image_info[i]['mask_']\n\n img_raw = img.tostring()\n mask_raw = mask.tostring()\n img_id=i\n example = _to_tfexample_coco_raw(\n img_id,\n img_raw,\n mask_raw,\n height, width, gt_boxes.shape[0],\n gt_boxes.tostring(), masks.tostring())\n\n tfrecord_writer.write(example.SerializeToString())\n sys.stdout.write('\\n')\n sys.stdout.flush()","def write_tfr(np_data, rw, rm, out_dir):\n if isinstance(np_data, dict):\n np_data = _np_generator(np_data)\n elif isinstance(np_data, types.GeneratorType):\n pass\n elif isinstance(np_data, collections.Iterable):\n pass\n else:\n raise Exception('np_data must be a dict, a generator or iterable.')\n\n for data in np_data:\n feature = {}\n for key, value in data.items():\n value_shape = list(value.shape)\n if type(value) == np.ndarray:\n if value.dtype == np.float64:\n value = value.astype(np.float32)\n if value.dtype == bool or value.dtype == np.int32 or \\\n value.dtype == np.int16:\n value = value.astype(np.float32)\n if key not in rm.tensors_shape:\n rm.tensors_shape[key] = value_shape\n rm.tensors_shape_max[key] = value_shape\n rm.tensors_dtype[key] = value.dtype.name\n rm.tensors_ndim[key] = value.ndim\n else:\n rm.tensors_shape[key] = \\\n _update_shape(rm.tensors_shape[key], value_shape)\n rm.tensors_shape_max[key] = \\\n map(max, zip(rm.tensors_shape_max[key], value_shape))\n\n convert_np_to_features(key, value, feature)\n\n example = \\\n tf.train.Example(features=tf.train.Features(feature=feature))\n rw.write(example.SerializeToString())\n\n rm.num_examples = rw.num_examples\n rm.num_records = rw.num_records\n rm.save(out_dir)","def write(self, filename, data, hdr):\n pass","def save_records(self, pad_id):\n train_records_path = os.path.join(self.config.records_dir, \"train.tfrecords\")\n dev_records_path = os.path.join(self.config.records_dir, \"dev.tfrecords\")\n test_records_path = os.path.join(self.config.records_dir, \"test.tfrecords\")\n statistics_file = os.path.join(self.config.records_dir, \"statistics.json\")\n\n dict = {}\n dict['train_examples_num'] = len(self.train_set)\n dict['dev_examples_num'] = len(self.dev_set)\n dict['test_examples_num'] = len(self.test_set)\n\n with open(statistics_file, 'w', encoding='utf8')as p:\n json.dump(dict, p)\n\n self._save_records(train_records_path, self.train_set, pad_id)\n self._save_records(dev_records_path, self.dev_set, pad_id)\n self._save_records(test_records_path, self.test_set, pad_id)\n\n self.logger.info(\"all data have saved to records files.\")","def dump2record(filename, corpus1, corpus2):\r\n\tassert len(corpus1) == len(corpus2)\r\n\twriter = tf.io.TFRecordWriter(filename)\r\n\r\n\tfor sent1, sent2 in tqdm(zip(corpus1, corpus2)):\r\n\t\tfeatures = {}\r\n\t\tfeatures['src_sent'] = _byte_features(sent1.encode('utf-8'))\r\n\t\tfeatures['tgt_sent'] = _byte_features(sent2.encode('utf-8'))\r\n\r\n\t\ttf_features = tf.train.Features(feature=features)\r\n\t\ttf_examples = tf.train.Example(features=tf_features)\r\n\t\ttf_serialized = tf_examples.SerializeToString()\r\n\r\n\t\twriter.write(tf_serialized)\r\n\r\n\twriter.close()","def create_training_record(data_path: str, path_to_gt: str, ratio: float):\n with open(data_path) as file:\n data = json.load(file)\n\n base = os.path.join(os.path.dirname(data_path), datetime.now().strftime('%Y_%m_%d_%H%M%S'))\n train_filename = '{}_{}'.format(base, 'train.tfrecords')\n test_filename = '{}_{}'.format(base, 'test.tfrecords')\n\n train_writer = tf.python_io.TFRecordWriter(train_filename)\n test_writer = tf.python_io.TFRecordWriter(test_filename)\n\n gt_reader = GroundTruthReader(path_to_gt)\n train_set_len = 1\n test_set_len = 1\n zeros = 0\n ones = 0\n\n for i, key in enumerate(data):\n if not i % 1000:\n print('Data: {}/{}'.format(i, len(data)))\n sys.stdout.flush()\n\n features, labels = compute_feature(key, data[key], gt_reader)\n\n for j, feat in enumerate(features):\n label = labels[j]\n if test_set_len / train_set_len >= ratio:\n # balance out training dataset (there are normally more zero- than one-labels)\n if (label == 0.0 and (zeros - ones <= 0)) or label == 1.0:\n train_set_len += 1\n if label == 1.0:\n ones += 1\n else:\n zeros += 1\n feature = {'train/feature': float_feature(feat),\n 'train/label': float_feature(labels[j])}\n example = tf.train.Example(features=tf.train.Features(feature=feature))\n train_writer.write(example.SerializeToString())\n else:\n test_set_len += 1\n feature = {'test/feature': float_feature(feat),\n 'test/label': float_feature(labels[j])}\n example = tf.train.Example(features=tf.train.Features(feature=feature))\n test_writer.write(example.SerializeToString())\n train_writer.close()\n sys.stdout.flush()","def write_tf_record(images, bboxes, filename):\n\n with tf.io.TFRecordWriter(filename) as writer:\n\n for i, (image_path, bbox) in enumerate(zip(images, bboxes)):\n image = cv2.imread(str(image_path), cv2.IMREAD_UNCHANGED)\n tf_example = bbox_to_tf_example(image, image_path, bbox)\n writer.write(tf_example.SerializeToString())\n print(\"Created tf-record file in: \\n\", filename)","def write(data):","def save_data_into_tf_records(image_file, image_label, tf_records_writer):\n try:\n img = Image.open(image_file)\n except OSError as e:\n print(e)\n print(\"Error image \" + image_file)\n return False\n # Unify resolution to 300 * 300.\n img = np.array(img.resize((IMAGE_SIZE, IMAGE_SIZE)))\n # img = np.array(img)\n\n # Check if the image is rgb image.\n if len(img.shape) != 3 or img.shape[2] != 3:\n print(\"Not rgb image \" + image_file)\n return False\n # Check if the image is useless.\n same = useless_image_array == img\n if type(same) == np.ndarray:\n if (useless_image_array == img).all():\n print(\"Useless image. \" + image_file)\n return False\n elif type(same) == bool:\n if same:\n print(\"Useless image. \" + image_file)\n return False\n\n img_raw = img.tobytes()\n example = tf.train.Example(features=tf.train.Features(feature={\n \"label\": tf.train.Feature(int64_list=tf.train.Int64List(value=[\n image_label])),\n \"raw\": tf.train.Feature(bytes_list=tf.train.BytesList(value=[\n img_raw])),\n \"height\": tf.train.Feature(int64_list=tf.train.Int64List(value=[\n img.shape[0]])),\n \"width\": tf.train.Feature(int64_list=tf.train.Int64List(\n value=[img.shape[1]])),\n \"channel\": tf.train.Feature(int64_list=tf.train.Int64List(\n value=[img.shape[2]]))\n }))\n tf_records_writer.write(example.SerializeToString())\n return True","def save(self,outPath=None):\n if (not self.canSave): raise StateError(_(\"Insufficient data to write file.\"))\n if not outPath:\n fileInfo = self.fileInfo\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\n out = file(outPath,'wb')\n #--Tes3 Record\n self.tes3.setChanged()\n self.tes3.hedr.setChanged()\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\n self.tes3.getSize()\n self.tes3.dump(out)\n #--Other Records\n for record in self.records:\n record.getSize()\n record.dump(out)\n out.close()","def save_to_tfrecord(type_dataset, dataset, label_map_dict, labels_by_class_dict):\n\n # create empty shards\n writers = [\n tf.python_io.TFRecordWriter(os.path.join(FLAGS.output_path, type_dataset) + '-%05d-of-%05d.tfrecord' %\n (i, FLAGS.num_shards))\n for i in range(FLAGS.num_shards)\n ]\n\n # add images to empty shards\n for idx, name_image_ in enumerate(dataset):\n _, tail = os.path.split(name_image_)\n data_total = {}\n name_file_xml_all = os.path.join(FLAGS.data_dir, 'LABELS', tail[0:-3] + 'xml')\n if os.path.exists(name_file_xml_all):\n with tf.gfile.GFile(name_file_xml_all, 'rb') as fid:\n xml_str = fid.read()\n xml = etree.fromstring(xml_str)\n data_total = tfrecord_util.recursive_parse_xml_to_dict(xml)['annotation']\n if 'object' in data_total:\n for obj in data_total['object']:\n name_in_obj_ = obj['name'].replace(' ', '')\n if name_in_obj_ in labels_by_class_dict:\n labels_by_class_dict[name_in_obj_] += 1\n if idx % 100 == 0:\n logging.info('On image %d of %d', idx, int(len(dataset)))\n if bool(data_total):\n tf_example = dict_to_tf_example(\n data_total,\n label_map_dict)\n writers[idx % FLAGS.num_shards].write(tf_example.SerializeToString())\n\n # close opened shards\n for writer in writers:\n writer.close()","def write( data ):","def write_trainingdata(args: ProcessTrainingArgs) -> None:\n log.info(\"Testing data is fold {} of {}\".format(args.testfold,\n args.folds.K))\n log.info(\"Writing training data to tfrecord in {}-point batches\".format(\n args.batchsize))\n n_rows = len(args.target_src)\n worker = _TrainingDataProcessor(args.feature_path, args.image_spec,\n args.halfwidth)\n sworker = Serialised(worker)\n tasks = list(batch_slices(args.batchsize, n_rows))\n out_it = task_list(tasks, args.target_src, sworker, args.nworkers)\n fold_it = args.folds.iterator(args.batchsize)\n tfwrite.training(out_it, n_rows, args.directory, args.testfold, fold_it)","def write(self, filename, data):\n raise NotImplementedError","def write_TFRecord(X_LR, X_HR, Y_HR, Y_PD, Ret, nx, nz, ny, interv, yp_flow, subsampling_lr, save_path, n_samples, max_samples_per_tfr):\n \n tfrecords_filename_base = save_path + f'Ret{Ret}_{nx}x{nz}x{ny}_dt{int(0.45*100*interv)}_subsampling{subsampling_lr}_yp{yp_flow}_'\n\n n_sets = int(np.ceil(np.sum(n_samples) / max_samples_per_tfr))\n\n i_samp = 0\n i_samp_file = 0\n\n for n_set in range(n_sets):\n\n if (n_set + 1) * max_samples_per_tfr > np.sum(n_samples):\n\n samples_per_tfr = np.sum(n_samples) - n_set * max_samples_per_tfr\n\n else:\n\n samples_per_tfr = max_samples_per_tfr\n\n tfrecords_filename = tfrecords_filename_base + f'file_{n_set+1:03d}-of-{n_sets:03d}_samples{samples_per_tfr:03d}.tfrecords'\n writer = tf.io.TFRecordWriter(tfrecords_filename)\n\n for idx in range(samples_per_tfr):\n\n wall_lr = X_LR[i_samp]\n wall_hr = X_HR[i_samp] \n flow_hr = Y_HR[i_samp]\n flow_pd = Y_PD[i_samp] \n n_modes = flow_pd.shape[0]\n\n wall_lr_raw1 = np.float32(wall_lr[0]).flatten().tolist()\n wall_lr_raw2 = np.float32(wall_lr[1]).flatten().tolist()\n wall_lr_raw3 = np.float32(wall_lr[2]).flatten().tolist()\n\n wall_hr_raw1 = np.float32(wall_hr[0]).flatten().tolist()\n wall_hr_raw2 = np.float32(wall_hr[1]).flatten().tolist()\n wall_hr_raw3 = np.float32(wall_hr[2]).flatten().tolist()\n\n flow_hr_raw1 = np.float32(flow_hr[0]).flatten().tolist()\n flow_hr_raw2 = np.float32(flow_hr[1]).flatten().tolist()\n flow_hr_raw3 = np.float32(flow_hr[2]).flatten().tolist()\n\n flow_pd_raw = np.float32(flow_pd).flatten().tolist()\n\n example = tf.train.Example(\n features = tf.train.Features(\n feature={\n 'i_samp': _int64_feature(i_samp_file),\n 'n_x': _int64_feature(nx),\n 'n_y': _int64_feature(ny),\n 'n_z': _int64_feature(nz),\n 'n_modes': _int64_feature(n_modes),\n 'subsampling': _int64_feature(subsampling_lr),\n 'wall_lr_raw1': _floatarray_feature(wall_lr_raw1),\n 'wall_lr_raw2': _floatarray_feature(wall_lr_raw2),\n 'wall_lr_raw3': _floatarray_feature(wall_lr_raw3),\n 'wall_hr_raw1': _floatarray_feature(wall_hr_raw1),\n 'wall_hr_raw2': _floatarray_feature(wall_hr_raw2),\n 'wall_hr_raw3': _floatarray_feature(wall_hr_raw3),\n 'flow_hr_raw1': _floatarray_feature(flow_hr_raw1),\n 'flow_hr_raw2': _floatarray_feature(flow_hr_raw2),\n 'flow_hr_raw3': _floatarray_feature(flow_hr_raw3),\n 'flow_pd_raw': _floatarray_feature(flow_pd_raw)\n }\n )\n )\n\n writer.write(example.SerializeToString())\n\n i_samp += 1 \n i_samp_file += interv\n\n writer.close()\n\n print(f'Closing file {tfrecords_filename}')\n\n return","def save_to_file(self, data):\n\t\tif self.data_file.write(data):\n\t\t\tprint(\"Data successfully added to file\")\n\t\telse:\n\t\t\tPrint(\"Problem occured during adding to file\")","def create_tf_record(output_filename,\n label_map_dict,\n examples):\n\n\n writer = tf.python_io.TFRecordWriter(output_filename)\n for idx, example in enumerate(examples):\n if idx % 100 == 0:\n logging.warning('On image %d of %d', idx, len(examples))\n try:\n tf_example = dict_to_tf_example(label_map_dict[idx])\n writer.write(tf_example.SerializeToString())\n except AttributeError:\n logging.warning('Invalid example: %s, ignoring.', label_map_dict[idx][0])\n\n\n writer.close()","def generateGenericTFRecord(addrs,labels,numOutputs):\n print(\"Generating TFRecord containing training and test files for {} outputs...\".format(numOutputs))\n filename = 'generic'+str(numOutputs)+'.tfrecords'\n writer = tf.python_io.TFRecordWriter(filename)\n labels = [i-171 for i in labels] #to start from Chinese characters, ignore alphanumeric\n for i in range(len(addrs)):\n # Load the image\n img = Image.open(addrs[i])\n img = np.array(img)\n label = labels[i]\n # Create a feature\n feature = {'label': convertToTFRecord._int64_feature(label),\n 'image': convertToTFRecord._bytes_feature(tf.compat.as_bytes(img.tostring()))}\n # Create an example protocol buffer\n example = tf.train.Example(features=tf.train.Features(feature=feature))\n # Serialize to string and write on the file\n writer.write(example.SerializeToString())\n writer.close()","def save_field(self, field_data, t):\n t0 = time.time()\n self.f << field_data\n t1 = time.time()\n log.debug(\"Saved field at t={} to file '{}' (snapshot #{}; saving took \"\n \"{:.3g} seconds).\".format(t, self.filename, self.counter, t1 - t0))\n self.counter += 1","def create_tfrecord(out_tfrecord_folder,\n caption_folder,\n image_folder,\n samples_per_shard):\n\n # create the outpout directory if it does not already exist\n tf.io.gfile.makedirs(out_tfrecord_folder)\n\n # obtain all caption feature files\n all_caption_f = sorted(\n tf.io.gfile.glob(os.path.join(caption_folder, \"*.txt.pkl\")))\n\n # obtain all image feature files\n all_image_f = sorted(\n tf.io.gfile.glob(os.path.join(image_folder, \"*.jpg.pkl\")))\n\n # create the initial file writer\n shard = 0\n num_samples_so_far = 0\n writer = tf.io.TFRecordWriter(os.path.join(\n out_tfrecord_folder, \"{:013d}.tfrecord\".format(shard)))\n\n # loop through every image which can have several captions\n # save features to the disk in tfrecord format\n # TODO: this should be made parallel\n for caption_f, image_f in zip(all_caption_f, all_image_f):\n with tf.io.gfile.GFile(caption_f, \"rb\") as f:\n samples = pkl.loads(f.read())\n\n # loop through every training example\n for sample in samples:\n\n # occasionally flush all out streams to the disk\n if num_samples_so_far >= samples_per_shard:\n sys.stdout.flush()\n writer.close()\n\n # make a new writer when samples_per_shard is reached\n shard += 1\n num_samples_so_far = 0\n writer = tf.io.TFRecordWriter(os.path.join(\n out_tfrecord_folder, \"{:013d}.tfrecord\".format(shard)))\n\n # serialize a single sequence example to the disk\n sequence_sample = create_sequence_example(image_f, sample)\n writer.write(sequence_sample.SerializeToString())\n num_samples_so_far += 1\n\n # done processing so flush any remaining data\n sys.stdout.flush()\n writer.close()","def write_record(self, *items):\n items = tuple(np.asarray(item) for item in items)\n total_size = sum(item.nbytes for item in items)\n\n nb = np.array([total_size], dtype=self._header_dtype)\n\n nb.tofile(self._fp)\n for item in items:\n item.tofile(self._fp)\n nb.tofile(self._fp)","def create_tffile(self, path, fl_list, outpath):\n with tf.python_io.TFRecordWriter(outpath) as wr:\n for vl in fl_list:\n exam = self.create_tfrec(path, vl[0], vl[1])\n wr.write(exam.SerializeToString())","def save_record(self, data, rownum=None):\n\n if rownum is not None:\n # This is an update\n records = self.get_all_records()\n records[rownum] = data\n with open(self.filename, 'w', encoding='utf-8') as fh:\n csvwriter = csv.DictWriter(fh, fieldnames=self.fields.keys())\n csvwriter.writeheader()\n csvwriter.writerows(records)\n else:\n # This is a new record\n newfile = not os.path.exists(self.filename)\n\n with open(self.filename, 'a', encoding='utf-8') as fh:\n csvwriter = csv.DictWriter(fh, fieldnames=self.fields.keys())\n if newfile:\n csvwriter.writeheader()\n csvwriter.writerow(data)","def test_write(self):\n path = os.path.join(self.tmp_dir, 'foo.tfrecord')\n writer = tfrecords_writer.Writer('some spec', path)\n to_write = [\n (1, b'a'), (2, b'b'),\n (3, b'c'),\n (4, b'd'), (5, b'e'),\n (6, b'f'),\n (7, b'g'), (8, b'h'),\n ]\n for key, record in to_write:\n writer.write(key, record)\n with absltest.mock.patch.object(tfrecords_writer, '_get_number_shards',\n return_value=5):\n shards_length = writer.finalize()\n self.assertEqual(shards_length, [2, 1, 2, 1, 2])\n written_files, all_recs = _read_records(self.tmp_dir)\n self.assertEqual(written_files,\n ['foo.tfrecord-0000%s-of-00005' % i for i in range(5)])\n self.assertEqual(all_recs, [\n [b'f', b'e'], [b'b'], [b'a', b'g'], [b'h'], [b'c', b'd'],\n ])","def _write_shard(filename, dataset, indices):\n with tf.python_io.TFRecordWriter(filename) as writer:\n for j in indices:\n writer.write(dataset[j])","def create_tf_record(\n output_filename,\n label_map_dict,\n dataset,\n examples):\n writer = tf.python_io.TFRecordWriter(output_filename)\n for idx, example in enumerate(examples):\n if idx % 100 == 0:\n logging.info('On image %d of %d', idx, len(examples))\n path = os.path.join(\"data\", dataset, 'annotations', example + '.xml')\n\n if not os.path.exists(path):\n logging.warning('Could not find %s, ignoring example.', path)\n continue\n with tf.gfile.GFile(path, 'r') as fid:\n xml_str = fid.read()\n xml = etree.fromstring(xml_str.encode('utf-8'))\n data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation']\n data['filename'] = \"{}.jpg\".format(example)\n\n tf_example = dict_to_tf_example(data, label_map_dict, os.path.join(\"data\", dataset, \"images\"))\n writer.write(tf_example.SerializeToString())\n\n writer.close()","def _write_shard(filename, dataset, indices):\n with tf.io.TFRecordWriter(filename) as writer:\n for j in indices:\n writer.write(dataset[j])","def data_to_tfrecord(images, labels, filename):\n if os.path.isfile(filename):\n print(\"%s exists\" % filename)\n return\n print(\"Converting data into %s ...\" % filename)\n # cwd = os.getcwd()\n writer = tf.python_io.TFRecordWriter(filename)\n for index, img in enumerate(images):\n img_raw = img.tobytes()\n # Visualize a image\n # tl.visualize.frame(np.asarray(img, dtype=np.uint8), second=1, saveable=False, name='frame', fig_idx=1236)\n label = int(labels[index])\n example = tf.train.Example(\n features=tf.train.Features(\n feature={\n \"label\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),\n 'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),\n }\n )\n )\n writer.write(example.SerializeToString()) # Serialize To String\n writer.close()","def to_tfrecord(data_blob):\n\n id = np.array(data_blob['id'], dtype=np.int32).tobytes()\n dim = np.array(data_blob['images'].shape, dtype=np.int32).tobytes()\n\n images = np.array(data_blob['images'], dtype=np.uint8).tobytes()\n poses = np.array(data_blob['poses'], dtype=np.float32).tobytes()\n depth = np.array(data_blob['depth'], dtype=np.float32).tobytes()\n filled = np.array(data_blob['filled'], dtype=np.float32).tobytes()\n intrinsics = np.array(data_blob['intrinsics'], dtype=np.float32).tobytes()\n\n\n example = tf.train.Example(features=tf.train.Features(feature={\n 'id': tf.train.Feature(bytes_list=tf.train.BytesList(value=[id])),\n 'dim': tf.train.Feature(bytes_list=tf.train.BytesList(value=[dim])),\n 'images': tf.train.Feature(bytes_list=tf.train.BytesList(value=[images])),\n 'poses': tf.train.Feature(bytes_list=tf.train.BytesList(value=[poses])),\n 'depth': tf.train.Feature(bytes_list=tf.train.BytesList(value=[depth])),\n 'filled': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filled])),\n 'intrinsics': tf.train.Feature(bytes_list=tf.train.BytesList(value=[intrinsics])),\n }))\n\n return example","def write_record(file_path, records, objector):\n request = service_pb2.WriteLocalSeqFileRequest()\n request.file_path = file_path\n for record in records:\n request.key.append(\"\")\n request.value.append(objector.serialize(record))\n\n response = _service.request(request, \"write_local_seqfile\")\n\n import google.protobuf.json_format as json_format\n res = json_format.Parse(response, service_pb2.VoidResponse())\n\n return None, res.status","def convert_dataset_to_tfrecord(data_set, save_dir, name):\n images = data_set.images\n labels = data_set.labels\n num_samples = data_set.num_examples\n\n rows = images.shape[1]\n cols = images.shape[2]\n depth = images.shape[3]\n\n filename = os.path.join(save_dir, name + '.tfrecords')\n with tf.python_io.TFRecordWriter(filename) as writer:\n for index in range(num_samples):\n image_raw = images[index].tostring()\n example = tf.train.Example(\n features=tf.train.Features(\n feature={\n 'height': _int64_feature(rows),\n 'width': _int64_feature(cols),\n 'depth': _int64_feature(depth),\n 'label': _int64_feature(int(labels[index])),\n 'image': _bytes_feature(image_raw)\n }))\n writer.write(example.SerializeToString())","def open(self):\n opt = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.GZIP)\n self.valid = tf.python_io.TFRecordWriter(self.valid_filename, opt)\n self.test = tf.python_io.TFRecordWriter(self.test_filename, opt)\n self.train = [tf.python_io.TFRecordWriter(filename, opt) for filename in\n self.train_filenames]","def make_tfrecord(img_dir, outf_nm='my_dataset'):\n img_file_list = glob(img_dir)\n outf_nm += '.tfrecord'\n tfrecord_wrt = tf.python_io.TFRecordWriter(outf_nm)\n for img_file in tqdm(img_file_list):\n # read image into np.array\n img = cv2.cvtColor(cv2.imread(img_file), cv2.COLOR_BGR2RGB)\n # compute shrink ratio\n shrink_ratio = TGT_SHAPE/max(img.shape)\n # shrink image to reduce size in resultant tf record file\n img = cv2.resize(img, (0, 0), fx=shrink_ratio, fy=shrink_ratio)\n # pass to function to serialize to tf example\n exmp = make_img_example(img)\n exmp_serial = exmp.SerializeToString()\n tfrecord_wrt.write(exmp_serial)","def record(self, content):\n datafile = open(self.filename, 'at')\n datafile.write('%s\\n' % content)\n datafile.close()","def to_file(self, file_path, smirnoff_data):\n pass","def _write_txt(\n output_path, records\n):\n output_path.write_text(_records_to_string(records))","def write(cls, file, data):\n file.write(data)","def make_tfrecords_from_arrs(data_records,save_path,dtypes=[np.float32,np.float32]):\n assert len(dtypes)==len(data_records),\"length of dtypes should be same length of data_records\"\n writer=tf.python_io.TFRecordWriter(save_path)\n first = True\n for k in data_records:\n if first:\n arr_size = len(data_records[k])\n first = False\n else:\n assert len(data_records[k]) == arr_size, 'not all components in data_records is of same size'\n names = []\n arr_grps = []\n count = 0\n for name, arr_grp in data_records.items():\n if type(arr_grp)==np.ndarray:\n arr_grp = arr_grp.astype(dtypes[count])\n names.append(name)\n arr_grps.append(arr_grp)\n count += 1\n for record in zip(*arr_grps):\n feature = {}\n for name, arr in zip(names, record):\n if type(arr)==np.ndarray or type(arr)==np.uint8:\n arr_str = arr.tostring()\n feature[name] = MakeTFRecords_tfdata._bytes_feature(arr_str)\n elif type(arr)==str:\n arr = np.asarray(arr).tostring()\n feature[name] = MakeTFRecords_tfdata._bytes_feature(arr)\n\n example = tf.train.Example(features=tf.train.Features(feature=feature))\n writer.write(example.SerializeToString())\n writer.close()","def test_tfrecord_to_mindrecord():\n if not tf or tf.__version__ < SupportedTensorFlowVersion:\n # skip the test\n logger.warning(\"Module tensorflow is not found or version wrong, \\\n please use pip install it / reinstall version >= {}.\".format(SupportedTensorFlowVersion))\n return\n\n file_name_ = os.environ.get('PYTEST_CURRENT_TEST').split(':')[-1].split(' ')[0]\n mindrecord_file_name = file_name_ + '.mindrecord'\n tfrecord_file_name = file_name_ + '.tfrecord'\n generate_tfrecord(tfrecord_file_name)\n\n assert os.path.exists(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\n\n feature_dict = {\"file_name\": tf.io.FixedLenFeature([], tf.string),\n \"image_bytes\": tf.io.FixedLenFeature([], tf.string),\n \"int64_scalar\": tf.io.FixedLenFeature([], tf.int64),\n \"float_scalar\": tf.io.FixedLenFeature([], tf.float32),\n \"int64_list\": tf.io.FixedLenFeature([6], tf.int64),\n \"float_list\": tf.io.FixedLenFeature([7], tf.float32),\n }\n\n if os.path.exists(mindrecord_file_name):\n os.remove(mindrecord_file_name)\n if os.path.exists(mindrecord_file_name + \".db\"):\n os.remove(mindrecord_file_name + \".db\")\n\n tfrecord_transformer = TFRecordToMR(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name),\n mindrecord_file_name, feature_dict, [\"image_bytes\"])\n tfrecord_transformer.transform()\n\n assert os.path.exists(mindrecord_file_name)\n assert os.path.exists(mindrecord_file_name + \".db\")\n\n fr_mindrecord = FileReader(mindrecord_file_name)\n verify_data(tfrecord_transformer, fr_mindrecord)\n\n os.remove(mindrecord_file_name)\n os.remove(mindrecord_file_name + \".db\")\n\n os.remove(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))","def save(datastream):","def to_file(self, records):\n self._file_manager.make_dir_when_no_dir(self._directory)\n file = os.path.join(self._directory, self._file_name + '.txt')\n record_lines = [rec.to_string() + \"\\n\" for rec in records]\n self._file_manager.write_lines(file, record_lines)","def write_record(self, record=None):\n contents = dict()\n for key, value in record.items():\n if value is None:\n continue\n elif key not in self.input_types:\n continue\n else:\n input_type = self.input_types[key]\n if input_type == 'float':\n # Handle np.float() types gracefully\n contents[key] = float(value)\n elif input_type == 'str':\n contents[key] = value\n elif input_type == 'int':\n contents[key] = int(value)\n elif input_type == 'boolean':\n contents[key] = bool(value)\n elif input_type == 'nparray':\n contents[key] = value.tolist()\n elif input_type == 'list' or input_type == 'vector':\n contents[key] = list(value)\n elif input_type == 'image_array':\n # Handle image array\n image = Image.fromarray(np.uint8(value))\n name = Tub._image_file_name(self.manifest.current_index, key)\n image_path = os.path.join(self.images_base_path, name)\n image.save(image_path)\n contents[key] = name\n elif input_type == 'gray16_array':\n # save np.uint16 as a 16bit png\n image = Image.fromarray(np.uint16(value))\n name = Tub._image_file_name(self.manifest.current_index, key, ext='.png')\n image_path = os.path.join(self.images_base_path, name)\n image.save(image_path)\n contents[key]=name\n\n # Private properties\n contents['_timestamp_ms'] = int(round(time.time() * 1000))\n contents['_index'] = self.manifest.current_index\n contents['_session_id'] = self.manifest.session_id\n\n self.manifest.write_record(contents)","def save(self, data):\n self.write(data)","def saveFile(self, data, filelocation):\n with open(filelocation, 'w+') as f:\n f.write(data)","def writeto(self, fileout):\n \n dump_pkl(self.data, fileout)","def convert_to(data_dir, dataset, labels, name):\n images = dataset\n labels = labels\n num_examples = dataset.shape[0]\n \n rows, cols, depth = dataset[0].shape\n \n filename = os.path.join(data_dir, name + '.tfrecords')\n \n writer = tf.python_io.TFRecordWriter(filename)\n \n for idx in range(num_examples):\n image_raw = images[idx].tostring()\n example = tf.train.Example(features=tf.train.Features(feature={\n 'height': _int64_feature(rows),\n 'width': _int64_feature(cols),\n 'depth': _int64_feature(depth),\n 'label': _int64_feature(int(labels[idx])),\n 'image_raw': _bytes_feature(image_raw)\n }))\n writer.write(example.SerializeToString())\n writer.close()","def create_tf_record(output_filename,\n label_map_dict,\n annotations_dir,\n annotation_file,\n image_dir,\n examples):\n with tf.gfile.GFile(os.path.join(annotations_dir, annotation_file)) as fid:\n lines = fid.readlines()\n\n writer = tf.python_io.TFRecordWriter(output_filename)\n\n for idx, example in enumerate(examples):\n if idx % 100 == 0:\n logging.info('On image %d of %d', idx, len(examples))\n print ' On image {0} of {1}'.format(idx, len(examples))\n\n pos = 0\n while pos < len(lines):\n line = lines[pos]\n line = line.strip().split()\n\n if len(line) != 0:\n if line[0] == example:\n break\n pos += 1\n\n if pos >= len(lines):\n logging.info('filename not found in '+annotation_file)\n\n tf_example = dict_to_tf_example(lines[pos], label_map_dict, image_dir)\n writer.write(tf_example.SerializeToString())\n \n writer.close()","def data_to_file(data, ta_file):\n file_handle = file(ta_file, \"w\")\n file_handle.write(data_to_string(data))\n file_handle.close()","def _convert_dataset(data, tfrecord_path, dataset):\n output_filename = os.path.join(tfrecord_path, dataset+\".tfrecord\") # /home/wangdong/桌面/工程项目目录Spyter-tensorblow/研究生竞赛 /一带一路竞赛/初赛赛题/tfrecord/train.tfrecord\n tfrecord_writer = tf.python_io.TFRecordWriter(output_filename) # 创建一个writer来写TFRecords文件\n length = len(data) # 三维数组的长度 84078\n for index, item in enumerate(data):\n data_ = item[0].tobytes()\n visit = item[1].tobytes()\n label = item[2] # 对应功能分类的标签\n example = image_to_tfexample(data_, visit, label)\n tfrecord_writer.write(example.SerializeToString()) # 将样列序列化为字符串后， 写入out_filename文件中\n sys.stdout.write('\\r>> Converting image %d/%d' % (index + 1, length))\n sys.stdout.flush()\n sys.stdout.write('\\n')\n sys.stdout.flush()","def write_record(\n record,\n target,\n file_format=\"genbank\",\n remove_locationless_features=True,\n max_name_length=20,\n):\n record = deepcopy(record)\n if remove_locationless_features:\n record.features = [f for f in record.features if f.location is not None]\n record.name = record.name[:max_name_length]\n if has_dna_alphabet:\n if str(record.seq.alphabet.__class__.__name__) != \"DNAAlphabet\":\n record.seq.alphabet = DNAAlphabet()\n if hasattr(target, \"open\"):\n target = target.open(\"w\")\n SeqIO.write(record, target, file_format)","def write(self, fname):\n pass","def write_record(rec):\n points = str(rec['Points']).replace(\"(\",\"[\").replace(\")\",\"]\")\n l = [ rec['UniqueID'], rec['FAO_USDA'], rec['Soil'], rec['Suborder'],\n rec['maxlat'], rec['maxlon'], rec['minlat'], rec['minlon'], points ]\n strings = map(str, l)\n return \"\\t\".join(strings) + \"\\n\"","def write(fname, data):\n # Encode to string.\n encoder = NumpyJSONEncoder(check_circular=True, indent=' ')\n serial = encoder.encode(data)\n\n # Write to file.\n with open(fname, 'w') as fo:\n fo.write(serial)","def convert_to_tf_record(_):\n\n mnist = input_data.read_data_sets(\n \"/tmp/tensorflow/mnist/input_data\",\n reshape=False\n )\n\n convert_to(mnist.validation, 'validation', FLAGS.data_directory)\n convert_to(mnist.train, 'train', FLAGS.data_directory, num_shards=10)\n convert_to(mnist.test, 'test', FLAGS.data_directory)","def record(self):\n # TODO: record the data","def _convert_dataset_test(data, tfrecord_path, dataset):\n output_filename = os.path.join(tfrecord_path, dataset+\".tfrecord\") # /home/wangdong/桌面/工程项目目录Spyter-tensorblow/研究生竞赛 /一带一路竞赛/初赛赛题/tfrecord/train.tfrecord\n tfrecord_writer = tf.python_io.TFRecordWriter(output_filename) # 创建一个writer来写TFRecords文件\n length = len(data) # 三维数组的长度 84078\n for index, item in enumerate(data):\n data_ = item[0].tobytes()\n visit = item[1].tobytes()\n areaID = item[2] # 对应地区的名字\n example = image_to_tfexample(data_, visit, areaID)\n tfrecord_writer.write(example.SerializeToString()) # 将样列序列化为字符串后， 写入out_filename文件中\n sys.stdout.write('\\r>> Converting image %d/%d' % (index + 1, length))\n sys.stdout.flush()\n sys.stdout.write('\\n')\n sys.stdout.flush()","def save(self,outPath=None):\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\"Insufficient data to write file.\"))\n if not outPath:\n fileInfo = self.fileInfo\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\n out = file(outPath,'wb')\n #--Tes3 Record\n self.tes3.changed = 1\n self.tes3.hedr.changed = 1\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\n self.tes3.getSize()\n self.tes3.dump(out)\n #--Size Cell Records\n cntRecords = 0\n progress = self.progress\n progress.setMax(len(self.cells))\n progress(0.0,'Saving '+self.fileInfo.name)\n for record in self.cells:\n record.getSize()\n #--Progress\n cntRecords += 1\n progress(cntRecords)\n #--Other Records\n for record in self.records:\n record.getSize() #--Should already be done, but just in case.\n record.dump(out)\n out.close()","def save_and_upload_samples(data, namespace, workspace, tsca_id):\n os.system('mkdir -p %s'%tsca_id)\n filename = '%s/fc_upload_samples_tsca_%s.txt' % (tsca_id, tsca_id)\n data.to_csv(filename, sep='\\t', index=False)\n res = upload_entities_from_tsv(namespace, workspace, filename)\n return res","def write_checkpoint(self):\n self.file_checkpoint_data = open(self.path_checkpoint, \"a+\")\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\n self.file_checkpoint_data.write(','.join(array_to_write) + \"\\n\")\n self.file_checkpoint_data.flush()","def write(init_time, end_time, vpk, media, rms):\n global data_file\n\n # atualiza o arquivo de dados\n update()\n\n # Salva os dados no arquivo\n data_file.write(\n str(init_time) + ',' + str(end_time) + ',' +\n str(vpk) + ',' + str(media) + ',' + str(rms) + '\\n'\n )","def Writedata(self, tstep):\n \n nc = Dataset(self.outfile, 'a')\n \n nc.variables['time'][tstep] = self.time\n nc.variables['salt'][tstep] = self.salt\n nc.variables['temp'][tstep] = self.temp\n nc.variables['uc'][tstep] = self.uc\n nc.variables['vc'][tstep] = self.vc\n nc.variables['nu_v'][tstep] = self.nu_v\n nc.variables['rho'][tstep] = self.rho\n nc.variables['tau_x'][tstep] = self.tau_x\n nc.variables['tau_y'][tstep] = self.tau_y\n nc.variables['eta'][tstep] = self.eta\n \n nc.close()","def _write_goft(parameters):\n # Format\n fmt = block_to_format[\"GOFT\"]\n fmt = str2format(fmt[5])\n\n values = [x for x in parameters[\"generator_history\"]]\n out = write_record(values, fmt, multi=True)\n\n return out","def write_scat(fname, data):\n from esutil.recfile import Recfile\n if os.path.exists(fname):\n os.remove(fname)\n with Recfile(fname,'w',delim=' ') as robj:\n robj.write(data)","def save(self, output, data):","def to_file(self, fname, delimiter=\"\\t\", encoding=\"utf-8\"):\n with open(fname, \"wb\") as fh:\n for key, score in self.ranked_items():\n fh.write(self.to_record(key, score, delimiter).encode(encoding))","def write_data(tech_id, tech_name, sentence, source, date_crawled):\n with open('PDF_data.txt', 'a') as f:\n # text = match[\"tid\"] + '\\n' + match[\"name\"] + '\\n' + sent + '\\n' + source + '\\n' + date_crawled + '\\n\\n'\n text = tech_id + '\\n' + tech_name + '\\n' + sentence + '\\n' + source + '\\n' + date_crawled + '\\n\\n'\n f.write(text)","def create_tfrec(self, path, imgfile, txtfile):\n ifname = os.path.join(path, imgfile)\n tfname = os.path.join(path, txtfile)\n\n # Size\n with Image.open(ifname) as img:\n width, height = img.size\n\n with tf.gfile.GFile(ifname, 'rb') as eimg:\n enc_img = eimg.read()\n hashed = hashlib.sha256(enc_img).hexdigest().encode('utf8')\n\n # Class and BBox\n with open(tfname, 'r') as fp:\n aline = fp.read()\n aline_splt = aline.split()\n imclazztxt = self.clazzes[int(aline_splt[0])].encode('utf8')\n imclazzint = int(aline_splt[0])\n cx, cy = float(aline_splt[1]), float(aline_splt[2])\n wx, wy = float(aline_splt[3]), float(aline_splt[4])\n xtl = (cx - wx/2.0)\n ytl = (cy - wy / 2.0)\n xbr = (cx + wx / 2.0)\n ybr = (cy + wy / 2.0)\n\n fname, ext = os.path.splitext(imgfile)\n imtype = 'jpeg' if (ext == 'jpg') else 'png'\n\n # Create TF Record\n trec = tf.train.Example(features=tf.train.Features(feature={\n 'image/height': self.add_int_feature(height),\n 'image/width': self.add_int_feature(width),\n 'image/filename': self.add_bytes_feature(imgfile.encode('utf8')),\n 'image/source_id': self.add_bytes_feature(imgfile.encode('utf8')),\n 'image/key/sha256': self.add_bytes_feature(hashed),\n 'image/encoded': self.add_bytes_feature(enc_img),\n 'image/format': self.add_bytes_feature(imtype.encode('utf8')),\n 'image/object/bbox/xmin': self.add_float_feature(xtl),\n 'image/object/bbox/xmax': self.add_float_feature(xbr),\n 'image/object/bbox/ymin': self.add_float_feature(ytl),\n 'image/object/bbox/ymax': self.add_float_feature(ybr),\n 'image/object/class/text': self.add_bytes_feature(imclazztxt),\n 'image/object/class/label': self.add_int_feature(imclazzint)\n }))\n return trec","def to_tfrecords(root_path, video_name, video_idx, list_imgpaths, list_keypoints, list_masks):\n make_dir(root_path + 'tfrecords/')\n out_path = os.path.join(root_path + 'tfrecords/' + video_name + \".tfrecords\")\n if not list_masks:\n list_masks = []\n mask = np.array([0])\n for i in range(len(list_imgpaths)):\n list_masks.append(mask)\n if not list_keypoints:\n list_keypoints = []\n kp = np.array([0])\n for i in range(len(list_imgpaths)):\n list_keypoints.append(kp)\n print(\"Converting: \" + video_name)\n with tf.python_io.TFRecordWriter(out_path) as writer:\n # Iterate over all the image-paths and class-labels.\n for i, (img_path, keypoints, mask) in enumerate(zip(list_imgpaths, list_keypoints, list_masks)):\n with open(img_path, 'rb') as f:\n img_raw = f.read()\n\n # Convert the image to raw bytes.\n # img_bytes = img_raw.tostring()\n # Create a dict with the data we want to save in the\n # TFRecords file. You can add more relevant data here.\n data = {'image': wrap_bytes(img_raw), # todo add frame number\n 'video': wrap_int64(video_idx),\n 'keypoints': wrap_float32(keypoints),\n # 'bbox_max': wrap_int64(max_bbox),\n 'masks': wrap_float32(mask), }\n\n # Wrap the data as TensorFlow Features.\n feature = tf.train.Features(feature=data)\n\n # Wrap again as a TensorFlow Example.\n example = tf.train.Example(features=feature)\n\n # Serialize the data.\n serialized = example.SerializeToString()\n\n # Write the serialized data to the TFRecords file.\n writer.write(serialized)","def save_data(self, record):\n self.dbm.addRecord(record)","def save(self, data, file_id=None, metadata={}):\n pass","def write_to(self, filename):\n with open(filename, 'w') as f:\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\n f.write(\"%s %s %s %s\\n\" % (xx, yy, zz, ww))\n logger.info(\"Written data into file {0}\".format(filename))","def record_trace(self):\n\n tfname = str(int(time.time())) + \".obd2_reader.trace\"\n self.tf_out = open(tfname, 'a')\n self.RecordTrace = 1\n print \"Recoding trace to:\", tfname","def cli(db_fp, out_fp=None):\n if out_fp is None:\n out_fp = db_fp + '.content'\n LOGGER.info(\"Writing from DB `%s` to `%s`.\", db_fp, out_fp)\n records = natsorted(glob(db_fp + '_p*.tfrecords'))\n if not path.exists(out_fp):\n os.mkdir(out_fp)\n nsamples, colnames, coltypes = cdbt.scan_tfdb(records)\n fillwidth = int(np.ceil(np.log10(nsamples)))\n run_idx = 0\n pbar = tqdm.tqdm(total=nsamples)\n for rec_fp in records:\n record_iterator = tf.python_io.tf_record_iterator(path=rec_fp)\n for string_record in record_iterator:\n example = tf.train.Example()\n example.ParseFromString(string_record)\n values = cdbt.decode_tf(example, colnames, coltypes, as_list=True)\n for colt, coln, val in zip(coltypes, colnames, values):\n if colt == 'text':\n with open(path.join(out_fp,\n '{0:0{width}}_{1}.txt'.format(\n run_idx, coln, width=fillwidth)\n .encode(\"ascii\")),\n 'w') as outf:\n outf.write(val)\n elif colt == 'plain':\n np.save(\n path.join(out_fp, '{0:0{width}}_{1}.npy'.format(\n run_idx, coln, width=fillwidth)),\n val)\n else:\n sm.imsave(\n path.join(out_fp, '{0:0{width}}_{1}.png'.format(\n run_idx, coln, width=fillwidth)),\n val)\n run_idx += 1\n pbar.update(1)\n pbar.close()\n LOGGER.info(\"Done.\")","def test_tfrecord_to_mindrecord_with_special_field_name():\n if not tf or tf.__version__ < SupportedTensorFlowVersion:\n # skip the test\n logger.warning(\"Module tensorflow is not found or version wrong, \\\n please use pip install it / reinstall version >= {}.\".format(SupportedTensorFlowVersion))\n return\n\n file_name_ = os.environ.get('PYTEST_CURRENT_TEST').split(':')[-1].split(' ')[0]\n mindrecord_file_name = file_name_ + '.mindrecord'\n tfrecord_file_name = file_name_ + '.tfrecord'\n generate_tfrecord_with_special_field_name(tfrecord_file_name)\n assert os.path.exists(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\n\n feature_dict = {\"image/class/label\": tf.io.FixedLenFeature([], tf.int64),\n \"image/encoded\": tf.io.FixedLenFeature([], tf.string),\n }\n\n if os.path.exists(mindrecord_file_name):\n os.remove(mindrecord_file_name)\n if os.path.exists(mindrecord_file_name + \".db\"):\n os.remove(mindrecord_file_name + \".db\")\n\n tfrecord_transformer = TFRecordToMR(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name),\n mindrecord_file_name, feature_dict, [\"image/encoded\"])\n tfrecord_transformer.transform()\n\n assert os.path.exists(mindrecord_file_name)\n assert os.path.exists(mindrecord_file_name + \".db\")\n\n fr_mindrecord = FileReader(mindrecord_file_name)\n verify_data(tfrecord_transformer, fr_mindrecord)\n\n os.remove(mindrecord_file_name)\n os.remove(mindrecord_file_name + \".db\")\n\n os.remove(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))","def save_to(self, f: BinaryIO):\n raise NotImplementedError","def write(self, record):\n # Make Splunk ready payload data and append it to self._buffers list.\n self._buffer.append({\n 'index': self._index,\n 'sourcetype': 'json',\n 'event': record\n })\n\n # If the records count in self._buffer is more than allowed by\n # self._buffer_size, send those records to Splunk.\n if len(self._buffer) >= self._buffer_size:\n self._flush()","def save_file(self, filename):\n if self.t3data:\n np.savetxt(filename, self.t3data)\n else:\n self.export_to_ascii()","def save_data(self, f): \n if not self.sampling:\n self.convert_to_array()\n np.save(f, self.reads)"],"string":"[\n \"def _create_tfrecords_file(data, output_file):\\n with tf.io.TFRecordWriter(str(output_file)) as writer:\\n for image, sign in data:\\n with tf.io.gfile.GFile(image, \\\"rb\\\") as f:\\n image_string = f.read()\\n feature = {\\n \\\"image\\\": tf.train.Feature(\\n bytes_list=tf.train.BytesList(value=[image_string])),\\n \\\"label\\\": tf.train.Feature(\\n int64_list=tf.train.Int64List(value=[sign]))\\n }\\n example = tf.train.Example(features=tf.train.Features(feature=feature))\\n writer.write(example.SerializeToString())\",\n \"def write_record(self, input):\\n \\\"\\\"\\\"\\n input: dict (dict of key, elem to write to tf-record)\\n \\\"\\\"\\\"\\n features = collections.OrderedDict()\\n for key, value in input.items():\\n if self.schema[key][0] == \\\"fixed_len\\\":\\n if self.schema[key][2] != []:\\n shape = self.schema[key][2][0]\\n if len(value) != shape:\\n raise ValueError(\\n \\\"`{}` has schema shape `{}`, but provided \\\\\\n values `{}` has shape `{}`\\\".format(\\n key, shape, value, len(value) # noqa\\n )\\n )\\n\\n if isinstance(value, six.text_type):\\n value = six.ensure_binary(value, \\\"utf-8\\\")\\n features[key] = self.schema_writer_fn[key](value)\\n example_proto = tf.train.Example(features=tf.train.Features(feature=features))\\n\\n if self.tag == \\\"train\\\":\\n if self.shuffle:\\n index = random.choice(range(len(self.all_writer)))\\n the_writer = self.all_writer[index]\\n the_writer.write(example_proto.SerializeToString())\\n self.examples_per_record[self.all_files[index]] += 1\\n self.global_counter += 1\\n else:\\n\\n # If global counter(no of individual records processed)\\n # exceeds max_files_per_record then increment self.current_writer\\n if self.global_counter > (self.current_writer + 1) * self.max_files_per_record:\\n self.current_writer += 1\\n self.current_file_name = \\\"{}_{}_{}.tfrecord\\\".format(self.file_name, self.tag, self.current_writer)\\n self.examples_per_record[self.current_file_name] = 0\\n self.current_file = tf.io.TFRecordWriter(self.current_file_name)\\n self.temp_writers.append(self.current_file)\\n\\n the_writer = self.current_file\\n the_writer.write(example_proto.SerializeToString())\\n self.examples_per_record[self.current_file_name] += 1\\n self.global_counter += 1\\n\\n if self.global_counter % self.verbose_counter == 0:\\n logging.info(\\\"Wrote {} tfrecods\\\".format(self.global_counter))\\n else:\\n the_writer = self.all_writer[0]\\n the_writer.write(example_proto.SerializeToString())\\n self.global_counter += 1\\n\\n if self.global_counter % self.verbose_counter == 0:\\n logging.info(\\\"Wrote {} tfrecods\\\".format(self.global_counter))\",\n \"def write_tfrecords(self, records, dataset):\\n\\n cnt_inc = len(records)\\n self.count += cnt_inc\\n\\n if dataset == 'test':\\n self.count_test += cnt_inc\\n for s in records:\\n self.test.write(s)\\n elif dataset == 'train':\\n self.count_train += cnt_inc\\n for s in records:\\n self.train[self.pick_file()].write(s)\\n elif dataset == 'valid':\\n self.count_eval += cnt_inc\\n for s in records:\\n self.valid.write(s)\\n else:\\n raise ValueError(\\\"invalid dataset: %s\\\" % dataset)\",\n \"def dump_to_tfrecord(record_file: str,\\n tf_examples: Sequence[Union[tf.train.Example,\\n tf.train.SequenceExample]]):\\n file_writers.write_small_dataset(tf_examples, record_file, 'tfrecord')\",\n \"def _writeRecord(self, path, name, data):\\n file_path = os.path.join(path, name)\\n with open(file_path, 'w') as f:\\n for item in data:\\n f.write(str(item)+'\\\\t')\\n f.write('\\\\n')\",\n \"def write_to_file(writer, data):\\n feature = {\\n \\\"text\\\": _int64_feature(data)\\n }\\n tf_example = tf.train.Example(features=tf.train.Features(feature=feature))\\n writer.write(tf_example.SerializeToString())\",\n \"def write_to_file(writer, data):\\n feature = {\\n \\\"text\\\": _int64_feature(data)\\n }\\n tf_example = tf.train.Example(features=tf.train.Features(feature=feature))\\n writer.write(tf_example.SerializeToString())\",\n \"def add_to_tfrecord():\\n\\n record_path = os.path.join(FLAGS.dataset_dir, \\\"records\\\")\\n if not os.path.isdir(record_path):\\n os.makedirs(record_path)\\n\\n ####### Path Definition #######\\n img_path = \\\"data/traindata/ccmpred/\\\"\\n ss3_path = \\\"data/traindata/ss3/\\\"\\n pdb_path = \\\"data/traindata/pdb/\\\"\\n fasta_path = \\\"data/traindata/fasta/\\\"\\n\\n with open('data/train.list') as fin:\\n names = [line.rstrip() for line in fin]\\n\\n num_shards = int(len(names) / 1000)\\n num_per_shard = int(math.ceil(len(names) / float(num_shards)))\\n\\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)\\n with tf.Graph().as_default(), tf.device('/cpu:0'):\\n with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\\n for shard_id in range(num_shards):\\n record_filename = os.path.join(record_path, \\\"new_train_ss3_%d.tfrecord\\\" %shard_id)\\n options = tf.python_io.TFRecordOptions(TFRecordCompressionType.ZLIB)\\n with tf.python_io.TFRecordWriter(record_filename) as tfrecord_writer:\\n start_ndx = shard_id * num_per_shard\\n end_ndx = min((shard_id + 1) * num_per_shard, len(names))\\n print \\\"processing data from %d to %d...\\\" %(start_ndx, end_ndx)\\n for i in range(start_ndx, end_ndx):\\n name = names[i]\\n img = np.loadtxt(os.path.join(img_path, name+\\\".ccmpred\\\"))\\n height, width = img.shape\\n # load ss3 info\\n predss3 = np.loadtxt(os.path.join(ss3_path, name+\\\".ss3\\\"))\\n if predss3.shape[0] != height:\\n continue\\n Index = np.mgrid[0: height, 0: width]\\n i, j = Index[0], Index[1]\\n ss3mat = np.concatenate([predss3[i], predss3[j]], axis=-1)\\n # combine ccmpred and ss3\\n img = np.concatenate([img[..., np.newaxis], ss3mat], axis=-1)\\n\\n # box and mask info\\n pdb = os.path.join(pdb_path, name+\\\".pdb\\\")\\n fasta = os.path.join(fasta_path, name+\\\".fasta\\\")\\n L, gt_boxes, masks, ss3 = LoadNativeBox(name, pdb, fasta)\\n gt_boxes = np.array(gt_boxes).astype(np.float32)\\n masks = np.array(masks).astype(np.uint8) ### Important ###\\n \\n # combine all masks in one mask\\n mask = np.zeros(shape=(height, width), dtype=np.int8)\\n for m in masks:\\n mask += m\\n\\n img = img.astype(np.float64)\\n #assert img.size == width * height * 3, '%s' % str(name)\\n \\n #if gt_boxes.shape[0] > 0:\\n example = to_tfexample_raw(\\n name, img.tostring(), mask.tostring(),\\n height, width, \\n gt_boxes.shape[0], gt_boxes.tostring(), masks.tostring())\\n \\n tfrecord_writer.write(example.SerializeToString())\",\n \"def test_write_tfrecord(self):\\n path = os.path.join(self.tmp_dir, 'foo-train.tfrecord')\\n shards_length, total_size = self._write(to_write=self.RECORDS_TO_WRITE)\\n self.assertEqual(self.NUM_SHARDS, len(shards_length))\\n self.assertEqual(\\n shards_length, [len(shard) for shard in self.SHARDS_CONTENT]\\n )\\n self.assertEqual(total_size, 9)\\n written_files, all_recs = _read_records(path)\\n written_index_files, all_indices = _read_indices(path)\\n self.assertEqual(\\n written_files,\\n [\\n f'foo-train.tfrecord-{i:05d}-of-{self.NUM_SHARDS:05d}'\\n for i in range(self.NUM_SHARDS)\\n if shards_length[i]\\n ],\\n )\\n self.assertEqual(all_recs, self.SHARDS_CONTENT)\\n self.assertEmpty(written_index_files)\\n self.assertEmpty(all_indices)\",\n \"def write_tfrecords(tf_examples: List[tf.train.Example], filename: str):\\n with tf.io.TFRecordWriter(filename) as file_writer:\\n for example in tf_examples:\\n file_writer.write(example)\",\n \"def test_write_tfrecord(self):\\n path = os.path.join(self.tmp_dir, 'foo-train.tfrecord')\\n shards_length, total_size = self._write(to_write=self.RECORDS_TO_WRITE)\\n self.assertEqual(self.NUM_SHARDS, len(shards_length))\\n self.assertEqual(\\n shards_length, [len(shard) for shard in self.SHARDS_CONTENT]\\n )\\n self.assertEqual(total_size, 10)\\n written_files, all_recs = _read_records(path)\\n written_index_files, all_indices = _read_indices(path)\\n self.assertEqual(\\n written_files,\\n [\\n f'foo-train.tfrecord-{i:05d}-of-{self.NUM_SHARDS:05d}'\\n for i in range(self.NUM_SHARDS)\\n if shards_length[i]\\n ],\\n )\\n self.assertEqual(all_recs, self.SHARDS_CONTENT)\\n self.assertEmpty(written_index_files)\\n self.assertEmpty(all_indices)\",\n \"def write_record(dataset, filename):\\n writer = tf.python_io.TFRecordWriter(filename)\\n print('result dim:')\\n print(dataset['images'].shape)\\n for image, label, meta in zip(dataset['images'], dataset['labels'],\\n dataset['meta']):\\n example = tf.train.Example(\\n features=tf.train.Features(\\n feature={\\n 'height': _int64_feature(image.shape[1]),\\n 'width': _int64_feature(image.shape[2]),\\n 'depth': _int64_feature(2),\\n 'label': _int64_feature(label),\\n 'meta': _int64_list_feature(meta),\\n 'image_raw': _bytes_feature(image.tostring()),\\n }))\\n writer.write(example.SerializeToString())\\n writer.close()\",\n \"def _add_to_tfrecord(filename, tfrecord_writer,labels_to_class_names, offset=0):\\n image = tf.gfile.FastGFile(filename,'r').read()\\n label = labels_to_class_names[filename.split('/')[-2]]\\n\\n with tf.Graph().as_default():\\n with tf.Session('') as sess:\\n example = dataset_utils.image_to_tfexample(\\n image, b'jpg', _IMAGE_SIZE_HEIGHT, _IMAGE_SIZE_WIDTH, label)\\n tfrecord_writer.write(example.SerializeToString())\\n\\n return offset + 1\",\n \"def _write_tfrecords(X_, y_, n_, output_file, target_type='int'):\\n writer = tf.io.TFRecordWriter(output_file)\\n\\n for X, y, n in zip(X_, y_, n_):\\n # print(len(X_), len(y_), X.shape, y.shape)\\n X = X.astype(np.float32)\\n n = n.astype(np.int64)\\n # Feature contains a map of string to feature proto objects\\n example = _make_example(X, y, n, target_type=target_type)\\n # Serialize the example to a string\\n serialized = example.SerializeToString()\\n # write the serialized object to the disk\\n writer.write(serialized)\\n writer.close()\",\n \"def write_tfrecord(data_list, output_dir, batch_size_per_file=100):\\n for data_category in data_list.keys():\\n file_basename = os.path.join(output_dir, data_category)\\n for i, (image_path, label_path) in tqdm.tqdm(\\n enumerate(\\n zip(data_list[data_category]['image_list'],\\n data_list[data_category]['label_list']))):\\n if i % batch_size_per_file == 0:\\n if i != 0:\\n writer.close()\\n filename = file_basename + '_{:04d}.tfrecord'.format(\\n int(i / batch_size_per_file))\\n writer = tf.python_io.TFRecordWriter(filename)\\n logging.info('Start writing {} data to {}'.format(\\n data_category, filename))\\n\\n filename = image_path\\n image = np.array(Image.open(image_path))\\n label = np.array(Image.open(label_path))\\n height = image.shape[0]\\n width = image.shape[1]\\n image_raw = image.tostring()\\n label_raw = label.tostring()\\n example = tf.train.Example(\\n features=tf.train.Features(\\n feature={\\n 'height':\\n tf.train.Feature(\\n int64_list=tf.train.Int64List(value=[height])),\\n 'width':\\n tf.train.Feature(\\n int64_list=tf.train.Int64List(value=[width])),\\n 'image_raw':\\n tf.train.Feature(\\n bytes_list=tf.train.BytesList(value=[image_raw])),\\n 'label_raw':\\n tf.train.Feature(\\n bytes_list=tf.train.BytesList(value=[label_raw])),\\n 'filename':\\n tf.train.Feature(\\n bytes_list=tf.train.BytesList(\\n value=[str.encode(filename)]))\\n }))\\n writer.write(example.SerializeToString())\\n writer.close()\",\n \"def write_data():\",\n \"def write_tfrecord(examples, encode_fn, file_name):\\n def create_feature(example):\\n \\\"\\\"\\\"\\n Creates a feature list from a document.\\n \\\"\\\"\\\"\\n input_ids, label_ids = encode_fn(\\n example['tokens'], example['labels'])\\n\\n features = {\\n 'input_ids': int64_feature(input_ids),\\n 'label_ids': int64_feature(label_ids)\\n }\\n\\n return features\\n\\n with tf.io.TFRecordWriter(file_name) as writer:\\n for example in examples:\\n example = tf.train.Example(\\n features=tf.train.Features(\\n feature=create_feature(example)))\\n\\n writer.write(example.SerializeToString())\\n\\n return file_name, len(examples)\",\n \"def create_tfrecord(self, tfrecord_filename, begin=0, einde=-1):\\n # Call imagesToTfRecord class to build dataset and store in TFRecord\\n T2.writeRecord(tfrecord_filename, TRAIN_DIR, begin=begin, einde=einde)\",\n \"def _add_to_tfrecord(filename, tfrecord_writer, offset=0):\\n with tf.gfile.Open(filename, 'rb') as f:\\n if sys.version_info < (3,):\\n data = cPickle.load(f)\\n else:\\n data = cPickle.load(f, encoding='bytes')\\n\\n images = data[b'data']\\n num_images = images.shape[0]\\n\\n images = images.reshape((num_images, 3, 32, 32))\\n labels = data[b'fine_labels']\\n\\n with tf.Graph().as_default():\\n image_placeholder = tf.placeholder(dtype=tf.uint8)\\n encoded_image = tf.image.encode_png(image_placeholder)\\n\\n with tf.Session('') as sess:\\n\\n for j in range(num_images):\\n sys.stdout.write('\\\\r>> Reading file [%s] image %d/%d' % (\\n filename, offset + j + 1, offset + num_images))\\n sys.stdout.flush()\\n\\n image = np.squeeze(images[j]).transpose((1, 2, 0))\\n label = labels[j]\\n\\n png_string = sess.run(encoded_image,\\n feed_dict={image_placeholder: image})\\n\\n example = dataset_utils.image_to_tfexample(\\n png_string, b'png', _IMAGE_SIZE, _IMAGE_SIZE, label)\\n tfrecord_writer.write(example.SerializeToString())\\n\\n return offset + num_images\",\n \"def write (self, path):\\n\\t\\ts=[]; add=s.append\\n\\t\\tadd ('\\\\t'.join (self.schema))\\n\\t\\tfor record in self.data:\\n\\t\\t\\tadd (record.asTabDelimitedRecord())\\n\\t\\t\\n\\t\\t# f = open (path, 'w')\\n\\t\\tf = codecs.open(path, 'w', 'utf-8')\\n\\t\\tf.write (self.linesep.join (s))\\n\\t\\tf.close()\\n\\t\\tprint (\\\"data written to \\\" + path)\",\n \"def create_tfrecords_file(input_filename, output_filename, example_fn):\\n writer = tf.python_io.TFRecordWriter(output_filename) #A class to write records to a TFRecords file.\\n print(\\\"Creating TFRecords file at {}...\\\".format(output_filename))\\n\\n for i, row in enumerate(create_csv_iter(input_filename)):\\n x = example_fn(row)\\n writer.write(x.SerializeToString())\\n\\n writer.close()\\n print(\\\"Wrote to {}\\\".format(output_filename))\",\n \"def convert_to_tfrecord(data_files, label_files, output_file, num_steps, test_flag):\\n print('Generating %s' % output_file)\\n\\n with tf.python_io.TFRecordWriter(output_file) as record_writer:\\n\\n for idx in enumerate(data_files):\\n\\n print('Working on %s' % data_files[idx[0]])\\n print('Working on %s' % label_files[idx[0]])\\n\\n #data = _read_data(data_files[idx[0]])\\n #label = _read_data(label_files[idx[0]])\\n\\n #data = loadtxt(data_files[idx[0]])\\n label = loadtxt(label_files[idx[0]])\\n feat = [0,1,2,3]\\n feat.extend(range(6,25))\\n if test_flag:\\n with open(data_files[idx[0]]) as infile:\\n data = np.zeros([num_steps, 25])\\n cnt = 0\\n for line in infile:\\n line = line.split()\\n data[0:num_steps-1, :]=data[1:num_steps, :]\\n data[num_steps-1,:]=line\\n data1 = data\\n data1[:,0] = signal.detrend(data1[:,0], axis=0)\\n write_to_tfrecord(data1[:,feat], label[cnt:cnt+num_steps], num_steps, record_writer)\\n cnt+=1\\n else:\\n with open(data_files[idx[0]]) as infile:\\n data = []\\n cnt = 1\\n for line in infile:\\n data.append(line.split())\\n if cnt%num_steps==0:\\n data = np.array(data, dtype=float)\\n data.reshape(data.shape[0], -1)\\n #data = signal.detrend(data, axis=0)\\n write_to_tfrecord(data[:,feat], label[cnt-num_steps:cnt], num_steps, record_writer)\\n data = []\\n cnt=cnt+1\",\n \"def _add_to_tfrecord(record_dir,num_images,image_h, image_w, split_name):\\n dataset_train = ShapesDataset()\\n dataset_train.load_shapes(num_images, image_h, image_w)\\n\\n num_shards = int(num_images /2500 ) # 2500\\n num_per_shard = int(math.ceil(num_images / float(num_shards)))\\n height, width=image_h, image_w\\n\\n for shard_id in range(num_shards):\\n record_filename = _get_dataset_filename(record_dir, split_name, shard_id, num_shards)\\n options = tf.python_io.TFRecordOptions(TFRecordCompressionType.ZLIB)\\n\\n with tf.python_io.TFRecordWriter(record_filename, options=options) as tfrecord_writer:\\n start_ndx = shard_id * num_per_shard\\n end_ndx = min((shard_id + 1) * num_per_shard, num_images)\\n for i in range(start_ndx, end_ndx):\\n if i % 50 == 0:\\n sys.stdout.write('\\\\r>> Converting image %d/%d shard %d\\\\n' % (\\n i + 1, num_images, shard_id))\\n sys.stdout.flush()\\n\\n img= dataset_train.image_info[i]['image']\\n gt_boxes= dataset_train.image_info[i]['gt_boxes']\\n masks= dataset_train.image_info[i]['mask']\\n mask= dataset_train.image_info[i]['mask_']\\n\\n img_raw = img.tostring()\\n mask_raw = mask.tostring()\\n img_id=i\\n example = _to_tfexample_coco_raw(\\n img_id,\\n img_raw,\\n mask_raw,\\n height, width, gt_boxes.shape[0],\\n gt_boxes.tostring(), masks.tostring())\\n\\n tfrecord_writer.write(example.SerializeToString())\\n sys.stdout.write('\\\\n')\\n sys.stdout.flush()\",\n \"def write_tfr(np_data, rw, rm, out_dir):\\n if isinstance(np_data, dict):\\n np_data = _np_generator(np_data)\\n elif isinstance(np_data, types.GeneratorType):\\n pass\\n elif isinstance(np_data, collections.Iterable):\\n pass\\n else:\\n raise Exception('np_data must be a dict, a generator or iterable.')\\n\\n for data in np_data:\\n feature = {}\\n for key, value in data.items():\\n value_shape = list(value.shape)\\n if type(value) == np.ndarray:\\n if value.dtype == np.float64:\\n value = value.astype(np.float32)\\n if value.dtype == bool or value.dtype == np.int32 or \\\\\\n value.dtype == np.int16:\\n value = value.astype(np.float32)\\n if key not in rm.tensors_shape:\\n rm.tensors_shape[key] = value_shape\\n rm.tensors_shape_max[key] = value_shape\\n rm.tensors_dtype[key] = value.dtype.name\\n rm.tensors_ndim[key] = value.ndim\\n else:\\n rm.tensors_shape[key] = \\\\\\n _update_shape(rm.tensors_shape[key], value_shape)\\n rm.tensors_shape_max[key] = \\\\\\n map(max, zip(rm.tensors_shape_max[key], value_shape))\\n\\n convert_np_to_features(key, value, feature)\\n\\n example = \\\\\\n tf.train.Example(features=tf.train.Features(feature=feature))\\n rw.write(example.SerializeToString())\\n\\n rm.num_examples = rw.num_examples\\n rm.num_records = rw.num_records\\n rm.save(out_dir)\",\n \"def write(self, filename, data, hdr):\\n pass\",\n \"def save_records(self, pad_id):\\n train_records_path = os.path.join(self.config.records_dir, \\\"train.tfrecords\\\")\\n dev_records_path = os.path.join(self.config.records_dir, \\\"dev.tfrecords\\\")\\n test_records_path = os.path.join(self.config.records_dir, \\\"test.tfrecords\\\")\\n statistics_file = os.path.join(self.config.records_dir, \\\"statistics.json\\\")\\n\\n dict = {}\\n dict['train_examples_num'] = len(self.train_set)\\n dict['dev_examples_num'] = len(self.dev_set)\\n dict['test_examples_num'] = len(self.test_set)\\n\\n with open(statistics_file, 'w', encoding='utf8')as p:\\n json.dump(dict, p)\\n\\n self._save_records(train_records_path, self.train_set, pad_id)\\n self._save_records(dev_records_path, self.dev_set, pad_id)\\n self._save_records(test_records_path, self.test_set, pad_id)\\n\\n self.logger.info(\\\"all data have saved to records files.\\\")\",\n \"def dump2record(filename, corpus1, corpus2):\\r\\n\\tassert len(corpus1) == len(corpus2)\\r\\n\\twriter = tf.io.TFRecordWriter(filename)\\r\\n\\r\\n\\tfor sent1, sent2 in tqdm(zip(corpus1, corpus2)):\\r\\n\\t\\tfeatures = {}\\r\\n\\t\\tfeatures['src_sent'] = _byte_features(sent1.encode('utf-8'))\\r\\n\\t\\tfeatures['tgt_sent'] = _byte_features(sent2.encode('utf-8'))\\r\\n\\r\\n\\t\\ttf_features = tf.train.Features(feature=features)\\r\\n\\t\\ttf_examples = tf.train.Example(features=tf_features)\\r\\n\\t\\ttf_serialized = tf_examples.SerializeToString()\\r\\n\\r\\n\\t\\twriter.write(tf_serialized)\\r\\n\\r\\n\\twriter.close()\",\n \"def create_training_record(data_path: str, path_to_gt: str, ratio: float):\\n with open(data_path) as file:\\n data = json.load(file)\\n\\n base = os.path.join(os.path.dirname(data_path), datetime.now().strftime('%Y_%m_%d_%H%M%S'))\\n train_filename = '{}_{}'.format(base, 'train.tfrecords')\\n test_filename = '{}_{}'.format(base, 'test.tfrecords')\\n\\n train_writer = tf.python_io.TFRecordWriter(train_filename)\\n test_writer = tf.python_io.TFRecordWriter(test_filename)\\n\\n gt_reader = GroundTruthReader(path_to_gt)\\n train_set_len = 1\\n test_set_len = 1\\n zeros = 0\\n ones = 0\\n\\n for i, key in enumerate(data):\\n if not i % 1000:\\n print('Data: {}/{}'.format(i, len(data)))\\n sys.stdout.flush()\\n\\n features, labels = compute_feature(key, data[key], gt_reader)\\n\\n for j, feat in enumerate(features):\\n label = labels[j]\\n if test_set_len / train_set_len >= ratio:\\n # balance out training dataset (there are normally more zero- than one-labels)\\n if (label == 0.0 and (zeros - ones <= 0)) or label == 1.0:\\n train_set_len += 1\\n if label == 1.0:\\n ones += 1\\n else:\\n zeros += 1\\n feature = {'train/feature': float_feature(feat),\\n 'train/label': float_feature(labels[j])}\\n example = tf.train.Example(features=tf.train.Features(feature=feature))\\n train_writer.write(example.SerializeToString())\\n else:\\n test_set_len += 1\\n feature = {'test/feature': float_feature(feat),\\n 'test/label': float_feature(labels[j])}\\n example = tf.train.Example(features=tf.train.Features(feature=feature))\\n test_writer.write(example.SerializeToString())\\n train_writer.close()\\n sys.stdout.flush()\",\n \"def write_tf_record(images, bboxes, filename):\\n\\n with tf.io.TFRecordWriter(filename) as writer:\\n\\n for i, (image_path, bbox) in enumerate(zip(images, bboxes)):\\n image = cv2.imread(str(image_path), cv2.IMREAD_UNCHANGED)\\n tf_example = bbox_to_tf_example(image, image_path, bbox)\\n writer.write(tf_example.SerializeToString())\\n print(\\\"Created tf-record file in: \\\\n\\\", filename)\",\n \"def write(data):\",\n \"def save_data_into_tf_records(image_file, image_label, tf_records_writer):\\n try:\\n img = Image.open(image_file)\\n except OSError as e:\\n print(e)\\n print(\\\"Error image \\\" + image_file)\\n return False\\n # Unify resolution to 300 * 300.\\n img = np.array(img.resize((IMAGE_SIZE, IMAGE_SIZE)))\\n # img = np.array(img)\\n\\n # Check if the image is rgb image.\\n if len(img.shape) != 3 or img.shape[2] != 3:\\n print(\\\"Not rgb image \\\" + image_file)\\n return False\\n # Check if the image is useless.\\n same = useless_image_array == img\\n if type(same) == np.ndarray:\\n if (useless_image_array == img).all():\\n print(\\\"Useless image. \\\" + image_file)\\n return False\\n elif type(same) == bool:\\n if same:\\n print(\\\"Useless image. \\\" + image_file)\\n return False\\n\\n img_raw = img.tobytes()\\n example = tf.train.Example(features=tf.train.Features(feature={\\n \\\"label\\\": tf.train.Feature(int64_list=tf.train.Int64List(value=[\\n image_label])),\\n \\\"raw\\\": tf.train.Feature(bytes_list=tf.train.BytesList(value=[\\n img_raw])),\\n \\\"height\\\": tf.train.Feature(int64_list=tf.train.Int64List(value=[\\n img.shape[0]])),\\n \\\"width\\\": tf.train.Feature(int64_list=tf.train.Int64List(\\n value=[img.shape[1]])),\\n \\\"channel\\\": tf.train.Feature(int64_list=tf.train.Int64List(\\n value=[img.shape[2]]))\\n }))\\n tf_records_writer.write(example.SerializeToString())\\n return True\",\n \"def save(self,outPath=None):\\n if (not self.canSave): raise StateError(_(\\\"Insufficient data to write file.\\\"))\\n if not outPath:\\n fileInfo = self.fileInfo\\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\\n out = file(outPath,'wb')\\n #--Tes3 Record\\n self.tes3.setChanged()\\n self.tes3.hedr.setChanged()\\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\\n self.tes3.getSize()\\n self.tes3.dump(out)\\n #--Other Records\\n for record in self.records:\\n record.getSize()\\n record.dump(out)\\n out.close()\",\n \"def save_to_tfrecord(type_dataset, dataset, label_map_dict, labels_by_class_dict):\\n\\n # create empty shards\\n writers = [\\n tf.python_io.TFRecordWriter(os.path.join(FLAGS.output_path, type_dataset) + '-%05d-of-%05d.tfrecord' %\\n (i, FLAGS.num_shards))\\n for i in range(FLAGS.num_shards)\\n ]\\n\\n # add images to empty shards\\n for idx, name_image_ in enumerate(dataset):\\n _, tail = os.path.split(name_image_)\\n data_total = {}\\n name_file_xml_all = os.path.join(FLAGS.data_dir, 'LABELS', tail[0:-3] + 'xml')\\n if os.path.exists(name_file_xml_all):\\n with tf.gfile.GFile(name_file_xml_all, 'rb') as fid:\\n xml_str = fid.read()\\n xml = etree.fromstring(xml_str)\\n data_total = tfrecord_util.recursive_parse_xml_to_dict(xml)['annotation']\\n if 'object' in data_total:\\n for obj in data_total['object']:\\n name_in_obj_ = obj['name'].replace(' ', '')\\n if name_in_obj_ in labels_by_class_dict:\\n labels_by_class_dict[name_in_obj_] += 1\\n if idx % 100 == 0:\\n logging.info('On image %d of %d', idx, int(len(dataset)))\\n if bool(data_total):\\n tf_example = dict_to_tf_example(\\n data_total,\\n label_map_dict)\\n writers[idx % FLAGS.num_shards].write(tf_example.SerializeToString())\\n\\n # close opened shards\\n for writer in writers:\\n writer.close()\",\n \"def write( data ):\",\n \"def write_trainingdata(args: ProcessTrainingArgs) -> None:\\n log.info(\\\"Testing data is fold {} of {}\\\".format(args.testfold,\\n args.folds.K))\\n log.info(\\\"Writing training data to tfrecord in {}-point batches\\\".format(\\n args.batchsize))\\n n_rows = len(args.target_src)\\n worker = _TrainingDataProcessor(args.feature_path, args.image_spec,\\n args.halfwidth)\\n sworker = Serialised(worker)\\n tasks = list(batch_slices(args.batchsize, n_rows))\\n out_it = task_list(tasks, args.target_src, sworker, args.nworkers)\\n fold_it = args.folds.iterator(args.batchsize)\\n tfwrite.training(out_it, n_rows, args.directory, args.testfold, fold_it)\",\n \"def write(self, filename, data):\\n raise NotImplementedError\",\n \"def write_TFRecord(X_LR, X_HR, Y_HR, Y_PD, Ret, nx, nz, ny, interv, yp_flow, subsampling_lr, save_path, n_samples, max_samples_per_tfr):\\n \\n tfrecords_filename_base = save_path + f'Ret{Ret}_{nx}x{nz}x{ny}_dt{int(0.45*100*interv)}_subsampling{subsampling_lr}_yp{yp_flow}_'\\n\\n n_sets = int(np.ceil(np.sum(n_samples) / max_samples_per_tfr))\\n\\n i_samp = 0\\n i_samp_file = 0\\n\\n for n_set in range(n_sets):\\n\\n if (n_set + 1) * max_samples_per_tfr > np.sum(n_samples):\\n\\n samples_per_tfr = np.sum(n_samples) - n_set * max_samples_per_tfr\\n\\n else:\\n\\n samples_per_tfr = max_samples_per_tfr\\n\\n tfrecords_filename = tfrecords_filename_base + f'file_{n_set+1:03d}-of-{n_sets:03d}_samples{samples_per_tfr:03d}.tfrecords'\\n writer = tf.io.TFRecordWriter(tfrecords_filename)\\n\\n for idx in range(samples_per_tfr):\\n\\n wall_lr = X_LR[i_samp]\\n wall_hr = X_HR[i_samp] \\n flow_hr = Y_HR[i_samp]\\n flow_pd = Y_PD[i_samp] \\n n_modes = flow_pd.shape[0]\\n\\n wall_lr_raw1 = np.float32(wall_lr[0]).flatten().tolist()\\n wall_lr_raw2 = np.float32(wall_lr[1]).flatten().tolist()\\n wall_lr_raw3 = np.float32(wall_lr[2]).flatten().tolist()\\n\\n wall_hr_raw1 = np.float32(wall_hr[0]).flatten().tolist()\\n wall_hr_raw2 = np.float32(wall_hr[1]).flatten().tolist()\\n wall_hr_raw3 = np.float32(wall_hr[2]).flatten().tolist()\\n\\n flow_hr_raw1 = np.float32(flow_hr[0]).flatten().tolist()\\n flow_hr_raw2 = np.float32(flow_hr[1]).flatten().tolist()\\n flow_hr_raw3 = np.float32(flow_hr[2]).flatten().tolist()\\n\\n flow_pd_raw = np.float32(flow_pd).flatten().tolist()\\n\\n example = tf.train.Example(\\n features = tf.train.Features(\\n feature={\\n 'i_samp': _int64_feature(i_samp_file),\\n 'n_x': _int64_feature(nx),\\n 'n_y': _int64_feature(ny),\\n 'n_z': _int64_feature(nz),\\n 'n_modes': _int64_feature(n_modes),\\n 'subsampling': _int64_feature(subsampling_lr),\\n 'wall_lr_raw1': _floatarray_feature(wall_lr_raw1),\\n 'wall_lr_raw2': _floatarray_feature(wall_lr_raw2),\\n 'wall_lr_raw3': _floatarray_feature(wall_lr_raw3),\\n 'wall_hr_raw1': _floatarray_feature(wall_hr_raw1),\\n 'wall_hr_raw2': _floatarray_feature(wall_hr_raw2),\\n 'wall_hr_raw3': _floatarray_feature(wall_hr_raw3),\\n 'flow_hr_raw1': _floatarray_feature(flow_hr_raw1),\\n 'flow_hr_raw2': _floatarray_feature(flow_hr_raw2),\\n 'flow_hr_raw3': _floatarray_feature(flow_hr_raw3),\\n 'flow_pd_raw': _floatarray_feature(flow_pd_raw)\\n }\\n )\\n )\\n\\n writer.write(example.SerializeToString())\\n\\n i_samp += 1 \\n i_samp_file += interv\\n\\n writer.close()\\n\\n print(f'Closing file {tfrecords_filename}')\\n\\n return\",\n \"def save_to_file(self, data):\\n\\t\\tif self.data_file.write(data):\\n\\t\\t\\tprint(\\\"Data successfully added to file\\\")\\n\\t\\telse:\\n\\t\\t\\tPrint(\\\"Problem occured during adding to file\\\")\",\n \"def create_tf_record(output_filename,\\n label_map_dict,\\n examples):\\n\\n\\n writer = tf.python_io.TFRecordWriter(output_filename)\\n for idx, example in enumerate(examples):\\n if idx % 100 == 0:\\n logging.warning('On image %d of %d', idx, len(examples))\\n try:\\n tf_example = dict_to_tf_example(label_map_dict[idx])\\n writer.write(tf_example.SerializeToString())\\n except AttributeError:\\n logging.warning('Invalid example: %s, ignoring.', label_map_dict[idx][0])\\n\\n\\n writer.close()\",\n \"def generateGenericTFRecord(addrs,labels,numOutputs):\\n print(\\\"Generating TFRecord containing training and test files for {} outputs...\\\".format(numOutputs))\\n filename = 'generic'+str(numOutputs)+'.tfrecords'\\n writer = tf.python_io.TFRecordWriter(filename)\\n labels = [i-171 for i in labels] #to start from Chinese characters, ignore alphanumeric\\n for i in range(len(addrs)):\\n # Load the image\\n img = Image.open(addrs[i])\\n img = np.array(img)\\n label = labels[i]\\n # Create a feature\\n feature = {'label': convertToTFRecord._int64_feature(label),\\n 'image': convertToTFRecord._bytes_feature(tf.compat.as_bytes(img.tostring()))}\\n # Create an example protocol buffer\\n example = tf.train.Example(features=tf.train.Features(feature=feature))\\n # Serialize to string and write on the file\\n writer.write(example.SerializeToString())\\n writer.close()\",\n \"def save_field(self, field_data, t):\\n t0 = time.time()\\n self.f << field_data\\n t1 = time.time()\\n log.debug(\\\"Saved field at t={} to file '{}' (snapshot #{}; saving took \\\"\\n \\\"{:.3g} seconds).\\\".format(t, self.filename, self.counter, t1 - t0))\\n self.counter += 1\",\n \"def create_tfrecord(out_tfrecord_folder,\\n caption_folder,\\n image_folder,\\n samples_per_shard):\\n\\n # create the outpout directory if it does not already exist\\n tf.io.gfile.makedirs(out_tfrecord_folder)\\n\\n # obtain all caption feature files\\n all_caption_f = sorted(\\n tf.io.gfile.glob(os.path.join(caption_folder, \\\"*.txt.pkl\\\")))\\n\\n # obtain all image feature files\\n all_image_f = sorted(\\n tf.io.gfile.glob(os.path.join(image_folder, \\\"*.jpg.pkl\\\")))\\n\\n # create the initial file writer\\n shard = 0\\n num_samples_so_far = 0\\n writer = tf.io.TFRecordWriter(os.path.join(\\n out_tfrecord_folder, \\\"{:013d}.tfrecord\\\".format(shard)))\\n\\n # loop through every image which can have several captions\\n # save features to the disk in tfrecord format\\n # TODO: this should be made parallel\\n for caption_f, image_f in zip(all_caption_f, all_image_f):\\n with tf.io.gfile.GFile(caption_f, \\\"rb\\\") as f:\\n samples = pkl.loads(f.read())\\n\\n # loop through every training example\\n for sample in samples:\\n\\n # occasionally flush all out streams to the disk\\n if num_samples_so_far >= samples_per_shard:\\n sys.stdout.flush()\\n writer.close()\\n\\n # make a new writer when samples_per_shard is reached\\n shard += 1\\n num_samples_so_far = 0\\n writer = tf.io.TFRecordWriter(os.path.join(\\n out_tfrecord_folder, \\\"{:013d}.tfrecord\\\".format(shard)))\\n\\n # serialize a single sequence example to the disk\\n sequence_sample = create_sequence_example(image_f, sample)\\n writer.write(sequence_sample.SerializeToString())\\n num_samples_so_far += 1\\n\\n # done processing so flush any remaining data\\n sys.stdout.flush()\\n writer.close()\",\n \"def write_record(self, *items):\\n items = tuple(np.asarray(item) for item in items)\\n total_size = sum(item.nbytes for item in items)\\n\\n nb = np.array([total_size], dtype=self._header_dtype)\\n\\n nb.tofile(self._fp)\\n for item in items:\\n item.tofile(self._fp)\\n nb.tofile(self._fp)\",\n \"def create_tffile(self, path, fl_list, outpath):\\n with tf.python_io.TFRecordWriter(outpath) as wr:\\n for vl in fl_list:\\n exam = self.create_tfrec(path, vl[0], vl[1])\\n wr.write(exam.SerializeToString())\",\n \"def save_record(self, data, rownum=None):\\n\\n if rownum is not None:\\n # This is an update\\n records = self.get_all_records()\\n records[rownum] = data\\n with open(self.filename, 'w', encoding='utf-8') as fh:\\n csvwriter = csv.DictWriter(fh, fieldnames=self.fields.keys())\\n csvwriter.writeheader()\\n csvwriter.writerows(records)\\n else:\\n # This is a new record\\n newfile = not os.path.exists(self.filename)\\n\\n with open(self.filename, 'a', encoding='utf-8') as fh:\\n csvwriter = csv.DictWriter(fh, fieldnames=self.fields.keys())\\n if newfile:\\n csvwriter.writeheader()\\n csvwriter.writerow(data)\",\n \"def test_write(self):\\n path = os.path.join(self.tmp_dir, 'foo.tfrecord')\\n writer = tfrecords_writer.Writer('some spec', path)\\n to_write = [\\n (1, b'a'), (2, b'b'),\\n (3, b'c'),\\n (4, b'd'), (5, b'e'),\\n (6, b'f'),\\n (7, b'g'), (8, b'h'),\\n ]\\n for key, record in to_write:\\n writer.write(key, record)\\n with absltest.mock.patch.object(tfrecords_writer, '_get_number_shards',\\n return_value=5):\\n shards_length = writer.finalize()\\n self.assertEqual(shards_length, [2, 1, 2, 1, 2])\\n written_files, all_recs = _read_records(self.tmp_dir)\\n self.assertEqual(written_files,\\n ['foo.tfrecord-0000%s-of-00005' % i for i in range(5)])\\n self.assertEqual(all_recs, [\\n [b'f', b'e'], [b'b'], [b'a', b'g'], [b'h'], [b'c', b'd'],\\n ])\",\n \"def _write_shard(filename, dataset, indices):\\n with tf.python_io.TFRecordWriter(filename) as writer:\\n for j in indices:\\n writer.write(dataset[j])\",\n \"def create_tf_record(\\n output_filename,\\n label_map_dict,\\n dataset,\\n examples):\\n writer = tf.python_io.TFRecordWriter(output_filename)\\n for idx, example in enumerate(examples):\\n if idx % 100 == 0:\\n logging.info('On image %d of %d', idx, len(examples))\\n path = os.path.join(\\\"data\\\", dataset, 'annotations', example + '.xml')\\n\\n if not os.path.exists(path):\\n logging.warning('Could not find %s, ignoring example.', path)\\n continue\\n with tf.gfile.GFile(path, 'r') as fid:\\n xml_str = fid.read()\\n xml = etree.fromstring(xml_str.encode('utf-8'))\\n data = dataset_util.recursive_parse_xml_to_dict(xml)['annotation']\\n data['filename'] = \\\"{}.jpg\\\".format(example)\\n\\n tf_example = dict_to_tf_example(data, label_map_dict, os.path.join(\\\"data\\\", dataset, \\\"images\\\"))\\n writer.write(tf_example.SerializeToString())\\n\\n writer.close()\",\n \"def _write_shard(filename, dataset, indices):\\n with tf.io.TFRecordWriter(filename) as writer:\\n for j in indices:\\n writer.write(dataset[j])\",\n \"def data_to_tfrecord(images, labels, filename):\\n if os.path.isfile(filename):\\n print(\\\"%s exists\\\" % filename)\\n return\\n print(\\\"Converting data into %s ...\\\" % filename)\\n # cwd = os.getcwd()\\n writer = tf.python_io.TFRecordWriter(filename)\\n for index, img in enumerate(images):\\n img_raw = img.tobytes()\\n # Visualize a image\\n # tl.visualize.frame(np.asarray(img, dtype=np.uint8), second=1, saveable=False, name='frame', fig_idx=1236)\\n label = int(labels[index])\\n example = tf.train.Example(\\n features=tf.train.Features(\\n feature={\\n \\\"label\\\": tf.train.Feature(int64_list=tf.train.Int64List(value=[label])),\\n 'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),\\n }\\n )\\n )\\n writer.write(example.SerializeToString()) # Serialize To String\\n writer.close()\",\n \"def to_tfrecord(data_blob):\\n\\n id = np.array(data_blob['id'], dtype=np.int32).tobytes()\\n dim = np.array(data_blob['images'].shape, dtype=np.int32).tobytes()\\n\\n images = np.array(data_blob['images'], dtype=np.uint8).tobytes()\\n poses = np.array(data_blob['poses'], dtype=np.float32).tobytes()\\n depth = np.array(data_blob['depth'], dtype=np.float32).tobytes()\\n filled = np.array(data_blob['filled'], dtype=np.float32).tobytes()\\n intrinsics = np.array(data_blob['intrinsics'], dtype=np.float32).tobytes()\\n\\n\\n example = tf.train.Example(features=tf.train.Features(feature={\\n 'id': tf.train.Feature(bytes_list=tf.train.BytesList(value=[id])),\\n 'dim': tf.train.Feature(bytes_list=tf.train.BytesList(value=[dim])),\\n 'images': tf.train.Feature(bytes_list=tf.train.BytesList(value=[images])),\\n 'poses': tf.train.Feature(bytes_list=tf.train.BytesList(value=[poses])),\\n 'depth': tf.train.Feature(bytes_list=tf.train.BytesList(value=[depth])),\\n 'filled': tf.train.Feature(bytes_list=tf.train.BytesList(value=[filled])),\\n 'intrinsics': tf.train.Feature(bytes_list=tf.train.BytesList(value=[intrinsics])),\\n }))\\n\\n return example\",\n \"def write_record(file_path, records, objector):\\n request = service_pb2.WriteLocalSeqFileRequest()\\n request.file_path = file_path\\n for record in records:\\n request.key.append(\\\"\\\")\\n request.value.append(objector.serialize(record))\\n\\n response = _service.request(request, \\\"write_local_seqfile\\\")\\n\\n import google.protobuf.json_format as json_format\\n res = json_format.Parse(response, service_pb2.VoidResponse())\\n\\n return None, res.status\",\n \"def convert_dataset_to_tfrecord(data_set, save_dir, name):\\n images = data_set.images\\n labels = data_set.labels\\n num_samples = data_set.num_examples\\n\\n rows = images.shape[1]\\n cols = images.shape[2]\\n depth = images.shape[3]\\n\\n filename = os.path.join(save_dir, name + '.tfrecords')\\n with tf.python_io.TFRecordWriter(filename) as writer:\\n for index in range(num_samples):\\n image_raw = images[index].tostring()\\n example = tf.train.Example(\\n features=tf.train.Features(\\n feature={\\n 'height': _int64_feature(rows),\\n 'width': _int64_feature(cols),\\n 'depth': _int64_feature(depth),\\n 'label': _int64_feature(int(labels[index])),\\n 'image': _bytes_feature(image_raw)\\n }))\\n writer.write(example.SerializeToString())\",\n \"def open(self):\\n opt = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.GZIP)\\n self.valid = tf.python_io.TFRecordWriter(self.valid_filename, opt)\\n self.test = tf.python_io.TFRecordWriter(self.test_filename, opt)\\n self.train = [tf.python_io.TFRecordWriter(filename, opt) for filename in\\n self.train_filenames]\",\n \"def make_tfrecord(img_dir, outf_nm='my_dataset'):\\n img_file_list = glob(img_dir)\\n outf_nm += '.tfrecord'\\n tfrecord_wrt = tf.python_io.TFRecordWriter(outf_nm)\\n for img_file in tqdm(img_file_list):\\n # read image into np.array\\n img = cv2.cvtColor(cv2.imread(img_file), cv2.COLOR_BGR2RGB)\\n # compute shrink ratio\\n shrink_ratio = TGT_SHAPE/max(img.shape)\\n # shrink image to reduce size in resultant tf record file\\n img = cv2.resize(img, (0, 0), fx=shrink_ratio, fy=shrink_ratio)\\n # pass to function to serialize to tf example\\n exmp = make_img_example(img)\\n exmp_serial = exmp.SerializeToString()\\n tfrecord_wrt.write(exmp_serial)\",\n \"def record(self, content):\\n datafile = open(self.filename, 'at')\\n datafile.write('%s\\\\n' % content)\\n datafile.close()\",\n \"def to_file(self, file_path, smirnoff_data):\\n pass\",\n \"def _write_txt(\\n output_path, records\\n):\\n output_path.write_text(_records_to_string(records))\",\n \"def write(cls, file, data):\\n file.write(data)\",\n \"def make_tfrecords_from_arrs(data_records,save_path,dtypes=[np.float32,np.float32]):\\n assert len(dtypes)==len(data_records),\\\"length of dtypes should be same length of data_records\\\"\\n writer=tf.python_io.TFRecordWriter(save_path)\\n first = True\\n for k in data_records:\\n if first:\\n arr_size = len(data_records[k])\\n first = False\\n else:\\n assert len(data_records[k]) == arr_size, 'not all components in data_records is of same size'\\n names = []\\n arr_grps = []\\n count = 0\\n for name, arr_grp in data_records.items():\\n if type(arr_grp)==np.ndarray:\\n arr_grp = arr_grp.astype(dtypes[count])\\n names.append(name)\\n arr_grps.append(arr_grp)\\n count += 1\\n for record in zip(*arr_grps):\\n feature = {}\\n for name, arr in zip(names, record):\\n if type(arr)==np.ndarray or type(arr)==np.uint8:\\n arr_str = arr.tostring()\\n feature[name] = MakeTFRecords_tfdata._bytes_feature(arr_str)\\n elif type(arr)==str:\\n arr = np.asarray(arr).tostring()\\n feature[name] = MakeTFRecords_tfdata._bytes_feature(arr)\\n\\n example = tf.train.Example(features=tf.train.Features(feature=feature))\\n writer.write(example.SerializeToString())\\n writer.close()\",\n \"def test_tfrecord_to_mindrecord():\\n if not tf or tf.__version__ < SupportedTensorFlowVersion:\\n # skip the test\\n logger.warning(\\\"Module tensorflow is not found or version wrong, \\\\\\n please use pip install it / reinstall version >= {}.\\\".format(SupportedTensorFlowVersion))\\n return\\n\\n file_name_ = os.environ.get('PYTEST_CURRENT_TEST').split(':')[-1].split(' ')[0]\\n mindrecord_file_name = file_name_ + '.mindrecord'\\n tfrecord_file_name = file_name_ + '.tfrecord'\\n generate_tfrecord(tfrecord_file_name)\\n\\n assert os.path.exists(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\\n\\n feature_dict = {\\\"file_name\\\": tf.io.FixedLenFeature([], tf.string),\\n \\\"image_bytes\\\": tf.io.FixedLenFeature([], tf.string),\\n \\\"int64_scalar\\\": tf.io.FixedLenFeature([], tf.int64),\\n \\\"float_scalar\\\": tf.io.FixedLenFeature([], tf.float32),\\n \\\"int64_list\\\": tf.io.FixedLenFeature([6], tf.int64),\\n \\\"float_list\\\": tf.io.FixedLenFeature([7], tf.float32),\\n }\\n\\n if os.path.exists(mindrecord_file_name):\\n os.remove(mindrecord_file_name)\\n if os.path.exists(mindrecord_file_name + \\\".db\\\"):\\n os.remove(mindrecord_file_name + \\\".db\\\")\\n\\n tfrecord_transformer = TFRecordToMR(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name),\\n mindrecord_file_name, feature_dict, [\\\"image_bytes\\\"])\\n tfrecord_transformer.transform()\\n\\n assert os.path.exists(mindrecord_file_name)\\n assert os.path.exists(mindrecord_file_name + \\\".db\\\")\\n\\n fr_mindrecord = FileReader(mindrecord_file_name)\\n verify_data(tfrecord_transformer, fr_mindrecord)\\n\\n os.remove(mindrecord_file_name)\\n os.remove(mindrecord_file_name + \\\".db\\\")\\n\\n os.remove(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\",\n \"def save(datastream):\",\n \"def to_file(self, records):\\n self._file_manager.make_dir_when_no_dir(self._directory)\\n file = os.path.join(self._directory, self._file_name + '.txt')\\n record_lines = [rec.to_string() + \\\"\\\\n\\\" for rec in records]\\n self._file_manager.write_lines(file, record_lines)\",\n \"def write_record(self, record=None):\\n contents = dict()\\n for key, value in record.items():\\n if value is None:\\n continue\\n elif key not in self.input_types:\\n continue\\n else:\\n input_type = self.input_types[key]\\n if input_type == 'float':\\n # Handle np.float() types gracefully\\n contents[key] = float(value)\\n elif input_type == 'str':\\n contents[key] = value\\n elif input_type == 'int':\\n contents[key] = int(value)\\n elif input_type == 'boolean':\\n contents[key] = bool(value)\\n elif input_type == 'nparray':\\n contents[key] = value.tolist()\\n elif input_type == 'list' or input_type == 'vector':\\n contents[key] = list(value)\\n elif input_type == 'image_array':\\n # Handle image array\\n image = Image.fromarray(np.uint8(value))\\n name = Tub._image_file_name(self.manifest.current_index, key)\\n image_path = os.path.join(self.images_base_path, name)\\n image.save(image_path)\\n contents[key] = name\\n elif input_type == 'gray16_array':\\n # save np.uint16 as a 16bit png\\n image = Image.fromarray(np.uint16(value))\\n name = Tub._image_file_name(self.manifest.current_index, key, ext='.png')\\n image_path = os.path.join(self.images_base_path, name)\\n image.save(image_path)\\n contents[key]=name\\n\\n # Private properties\\n contents['_timestamp_ms'] = int(round(time.time() * 1000))\\n contents['_index'] = self.manifest.current_index\\n contents['_session_id'] = self.manifest.session_id\\n\\n self.manifest.write_record(contents)\",\n \"def save(self, data):\\n self.write(data)\",\n \"def saveFile(self, data, filelocation):\\n with open(filelocation, 'w+') as f:\\n f.write(data)\",\n \"def writeto(self, fileout):\\n \\n dump_pkl(self.data, fileout)\",\n \"def convert_to(data_dir, dataset, labels, name):\\n images = dataset\\n labels = labels\\n num_examples = dataset.shape[0]\\n \\n rows, cols, depth = dataset[0].shape\\n \\n filename = os.path.join(data_dir, name + '.tfrecords')\\n \\n writer = tf.python_io.TFRecordWriter(filename)\\n \\n for idx in range(num_examples):\\n image_raw = images[idx].tostring()\\n example = tf.train.Example(features=tf.train.Features(feature={\\n 'height': _int64_feature(rows),\\n 'width': _int64_feature(cols),\\n 'depth': _int64_feature(depth),\\n 'label': _int64_feature(int(labels[idx])),\\n 'image_raw': _bytes_feature(image_raw)\\n }))\\n writer.write(example.SerializeToString())\\n writer.close()\",\n \"def create_tf_record(output_filename,\\n label_map_dict,\\n annotations_dir,\\n annotation_file,\\n image_dir,\\n examples):\\n with tf.gfile.GFile(os.path.join(annotations_dir, annotation_file)) as fid:\\n lines = fid.readlines()\\n\\n writer = tf.python_io.TFRecordWriter(output_filename)\\n\\n for idx, example in enumerate(examples):\\n if idx % 100 == 0:\\n logging.info('On image %d of %d', idx, len(examples))\\n print ' On image {0} of {1}'.format(idx, len(examples))\\n\\n pos = 0\\n while pos < len(lines):\\n line = lines[pos]\\n line = line.strip().split()\\n\\n if len(line) != 0:\\n if line[0] == example:\\n break\\n pos += 1\\n\\n if pos >= len(lines):\\n logging.info('filename not found in '+annotation_file)\\n\\n tf_example = dict_to_tf_example(lines[pos], label_map_dict, image_dir)\\n writer.write(tf_example.SerializeToString())\\n \\n writer.close()\",\n \"def data_to_file(data, ta_file):\\n file_handle = file(ta_file, \\\"w\\\")\\n file_handle.write(data_to_string(data))\\n file_handle.close()\",\n \"def _convert_dataset(data, tfrecord_path, dataset):\\n output_filename = os.path.join(tfrecord_path, dataset+\\\".tfrecord\\\") # /home/wangdong/桌面/工程项目目录Spyter-tensorblow/研究生竞赛 /一带一路竞赛/初赛赛题/tfrecord/train.tfrecord\\n tfrecord_writer = tf.python_io.TFRecordWriter(output_filename) # 创建一个writer来写TFRecords文件\\n length = len(data) # 三维数组的长度 84078\\n for index, item in enumerate(data):\\n data_ = item[0].tobytes()\\n visit = item[1].tobytes()\\n label = item[2] # 对应功能分类的标签\\n example = image_to_tfexample(data_, visit, label)\\n tfrecord_writer.write(example.SerializeToString()) # 将样列序列化为字符串后， 写入out_filename文件中\\n sys.stdout.write('\\\\r>> Converting image %d/%d' % (index + 1, length))\\n sys.stdout.flush()\\n sys.stdout.write('\\\\n')\\n sys.stdout.flush()\",\n \"def write_record(\\n record,\\n target,\\n file_format=\\\"genbank\\\",\\n remove_locationless_features=True,\\n max_name_length=20,\\n):\\n record = deepcopy(record)\\n if remove_locationless_features:\\n record.features = [f for f in record.features if f.location is not None]\\n record.name = record.name[:max_name_length]\\n if has_dna_alphabet:\\n if str(record.seq.alphabet.__class__.__name__) != \\\"DNAAlphabet\\\":\\n record.seq.alphabet = DNAAlphabet()\\n if hasattr(target, \\\"open\\\"):\\n target = target.open(\\\"w\\\")\\n SeqIO.write(record, target, file_format)\",\n \"def write(self, fname):\\n pass\",\n \"def write_record(rec):\\n points = str(rec['Points']).replace(\\\"(\\\",\\\"[\\\").replace(\\\")\\\",\\\"]\\\")\\n l = [ rec['UniqueID'], rec['FAO_USDA'], rec['Soil'], rec['Suborder'],\\n rec['maxlat'], rec['maxlon'], rec['minlat'], rec['minlon'], points ]\\n strings = map(str, l)\\n return \\\"\\\\t\\\".join(strings) + \\\"\\\\n\\\"\",\n \"def write(fname, data):\\n # Encode to string.\\n encoder = NumpyJSONEncoder(check_circular=True, indent=' ')\\n serial = encoder.encode(data)\\n\\n # Write to file.\\n with open(fname, 'w') as fo:\\n fo.write(serial)\",\n \"def convert_to_tf_record(_):\\n\\n mnist = input_data.read_data_sets(\\n \\\"/tmp/tensorflow/mnist/input_data\\\",\\n reshape=False\\n )\\n\\n convert_to(mnist.validation, 'validation', FLAGS.data_directory)\\n convert_to(mnist.train, 'train', FLAGS.data_directory, num_shards=10)\\n convert_to(mnist.test, 'test', FLAGS.data_directory)\",\n \"def record(self):\\n # TODO: record the data\",\n \"def _convert_dataset_test(data, tfrecord_path, dataset):\\n output_filename = os.path.join(tfrecord_path, dataset+\\\".tfrecord\\\") # /home/wangdong/桌面/工程项目目录Spyter-tensorblow/研究生竞赛 /一带一路竞赛/初赛赛题/tfrecord/train.tfrecord\\n tfrecord_writer = tf.python_io.TFRecordWriter(output_filename) # 创建一个writer来写TFRecords文件\\n length = len(data) # 三维数组的长度 84078\\n for index, item in enumerate(data):\\n data_ = item[0].tobytes()\\n visit = item[1].tobytes()\\n areaID = item[2] # 对应地区的名字\\n example = image_to_tfexample(data_, visit, areaID)\\n tfrecord_writer.write(example.SerializeToString()) # 将样列序列化为字符串后， 写入out_filename文件中\\n sys.stdout.write('\\\\r>> Converting image %d/%d' % (index + 1, length))\\n sys.stdout.flush()\\n sys.stdout.write('\\\\n')\\n sys.stdout.flush()\",\n \"def save(self,outPath=None):\\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\\\"Insufficient data to write file.\\\"))\\n if not outPath:\\n fileInfo = self.fileInfo\\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\\n out = file(outPath,'wb')\\n #--Tes3 Record\\n self.tes3.changed = 1\\n self.tes3.hedr.changed = 1\\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\\n self.tes3.getSize()\\n self.tes3.dump(out)\\n #--Size Cell Records\\n cntRecords = 0\\n progress = self.progress\\n progress.setMax(len(self.cells))\\n progress(0.0,'Saving '+self.fileInfo.name)\\n for record in self.cells:\\n record.getSize()\\n #--Progress\\n cntRecords += 1\\n progress(cntRecords)\\n #--Other Records\\n for record in self.records:\\n record.getSize() #--Should already be done, but just in case.\\n record.dump(out)\\n out.close()\",\n \"def save_and_upload_samples(data, namespace, workspace, tsca_id):\\n os.system('mkdir -p %s'%tsca_id)\\n filename = '%s/fc_upload_samples_tsca_%s.txt' % (tsca_id, tsca_id)\\n data.to_csv(filename, sep='\\\\t', index=False)\\n res = upload_entities_from_tsv(namespace, workspace, filename)\\n return res\",\n \"def write_checkpoint(self):\\n self.file_checkpoint_data = open(self.path_checkpoint, \\\"a+\\\")\\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\\n self.file_checkpoint_data.write(','.join(array_to_write) + \\\"\\\\n\\\")\\n self.file_checkpoint_data.flush()\",\n \"def write(init_time, end_time, vpk, media, rms):\\n global data_file\\n\\n # atualiza o arquivo de dados\\n update()\\n\\n # Salva os dados no arquivo\\n data_file.write(\\n str(init_time) + ',' + str(end_time) + ',' +\\n str(vpk) + ',' + str(media) + ',' + str(rms) + '\\\\n'\\n )\",\n \"def Writedata(self, tstep):\\n \\n nc = Dataset(self.outfile, 'a')\\n \\n nc.variables['time'][tstep] = self.time\\n nc.variables['salt'][tstep] = self.salt\\n nc.variables['temp'][tstep] = self.temp\\n nc.variables['uc'][tstep] = self.uc\\n nc.variables['vc'][tstep] = self.vc\\n nc.variables['nu_v'][tstep] = self.nu_v\\n nc.variables['rho'][tstep] = self.rho\\n nc.variables['tau_x'][tstep] = self.tau_x\\n nc.variables['tau_y'][tstep] = self.tau_y\\n nc.variables['eta'][tstep] = self.eta\\n \\n nc.close()\",\n \"def _write_goft(parameters):\\n # Format\\n fmt = block_to_format[\\\"GOFT\\\"]\\n fmt = str2format(fmt[5])\\n\\n values = [x for x in parameters[\\\"generator_history\\\"]]\\n out = write_record(values, fmt, multi=True)\\n\\n return out\",\n \"def write_scat(fname, data):\\n from esutil.recfile import Recfile\\n if os.path.exists(fname):\\n os.remove(fname)\\n with Recfile(fname,'w',delim=' ') as robj:\\n robj.write(data)\",\n \"def save(self, output, data):\",\n \"def to_file(self, fname, delimiter=\\\"\\\\t\\\", encoding=\\\"utf-8\\\"):\\n with open(fname, \\\"wb\\\") as fh:\\n for key, score in self.ranked_items():\\n fh.write(self.to_record(key, score, delimiter).encode(encoding))\",\n \"def write_data(tech_id, tech_name, sentence, source, date_crawled):\\n with open('PDF_data.txt', 'a') as f:\\n # text = match[\\\"tid\\\"] + '\\\\n' + match[\\\"name\\\"] + '\\\\n' + sent + '\\\\n' + source + '\\\\n' + date_crawled + '\\\\n\\\\n'\\n text = tech_id + '\\\\n' + tech_name + '\\\\n' + sentence + '\\\\n' + source + '\\\\n' + date_crawled + '\\\\n\\\\n'\\n f.write(text)\",\n \"def create_tfrec(self, path, imgfile, txtfile):\\n ifname = os.path.join(path, imgfile)\\n tfname = os.path.join(path, txtfile)\\n\\n # Size\\n with Image.open(ifname) as img:\\n width, height = img.size\\n\\n with tf.gfile.GFile(ifname, 'rb') as eimg:\\n enc_img = eimg.read()\\n hashed = hashlib.sha256(enc_img).hexdigest().encode('utf8')\\n\\n # Class and BBox\\n with open(tfname, 'r') as fp:\\n aline = fp.read()\\n aline_splt = aline.split()\\n imclazztxt = self.clazzes[int(aline_splt[0])].encode('utf8')\\n imclazzint = int(aline_splt[0])\\n cx, cy = float(aline_splt[1]), float(aline_splt[2])\\n wx, wy = float(aline_splt[3]), float(aline_splt[4])\\n xtl = (cx - wx/2.0)\\n ytl = (cy - wy / 2.0)\\n xbr = (cx + wx / 2.0)\\n ybr = (cy + wy / 2.0)\\n\\n fname, ext = os.path.splitext(imgfile)\\n imtype = 'jpeg' if (ext == 'jpg') else 'png'\\n\\n # Create TF Record\\n trec = tf.train.Example(features=tf.train.Features(feature={\\n 'image/height': self.add_int_feature(height),\\n 'image/width': self.add_int_feature(width),\\n 'image/filename': self.add_bytes_feature(imgfile.encode('utf8')),\\n 'image/source_id': self.add_bytes_feature(imgfile.encode('utf8')),\\n 'image/key/sha256': self.add_bytes_feature(hashed),\\n 'image/encoded': self.add_bytes_feature(enc_img),\\n 'image/format': self.add_bytes_feature(imtype.encode('utf8')),\\n 'image/object/bbox/xmin': self.add_float_feature(xtl),\\n 'image/object/bbox/xmax': self.add_float_feature(xbr),\\n 'image/object/bbox/ymin': self.add_float_feature(ytl),\\n 'image/object/bbox/ymax': self.add_float_feature(ybr),\\n 'image/object/class/text': self.add_bytes_feature(imclazztxt),\\n 'image/object/class/label': self.add_int_feature(imclazzint)\\n }))\\n return trec\",\n \"def to_tfrecords(root_path, video_name, video_idx, list_imgpaths, list_keypoints, list_masks):\\n make_dir(root_path + 'tfrecords/')\\n out_path = os.path.join(root_path + 'tfrecords/' + video_name + \\\".tfrecords\\\")\\n if not list_masks:\\n list_masks = []\\n mask = np.array([0])\\n for i in range(len(list_imgpaths)):\\n list_masks.append(mask)\\n if not list_keypoints:\\n list_keypoints = []\\n kp = np.array([0])\\n for i in range(len(list_imgpaths)):\\n list_keypoints.append(kp)\\n print(\\\"Converting: \\\" + video_name)\\n with tf.python_io.TFRecordWriter(out_path) as writer:\\n # Iterate over all the image-paths and class-labels.\\n for i, (img_path, keypoints, mask) in enumerate(zip(list_imgpaths, list_keypoints, list_masks)):\\n with open(img_path, 'rb') as f:\\n img_raw = f.read()\\n\\n # Convert the image to raw bytes.\\n # img_bytes = img_raw.tostring()\\n # Create a dict with the data we want to save in the\\n # TFRecords file. You can add more relevant data here.\\n data = {'image': wrap_bytes(img_raw), # todo add frame number\\n 'video': wrap_int64(video_idx),\\n 'keypoints': wrap_float32(keypoints),\\n # 'bbox_max': wrap_int64(max_bbox),\\n 'masks': wrap_float32(mask), }\\n\\n # Wrap the data as TensorFlow Features.\\n feature = tf.train.Features(feature=data)\\n\\n # Wrap again as a TensorFlow Example.\\n example = tf.train.Example(features=feature)\\n\\n # Serialize the data.\\n serialized = example.SerializeToString()\\n\\n # Write the serialized data to the TFRecords file.\\n writer.write(serialized)\",\n \"def save_data(self, record):\\n self.dbm.addRecord(record)\",\n \"def save(self, data, file_id=None, metadata={}):\\n pass\",\n \"def write_to(self, filename):\\n with open(filename, 'w') as f:\\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\\n f.write(\\\"%s %s %s %s\\\\n\\\" % (xx, yy, zz, ww))\\n logger.info(\\\"Written data into file {0}\\\".format(filename))\",\n \"def record_trace(self):\\n\\n tfname = str(int(time.time())) + \\\".obd2_reader.trace\\\"\\n self.tf_out = open(tfname, 'a')\\n self.RecordTrace = 1\\n print \\\"Recoding trace to:\\\", tfname\",\n \"def cli(db_fp, out_fp=None):\\n if out_fp is None:\\n out_fp = db_fp + '.content'\\n LOGGER.info(\\\"Writing from DB `%s` to `%s`.\\\", db_fp, out_fp)\\n records = natsorted(glob(db_fp + '_p*.tfrecords'))\\n if not path.exists(out_fp):\\n os.mkdir(out_fp)\\n nsamples, colnames, coltypes = cdbt.scan_tfdb(records)\\n fillwidth = int(np.ceil(np.log10(nsamples)))\\n run_idx = 0\\n pbar = tqdm.tqdm(total=nsamples)\\n for rec_fp in records:\\n record_iterator = tf.python_io.tf_record_iterator(path=rec_fp)\\n for string_record in record_iterator:\\n example = tf.train.Example()\\n example.ParseFromString(string_record)\\n values = cdbt.decode_tf(example, colnames, coltypes, as_list=True)\\n for colt, coln, val in zip(coltypes, colnames, values):\\n if colt == 'text':\\n with open(path.join(out_fp,\\n '{0:0{width}}_{1}.txt'.format(\\n run_idx, coln, width=fillwidth)\\n .encode(\\\"ascii\\\")),\\n 'w') as outf:\\n outf.write(val)\\n elif colt == 'plain':\\n np.save(\\n path.join(out_fp, '{0:0{width}}_{1}.npy'.format(\\n run_idx, coln, width=fillwidth)),\\n val)\\n else:\\n sm.imsave(\\n path.join(out_fp, '{0:0{width}}_{1}.png'.format(\\n run_idx, coln, width=fillwidth)),\\n val)\\n run_idx += 1\\n pbar.update(1)\\n pbar.close()\\n LOGGER.info(\\\"Done.\\\")\",\n \"def test_tfrecord_to_mindrecord_with_special_field_name():\\n if not tf or tf.__version__ < SupportedTensorFlowVersion:\\n # skip the test\\n logger.warning(\\\"Module tensorflow is not found or version wrong, \\\\\\n please use pip install it / reinstall version >= {}.\\\".format(SupportedTensorFlowVersion))\\n return\\n\\n file_name_ = os.environ.get('PYTEST_CURRENT_TEST').split(':')[-1].split(' ')[0]\\n mindrecord_file_name = file_name_ + '.mindrecord'\\n tfrecord_file_name = file_name_ + '.tfrecord'\\n generate_tfrecord_with_special_field_name(tfrecord_file_name)\\n assert os.path.exists(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\\n\\n feature_dict = {\\\"image/class/label\\\": tf.io.FixedLenFeature([], tf.int64),\\n \\\"image/encoded\\\": tf.io.FixedLenFeature([], tf.string),\\n }\\n\\n if os.path.exists(mindrecord_file_name):\\n os.remove(mindrecord_file_name)\\n if os.path.exists(mindrecord_file_name + \\\".db\\\"):\\n os.remove(mindrecord_file_name + \\\".db\\\")\\n\\n tfrecord_transformer = TFRecordToMR(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name),\\n mindrecord_file_name, feature_dict, [\\\"image/encoded\\\"])\\n tfrecord_transformer.transform()\\n\\n assert os.path.exists(mindrecord_file_name)\\n assert os.path.exists(mindrecord_file_name + \\\".db\\\")\\n\\n fr_mindrecord = FileReader(mindrecord_file_name)\\n verify_data(tfrecord_transformer, fr_mindrecord)\\n\\n os.remove(mindrecord_file_name)\\n os.remove(mindrecord_file_name + \\\".db\\\")\\n\\n os.remove(os.path.join(TFRECORD_DATA_DIR, tfrecord_file_name))\",\n \"def save_to(self, f: BinaryIO):\\n raise NotImplementedError\",\n \"def write(self, record):\\n # Make Splunk ready payload data and append it to self._buffers list.\\n self._buffer.append({\\n 'index': self._index,\\n 'sourcetype': 'json',\\n 'event': record\\n })\\n\\n # If the records count in self._buffer is more than allowed by\\n # self._buffer_size, send those records to Splunk.\\n if len(self._buffer) >= self._buffer_size:\\n self._flush()\",\n \"def save_file(self, filename):\\n if self.t3data:\\n np.savetxt(filename, self.t3data)\\n else:\\n self.export_to_ascii()\",\n \"def save_data(self, f): \\n if not self.sampling:\\n self.convert_to_array()\\n np.save(f, self.reads)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7325877","0.73068726","0.7304733","0.7111031","0.70561475","0.70471674","0.70471674","0.70045257","0.68853045","0.6885133","0.6868757","0.6831078","0.68181723","0.67123234","0.6695657","0.66853046","0.6652954","0.66398877","0.66188484","0.65502214","0.6538491","0.6496384","0.6446258","0.64383703","0.63910854","0.6373182","0.63562155","0.6351208","0.632414","0.6306575","0.6271133","0.624588","0.6235899","0.6224362","0.6217407","0.62146306","0.6205146","0.61821634","0.6179169","0.61539215","0.61508954","0.61146694","0.61119616","0.6107778","0.6089476","0.6079805","0.60612744","0.6053162","0.6047873","0.60465515","0.6038099","0.60194194","0.6018296","0.6017333","0.6003118","0.5941926","0.59179914","0.59099114","0.58991057","0.5892392","0.5889874","0.58851194","0.5879359","0.58775723","0.5874596","0.5870735","0.5858544","0.58570206","0.58396447","0.5836637","0.5835332","0.58276576","0.5822192","0.58096856","0.5806054","0.57983434","0.5796284","0.5794439","0.57889926","0.57785887","0.5776324","0.5775961","0.57741565","0.57728046","0.5768201","0.5764822","0.57534844","0.5750773","0.5750719","0.5747505","0.5744041","0.57439494","0.574262","0.5742528","0.5732652","0.57296354","0.5725401","0.5705891","0.5702903","0.56922996"],"string":"[\n \"0.7325877\",\n \"0.73068726\",\n \"0.7304733\",\n \"0.7111031\",\n \"0.70561475\",\n \"0.70471674\",\n \"0.70471674\",\n \"0.70045257\",\n \"0.68853045\",\n \"0.6885133\",\n \"0.6868757\",\n \"0.6831078\",\n \"0.68181723\",\n \"0.67123234\",\n \"0.6695657\",\n \"0.66853046\",\n \"0.6652954\",\n \"0.66398877\",\n \"0.66188484\",\n \"0.65502214\",\n \"0.6538491\",\n \"0.6496384\",\n \"0.6446258\",\n \"0.64383703\",\n \"0.63910854\",\n \"0.6373182\",\n \"0.63562155\",\n \"0.6351208\",\n \"0.632414\",\n \"0.6306575\",\n \"0.6271133\",\n \"0.624588\",\n \"0.6235899\",\n \"0.6224362\",\n \"0.6217407\",\n \"0.62146306\",\n \"0.6205146\",\n \"0.61821634\",\n \"0.6179169\",\n \"0.61539215\",\n \"0.61508954\",\n \"0.61146694\",\n \"0.61119616\",\n \"0.6107778\",\n \"0.6089476\",\n \"0.6079805\",\n \"0.60612744\",\n \"0.6053162\",\n \"0.6047873\",\n \"0.60465515\",\n \"0.6038099\",\n \"0.60194194\",\n \"0.6018296\",\n \"0.6017333\",\n \"0.6003118\",\n \"0.5941926\",\n \"0.59179914\",\n \"0.59099114\",\n \"0.58991057\",\n \"0.5892392\",\n \"0.5889874\",\n \"0.58851194\",\n \"0.5879359\",\n \"0.58775723\",\n \"0.5874596\",\n \"0.5870735\",\n \"0.5858544\",\n \"0.58570206\",\n \"0.58396447\",\n \"0.5836637\",\n \"0.5835332\",\n \"0.58276576\",\n \"0.5822192\",\n \"0.58096856\",\n \"0.5806054\",\n \"0.57983434\",\n \"0.5796284\",\n \"0.5794439\",\n \"0.57889926\",\n \"0.57785887\",\n \"0.5776324\",\n \"0.5775961\",\n \"0.57741565\",\n \"0.57728046\",\n \"0.5768201\",\n \"0.5764822\",\n \"0.57534844\",\n \"0.5750773\",\n \"0.5750719\",\n \"0.5747505\",\n \"0.5744041\",\n \"0.57439494\",\n \"0.574262\",\n \"0.5742528\",\n \"0.5732652\",\n \"0.57296354\",\n \"0.5725401\",\n \"0.5705891\",\n \"0.5702903\",\n \"0.56922996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6723572"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":83776,"cells":{"query":{"kind":"string","value":"Calculates the MD5 sum of a file."},"document":{"kind":"string","value":"def md5_sum_file(path):\n with open(path, 'rb') as f:\n m = hashlib.md5()\n while True:\n data = f.read(8192)\n if not data:\n break\n m.update(data)\n return m.hexdigest()"},"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 md5sum(file_name):\n f = open(file_name, mode='rb')\n h = hashlib.md5()\n h.update(f.read())\n return h.hexdigest()","def calculate_md5sum_of_a_file(context, file_name, file_path):\n command = \"md5sum \" + file_path + \"/\" + file_name + \" | awk {'print $1'}\"\n return context.cme_session.send_ssh_command(command=command)","def md5sum_file(filepath):\n hasher = hashlib.md5()\n with open(filepath, 'rb') as infile:\n for chunk in util.chunk_reader(infile):\n hasher.update(chunk)\n return hasher.hexdigest()","def md5sum(filename):\n with open(filename, mode='rb') as f:\n d = hashlib.md5()\n for buf in iter(functools.partial(f.read, 1024*100), b''):\n d.update(buf)\n return d.hexdigest()","def CalcMD5(filepath):\n with open(filepath,'rb') as f:\n md5obj = hashlib.md5()\n md5obj.update(f.read())\n return md5obj.hexdigest()","def md5sum(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def calc_file_md5(file_path):\n hash_md5 = str()\n method = hashlib.md5()\n if not os.path.exists(file_path):\n logger.error(\"File(%s) don not exist, can not calculation file hash\" % file_path)\n return hash_md5\n\n with open(file_path, 'rb') as f:\n for chunk in read_chunks(f, 1024 * 1024):\n method.update(chunk)\n return method.hexdigest()","def calc_md5(infile, block_size=256*128):\n logger = logging.getLogger(__name__)\n logger.info(f'Calculating md5 of {infile}')\n md5 = hashlib.md5()\n with open(infile, 'rb') as f:\n for chunk in iter(lambda: f.read(block_size), b''):\n md5.update(chunk)\n return md5.hexdigest()","def md5sum(fileSrc):\n md5 = hashlib.md5()\n try:\n with open(fileSrc, \"rb\") as fd:\n while True:\n content = fd.read(2**20)\n if not content:\n break\n md5.update(content)\n except IOError:\n print(fileSrc + \" Not found\")\n exit(1)\n return md5.hexdigest()","def generate_sum(file_path):\n #file = open(file_path, 'rb')\n #header = file.read()\n header = open(file_path, 'rb').read()\n suma_md5 = md5(header).hexdigest()\n return suma_md5","def compute_checksum(filename):\n cmd = 'md5sum ' + filename\n return pipe(cmd)","def md5checksum(file_name):\n from hashlib import md5\n hash_md5 = md5()\n with open(file_name, \"rb\") as f:\n for chunk in iter(lambda: f.read(32768), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5_checksum(file_path):\n with open(file_path, 'rb') as fh:\n m = hashlib.md5()\n while True:\n data = fh.read(8192)\n if not data:\n break\n m.update(data)\n return m.hexdigest()","def fsum(fpath):\n import hashlib\n import codecs\n with codecs.open(fpath, \"r\", \"utf-8\") as filep:\n buff = filep.read()\n cksum = hashlib.md5(buff.encode(\"utf-8\"))\n return cksum.hexdigest()","def md5sum(fname):\n\tdef read_chunks(fh):\n\t\tfh.seek(0)\n\t\tchunk = fh.read(8096)\n\t\twhile chunk:\n\t\t\tyield chunk\n\t\t\tchunk = fh.read(8096)\n\t\telse: #最后要将游标放回文件开头\n\t\t\tfh.seek(0)\n\n\tm = hashlib.md5()\n\tif isinstance(fname, str) and os.path.exists(fname):\n\t\tfh = open(fname, \"rb\")\n\t\tfor chunk in read_chunks(fh):\n\t\t\tm.update(chunk)\n\t#上传的文件缓存或已打开的文件流\n\telif fname.__class__.__name__ in [\"StringIO\", \"StringO\"] or isinstance(fname, file):\n\t\tfor chunk in read_chunks(fname):\n\t\t\tm.update(chunk)\n\telse:\n\t\treturn \"\"\n\treturn m.hexdigest()","def md5sum_file(filename: str, hr: bool = True) -> str:\n block_size = 256 * 128\n\n md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(block_size), b\"\"):\n md5.update(chunk)\n if hr:\n return md5.hexdigest()\n return md5.digest()","def checksumFile(filename):\n return md5File(filename)","def file_md5(file_path):\n log.debug(\"Calculating md5 for %s\", file_path)\n start_ms = time.time() * 10**3\n fp = open(file_path, 'rb')\n try:\n # returns tuple (md5_hex, md5_base64, size)\n md5, _, _ = boto.utils.compute_md5(fp)\n finally:\n fp.close()\n duration_ms = (time.time() * 10**3) - start_ms\n log.debug(\"Calculated hash %s for %s in %s ms\", md5, file_path, \n duration_ms)\n return md5","def calculate_md5(filename, block_size=2**20):\n import hashlib\n\n md5 = hashlib.md5()\n try:\n with open(filename, 'rb') as f:\n while True:\n data = f.read(block_size)\n if not data:\n break\n md5.update(data)\n except IOError:\n print('File \\'' + filename + '\\' not found!')\n return None\n except:\n return None\n return md5.hexdigest()","def get_md5sum_file(fullname, blksize=2**15):\n\n md5 = hashlib.md5()\n with open(fullname, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(blksize), b''):\n md5.update(chunk)\n return md5.hexdigest()","def md5_sum(content):\r\n md5_hash = hashlib.md5(content).hexdigest()\r\n return md5_hash","def compute_md5_for_file(file, block_size=2**14):\n f = open(file, 'r')\n md5 = hashlib.md5()\n while True:\n data = f.read(block_size)\n if not data:\n break\n md5.update(data)\n return base64.b64encode(md5.digest())","def md5(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(4096), b''):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(4096), b''):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def calculate(d):\r\n\r\n # Set correct slashes for the OS\r\n if sys.platform == 'windows':\r\n slash = '\\\\'\r\n elif sys.platform == 'linux':\r\n slash = '/'\r\n else:\r\n print('#Error. Unknown platform.')\r\n return\r\n\r\n print('Files in the current directory and their md5-hashes:\\n')\r\n i = 0\r\n assert i == 0, '#Error. Variable i != 0.'\r\n\r\n for i in range(len(d[2])): # Go through the list of files\r\n full_path = d[0]+slash+d[2][i]\r\n print(full_path) # Get the list of files with full paths\r\n print(md5(full_path))\r\n size(full_path)","def CalculateMd5OfEachFile(self, filedic):\n #for eachfiledic in self.fileTobeUploaded:\n fileobj = open(filedic[\"filepath\"], 'rb')\n buf = fileobj.read()\n hash = hashlib.md5()\n hash.update(buf)\n\n digest = hashlib.md5(buf).digest()\n md5enc = base64.b64encode(digest)\n md5tostr = md5enc.decode('utf-8')\n filedic[\"md5\"] = md5tostr\n fileobj.close()\n\n #pprint.pprint(self.fileTobeUploaded)","def GenerateMd5(filename):\n try:\n with open(filename, 'r') as read_file:\n hasher = hashlib.md5()\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\n hasher.update(chunk)\n return hasher.hexdigest()\n except IOError:\n logging.error('Failed to compute md5 checksum for file %s.',\n filename)\n return ''","def md5(file_path):\r\n\r\n hasher = hashlib.md5()\r\n with Profiler():\r\n with open(file_path, 'rb') as f:\r\n while True:\r\n buf = f.read(BLOCKSIZE)\r\n if not buf:\r\n break\r\n while len(buf) > 0:\r\n hasher.update(buf)\r\n buf = f.read(BLOCKSIZE)\r\n md5_hash = (hasher.hexdigest()).upper()\r\n return md5_hash","def md5(filename):\n # see https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file # noqa: E501\n hash_md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(1048576), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5(fname):\n hash = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash.update(chunk)\n return hash.hexdigest()","def md5(filename: str) -> str:\n # using md5 for speed\n _hash = hashlib.md5()\n # open file for reading in binary mode\n with open(filename,'rb') as file:\n for block in iter(lambda: file.read(1024), b\"\"):\n _hash.update(block)\n return _hash.hexdigest()","def GetFileMd5(file_path):\n return binascii.hexlify(GetFileHashes(file_path, do_md5=True)['md5'])","def checksum(path):\n with open(path, 'r') as f:\n return md5(f.read()).digest()","def md5(fname):\n hash_md5 = hashlib.md5()\n with open(fname, 'rb') as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def _md5_of_file(path):\n md5 = hashlib.md5()\n\n with open(path, 'rb') as f:\n for chunk in iter(lambda: f.read(4096), b''):\n md5.update(chunk)\n\n return md5.hexdigest()","def md5sum(filename_list):\n md5 = hashlib.md5()\n for filename in filename_list:\n if os.path.isfile(filename):\n _count_md5_for_file(md5, filename)\n elif os.path.isdir(filename):\n for base, dirs, files in os.walk(filename):\n dirs.sort() # ensure that directories will be traversed in same order on all platforms\n for name in sorted(files):\n _count_md5_for_file(md5, os.path.join(base, name))\n return md5.hexdigest()","def md5file(filename):\n fh = open(filename)\n digest = md5.new()\n while 1:\n buf = fh.read(4096)\n if buf == \"\":\n break\n digest.update(buf)\n fh.close()\n return digest.hexdigest()","def file_field_md5(source_file, blocksize=65536):\n hasher = hashlib.md5()\n if source_file.closed:\n source_file.open('rb')\n buf = source_file.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = source_file.read(blocksize)\n source_file.seek(0)\n return hasher.hexdigest()","def get_checksum(input_fname):\n with open(input_fname, \"rb\") as infile:\n file_contents = infile.read()\n\n checksum = hashlib.md5(file_contents).hexdigest()\n return checksum","def md5(fname):\n\t\n\thash_md5 = hashlib.md5()\n\twith open(fname, \"rb\") as f:\n\t\tfor chunk in iter(lambda: f.read(4096), b\"\"):\n\t\t\thash_md5.update(chunk)\n\t\n\treturn hash_md5.hexdigest()","def MD5(self) -> _n_0_t_3[_n_0_t_9]:","def local_md5(filepath, blocksize=65536):\n hasher = hashlib.md5()\n with open(filepath, 'rb') as source:\n buf = source.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = source.read(blocksize)\n return hasher.hexdigest()","def md5(filename: str) -> str:\n hash_md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5(path):\n with open(path, 'rb') as f:\n md5hash = hashlib.md5()\n for chunk in iter(lambda: f.read(4096), b''):\n md5hash.update(chunk)\n return md5hash.hexdigest()","def md5File(fname):\n if not os.path.isfile(fname):\n fatal('file does not exist: %s' % fname)\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def _get_file_md5(filename):\n md5_data = md5()\n with open(filename, 'rb') as f:\n for chunk in iter(lambda: f.read(128*md5_data.block_size), b''):\n md5_data.update(chunk)\n return md5_data.hexdigest()","def __md5_for_file(self, filename, num_chunks=None):\n md5 = hashlib.md5()\n with open(filename, 'rb') as f:\n chunk_count = 0\n for chunk in iter(lambda: f.read(8192), ''):\n if (num_chunks is not None) and (num_chunks < chunk_count):\n break\n md5.update(chunk)\n chunk_count += 1\n return md5.hexdigest()","def svn_fs_file_md5_checksum(*args):\r\n return _fs.svn_fs_file_md5_checksum(*args)","def get_md5(filepath):\n md5 = hashlib.md5()\n with open(filepath, 'rb') as f:\n while True:\n data = f.read(BUF_SIZE)\n if not data:\n break\n md5.update(data)\n return md5.hexdigest()","def checksum(self, filepath) -> str:\n if os.path.exists(filepath):\n hash_md5 = md5()\n with open(filepath, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return urlsafe_b64encode(hash_md5.digest()).decode('utf-8')\n\n return \"\"","def md5Hash(pathAndFilename, blockSize=8192):\n hashcode = hashlib.md5()\n with open(pathAndFilename, \"rb\" ) as f:\n block = f.read(blockSize)\n while len(block)>0:\n hashcode.update(block)\n block = f.read(blockSize)\n return hashcode.hexdigest()","def generate_md5(filename, file_size: int = 65536):\n hash_md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for file_chunk in iter(lambda: f.read(file_size), b\"\"):\n hash_md5.update(file_chunk)\n return hash_md5.hexdigest()","def apkdownloadmirror_get_md5_sum(soup, **_):\n return soup.find(text=re.compile(r'File APK Md5:')).next.text.strip()","def md5_hash(file_path):\n with open(file_path, 'rb') as fp:\n return md5(fp.read()).hexdigest()","def get_checksum(filename):\n # You could use popen here. I read about it, and subprocess is meant\n # to replace os.popen, so I used it instead.\n\n # First, run the command md5 sum with filename as input.\n # It's stored as a subprocess.CompletedProcess\n process = subprocess.run(['md5sum',filename], capture_output=True)\n \n # Use the method stdout from subprocess.CompletedProcess (seen in\n # the Python docs) to get the output. As seen in the book, md5sum will\n # output the checksum follwed by the filename. split() will put\n # those two elements into a list, and [0] will take the first element,\n # which will be the checksum.\n checksum = process.stdout.split()[0]\n return checksum","def md5(dir):\n\n # ugly way to avoid circular imports\n from . import settings\n\n files = [ \n settings.DATA['nation']['file_name'],\n settings.DATA['regions']['file_name'],\n settings.DATA['provinces']['file_name'],\n ]\n\n hash_md5 = hashlib.md5()\n for f in files:\n with open(dir+'/'+f, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n \n return hash_md5.hexdigest()","def md5get(filename):\n with open(filename, mode='rb') as f:\n d = hashlib.md5()\n for buf in iter(partial(f.read, 128), b''):\n d.update(buf)\n return d.hexdigest()","def md5(filename):\n d = hashlib.md5()\n try:\n d.update(open(filename).read())\n except Exception,e:\n return False\n else:\n return d.hexdigest()","def count_md5hash_file(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5_sum(string):\n m = hashlib.md5()\n m.update(string.encode(\"utf-8\"))\n return m.hexdigest()","def md5_hash_file(filepath: str) -> str:\n block_size = 64 * 1024\n md5 = hashlib.md5()\n with open(filepath, \"rb\") as file_handler:\n while True:\n data = file_handler.read(block_size)\n if not data:\n break\n md5.update(data)\n return md5.hexdigest()","def file_checksum(filename):\n hash_md5 = hashlib.md5()\n with tf.gfile.Open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n f.close()\n return hash_md5.hexdigest()","def set_file_md5(self):\n md5 = hashlib.md5()\n with open(self.file_path, 'rb') as f:\n while True:\n block = f.read(2 ** 10) # One-megabyte blocks\n if not block:\n break\n md5.update(block)\n self.md5 = md5.hexdigest()","def find_md5checksum(device=None, file_name=None):\n if device is None or file_name is None:\n raise Exception(\"device and file_name are mandatory arguments\")\n\n resp = device.shell(command=\"md5sum \" + file_name).response()\n match = re.search(\"([a-fA-F\\d]{32})\\\\s+\" + file_name +\".*\", resp, re.DOTALL)\n\n if not match:\n device.log(level='ERROR', message=\"Not able to find the checksum\")\n raise Exception(\"Not able to find the checksum\")\n\n md5sum = match.group(1)\n return md5sum","def get_file_checksum(file_path):\n with open(file_path) as f:\n content = f.read()\n return md5(content.encode()).hexdigest()","def checksum_file(vm_name, file_name, vm_executor=None):\n command = config.MD5SUM_CMD % file_name\n if not vm_executor:\n vm_executor = get_vm_executor(vm_name)\n return vm_executor.run_cmd(shlex.split(command))[1]","def hash_file_md5(file_path, binary=False, buffer_size=65536):\n return hash_file(file_path, hash_type=hashlib.md5, binary=binary, buffer_size=buffer_size)","def calc_md5(string):\n\treturn md5(string).hexdigest()","def compute_md5_for_file(file, as_base64, blocksize=65536):\n # type: (pathlib.Path, bool, int) -> str\n hasher = hashlib.md5()\n if isinstance(file, pathlib.Path):\n file = str(file)\n with open(file, 'rb') as filedesc:\n while True:\n buf = filedesc.read(blocksize)\n if not buf:\n break\n hasher.update(buf)\n if as_base64:\n return base64_encode_string(hasher.digest())\n else:\n return hasher.hexdigest()","def md5(self, fileName, excludeLine=\"\", includeLine=\"\"):\n m = hashlib.md5()\n try:\n fd = open(fileName,\"rb\")\n except IOError:\n print \"Unable to open the file in readmode:\", fileName\n return\n eachLine = fd.readline()\n while eachLine:\n if excludeLine and eachLine.startswith(excludeLine):\n continue\n m.update(eachLine)\n eachLine = fd.readline()\n m.update(includeLine)\n fd.close()\n \n return m.hexdigest()","def chunkedmd5(filename,csize=8192):\n md5=hashlib.md5()\n with open(filename,'rb') as f:\n for chunk in iter(lambda: f.read(csize), b''):\n md5.update(chunk)\n return md5.digest().encode('hex')","def md5(self):\n return md5file(self.abspath)","def _get_local_md5(self, blocksize=2**20):\n m = hashlib.md5()\n with open(self.dst, \"rb\") as f:\n buf = f.read(blocksize)\n while buf:\n m.update(buf)\n buf = f.read(blocksize)\n return m.hexdigest()","def generate_file_md5(filename, blocksize=2**20):\r\n m = hashlib.md5()\r\n with open(filename, \"rb\") as f:\r\n while True:\r\n buf = f.read(blocksize)\r\n if not buf:\r\n break\r\n m.update(buf)\r\n return m.hexdigest()","def calc_file_hash(filepath):\n with open(filepath, 'rb') as f:\n return md5(f.read()).hexdigest()","def calc_md5(code):\n md5 = hashlib.md5()\n md5.update(code)\n return md5.hexdigest()","def MakeMd5(filename, md5filename):\n try:\n with open(filename, 'r') as read_file:\n with open(md5filename, 'w') as hash_file:\n hasher = hashlib.md5()\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\n hasher.update(chunk)\n hash_file.write(hasher.hexdigest())\n return True\n except IOError:\n logging.error('Failed to compute md5 checksum for file %s.',\n filename)\n return False","def _md5sum(data):\n hash = hashlib.md5()\n hash.update(six.b(data))\n hash_hex = hash.hexdigest()\n return hash_hex","def checksum(self):\n hasher = md5()\n with self.open('rb') as fd:\n buf = fd.read(_BLOCKSIZE)\n while len(buf) > 0:\n # TODO Could cancel work here.\n hasher.update(buf)\n buf = fd.read(_BLOCKSIZE)\n digest = safetype(hasher.hexdigest())\n return digest","def get_md5(f: BinaryIO) -> str:\n BLOCKSIZE = 65536\n hasher = hashlib.md5()\n buf = f.read(BLOCKSIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = f.read(BLOCKSIZE)\n return hasher.hexdigest()","def _md5(input):\n m = hashlib.md5()\n m.update(input)\n return m.hexdigest()","def hash_file(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def compute(fileName, excludeLine=\"\", includeLine=\"\"):\n m = hashlib.md5()\n fd = open(fileName,\"rb\")\n content = fd.readlines()\n fd.close()\n for eachLine in content:\n if excludeLine and eachLine.startswith(excludeLine):\n continue\n m.update(eachLine)\n m.update(includeLine)\n return m.hexdigest()","def calculate_md5_of_dir(self, verbose=0):\n directory = self.cfg['sharing_path']\n if verbose:\n start = time.time()\n md5Hash = hashlib.md5()\n if not os.path.exists(directory):\n self.stop(1, 'Error during calculate md5! Impossible to find \"{}\" in user folder'.format(directory))\n\n for root, dirs, files in os.walk(directory, followlinks=False):\n for names in files:\n filepath = os.path.join(root, names)\n rel_path = self.relativize_path(filepath)\n if rel_path in self.client_snapshot:\n md5Hash.update(self.client_snapshot[rel_path][1])\n md5Hash.update(hashlib.md5(filepath).hexdigest())\n else:\n hashed_file = self.hash_file(filepath)\n if hashed_file:\n md5Hash.update(hashed_file)\n md5Hash.update(hashlib.md5(filepath).hexdigest())\n else:\n print \"can't hash file: \", filepath\n\n if verbose:\n stop = time.time()\n print stop - start\n return md5Hash.hexdigest()","def get_md5sum(host, fqpath):\n command = \"md5sum %s\" % fqpath\n rcode, rout, rerr = g.run(host, command)\n\n if rcode == 0:\n return rout.strip()\n\n g.log.error('md5sum failed: %s' % rerr)\n return None","def md5(self):\n if self.source_file is None:\n return None\n if self._md5 is None:\n self._md5 = file_field_md5(self.source_file)\n # try: # Locally stored file\n # self._md5 = local_md5(self.source_file.path)\n # except NotImplementedError: # AWS S3 storage\n # self._md5 = s3_md5(self.source_file.file.key)\n return self._md5","def test_md5sum(self, changes_file):\n for file in changes_file['Files']:\n log.debug('Checking md5sum of %s' % file['name'])\n filename = os.path.join(pylons.config['debexpo.upload.incoming'], file['name'])\n if not os.path.isfile(filename):\n raise OSError(\"Missing file %s in incoming\" % (file['name']))\n sum = md5sum(filename)\n\n if sum != file['md5sum']:\n log.critical('%s != %s' % (sum, file['md5sum']))\n raise OSError(\"MD5 sum mismatch in file %s: %s != %s\" % (file['name'], sum, file['md5sum']))\n\n return True","def get_md5(self, line):\n m = hashlib.md5()\n m.update(str(line).encode('utf-8'))\n return m.hexdigest()","def get_md5(data):\n if hasattr(data, \"read\") and hasattr(data, 'seek'):\n data.seek(0)\n m = md5()\n chunk = data.read(1024*1024) # 1Mb\n f_size = 0\n while(chunk):\n f_size += len(chunk)\n m.update(chunk)\n chunk = data.read(1024*1024)\n data.seek(0)\n return m.hexdigest(), f_size\n else: # normal str\n m = md5()\n f_size = len(data)\n m.update(data)\n return m.hexdigest(), f_size","def readfile(self, filename):\n \n f = file(filename,'rb');\n #print \"\\nReading %s \\n\" % f.name;\n m = md5.new();\n readBytes = 1024; # read 1024 bytes per time\n totalBytes = 0;\n while (readBytes):\n readString = f.read(readBytes);\n m.update(readString);\n readBytes = len(readString);\n totalBytes+=readBytes;\n f.close();\n \n return m.hexdigest()","def get_file_hash (fullpath) : \n\n # This bit was sourced from Stack Overflow via Google, specifically:\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\n\n md5 = hashlib.md5()\n with open(fullpath,'rb') as f: \n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \n md5.update(chunk)\n # Hexdigest is the safe varchar(32) style output\n return md5.hexdigest()","def checksum(self, md5_file, file_name):\n try:\n with open(md5_file, 'r') as f:\n md5_file_contents = f.read()\n md5_str = md5_file_contents.split(' ')[0]\n os.remove(md5_file)\n except Exception as e:\n logging.exception('Could not read MD5 file {}. \\\n \\nTry to download the file again'.format(file_name))\n return False\n if not self.check_md5(file_name, md5_str):\n logging.error('Failed in checksum. Download the file again.')\n return False\n return True","def file_digest(path, algo=hashlib.md5):\n checksum = algo()\n with open(path, 'rb') as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n checksum.update(chunk)\n return checksum.hexdigest()","def verify_sum(file_path, md5_sum):\n file_md5_sum = generate_sum(file_path)\n return (file_md5_sum == md5_sum)","def get_md5(self):\n self.md5sum = ''\n return self.md5sum","def compute_gzip_md5(fqfn):\n md5 = hashlib.md5()\n file_obj = gzip.open(fqfn, 'rb')\n for chunk in iter(lambda: file_obj.read(8192), ''):\n md5.update(chunk)\n\n file_obj.close()\n return md5.hexdigest()","def get_partial_md5(self, nbytes):\n return md5file(abspath=self.abspath, nbytes=nbytes)","def getFileMD5(f: java.io.File, monitor: ghidra.util.task.TaskMonitor) -> unicode:\n ...","def updateMD5(_filename, _md5):\n with open(_filename, 'r') as fp:\n while True:\n line = fp.readline()\n if not line:\n break\n\n if \"#ifndef\" in line and line[-3:-1] == \"__\":\n p = re.compile('\\w{32}')\n if _md5 == line[-35:-3]:\n print(\" \" + _filename + \": Unchanged\")\n elif p.match(line[-35:-3]):\n print(\" \" + _filename + \": Modified\")\n addMD5(_filename, _md5)\n else:\n print(\" \" + _filename + \": Added\")\n addMD5(_filename, _md5)","def file_checksum(file_path, block_size=65536):\n path = Path(file_path)\n h = xxhash.xxh64()\n with path.open(\"rb\") as f:\n for chunk in iter(lambda: f.read(block_size), b\"\"):\n h.update(chunk)\n return h.hexdigest()"],"string":"[\n \"def md5sum(file_name):\\n f = open(file_name, mode='rb')\\n h = hashlib.md5()\\n h.update(f.read())\\n return h.hexdigest()\",\n \"def calculate_md5sum_of_a_file(context, file_name, file_path):\\n command = \\\"md5sum \\\" + file_path + \\\"/\\\" + file_name + \\\" | awk {'print $1'}\\\"\\n return context.cme_session.send_ssh_command(command=command)\",\n \"def md5sum_file(filepath):\\n hasher = hashlib.md5()\\n with open(filepath, 'rb') as infile:\\n for chunk in util.chunk_reader(infile):\\n hasher.update(chunk)\\n return hasher.hexdigest()\",\n \"def md5sum(filename):\\n with open(filename, mode='rb') as f:\\n d = hashlib.md5()\\n for buf in iter(functools.partial(f.read, 1024*100), b''):\\n d.update(buf)\\n return d.hexdigest()\",\n \"def CalcMD5(filepath):\\n with open(filepath,'rb') as f:\\n md5obj = hashlib.md5()\\n md5obj.update(f.read())\\n return md5obj.hexdigest()\",\n \"def md5sum(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def calc_file_md5(file_path):\\n hash_md5 = str()\\n method = hashlib.md5()\\n if not os.path.exists(file_path):\\n logger.error(\\\"File(%s) don not exist, can not calculation file hash\\\" % file_path)\\n return hash_md5\\n\\n with open(file_path, 'rb') as f:\\n for chunk in read_chunks(f, 1024 * 1024):\\n method.update(chunk)\\n return method.hexdigest()\",\n \"def calc_md5(infile, block_size=256*128):\\n logger = logging.getLogger(__name__)\\n logger.info(f'Calculating md5 of {infile}')\\n md5 = hashlib.md5()\\n with open(infile, 'rb') as f:\\n for chunk in iter(lambda: f.read(block_size), b''):\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def md5sum(fileSrc):\\n md5 = hashlib.md5()\\n try:\\n with open(fileSrc, \\\"rb\\\") as fd:\\n while True:\\n content = fd.read(2**20)\\n if not content:\\n break\\n md5.update(content)\\n except IOError:\\n print(fileSrc + \\\" Not found\\\")\\n exit(1)\\n return md5.hexdigest()\",\n \"def generate_sum(file_path):\\n #file = open(file_path, 'rb')\\n #header = file.read()\\n header = open(file_path, 'rb').read()\\n suma_md5 = md5(header).hexdigest()\\n return suma_md5\",\n \"def compute_checksum(filename):\\n cmd = 'md5sum ' + filename\\n return pipe(cmd)\",\n \"def md5checksum(file_name):\\n from hashlib import md5\\n hash_md5 = md5()\\n with open(file_name, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(32768), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5_checksum(file_path):\\n with open(file_path, 'rb') as fh:\\n m = hashlib.md5()\\n while True:\\n data = fh.read(8192)\\n if not data:\\n break\\n m.update(data)\\n return m.hexdigest()\",\n \"def fsum(fpath):\\n import hashlib\\n import codecs\\n with codecs.open(fpath, \\\"r\\\", \\\"utf-8\\\") as filep:\\n buff = filep.read()\\n cksum = hashlib.md5(buff.encode(\\\"utf-8\\\"))\\n return cksum.hexdigest()\",\n \"def md5sum(fname):\\n\\tdef read_chunks(fh):\\n\\t\\tfh.seek(0)\\n\\t\\tchunk = fh.read(8096)\\n\\t\\twhile chunk:\\n\\t\\t\\tyield chunk\\n\\t\\t\\tchunk = fh.read(8096)\\n\\t\\telse: #最后要将游标放回文件开头\\n\\t\\t\\tfh.seek(0)\\n\\n\\tm = hashlib.md5()\\n\\tif isinstance(fname, str) and os.path.exists(fname):\\n\\t\\tfh = open(fname, \\\"rb\\\")\\n\\t\\tfor chunk in read_chunks(fh):\\n\\t\\t\\tm.update(chunk)\\n\\t#上传的文件缓存或已打开的文件流\\n\\telif fname.__class__.__name__ in [\\\"StringIO\\\", \\\"StringO\\\"] or isinstance(fname, file):\\n\\t\\tfor chunk in read_chunks(fname):\\n\\t\\t\\tm.update(chunk)\\n\\telse:\\n\\t\\treturn \\\"\\\"\\n\\treturn m.hexdigest()\",\n \"def md5sum_file(filename: str, hr: bool = True) -> str:\\n block_size = 256 * 128\\n\\n md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(block_size), b\\\"\\\"):\\n md5.update(chunk)\\n if hr:\\n return md5.hexdigest()\\n return md5.digest()\",\n \"def checksumFile(filename):\\n return md5File(filename)\",\n \"def file_md5(file_path):\\n log.debug(\\\"Calculating md5 for %s\\\", file_path)\\n start_ms = time.time() * 10**3\\n fp = open(file_path, 'rb')\\n try:\\n # returns tuple (md5_hex, md5_base64, size)\\n md5, _, _ = boto.utils.compute_md5(fp)\\n finally:\\n fp.close()\\n duration_ms = (time.time() * 10**3) - start_ms\\n log.debug(\\\"Calculated hash %s for %s in %s ms\\\", md5, file_path, \\n duration_ms)\\n return md5\",\n \"def calculate_md5(filename, block_size=2**20):\\n import hashlib\\n\\n md5 = hashlib.md5()\\n try:\\n with open(filename, 'rb') as f:\\n while True:\\n data = f.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n except IOError:\\n print('File \\\\'' + filename + '\\\\' not found!')\\n return None\\n except:\\n return None\\n return md5.hexdigest()\",\n \"def get_md5sum_file(fullname, blksize=2**15):\\n\\n md5 = hashlib.md5()\\n with open(fullname, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(blksize), b''):\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def md5_sum(content):\\r\\n md5_hash = hashlib.md5(content).hexdigest()\\r\\n return md5_hash\",\n \"def compute_md5_for_file(file, block_size=2**14):\\n f = open(file, 'r')\\n md5 = hashlib.md5()\\n while True:\\n data = f.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n return base64.b64encode(md5.digest())\",\n \"def md5(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(4096), b''):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(4096), b''):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def calculate(d):\\r\\n\\r\\n # Set correct slashes for the OS\\r\\n if sys.platform == 'windows':\\r\\n slash = '\\\\\\\\'\\r\\n elif sys.platform == 'linux':\\r\\n slash = '/'\\r\\n else:\\r\\n print('#Error. Unknown platform.')\\r\\n return\\r\\n\\r\\n print('Files in the current directory and their md5-hashes:\\\\n')\\r\\n i = 0\\r\\n assert i == 0, '#Error. Variable i != 0.'\\r\\n\\r\\n for i in range(len(d[2])): # Go through the list of files\\r\\n full_path = d[0]+slash+d[2][i]\\r\\n print(full_path) # Get the list of files with full paths\\r\\n print(md5(full_path))\\r\\n size(full_path)\",\n \"def CalculateMd5OfEachFile(self, filedic):\\n #for eachfiledic in self.fileTobeUploaded:\\n fileobj = open(filedic[\\\"filepath\\\"], 'rb')\\n buf = fileobj.read()\\n hash = hashlib.md5()\\n hash.update(buf)\\n\\n digest = hashlib.md5(buf).digest()\\n md5enc = base64.b64encode(digest)\\n md5tostr = md5enc.decode('utf-8')\\n filedic[\\\"md5\\\"] = md5tostr\\n fileobj.close()\\n\\n #pprint.pprint(self.fileTobeUploaded)\",\n \"def GenerateMd5(filename):\\n try:\\n with open(filename, 'r') as read_file:\\n hasher = hashlib.md5()\\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\\n hasher.update(chunk)\\n return hasher.hexdigest()\\n except IOError:\\n logging.error('Failed to compute md5 checksum for file %s.',\\n filename)\\n return ''\",\n \"def md5(file_path):\\r\\n\\r\\n hasher = hashlib.md5()\\r\\n with Profiler():\\r\\n with open(file_path, 'rb') as f:\\r\\n while True:\\r\\n buf = f.read(BLOCKSIZE)\\r\\n if not buf:\\r\\n break\\r\\n while len(buf) > 0:\\r\\n hasher.update(buf)\\r\\n buf = f.read(BLOCKSIZE)\\r\\n md5_hash = (hasher.hexdigest()).upper()\\r\\n return md5_hash\",\n \"def md5(filename):\\n # see https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file # noqa: E501\\n hash_md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(1048576), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5(fname):\\n hash = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash.update(chunk)\\n return hash.hexdigest()\",\n \"def md5(filename: str) -> str:\\n # using md5 for speed\\n _hash = hashlib.md5()\\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n for block in iter(lambda: file.read(1024), b\\\"\\\"):\\n _hash.update(block)\\n return _hash.hexdigest()\",\n \"def GetFileMd5(file_path):\\n return binascii.hexlify(GetFileHashes(file_path, do_md5=True)['md5'])\",\n \"def checksum(path):\\n with open(path, 'r') as f:\\n return md5(f.read()).digest()\",\n \"def md5(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, 'rb') as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def _md5_of_file(path):\\n md5 = hashlib.md5()\\n\\n with open(path, 'rb') as f:\\n for chunk in iter(lambda: f.read(4096), b''):\\n md5.update(chunk)\\n\\n return md5.hexdigest()\",\n \"def md5sum(filename_list):\\n md5 = hashlib.md5()\\n for filename in filename_list:\\n if os.path.isfile(filename):\\n _count_md5_for_file(md5, filename)\\n elif os.path.isdir(filename):\\n for base, dirs, files in os.walk(filename):\\n dirs.sort() # ensure that directories will be traversed in same order on all platforms\\n for name in sorted(files):\\n _count_md5_for_file(md5, os.path.join(base, name))\\n return md5.hexdigest()\",\n \"def md5file(filename):\\n fh = open(filename)\\n digest = md5.new()\\n while 1:\\n buf = fh.read(4096)\\n if buf == \\\"\\\":\\n break\\n digest.update(buf)\\n fh.close()\\n return digest.hexdigest()\",\n \"def file_field_md5(source_file, blocksize=65536):\\n hasher = hashlib.md5()\\n if source_file.closed:\\n source_file.open('rb')\\n buf = source_file.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = source_file.read(blocksize)\\n source_file.seek(0)\\n return hasher.hexdigest()\",\n \"def get_checksum(input_fname):\\n with open(input_fname, \\\"rb\\\") as infile:\\n file_contents = infile.read()\\n\\n checksum = hashlib.md5(file_contents).hexdigest()\\n return checksum\",\n \"def md5(fname):\\n\\t\\n\\thash_md5 = hashlib.md5()\\n\\twith open(fname, \\\"rb\\\") as f:\\n\\t\\tfor chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n\\t\\t\\thash_md5.update(chunk)\\n\\t\\n\\treturn hash_md5.hexdigest()\",\n \"def MD5(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def local_md5(filepath, blocksize=65536):\\n hasher = hashlib.md5()\\n with open(filepath, 'rb') as source:\\n buf = source.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = source.read(blocksize)\\n return hasher.hexdigest()\",\n \"def md5(filename: str) -> str:\\n hash_md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5(path):\\n with open(path, 'rb') as f:\\n md5hash = hashlib.md5()\\n for chunk in iter(lambda: f.read(4096), b''):\\n md5hash.update(chunk)\\n return md5hash.hexdigest()\",\n \"def md5File(fname):\\n if not os.path.isfile(fname):\\n fatal('file does not exist: %s' % fname)\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def _get_file_md5(filename):\\n md5_data = md5()\\n with open(filename, 'rb') as f:\\n for chunk in iter(lambda: f.read(128*md5_data.block_size), b''):\\n md5_data.update(chunk)\\n return md5_data.hexdigest()\",\n \"def __md5_for_file(self, filename, num_chunks=None):\\n md5 = hashlib.md5()\\n with open(filename, 'rb') as f:\\n chunk_count = 0\\n for chunk in iter(lambda: f.read(8192), ''):\\n if (num_chunks is not None) and (num_chunks < chunk_count):\\n break\\n md5.update(chunk)\\n chunk_count += 1\\n return md5.hexdigest()\",\n \"def svn_fs_file_md5_checksum(*args):\\r\\n return _fs.svn_fs_file_md5_checksum(*args)\",\n \"def get_md5(filepath):\\n md5 = hashlib.md5()\\n with open(filepath, 'rb') as f:\\n while True:\\n data = f.read(BUF_SIZE)\\n if not data:\\n break\\n md5.update(data)\\n return md5.hexdigest()\",\n \"def checksum(self, filepath) -> str:\\n if os.path.exists(filepath):\\n hash_md5 = md5()\\n with open(filepath, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return urlsafe_b64encode(hash_md5.digest()).decode('utf-8')\\n\\n return \\\"\\\"\",\n \"def md5Hash(pathAndFilename, blockSize=8192):\\n hashcode = hashlib.md5()\\n with open(pathAndFilename, \\\"rb\\\" ) as f:\\n block = f.read(blockSize)\\n while len(block)>0:\\n hashcode.update(block)\\n block = f.read(blockSize)\\n return hashcode.hexdigest()\",\n \"def generate_md5(filename, file_size: int = 65536):\\n hash_md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for file_chunk in iter(lambda: f.read(file_size), b\\\"\\\"):\\n hash_md5.update(file_chunk)\\n return hash_md5.hexdigest()\",\n \"def apkdownloadmirror_get_md5_sum(soup, **_):\\n return soup.find(text=re.compile(r'File APK Md5:')).next.text.strip()\",\n \"def md5_hash(file_path):\\n with open(file_path, 'rb') as fp:\\n return md5(fp.read()).hexdigest()\",\n \"def get_checksum(filename):\\n # You could use popen here. I read about it, and subprocess is meant\\n # to replace os.popen, so I used it instead.\\n\\n # First, run the command md5 sum with filename as input.\\n # It's stored as a subprocess.CompletedProcess\\n process = subprocess.run(['md5sum',filename], capture_output=True)\\n \\n # Use the method stdout from subprocess.CompletedProcess (seen in\\n # the Python docs) to get the output. As seen in the book, md5sum will\\n # output the checksum follwed by the filename. split() will put\\n # those two elements into a list, and [0] will take the first element,\\n # which will be the checksum.\\n checksum = process.stdout.split()[0]\\n return checksum\",\n \"def md5(dir):\\n\\n # ugly way to avoid circular imports\\n from . import settings\\n\\n files = [ \\n settings.DATA['nation']['file_name'],\\n settings.DATA['regions']['file_name'],\\n settings.DATA['provinces']['file_name'],\\n ]\\n\\n hash_md5 = hashlib.md5()\\n for f in files:\\n with open(dir+'/'+f, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n \\n return hash_md5.hexdigest()\",\n \"def md5get(filename):\\n with open(filename, mode='rb') as f:\\n d = hashlib.md5()\\n for buf in iter(partial(f.read, 128), b''):\\n d.update(buf)\\n return d.hexdigest()\",\n \"def md5(filename):\\n d = hashlib.md5()\\n try:\\n d.update(open(filename).read())\\n except Exception,e:\\n return False\\n else:\\n return d.hexdigest()\",\n \"def count_md5hash_file(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5_sum(string):\\n m = hashlib.md5()\\n m.update(string.encode(\\\"utf-8\\\"))\\n return m.hexdigest()\",\n \"def md5_hash_file(filepath: str) -> str:\\n block_size = 64 * 1024\\n md5 = hashlib.md5()\\n with open(filepath, \\\"rb\\\") as file_handler:\\n while True:\\n data = file_handler.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n return md5.hexdigest()\",\n \"def file_checksum(filename):\\n hash_md5 = hashlib.md5()\\n with tf.gfile.Open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n f.close()\\n return hash_md5.hexdigest()\",\n \"def set_file_md5(self):\\n md5 = hashlib.md5()\\n with open(self.file_path, 'rb') as f:\\n while True:\\n block = f.read(2 ** 10) # One-megabyte blocks\\n if not block:\\n break\\n md5.update(block)\\n self.md5 = md5.hexdigest()\",\n \"def find_md5checksum(device=None, file_name=None):\\n if device is None or file_name is None:\\n raise Exception(\\\"device and file_name are mandatory arguments\\\")\\n\\n resp = device.shell(command=\\\"md5sum \\\" + file_name).response()\\n match = re.search(\\\"([a-fA-F\\\\d]{32})\\\\\\\\s+\\\" + file_name +\\\".*\\\", resp, re.DOTALL)\\n\\n if not match:\\n device.log(level='ERROR', message=\\\"Not able to find the checksum\\\")\\n raise Exception(\\\"Not able to find the checksum\\\")\\n\\n md5sum = match.group(1)\\n return md5sum\",\n \"def get_file_checksum(file_path):\\n with open(file_path) as f:\\n content = f.read()\\n return md5(content.encode()).hexdigest()\",\n \"def checksum_file(vm_name, file_name, vm_executor=None):\\n command = config.MD5SUM_CMD % file_name\\n if not vm_executor:\\n vm_executor = get_vm_executor(vm_name)\\n return vm_executor.run_cmd(shlex.split(command))[1]\",\n \"def hash_file_md5(file_path, binary=False, buffer_size=65536):\\n return hash_file(file_path, hash_type=hashlib.md5, binary=binary, buffer_size=buffer_size)\",\n \"def calc_md5(string):\\n\\treturn md5(string).hexdigest()\",\n \"def compute_md5_for_file(file, as_base64, blocksize=65536):\\n # type: (pathlib.Path, bool, int) -> str\\n hasher = hashlib.md5()\\n if isinstance(file, pathlib.Path):\\n file = str(file)\\n with open(file, 'rb') as filedesc:\\n while True:\\n buf = filedesc.read(blocksize)\\n if not buf:\\n break\\n hasher.update(buf)\\n if as_base64:\\n return base64_encode_string(hasher.digest())\\n else:\\n return hasher.hexdigest()\",\n \"def md5(self, fileName, excludeLine=\\\"\\\", includeLine=\\\"\\\"):\\n m = hashlib.md5()\\n try:\\n fd = open(fileName,\\\"rb\\\")\\n except IOError:\\n print \\\"Unable to open the file in readmode:\\\", fileName\\n return\\n eachLine = fd.readline()\\n while eachLine:\\n if excludeLine and eachLine.startswith(excludeLine):\\n continue\\n m.update(eachLine)\\n eachLine = fd.readline()\\n m.update(includeLine)\\n fd.close()\\n \\n return m.hexdigest()\",\n \"def chunkedmd5(filename,csize=8192):\\n md5=hashlib.md5()\\n with open(filename,'rb') as f:\\n for chunk in iter(lambda: f.read(csize), b''):\\n md5.update(chunk)\\n return md5.digest().encode('hex')\",\n \"def md5(self):\\n return md5file(self.abspath)\",\n \"def _get_local_md5(self, blocksize=2**20):\\n m = hashlib.md5()\\n with open(self.dst, \\\"rb\\\") as f:\\n buf = f.read(blocksize)\\n while buf:\\n m.update(buf)\\n buf = f.read(blocksize)\\n return m.hexdigest()\",\n \"def generate_file_md5(filename, blocksize=2**20):\\r\\n m = hashlib.md5()\\r\\n with open(filename, \\\"rb\\\") as f:\\r\\n while True:\\r\\n buf = f.read(blocksize)\\r\\n if not buf:\\r\\n break\\r\\n m.update(buf)\\r\\n return m.hexdigest()\",\n \"def calc_file_hash(filepath):\\n with open(filepath, 'rb') as f:\\n return md5(f.read()).hexdigest()\",\n \"def calc_md5(code):\\n md5 = hashlib.md5()\\n md5.update(code)\\n return md5.hexdigest()\",\n \"def MakeMd5(filename, md5filename):\\n try:\\n with open(filename, 'r') as read_file:\\n with open(md5filename, 'w') as hash_file:\\n hasher = hashlib.md5()\\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\\n hasher.update(chunk)\\n hash_file.write(hasher.hexdigest())\\n return True\\n except IOError:\\n logging.error('Failed to compute md5 checksum for file %s.',\\n filename)\\n return False\",\n \"def _md5sum(data):\\n hash = hashlib.md5()\\n hash.update(six.b(data))\\n hash_hex = hash.hexdigest()\\n return hash_hex\",\n \"def checksum(self):\\n hasher = md5()\\n with self.open('rb') as fd:\\n buf = fd.read(_BLOCKSIZE)\\n while len(buf) > 0:\\n # TODO Could cancel work here.\\n hasher.update(buf)\\n buf = fd.read(_BLOCKSIZE)\\n digest = safetype(hasher.hexdigest())\\n return digest\",\n \"def get_md5(f: BinaryIO) -> str:\\n BLOCKSIZE = 65536\\n hasher = hashlib.md5()\\n buf = f.read(BLOCKSIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = f.read(BLOCKSIZE)\\n return hasher.hexdigest()\",\n \"def _md5(input):\\n m = hashlib.md5()\\n m.update(input)\\n return m.hexdigest()\",\n \"def hash_file(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def compute(fileName, excludeLine=\\\"\\\", includeLine=\\\"\\\"):\\n m = hashlib.md5()\\n fd = open(fileName,\\\"rb\\\")\\n content = fd.readlines()\\n fd.close()\\n for eachLine in content:\\n if excludeLine and eachLine.startswith(excludeLine):\\n continue\\n m.update(eachLine)\\n m.update(includeLine)\\n return m.hexdigest()\",\n \"def calculate_md5_of_dir(self, verbose=0):\\n directory = self.cfg['sharing_path']\\n if verbose:\\n start = time.time()\\n md5Hash = hashlib.md5()\\n if not os.path.exists(directory):\\n self.stop(1, 'Error during calculate md5! Impossible to find \\\"{}\\\" in user folder'.format(directory))\\n\\n for root, dirs, files in os.walk(directory, followlinks=False):\\n for names in files:\\n filepath = os.path.join(root, names)\\n rel_path = self.relativize_path(filepath)\\n if rel_path in self.client_snapshot:\\n md5Hash.update(self.client_snapshot[rel_path][1])\\n md5Hash.update(hashlib.md5(filepath).hexdigest())\\n else:\\n hashed_file = self.hash_file(filepath)\\n if hashed_file:\\n md5Hash.update(hashed_file)\\n md5Hash.update(hashlib.md5(filepath).hexdigest())\\n else:\\n print \\\"can't hash file: \\\", filepath\\n\\n if verbose:\\n stop = time.time()\\n print stop - start\\n return md5Hash.hexdigest()\",\n \"def get_md5sum(host, fqpath):\\n command = \\\"md5sum %s\\\" % fqpath\\n rcode, rout, rerr = g.run(host, command)\\n\\n if rcode == 0:\\n return rout.strip()\\n\\n g.log.error('md5sum failed: %s' % rerr)\\n return None\",\n \"def md5(self):\\n if self.source_file is None:\\n return None\\n if self._md5 is None:\\n self._md5 = file_field_md5(self.source_file)\\n # try: # Locally stored file\\n # self._md5 = local_md5(self.source_file.path)\\n # except NotImplementedError: # AWS S3 storage\\n # self._md5 = s3_md5(self.source_file.file.key)\\n return self._md5\",\n \"def test_md5sum(self, changes_file):\\n for file in changes_file['Files']:\\n log.debug('Checking md5sum of %s' % file['name'])\\n filename = os.path.join(pylons.config['debexpo.upload.incoming'], file['name'])\\n if not os.path.isfile(filename):\\n raise OSError(\\\"Missing file %s in incoming\\\" % (file['name']))\\n sum = md5sum(filename)\\n\\n if sum != file['md5sum']:\\n log.critical('%s != %s' % (sum, file['md5sum']))\\n raise OSError(\\\"MD5 sum mismatch in file %s: %s != %s\\\" % (file['name'], sum, file['md5sum']))\\n\\n return True\",\n \"def get_md5(self, line):\\n m = hashlib.md5()\\n m.update(str(line).encode('utf-8'))\\n return m.hexdigest()\",\n \"def get_md5(data):\\n if hasattr(data, \\\"read\\\") and hasattr(data, 'seek'):\\n data.seek(0)\\n m = md5()\\n chunk = data.read(1024*1024) # 1Mb\\n f_size = 0\\n while(chunk):\\n f_size += len(chunk)\\n m.update(chunk)\\n chunk = data.read(1024*1024)\\n data.seek(0)\\n return m.hexdigest(), f_size\\n else: # normal str\\n m = md5()\\n f_size = len(data)\\n m.update(data)\\n return m.hexdigest(), f_size\",\n \"def readfile(self, filename):\\n \\n f = file(filename,'rb');\\n #print \\\"\\\\nReading %s \\\\n\\\" % f.name;\\n m = md5.new();\\n readBytes = 1024; # read 1024 bytes per time\\n totalBytes = 0;\\n while (readBytes):\\n readString = f.read(readBytes);\\n m.update(readString);\\n readBytes = len(readString);\\n totalBytes+=readBytes;\\n f.close();\\n \\n return m.hexdigest()\",\n \"def get_file_hash (fullpath) : \\n\\n # This bit was sourced from Stack Overflow via Google, specifically:\\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\\n\\n md5 = hashlib.md5()\\n with open(fullpath,'rb') as f: \\n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \\n md5.update(chunk)\\n # Hexdigest is the safe varchar(32) style output\\n return md5.hexdigest()\",\n \"def checksum(self, md5_file, file_name):\\n try:\\n with open(md5_file, 'r') as f:\\n md5_file_contents = f.read()\\n md5_str = md5_file_contents.split(' ')[0]\\n os.remove(md5_file)\\n except Exception as e:\\n logging.exception('Could not read MD5 file {}. \\\\\\n \\\\nTry to download the file again'.format(file_name))\\n return False\\n if not self.check_md5(file_name, md5_str):\\n logging.error('Failed in checksum. Download the file again.')\\n return False\\n return True\",\n \"def file_digest(path, algo=hashlib.md5):\\n checksum = algo()\\n with open(path, 'rb') as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n checksum.update(chunk)\\n return checksum.hexdigest()\",\n \"def verify_sum(file_path, md5_sum):\\n file_md5_sum = generate_sum(file_path)\\n return (file_md5_sum == md5_sum)\",\n \"def get_md5(self):\\n self.md5sum = ''\\n return self.md5sum\",\n \"def compute_gzip_md5(fqfn):\\n md5 = hashlib.md5()\\n file_obj = gzip.open(fqfn, 'rb')\\n for chunk in iter(lambda: file_obj.read(8192), ''):\\n md5.update(chunk)\\n\\n file_obj.close()\\n return md5.hexdigest()\",\n \"def get_partial_md5(self, nbytes):\\n return md5file(abspath=self.abspath, nbytes=nbytes)\",\n \"def getFileMD5(f: java.io.File, monitor: ghidra.util.task.TaskMonitor) -> unicode:\\n ...\",\n \"def updateMD5(_filename, _md5):\\n with open(_filename, 'r') as fp:\\n while True:\\n line = fp.readline()\\n if not line:\\n break\\n\\n if \\\"#ifndef\\\" in line and line[-3:-1] == \\\"__\\\":\\n p = re.compile('\\\\w{32}')\\n if _md5 == line[-35:-3]:\\n print(\\\" \\\" + _filename + \\\": Unchanged\\\")\\n elif p.match(line[-35:-3]):\\n print(\\\" \\\" + _filename + \\\": Modified\\\")\\n addMD5(_filename, _md5)\\n else:\\n print(\\\" \\\" + _filename + \\\": Added\\\")\\n addMD5(_filename, _md5)\",\n \"def file_checksum(file_path, block_size=65536):\\n path = Path(file_path)\\n h = xxhash.xxh64()\\n with path.open(\\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(block_size), b\\\"\\\"):\\n h.update(chunk)\\n return h.hexdigest()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8501577","0.8366398","0.8354866","0.83091176","0.82591504","0.8246826","0.81144214","0.7983357","0.79745054","0.7973922","0.79374063","0.7884534","0.78658235","0.78574777","0.78492963","0.7834824","0.77871597","0.77637947","0.7742572","0.7533376","0.7526748","0.75238115","0.7501976","0.7501976","0.7492153","0.74588114","0.7457103","0.7431222","0.7427425","0.7413591","0.73849624","0.7382272","0.73562217","0.7348688","0.7341209","0.73301136","0.731542","0.729698","0.72923386","0.72919154","0.72838026","0.72806597","0.7236022","0.7230551","0.7210472","0.7196652","0.71890956","0.71534395","0.7133278","0.71292555","0.7124713","0.71244824","0.7119323","0.7107198","0.7091253","0.7087552","0.7086607","0.70864093","0.7053791","0.7051021","0.7037467","0.7036417","0.7001776","0.6960615","0.6957744","0.6956258","0.6921195","0.691737","0.69111663","0.6892677","0.68857205","0.687561","0.68690443","0.68666685","0.6860961","0.685971","0.6839753","0.6833285","0.67699414","0.67528063","0.67459816","0.67289317","0.672011","0.67069036","0.6703147","0.6683807","0.66819036","0.6679379","0.66717154","0.66690075","0.6657467","0.6645615","0.66048545","0.6577835","0.6574206","0.65543854","0.64800113","0.64727783","0.6461755","0.6450348"],"string":"[\n \"0.8501577\",\n \"0.8366398\",\n \"0.8354866\",\n \"0.83091176\",\n \"0.82591504\",\n \"0.8246826\",\n \"0.81144214\",\n \"0.7983357\",\n \"0.79745054\",\n \"0.7973922\",\n \"0.79374063\",\n \"0.7884534\",\n \"0.78658235\",\n \"0.78574777\",\n \"0.78492963\",\n \"0.7834824\",\n \"0.77871597\",\n \"0.77637947\",\n \"0.7742572\",\n \"0.7533376\",\n \"0.7526748\",\n \"0.75238115\",\n \"0.7501976\",\n \"0.7501976\",\n \"0.7492153\",\n \"0.74588114\",\n \"0.7457103\",\n \"0.7431222\",\n \"0.7427425\",\n \"0.7413591\",\n \"0.73849624\",\n \"0.7382272\",\n \"0.73562217\",\n \"0.7348688\",\n \"0.7341209\",\n \"0.73301136\",\n \"0.731542\",\n \"0.729698\",\n \"0.72923386\",\n \"0.72919154\",\n \"0.72838026\",\n \"0.72806597\",\n \"0.7236022\",\n \"0.7230551\",\n \"0.7210472\",\n \"0.7196652\",\n \"0.71890956\",\n \"0.71534395\",\n \"0.7133278\",\n \"0.71292555\",\n \"0.7124713\",\n \"0.71244824\",\n \"0.7119323\",\n \"0.7107198\",\n \"0.7091253\",\n \"0.7087552\",\n \"0.7086607\",\n \"0.70864093\",\n \"0.7053791\",\n \"0.7051021\",\n \"0.7037467\",\n \"0.7036417\",\n \"0.7001776\",\n \"0.6960615\",\n \"0.6957744\",\n \"0.6956258\",\n \"0.6921195\",\n \"0.691737\",\n \"0.69111663\",\n \"0.6892677\",\n \"0.68857205\",\n \"0.687561\",\n \"0.68690443\",\n \"0.68666685\",\n \"0.6860961\",\n \"0.685971\",\n \"0.6839753\",\n \"0.6833285\",\n \"0.67699414\",\n \"0.67528063\",\n \"0.67459816\",\n \"0.67289317\",\n \"0.672011\",\n \"0.67069036\",\n \"0.6703147\",\n \"0.6683807\",\n \"0.66819036\",\n \"0.6679379\",\n \"0.66717154\",\n \"0.66690075\",\n \"0.6657467\",\n \"0.6645615\",\n \"0.66048545\",\n \"0.6577835\",\n \"0.6574206\",\n \"0.65543854\",\n \"0.64800113\",\n \"0.64727783\",\n \"0.6461755\",\n \"0.6450348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8164291"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":83777,"cells":{"query":{"kind":"string","value":"Reads a MD5 checksum file and returns hashes as a dictionary."},"document":{"kind":"string","value":"def readmd5_sum_file(path):\n with open(path, \"r\") as f:\n hashes = {}\n while True:\n line = f.readline()\n if not line:\n break\n h, name = line.rstrip().split(' ', 1)\n hashes[name] = h\n return hashes"},"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_md5_lookup(filename):\n lookup = {}\n\n with open(filename) as f:\n for row in f:\n (md5, sha256) = row.strip().split(\",\")\n lookup[md5] = sha256\n\n return lookup","def data_checksum(self, node):\n cmd = f\"find {RedpandaService.DATA_DIR} -type f -exec md5sum '{{}}' \\; -exec stat -c %s '{{}}' \\;\"\n lines = node.account.ssh_output(cmd)\n tokens = lines.split()\n return {\n tokens[ix + 1].decode(): (tokens[ix].decode(), int(tokens[ix + 2]))\n for ix in range(0, len(tokens), 3)\n }","def md5sum_file(filepath):\n hasher = hashlib.md5()\n with open(filepath, 'rb') as infile:\n for chunk in util.chunk_reader(infile):\n hasher.update(chunk)\n return hasher.hexdigest()","def md5_checksum(file_path):\n with open(file_path, 'rb') as fh:\n m = hashlib.md5()\n while True:\n data = fh.read(8192)\n if not data:\n break\n m.update(data)\n return m.hexdigest()","def md5sum(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def checksumFile(filename):\n return md5File(filename)","def GetFileMd5(file_path):\n return binascii.hexlify(GetFileHashes(file_path, do_md5=True)['md5'])","def count_md5hash_file(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5sum(file_name):\n f = open(file_name, mode='rb')\n h = hashlib.md5()\n h.update(f.read())\n return h.hexdigest()","def CalcMD5(filepath):\n with open(filepath,'rb') as f:\n md5obj = hashlib.md5()\n md5obj.update(f.read())\n return md5obj.hexdigest()","def md5_sum_file(path):\n with open(path, 'rb') as f:\n m = hashlib.md5()\n while True:\n data = f.read(8192)\n if not data:\n break\n m.update(data)\n return m.hexdigest()","def md5checksum(file_name):\n from hashlib import md5\n hash_md5 = md5()\n with open(file_name, \"rb\") as f:\n for chunk in iter(lambda: f.read(32768), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5_hash(file_path):\n with open(file_path, 'rb') as fp:\n return md5(fp.read()).hexdigest()","def checksum(path):\n with open(path, 'r') as f:\n return md5(f.read()).digest()","def md5(path):\n with open(path, 'rb') as f:\n md5hash = hashlib.md5()\n for chunk in iter(lambda: f.read(4096), b''):\n md5hash.update(chunk)\n return md5hash.hexdigest()","def get_contents_hash(self):\n md5 = hashlib.md5()\n with closing(self.open()) as handle:\n for chunk in handle.chunks():\n md5.update(chunk)\n return md5.hexdigest()","def readfile(self, filename):\n \n f = file(filename,'rb');\n #print \"\\nReading %s \\n\" % f.name;\n m = md5.new();\n readBytes = 1024; # read 1024 bytes per time\n totalBytes = 0;\n while (readBytes):\n readString = f.read(readBytes);\n m.update(readString);\n readBytes = len(readString);\n totalBytes+=readBytes;\n f.close();\n \n return m.hexdigest()","def get_checksum(input_fname):\n with open(input_fname, \"rb\") as infile:\n file_contents = infile.read()\n\n checksum = hashlib.md5(file_contents).hexdigest()\n return checksum","def calc_md5(infile, block_size=256*128):\n logger = logging.getLogger(__name__)\n logger.info(f'Calculating md5 of {infile}')\n md5 = hashlib.md5()\n with open(infile, 'rb') as f:\n for chunk in iter(lambda: f.read(block_size), b''):\n md5.update(chunk)\n return md5.hexdigest()","def GetFileHashes(file_path, do_sha1=False, do_sha256=False, do_md5=False):\n hashes = {}\n if (do_sha1 or do_sha256 or do_md5):\n # Initialize hashers.\n hasher_sha1 = hashlib.sha1() if do_sha1 else None\n hasher_sha256 = hashlib.sha256() if do_sha256 else None\n hasher_md5 = hashlib.md5() if do_md5 else None\n\n # Read blocks from file, update hashes.\n with open(file_path, 'rb') as fd:\n while True:\n block = fd.read(_HASH_BLOCK_SIZE)\n if not block:\n break\n hasher_sha1 and hasher_sha1.update(block)\n hasher_sha256 and hasher_sha256.update(block)\n hasher_md5 and hasher_md5.update(block)\n\n # Update return values.\n if hasher_sha1:\n hashes['sha1'] = hasher_sha1.digest()\n if hasher_sha256:\n hashes['sha256'] = hasher_sha256.digest()\n if hasher_md5:\n hashes['md5'] = hasher_md5.digest()\n\n return hashes","def _load_md5s(self) -> None:\n self._md5s = {}\n path = os.path.join(self.path, \".fairly_md5\")\n try:\n with open(path, \"r\") as file:\n reader = csv.reader(file)\n for name, date, size, md5 in reader:\n self._md5s[name] = (date, size, md5)\n except FileNotFoundError:\n pass","def md5sum(filename):\n with open(filename, mode='rb') as f:\n d = hashlib.md5()\n for buf in iter(functools.partial(f.read, 1024*100), b''):\n d.update(buf)\n return d.hexdigest()","def md5(fname):\n hash = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash.update(chunk)\n return hash.hexdigest()","def calc_file_md5(file_path):\n hash_md5 = str()\n method = hashlib.md5()\n if not os.path.exists(file_path):\n logger.error(\"File(%s) don not exist, can not calculation file hash\" % file_path)\n return hash_md5\n\n with open(file_path, 'rb') as f:\n for chunk in read_chunks(f, 1024 * 1024):\n method.update(chunk)\n return method.hexdigest()","def md5(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(4096), b''):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5(file_path):\n hash_md5 = hashlib.md5()\n with open(file_path, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(4096), b''):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def hash_file(fname):\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def md5_hash_file(filepath: str) -> str:\n block_size = 64 * 1024\n md5 = hashlib.md5()\n with open(filepath, \"rb\") as file_handler:\n while True:\n data = file_handler.read(block_size)\n if not data:\n break\n md5.update(data)\n return md5.hexdigest()","def find_and_validate_md5_checksums(in_folder, md5key_filename):\n validated_files = []\n for filename in locate(md5key_filename, root=in_folder):\n file_fd = open(filename, 'r')\n contents = file_fd.readlines()\n for line in contents:\n split_line = line.split(' ')\n if len(split_line) == 2:\n hashkey, hashkey_target = split_line\n hashkey_target = os.path.join(os.path.dirname(filename),\n hashkey_target.strip())\n hashkey = hashkey.strip()\n found_hashkey = calculate_md5_external(hashkey_target).strip()\n if found_hashkey != hashkey:\n raise InvenioFileChecksumError(\"Error matching checksum of %s:\"\n \" %s is not equal to %s\" %\n (hashkey_target,\n found_hashkey,\n hashkey))\n validated_files.append(hashkey_target)\n return validated_files","def _md5_of_file(path):\n md5 = hashlib.md5()\n\n with open(path, 'rb') as f:\n for chunk in iter(lambda: f.read(4096), b''):\n md5.update(chunk)\n\n return md5.hexdigest()","def checksum(self):\n hasher = md5()\n with self.open('rb') as fd:\n buf = fd.read(_BLOCKSIZE)\n while len(buf) > 0:\n # TODO Could cancel work here.\n hasher.update(buf)\n buf = fd.read(_BLOCKSIZE)\n digest = safetype(hasher.hexdigest())\n return digest","def md5(fname):\n hash_md5 = hashlib.md5()\n with open(fname, 'rb') as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def _get_file_md5(filename):\n md5_data = md5()\n with open(filename, 'rb') as f:\n for chunk in iter(lambda: f.read(128*md5_data.block_size), b''):\n md5_data.update(chunk)\n return md5_data.hexdigest()","def md5get(filename):\n with open(filename, mode='rb') as f:\n d = hashlib.md5()\n for buf in iter(partial(f.read, 128), b''):\n d.update(buf)\n return d.hexdigest()","def md5file(filename):\n fh = open(filename)\n digest = md5.new()\n while 1:\n buf = fh.read(4096)\n if buf == \"\":\n break\n digest.update(buf)\n fh.close()\n return digest.hexdigest()","def hash_file(fname,bs=M):\n h = hashlib.md5()\n with open(fname,'rb') as f:\n chunk = f.read(bs)\n while chunk:\n h.update(chunk)\n chunk = f.read(bs)\n return h.digest()","def md5(filename: str) -> str:\n # using md5 for speed\n _hash = hashlib.md5()\n # open file for reading in binary mode\n with open(filename,'rb') as file:\n for block in iter(lambda: file.read(1024), b\"\"):\n _hash.update(block)\n return _hash.hexdigest()","def get_md5(filepath):\n md5 = hashlib.md5()\n with open(filepath, 'rb') as f:\n while True:\n data = f.read(BUF_SIZE)\n if not data:\n break\n md5.update(data)\n return md5.hexdigest()","def md5sum_file(filename: str, hr: bool = True) -> str:\n block_size = 256 * 128\n\n md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(block_size), b\"\"):\n md5.update(chunk)\n if hr:\n return md5.hexdigest()\n return md5.digest()","def md5(file_path):\r\n\r\n hasher = hashlib.md5()\r\n with Profiler():\r\n with open(file_path, 'rb') as f:\r\n while True:\r\n buf = f.read(BLOCKSIZE)\r\n if not buf:\r\n break\r\n while len(buf) > 0:\r\n hasher.update(buf)\r\n buf = f.read(BLOCKSIZE)\r\n md5_hash = (hasher.hexdigest()).upper()\r\n return md5_hash","def get_all_hashes(data_dir):\n file_hashes = {}\n for root, dirs, files in os.walk(data_dir):\n for file_name in files:\n file_path = os.path.join(root, file_name)\n file_hashes[file_path] = generate_file_md5(file_path)\n return file_hashes","def md5sum(fileSrc):\n md5 = hashlib.md5()\n try:\n with open(fileSrc, \"rb\") as fd:\n while True:\n content = fd.read(2**20)\n if not content:\n break\n md5.update(content)\n except IOError:\n print(fileSrc + \" Not found\")\n exit(1)\n return md5.hexdigest()","def checksum(self):\n def stat_string(path):\n stat = os.stat(path)\n return '%s,%s' % (str(stat.st_size), str(stat.st_mtime))\n\n return dict((path, stat_string(path))\n for path in self.crawl()\n if os.path.exists(path))","def _hash_file(file: Union[str, Path], md5: Hash) -> Hash:\n if isinstance(file, str) and file.lower().startswith(\"file://\"):\n file = unquote(urlparse(file).path)\n if not Path(file).is_file():\n raise ValueError(str(file) + \" is not a valid file\")\n with open(file, \"rb\") as f:\n while True:\n data = f.read(BUF_SIZE)\n if not data:\n break\n md5.update(data)\n return md5","def md5(self, fileName, excludeLine=\"\", includeLine=\"\"):\n m = hashlib.md5()\n try:\n fd = open(fileName,\"rb\")\n except IOError:\n print \"Unable to open the file in readmode:\", fileName\n return\n eachLine = fd.readline()\n while eachLine:\n if excludeLine and eachLine.startswith(excludeLine):\n continue\n m.update(eachLine)\n eachLine = fd.readline()\n m.update(includeLine)\n fd.close()\n \n return m.hexdigest()","def md5_sum(content):\r\n md5_hash = hashlib.md5(content).hexdigest()\r\n return md5_hash","def calculate_md5(filename, block_size=2**20):\n import hashlib\n\n md5 = hashlib.md5()\n try:\n with open(filename, 'rb') as f:\n while True:\n data = f.read(block_size)\n if not data:\n break\n md5.update(data)\n except IOError:\n print('File \\'' + filename + '\\' not found!')\n return None\n except:\n return None\n return md5.hexdigest()","def fsum(fpath):\n import hashlib\n import codecs\n with codecs.open(fpath, \"r\", \"utf-8\") as filep:\n buff = filep.read()\n cksum = hashlib.md5(buff.encode(\"utf-8\"))\n return cksum.hexdigest()","def get_checksum(filename):\n # You could use popen here. I read about it, and subprocess is meant\n # to replace os.popen, so I used it instead.\n\n # First, run the command md5 sum with filename as input.\n # It's stored as a subprocess.CompletedProcess\n process = subprocess.run(['md5sum',filename], capture_output=True)\n \n # Use the method stdout from subprocess.CompletedProcess (seen in\n # the Python docs) to get the output. As seen in the book, md5sum will\n # output the checksum follwed by the filename. split() will put\n # those two elements into a list, and [0] will take the first element,\n # which will be the checksum.\n checksum = process.stdout.split()[0]\n return checksum","def md5(fname):\n\t\n\thash_md5 = hashlib.md5()\n\twith open(fname, \"rb\") as f:\n\t\tfor chunk in iter(lambda: f.read(4096), b\"\"):\n\t\t\thash_md5.update(chunk)\n\t\n\treturn hash_md5.hexdigest()","def get_file_hash (fullpath) : \n\n # This bit was sourced from Stack Overflow via Google, specifically:\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\n\n md5 = hashlib.md5()\n with open(fullpath,'rb') as f: \n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \n md5.update(chunk)\n # Hexdigest is the safe varchar(32) style output\n return md5.hexdigest()","def md5File(fname):\n if not os.path.isfile(fname):\n fatal('file does not exist: %s' % fname)\n hash_md5 = hashlib.md5()\n with open(fname, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def find_md5checksum(device=None, file_name=None):\n if device is None or file_name is None:\n raise Exception(\"device and file_name are mandatory arguments\")\n\n resp = device.shell(command=\"md5sum \" + file_name).response()\n match = re.search(\"([a-fA-F\\d]{32})\\\\s+\" + file_name +\".*\", resp, re.DOTALL)\n\n if not match:\n device.log(level='ERROR', message=\"Not able to find the checksum\")\n raise Exception(\"Not able to find the checksum\")\n\n md5sum = match.group(1)\n return md5sum","def get_md5(f: BinaryIO) -> str:\n BLOCKSIZE = 65536\n hasher = hashlib.md5()\n buf = f.read(BLOCKSIZE)\n while len(buf) > 0:\n hasher.update(buf)\n buf = f.read(BLOCKSIZE)\n return hasher.hexdigest()","def content_md5(self):\n with self.open() as fileobj:\n return get_content_md5(fileobj)","def get_file_checksum(file_path):\n with open(file_path) as f:\n content = f.read()\n return md5(content.encode()).hexdigest()","def hash_file_md5(file_path, binary=False, buffer_size=65536):\n return hash_file(file_path, hash_type=hashlib.md5, binary=binary, buffer_size=buffer_size)","def md5Hash(pathAndFilename, blockSize=8192):\n hashcode = hashlib.md5()\n with open(pathAndFilename, \"rb\" ) as f:\n block = f.read(blockSize)\n while len(block)>0:\n hashcode.update(block)\n block = f.read(blockSize)\n return hashcode.hexdigest()","def file_md5(file_path):\n log.debug(\"Calculating md5 for %s\", file_path)\n start_ms = time.time() * 10**3\n fp = open(file_path, 'rb')\n try:\n # returns tuple (md5_hex, md5_base64, size)\n md5, _, _ = boto.utils.compute_md5(fp)\n finally:\n fp.close()\n duration_ms = (time.time() * 10**3) - start_ms\n log.debug(\"Calculated hash %s for %s in %s ms\", md5, file_path, \n duration_ms)\n return md5","def md5sum(fname):\n\tdef read_chunks(fh):\n\t\tfh.seek(0)\n\t\tchunk = fh.read(8096)\n\t\twhile chunk:\n\t\t\tyield chunk\n\t\t\tchunk = fh.read(8096)\n\t\telse: #最后要将游标放回文件开头\n\t\t\tfh.seek(0)\n\n\tm = hashlib.md5()\n\tif isinstance(fname, str) and os.path.exists(fname):\n\t\tfh = open(fname, \"rb\")\n\t\tfor chunk in read_chunks(fh):\n\t\t\tm.update(chunk)\n\t#上传的文件缓存或已打开的文件流\n\telif fname.__class__.__name__ in [\"StringIO\", \"StringO\"] or isinstance(fname, file):\n\t\tfor chunk in read_chunks(fname):\n\t\t\tm.update(chunk)\n\telse:\n\t\treturn \"\"\n\treturn m.hexdigest()","def chunkedmd5(filename,csize=8192):\n md5=hashlib.md5()\n with open(filename,'rb') as f:\n for chunk in iter(lambda: f.read(csize), b''):\n md5.update(chunk)\n return md5.digest().encode('hex')","def get_md5sum_file(fullname, blksize=2**15):\n\n md5 = hashlib.md5()\n with open(fullname, 'rb') as fhandle:\n for chunk in iter(lambda: fhandle.read(blksize), b''):\n md5.update(chunk)\n return md5.hexdigest()","def get_md5_hash(file_path: str) -> str:\n from hashlib import md5\n\n # local file\n if file_path.startswith('/'):\n return md5(open(file_path, 'rb').read()).hexdigest()\n\n # remote file\n httpresponse = url_is_alive(file_path)\n if not httpresponse:\n error_open_mess(file_path)\n return ''\n\n md5hash = md5()\n max_file_size = 100 * 1024 * 1024\n total_read = 0\n while True:\n data = httpresponse.read(4096)\n total_read += 4096\n\n if not data or total_read > max_file_size:\n break\n\n md5hash.update(data)\n\n httpresponse.close()\n return md5hash.hexdigest()","def calc_file_hash(filepath):\n with open(filepath, 'rb') as f:\n return md5(f.read()).hexdigest()","def md5(filename: str) -> str:\n hash_md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def GenerateMd5(filename):\n try:\n with open(filename, 'r') as read_file:\n hasher = hashlib.md5()\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\n hasher.update(chunk)\n return hasher.hexdigest()\n except IOError:\n logging.error('Failed to compute md5 checksum for file %s.',\n filename)\n return ''","def get_md5(self, line):\n m = hashlib.md5()\n m.update(str(line).encode('utf-8'))\n return m.hexdigest()","def compute_md5_for_file(file, block_size=2**14):\n f = open(file, 'r')\n md5 = hashlib.md5()\n while True:\n data = f.read(block_size)\n if not data:\n break\n md5.update(data)\n return base64.b64encode(md5.digest())","def file_hash(load, fnd):\n if \"env\" in load:\n # \"env\" is not supported; Use \"saltenv\".\n load.pop(\"env\")\n\n ret = {}\n\n if \"saltenv\" not in load:\n return ret\n\n if \"path\" not in fnd or \"bucket\" not in fnd or not fnd[\"path\"]:\n return ret\n\n cached_file_path = _get_cached_file_name(\n fnd[\"bucket\"], load[\"saltenv\"], fnd[\"path\"]\n )\n\n if os.path.isfile(cached_file_path):\n ret[\"hsum\"] = salt.utils.hashutils.get_hash(cached_file_path)\n ret[\"hash_type\"] = \"md5\"\n\n return ret","def generate_sum(file_path):\n #file = open(file_path, 'rb')\n #header = file.read()\n header = open(file_path, 'rb').read()\n suma_md5 = md5(header).hexdigest()\n return suma_md5","def __md5_for_file(self, filename, num_chunks=None):\n md5 = hashlib.md5()\n with open(filename, 'rb') as f:\n chunk_count = 0\n for chunk in iter(lambda: f.read(8192), ''):\n if (num_chunks is not None) and (num_chunks < chunk_count):\n break\n md5.update(chunk)\n chunk_count += 1\n return md5.hexdigest()","def apkdownloadmirror_get_md5_sum(soup, **_):\n return soup.find(text=re.compile(r'File APK Md5:')).next.text.strip()","def _md5sum(data):\n hash = hashlib.md5()\n hash.update(six.b(data))\n hash_hex = hash.hexdigest()\n return hash_hex","def local_md5(filepath, blocksize=65536):\n hasher = hashlib.md5()\n with open(filepath, 'rb') as source:\n buf = source.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = source.read(blocksize)\n return hasher.hexdigest()","def file_checksum(filename):\n hash_md5 = hashlib.md5()\n with tf.gfile.Open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n f.close()\n return hash_md5.hexdigest()","def md5(filename):\n # see https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file # noqa: E501\n hash_md5 = hashlib.md5()\n with open(filename, \"rb\") as f:\n for chunk in iter(lambda: f.read(1048576), b\"\"):\n hash_md5.update(chunk)\n return hash_md5.hexdigest()","def CheckMd5(filename, md5filename):\n try:\n hasher = hashlib.md5()\n with open(filename) as check_file:\n with open(md5filename) as golden_file:\n for chunk in iter(lambda: check_file.read(128*hasher.block_size), ''):\n hasher.update(chunk)\n md5_contents = golden_file.read()\n if md5_contents:\n golden_digest_and_more = md5_contents.split(' ')\n if golden_digest_and_more:\n return golden_digest_and_more[0] == hasher.hexdigest()\n logging.warning('MD5 checksum match failed for %s', filename)\n return False\n except IOError:\n logging.warning('MD5 hasher read failed for %s', filename)\n return False","def calculate_md5sum_of_a_file(context, file_name, file_path):\n command = \"md5sum \" + file_path + \"/\" + file_name + \" | awk {'print $1'}\"\n return context.cme_session.send_ssh_command(command=command)","def file_digest(file):\n # 'rb' file mode reads the file as bytes\n input_file = open(file, 'rb')\n data = input_file.read()\n # getting the digest\n digest = hash_comparing(data).hexdigest()\n input_file.close()\n return digest","def get_md5_from_hexdigest(self, md5_hexdigest):\r\n import binascii\r\n digest = binascii.unhexlify(md5_hexdigest)\r\n base64md5 = base64.encodestring(digest)\r\n if base64md5[-1] == '\\n':\r\n base64md5 = base64md5[0:-1]\r\n return (md5_hexdigest, base64md5)","def compute_checksum(filename):\n cmd = 'md5sum ' + filename\n return pipe(cmd)","def hash_file(path):\n if not os.path.isfile(path):\n raise ValueError(\"The given path `{}` is not a file.\".format(path))\n\n md5 = hashlib.md5()\n\n with open(path, 'rb') as file_:\n while True:\n data = file_.read(65536)\n if not data:\n break\n md5.update(data)\n\n return \"{}\".format(md5.hexdigest())","def get_md5(data):\n if hasattr(data, \"read\") and hasattr(data, 'seek'):\n data.seek(0)\n m = md5()\n chunk = data.read(1024*1024) # 1Mb\n f_size = 0\n while(chunk):\n f_size += len(chunk)\n m.update(chunk)\n chunk = data.read(1024*1024)\n data.seek(0)\n return m.hexdigest(), f_size\n else: # normal str\n m = md5()\n f_size = len(data)\n m.update(data)\n return m.hexdigest(), f_size","def get_file_hash(file_path):\n with open(file_path, 'rb') as f:\n file_name = os.path.basename(file_path)\n to_hash = f.read() + file_name.encode('utf-8')\n new_hash = hashlib.md5(to_hash).hexdigest()\n return new_hash","def file_field_md5(source_file, blocksize=65536):\n hasher = hashlib.md5()\n if source_file.closed:\n source_file.open('rb')\n buf = source_file.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = source_file.read(blocksize)\n source_file.seek(0)\n return hasher.hexdigest()","def hashFiles(directory):\r\n\tfiledict = {}\r\n\tfor path in getFilePaths(directory):\r\n\t\twith open(path, 'rb') as file:\r\n\t\t\tfiledict[hashlib.md5(file.read()).hexdigest()] = path\r\n\treturn filedict","def get_dockerfile_md5(dockerfile_path):\n valid_lines = list()\n with open(dockerfile_path, \"rb\") as f:\n lines = f.read().decode(\"utf-8\").split(\"\\n\")\n for line in lines:\n line = line.rstrip()\n # ignore comment line\n if line.startswith(\"#\"):\n continue\n # ignore empty line\n if not bool(line):\n continue\n # trim tailing comment\n if \"#\" in line:\n line = line[:-(line[::-1].index(\"#\") + 1)].rstrip()\n if line:\n valid_lines.append(line)\n else:\n valid_lines.append(line)\n md5 = hashlib.md5()\n md5.update(\"\\n\".join(valid_lines).encode(\"utf-8\"))\n return md5.hexdigest()","def MakeMd5(filename, md5filename):\n try:\n with open(filename, 'r') as read_file:\n with open(md5filename, 'w') as hash_file:\n hasher = hashlib.md5()\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\n hasher.update(chunk)\n hash_file.write(hasher.hexdigest())\n return True\n except IOError:\n logging.error('Failed to compute md5 checksum for file %s.',\n filename)\n return False","def calculate(d):\r\n\r\n # Set correct slashes for the OS\r\n if sys.platform == 'windows':\r\n slash = '\\\\'\r\n elif sys.platform == 'linux':\r\n slash = '/'\r\n else:\r\n print('#Error. Unknown platform.')\r\n return\r\n\r\n print('Files in the current directory and their md5-hashes:\\n')\r\n i = 0\r\n assert i == 0, '#Error. Variable i != 0.'\r\n\r\n for i in range(len(d[2])): # Go through the list of files\r\n full_path = d[0]+slash+d[2][i]\r\n print(full_path) # Get the list of files with full paths\r\n print(md5(full_path))\r\n size(full_path)","def hashfile(fname, blocksize=65536):\n hasher = hashlib.md5()\n afile = open(fname, 'rb')\n buf = afile.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(blocksize)\n return hasher.hexdigest()","def md5(filename):\n d = hashlib.md5()\n try:\n d.update(open(filename).read())\n except Exception,e:\n return False\n else:\n return d.hexdigest()","def hashes(cls, dir_path, filenames): \n block_size = 65536\n hasher = hashlib.md5()\n hashes = []\n for filename in filenames:\n try:\n with open(dir_path + '/' + filename, 'rb') as afile:\n buf = afile.read(block_size)\n while len(buf) > 0:\n hasher.update(buf)\n buf = afile.read(block_size)\n hashes.append(hasher.hexdigest())\n except (IOError, Exception):\n hashes.append(None)\n return hashes","def checksum(self, md5_file, file_name):\n try:\n with open(md5_file, 'r') as f:\n md5_file_contents = f.read()\n md5_str = md5_file_contents.split(' ')[0]\n os.remove(md5_file)\n except Exception as e:\n logging.exception('Could not read MD5 file {}. \\\n \\nTry to download the file again'.format(file_name))\n return False\n if not self.check_md5(file_name, md5_str):\n logging.error('Failed in checksum. Download the file again.')\n return False\n return True","def checksum(self, filepath) -> str:\n if os.path.exists(filepath):\n hash_md5 = md5()\n with open(filepath, \"rb\") as f:\n for chunk in iter(lambda: f.read(4096), b\"\"):\n hash_md5.update(chunk)\n return urlsafe_b64encode(hash_md5.digest()).decode('utf-8')\n\n return \"\"","def test_check_md5_crit_md5sum_mismatch(self, mock_generate_md5):\n jdata = b'{\"/etc/swift/object.ring.gz\": ' \\\n b'\"6b4f3a0ef3731f18291ecd053ce0d9b6\", ' \\\n b'\"/etc/swift/account.ring.gz\": ' \\\n b'\"93fc4ae496a7343362ebf13988a137e7\", ' \\\n b'\"/etc/swift/container.ring.gz\": ' \\\n b'\"0ea1ec9585ef644ce2b5c5b1dced4128\"}'\n pmock_jdata = PropertyMock(return_value=jdata)\n mock_generate_md5.return_value = 'xxxx'\n with patch('urllib.request.urlopen') as mock_urlopen:\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\n result = check_md5('.')\n mock_urlopen.assert_called_with('.ringmd5')\n expected_result = [(STATUS_CRIT,\n 'Ringfile /etc/swift/{}.ring.gz '\n 'MD5 sum mismatch'.format(name))\n for name in ('object', 'account', 'container')]\n self.assertEqual(result, expected_result)","def hashfile(file: str, block_size: int = 65536) -> str:\n with open(file, 'rb') as message:\n m = hashlib.sha256()\n block = message.read(block_size)\n while len(block) > 0:\n m.update(block)\n block = message.read(block_size)\n digest = m.hexdigest()\n\n return digest","def getTracksByMD5Sum(self, md5sum):\n return defer.succeed(self._md5sums.get(md5sum, []))","def content_md5(self):\n return get_content_md5(self.open())","def CalculateMd5OfEachFile(self, filedic):\n #for eachfiledic in self.fileTobeUploaded:\n fileobj = open(filedic[\"filepath\"], 'rb')\n buf = fileobj.read()\n hash = hashlib.md5()\n hash.update(buf)\n\n digest = hashlib.md5(buf).digest()\n md5enc = base64.b64encode(digest)\n md5tostr = md5enc.decode('utf-8')\n filedic[\"md5\"] = md5tostr\n fileobj.close()\n\n #pprint.pprint(self.fileTobeUploaded)","def checksum(file):\n\n cksm = hashlib.sha256()\n f = open(file, 'rb')\n try:\n cksm.update(f.read())\n finally:\n f.close()\n return cksm.hexdigest()"],"string":"[\n \"def get_md5_lookup(filename):\\n lookup = {}\\n\\n with open(filename) as f:\\n for row in f:\\n (md5, sha256) = row.strip().split(\\\",\\\")\\n lookup[md5] = sha256\\n\\n return lookup\",\n \"def data_checksum(self, node):\\n cmd = f\\\"find {RedpandaService.DATA_DIR} -type f -exec md5sum '{{}}' \\\\; -exec stat -c %s '{{}}' \\\\;\\\"\\n lines = node.account.ssh_output(cmd)\\n tokens = lines.split()\\n return {\\n tokens[ix + 1].decode(): (tokens[ix].decode(), int(tokens[ix + 2]))\\n for ix in range(0, len(tokens), 3)\\n }\",\n \"def md5sum_file(filepath):\\n hasher = hashlib.md5()\\n with open(filepath, 'rb') as infile:\\n for chunk in util.chunk_reader(infile):\\n hasher.update(chunk)\\n return hasher.hexdigest()\",\n \"def md5_checksum(file_path):\\n with open(file_path, 'rb') as fh:\\n m = hashlib.md5()\\n while True:\\n data = fh.read(8192)\\n if not data:\\n break\\n m.update(data)\\n return m.hexdigest()\",\n \"def md5sum(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def checksumFile(filename):\\n return md5File(filename)\",\n \"def GetFileMd5(file_path):\\n return binascii.hexlify(GetFileHashes(file_path, do_md5=True)['md5'])\",\n \"def count_md5hash_file(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5sum(file_name):\\n f = open(file_name, mode='rb')\\n h = hashlib.md5()\\n h.update(f.read())\\n return h.hexdigest()\",\n \"def CalcMD5(filepath):\\n with open(filepath,'rb') as f:\\n md5obj = hashlib.md5()\\n md5obj.update(f.read())\\n return md5obj.hexdigest()\",\n \"def md5_sum_file(path):\\n with open(path, 'rb') as f:\\n m = hashlib.md5()\\n while True:\\n data = f.read(8192)\\n if not data:\\n break\\n m.update(data)\\n return m.hexdigest()\",\n \"def md5checksum(file_name):\\n from hashlib import md5\\n hash_md5 = md5()\\n with open(file_name, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(32768), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5_hash(file_path):\\n with open(file_path, 'rb') as fp:\\n return md5(fp.read()).hexdigest()\",\n \"def checksum(path):\\n with open(path, 'r') as f:\\n return md5(f.read()).digest()\",\n \"def md5(path):\\n with open(path, 'rb') as f:\\n md5hash = hashlib.md5()\\n for chunk in iter(lambda: f.read(4096), b''):\\n md5hash.update(chunk)\\n return md5hash.hexdigest()\",\n \"def get_contents_hash(self):\\n md5 = hashlib.md5()\\n with closing(self.open()) as handle:\\n for chunk in handle.chunks():\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def readfile(self, filename):\\n \\n f = file(filename,'rb');\\n #print \\\"\\\\nReading %s \\\\n\\\" % f.name;\\n m = md5.new();\\n readBytes = 1024; # read 1024 bytes per time\\n totalBytes = 0;\\n while (readBytes):\\n readString = f.read(readBytes);\\n m.update(readString);\\n readBytes = len(readString);\\n totalBytes+=readBytes;\\n f.close();\\n \\n return m.hexdigest()\",\n \"def get_checksum(input_fname):\\n with open(input_fname, \\\"rb\\\") as infile:\\n file_contents = infile.read()\\n\\n checksum = hashlib.md5(file_contents).hexdigest()\\n return checksum\",\n \"def calc_md5(infile, block_size=256*128):\\n logger = logging.getLogger(__name__)\\n logger.info(f'Calculating md5 of {infile}')\\n md5 = hashlib.md5()\\n with open(infile, 'rb') as f:\\n for chunk in iter(lambda: f.read(block_size), b''):\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def GetFileHashes(file_path, do_sha1=False, do_sha256=False, do_md5=False):\\n hashes = {}\\n if (do_sha1 or do_sha256 or do_md5):\\n # Initialize hashers.\\n hasher_sha1 = hashlib.sha1() if do_sha1 else None\\n hasher_sha256 = hashlib.sha256() if do_sha256 else None\\n hasher_md5 = hashlib.md5() if do_md5 else None\\n\\n # Read blocks from file, update hashes.\\n with open(file_path, 'rb') as fd:\\n while True:\\n block = fd.read(_HASH_BLOCK_SIZE)\\n if not block:\\n break\\n hasher_sha1 and hasher_sha1.update(block)\\n hasher_sha256 and hasher_sha256.update(block)\\n hasher_md5 and hasher_md5.update(block)\\n\\n # Update return values.\\n if hasher_sha1:\\n hashes['sha1'] = hasher_sha1.digest()\\n if hasher_sha256:\\n hashes['sha256'] = hasher_sha256.digest()\\n if hasher_md5:\\n hashes['md5'] = hasher_md5.digest()\\n\\n return hashes\",\n \"def _load_md5s(self) -> None:\\n self._md5s = {}\\n path = os.path.join(self.path, \\\".fairly_md5\\\")\\n try:\\n with open(path, \\\"r\\\") as file:\\n reader = csv.reader(file)\\n for name, date, size, md5 in reader:\\n self._md5s[name] = (date, size, md5)\\n except FileNotFoundError:\\n pass\",\n \"def md5sum(filename):\\n with open(filename, mode='rb') as f:\\n d = hashlib.md5()\\n for buf in iter(functools.partial(f.read, 1024*100), b''):\\n d.update(buf)\\n return d.hexdigest()\",\n \"def md5(fname):\\n hash = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash.update(chunk)\\n return hash.hexdigest()\",\n \"def calc_file_md5(file_path):\\n hash_md5 = str()\\n method = hashlib.md5()\\n if not os.path.exists(file_path):\\n logger.error(\\\"File(%s) don not exist, can not calculation file hash\\\" % file_path)\\n return hash_md5\\n\\n with open(file_path, 'rb') as f:\\n for chunk in read_chunks(f, 1024 * 1024):\\n method.update(chunk)\\n return method.hexdigest()\",\n \"def md5(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(4096), b''):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5(file_path):\\n hash_md5 = hashlib.md5()\\n with open(file_path, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(4096), b''):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def hash_file(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def md5_hash_file(filepath: str) -> str:\\n block_size = 64 * 1024\\n md5 = hashlib.md5()\\n with open(filepath, \\\"rb\\\") as file_handler:\\n while True:\\n data = file_handler.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n return md5.hexdigest()\",\n \"def find_and_validate_md5_checksums(in_folder, md5key_filename):\\n validated_files = []\\n for filename in locate(md5key_filename, root=in_folder):\\n file_fd = open(filename, 'r')\\n contents = file_fd.readlines()\\n for line in contents:\\n split_line = line.split(' ')\\n if len(split_line) == 2:\\n hashkey, hashkey_target = split_line\\n hashkey_target = os.path.join(os.path.dirname(filename),\\n hashkey_target.strip())\\n hashkey = hashkey.strip()\\n found_hashkey = calculate_md5_external(hashkey_target).strip()\\n if found_hashkey != hashkey:\\n raise InvenioFileChecksumError(\\\"Error matching checksum of %s:\\\"\\n \\\" %s is not equal to %s\\\" %\\n (hashkey_target,\\n found_hashkey,\\n hashkey))\\n validated_files.append(hashkey_target)\\n return validated_files\",\n \"def _md5_of_file(path):\\n md5 = hashlib.md5()\\n\\n with open(path, 'rb') as f:\\n for chunk in iter(lambda: f.read(4096), b''):\\n md5.update(chunk)\\n\\n return md5.hexdigest()\",\n \"def checksum(self):\\n hasher = md5()\\n with self.open('rb') as fd:\\n buf = fd.read(_BLOCKSIZE)\\n while len(buf) > 0:\\n # TODO Could cancel work here.\\n hasher.update(buf)\\n buf = fd.read(_BLOCKSIZE)\\n digest = safetype(hasher.hexdigest())\\n return digest\",\n \"def md5(fname):\\n hash_md5 = hashlib.md5()\\n with open(fname, 'rb') as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def _get_file_md5(filename):\\n md5_data = md5()\\n with open(filename, 'rb') as f:\\n for chunk in iter(lambda: f.read(128*md5_data.block_size), b''):\\n md5_data.update(chunk)\\n return md5_data.hexdigest()\",\n \"def md5get(filename):\\n with open(filename, mode='rb') as f:\\n d = hashlib.md5()\\n for buf in iter(partial(f.read, 128), b''):\\n d.update(buf)\\n return d.hexdigest()\",\n \"def md5file(filename):\\n fh = open(filename)\\n digest = md5.new()\\n while 1:\\n buf = fh.read(4096)\\n if buf == \\\"\\\":\\n break\\n digest.update(buf)\\n fh.close()\\n return digest.hexdigest()\",\n \"def hash_file(fname,bs=M):\\n h = hashlib.md5()\\n with open(fname,'rb') as f:\\n chunk = f.read(bs)\\n while chunk:\\n h.update(chunk)\\n chunk = f.read(bs)\\n return h.digest()\",\n \"def md5(filename: str) -> str:\\n # using md5 for speed\\n _hash = hashlib.md5()\\n # open file for reading in binary mode\\n with open(filename,'rb') as file:\\n for block in iter(lambda: file.read(1024), b\\\"\\\"):\\n _hash.update(block)\\n return _hash.hexdigest()\",\n \"def get_md5(filepath):\\n md5 = hashlib.md5()\\n with open(filepath, 'rb') as f:\\n while True:\\n data = f.read(BUF_SIZE)\\n if not data:\\n break\\n md5.update(data)\\n return md5.hexdigest()\",\n \"def md5sum_file(filename: str, hr: bool = True) -> str:\\n block_size = 256 * 128\\n\\n md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(block_size), b\\\"\\\"):\\n md5.update(chunk)\\n if hr:\\n return md5.hexdigest()\\n return md5.digest()\",\n \"def md5(file_path):\\r\\n\\r\\n hasher = hashlib.md5()\\r\\n with Profiler():\\r\\n with open(file_path, 'rb') as f:\\r\\n while True:\\r\\n buf = f.read(BLOCKSIZE)\\r\\n if not buf:\\r\\n break\\r\\n while len(buf) > 0:\\r\\n hasher.update(buf)\\r\\n buf = f.read(BLOCKSIZE)\\r\\n md5_hash = (hasher.hexdigest()).upper()\\r\\n return md5_hash\",\n \"def get_all_hashes(data_dir):\\n file_hashes = {}\\n for root, dirs, files in os.walk(data_dir):\\n for file_name in files:\\n file_path = os.path.join(root, file_name)\\n file_hashes[file_path] = generate_file_md5(file_path)\\n return file_hashes\",\n \"def md5sum(fileSrc):\\n md5 = hashlib.md5()\\n try:\\n with open(fileSrc, \\\"rb\\\") as fd:\\n while True:\\n content = fd.read(2**20)\\n if not content:\\n break\\n md5.update(content)\\n except IOError:\\n print(fileSrc + \\\" Not found\\\")\\n exit(1)\\n return md5.hexdigest()\",\n \"def checksum(self):\\n def stat_string(path):\\n stat = os.stat(path)\\n return '%s,%s' % (str(stat.st_size), str(stat.st_mtime))\\n\\n return dict((path, stat_string(path))\\n for path in self.crawl()\\n if os.path.exists(path))\",\n \"def _hash_file(file: Union[str, Path], md5: Hash) -> Hash:\\n if isinstance(file, str) and file.lower().startswith(\\\"file://\\\"):\\n file = unquote(urlparse(file).path)\\n if not Path(file).is_file():\\n raise ValueError(str(file) + \\\" is not a valid file\\\")\\n with open(file, \\\"rb\\\") as f:\\n while True:\\n data = f.read(BUF_SIZE)\\n if not data:\\n break\\n md5.update(data)\\n return md5\",\n \"def md5(self, fileName, excludeLine=\\\"\\\", includeLine=\\\"\\\"):\\n m = hashlib.md5()\\n try:\\n fd = open(fileName,\\\"rb\\\")\\n except IOError:\\n print \\\"Unable to open the file in readmode:\\\", fileName\\n return\\n eachLine = fd.readline()\\n while eachLine:\\n if excludeLine and eachLine.startswith(excludeLine):\\n continue\\n m.update(eachLine)\\n eachLine = fd.readline()\\n m.update(includeLine)\\n fd.close()\\n \\n return m.hexdigest()\",\n \"def md5_sum(content):\\r\\n md5_hash = hashlib.md5(content).hexdigest()\\r\\n return md5_hash\",\n \"def calculate_md5(filename, block_size=2**20):\\n import hashlib\\n\\n md5 = hashlib.md5()\\n try:\\n with open(filename, 'rb') as f:\\n while True:\\n data = f.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n except IOError:\\n print('File \\\\'' + filename + '\\\\' not found!')\\n return None\\n except:\\n return None\\n return md5.hexdigest()\",\n \"def fsum(fpath):\\n import hashlib\\n import codecs\\n with codecs.open(fpath, \\\"r\\\", \\\"utf-8\\\") as filep:\\n buff = filep.read()\\n cksum = hashlib.md5(buff.encode(\\\"utf-8\\\"))\\n return cksum.hexdigest()\",\n \"def get_checksum(filename):\\n # You could use popen here. I read about it, and subprocess is meant\\n # to replace os.popen, so I used it instead.\\n\\n # First, run the command md5 sum with filename as input.\\n # It's stored as a subprocess.CompletedProcess\\n process = subprocess.run(['md5sum',filename], capture_output=True)\\n \\n # Use the method stdout from subprocess.CompletedProcess (seen in\\n # the Python docs) to get the output. As seen in the book, md5sum will\\n # output the checksum follwed by the filename. split() will put\\n # those two elements into a list, and [0] will take the first element,\\n # which will be the checksum.\\n checksum = process.stdout.split()[0]\\n return checksum\",\n \"def md5(fname):\\n\\t\\n\\thash_md5 = hashlib.md5()\\n\\twith open(fname, \\\"rb\\\") as f:\\n\\t\\tfor chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n\\t\\t\\thash_md5.update(chunk)\\n\\t\\n\\treturn hash_md5.hexdigest()\",\n \"def get_file_hash (fullpath) : \\n\\n # This bit was sourced from Stack Overflow via Google, specifically:\\n # http://stackoverflow.com/questions/1131220/get-md5-hash-of-a-files-without-open-it-in-python\\n\\n md5 = hashlib.md5()\\n with open(fullpath,'rb') as f: \\n for chunk in iter(lambda: f.read(512*md5.block_size), ''): \\n md5.update(chunk)\\n # Hexdigest is the safe varchar(32) style output\\n return md5.hexdigest()\",\n \"def md5File(fname):\\n if not os.path.isfile(fname):\\n fatal('file does not exist: %s' % fname)\\n hash_md5 = hashlib.md5()\\n with open(fname, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def find_md5checksum(device=None, file_name=None):\\n if device is None or file_name is None:\\n raise Exception(\\\"device and file_name are mandatory arguments\\\")\\n\\n resp = device.shell(command=\\\"md5sum \\\" + file_name).response()\\n match = re.search(\\\"([a-fA-F\\\\d]{32})\\\\\\\\s+\\\" + file_name +\\\".*\\\", resp, re.DOTALL)\\n\\n if not match:\\n device.log(level='ERROR', message=\\\"Not able to find the checksum\\\")\\n raise Exception(\\\"Not able to find the checksum\\\")\\n\\n md5sum = match.group(1)\\n return md5sum\",\n \"def get_md5(f: BinaryIO) -> str:\\n BLOCKSIZE = 65536\\n hasher = hashlib.md5()\\n buf = f.read(BLOCKSIZE)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = f.read(BLOCKSIZE)\\n return hasher.hexdigest()\",\n \"def content_md5(self):\\n with self.open() as fileobj:\\n return get_content_md5(fileobj)\",\n \"def get_file_checksum(file_path):\\n with open(file_path) as f:\\n content = f.read()\\n return md5(content.encode()).hexdigest()\",\n \"def hash_file_md5(file_path, binary=False, buffer_size=65536):\\n return hash_file(file_path, hash_type=hashlib.md5, binary=binary, buffer_size=buffer_size)\",\n \"def md5Hash(pathAndFilename, blockSize=8192):\\n hashcode = hashlib.md5()\\n with open(pathAndFilename, \\\"rb\\\" ) as f:\\n block = f.read(blockSize)\\n while len(block)>0:\\n hashcode.update(block)\\n block = f.read(blockSize)\\n return hashcode.hexdigest()\",\n \"def file_md5(file_path):\\n log.debug(\\\"Calculating md5 for %s\\\", file_path)\\n start_ms = time.time() * 10**3\\n fp = open(file_path, 'rb')\\n try:\\n # returns tuple (md5_hex, md5_base64, size)\\n md5, _, _ = boto.utils.compute_md5(fp)\\n finally:\\n fp.close()\\n duration_ms = (time.time() * 10**3) - start_ms\\n log.debug(\\\"Calculated hash %s for %s in %s ms\\\", md5, file_path, \\n duration_ms)\\n return md5\",\n \"def md5sum(fname):\\n\\tdef read_chunks(fh):\\n\\t\\tfh.seek(0)\\n\\t\\tchunk = fh.read(8096)\\n\\t\\twhile chunk:\\n\\t\\t\\tyield chunk\\n\\t\\t\\tchunk = fh.read(8096)\\n\\t\\telse: #最后要将游标放回文件开头\\n\\t\\t\\tfh.seek(0)\\n\\n\\tm = hashlib.md5()\\n\\tif isinstance(fname, str) and os.path.exists(fname):\\n\\t\\tfh = open(fname, \\\"rb\\\")\\n\\t\\tfor chunk in read_chunks(fh):\\n\\t\\t\\tm.update(chunk)\\n\\t#上传的文件缓存或已打开的文件流\\n\\telif fname.__class__.__name__ in [\\\"StringIO\\\", \\\"StringO\\\"] or isinstance(fname, file):\\n\\t\\tfor chunk in read_chunks(fname):\\n\\t\\t\\tm.update(chunk)\\n\\telse:\\n\\t\\treturn \\\"\\\"\\n\\treturn m.hexdigest()\",\n \"def chunkedmd5(filename,csize=8192):\\n md5=hashlib.md5()\\n with open(filename,'rb') as f:\\n for chunk in iter(lambda: f.read(csize), b''):\\n md5.update(chunk)\\n return md5.digest().encode('hex')\",\n \"def get_md5sum_file(fullname, blksize=2**15):\\n\\n md5 = hashlib.md5()\\n with open(fullname, 'rb') as fhandle:\\n for chunk in iter(lambda: fhandle.read(blksize), b''):\\n md5.update(chunk)\\n return md5.hexdigest()\",\n \"def get_md5_hash(file_path: str) -> str:\\n from hashlib import md5\\n\\n # local file\\n if file_path.startswith('/'):\\n return md5(open(file_path, 'rb').read()).hexdigest()\\n\\n # remote file\\n httpresponse = url_is_alive(file_path)\\n if not httpresponse:\\n error_open_mess(file_path)\\n return ''\\n\\n md5hash = md5()\\n max_file_size = 100 * 1024 * 1024\\n total_read = 0\\n while True:\\n data = httpresponse.read(4096)\\n total_read += 4096\\n\\n if not data or total_read > max_file_size:\\n break\\n\\n md5hash.update(data)\\n\\n httpresponse.close()\\n return md5hash.hexdigest()\",\n \"def calc_file_hash(filepath):\\n with open(filepath, 'rb') as f:\\n return md5(f.read()).hexdigest()\",\n \"def md5(filename: str) -> str:\\n hash_md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def GenerateMd5(filename):\\n try:\\n with open(filename, 'r') as read_file:\\n hasher = hashlib.md5()\\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\\n hasher.update(chunk)\\n return hasher.hexdigest()\\n except IOError:\\n logging.error('Failed to compute md5 checksum for file %s.',\\n filename)\\n return ''\",\n \"def get_md5(self, line):\\n m = hashlib.md5()\\n m.update(str(line).encode('utf-8'))\\n return m.hexdigest()\",\n \"def compute_md5_for_file(file, block_size=2**14):\\n f = open(file, 'r')\\n md5 = hashlib.md5()\\n while True:\\n data = f.read(block_size)\\n if not data:\\n break\\n md5.update(data)\\n return base64.b64encode(md5.digest())\",\n \"def file_hash(load, fnd):\\n if \\\"env\\\" in load:\\n # \\\"env\\\" is not supported; Use \\\"saltenv\\\".\\n load.pop(\\\"env\\\")\\n\\n ret = {}\\n\\n if \\\"saltenv\\\" not in load:\\n return ret\\n\\n if \\\"path\\\" not in fnd or \\\"bucket\\\" not in fnd or not fnd[\\\"path\\\"]:\\n return ret\\n\\n cached_file_path = _get_cached_file_name(\\n fnd[\\\"bucket\\\"], load[\\\"saltenv\\\"], fnd[\\\"path\\\"]\\n )\\n\\n if os.path.isfile(cached_file_path):\\n ret[\\\"hsum\\\"] = salt.utils.hashutils.get_hash(cached_file_path)\\n ret[\\\"hash_type\\\"] = \\\"md5\\\"\\n\\n return ret\",\n \"def generate_sum(file_path):\\n #file = open(file_path, 'rb')\\n #header = file.read()\\n header = open(file_path, 'rb').read()\\n suma_md5 = md5(header).hexdigest()\\n return suma_md5\",\n \"def __md5_for_file(self, filename, num_chunks=None):\\n md5 = hashlib.md5()\\n with open(filename, 'rb') as f:\\n chunk_count = 0\\n for chunk in iter(lambda: f.read(8192), ''):\\n if (num_chunks is not None) and (num_chunks < chunk_count):\\n break\\n md5.update(chunk)\\n chunk_count += 1\\n return md5.hexdigest()\",\n \"def apkdownloadmirror_get_md5_sum(soup, **_):\\n return soup.find(text=re.compile(r'File APK Md5:')).next.text.strip()\",\n \"def _md5sum(data):\\n hash = hashlib.md5()\\n hash.update(six.b(data))\\n hash_hex = hash.hexdigest()\\n return hash_hex\",\n \"def local_md5(filepath, blocksize=65536):\\n hasher = hashlib.md5()\\n with open(filepath, 'rb') as source:\\n buf = source.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = source.read(blocksize)\\n return hasher.hexdigest()\",\n \"def file_checksum(filename):\\n hash_md5 = hashlib.md5()\\n with tf.gfile.Open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n f.close()\\n return hash_md5.hexdigest()\",\n \"def md5(filename):\\n # see https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file # noqa: E501\\n hash_md5 = hashlib.md5()\\n with open(filename, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(1048576), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return hash_md5.hexdigest()\",\n \"def CheckMd5(filename, md5filename):\\n try:\\n hasher = hashlib.md5()\\n with open(filename) as check_file:\\n with open(md5filename) as golden_file:\\n for chunk in iter(lambda: check_file.read(128*hasher.block_size), ''):\\n hasher.update(chunk)\\n md5_contents = golden_file.read()\\n if md5_contents:\\n golden_digest_and_more = md5_contents.split(' ')\\n if golden_digest_and_more:\\n return golden_digest_and_more[0] == hasher.hexdigest()\\n logging.warning('MD5 checksum match failed for %s', filename)\\n return False\\n except IOError:\\n logging.warning('MD5 hasher read failed for %s', filename)\\n return False\",\n \"def calculate_md5sum_of_a_file(context, file_name, file_path):\\n command = \\\"md5sum \\\" + file_path + \\\"/\\\" + file_name + \\\" | awk {'print $1'}\\\"\\n return context.cme_session.send_ssh_command(command=command)\",\n \"def file_digest(file):\\n # 'rb' file mode reads the file as bytes\\n input_file = open(file, 'rb')\\n data = input_file.read()\\n # getting the digest\\n digest = hash_comparing(data).hexdigest()\\n input_file.close()\\n return digest\",\n \"def get_md5_from_hexdigest(self, md5_hexdigest):\\r\\n import binascii\\r\\n digest = binascii.unhexlify(md5_hexdigest)\\r\\n base64md5 = base64.encodestring(digest)\\r\\n if base64md5[-1] == '\\\\n':\\r\\n base64md5 = base64md5[0:-1]\\r\\n return (md5_hexdigest, base64md5)\",\n \"def compute_checksum(filename):\\n cmd = 'md5sum ' + filename\\n return pipe(cmd)\",\n \"def hash_file(path):\\n if not os.path.isfile(path):\\n raise ValueError(\\\"The given path `{}` is not a file.\\\".format(path))\\n\\n md5 = hashlib.md5()\\n\\n with open(path, 'rb') as file_:\\n while True:\\n data = file_.read(65536)\\n if not data:\\n break\\n md5.update(data)\\n\\n return \\\"{}\\\".format(md5.hexdigest())\",\n \"def get_md5(data):\\n if hasattr(data, \\\"read\\\") and hasattr(data, 'seek'):\\n data.seek(0)\\n m = md5()\\n chunk = data.read(1024*1024) # 1Mb\\n f_size = 0\\n while(chunk):\\n f_size += len(chunk)\\n m.update(chunk)\\n chunk = data.read(1024*1024)\\n data.seek(0)\\n return m.hexdigest(), f_size\\n else: # normal str\\n m = md5()\\n f_size = len(data)\\n m.update(data)\\n return m.hexdigest(), f_size\",\n \"def get_file_hash(file_path):\\n with open(file_path, 'rb') as f:\\n file_name = os.path.basename(file_path)\\n to_hash = f.read() + file_name.encode('utf-8')\\n new_hash = hashlib.md5(to_hash).hexdigest()\\n return new_hash\",\n \"def file_field_md5(source_file, blocksize=65536):\\n hasher = hashlib.md5()\\n if source_file.closed:\\n source_file.open('rb')\\n buf = source_file.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = source_file.read(blocksize)\\n source_file.seek(0)\\n return hasher.hexdigest()\",\n \"def hashFiles(directory):\\r\\n\\tfiledict = {}\\r\\n\\tfor path in getFilePaths(directory):\\r\\n\\t\\twith open(path, 'rb') as file:\\r\\n\\t\\t\\tfiledict[hashlib.md5(file.read()).hexdigest()] = path\\r\\n\\treturn filedict\",\n \"def get_dockerfile_md5(dockerfile_path):\\n valid_lines = list()\\n with open(dockerfile_path, \\\"rb\\\") as f:\\n lines = f.read().decode(\\\"utf-8\\\").split(\\\"\\\\n\\\")\\n for line in lines:\\n line = line.rstrip()\\n # ignore comment line\\n if line.startswith(\\\"#\\\"):\\n continue\\n # ignore empty line\\n if not bool(line):\\n continue\\n # trim tailing comment\\n if \\\"#\\\" in line:\\n line = line[:-(line[::-1].index(\\\"#\\\") + 1)].rstrip()\\n if line:\\n valid_lines.append(line)\\n else:\\n valid_lines.append(line)\\n md5 = hashlib.md5()\\n md5.update(\\\"\\\\n\\\".join(valid_lines).encode(\\\"utf-8\\\"))\\n return md5.hexdigest()\",\n \"def MakeMd5(filename, md5filename):\\n try:\\n with open(filename, 'r') as read_file:\\n with open(md5filename, 'w') as hash_file:\\n hasher = hashlib.md5()\\n for chunk in iter(lambda: read_file.read(128*hasher.block_size), ''):\\n hasher.update(chunk)\\n hash_file.write(hasher.hexdigest())\\n return True\\n except IOError:\\n logging.error('Failed to compute md5 checksum for file %s.',\\n filename)\\n return False\",\n \"def calculate(d):\\r\\n\\r\\n # Set correct slashes for the OS\\r\\n if sys.platform == 'windows':\\r\\n slash = '\\\\\\\\'\\r\\n elif sys.platform == 'linux':\\r\\n slash = '/'\\r\\n else:\\r\\n print('#Error. Unknown platform.')\\r\\n return\\r\\n\\r\\n print('Files in the current directory and their md5-hashes:\\\\n')\\r\\n i = 0\\r\\n assert i == 0, '#Error. Variable i != 0.'\\r\\n\\r\\n for i in range(len(d[2])): # Go through the list of files\\r\\n full_path = d[0]+slash+d[2][i]\\r\\n print(full_path) # Get the list of files with full paths\\r\\n print(md5(full_path))\\r\\n size(full_path)\",\n \"def hashfile(fname, blocksize=65536):\\n hasher = hashlib.md5()\\n afile = open(fname, 'rb')\\n buf = afile.read(blocksize)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(blocksize)\\n return hasher.hexdigest()\",\n \"def md5(filename):\\n d = hashlib.md5()\\n try:\\n d.update(open(filename).read())\\n except Exception,e:\\n return False\\n else:\\n return d.hexdigest()\",\n \"def hashes(cls, dir_path, filenames): \\n block_size = 65536\\n hasher = hashlib.md5()\\n hashes = []\\n for filename in filenames:\\n try:\\n with open(dir_path + '/' + filename, 'rb') as afile:\\n buf = afile.read(block_size)\\n while len(buf) > 0:\\n hasher.update(buf)\\n buf = afile.read(block_size)\\n hashes.append(hasher.hexdigest())\\n except (IOError, Exception):\\n hashes.append(None)\\n return hashes\",\n \"def checksum(self, md5_file, file_name):\\n try:\\n with open(md5_file, 'r') as f:\\n md5_file_contents = f.read()\\n md5_str = md5_file_contents.split(' ')[0]\\n os.remove(md5_file)\\n except Exception as e:\\n logging.exception('Could not read MD5 file {}. \\\\\\n \\\\nTry to download the file again'.format(file_name))\\n return False\\n if not self.check_md5(file_name, md5_str):\\n logging.error('Failed in checksum. Download the file again.')\\n return False\\n return True\",\n \"def checksum(self, filepath) -> str:\\n if os.path.exists(filepath):\\n hash_md5 = md5()\\n with open(filepath, \\\"rb\\\") as f:\\n for chunk in iter(lambda: f.read(4096), b\\\"\\\"):\\n hash_md5.update(chunk)\\n return urlsafe_b64encode(hash_md5.digest()).decode('utf-8')\\n\\n return \\\"\\\"\",\n \"def test_check_md5_crit_md5sum_mismatch(self, mock_generate_md5):\\n jdata = b'{\\\"/etc/swift/object.ring.gz\\\": ' \\\\\\n b'\\\"6b4f3a0ef3731f18291ecd053ce0d9b6\\\", ' \\\\\\n b'\\\"/etc/swift/account.ring.gz\\\": ' \\\\\\n b'\\\"93fc4ae496a7343362ebf13988a137e7\\\", ' \\\\\\n b'\\\"/etc/swift/container.ring.gz\\\": ' \\\\\\n b'\\\"0ea1ec9585ef644ce2b5c5b1dced4128\\\"}'\\n pmock_jdata = PropertyMock(return_value=jdata)\\n mock_generate_md5.return_value = 'xxxx'\\n with patch('urllib.request.urlopen') as mock_urlopen:\\n mock_urlopen.return_value = MagicMock(read=pmock_jdata)\\n result = check_md5('.')\\n mock_urlopen.assert_called_with('.ringmd5')\\n expected_result = [(STATUS_CRIT,\\n 'Ringfile /etc/swift/{}.ring.gz '\\n 'MD5 sum mismatch'.format(name))\\n for name in ('object', 'account', 'container')]\\n self.assertEqual(result, expected_result)\",\n \"def hashfile(file: str, block_size: int = 65536) -> str:\\n with open(file, 'rb') as message:\\n m = hashlib.sha256()\\n block = message.read(block_size)\\n while len(block) > 0:\\n m.update(block)\\n block = message.read(block_size)\\n digest = m.hexdigest()\\n\\n return digest\",\n \"def getTracksByMD5Sum(self, md5sum):\\n return defer.succeed(self._md5sums.get(md5sum, []))\",\n \"def content_md5(self):\\n return get_content_md5(self.open())\",\n \"def CalculateMd5OfEachFile(self, filedic):\\n #for eachfiledic in self.fileTobeUploaded:\\n fileobj = open(filedic[\\\"filepath\\\"], 'rb')\\n buf = fileobj.read()\\n hash = hashlib.md5()\\n hash.update(buf)\\n\\n digest = hashlib.md5(buf).digest()\\n md5enc = base64.b64encode(digest)\\n md5tostr = md5enc.decode('utf-8')\\n filedic[\\\"md5\\\"] = md5tostr\\n fileobj.close()\\n\\n #pprint.pprint(self.fileTobeUploaded)\",\n \"def checksum(file):\\n\\n cksm = hashlib.sha256()\\n f = open(file, 'rb')\\n try:\\n cksm.update(f.read())\\n finally:\\n f.close()\\n return cksm.hexdigest()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6960468","0.6812591","0.6801497","0.6614257","0.6598387","0.6572755","0.65507716","0.6542189","0.6502235","0.64885104","0.6479202","0.646785","0.6450681","0.6447718","0.64337075","0.640807","0.6402168","0.63971865","0.6393921","0.6386618","0.63784134","0.6374899","0.63717973","0.635859","0.6349585","0.6349585","0.631881","0.6306003","0.62603986","0.6259556","0.62429076","0.62320876","0.6220352","0.6203429","0.6191736","0.6168949","0.61633486","0.61605316","0.61600375","0.6153642","0.6150285","0.6143058","0.6138846","0.61251533","0.61167127","0.610117","0.610042","0.60988057","0.60810083","0.60751843","0.60689646","0.60684043","0.6042885","0.60413086","0.60394394","0.60329914","0.60225314","0.6016823","0.6014221","0.60077614","0.6004126","0.60030556","0.59847426","0.59837425","0.5955022","0.59532595","0.5949767","0.59325105","0.5926143","0.59246475","0.5923554","0.58719254","0.58718026","0.58707184","0.58669484","0.58635396","0.5827972","0.5825308","0.58106965","0.5798845","0.57875365","0.57799757","0.5776864","0.576488","0.5762498","0.57610905","0.57535714","0.5748513","0.5727051","0.57267326","0.5722806","0.5704894","0.56923276","0.5673192","0.56649166","0.5659682","0.5658156","0.5640848","0.56395495","0.5631491"],"string":"[\n \"0.6960468\",\n \"0.6812591\",\n \"0.6801497\",\n \"0.6614257\",\n \"0.6598387\",\n \"0.6572755\",\n \"0.65507716\",\n \"0.6542189\",\n \"0.6502235\",\n \"0.64885104\",\n \"0.6479202\",\n \"0.646785\",\n \"0.6450681\",\n \"0.6447718\",\n \"0.64337075\",\n \"0.640807\",\n \"0.6402168\",\n \"0.63971865\",\n \"0.6393921\",\n \"0.6386618\",\n \"0.63784134\",\n \"0.6374899\",\n \"0.63717973\",\n \"0.635859\",\n \"0.6349585\",\n \"0.6349585\",\n \"0.631881\",\n \"0.6306003\",\n \"0.62603986\",\n \"0.6259556\",\n \"0.62429076\",\n \"0.62320876\",\n \"0.6220352\",\n \"0.6203429\",\n \"0.6191736\",\n \"0.6168949\",\n \"0.61633486\",\n \"0.61605316\",\n \"0.61600375\",\n \"0.6153642\",\n \"0.6150285\",\n \"0.6143058\",\n \"0.6138846\",\n \"0.61251533\",\n \"0.61167127\",\n \"0.610117\",\n \"0.610042\",\n \"0.60988057\",\n \"0.60810083\",\n \"0.60751843\",\n \"0.60689646\",\n \"0.60684043\",\n \"0.6042885\",\n \"0.60413086\",\n \"0.60394394\",\n \"0.60329914\",\n \"0.60225314\",\n \"0.6016823\",\n \"0.6014221\",\n \"0.60077614\",\n \"0.6004126\",\n \"0.60030556\",\n \"0.59847426\",\n \"0.59837425\",\n \"0.5955022\",\n \"0.59532595\",\n \"0.5949767\",\n \"0.59325105\",\n \"0.5926143\",\n \"0.59246475\",\n \"0.5923554\",\n \"0.58719254\",\n \"0.58718026\",\n \"0.58707184\",\n \"0.58669484\",\n \"0.58635396\",\n \"0.5827972\",\n \"0.5825308\",\n \"0.58106965\",\n \"0.5798845\",\n \"0.57875365\",\n \"0.57799757\",\n \"0.5776864\",\n \"0.576488\",\n \"0.5762498\",\n \"0.57610905\",\n \"0.57535714\",\n \"0.5748513\",\n \"0.5727051\",\n \"0.57267326\",\n \"0.5722806\",\n \"0.5704894\",\n \"0.56923276\",\n \"0.5673192\",\n \"0.56649166\",\n \"0.5659682\",\n \"0.5658156\",\n \"0.5640848\",\n \"0.56395495\",\n \"0.5631491\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8217127"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83778,"cells":{"query":{"kind":"string","value":"Return index array matching criteria"},"document":{"kind":"string","value":"def _filter_column(array, col, criteria):\n # Raise an error if the column does not exist. This is the only way to\n # test it across all possible types (pandas, recarray...)\n try:\n array[col]\n except:\n raise KeyError('Filtering criterion %s does not exist' % col)\n\n if (not isinstance(criteria, string_types) and\n not isinstance(criteria, bytes) and\n not isinstance(criteria, tuple) and\n isinstance(criteria, collections.Iterable)):\n\n filter = np.zeros(array.shape[0], dtype=np.bool)\n for criterion in criteria:\n filter = np.logical_or(filter,\n _filter_column(array, col, criterion))\n return filter\n\n if isinstance(criteria, tuple):\n if len(criteria) != 2:\n raise ValueError(\"An interval must have 2 values\")\n if criteria[0] is None:\n return array[col] <= criteria[1]\n if criteria[1] is None:\n return array[col] >= criteria[0]\n filter = array[col] <= criteria[1]\n return np.logical_and(filter, array[col] >= criteria[0])\n\n return array[col] == criteria"},"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_indexes(from_list, find_list):\n\n df_find = pd.DataFrame(find_list, columns=['value'])\n df_from = pd.DataFrame(list(zip(from_list, np.arange(len(from_list)))), columns=['value', 'index'])\n indexes = pd.merge(df_from, df_find, on='value', how='inner')['index'].values\n return indexes","def getIndex(self,filt):\n indx = [i for i in xrange(len(self._header)) if filt == self._header[i]]\n return indx","def get_idxvals(self):\n input_rows = list()\n input_cols = list()\n for key in self.index:\n input_rows.append(key[0])\n input_cols.append(key[1])\n\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))","def getIndexes(self, val):\n # Find where this value is listed. \n valNdx = (self.values == val).nonzero()[0]\n \n # If this value is not actually in those listed, then we \n # must return empty indexes\n if len(valNdx) == 0:\n start = 0\n end = 0\n else:\n # The index into counts, etc. for this value. \n valNdx = valNdx[0]\n start = self.start[valNdx]\n end = self.end[valNdx]\n \n # Create a tuple of index arrays, one for each index of the original array. \n ndx = ()\n for i in range(self.nDims):\n ndx += (self.indexes[start:end, i], )\n return ndx","def get_indexes(self, variable, *args):\n\n return [get_subset_idxs(data, min, max)\n for data, (min, max) in args]","def where(predicate):\n matching_indices = predicate.nonzero()\n if len(matching_indices) != 0:\n matching_indices = matching_indices.t().squeeze(0)\n return matching_indices","def _get_indices(scores: np.ndarray, shuffle_prop: float) -> np.ndarray:\n return _shuffle_subset(scores.argsort().argsort(), shuffle_prop)","def indices(self):\n return tuple([slice(*r) for r in self.location])","def positions(self, searchstr: str):\n indices = []\n index = mybinsearch(self.sarray, searchstr, self.comp)\n if index >= 0:\n indices.append(index)\n return indices","def findArrayIndex(cluster_idx, tracked_clusters, index_tracked_clusters):\n \n found = np.zeros(5, dtype=int)\n \n # Index the clusters again since the unique cluster ids may be changed\n for i, indi in enumerate(cluster_idx):\n if indi == tracked_clusters[0]:\n index_tracked_clusters[0] = i\n found[0] = 1\n continue\n elif indi == tracked_clusters[1]:\n index_tracked_clusters[1] = i\n found[1] = 1\n continue\n elif indi == tracked_clusters[2]:\n index_tracked_clusters[2] = i\n found[2] = 1\n continue\n elif indi == tracked_clusters[3]:\n index_tracked_clusters[3] = i\n found[3] = 1\n continue\n elif indi == tracked_clusters[4]:\n index_tracked_clusters[4] = i\n found[4] = 1\n continue\n \n return found","def occ_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==1:\n indices.append(index)\n return indices","def _get_indx(self, t):\n t = np.array(t)\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\n self._data['start'])\n return np.array([np.where(row)[0][0] for row in a])","def indices_using_group_array(group_array):\n unique_elements = np.unique(group_array)\n indices = []\n for unique_element in unique_elements:\n indices.append((unique_element,\n np.flatnonzero(group_array == unique_element)))\n return indices","def findings_2_idx(findings, corner_2_idx, funcx, funcy):\n idx = []\n for finding in findings:\n x, y = finding\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\n idx.extend([corner_2_idx(c) for c in mesh])\n\n return np.unique(idx)","def find_indices(subset,fullset):\n nsub=len(subset)\n indices=-np.ones(subset.shape,dtype=int)\n indices_full=np.arange(0,len(fullset),1,dtype=int)\n for s in range(0,nsub):\n ind=fullset==subset[s]\n if any(ind):\n indices[s]=indices_full[ind][0] # numerical indices\n else:\n indices[s]=-1 # not found\n return indices","def get_indexes(self, x):\n indexes = []\n for index_hashes in self.hash_functions:\n combined_index = []\n for idx_spec, hash_func in zip(self.config.index_specs, index_hashes):\n combined_index.append(idx_spec.distribution.get_index(hash_func(x)))\n indexes.append(tuple(combined_index))\n return indexes","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def find_indices_of_matched_samples(self, X, a):\n\n matching_weights = self.matching.matches_to_weights()\n matches_mask = self._filter_matching_weights_by_mode(matching_weights)\n return matches_mask","def return_inds(arr, target):\n\n # Convert list to numpy array\n arr = np.array(arr)\n # Determine all possible combinations, excluding combinations of the same number\n arr_combs = list(combinations(arr, 2))\n \n # Determine the sum of each combination\n sum_arr = np.array(list((map(sum, arr_combs)))) \n \n # Determine the index where the sum is equal to our target\n vals = arr_combs[np.where(sum_arr == target)[0][0]]\n \n # Determine the two indices\n ind_1 = np.where(arr == vals[0])[0][0]\n ind_2 = np.where(arr == vals[1])[0][0]\n\n return ind_1, ind_2","def index_object(idxs=None):","def _pick_elements(self,regexp_ind,array_list):\r\n new_array_list = [] #New list with elements matching regexp_ind\r\n array_indices = [] #Indices that matches the arrays in new_array_list and array_list\r\n\r\n array_index = 0\r\n for array in array_list:\r\n _new = []\r\n for ai in array:\r\n if ai in regexp_ind:\r\n _new.append(ai)\r\n if len(_new):\r\n new_array_list.append(np.array(_new))\r\n array_indices.append(array_index)\r\n array_index += 1\r\n return new_array_list, array_indices","def indices(self) -> np.ndarray:\n return self.impl.indices","def getindex(self,name,searchfrom='name'):\n name = name.replace(':','_').lower()\n pat = re.compile(name)\n result = []\n\n for (i,elem) in enumerate(self.lat):\n if pat.search(elem[searchby]):\n result.append(i)\n return result","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def pt_index(*args):\n index = []\n x = check_pt_data(args[0])\n i = 0\n for line in args[0].Data.PTData.pt_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def get_data_by_indexes(indexes: list, data: np.ndarray) -> np.ndarray:\n return np.asarray([data[i, j] for i, j in indexes])","def select_indices(arr,index_arr,axis=-1):\n shape_list=(lambda x,y: [ 1 if dim!=x else y for dim in range(len(arr.shape))] )\n indices_list=[np.reshape(np.arange(length),shape_list(length_id,length))\n for length_id,length in enumerate(arr.shape)]\n indices_list[axis]=index_arr\n return arr.ravel()[np.ravel_multi_index(indices_list,dims=arr.shape)]","def selectCompatibleIndices(bigTimes, smallTimes):\r\n indices = []\r\n for idx, _ in enumerate(smallTimes):\r\n distances = (bigTimes - smallTimes[idx])**2\r\n def getValue(k):\r\n return distances[k]\r\n thisIndices = sorted(range(len(distances)), key=getValue)\r\n indices.append(thisIndices[0])\r\n return np.array(indices)","def _selected_indices(self, subset):\n # We want the DataFrame to be indexed the same way its values array is\n ftr = self.frametracks.reset_index(drop=True)\n if subset is not None:\n ftr['tmpindex'] = ftr.index.values\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\n if self.autoclip:\n # Boundaries are computed for the whole system\n xmin = self.frametracks.x.min() + self.nncutoff\n xmax = self.frametracks.x.max() - self.nncutoff\n ymin = self.frametracks.y.min() + self.nncutoff\n ymax = self.frametracks.y.max() - self.nncutoff\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\n else:\n r = ftr.index.values.astype(int)\n if self.fast:\n return np.random.permutation(r)[:int(len(r) / 10)]\n else:\n return r","def pndindex(*args):\r\n return np.ndindex(*args)","def masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask,order='C'))[0]","def _get_indices(input_items, wanted_items):\r\n # Note: Some of this code is taken from Jeremy Widmann's\r\n # get_valid_indices() function, part of make_distance_histograms.py from QIIME 1.8.0.\r\n try:\r\n iter(input_items)\r\n except:\r\n raise ValueError(\"The input_items to search must be iterable.\")\r\n try:\r\n len(wanted_items)\r\n except:\r\n # We have a scalar value, so put it in a list.\r\n wanted_items = [wanted_items]\r\n if isinstance(wanted_items, basestring):\r\n wanted_items = [wanted_items]\r\n\r\n return [input_items.index(item)\r\n for item in wanted_items if item in input_items]","def pndindex(*args):\n return np.ndindex(*args)","def get_indexes(self, dataset):\n\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexs","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices","def get_indices(waves):\n prob_ = np.abs(waves)**2\n # batch\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\n prob = np.asarray(prob)\n prob_tot = np.sum(prob, axis=0)\n \n # cutoff\n length = np.size(prob[:,0])\n len10 = int(length/10)\n flags = np.zeros((prob.shape[1]), dtype=int)\n # hinges\n # 50% within 10% of corners\n\n # surface\n # 50% within 10% of surfaces\n # not already labelled hinges\n prob_left = np.sum(prob[0:len10,:], axis=0)\n frac_left = prob_left/prob_tot\n\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\n frac_right = np.divide(prob_right, prob_tot)\n\n for i in range(len(flags)):\n if frac_left[i]>0.5 or frac_right[i]>0.5:\n flags[i] = 1\n \n indices = [i for i, x in enumerate(flags) if x == 1]\n indices0 = [i for i, x in enumerate(flags) if x == 0]\n \n return indices, indices0","def get_subset_inds(self, adata_parent):\r\n subset_inds = np.ones(len(adata_parent), dtype=bool)\r\n for condition, values in self.subset_cond.items():\r\n subset_inds *= adata_parent.obs[condition].isin(values)\r\n return subset_inds","def getIndices(self,img,covariates):\n\t\t\n\t\t# no need to add indices that are already there\n\t\tindices = self.removeDuplicates(covariates,img.bandNames().getInfo())\n\t\t\n\t\tfor item in indices:\n\t\t\timg = self.functionList[item](img)\n\n\t\treturn img","def get_random_indexes(msk, n_idxs):\n pos_idxs = np.array(np.where(msk > 0))\n neg_idxs = np.array(np.where(msk == 0))\n n_pos = pos_idxs.shape[1] # number of positives found in the mask\n n_neg = neg_idxs.shape[1] # number of negatives found in the mask\n n_min = min(n_neg, min(n_idxs, n_pos))\n rnd_idxs_pos = range(n_pos)\n np.random.shuffle(rnd_idxs_pos)\n rnd_idxs_neg = range(n_neg)\n np.random.shuffle(rnd_idxs_neg)\n return pos_idxs[:, rnd_idxs_pos[:n_min]], neg_idxs[:, rnd_idxs_neg[:n_min]]","def indices(self, position=None):\n \n raise NotImplementedError()","def get_indexes(self):\n indexes = []\n for c in self.components:\n indexes.extend(c.get_indexes())\n return indexes","def getAllIndex(ldata, fldata):\n\treturn list(map(lambda e : fldata.index(e), ldata))","def get_agent_indices_of_type(array, agent_type):\t\n\tagent_indices = np.argwhere(array == agent_type)\n\treturn agent_indices","def get_current_index(self, index):\n\n if self.method == 1:\n current_idx = np.where((self.unassigned_data[0,:]==self.unassigned_data_relax[0,index]) & \\\n (self.unassigned_data[1,:]==self.unassigned_data_relax[1,index]) & \\\n (self.unassigned_data[2,:]==self.unassigned_data_relax[2,index]) & \\\n (self.unassigned_data[3,:]==self.unassigned_data_relax[3,index]) & \\\n (self.unassigned_data[4,:]==self.unassigned_data_relax[4,index]))\n else:\n current_idx = np.where((self.unassigned_data[0,:]==self.unassigned_data_relax[0,index]) & \\\n (self.unassigned_data[1,:]==self.unassigned_data_relax[1,index]) & \\\n (self.unassigned_data[2,:]==self.unassigned_data_relax[2,index]) & \\\n (self.unassigned_data[3,:]==self.unassigned_data_relax[3,index]))\n\n current_idx = current_idx[0][0]\n\n return current_idx","def get_index(self, x, y):\n i = (y - self.y0) // self.dy\n j = (x - self.x0) // self.dx\n i = min(max(i, 0), self.n-1)\n j = min(max(j, 0), self.m-1)\n return [i, j]","def tc_index(*args):\n index = []\n x = check_tc_data(args[0])\n i = 0\n for line in args[0].Data.TCData.tc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def find_index(vec_vals,target):\n target=np.atleast_1d(target) #turn scalar into iterable, no op if already array\n vec_vals=np.array(vec_vals)\n index_list=[]\n for item in target:\n first_index=np.argmin(np.abs(vec_vals - item))\n index_list.append(first_index)\n return index_list","def find_indices_srnn(data, action):\n\n SEED = 1234567890\n rng = np.random.RandomState(SEED)\n\n subject = 5\n subaction1 = 1\n subaction2 = 2\n\n T1 = data[(subject, action, subaction1)].shape[0]\n T2 = data[(subject, action, subaction2)].shape[0]\n prefix, suffix = 50, 100\n\n idx = []\n idx.append(rng.randint(16,T1-prefix-suffix))\n idx.append(rng.randint(16,T2-prefix-suffix))\n idx.append(rng.randint(16,T1-prefix-suffix))\n idx.append(rng.randint(16,T2-prefix-suffix))\n idx.append(rng.randint(16,T1-prefix-suffix))\n idx.append(rng.randint(16,T2-prefix-suffix))\n idx.append(rng.randint(16,T1-prefix-suffix))\n idx.append(rng.randint(16,T2-prefix-suffix))\n\n return idx","def get_index_for_group(groups, which_group):\n group_indexes = np.where(groups == float(which_group))[0]\n return group_indexes","def get_index_array(self):\n return self.region_pairs","def relevant_indexes(data, min_threshold):\n\n start_index = 1\n end_index = len(data) - 1\n\n for i in range(len(data)):\n if data[i] > min_threshold:\n start_index = i\n break\n\n for i in range(len(data)):\n if data[::-1][i] > min_threshold:\n end_index = i\n break\n\n return start_index, end_index","def index_col(self, i0, i1, j0, j1):\n edges = self.h5['indexes']['bin1_offset'][i0:i1 + 1]\n index = []\n for lo1, hi1 in zip(edges[:-1], edges[1:]):\n if hi1 - lo1 > 0:\n bin2 = self.h5['pixels']['bin2_id'][lo1:hi1]\n mask = (bin2 >= j0) & (bin2 < j1)\n index.append(lo1 + np.flatnonzero(mask))\n if not index:\n return np.array([], dtype=int)\n else:\n return np.concatenate(index, axis=0)","def create_repeated_indexes(data):\n from numpy import arange\n\n index_range = arange(0, len(data))\n return (index_range for i in index_range)","def create_jackknife_indexes(data):\n from numpy import arange, delete\n\n index_range = arange(0, len(data))\n return (delete(index_range, i) for i in index_range)","def inidices(self):\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]","def select(arrays, index):\n if arrays is None or any(i is None for i in arrays):\n return arrays\n return tuple(i.ravel()[index] for i in arrays)","def indices_of(self, col_name, value):\n return list(self._obj[self._obj[col_name] == value].index\n ) if col_name in self._obj.columns else None","def find_at(self, x, y):\n return list(self.ifind_at(x, y))","def indices(self):\n return self.index.indices","def getidx(self, ind: Union[str, int]) -> List[Any]:\n output = []\n for data in self.data:\n output.append(data[ind])\n return output","def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\n res = np.zeros(len(object_seq))\n for i, obj in enumerate(object_seq):\n if obj in self.obj_to_idx:\n res[i] = self.obj_to_idx[obj]\n else:\n res[i] = self.start-1\n return res","def FindIdxValues(X):\n data = X.select_dtypes(include=[\"float64\"])\n idx = np.argwhere(~np.isnan(data.values))\n idx[:, 1] += 4 # add ID variable columns\n StoE = pd.read_csv(\"msresist/data/MS/CPTAC/IDtoExperiment.csv\")\n assert all(StoE.iloc[:, 0] == data.columns), \"Sample labels don't match.\"\n StoE = StoE.iloc[:, 1].values\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\n return np.append(idx, tmt, axis=1)","def indices(self, _user=None):\n return [p.index for p in self.get_active_smallvariant_cases()]","def _get_indices_2(image_set, min_groups, num_labels=2, num_protected=2):\r\n indices = [[[] for _ in range(num_protected)] for _ in range(num_labels)]\r\n for i, (_, label, _, index) in enumerate(image_set):\r\n indices[label][int(image_set.samples[i][0].split(\"/\")[-1] in min_groups[label])].append(index)\r\n\r\n return indices","def compute_binary_set_mappings(indexing, counts): \n ret = np.zeros_like(indexing)-1\n for vertex,index in enumerate(indexing):\n if counts[index] == 2:\n if ret[index] == -1:\n ret[index] = vertex\n return ret","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def find_index(self):\n current = self.from_grid\n #find index of \"*\"\n for x in range(len(current)):\n for y in range(len(current[x])):\n if current[x][y] == \"*\":\n index = (x,y)\n return index","def get_index(ks):\n unq_vals, unq_ix = np.unique(ks[:, 0], return_index=True)\n return np.vstack([unq_vals, unq_ix]).T","def get_index_from_nested_list(data, conditions):\n assert type(np.array(data)) == np.ndarray, \"Please match list's element structure\"\n \n def check_function(element):\n return sum(apply_function_vector(conditions, element)) == len(conditions)\n\n condition_results = np.array(list(map(lambda element: True if check_function(element) else False, flatten_to_vector(data))))\n \n return condition_results.nonzero()","def get_prediction_indices(self):\r\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\r\n self.full_df = self.full_df[::-1]\r\n self.full_df.reset_index(inplace=True)\r\n self.full_df.drop('index', axis=1, inplace=True)\r\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\r\n (self.full_df['Dates'] >= self.pred_start))\r\n self.pred_indices = list(self.full_df[date_condition].index)","def index(self):\n # Check is multiple orders were given\n try:\n orders = list(iter(self.orders))\n except TypeError:\n orders = [self.orders]\n sites = self._epistasismap.sites\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\n # Add the zeroth element if included\n if 0 in orders:\n x = [0] + x\n return np.array(x)","def get_idx(q_nbrs, q_mem):\n\n # Whether a matching sample can be found in neighbours or memory\n any_match_nbrs = T.any(q_nbrs, axis=1)\n any_match_mem = T.any(q_mem, axis=1)\n any_match = T.or_(any_match_nbrs, any_match_mem)\n\n # Look in neighbours then memory for corresponding sample.\n # If from neighbours, we need to retrieve the full mem idx.\n rows = T.arange(nbrs.shape[0])\n idx = T.switch(any_match_nbrs,\n nbrs[rows, tensor_choose_k(q_nbrs, self.rng, k=1)],\n tensor_choose_k(q_mem, self.rng, k=1, random=True))\n\n return (idx, any_match)","def get_relevant_indices(dataset, classes, target_classes):\n indices = []\n for i in range(len(dataset)):\n # Check if the label is in the target classes\n label_index = dataset[i][1] # ex: 3\n label_class = classes[label_index] # ex: 'cat'\n if label_class in target_classes:\n indices.append(i)\n return indices","def _make_sample_filter_indices(\n X: np.ndarray,\n test: bool = False,\n building_types: list = None,\n htc_upper_bound: float = None,\n htc_lower_bound: float = None\n):\n all_indices = list(range(X.shape[0]))\n\n print(\">>>\", building_types)\n\n if building_types and len(building_types) > 0:\n building_types_list = _building_types_from_csv(test)\n all_indices += [i for i, bt in enumerate(building_types_list) if bt in building_types]\n\n if htc_lower_bound:\n mean_htcs = _mean_htc_from_csv(test)\n htc_lower_filtered_indices = np.where(np.array(mean_htcs) >= htc_lower_bound)[0].tolist()\n\n if len(all_indices) > 0:\n all_indices = list(set(all_indices) & set(htc_lower_filtered_indices))\n else:\n all_indices = htc_lower_filtered_indices\n\n if htc_upper_bound:\n mean_htcs = _mean_htc_from_csv(test)\n htc_upper_filtered_indices = np.where(np.array(mean_htcs) <= htc_upper_bound)[0].tolist()\n\n if len(all_indices) > 0:\n all_indices = list(set(all_indices) & set(htc_upper_filtered_indices))\n else:\n all_indices = htc_upper_filtered_indices\n\n return all_indices","def mainIndices(self):\n return self.i1, self.i2","def get_agent_indices(array):\t\n\tagent_indices = np.argwhere(array != 0)\n\treturn agent_indices","def check_for_indices(self, indices: Iterable[int]) -> Set[int]:\n cursor = self.mongo_database.cache.find(\n {\"session_id\": self.session_id, \"sample_identifier\": {\"$in\": indices}},\n {\"_id\": 0, \"sample_identifier\": 1},\n )\n return {i[\"sample_identifier\"] for i in cursor}","def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\n _, ncol = self.shape\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\n mask = r != nodata\n idx = np.full(r.shape, nodata, dtype=int)\n idx[mask] = r[mask] * ncol + c[mask]\n return idx","def get_indexes(self, items: Iterable[_T]) -> List[int]:\n return [self.get_index(item) for item in items]","def indices_of_label(self, label_name):\n return self.indices_of('label', label_name)","def get_34index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==1]","def columnIndexes(a):\n nrows = (a.size-2)+1\n return a[1*np.arange(nrows)[:,None] + np.arange(2)]","def get_data_index(self, data, data_point):\n\n if self.method == 1:\n idx = np.where((data[0,:]==data_point[0]) & \\\n (data[1,:]==data_point[1]) & \\\n (data[2,:]==data_point[2]) & \\\n (data[3,:]==data_point[3]) & \\\n (data[4,:]==data_point[4]))\n else:\n idx = np.where((data[0,:]==data_point[0]) & \\\n (data[1,:]==data_point[1]) & \\\n (data[2,:]==data_point[2]) & \\\n (data[3,:]==data_point[3]))\n\n idx = idx[0][0]\n\n return idx","def matrix_idx(n_hist, n_req, n_rows):\n\n flat_idx = []\n for i in range(n_rows):\n flat_idx.extend(range(i * n_req, (i + 1) * n_req + n_hist))\n # idx = np.unravel_index(flat_idx, (n_rows, n_hist + n_req))\n\n idx_matrix = np.reshape(flat_idx, (n_rows, n_hist + n_req))\n idxX = idx_matrix[:, n_req:]\n idxY = idx_matrix[:, :n_req]\n\n return idxX, idxY","def getidx(self, ind: Union[str, int]) -> List[Any]:\n output = []\n for data in self.data:\n output.append(data[ind])\n\n return output","def get_marginal_indexes(actions, mode):\n vi = []\n for v in range(actions[mode].max()+1):\n vals = actions[actions[mode] == v].index.values\n if len(vals) > 0:\n vi.append(vals)\n else:\n vi.append(np.array([0]))\n return vi","def getLandmarkindices(self):\n return self.subsetindices","def search(query, idx):\n\n if len(query) == 0:\n return []\n ordered = {}\n for e in query:\n ordered[e] = len(idx[e])\n ordered = sorted(ordered.items(), key = lambda d: d[1])\n results = idx[ordered[0][0]]\n i = 1\n while i < len(ordered):\n results = intersect(results, idx[ordered[i][0]])\n i += 1\n return results","def get_indices(self):\r\n return self._indices","def lc_index(*args):\n index = []\n x = check_lc_data(args[0])\n i = 0\n for line in args[0].Data.LCData.lc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def get_target_indexes(self, dataset):\n targets = []\n for i, fobj in enumerate(dataset.files):\n for criterion in self.target_criteria:\n if self._is_valid_target_int(criterion):\n if i == criterion:\n targets.append(i)\n elif self._is_valid_target_str(criterion):\n if re.match(criterion, str(fobj)):\n targets.append(i)\n else:\n raise TypeError(\n \"Unrecognized type for 'applies_to()' target criteria\"\n )\n return targets","def get_index(self, _quals):\n return self._options['index']","def indexarray(matrix_terms, which, var):\n mults = matrix_terms[which].copy()\n mults[:, var] += 1\n return np.argmin(np.abs(mults[:, np.newaxis] - matrix_terms[np.newaxis]).sum(axis=-1), axis=1)","def indexMatching(seq, condition):\n for i,x in enumerate(seq):\n if condition(x):\n return i\n return -1","def _get_index_lists(self, mat):\n n_row, n_col = mat.shape\n \n col_ind_at_row, row_ind_at_col = [],[]\n for i in range(n_row):\n aux_ind = _np.where(mat[i]>0)[0]\n if len(aux_ind) == 0:\n raise Exception('Row {} is composed of zeros'.format(i))\n col_ind_at_row.append(aux_ind)\n \n for j in range(n_col):\n aux_ind = _np.where(mat[:,j]>0)[0]\n if len(aux_ind) == 0:\n raise Exception('Column {} is composed of zeros'.format(j))\n \n row_ind_at_col.append(aux_ind)\n \n return col_ind_at_row, row_ind_at_col","def rows_matching(BL, indices):\n inBL0 = np.in1d(BL[:, 0], indices)\n # print 'BLUC[:,0] = ', BL[:,0]\n # print 'indices = ', indices\n # print 'inBL0 = ', inBL0\n inBL1 = np.in1d(BL[:, 1], indices)\n matches = np.where(np.logical_and(inBL0, inBL1))[0]\n return matches","def other_indices(mentions, toks):\r\n indices = []\r\n for i, tok in enumerate(toks):\r\n for m in mentions:\r\n if m['start'] <= tok['start'] and tok['end'] <= m['end']:\r\n indices.append(i)\r\n break\r\n return indices","def indices(self):\n return range(len(self))","def indexer(list1, list2):\r\n\tindex_list = []\r\n\tfor x in list2:\r\n\t\tfor y in list1:\r\n\t\t\tif x == y:\r\n\t\t\t\tindex = list1.index(x)\r\n\t\t\t\tindex_list.append(index)\r\n\treturn index_list"],"string":"[\n \"def get_indexes(from_list, find_list):\\n\\n df_find = pd.DataFrame(find_list, columns=['value'])\\n df_from = pd.DataFrame(list(zip(from_list, np.arange(len(from_list)))), columns=['value', 'index'])\\n indexes = pd.merge(df_from, df_find, on='value', how='inner')['index'].values\\n return indexes\",\n \"def getIndex(self,filt):\\n indx = [i for i in xrange(len(self._header)) if filt == self._header[i]]\\n return indx\",\n \"def get_idxvals(self):\\n input_rows = list()\\n input_cols = list()\\n for key in self.index:\\n input_rows.append(key[0])\\n input_cols.append(key[1])\\n\\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))\",\n \"def getIndexes(self, val):\\n # Find where this value is listed. \\n valNdx = (self.values == val).nonzero()[0]\\n \\n # If this value is not actually in those listed, then we \\n # must return empty indexes\\n if len(valNdx) == 0:\\n start = 0\\n end = 0\\n else:\\n # The index into counts, etc. for this value. \\n valNdx = valNdx[0]\\n start = self.start[valNdx]\\n end = self.end[valNdx]\\n \\n # Create a tuple of index arrays, one for each index of the original array. \\n ndx = ()\\n for i in range(self.nDims):\\n ndx += (self.indexes[start:end, i], )\\n return ndx\",\n \"def get_indexes(self, variable, *args):\\n\\n return [get_subset_idxs(data, min, max)\\n for data, (min, max) in args]\",\n \"def where(predicate):\\n matching_indices = predicate.nonzero()\\n if len(matching_indices) != 0:\\n matching_indices = matching_indices.t().squeeze(0)\\n return matching_indices\",\n \"def _get_indices(scores: np.ndarray, shuffle_prop: float) -> np.ndarray:\\n return _shuffle_subset(scores.argsort().argsort(), shuffle_prop)\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def positions(self, searchstr: str):\\n indices = []\\n index = mybinsearch(self.sarray, searchstr, self.comp)\\n if index >= 0:\\n indices.append(index)\\n return indices\",\n \"def findArrayIndex(cluster_idx, tracked_clusters, index_tracked_clusters):\\n \\n found = np.zeros(5, dtype=int)\\n \\n # Index the clusters again since the unique cluster ids may be changed\\n for i, indi in enumerate(cluster_idx):\\n if indi == tracked_clusters[0]:\\n index_tracked_clusters[0] = i\\n found[0] = 1\\n continue\\n elif indi == tracked_clusters[1]:\\n index_tracked_clusters[1] = i\\n found[1] = 1\\n continue\\n elif indi == tracked_clusters[2]:\\n index_tracked_clusters[2] = i\\n found[2] = 1\\n continue\\n elif indi == tracked_clusters[3]:\\n index_tracked_clusters[3] = i\\n found[3] = 1\\n continue\\n elif indi == tracked_clusters[4]:\\n index_tracked_clusters[4] = i\\n found[4] = 1\\n continue\\n \\n return found\",\n \"def occ_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==1:\\n indices.append(index)\\n return indices\",\n \"def _get_indx(self, t):\\n t = np.array(t)\\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\\n self._data['start'])\\n return np.array([np.where(row)[0][0] for row in a])\",\n \"def indices_using_group_array(group_array):\\n unique_elements = np.unique(group_array)\\n indices = []\\n for unique_element in unique_elements:\\n indices.append((unique_element,\\n np.flatnonzero(group_array == unique_element)))\\n return indices\",\n \"def findings_2_idx(findings, corner_2_idx, funcx, funcy):\\n idx = []\\n for finding in findings:\\n x, y = finding\\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\\n idx.extend([corner_2_idx(c) for c in mesh])\\n\\n return np.unique(idx)\",\n \"def find_indices(subset,fullset):\\n nsub=len(subset)\\n indices=-np.ones(subset.shape,dtype=int)\\n indices_full=np.arange(0,len(fullset),1,dtype=int)\\n for s in range(0,nsub):\\n ind=fullset==subset[s]\\n if any(ind):\\n indices[s]=indices_full[ind][0] # numerical indices\\n else:\\n indices[s]=-1 # not found\\n return indices\",\n \"def get_indexes(self, x):\\n indexes = []\\n for index_hashes in self.hash_functions:\\n combined_index = []\\n for idx_spec, hash_func in zip(self.config.index_specs, index_hashes):\\n combined_index.append(idx_spec.distribution.get_index(hash_func(x)))\\n indexes.append(tuple(combined_index))\\n return indexes\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def find_indices_of_matched_samples(self, X, a):\\n\\n matching_weights = self.matching.matches_to_weights()\\n matches_mask = self._filter_matching_weights_by_mode(matching_weights)\\n return matches_mask\",\n \"def return_inds(arr, target):\\n\\n # Convert list to numpy array\\n arr = np.array(arr)\\n # Determine all possible combinations, excluding combinations of the same number\\n arr_combs = list(combinations(arr, 2))\\n \\n # Determine the sum of each combination\\n sum_arr = np.array(list((map(sum, arr_combs)))) \\n \\n # Determine the index where the sum is equal to our target\\n vals = arr_combs[np.where(sum_arr == target)[0][0]]\\n \\n # Determine the two indices\\n ind_1 = np.where(arr == vals[0])[0][0]\\n ind_2 = np.where(arr == vals[1])[0][0]\\n\\n return ind_1, ind_2\",\n \"def index_object(idxs=None):\",\n \"def _pick_elements(self,regexp_ind,array_list):\\r\\n new_array_list = [] #New list with elements matching regexp_ind\\r\\n array_indices = [] #Indices that matches the arrays in new_array_list and array_list\\r\\n\\r\\n array_index = 0\\r\\n for array in array_list:\\r\\n _new = []\\r\\n for ai in array:\\r\\n if ai in regexp_ind:\\r\\n _new.append(ai)\\r\\n if len(_new):\\r\\n new_array_list.append(np.array(_new))\\r\\n array_indices.append(array_index)\\r\\n array_index += 1\\r\\n return new_array_list, array_indices\",\n \"def indices(self) -> np.ndarray:\\n return self.impl.indices\",\n \"def getindex(self,name,searchfrom='name'):\\n name = name.replace(':','_').lower()\\n pat = re.compile(name)\\n result = []\\n\\n for (i,elem) in enumerate(self.lat):\\n if pat.search(elem[searchby]):\\n result.append(i)\\n return result\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def pt_index(*args):\\n index = []\\n x = check_pt_data(args[0])\\n i = 0\\n for line in args[0].Data.PTData.pt_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def get_data_by_indexes(indexes: list, data: np.ndarray) -> np.ndarray:\\n return np.asarray([data[i, j] for i, j in indexes])\",\n \"def select_indices(arr,index_arr,axis=-1):\\n shape_list=(lambda x,y: [ 1 if dim!=x else y for dim in range(len(arr.shape))] )\\n indices_list=[np.reshape(np.arange(length),shape_list(length_id,length))\\n for length_id,length in enumerate(arr.shape)]\\n indices_list[axis]=index_arr\\n return arr.ravel()[np.ravel_multi_index(indices_list,dims=arr.shape)]\",\n \"def selectCompatibleIndices(bigTimes, smallTimes):\\r\\n indices = []\\r\\n for idx, _ in enumerate(smallTimes):\\r\\n distances = (bigTimes - smallTimes[idx])**2\\r\\n def getValue(k):\\r\\n return distances[k]\\r\\n thisIndices = sorted(range(len(distances)), key=getValue)\\r\\n indices.append(thisIndices[0])\\r\\n return np.array(indices)\",\n \"def _selected_indices(self, subset):\\n # We want the DataFrame to be indexed the same way its values array is\\n ftr = self.frametracks.reset_index(drop=True)\\n if subset is not None:\\n ftr['tmpindex'] = ftr.index.values\\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\\n if self.autoclip:\\n # Boundaries are computed for the whole system\\n xmin = self.frametracks.x.min() + self.nncutoff\\n xmax = self.frametracks.x.max() - self.nncutoff\\n ymin = self.frametracks.y.min() + self.nncutoff\\n ymax = self.frametracks.y.max() - self.nncutoff\\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\\\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\\n else:\\n r = ftr.index.values.astype(int)\\n if self.fast:\\n return np.random.permutation(r)[:int(len(r) / 10)]\\n else:\\n return r\",\n \"def pndindex(*args):\\r\\n return np.ndindex(*args)\",\n \"def masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask,order='C'))[0]\",\n \"def _get_indices(input_items, wanted_items):\\r\\n # Note: Some of this code is taken from Jeremy Widmann's\\r\\n # get_valid_indices() function, part of make_distance_histograms.py from QIIME 1.8.0.\\r\\n try:\\r\\n iter(input_items)\\r\\n except:\\r\\n raise ValueError(\\\"The input_items to search must be iterable.\\\")\\r\\n try:\\r\\n len(wanted_items)\\r\\n except:\\r\\n # We have a scalar value, so put it in a list.\\r\\n wanted_items = [wanted_items]\\r\\n if isinstance(wanted_items, basestring):\\r\\n wanted_items = [wanted_items]\\r\\n\\r\\n return [input_items.index(item)\\r\\n for item in wanted_items if item in input_items]\",\n \"def pndindex(*args):\\n return np.ndindex(*args)\",\n \"def get_indexes(self, dataset):\\n\\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexs\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\",\n \"def get_indices(waves):\\n prob_ = np.abs(waves)**2\\n # batch\\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\\n prob = np.asarray(prob)\\n prob_tot = np.sum(prob, axis=0)\\n \\n # cutoff\\n length = np.size(prob[:,0])\\n len10 = int(length/10)\\n flags = np.zeros((prob.shape[1]), dtype=int)\\n # hinges\\n # 50% within 10% of corners\\n\\n # surface\\n # 50% within 10% of surfaces\\n # not already labelled hinges\\n prob_left = np.sum(prob[0:len10,:], axis=0)\\n frac_left = prob_left/prob_tot\\n\\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\\n frac_right = np.divide(prob_right, prob_tot)\\n\\n for i in range(len(flags)):\\n if frac_left[i]>0.5 or frac_right[i]>0.5:\\n flags[i] = 1\\n \\n indices = [i for i, x in enumerate(flags) if x == 1]\\n indices0 = [i for i, x in enumerate(flags) if x == 0]\\n \\n return indices, indices0\",\n \"def get_subset_inds(self, adata_parent):\\r\\n subset_inds = np.ones(len(adata_parent), dtype=bool)\\r\\n for condition, values in self.subset_cond.items():\\r\\n subset_inds *= adata_parent.obs[condition].isin(values)\\r\\n return subset_inds\",\n \"def getIndices(self,img,covariates):\\n\\t\\t\\n\\t\\t# no need to add indices that are already there\\n\\t\\tindices = self.removeDuplicates(covariates,img.bandNames().getInfo())\\n\\t\\t\\n\\t\\tfor item in indices:\\n\\t\\t\\timg = self.functionList[item](img)\\n\\n\\t\\treturn img\",\n \"def get_random_indexes(msk, n_idxs):\\n pos_idxs = np.array(np.where(msk > 0))\\n neg_idxs = np.array(np.where(msk == 0))\\n n_pos = pos_idxs.shape[1] # number of positives found in the mask\\n n_neg = neg_idxs.shape[1] # number of negatives found in the mask\\n n_min = min(n_neg, min(n_idxs, n_pos))\\n rnd_idxs_pos = range(n_pos)\\n np.random.shuffle(rnd_idxs_pos)\\n rnd_idxs_neg = range(n_neg)\\n np.random.shuffle(rnd_idxs_neg)\\n return pos_idxs[:, rnd_idxs_pos[:n_min]], neg_idxs[:, rnd_idxs_neg[:n_min]]\",\n \"def indices(self, position=None):\\n \\n raise NotImplementedError()\",\n \"def get_indexes(self):\\n indexes = []\\n for c in self.components:\\n indexes.extend(c.get_indexes())\\n return indexes\",\n \"def getAllIndex(ldata, fldata):\\n\\treturn list(map(lambda e : fldata.index(e), ldata))\",\n \"def get_agent_indices_of_type(array, agent_type):\\t\\n\\tagent_indices = np.argwhere(array == agent_type)\\n\\treturn agent_indices\",\n \"def get_current_index(self, index):\\n\\n if self.method == 1:\\n current_idx = np.where((self.unassigned_data[0,:]==self.unassigned_data_relax[0,index]) & \\\\\\n (self.unassigned_data[1,:]==self.unassigned_data_relax[1,index]) & \\\\\\n (self.unassigned_data[2,:]==self.unassigned_data_relax[2,index]) & \\\\\\n (self.unassigned_data[3,:]==self.unassigned_data_relax[3,index]) & \\\\\\n (self.unassigned_data[4,:]==self.unassigned_data_relax[4,index]))\\n else:\\n current_idx = np.where((self.unassigned_data[0,:]==self.unassigned_data_relax[0,index]) & \\\\\\n (self.unassigned_data[1,:]==self.unassigned_data_relax[1,index]) & \\\\\\n (self.unassigned_data[2,:]==self.unassigned_data_relax[2,index]) & \\\\\\n (self.unassigned_data[3,:]==self.unassigned_data_relax[3,index]))\\n\\n current_idx = current_idx[0][0]\\n\\n return current_idx\",\n \"def get_index(self, x, y):\\n i = (y - self.y0) // self.dy\\n j = (x - self.x0) // self.dx\\n i = min(max(i, 0), self.n-1)\\n j = min(max(j, 0), self.m-1)\\n return [i, j]\",\n \"def tc_index(*args):\\n index = []\\n x = check_tc_data(args[0])\\n i = 0\\n for line in args[0].Data.TCData.tc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def find_index(vec_vals,target):\\n target=np.atleast_1d(target) #turn scalar into iterable, no op if already array\\n vec_vals=np.array(vec_vals)\\n index_list=[]\\n for item in target:\\n first_index=np.argmin(np.abs(vec_vals - item))\\n index_list.append(first_index)\\n return index_list\",\n \"def find_indices_srnn(data, action):\\n\\n SEED = 1234567890\\n rng = np.random.RandomState(SEED)\\n\\n subject = 5\\n subaction1 = 1\\n subaction2 = 2\\n\\n T1 = data[(subject, action, subaction1)].shape[0]\\n T2 = data[(subject, action, subaction2)].shape[0]\\n prefix, suffix = 50, 100\\n\\n idx = []\\n idx.append(rng.randint(16,T1-prefix-suffix))\\n idx.append(rng.randint(16,T2-prefix-suffix))\\n idx.append(rng.randint(16,T1-prefix-suffix))\\n idx.append(rng.randint(16,T2-prefix-suffix))\\n idx.append(rng.randint(16,T1-prefix-suffix))\\n idx.append(rng.randint(16,T2-prefix-suffix))\\n idx.append(rng.randint(16,T1-prefix-suffix))\\n idx.append(rng.randint(16,T2-prefix-suffix))\\n\\n return idx\",\n \"def get_index_for_group(groups, which_group):\\n group_indexes = np.where(groups == float(which_group))[0]\\n return group_indexes\",\n \"def get_index_array(self):\\n return self.region_pairs\",\n \"def relevant_indexes(data, min_threshold):\\n\\n start_index = 1\\n end_index = len(data) - 1\\n\\n for i in range(len(data)):\\n if data[i] > min_threshold:\\n start_index = i\\n break\\n\\n for i in range(len(data)):\\n if data[::-1][i] > min_threshold:\\n end_index = i\\n break\\n\\n return start_index, end_index\",\n \"def index_col(self, i0, i1, j0, j1):\\n edges = self.h5['indexes']['bin1_offset'][i0:i1 + 1]\\n index = []\\n for lo1, hi1 in zip(edges[:-1], edges[1:]):\\n if hi1 - lo1 > 0:\\n bin2 = self.h5['pixels']['bin2_id'][lo1:hi1]\\n mask = (bin2 >= j0) & (bin2 < j1)\\n index.append(lo1 + np.flatnonzero(mask))\\n if not index:\\n return np.array([], dtype=int)\\n else:\\n return np.concatenate(index, axis=0)\",\n \"def create_repeated_indexes(data):\\n from numpy import arange\\n\\n index_range = arange(0, len(data))\\n return (index_range for i in index_range)\",\n \"def create_jackknife_indexes(data):\\n from numpy import arange, delete\\n\\n index_range = arange(0, len(data))\\n return (delete(index_range, i) for i in index_range)\",\n \"def inidices(self):\\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]\",\n \"def select(arrays, index):\\n if arrays is None or any(i is None for i in arrays):\\n return arrays\\n return tuple(i.ravel()[index] for i in arrays)\",\n \"def indices_of(self, col_name, value):\\n return list(self._obj[self._obj[col_name] == value].index\\n ) if col_name in self._obj.columns else None\",\n \"def find_at(self, x, y):\\n return list(self.ifind_at(x, y))\",\n \"def indices(self):\\n return self.index.indices\",\n \"def getidx(self, ind: Union[str, int]) -> List[Any]:\\n output = []\\n for data in self.data:\\n output.append(data[ind])\\n return output\",\n \"def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\\n res = np.zeros(len(object_seq))\\n for i, obj in enumerate(object_seq):\\n if obj in self.obj_to_idx:\\n res[i] = self.obj_to_idx[obj]\\n else:\\n res[i] = self.start-1\\n return res\",\n \"def FindIdxValues(X):\\n data = X.select_dtypes(include=[\\\"float64\\\"])\\n idx = np.argwhere(~np.isnan(data.values))\\n idx[:, 1] += 4 # add ID variable columns\\n StoE = pd.read_csv(\\\"msresist/data/MS/CPTAC/IDtoExperiment.csv\\\")\\n assert all(StoE.iloc[:, 0] == data.columns), \\\"Sample labels don't match.\\\"\\n StoE = StoE.iloc[:, 1].values\\n tmt = [[StoE[idx[ii][1] - 4]] for ii in range(idx.shape[0])]\\n return np.append(idx, tmt, axis=1)\",\n \"def indices(self, _user=None):\\n return [p.index for p in self.get_active_smallvariant_cases()]\",\n \"def _get_indices_2(image_set, min_groups, num_labels=2, num_protected=2):\\r\\n indices = [[[] for _ in range(num_protected)] for _ in range(num_labels)]\\r\\n for i, (_, label, _, index) in enumerate(image_set):\\r\\n indices[label][int(image_set.samples[i][0].split(\\\"/\\\")[-1] in min_groups[label])].append(index)\\r\\n\\r\\n return indices\",\n \"def compute_binary_set_mappings(indexing, counts): \\n ret = np.zeros_like(indexing)-1\\n for vertex,index in enumerate(indexing):\\n if counts[index] == 2:\\n if ret[index] == -1:\\n ret[index] = vertex\\n return ret\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def find_index(self):\\n current = self.from_grid\\n #find index of \\\"*\\\"\\n for x in range(len(current)):\\n for y in range(len(current[x])):\\n if current[x][y] == \\\"*\\\":\\n index = (x,y)\\n return index\",\n \"def get_index(ks):\\n unq_vals, unq_ix = np.unique(ks[:, 0], return_index=True)\\n return np.vstack([unq_vals, unq_ix]).T\",\n \"def get_index_from_nested_list(data, conditions):\\n assert type(np.array(data)) == np.ndarray, \\\"Please match list's element structure\\\"\\n \\n def check_function(element):\\n return sum(apply_function_vector(conditions, element)) == len(conditions)\\n\\n condition_results = np.array(list(map(lambda element: True if check_function(element) else False, flatten_to_vector(data))))\\n \\n return condition_results.nonzero()\",\n \"def get_prediction_indices(self):\\r\\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\\r\\n self.full_df = self.full_df[::-1]\\r\\n self.full_df.reset_index(inplace=True)\\r\\n self.full_df.drop('index', axis=1, inplace=True)\\r\\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\\r\\n (self.full_df['Dates'] >= self.pred_start))\\r\\n self.pred_indices = list(self.full_df[date_condition].index)\",\n \"def index(self):\\n # Check is multiple orders were given\\n try:\\n orders = list(iter(self.orders))\\n except TypeError:\\n orders = [self.orders]\\n sites = self._epistasismap.sites\\n x = [i for i in range(1, len(sites)) if len(sites[i]) in orders]\\n # Add the zeroth element if included\\n if 0 in orders:\\n x = [0] + x\\n return np.array(x)\",\n \"def get_idx(q_nbrs, q_mem):\\n\\n # Whether a matching sample can be found in neighbours or memory\\n any_match_nbrs = T.any(q_nbrs, axis=1)\\n any_match_mem = T.any(q_mem, axis=1)\\n any_match = T.or_(any_match_nbrs, any_match_mem)\\n\\n # Look in neighbours then memory for corresponding sample.\\n # If from neighbours, we need to retrieve the full mem idx.\\n rows = T.arange(nbrs.shape[0])\\n idx = T.switch(any_match_nbrs,\\n nbrs[rows, tensor_choose_k(q_nbrs, self.rng, k=1)],\\n tensor_choose_k(q_mem, self.rng, k=1, random=True))\\n\\n return (idx, any_match)\",\n \"def get_relevant_indices(dataset, classes, target_classes):\\n indices = []\\n for i in range(len(dataset)):\\n # Check if the label is in the target classes\\n label_index = dataset[i][1] # ex: 3\\n label_class = classes[label_index] # ex: 'cat'\\n if label_class in target_classes:\\n indices.append(i)\\n return indices\",\n \"def _make_sample_filter_indices(\\n X: np.ndarray,\\n test: bool = False,\\n building_types: list = None,\\n htc_upper_bound: float = None,\\n htc_lower_bound: float = None\\n):\\n all_indices = list(range(X.shape[0]))\\n\\n print(\\\">>>\\\", building_types)\\n\\n if building_types and len(building_types) > 0:\\n building_types_list = _building_types_from_csv(test)\\n all_indices += [i for i, bt in enumerate(building_types_list) if bt in building_types]\\n\\n if htc_lower_bound:\\n mean_htcs = _mean_htc_from_csv(test)\\n htc_lower_filtered_indices = np.where(np.array(mean_htcs) >= htc_lower_bound)[0].tolist()\\n\\n if len(all_indices) > 0:\\n all_indices = list(set(all_indices) & set(htc_lower_filtered_indices))\\n else:\\n all_indices = htc_lower_filtered_indices\\n\\n if htc_upper_bound:\\n mean_htcs = _mean_htc_from_csv(test)\\n htc_upper_filtered_indices = np.where(np.array(mean_htcs) <= htc_upper_bound)[0].tolist()\\n\\n if len(all_indices) > 0:\\n all_indices = list(set(all_indices) & set(htc_upper_filtered_indices))\\n else:\\n all_indices = htc_upper_filtered_indices\\n\\n return all_indices\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def get_agent_indices(array):\\t\\n\\tagent_indices = np.argwhere(array != 0)\\n\\treturn agent_indices\",\n \"def check_for_indices(self, indices: Iterable[int]) -> Set[int]:\\n cursor = self.mongo_database.cache.find(\\n {\\\"session_id\\\": self.session_id, \\\"sample_identifier\\\": {\\\"$in\\\": indices}},\\n {\\\"_id\\\": 0, \\\"sample_identifier\\\": 1},\\n )\\n return {i[\\\"sample_identifier\\\"] for i in cursor}\",\n \"def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\\n _, ncol = self.shape\\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\\n mask = r != nodata\\n idx = np.full(r.shape, nodata, dtype=int)\\n idx[mask] = r[mask] * ncol + c[mask]\\n return idx\",\n \"def get_indexes(self, items: Iterable[_T]) -> List[int]:\\n return [self.get_index(item) for item in items]\",\n \"def indices_of_label(self, label_name):\\n return self.indices_of('label', label_name)\",\n \"def get_34index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==1]\",\n \"def columnIndexes(a):\\n nrows = (a.size-2)+1\\n return a[1*np.arange(nrows)[:,None] + np.arange(2)]\",\n \"def get_data_index(self, data, data_point):\\n\\n if self.method == 1:\\n idx = np.where((data[0,:]==data_point[0]) & \\\\\\n (data[1,:]==data_point[1]) & \\\\\\n (data[2,:]==data_point[2]) & \\\\\\n (data[3,:]==data_point[3]) & \\\\\\n (data[4,:]==data_point[4]))\\n else:\\n idx = np.where((data[0,:]==data_point[0]) & \\\\\\n (data[1,:]==data_point[1]) & \\\\\\n (data[2,:]==data_point[2]) & \\\\\\n (data[3,:]==data_point[3]))\\n\\n idx = idx[0][0]\\n\\n return idx\",\n \"def matrix_idx(n_hist, n_req, n_rows):\\n\\n flat_idx = []\\n for i in range(n_rows):\\n flat_idx.extend(range(i * n_req, (i + 1) * n_req + n_hist))\\n # idx = np.unravel_index(flat_idx, (n_rows, n_hist + n_req))\\n\\n idx_matrix = np.reshape(flat_idx, (n_rows, n_hist + n_req))\\n idxX = idx_matrix[:, n_req:]\\n idxY = idx_matrix[:, :n_req]\\n\\n return idxX, idxY\",\n \"def getidx(self, ind: Union[str, int]) -> List[Any]:\\n output = []\\n for data in self.data:\\n output.append(data[ind])\\n\\n return output\",\n \"def get_marginal_indexes(actions, mode):\\n vi = []\\n for v in range(actions[mode].max()+1):\\n vals = actions[actions[mode] == v].index.values\\n if len(vals) > 0:\\n vi.append(vals)\\n else:\\n vi.append(np.array([0]))\\n return vi\",\n \"def getLandmarkindices(self):\\n return self.subsetindices\",\n \"def search(query, idx):\\n\\n if len(query) == 0:\\n return []\\n ordered = {}\\n for e in query:\\n ordered[e] = len(idx[e])\\n ordered = sorted(ordered.items(), key = lambda d: d[1])\\n results = idx[ordered[0][0]]\\n i = 1\\n while i < len(ordered):\\n results = intersect(results, idx[ordered[i][0]])\\n i += 1\\n return results\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def lc_index(*args):\\n index = []\\n x = check_lc_data(args[0])\\n i = 0\\n for line in args[0].Data.LCData.lc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def get_target_indexes(self, dataset):\\n targets = []\\n for i, fobj in enumerate(dataset.files):\\n for criterion in self.target_criteria:\\n if self._is_valid_target_int(criterion):\\n if i == criterion:\\n targets.append(i)\\n elif self._is_valid_target_str(criterion):\\n if re.match(criterion, str(fobj)):\\n targets.append(i)\\n else:\\n raise TypeError(\\n \\\"Unrecognized type for 'applies_to()' target criteria\\\"\\n )\\n return targets\",\n \"def get_index(self, _quals):\\n return self._options['index']\",\n \"def indexarray(matrix_terms, which, var):\\n mults = matrix_terms[which].copy()\\n mults[:, var] += 1\\n return np.argmin(np.abs(mults[:, np.newaxis] - matrix_terms[np.newaxis]).sum(axis=-1), axis=1)\",\n \"def indexMatching(seq, condition):\\n for i,x in enumerate(seq):\\n if condition(x):\\n return i\\n return -1\",\n \"def _get_index_lists(self, mat):\\n n_row, n_col = mat.shape\\n \\n col_ind_at_row, row_ind_at_col = [],[]\\n for i in range(n_row):\\n aux_ind = _np.where(mat[i]>0)[0]\\n if len(aux_ind) == 0:\\n raise Exception('Row {} is composed of zeros'.format(i))\\n col_ind_at_row.append(aux_ind)\\n \\n for j in range(n_col):\\n aux_ind = _np.where(mat[:,j]>0)[0]\\n if len(aux_ind) == 0:\\n raise Exception('Column {} is composed of zeros'.format(j))\\n \\n row_ind_at_col.append(aux_ind)\\n \\n return col_ind_at_row, row_ind_at_col\",\n \"def rows_matching(BL, indices):\\n inBL0 = np.in1d(BL[:, 0], indices)\\n # print 'BLUC[:,0] = ', BL[:,0]\\n # print 'indices = ', indices\\n # print 'inBL0 = ', inBL0\\n inBL1 = np.in1d(BL[:, 1], indices)\\n matches = np.where(np.logical_and(inBL0, inBL1))[0]\\n return matches\",\n \"def other_indices(mentions, toks):\\r\\n indices = []\\r\\n for i, tok in enumerate(toks):\\r\\n for m in mentions:\\r\\n if m['start'] <= tok['start'] and tok['end'] <= m['end']:\\r\\n indices.append(i)\\r\\n break\\r\\n return indices\",\n \"def indices(self):\\n return range(len(self))\",\n \"def indexer(list1, list2):\\r\\n\\tindex_list = []\\r\\n\\tfor x in list2:\\r\\n\\t\\tfor y in list1:\\r\\n\\t\\t\\tif x == y:\\r\\n\\t\\t\\t\\tindex = list1.index(x)\\r\\n\\t\\t\\t\\tindex_list.append(index)\\r\\n\\treturn index_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.648662","0.63990045","0.6351997","0.6327967","0.6317841","0.6282272","0.62778795","0.62594384","0.62156016","0.61883366","0.6183509","0.61677086","0.61461943","0.6115965","0.6113757","0.6105369","0.60910106","0.6073242","0.60502017","0.6050009","0.6044658","0.60356003","0.6021604","0.6006179","0.6006179","0.5998554","0.5993392","0.59902567","0.5989504","0.598655","0.5978501","0.59735215","0.5973135","0.59617627","0.5958427","0.59425616","0.5940887","0.5937748","0.5922607","0.589275","0.58898425","0.5887596","0.58870715","0.5879478","0.5858006","0.58542013","0.58437437","0.58384204","0.5838171","0.5835476","0.58344233","0.5826289","0.5825096","0.5821432","0.58090377","0.5800982","0.57956076","0.57928187","0.5787863","0.57724845","0.57712954","0.5765637","0.5763633","0.5763532","0.57627785","0.57576656","0.5755804","0.5753099","0.5750765","0.57375664","0.57345676","0.5730798","0.5729111","0.5727656","0.57206327","0.57195306","0.57130474","0.5712717","0.57113224","0.5710907","0.57096666","0.5708571","0.569432","0.5692964","0.5691259","0.5690894","0.5687975","0.56872946","0.5685693","0.5674075","0.5671656","0.56709516","0.5663202","0.56586915","0.56455827","0.564072","0.5631044","0.5626041","0.5622367","0.5622095","0.56215894"],"string":"[\n \"0.648662\",\n \"0.63990045\",\n \"0.6351997\",\n \"0.6327967\",\n \"0.6317841\",\n \"0.6282272\",\n \"0.62778795\",\n \"0.62594384\",\n \"0.62156016\",\n \"0.61883366\",\n \"0.6183509\",\n \"0.61677086\",\n \"0.61461943\",\n \"0.6115965\",\n \"0.6113757\",\n \"0.6105369\",\n \"0.60910106\",\n \"0.6073242\",\n \"0.60502017\",\n \"0.6050009\",\n \"0.6044658\",\n \"0.60356003\",\n \"0.6021604\",\n \"0.6006179\",\n \"0.6006179\",\n \"0.5998554\",\n \"0.5993392\",\n \"0.59902567\",\n \"0.5989504\",\n \"0.598655\",\n \"0.5978501\",\n \"0.59735215\",\n \"0.5973135\",\n \"0.59617627\",\n \"0.5958427\",\n \"0.59425616\",\n \"0.5940887\",\n \"0.5937748\",\n \"0.5922607\",\n \"0.589275\",\n \"0.58898425\",\n \"0.5887596\",\n \"0.58870715\",\n \"0.5879478\",\n \"0.5858006\",\n \"0.58542013\",\n \"0.58437437\",\n \"0.58384204\",\n \"0.5838171\",\n \"0.5835476\",\n \"0.58344233\",\n \"0.5826289\",\n \"0.5825096\",\n \"0.5821432\",\n \"0.58090377\",\n \"0.5800982\",\n \"0.57956076\",\n \"0.57928187\",\n \"0.5787863\",\n \"0.57724845\",\n \"0.57712954\",\n \"0.5765637\",\n \"0.5763633\",\n \"0.5763532\",\n \"0.57627785\",\n \"0.57576656\",\n \"0.5755804\",\n \"0.5753099\",\n \"0.5750765\",\n \"0.57375664\",\n \"0.57345676\",\n \"0.5730798\",\n \"0.5729111\",\n \"0.5727656\",\n \"0.57206327\",\n \"0.57195306\",\n \"0.57130474\",\n \"0.5712717\",\n \"0.57113224\",\n \"0.5710907\",\n \"0.57096666\",\n \"0.5708571\",\n \"0.569432\",\n \"0.5692964\",\n \"0.5691259\",\n \"0.5690894\",\n \"0.5687975\",\n \"0.56872946\",\n \"0.5685693\",\n \"0.5674075\",\n \"0.5671656\",\n \"0.56709516\",\n \"0.5663202\",\n \"0.56586915\",\n \"0.56455827\",\n \"0.564072\",\n \"0.5631044\",\n \"0.5626041\",\n \"0.5622367\",\n \"0.5622095\",\n \"0.56215894\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83779,"cells":{"query":{"kind":"string","value":"Return indices of recarray entries that match criteria."},"document":{"kind":"string","value":"def filter_columns(array, filters, combination='and'):\n if combination == 'and':\n fcomb = np.logical_and\n mask = np.ones(array.shape[0], dtype=np.bool)\n elif combination == 'or':\n fcomb = np.logical_or\n mask = np.zeros(array.shape[0], dtype=np.bool)\n else:\n raise ValueError('Combination mode not known: %s' % combination)\n\n for column in filters:\n mask = fcomb(mask, _filter_column(array, column, filters[column]))\n return mask"},"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 getIndexes(self, val):\n # Find where this value is listed. \n valNdx = (self.values == val).nonzero()[0]\n \n # If this value is not actually in those listed, then we \n # must return empty indexes\n if len(valNdx) == 0:\n start = 0\n end = 0\n else:\n # The index into counts, etc. for this value. \n valNdx = valNdx[0]\n start = self.start[valNdx]\n end = self.end[valNdx]\n \n # Create a tuple of index arrays, one for each index of the original array. \n ndx = ()\n for i in range(self.nDims):\n ndx += (self.indexes[start:end, i], )\n return ndx","def where(predicate):\n matching_indices = predicate.nonzero()\n if len(matching_indices) != 0:\n matching_indices = matching_indices.t().squeeze(0)\n return matching_indices","def find_indices(subset,fullset):\n nsub=len(subset)\n indices=-np.ones(subset.shape,dtype=int)\n indices_full=np.arange(0,len(fullset),1,dtype=int)\n for s in range(0,nsub):\n ind=fullset==subset[s]\n if any(ind):\n indices[s]=indices_full[ind][0] # numerical indices\n else:\n indices[s]=-1 # not found\n return indices","def getIndex(self,filt):\n indx = [i for i in xrange(len(self._header)) if filt == self._header[i]]\n return indx","def positions(self, searchstr: str):\n indices = []\n index = mybinsearch(self.sarray, searchstr, self.comp)\n if index >= 0:\n indices.append(index)\n return indices","def indices_using_group_array(group_array):\n unique_elements = np.unique(group_array)\n indices = []\n for unique_element in unique_elements:\n indices.append((unique_element,\n np.flatnonzero(group_array == unique_element)))\n return indices","def rows_matching(BL, indices):\n inBL0 = np.in1d(BL[:, 0], indices)\n # print 'BLUC[:,0] = ', BL[:,0]\n # print 'indices = ', indices\n # print 'inBL0 = ', inBL0\n inBL1 = np.in1d(BL[:, 1], indices)\n matches = np.where(np.logical_and(inBL0, inBL1))[0]\n return matches","def find_indices_of_matched_samples(self, X, a):\n\n matching_weights = self.matching.matches_to_weights()\n matches_mask = self._filter_matching_weights_by_mode(matching_weights)\n return matches_mask","def masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask,order='C'))[0]","def occ_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==1:\n indices.append(index)\n return indices","def get_indices(waves):\n prob_ = np.abs(waves)**2\n # batch\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\n prob = np.asarray(prob)\n prob_tot = np.sum(prob, axis=0)\n \n # cutoff\n length = np.size(prob[:,0])\n len10 = int(length/10)\n flags = np.zeros((prob.shape[1]), dtype=int)\n # hinges\n # 50% within 10% of corners\n\n # surface\n # 50% within 10% of surfaces\n # not already labelled hinges\n prob_left = np.sum(prob[0:len10,:], axis=0)\n frac_left = prob_left/prob_tot\n\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\n frac_right = np.divide(prob_right, prob_tot)\n\n for i in range(len(flags)):\n if frac_left[i]>0.5 or frac_right[i]>0.5:\n flags[i] = 1\n \n indices = [i for i, x in enumerate(flags) if x == 1]\n indices0 = [i for i, x in enumerate(flags) if x == 0]\n \n return indices, indices0","def get_subset_inds(self, adata_parent):\r\n subset_inds = np.ones(len(adata_parent), dtype=bool)\r\n for condition, values in self.subset_cond.items():\r\n subset_inds *= adata_parent.obs[condition].isin(values)\r\n return subset_inds","def lc_index(*args):\n index = []\n x = check_lc_data(args[0])\n i = 0\n for line in args[0].Data.LCData.lc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def _get_indx(self, t):\n t = np.array(t)\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\n self._data['start'])\n return np.array([np.where(row)[0][0] for row in a])","def getAllIndex(ldata, fldata):\n\treturn list(map(lambda e : fldata.index(e), ldata))","def linear_search(arr: IntList, query: int) -> int:\n arr_len: int = len(arr)\n for idx in range(arr_len):\n if arr[idx] == query:\n return idx\n return -1","def relevant_indexes(data, min_threshold):\n\n start_index = 1\n end_index = len(data) - 1\n\n for i in range(len(data)):\n if data[i] > min_threshold:\n start_index = i\n break\n\n for i in range(len(data)):\n if data[::-1][i] > min_threshold:\n end_index = i\n break\n\n return start_index, end_index","def get_indexes(self, variable, *args):\n\n return [get_subset_idxs(data, min, max)\n for data, (min, max) in args]","def _get_indexes(self, participants):\n tr_idx = int(np.floor(self.tr_size*len(participants)))\n j = self.val_size + self.tr_size\n val_idx = int(np.floor(j*len(participants)))\n return tr_idx, val_idx","def findArrayIndex(cluster_idx, tracked_clusters, index_tracked_clusters):\n \n found = np.zeros(5, dtype=int)\n \n # Index the clusters again since the unique cluster ids may be changed\n for i, indi in enumerate(cluster_idx):\n if indi == tracked_clusters[0]:\n index_tracked_clusters[0] = i\n found[0] = 1\n continue\n elif indi == tracked_clusters[1]:\n index_tracked_clusters[1] = i\n found[1] = 1\n continue\n elif indi == tracked_clusters[2]:\n index_tracked_clusters[2] = i\n found[2] = 1\n continue\n elif indi == tracked_clusters[3]:\n index_tracked_clusters[3] = i\n found[3] = 1\n continue\n elif indi == tracked_clusters[4]:\n index_tracked_clusters[4] = i\n found[4] = 1\n continue\n \n return found","def get_indexes(from_list, find_list):\n\n df_find = pd.DataFrame(find_list, columns=['value'])\n df_from = pd.DataFrame(list(zip(from_list, np.arange(len(from_list)))), columns=['value', 'index'])\n indexes = pd.merge(df_from, df_find, on='value', how='inner')['index'].values\n return indexes","def _get_indices(input_items, wanted_items):\r\n # Note: Some of this code is taken from Jeremy Widmann's\r\n # get_valid_indices() function, part of make_distance_histograms.py from QIIME 1.8.0.\r\n try:\r\n iter(input_items)\r\n except:\r\n raise ValueError(\"The input_items to search must be iterable.\")\r\n try:\r\n len(wanted_items)\r\n except:\r\n # We have a scalar value, so put it in a list.\r\n wanted_items = [wanted_items]\r\n if isinstance(wanted_items, basestring):\r\n wanted_items = [wanted_items]\r\n\r\n return [input_items.index(item)\r\n for item in wanted_items if item in input_items]","def get_indices(self):\n selection_model = self.selectionModel()\n return selection_model.selectedRows()","def getLandmarkindices(self):\n return self.subsetindices","def columnIndexes(a):\n nrows = (a.size-2)+1\n return a[1*np.arange(nrows)[:,None] + np.arange(2)]","def get_idxvals(self):\n input_rows = list()\n input_cols = list()\n for key in self.index:\n input_rows.append(key[0])\n input_cols.append(key[1])\n\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))","def indices_of_label(self, label_name):\n return self.indices_of('label', label_name)","def get_vacancy_indices(array):\t\n\tvacancy_indices = np.argwhere(array == 0)\n\treturn vacancy_indices","def indices_of(self, col_name, value):\n return list(self._obj[self._obj[col_name] == value].index\n ) if col_name in self._obj.columns else None","def _get_filter_idx(values, cutoff, percentile, keep_cells):\n cutoff = _get_percentile_cutoff(values, cutoff, percentile, required=True)\n if keep_cells is None:\n if isinstance(cutoff, numbers.Number):\n keep_cells = \"above\"\n else:\n keep_cells = \"between\"\n if keep_cells == \"above\":\n if not isinstance(cutoff, numbers.Number):\n raise ValueError(\n \"Expected a single cutoff with keep_cells='above'.\"\n \" Got {}\".format(cutoff)\n )\n keep_cells_idx = values > cutoff\n elif keep_cells == \"below\":\n if not isinstance(cutoff, numbers.Number):\n raise ValueError(\n \"Expected a single cutoff with keep_cells='below'.\"\n \" Got {}\".format(cutoff)\n )\n keep_cells_idx = values < cutoff\n elif keep_cells == \"between\":\n if isinstance(cutoff, numbers.Number) or len(cutoff) != 2:\n raise ValueError(\n \"Expected cutoff of length 2 with keep_cells='between'.\"\n \" Got {}\".format(cutoff)\n )\n keep_cells_idx = np.logical_and(\n values > np.min(cutoff), values < np.max(cutoff)\n )\n else:\n raise ValueError(\n \"Expected `keep_cells` in ['above', 'below', 'between']. \"\n \"Got {}\".format(keep_cells)\n )\n return keep_cells_idx","def return_inds(arr, target):\n\n # Convert list to numpy array\n arr = np.array(arr)\n # Determine all possible combinations, excluding combinations of the same number\n arr_combs = list(combinations(arr, 2))\n \n # Determine the sum of each combination\n sum_arr = np.array(list((map(sum, arr_combs)))) \n \n # Determine the index where the sum is equal to our target\n vals = arr_combs[np.where(sum_arr == target)[0][0]]\n \n # Determine the two indices\n ind_1 = np.where(arr == vals[0])[0][0]\n ind_2 = np.where(arr == vals[1])[0][0]\n\n return ind_1, ind_2","def find_neighbor_indices(atoms, probe, k):\r\n coords_all = atoms.getCoords()\r\n neighbor_indices = []\r\n atom_k = atoms[k]\r\n radius = atom_k.getRadius() + probe + probe\r\n\r\n indices = range(k)\r\n indices.extend(range(k+1, len(atoms)))\r\n\r\n for i in indices:\r\n\tdist = pos_distance(coords_all[k], coords_all[i])\r\n\t#dist = np.linalg.norm(coords_all[k] - coords_all[i])\r\n\tif dist < radius + atoms[i].getRadius():\r\n neighbor_indices.append(i)\r\n\r\n return neighbor_indices","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def index_dict(self):\n msk = self.load_mask()\n mski = enumerate(msk)\n ifiltered = (i for (i, m) in mski if m == 1)\n return {i: j for (j, i) in enumerate(ifiltered)}","def matrix_idx(n_hist, n_req, n_rows):\n\n flat_idx = []\n for i in range(n_rows):\n flat_idx.extend(range(i * n_req, (i + 1) * n_req + n_hist))\n # idx = np.unravel_index(flat_idx, (n_rows, n_hist + n_req))\n\n idx_matrix = np.reshape(flat_idx, (n_rows, n_hist + n_req))\n idxX = idx_matrix[:, n_req:]\n idxY = idx_matrix[:, :n_req]\n\n return idxX, idxY","def get_indexes(self):\n return set(k.index for k in self if k.has_index)","def get_idx(q_nbrs, q_mem):\n\n # Whether a matching sample can be found in neighbours or memory\n any_match_nbrs = T.any(q_nbrs, axis=1)\n any_match_mem = T.any(q_mem, axis=1)\n any_match = T.or_(any_match_nbrs, any_match_mem)\n\n # Look in neighbours then memory for corresponding sample.\n # If from neighbours, we need to retrieve the full mem idx.\n rows = T.arange(nbrs.shape[0])\n idx = T.switch(any_match_nbrs,\n nbrs[rows, tensor_choose_k(q_nbrs, self.rng, k=1)],\n tensor_choose_k(q_mem, self.rng, k=1, random=True))\n\n return (idx, any_match)","def non_masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]","def indices_above(a, val, extend_window: int=0, extend_dir='+'):\n idx_ = indices_below(a, val, extend_window, extend_dir)\n idx = np.ones_like(a, dtype=np.bool)\n idx[idx_] = 0\n return idx","def pt_index(*args):\n index = []\n x = check_pt_data(args[0])\n i = 0\n for line in args[0].Data.PTData.pt_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def getindex(self,name,searchfrom='name'):\n name = name.replace(':','_').lower()\n pat = re.compile(name)\n result = []\n\n for (i,elem) in enumerate(self.lat):\n if pat.search(elem[searchby]):\n result.append(i)\n return result","def tc_index(*args):\n index = []\n x = check_tc_data(args[0])\n i = 0\n for line in args[0].Data.TCData.tc_data:\n i += 1\n if line != x[i - 1]:\n index.append(0)\n elif line == x[i - 1]:\n index.append(i)\n return index","def findings_2_idx(findings, corner_2_idx, funcx, funcy):\n idx = []\n for finding in findings:\n x, y = finding\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\n idx.extend([corner_2_idx(c) for c in mesh])\n\n return np.unique(idx)","def get_index_for_group(groups, which_group):\n group_indexes = np.where(groups == float(which_group))[0]\n return group_indexes","def _dofidxs(self):\n return [const['dofidxs'] for i, const in self._constraints_df.iterrows()]","def get_data_indices(aperiodic_mode):\n\n indices = {\n 'CF' : 0,\n 'PW' : 1,\n 'BW' : 2,\n 'offset' : 0,\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\n }\n\n return indices","def findall(l, o):\n return [i for i, u in enumerate(l) if u==o]","def getMask(self,filt):\n indx = [self.mask[i] for i in xrange(len(self._header)) if filt == self._header[i]]\n return indx","def indexMatching(seq, condition):\n for i,x in enumerate(seq):\n if condition(x):\n return i\n return -1","def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\n _, ncol = self.shape\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\n mask = r != nodata\n idx = np.full(r.shape, nodata, dtype=int)\n idx[mask] = r[mask] * ncol + c[mask]\n return idx","def find_indices(colorhs, centres):\n\n indices = np.zeros(colorhs.shape[0], dtype=np.uint8)\n i = 0\n\n for hs in colorhs:\n # Past Euclidian distance\n past_ed = float(\"inf\")\n for cluster in range(centres.shape[0]):\n # Current Euclidian distance\n curr_ed = (sum((hs - centres[cluster, :]) ** 2)) ** 1/2\n # A frame belongs to the cluster with the minimum ed value.\n if curr_ed <= past_ed:\n past_ed = curr_ed\n indices[i] = cluster\n i += 1\n return indices","def get_agent_indices_of_type(array, agent_type):\t\n\tagent_indices = np.argwhere(array == agent_type)\n\treturn agent_indices","def atom_idxs(self):\n\n return np.array([atom.atom_idxs for atom in self])","def indices_for_column(self, colname):\n rv = []\n\n fieldid = self.attrs[colname]\n\n for index in self.indices:\n if index.columns[0] == fieldid:\n rv.append(index)\n\n # TODO: New indices\n\n return rv","def get_34index_list(self):\n msk = self.load_mask()\n return [i for (i,v) in enumerate(msk) if v==1]","def getIndices(schema_attr_levels):\n return np.array(list(schema_attr_levels.values())).flatten().tolist()","def vir_indices(self):\n indices = []\n for index,item in enumerate(self):\n if item==0:\n indices.append(index)\n return indices","def all_indices(haystack, needle):\n index = 0\n indices = list()\n while True:\n try:\n i = haystack.index(needle, index)\n except ValueError:\n break\n indices.append(i)\n index = i+1\n return indices","def _get_saved_indices(self, columns):\n # FIXME - assuming that the columns never change\n self._saved_indices = []\n for i in range(len(columns)):\n if self.pattern.match(columns[i]):\n self._saved_indices.append(i)\n return self._saved_indices","def get_relevant_indices(dataset, classes, target_classes):\n indices = []\n for i in range(len(dataset)):\n # Check if the label is in the target classes\n label_index = dataset[i][1] # ex: 3\n label_class = classes[label_index] # ex: 'cat'\n if label_class in target_classes:\n indices.append(i)\n return indices","def research_index(self,matrix,array_to_find):\n # type: (Array,Array) -> int\n for i,element in enumerate(matrix):\n if not (element-array_to_find).any():\n return i\n raise ValueError(\"Could not find array in the matrix\")","def indices(self) -> np.ndarray:\n return self.impl.indices","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","def indices(self):\n return tuple([slice(*r) for r in self.location])","def aprime_inds(self, att_inds):\n if type(att_inds) == set:\n att_inds = list(att_inds)\n try:\n common_extent = self.np_table[:, att_inds[0]].copy()\n except IndexError:\n return set(range(len(self.objects)))\n else:\n for att_ind in att_inds[1:]:\n common_extent &= self.np_table[:, att_ind]\n return common_extent.nonzero()[0]","def indmatch(ra1, dec1, ra2, dec2, tol):\n m = match(ra1, dec1, ra2, dec2, tol)\n c = m.ind > -1\n i1 = c.nonzero()[0]\n i2 = m.ind[c]\n return i1, i2","def get_checked_indices(self) -> List[int]:\n checked = list()\n for i in range(self.rowCount()):\n if bool(self.item(i, 0).checkState()):\n checked.append(i)\n\n return checked","def get_index_from_nested_list(data, conditions):\n assert type(np.array(data)) == np.ndarray, \"Please match list's element structure\"\n \n def check_function(element):\n return sum(apply_function_vector(conditions, element)) == len(conditions)\n\n condition_results = np.array(list(map(lambda element: True if check_function(element) else False, flatten_to_vector(data))))\n \n return condition_results.nonzero()","def get_recorded_indices(self, application_vertex, variable):\n if variable not in self.__sampling_rates:\n return []\n if self.__indexes[variable] is None:\n return range(application_vertex.n_atoms)\n return self.__indexes[variable]","def toIndexes(self, binaryVector):\n\t\treturn n.array([i for i,v in enumerate(binaryVector) if v], dtype=\"int32\")","def get_indices(self):\r\n return self._indices","def getAtomIndices( structure, resname ):\n atom_indices_ligand = []\n topology = structure.topology\n for atom in topology.atoms():\n if str(resname) in atom.residue.name:\n atom_indices_ligand.append(atom.index)\n\n return atom_indices_ligand","def indices_below(a, val, extend_window: int=0, extend_dir='-'):\n if extend_dir == '-':\n inv = True\n elif extend_dir == '+':\n inv = False\n else:\n raise ValueError(\"'extend_dir' can only have '+' or '-' as value\")\n nz = np.nonzero(a<val)[0]\n idx = np.zeros_like(a, dtype=np.bool)\n idx[_extend_window(nz, extend_window, a.shape[0], inv)] = 1\n return idx","def get_indexes(self,\r\n childrentoo=True,\r\n levels=0):\r\n\r\n if childrentoo:\r\n if levels==0:\r\n entrylist = self.apply_limit(self.find_within(indexfrom=Index(0),orequal=True))\r\n # if entrylist is , default to all notes, with limit applied.\r\n\r\n else:\r\n entrylist = self.apply_limit([a_temp for a_temp in self.indexes()\r\n if Index(a_temp) > Index(str(0))\r\n and Index(a_temp).level()<=levels])\r\n\r\n else:\r\n entrylist = self.apply_limit([a_temp for a_temp in self.indexes()\r\n if Index(a_temp) > Index(str(0))\r\n and Index(a_temp).is_top()])\r\n\r\n return entrylist","def get_agent_indices(array):\t\n\tagent_indices = np.argwhere(array != 0)\n\treturn agent_indices","def indexof(self, value, tag=WORD):\n match = lambda a, b: a.endswith(\"*\") and b.startswith(a[:-1]) or a==b\n indices = []\n for i in range(len(self.words)):\n if match(value, unicode(self.get(i, tag))):\n indices.append(i)\n return indices","def get_antecedent_constant_indexes(rule):\n constant_indexes = dict()\n for antecedent_atom in extract_logic_predicates(rule.antecedent):\n predicate = antecedent_atom.functor.name\n indexes = {\n i\n for i, arg in enumerate(antecedent_atom.args)\n if isinstance(arg, Constant)\n }\n if len(indexes) > 0:\n constant_indexes[predicate] = indexes\n return constant_indexes","def indices(self):\n return range(len(self))","def get_indexes(self, items: Iterable[_T]) -> List[int]:\n return [self.get_index(item) for item in items]","def occurence(main_seq,sub_seq):\n start= 0\n indices =[]\n while True:\n start = main_seq.find(sub_seq,start)\n if start > 0:\n indices.append(start)\n else:\n break\n start +=1\n return indices","def get_row_indices(df, col, vals):\n\n return list(df[df[col].isin(vals)].index)","def indexes(self, fields):\r\n\r\n indexes = [self.index(field) for field in fields]\r\n\r\n return tuple(indexes)","def inidices(self):\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]","def matchloc(alist,val): \n return [ilc for ilc,jlc in enumerate(alist) if jlc==val]","def get_indices(self):\n\n def query(rel): \n return \"\"\"SELECT pg_class.relname, pg_index.indkey\n FROM pg_class, pg_index\n WHERE (pg_index.indexrelid = pg_class.oid)\n AND (pg_index.indrelid = (SELECT pg_class.oid FROM pg_class WHERE pg_class.relname = \\'{}\\'));\n \"\"\".format(rel)\n\n rels = tpch.schema.keys()\n idxs = dict.fromkeys(rels)\n\n with self.tpch_cxn.cursor() as curs:\n for rel in rels:\n curs.execute(query(rel))\n idxs_ = curs.fetchall()\n idxs_ = dict(idxs_) # index -> index keys \n \n # TODO this can be done cleanly in query\n # pg_index.indkey is a SQL array of attributes indices in their respective tables\n split=lambda attrs: attrs.split() \n cast=lambda attrs: list(map(lambda attr: int(attr)-1, attrs))\n invertindex=lambda attrs: list(np.array(schema[rel])[attrs])\n\n attrs = idxs_.values() \n attrs = list(map(split, attrs))\n attrs = list(map(cast, attrs))\n attrs = list(map(invertindex, attrs))\n\n idxs_ = {key : attrs[i] for i, key in enumerate(idxs_.keys())}\n idxs[rel] = idxs_\n return idxs","def _get_k_indices(self, ks):\n if self.staticneighs:\n idx_ks = ks\n else:\n idx_ks = [self.ks.index(e) for e in ks]\n return idx_ks","def get_data_index(self, data, data_point):\n\n if self.method == 1:\n idx = np.where((data[0,:]==data_point[0]) & \\\n (data[1,:]==data_point[1]) & \\\n (data[2,:]==data_point[2]) & \\\n (data[3,:]==data_point[3]) & \\\n (data[4,:]==data_point[4]))\n else:\n idx = np.where((data[0,:]==data_point[0]) & \\\n (data[1,:]==data_point[1]) & \\\n (data[2,:]==data_point[2]) & \\\n (data[3,:]==data_point[3]))\n\n idx = idx[0][0]\n\n return idx","def indsWithin(vals, extr, edges=True):\n assert np.ndim(vals) == 1, \"Only `ndim = 1` arrays allowed!\"\n bnds = minmax(extr)\n if(edges):\n inds = np.where((vals >= bnds[0]) & (vals <= bnds[1]))[0]\n else:\n inds = np.where((vals > bnds[0]) & (vals < bnds[1]))[0]\n\n return inds","def index_equals_value_search1(arr):\n for key, value in enumerate(arr):\n if value == key:\n return value\n return -1","def get_predicate_indices(tags: List[str]) -> List[int]:\n return [ind for ind, tag in enumerate(tags) if \"V\" in tag]","def getLandmarkindices(self):\n return self.subsetnodes_indices","def _get_subset_timesteps_idxs(timesteps, subset_timesteps, strict_match=True):\n # Check timesteps format\n subset_timesteps = _check_timesteps(subset_timesteps)\n timesteps = _check_timesteps(timesteps)\n # Ensure same time precision for comparison\n subset_timesteps = subset_timesteps.astype(timesteps.dtype)\n # Retrieve idxs corresponding to subset_timesteps\n subset_idxs = np.array(\n [idx for idx, v in enumerate(timesteps) if v in set(subset_timesteps)]\n )\n # If no idxs available,means that subset_timesteps are not in the period covered by 'data_dyamic\n if subset_idxs.size == 0:\n raise ValueError(\n \"All 'forecast_reference_times' are not within the time period covered by 'data_dynamic'.\"\n )\n if len(subset_idxs) != len(subset_timesteps):\n timesteps_not_in = subset_timesteps[\n np.isin(subset_timesteps, timesteps, invert=True)\n ]\n if strict_match:\n raise ValueError(\n \"The following 'forecast_start_time(s)' are not within the time period covered by 'data_dynamic': {}\".format(\n list(timesteps_not_in)\n )\n )\n else:\n warnings.warn(\n \"The following 'forecast_start_time(s)' are not within the time period covered by 'data_dynamic': {}\".format(\n list(timesteps_not_in)\n )\n )\n return subset_idxs","def search(query, idx):\n\n if len(query) == 0:\n return []\n ordered = {}\n for e in query:\n ordered[e] = len(idx[e])\n ordered = sorted(ordered.items(), key = lambda d: d[1])\n results = idx[ordered[0][0]]\n i = 1\n while i < len(ordered):\n results = intersect(results, idx[ordered[i][0]])\n i += 1\n return results","def get_prediction_indices(self):\r\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\r\n self.full_df = self.full_df[::-1]\r\n self.full_df.reset_index(inplace=True)\r\n self.full_df.drop('index', axis=1, inplace=True)\r\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\r\n (self.full_df['Dates'] >= self.pred_start))\r\n self.pred_indices = list(self.full_df[date_condition].index)","def other_indices(mentions, toks):\r\n indices = []\r\n for i, tok in enumerate(toks):\r\n for m in mentions:\r\n if m['start'] <= tok['start'] and tok['end'] <= m['end']:\r\n indices.append(i)\r\n break\r\n return indices","def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\n res = np.zeros(len(object_seq))\n for i, obj in enumerate(object_seq):\n if obj in self.obj_to_idx:\n res[i] = self.obj_to_idx[obj]\n else:\n res[i] = self.start-1\n return res","def get_indexes(self, dataset):\n\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\n return indexs","def arg_indices(concept, mentions, toks):\r\n indices = []\r\n for i, tok in enumerate(toks):\r\n for m in mentions:\r\n if 'start' not in m:\r\n logging.warning('%s', m)\r\n if m['id'] == concept and m['start'] <= tok['start'] and tok['end'] <= m['end']:\r\n indices.append(i)\r\n break\r\n return indices","def list_item_indexes(list_arg: list, item: Any) -> Tuple[int, ...]:\n indexes = [index for index, value in enumerate(list_arg) if value == item]\n return indexes","def getBitArrayIndices(self, key):\n\t\treturnList = []\n\t\tfor i in range(1, self.k + 1):\n\t\t\treturnList.append((hash(key) + i * mmh3.hash(key)) % self.m)\n\t\t#print \"Indices list for key: \", key, \" is: \", str(returnList)\n\t\treturn returnList","def subsequence_search(subseq, sequence):\n index_tuples = filter(lambda (start, end): sequence[start:end] == subseq, [(start,start+len(subseq)) for start in range(len(sequence) - len(subseq) + 1)])\n return index_tuples"],"string":"[\n \"def getIndexes(self, val):\\n # Find where this value is listed. \\n valNdx = (self.values == val).nonzero()[0]\\n \\n # If this value is not actually in those listed, then we \\n # must return empty indexes\\n if len(valNdx) == 0:\\n start = 0\\n end = 0\\n else:\\n # The index into counts, etc. for this value. \\n valNdx = valNdx[0]\\n start = self.start[valNdx]\\n end = self.end[valNdx]\\n \\n # Create a tuple of index arrays, one for each index of the original array. \\n ndx = ()\\n for i in range(self.nDims):\\n ndx += (self.indexes[start:end, i], )\\n return ndx\",\n \"def where(predicate):\\n matching_indices = predicate.nonzero()\\n if len(matching_indices) != 0:\\n matching_indices = matching_indices.t().squeeze(0)\\n return matching_indices\",\n \"def find_indices(subset,fullset):\\n nsub=len(subset)\\n indices=-np.ones(subset.shape,dtype=int)\\n indices_full=np.arange(0,len(fullset),1,dtype=int)\\n for s in range(0,nsub):\\n ind=fullset==subset[s]\\n if any(ind):\\n indices[s]=indices_full[ind][0] # numerical indices\\n else:\\n indices[s]=-1 # not found\\n return indices\",\n \"def getIndex(self,filt):\\n indx = [i for i in xrange(len(self._header)) if filt == self._header[i]]\\n return indx\",\n \"def positions(self, searchstr: str):\\n indices = []\\n index = mybinsearch(self.sarray, searchstr, self.comp)\\n if index >= 0:\\n indices.append(index)\\n return indices\",\n \"def indices_using_group_array(group_array):\\n unique_elements = np.unique(group_array)\\n indices = []\\n for unique_element in unique_elements:\\n indices.append((unique_element,\\n np.flatnonzero(group_array == unique_element)))\\n return indices\",\n \"def rows_matching(BL, indices):\\n inBL0 = np.in1d(BL[:, 0], indices)\\n # print 'BLUC[:,0] = ', BL[:,0]\\n # print 'indices = ', indices\\n # print 'inBL0 = ', inBL0\\n inBL1 = np.in1d(BL[:, 1], indices)\\n matches = np.where(np.logical_and(inBL0, inBL1))[0]\\n return matches\",\n \"def find_indices_of_matched_samples(self, X, a):\\n\\n matching_weights = self.matching.matches_to_weights()\\n matches_mask = self._filter_matching_weights_by_mode(matching_weights)\\n return matches_mask\",\n \"def masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask,order='C'))[0]\",\n \"def occ_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==1:\\n indices.append(index)\\n return indices\",\n \"def get_indices(waves):\\n prob_ = np.abs(waves)**2\\n # batch\\n prob = [np.sum(prob_[i:i+4,:], axis=0) for i in range(0, len(waves[:,0]), 4)]\\n prob = np.asarray(prob)\\n prob_tot = np.sum(prob, axis=0)\\n \\n # cutoff\\n length = np.size(prob[:,0])\\n len10 = int(length/10)\\n flags = np.zeros((prob.shape[1]), dtype=int)\\n # hinges\\n # 50% within 10% of corners\\n\\n # surface\\n # 50% within 10% of surfaces\\n # not already labelled hinges\\n prob_left = np.sum(prob[0:len10,:], axis=0)\\n frac_left = prob_left/prob_tot\\n\\n prob_right = np.sum(prob[length-len10:length,:], axis=0)\\n frac_right = np.divide(prob_right, prob_tot)\\n\\n for i in range(len(flags)):\\n if frac_left[i]>0.5 or frac_right[i]>0.5:\\n flags[i] = 1\\n \\n indices = [i for i, x in enumerate(flags) if x == 1]\\n indices0 = [i for i, x in enumerate(flags) if x == 0]\\n \\n return indices, indices0\",\n \"def get_subset_inds(self, adata_parent):\\r\\n subset_inds = np.ones(len(adata_parent), dtype=bool)\\r\\n for condition, values in self.subset_cond.items():\\r\\n subset_inds *= adata_parent.obs[condition].isin(values)\\r\\n return subset_inds\",\n \"def lc_index(*args):\\n index = []\\n x = check_lc_data(args[0])\\n i = 0\\n for line in args[0].Data.LCData.lc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def _get_indx(self, t):\\n t = np.array(t)\\n a = (t[:, np.newaxis] <= self._data['stop']) & (t[:, np.newaxis] >=\\n self._data['start'])\\n return np.array([np.where(row)[0][0] for row in a])\",\n \"def getAllIndex(ldata, fldata):\\n\\treturn list(map(lambda e : fldata.index(e), ldata))\",\n \"def linear_search(arr: IntList, query: int) -> int:\\n arr_len: int = len(arr)\\n for idx in range(arr_len):\\n if arr[idx] == query:\\n return idx\\n return -1\",\n \"def relevant_indexes(data, min_threshold):\\n\\n start_index = 1\\n end_index = len(data) - 1\\n\\n for i in range(len(data)):\\n if data[i] > min_threshold:\\n start_index = i\\n break\\n\\n for i in range(len(data)):\\n if data[::-1][i] > min_threshold:\\n end_index = i\\n break\\n\\n return start_index, end_index\",\n \"def get_indexes(self, variable, *args):\\n\\n return [get_subset_idxs(data, min, max)\\n for data, (min, max) in args]\",\n \"def _get_indexes(self, participants):\\n tr_idx = int(np.floor(self.tr_size*len(participants)))\\n j = self.val_size + self.tr_size\\n val_idx = int(np.floor(j*len(participants)))\\n return tr_idx, val_idx\",\n \"def findArrayIndex(cluster_idx, tracked_clusters, index_tracked_clusters):\\n \\n found = np.zeros(5, dtype=int)\\n \\n # Index the clusters again since the unique cluster ids may be changed\\n for i, indi in enumerate(cluster_idx):\\n if indi == tracked_clusters[0]:\\n index_tracked_clusters[0] = i\\n found[0] = 1\\n continue\\n elif indi == tracked_clusters[1]:\\n index_tracked_clusters[1] = i\\n found[1] = 1\\n continue\\n elif indi == tracked_clusters[2]:\\n index_tracked_clusters[2] = i\\n found[2] = 1\\n continue\\n elif indi == tracked_clusters[3]:\\n index_tracked_clusters[3] = i\\n found[3] = 1\\n continue\\n elif indi == tracked_clusters[4]:\\n index_tracked_clusters[4] = i\\n found[4] = 1\\n continue\\n \\n return found\",\n \"def get_indexes(from_list, find_list):\\n\\n df_find = pd.DataFrame(find_list, columns=['value'])\\n df_from = pd.DataFrame(list(zip(from_list, np.arange(len(from_list)))), columns=['value', 'index'])\\n indexes = pd.merge(df_from, df_find, on='value', how='inner')['index'].values\\n return indexes\",\n \"def _get_indices(input_items, wanted_items):\\r\\n # Note: Some of this code is taken from Jeremy Widmann's\\r\\n # get_valid_indices() function, part of make_distance_histograms.py from QIIME 1.8.0.\\r\\n try:\\r\\n iter(input_items)\\r\\n except:\\r\\n raise ValueError(\\\"The input_items to search must be iterable.\\\")\\r\\n try:\\r\\n len(wanted_items)\\r\\n except:\\r\\n # We have a scalar value, so put it in a list.\\r\\n wanted_items = [wanted_items]\\r\\n if isinstance(wanted_items, basestring):\\r\\n wanted_items = [wanted_items]\\r\\n\\r\\n return [input_items.index(item)\\r\\n for item in wanted_items if item in input_items]\",\n \"def get_indices(self):\\n selection_model = self.selectionModel()\\n return selection_model.selectedRows()\",\n \"def getLandmarkindices(self):\\n return self.subsetindices\",\n \"def columnIndexes(a):\\n nrows = (a.size-2)+1\\n return a[1*np.arange(nrows)[:,None] + np.arange(2)]\",\n \"def get_idxvals(self):\\n input_rows = list()\\n input_cols = list()\\n for key in self.index:\\n input_rows.append(key[0])\\n input_cols.append(key[1])\\n\\n return list(OrderedSet(input_rows)), list(OrderedSet(input_cols))\",\n \"def indices_of_label(self, label_name):\\n return self.indices_of('label', label_name)\",\n \"def get_vacancy_indices(array):\\t\\n\\tvacancy_indices = np.argwhere(array == 0)\\n\\treturn vacancy_indices\",\n \"def indices_of(self, col_name, value):\\n return list(self._obj[self._obj[col_name] == value].index\\n ) if col_name in self._obj.columns else None\",\n \"def _get_filter_idx(values, cutoff, percentile, keep_cells):\\n cutoff = _get_percentile_cutoff(values, cutoff, percentile, required=True)\\n if keep_cells is None:\\n if isinstance(cutoff, numbers.Number):\\n keep_cells = \\\"above\\\"\\n else:\\n keep_cells = \\\"between\\\"\\n if keep_cells == \\\"above\\\":\\n if not isinstance(cutoff, numbers.Number):\\n raise ValueError(\\n \\\"Expected a single cutoff with keep_cells='above'.\\\"\\n \\\" Got {}\\\".format(cutoff)\\n )\\n keep_cells_idx = values > cutoff\\n elif keep_cells == \\\"below\\\":\\n if not isinstance(cutoff, numbers.Number):\\n raise ValueError(\\n \\\"Expected a single cutoff with keep_cells='below'.\\\"\\n \\\" Got {}\\\".format(cutoff)\\n )\\n keep_cells_idx = values < cutoff\\n elif keep_cells == \\\"between\\\":\\n if isinstance(cutoff, numbers.Number) or len(cutoff) != 2:\\n raise ValueError(\\n \\\"Expected cutoff of length 2 with keep_cells='between'.\\\"\\n \\\" Got {}\\\".format(cutoff)\\n )\\n keep_cells_idx = np.logical_and(\\n values > np.min(cutoff), values < np.max(cutoff)\\n )\\n else:\\n raise ValueError(\\n \\\"Expected `keep_cells` in ['above', 'below', 'between']. \\\"\\n \\\"Got {}\\\".format(keep_cells)\\n )\\n return keep_cells_idx\",\n \"def return_inds(arr, target):\\n\\n # Convert list to numpy array\\n arr = np.array(arr)\\n # Determine all possible combinations, excluding combinations of the same number\\n arr_combs = list(combinations(arr, 2))\\n \\n # Determine the sum of each combination\\n sum_arr = np.array(list((map(sum, arr_combs)))) \\n \\n # Determine the index where the sum is equal to our target\\n vals = arr_combs[np.where(sum_arr == target)[0][0]]\\n \\n # Determine the two indices\\n ind_1 = np.where(arr == vals[0])[0][0]\\n ind_2 = np.where(arr == vals[1])[0][0]\\n\\n return ind_1, ind_2\",\n \"def find_neighbor_indices(atoms, probe, k):\\r\\n coords_all = atoms.getCoords()\\r\\n neighbor_indices = []\\r\\n atom_k = atoms[k]\\r\\n radius = atom_k.getRadius() + probe + probe\\r\\n\\r\\n indices = range(k)\\r\\n indices.extend(range(k+1, len(atoms)))\\r\\n\\r\\n for i in indices:\\r\\n\\tdist = pos_distance(coords_all[k], coords_all[i])\\r\\n\\t#dist = np.linalg.norm(coords_all[k] - coords_all[i])\\r\\n\\tif dist < radius + atoms[i].getRadius():\\r\\n neighbor_indices.append(i)\\r\\n\\r\\n return neighbor_indices\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def index_dict(self):\\n msk = self.load_mask()\\n mski = enumerate(msk)\\n ifiltered = (i for (i, m) in mski if m == 1)\\n return {i: j for (j, i) in enumerate(ifiltered)}\",\n \"def matrix_idx(n_hist, n_req, n_rows):\\n\\n flat_idx = []\\n for i in range(n_rows):\\n flat_idx.extend(range(i * n_req, (i + 1) * n_req + n_hist))\\n # idx = np.unravel_index(flat_idx, (n_rows, n_hist + n_req))\\n\\n idx_matrix = np.reshape(flat_idx, (n_rows, n_hist + n_req))\\n idxX = idx_matrix[:, n_req:]\\n idxY = idx_matrix[:, :n_req]\\n\\n return idxX, idxY\",\n \"def get_indexes(self):\\n return set(k.index for k in self if k.has_index)\",\n \"def get_idx(q_nbrs, q_mem):\\n\\n # Whether a matching sample can be found in neighbours or memory\\n any_match_nbrs = T.any(q_nbrs, axis=1)\\n any_match_mem = T.any(q_mem, axis=1)\\n any_match = T.or_(any_match_nbrs, any_match_mem)\\n\\n # Look in neighbours then memory for corresponding sample.\\n # If from neighbours, we need to retrieve the full mem idx.\\n rows = T.arange(nbrs.shape[0])\\n idx = T.switch(any_match_nbrs,\\n nbrs[rows, tensor_choose_k(q_nbrs, self.rng, k=1)],\\n tensor_choose_k(q_mem, self.rng, k=1, random=True))\\n\\n return (idx, any_match)\",\n \"def non_masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]\",\n \"def indices_above(a, val, extend_window: int=0, extend_dir='+'):\\n idx_ = indices_below(a, val, extend_window, extend_dir)\\n idx = np.ones_like(a, dtype=np.bool)\\n idx[idx_] = 0\\n return idx\",\n \"def pt_index(*args):\\n index = []\\n x = check_pt_data(args[0])\\n i = 0\\n for line in args[0].Data.PTData.pt_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def getindex(self,name,searchfrom='name'):\\n name = name.replace(':','_').lower()\\n pat = re.compile(name)\\n result = []\\n\\n for (i,elem) in enumerate(self.lat):\\n if pat.search(elem[searchby]):\\n result.append(i)\\n return result\",\n \"def tc_index(*args):\\n index = []\\n x = check_tc_data(args[0])\\n i = 0\\n for line in args[0].Data.TCData.tc_data:\\n i += 1\\n if line != x[i - 1]:\\n index.append(0)\\n elif line == x[i - 1]:\\n index.append(i)\\n return index\",\n \"def findings_2_idx(findings, corner_2_idx, funcx, funcy):\\n idx = []\\n for finding in findings:\\n x, y = finding\\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\\n idx.extend([corner_2_idx(c) for c in mesh])\\n\\n return np.unique(idx)\",\n \"def get_index_for_group(groups, which_group):\\n group_indexes = np.where(groups == float(which_group))[0]\\n return group_indexes\",\n \"def _dofidxs(self):\\n return [const['dofidxs'] for i, const in self._constraints_df.iterrows()]\",\n \"def get_data_indices(aperiodic_mode):\\n\\n indices = {\\n 'CF' : 0,\\n 'PW' : 1,\\n 'BW' : 2,\\n 'offset' : 0,\\n 'knee' : 1 if aperiodic_mode == 'knee' else None,\\n 'exponent' : 1 if aperiodic_mode == 'fixed' else 2\\n }\\n\\n return indices\",\n \"def findall(l, o):\\n return [i for i, u in enumerate(l) if u==o]\",\n \"def getMask(self,filt):\\n indx = [self.mask[i] for i in xrange(len(self._header)) if filt == self._header[i]]\\n return indx\",\n \"def indexMatching(seq, condition):\\n for i,x in enumerate(seq):\\n if condition(x):\\n return i\\n return -1\",\n \"def xy_to_idx(self, xs, ys, mask=None, mask_outside=False, nodata=-1):\\n _, ncol = self.shape\\n r, c = self.rowcol(xs, ys, mask=mask, mask_outside=mask_outside, nodata=nodata)\\n mask = r != nodata\\n idx = np.full(r.shape, nodata, dtype=int)\\n idx[mask] = r[mask] * ncol + c[mask]\\n return idx\",\n \"def find_indices(colorhs, centres):\\n\\n indices = np.zeros(colorhs.shape[0], dtype=np.uint8)\\n i = 0\\n\\n for hs in colorhs:\\n # Past Euclidian distance\\n past_ed = float(\\\"inf\\\")\\n for cluster in range(centres.shape[0]):\\n # Current Euclidian distance\\n curr_ed = (sum((hs - centres[cluster, :]) ** 2)) ** 1/2\\n # A frame belongs to the cluster with the minimum ed value.\\n if curr_ed <= past_ed:\\n past_ed = curr_ed\\n indices[i] = cluster\\n i += 1\\n return indices\",\n \"def get_agent_indices_of_type(array, agent_type):\\t\\n\\tagent_indices = np.argwhere(array == agent_type)\\n\\treturn agent_indices\",\n \"def atom_idxs(self):\\n\\n return np.array([atom.atom_idxs for atom in self])\",\n \"def indices_for_column(self, colname):\\n rv = []\\n\\n fieldid = self.attrs[colname]\\n\\n for index in self.indices:\\n if index.columns[0] == fieldid:\\n rv.append(index)\\n\\n # TODO: New indices\\n\\n return rv\",\n \"def get_34index_list(self):\\n msk = self.load_mask()\\n return [i for (i,v) in enumerate(msk) if v==1]\",\n \"def getIndices(schema_attr_levels):\\n return np.array(list(schema_attr_levels.values())).flatten().tolist()\",\n \"def vir_indices(self):\\n indices = []\\n for index,item in enumerate(self):\\n if item==0:\\n indices.append(index)\\n return indices\",\n \"def all_indices(haystack, needle):\\n index = 0\\n indices = list()\\n while True:\\n try:\\n i = haystack.index(needle, index)\\n except ValueError:\\n break\\n indices.append(i)\\n index = i+1\\n return indices\",\n \"def _get_saved_indices(self, columns):\\n # FIXME - assuming that the columns never change\\n self._saved_indices = []\\n for i in range(len(columns)):\\n if self.pattern.match(columns[i]):\\n self._saved_indices.append(i)\\n return self._saved_indices\",\n \"def get_relevant_indices(dataset, classes, target_classes):\\n indices = []\\n for i in range(len(dataset)):\\n # Check if the label is in the target classes\\n label_index = dataset[i][1] # ex: 3\\n label_class = classes[label_index] # ex: 'cat'\\n if label_class in target_classes:\\n indices.append(i)\\n return indices\",\n \"def research_index(self,matrix,array_to_find):\\n # type: (Array,Array) -> int\\n for i,element in enumerate(matrix):\\n if not (element-array_to_find).any():\\n return i\\n raise ValueError(\\\"Could not find array in the matrix\\\")\",\n \"def indices(self) -> np.ndarray:\\n return self.impl.indices\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\n \"def indices(self):\\n return tuple([slice(*r) for r in self.location])\",\n \"def aprime_inds(self, att_inds):\\n if type(att_inds) == set:\\n att_inds = list(att_inds)\\n try:\\n common_extent = self.np_table[:, att_inds[0]].copy()\\n except IndexError:\\n return set(range(len(self.objects)))\\n else:\\n for att_ind in att_inds[1:]:\\n common_extent &= self.np_table[:, att_ind]\\n return common_extent.nonzero()[0]\",\n \"def indmatch(ra1, dec1, ra2, dec2, tol):\\n m = match(ra1, dec1, ra2, dec2, tol)\\n c = m.ind > -1\\n i1 = c.nonzero()[0]\\n i2 = m.ind[c]\\n return i1, i2\",\n \"def get_checked_indices(self) -> List[int]:\\n checked = list()\\n for i in range(self.rowCount()):\\n if bool(self.item(i, 0).checkState()):\\n checked.append(i)\\n\\n return checked\",\n \"def get_index_from_nested_list(data, conditions):\\n assert type(np.array(data)) == np.ndarray, \\\"Please match list's element structure\\\"\\n \\n def check_function(element):\\n return sum(apply_function_vector(conditions, element)) == len(conditions)\\n\\n condition_results = np.array(list(map(lambda element: True if check_function(element) else False, flatten_to_vector(data))))\\n \\n return condition_results.nonzero()\",\n \"def get_recorded_indices(self, application_vertex, variable):\\n if variable not in self.__sampling_rates:\\n return []\\n if self.__indexes[variable] is None:\\n return range(application_vertex.n_atoms)\\n return self.__indexes[variable]\",\n \"def toIndexes(self, binaryVector):\\n\\t\\treturn n.array([i for i,v in enumerate(binaryVector) if v], dtype=\\\"int32\\\")\",\n \"def get_indices(self):\\r\\n return self._indices\",\n \"def getAtomIndices( structure, resname ):\\n atom_indices_ligand = []\\n topology = structure.topology\\n for atom in topology.atoms():\\n if str(resname) in atom.residue.name:\\n atom_indices_ligand.append(atom.index)\\n\\n return atom_indices_ligand\",\n \"def indices_below(a, val, extend_window: int=0, extend_dir='-'):\\n if extend_dir == '-':\\n inv = True\\n elif extend_dir == '+':\\n inv = False\\n else:\\n raise ValueError(\\\"'extend_dir' can only have '+' or '-' as value\\\")\\n nz = np.nonzero(a<val)[0]\\n idx = np.zeros_like(a, dtype=np.bool)\\n idx[_extend_window(nz, extend_window, a.shape[0], inv)] = 1\\n return idx\",\n \"def get_indexes(self,\\r\\n childrentoo=True,\\r\\n levels=0):\\r\\n\\r\\n if childrentoo:\\r\\n if levels==0:\\r\\n entrylist = self.apply_limit(self.find_within(indexfrom=Index(0),orequal=True))\\r\\n # if entrylist is , default to all notes, with limit applied.\\r\\n\\r\\n else:\\r\\n entrylist = self.apply_limit([a_temp for a_temp in self.indexes()\\r\\n if Index(a_temp) > Index(str(0))\\r\\n and Index(a_temp).level()<=levels])\\r\\n\\r\\n else:\\r\\n entrylist = self.apply_limit([a_temp for a_temp in self.indexes()\\r\\n if Index(a_temp) > Index(str(0))\\r\\n and Index(a_temp).is_top()])\\r\\n\\r\\n return entrylist\",\n \"def get_agent_indices(array):\\t\\n\\tagent_indices = np.argwhere(array != 0)\\n\\treturn agent_indices\",\n \"def indexof(self, value, tag=WORD):\\n match = lambda a, b: a.endswith(\\\"*\\\") and b.startswith(a[:-1]) or a==b\\n indices = []\\n for i in range(len(self.words)):\\n if match(value, unicode(self.get(i, tag))):\\n indices.append(i)\\n return indices\",\n \"def get_antecedent_constant_indexes(rule):\\n constant_indexes = dict()\\n for antecedent_atom in extract_logic_predicates(rule.antecedent):\\n predicate = antecedent_atom.functor.name\\n indexes = {\\n i\\n for i, arg in enumerate(antecedent_atom.args)\\n if isinstance(arg, Constant)\\n }\\n if len(indexes) > 0:\\n constant_indexes[predicate] = indexes\\n return constant_indexes\",\n \"def indices(self):\\n return range(len(self))\",\n \"def get_indexes(self, items: Iterable[_T]) -> List[int]:\\n return [self.get_index(item) for item in items]\",\n \"def occurence(main_seq,sub_seq):\\n start= 0\\n indices =[]\\n while True:\\n start = main_seq.find(sub_seq,start)\\n if start > 0:\\n indices.append(start)\\n else:\\n break\\n start +=1\\n return indices\",\n \"def get_row_indices(df, col, vals):\\n\\n return list(df[df[col].isin(vals)].index)\",\n \"def indexes(self, fields):\\r\\n\\r\\n indexes = [self.index(field) for field in fields]\\r\\n\\r\\n return tuple(indexes)\",\n \"def inidices(self):\\n return [Index(name, index) for name, index in self._data['indices'].iteritems()]\",\n \"def matchloc(alist,val): \\n return [ilc for ilc,jlc in enumerate(alist) if jlc==val]\",\n \"def get_indices(self):\\n\\n def query(rel): \\n return \\\"\\\"\\\"SELECT pg_class.relname, pg_index.indkey\\n FROM pg_class, pg_index\\n WHERE (pg_index.indexrelid = pg_class.oid)\\n AND (pg_index.indrelid = (SELECT pg_class.oid FROM pg_class WHERE pg_class.relname = \\\\'{}\\\\'));\\n \\\"\\\"\\\".format(rel)\\n\\n rels = tpch.schema.keys()\\n idxs = dict.fromkeys(rels)\\n\\n with self.tpch_cxn.cursor() as curs:\\n for rel in rels:\\n curs.execute(query(rel))\\n idxs_ = curs.fetchall()\\n idxs_ = dict(idxs_) # index -> index keys \\n \\n # TODO this can be done cleanly in query\\n # pg_index.indkey is a SQL array of attributes indices in their respective tables\\n split=lambda attrs: attrs.split() \\n cast=lambda attrs: list(map(lambda attr: int(attr)-1, attrs))\\n invertindex=lambda attrs: list(np.array(schema[rel])[attrs])\\n\\n attrs = idxs_.values() \\n attrs = list(map(split, attrs))\\n attrs = list(map(cast, attrs))\\n attrs = list(map(invertindex, attrs))\\n\\n idxs_ = {key : attrs[i] for i, key in enumerate(idxs_.keys())}\\n idxs[rel] = idxs_\\n return idxs\",\n \"def _get_k_indices(self, ks):\\n if self.staticneighs:\\n idx_ks = ks\\n else:\\n idx_ks = [self.ks.index(e) for e in ks]\\n return idx_ks\",\n \"def get_data_index(self, data, data_point):\\n\\n if self.method == 1:\\n idx = np.where((data[0,:]==data_point[0]) & \\\\\\n (data[1,:]==data_point[1]) & \\\\\\n (data[2,:]==data_point[2]) & \\\\\\n (data[3,:]==data_point[3]) & \\\\\\n (data[4,:]==data_point[4]))\\n else:\\n idx = np.where((data[0,:]==data_point[0]) & \\\\\\n (data[1,:]==data_point[1]) & \\\\\\n (data[2,:]==data_point[2]) & \\\\\\n (data[3,:]==data_point[3]))\\n\\n idx = idx[0][0]\\n\\n return idx\",\n \"def indsWithin(vals, extr, edges=True):\\n assert np.ndim(vals) == 1, \\\"Only `ndim = 1` arrays allowed!\\\"\\n bnds = minmax(extr)\\n if(edges):\\n inds = np.where((vals >= bnds[0]) & (vals <= bnds[1]))[0]\\n else:\\n inds = np.where((vals > bnds[0]) & (vals < bnds[1]))[0]\\n\\n return inds\",\n \"def index_equals_value_search1(arr):\\n for key, value in enumerate(arr):\\n if value == key:\\n return value\\n return -1\",\n \"def get_predicate_indices(tags: List[str]) -> List[int]:\\n return [ind for ind, tag in enumerate(tags) if \\\"V\\\" in tag]\",\n \"def getLandmarkindices(self):\\n return self.subsetnodes_indices\",\n \"def _get_subset_timesteps_idxs(timesteps, subset_timesteps, strict_match=True):\\n # Check timesteps format\\n subset_timesteps = _check_timesteps(subset_timesteps)\\n timesteps = _check_timesteps(timesteps)\\n # Ensure same time precision for comparison\\n subset_timesteps = subset_timesteps.astype(timesteps.dtype)\\n # Retrieve idxs corresponding to subset_timesteps\\n subset_idxs = np.array(\\n [idx for idx, v in enumerate(timesteps) if v in set(subset_timesteps)]\\n )\\n # If no idxs available,means that subset_timesteps are not in the period covered by 'data_dyamic\\n if subset_idxs.size == 0:\\n raise ValueError(\\n \\\"All 'forecast_reference_times' are not within the time period covered by 'data_dynamic'.\\\"\\n )\\n if len(subset_idxs) != len(subset_timesteps):\\n timesteps_not_in = subset_timesteps[\\n np.isin(subset_timesteps, timesteps, invert=True)\\n ]\\n if strict_match:\\n raise ValueError(\\n \\\"The following 'forecast_start_time(s)' are not within the time period covered by 'data_dynamic': {}\\\".format(\\n list(timesteps_not_in)\\n )\\n )\\n else:\\n warnings.warn(\\n \\\"The following 'forecast_start_time(s)' are not within the time period covered by 'data_dynamic': {}\\\".format(\\n list(timesteps_not_in)\\n )\\n )\\n return subset_idxs\",\n \"def search(query, idx):\\n\\n if len(query) == 0:\\n return []\\n ordered = {}\\n for e in query:\\n ordered[e] = len(idx[e])\\n ordered = sorted(ordered.items(), key = lambda d: d[1])\\n results = idx[ordered[0][0]]\\n i = 1\\n while i < len(ordered):\\n results = intersect(results, idx[ordered[i][0]])\\n i += 1\\n return results\",\n \"def get_prediction_indices(self):\\r\\n if self.full_df['Dates'][0] > self.full_df['Dates'][len(self.full_df) - 1]:\\r\\n self.full_df = self.full_df[::-1]\\r\\n self.full_df.reset_index(inplace=True)\\r\\n self.full_df.drop('index', axis=1, inplace=True)\\r\\n date_condition = ((self.full_df['Dates'] <= self.pred_end) &\\r\\n (self.full_df['Dates'] >= self.pred_start))\\r\\n self.pred_indices = list(self.full_df[date_condition].index)\",\n \"def other_indices(mentions, toks):\\r\\n indices = []\\r\\n for i, tok in enumerate(toks):\\r\\n for m in mentions:\\r\\n if m['start'] <= tok['start'] and tok['end'] <= m['end']:\\r\\n indices.append(i)\\r\\n break\\r\\n return indices\",\n \"def objects_to_indexes(self, object_seq: Sequence[Any]) -> np.ndarray:\\n res = np.zeros(len(object_seq))\\n for i, obj in enumerate(object_seq):\\n if obj in self.obj_to_idx:\\n res[i] = self.obj_to_idx[obj]\\n else:\\n res[i] = self.start-1\\n return res\",\n \"def get_indexes(self, dataset):\\n\\n indexs = [random.randint(0, len(dataset)) for _ in range(3)]\\n return indexs\",\n \"def arg_indices(concept, mentions, toks):\\r\\n indices = []\\r\\n for i, tok in enumerate(toks):\\r\\n for m in mentions:\\r\\n if 'start' not in m:\\r\\n logging.warning('%s', m)\\r\\n if m['id'] == concept and m['start'] <= tok['start'] and tok['end'] <= m['end']:\\r\\n indices.append(i)\\r\\n break\\r\\n return indices\",\n \"def list_item_indexes(list_arg: list, item: Any) -> Tuple[int, ...]:\\n indexes = [index for index, value in enumerate(list_arg) if value == item]\\n return indexes\",\n \"def getBitArrayIndices(self, key):\\n\\t\\treturnList = []\\n\\t\\tfor i in range(1, self.k + 1):\\n\\t\\t\\treturnList.append((hash(key) + i * mmh3.hash(key)) % self.m)\\n\\t\\t#print \\\"Indices list for key: \\\", key, \\\" is: \\\", str(returnList)\\n\\t\\treturn returnList\",\n \"def subsequence_search(subseq, sequence):\\n index_tuples = filter(lambda (start, end): sequence[start:end] == subseq, [(start,start+len(subseq)) for start in range(len(sequence) - len(subseq) + 1)])\\n return index_tuples\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66991407","0.6451458","0.6383022","0.63413405","0.62079084","0.61890465","0.6104715","0.60981125","0.60734594","0.6064704","0.60335106","0.6032053","0.6005462","0.6005365","0.59307843","0.5874397","0.58559686","0.5853381","0.583678","0.58103853","0.5805355","0.579123","0.5789811","0.5780788","0.5768719","0.576835","0.57625407","0.5746834","0.57292926","0.5716682","0.5706014","0.5702569","0.56992847","0.56992847","0.5698575","0.56957364","0.5688341","0.567564","0.5648913","0.5647851","0.5631704","0.5631251","0.5626453","0.56252825","0.5622416","0.56197196","0.5614128","0.5614123","0.56007487","0.5593027","0.55819935","0.5580997","0.5578685","0.5574346","0.5572929","0.5572712","0.5568863","0.55626386","0.55623126","0.55620867","0.55542064","0.555411","0.55487317","0.5548265","0.5536121","0.55315924","0.55305797","0.55166024","0.5515374","0.5508491","0.5495586","0.54851437","0.5474368","0.54630035","0.5457374","0.5457373","0.5454383","0.5450453","0.54421234","0.5436116","0.5434766","0.54331803","0.54268616","0.54262704","0.54261655","0.5421192","0.5411998","0.5390658","0.53810894","0.538088","0.5378705","0.5375427","0.5372677","0.5372353","0.5360377","0.53578347","0.53553575","0.5347472","0.5347107","0.53455454","0.53412026"],"string":"[\n \"0.66991407\",\n \"0.6451458\",\n \"0.6383022\",\n \"0.63413405\",\n \"0.62079084\",\n \"0.61890465\",\n \"0.6104715\",\n \"0.60981125\",\n \"0.60734594\",\n \"0.6064704\",\n \"0.60335106\",\n \"0.6032053\",\n \"0.6005462\",\n \"0.6005365\",\n \"0.59307843\",\n \"0.5874397\",\n \"0.58559686\",\n \"0.5853381\",\n \"0.583678\",\n \"0.58103853\",\n \"0.5805355\",\n \"0.579123\",\n \"0.5789811\",\n \"0.5780788\",\n \"0.5768719\",\n \"0.576835\",\n \"0.57625407\",\n \"0.5746834\",\n \"0.57292926\",\n \"0.5716682\",\n \"0.5706014\",\n \"0.5702569\",\n \"0.56992847\",\n \"0.56992847\",\n \"0.5698575\",\n \"0.56957364\",\n \"0.5688341\",\n \"0.567564\",\n \"0.5648913\",\n \"0.5647851\",\n \"0.5631704\",\n \"0.5631251\",\n \"0.5626453\",\n \"0.56252825\",\n \"0.5622416\",\n \"0.56197196\",\n \"0.5614128\",\n \"0.5614123\",\n \"0.56007487\",\n \"0.5593027\",\n \"0.55819935\",\n \"0.5580997\",\n \"0.5578685\",\n \"0.5574346\",\n \"0.5572929\",\n \"0.5572712\",\n \"0.5568863\",\n \"0.55626386\",\n \"0.55623126\",\n \"0.55620867\",\n \"0.55542064\",\n \"0.555411\",\n \"0.55487317\",\n \"0.5548265\",\n \"0.5536121\",\n \"0.55315924\",\n \"0.55305797\",\n \"0.55166024\",\n \"0.5515374\",\n \"0.5508491\",\n \"0.5495586\",\n \"0.54851437\",\n \"0.5474368\",\n \"0.54630035\",\n \"0.5457374\",\n \"0.5457373\",\n \"0.5454383\",\n \"0.5450453\",\n \"0.54421234\",\n \"0.5436116\",\n \"0.5434766\",\n \"0.54331803\",\n \"0.54268616\",\n \"0.54262704\",\n \"0.54261655\",\n \"0.5421192\",\n \"0.5411998\",\n \"0.5390658\",\n \"0.53810894\",\n \"0.538088\",\n \"0.5378705\",\n \"0.5375427\",\n \"0.5372677\",\n \"0.5372353\",\n \"0.5360377\",\n \"0.53578347\",\n \"0.53553575\",\n \"0.5347472\",\n \"0.5347107\",\n \"0.53455454\",\n \"0.53412026\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83780,"cells":{"query":{"kind":"string","value":"Takes an iterable, and puts into the expected format of a tuple if triplet tuples."},"document":{"kind":"string","value":"def reformat_files(cls, files):\n\n common_path = None # src base\n out_files = []\n for fil in files:\n if isinstance(fil, string_types):\n if len(files) == 1:\n common_prefix = op.dirname(fil) + '/'\n elif common_path is None:\n common_prefix = op.commonprefix(files)\n if fil[len(common_prefix):][0] != '/':\n common_path = op.dirname(common_prefix) + '/'\n else:\n common_path = common_prefix\n out_files.append((fil[len(common_path):], fil, dict()))\n elif not isinstance(fil, collections.Iterable):\n raise ValueError(\"Unexpected format: %s\" % str(fil))\n elif len(fil) == 2: # assume src, dest\n out_files.append((fil[0], fil[1], dict()))\n elif len(fil) == 3:\n out_files.append(fil)\n else:\n raise ValueError(\"Unexpected format: %s\" % str(fil))\n return out_files"},"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 flatten_as_tuple(iterable):\n return tuple(chain(*iterable))","def strtuple(iterable): \n string = ''\n function = type(strtuple)\n for i in iterable:\n if isinstance(i , function):\n string += i.__name__ + ', '\n else:\n string += str(i) + ', '\n string = string.rstrip(', ')\n string = '(' + string + ')'\n return string","def tup(item, ret_is_single=False):\r\n #return true for iterables, except for strings, which is what we want\r\n if hasattr(item, '__iter__'):\r\n return (item, False) if ret_is_single else item\r\n else:\r\n return ((item,), True) if ret_is_single else (item,)","def to_tuple(\n value: Union[TypeNumber, Iterable[TypeNumber]],\n length: int = 1,\n ) -> Union[TypeTripletFloat, Tuple[TypeNumber, ...]]:\n try:\n iter(value)\n value = tuple(value)\n except TypeError:\n value = length * (value,)\n return value","def tuple(x):\n pass","def _to_tuple(values: Union[int, Iterable[int]]) -> Tuple[int, ...]:\n try:\n return tuple(values)\n except TypeError:\n return (values,)","def make_tuple(tuple_like):\n tuple_like = (\n tuple_like\n if isinstance(tuple_like, (list, tuple))\n else (tuple_like, tuple_like)\n )\n return tuple_like","def format_tuple(data):\n return \",\".join([str(item) for item in data])","def test_tuples():\n\n @type_checked\n def _run_test(something:(str, int, bool)):\n assert isinstance(something[0], str)\n assert isinstance(something[1], int)\n assert isinstance(something[2], bool)\n\n _run_test(something=(None, \"12\", 1))","def unpack_all_equal_tuple(t):\n if not isinstance(t, tuple):\n return t\n\n assert all(x == t[0] for x in t)\n return t[0]","def triplet(value):\n return tuplet(value, 3, 2)","def tuple_from_sequence(*args):\n return tuple(args)","def tupleStrFormat(tupl):\n string = \"this is a tuple (\"\n for element in tupl:\n string += str(element) + \", \"\n string += \")\"\n return string","def tuple_cast(inputs, dst_type):\n return iter_cast(inputs, dst_type, return_type=tuple)","def str_tuple(item):\n return \"{}:{}\".format(item[0], item[1])","def zipper_list_and_tuple_tests():\n assert_with_message(zipper((1, 2, 3), [\"hello\", \"mr.\", \"world\"]), [(1, \"hello\"), (2, \"mr.\"), (3, \"world\")])\n assert_with_message(zipper([1, 2, 3], (\"hello\", \"mr.\", \"world\")), [(1, \"hello\"), (2, \"mr.\"), (3, \"world\")])\n assert_with_message(zipper([1, 2, 3], ()), [])\n assert_with_message(zipper([], (\"hello\", \"mr.\", \"world\")), [])\n assert_with_message(zipper([], ()), [])\n print(\"All tests with a list and a tuple as parameters passed!\")","def build_tuple(self, t):\n comma = self.art_type([self.string_type(', ')],\n baseline=0,\n breakpoints=[1])\n repr_elems = self.concatenate(t, comma)\n return self.build_container(\n repr_elems, self.left_parenthesis, self.right_parenthesis)","def tuple_gen(self, gen):\n for r in gen:\n yield self.convert_v6_to_tuple(r)","def _polymorph_args_to_tuple( args):\n\n if len(args) == 1 and isinstance(args[0], Iterable):\n args = args[0]\n return list(tuple(args))","def astuple(self):\n try:\n return tuple([x.astuple() for x in self])\n except Exception:\n pass\n return tuple([x for x in self])","def single_element_tuple():\n single = (1,)\n print(type(single)) # <type 'tuple'>","def tupleize(num_items=None, conv=float, dtype=tuple):\n def split_values(value):\n \"\"\"Convert comma-separated string *value* to a tuple of numbers.\"\"\"\n try:\n result = dtype([conv(x) for x in value.split(',')])\n except:\n raise argparse.ArgumentTypeError('Expect comma-separated tuple')\n\n if num_items and len(result) != num_items:\n raise argparse.ArgumentTypeError('Expected {} items'.format(num_items))\n\n return result\n\n return split_values","def as_tuple(*values):\n cleaned_values = []\n for value in values:\n if isinstance(value, (tuple, list)):\n cleaned_values.extend(value)\n else:\n cleaned_values.append(value)\n return tuple(cleaned_values)","def list_to_tuple(list):\n templist = []\n for i in list:\n try:\n templist.append(int(i))\n except ValueError:\n print('Error. Please enter only integers.')\n return ()\n return tuple(templist)","def make_tuple():\n thing = 1, 2, 3, 4\n print(type(thing))","def element_to_tuple(list_of_elements):\n return list(map(lambda x: tuple(x), list_of_elements))","def try_tuple(obj):\n # type: (Union[T, Tuple[T]]) -> Tuple[T]\n if isinstance(obj, tuple):\n return obj\n\n return obj, # NOTE the comma, made into tuple","def astuple(v: Any) -> Tuple[Any, ...]:\n return to_tuple(v, reuse_instances=False, convert_sets=False)","def main():\n sampleTuple = (100, 200, 300)\n print(tupleStrFormat(sampleTuple))","def is_tuple_of(seq, expected_type):\n return is_seq_of(seq, expected_type, seq_type=tuple)","def _tupleize(d):\n return [(key, value) for key, value in d.items()]","def test_as_tuple(self):\n\n vec = Vec3(7, 8, 9)\n\n self.assertEqual((7, 8, 9), vec.as_tuple())","def triplewise(iterable):\n # triplewise('ABCDEFG') -> ABC BCD CDE DEF EFG\n for (a, _), (b, c) in pairwise(pairwise(iterable)):\n yield a, b, c","def pairwise(iterable: Iterable,\n tuple_size: int):\n return zip_longest(*(islice(it, pos, None) for pos, it in enumerate(tee(iterable, tuple_size))))","def is_sequence_of_tuple(items):\n return all(isinstance(item, tuple) for item in items)","def toTupple(obj):\n try:\n return tuple(map(toTupple, obj))\n except TypeError:\n return obj","def test_tuple_passed_as_iterable():\n tree = Tree((10, 5, 100))\n assert tree.root.value == 10\n assert tree.root.left.value == 5\n assert tree.root.right.value == 100","def _tupstr(tuple_):\n return ', '.join(list(map(str, tuple_)))","def _silent_ntuple_ ( s , *args ) :\n from Ostap.Utils import mute_py \n with mute_py() : \n tup = _TU.__nTuple__(s , *args )\n logger.info ( 'Booked n-tuple %s' % tup )\n return tup","def hinted_tuple_hook(obj):\n if '__tuple__' in obj:\n return tuple(obj['items'])\n return obj","def _covert_list_tensor_to_tuple_tensor(list_of_tensor):\n if isinstance(list_of_tensor, list):\n tuple_of_tensor = ()\n for tensor in list_of_tensor:\n tuple_of_tensor += (tensor,)\n return tuple_of_tensor\n return list_of_tensor","def unzip(iterable: Iterable[Tuple[Any, ...]]) -> Tuple[Iterator[Any], ...]:\n first, iterator = _common.peek(iter(iterable))\n if first is None:\n return ()\n tees = itertools.tee(iterator, len(first))\n return (map(operator.itemgetter(i), tee) for i, tee in enumerate(tees))","def _unpack_tuple(x):\n if len(x) == 1:\n return x[0]\n else:\n return x","def _unpack_tuple(x):\n if len(x) == 1:\n return x[0]\n else:\n return x","def _separate(xs):\n if isinstance(xs, typing.Sequence):\n return tuple(_single_separate(x) for x in xs)\n else:\n return _single_separate(xs)","def tuple(self, arg: SeField[Any]) -> str:\n if is_bare_tuple(arg.type):\n return arg.varname\n elif is_variable_tuple(arg.type):\n earg = arg[0]\n earg.name = \"v\"\n return f\"tuple({self.render(earg)} for v in {arg.varname})\"\n else:\n rvalues = []\n for i, _ in enumerate(type_args(arg.type)):\n r = arg[i]\n r.name = f\"{arg.varname}[{i}]\"\n rvalues.append(self.render(r))\n return f\"({', '.join(rvalues)},)\" # trailing , is required for single element tuples","def serialize_tuple(self, obj):\n return '(' + ''.join([self.serialize(i) for i in obj]) + 't'","def tuple(self, spec):\n return tuple(self(inner_spec) for inner_spec in spec)","def __wrap_with_tuple(self) -> tuple:\r\n l = list()\r\n length = len(self.data)\r\n while self.idx < length:\r\n l.append(self.__parse())\r\n return tuple(l)","def pairwise(iterable):\n a = iter(iterable)\n return zip(a, a, a)","def testTypTagsTupleEnforced(self) -> None:\n fake_typ_tuple = typing.cast(tuple, ['win', 'x86'])\n with self.assertRaises(AssertionError):\n _ = data_types.Result('test', fake_typ_tuple, (1, 10), 'build_id')","def pairwise(iterable: Iterable[Any]) -> Sequence[Any]:\n a, b = tee(iterable)\n next(b, None)\n return [\"\".join(t) for t in zip(a, b)]","def no_parentheses():\n weird_tuple = 1, 2, 3\n print(weird_tuple) # (1, 2, 3)\n print(type(weird_tuple)) # <type 'tuple'>","def gen_4_tuples(it):\n\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))","def gen_4_tuples(it):\n\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))","def zipper_two_tuples_tests():\n assert_with_message(zipper((1, 2, 3), (\"hello\", \"mr.\", \"world\")), [(1, \"hello\"), (2, \"mr.\"), (3, \"world\")])\n assert_with_message(zipper((), (\"hello\", \"mr.\", \"world\")), [])\n assert_with_message(zipper((1, 2, 3), ()), [])\n assert_with_message(zipper((), ()), [])\n print(\"All tests with two tuples as parameters passed!\")","def prettyTuple(app, tup, seq=None, _asString=False, item=RESULT, **options):\n\n display = app.display\n\n if not display.check(\"prettyTuple\", options):\n return \"\"\n\n dContext = display.distill(options)\n colorMap = dContext.colorMap\n highlights = dContext.highlights\n condenseType = dContext.condenseType\n condensed = dContext.condensed\n\n _browse = app._browse\n inNb = app.inNb\n asString = _browse or _asString\n\n if len(tup) == 0:\n if asString:\n return \"\"\n else:\n return\n\n api = app.api\n N = api.N\n sortKey = N.sortKey\n\n containers = {tup[0]} if condensed else condenseSet(api, tup, condenseType)\n highlights = getTupleHighlights(api, tup, highlights, colorMap, condenseType)\n seqRep = \"\" if seq is None else f\" <i>{seq}</i>\"\n\n if not asString:\n dh(f\"<p><b>{item}</b>{seqRep}\", inNb=inNb)\n if asString:\n html = []\n for t in sorted(containers, key=sortKey):\n h = app.pretty(\n t,\n highlights=highlights,\n **display.consume(options, \"highlights\"),\n )\n if asString:\n html.append(h)\n if asString:\n return \"\".join(html)","def tuple_ty(*tuple_types : MIRType) -> 'MIRTupleType':\n return MIRTupleType(list(tuple_types))","def test_insertion_for_each_element_in_iterable_tuple(empty_list):\n b = (1, 2, 3)\n bb = LinkedList([])\n bb.insert(b)\n assert len(bb) == 3","def is_tuple(obj):\n return type(obj) is tuple","def pack_tuple(self, values):\n assert isinstance(values, (tuple, list))\n cardinality = [struct_L.pack(len(values))]\n packed_items = [self.pack_field(v) for v in values]\n return b''.join(itertools.chain(cardinality, packed_items))","def batch_iter(iterable: Iterable[T], size: int) -> Iterator[Tuple[T]]:\n # make sure we can deal with iterables like lists too\n sourceiter = iter(iterable)\n # call islice until it returns an empty tuple\n return iter(lambda: tuple(islice(sourceiter, size)), ())","def test_mix_tuple_issue_387(self):\n assert_type_and_value(\n tuple,\n (42, 'Test'),\n self.env(\n 'MIX_TUPLE',\n default=(0, ''),\n cast=lambda t: tuple(\n map(\n lambda v: int(v) if v.isdigit() else v.strip(),\n [c for c in t.strip('()').split(',')]\n )\n ),\n )\n )","def totuple(self, arr):\n\n\t\ttry:\n\t\t return tuple(self.totuple(i) for i in arr)\n\t\texcept TypeError:\n\t\t return arr","def generate_from_tuple(t):\n\n data_generator(*t)","def to_tuple(self) -> Tuple[Any, Iterable[Tuple]]:\n return non_recursive_tree_to_tuple(self)","def split_in_pairs(arg: Iterable) -> Iterable[Tuple]:\n # We are using zip_longest with one clever hack:\n # https://docs.python.org/3/library/itertools.html#itertools.zip_longest\n # We create an iterator out of the list and then pass the same iterator to\n # the function two times. Thus the function consumes a different element\n # from the iterator each time and produces the desired result.\n iterator = iter(arg)\n return zip_longest(iterator, iterator)","def test_single_tuple(self):\n conn = self.connect()\n c = conn.cursor()\n self.safe_create_table(\n conn, \"mystuff\", \"create table mystuff (id integer primary key)\"\n )\n c.execute(\"insert into mystuff (id) values (1)\")\n c.execute(\"insert into mystuff (id) values (2)\")\n c.execute(\"select id from mystuff where id in %s\", ((1,),))\n self.assertEqual([(1,)], list(c.fetchall()))\n c.close()","def test_tuple_input(self):\n \n self._tuple1 = 1, 2, 3\n self._tuple2 = 'yes', 'y', 'hey'\n self.assertEqual(False, maps.map_list(self._tuple1))\n self.assertEqual(False, maps.map_list(self._tuple2))","def pairwise(iterable: Iterable[Any]) -> Iterable[Any]:\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)","def pairwise(iterable):\n a = iter(iterable)\n return zip(a, a)","def tupleofwords_to_wordoftuples(tupleofwords):\n return list(zip_longest(*tupleofwords, fillvalue=None))","def convert_to_tuple(v):\n if not isinstance(v, tuple):\n return tuple(v)\n else:\n return v","def _list_to_tuple(v):\n if isinstance(v, list):\n return tuple(v)\n return v","def tuple_merge(tuples):\n\n\t# Add your code here\n\treturn","def pairwise(iterable):\n a, b = itertools.tee(iterable)\n next(b, None)\n return zip(a, b)","def pairwise(iterable):\n a, b = itertools.tee(iterable)\n next(b, None)\n return zip(a, b)","def pairwise(iterable):\n a, b = itertools.tee(iterable)\n next(b, None)\n return zip(a, b)","def delimit_tuple(tuple_: tuple, delimiter=\",\"):\n if not type(tuple_) == tuple:\n raise TypeError(\n \"Expected a list or tuple, \" \"but got {}\".format(type(tuple_).__name__)\n )\n return delimiter.join(map(str, tuple_))","def unzip(seq: Iterable) -> tuple:\n seq = iter(seq)\n # check how many iterators we need\n try:\n first = tuple(next(seq))\n except StopIteration:\n return tuple()\n # and create them\n niters = len(first)\n seqs = itertools.tee(itertoolz.cons(first, seq), niters)\n return tuple(itertools.starmap(itertoolz.pluck, enumerate(seqs)))","def create_record_tuple(ilist):\n list_length = len(ilist)\n if list_length:\n rec_tuple = '('\n for row in list[0:list_length-1]:\n rec_tuple += str(row)\n rec_tuple += ','\n rec_tuple += str(list[list_length-1])\n rec_tuple += ')'\n else: rec_tuple = '()'\n return rec_tuple","def pairwise(iterable: Iterable):\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)","def pairwise(iterable):\n a, b = tee(iterable)\n next(b, None)\n return izip(a, b)","def test_query_simple_tuple(self):\n tab = 'query_test'\n cols = ['col1', 'col2']\n rows_in = [(1, 2), (2, 4), (3, 6)]\n\n with self.dbh.table_recreate(tab, cols, 'integer'):\n self.dbh.insert_many(tab, cols, rows_in)\n rows_out = self.dbh.query_simple(tab, cols, rowtype=tuple)\n self.assertEqual(set(rows_in), set(rows_out))","def to_tuple(self):\n return tuple(self.to_list())","def pairwise(iterable):\r\n a = iter(iterable)\r\n return izip(a, a)","def test_complex_to_tuple():\n\n @type_checked\n def _run_test(thing:(complex,)):\n assert thing == (complex(15, 2),)\n\n _run_test(complex(15, 2))","def test_defined_in_iter():\n\n @type_checked\n def _run_test(thing:[(int, str, str)]):\n for group in thing:\n assert isinstance(group[0], int)\n assert isinstance(group[1], str)\n assert isinstance(group[2], str)\n assert len(thing) == 4\n\n _run_test(thing=[\n (12.3, None, False),\n (\"12.1\", True, 1),\n (False, 10, 12.1),\n (True, 14.9, None),\n ])","def tuple_check(*args, func=None):\n func = func or inspect.stack()[2][3]\n for var in args:\n if not isinstance(var, (tuple, collections.abc.Sequence)):\n name = type(var).__name__\n raise TupleError(\n 'Function {} expected tuple, {} got instead.'.format(func, name))","def create_type_tuple(*elems):\n tuple = ast.Tuple()\n\n tuple.elts = []\n for elem in elems:\n tuple.elts.append(elem)\n\n return tuple","def visit_tuple_type(self, left: TupleType) -> T:","def _item_or_tuple(self, seq):\n t = tuple(seq)\n if self._is_multi:\n return t\n else:\n return t[0]","def hint_tuples(o):\n if isinstance(o, tuple):\n return dict(_type='tuple', items=o)\n elif isinstance(o, list):\n return [hint_tuples(el) for el in o]\n else:\n return o","def get_tuples(outputs) -> list:\n return list(map(get_tuples_helper, outputs))","def unzip_finite(\n iterable: Iterable[Tuple[Any, ...]],\n) -> Tuple[Iterator[Any], ...]:\n for zipped in zip(*iterable):\n yield zipped","def trigrams(content):\n for item in range(len(content) - 2):\n buld_tupls = tuple(contents[item: item + 2])\n # test to make sure that two items are in a tuple\n # print(buld_tupls)\n # print(type(buld_tupls))","def make_iterable(arg):\n return arg if is_iterable(arg) else (arg,)","def convert_tuple(self, v, t):\n return tuple(self(v, t)\n for v, t in zip(v, t.elements))","def _convert_to_tuple(r):\n if not r:\n return r\n else:\n return (r[\"token\"], r[\"value\"], r[\"code\"], r[\"address\"],)","def pairwise(iterable):\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)","def pairwise(iterable):\n a, b = tee(iterable)\n next(b, None)\n return zip(a, b)"],"string":"[\n \"def flatten_as_tuple(iterable):\\n return tuple(chain(*iterable))\",\n \"def strtuple(iterable): \\n string = ''\\n function = type(strtuple)\\n for i in iterable:\\n if isinstance(i , function):\\n string += i.__name__ + ', '\\n else:\\n string += str(i) + ', '\\n string = string.rstrip(', ')\\n string = '(' + string + ')'\\n return string\",\n \"def tup(item, ret_is_single=False):\\r\\n #return true for iterables, except for strings, which is what we want\\r\\n if hasattr(item, '__iter__'):\\r\\n return (item, False) if ret_is_single else item\\r\\n else:\\r\\n return ((item,), True) if ret_is_single else (item,)\",\n \"def to_tuple(\\n value: Union[TypeNumber, Iterable[TypeNumber]],\\n length: int = 1,\\n ) -> Union[TypeTripletFloat, Tuple[TypeNumber, ...]]:\\n try:\\n iter(value)\\n value = tuple(value)\\n except TypeError:\\n value = length * (value,)\\n return value\",\n \"def tuple(x):\\n pass\",\n \"def _to_tuple(values: Union[int, Iterable[int]]) -> Tuple[int, ...]:\\n try:\\n return tuple(values)\\n except TypeError:\\n return (values,)\",\n \"def make_tuple(tuple_like):\\n tuple_like = (\\n tuple_like\\n if isinstance(tuple_like, (list, tuple))\\n else (tuple_like, tuple_like)\\n )\\n return tuple_like\",\n \"def format_tuple(data):\\n return \\\",\\\".join([str(item) for item in data])\",\n \"def test_tuples():\\n\\n @type_checked\\n def _run_test(something:(str, int, bool)):\\n assert isinstance(something[0], str)\\n assert isinstance(something[1], int)\\n assert isinstance(something[2], bool)\\n\\n _run_test(something=(None, \\\"12\\\", 1))\",\n \"def unpack_all_equal_tuple(t):\\n if not isinstance(t, tuple):\\n return t\\n\\n assert all(x == t[0] for x in t)\\n return t[0]\",\n \"def triplet(value):\\n return tuplet(value, 3, 2)\",\n \"def tuple_from_sequence(*args):\\n return tuple(args)\",\n \"def tupleStrFormat(tupl):\\n string = \\\"this is a tuple (\\\"\\n for element in tupl:\\n string += str(element) + \\\", \\\"\\n string += \\\")\\\"\\n return string\",\n \"def tuple_cast(inputs, dst_type):\\n return iter_cast(inputs, dst_type, return_type=tuple)\",\n \"def str_tuple(item):\\n return \\\"{}:{}\\\".format(item[0], item[1])\",\n \"def zipper_list_and_tuple_tests():\\n assert_with_message(zipper((1, 2, 3), [\\\"hello\\\", \\\"mr.\\\", \\\"world\\\"]), [(1, \\\"hello\\\"), (2, \\\"mr.\\\"), (3, \\\"world\\\")])\\n assert_with_message(zipper([1, 2, 3], (\\\"hello\\\", \\\"mr.\\\", \\\"world\\\")), [(1, \\\"hello\\\"), (2, \\\"mr.\\\"), (3, \\\"world\\\")])\\n assert_with_message(zipper([1, 2, 3], ()), [])\\n assert_with_message(zipper([], (\\\"hello\\\", \\\"mr.\\\", \\\"world\\\")), [])\\n assert_with_message(zipper([], ()), [])\\n print(\\\"All tests with a list and a tuple as parameters passed!\\\")\",\n \"def build_tuple(self, t):\\n comma = self.art_type([self.string_type(', ')],\\n baseline=0,\\n breakpoints=[1])\\n repr_elems = self.concatenate(t, comma)\\n return self.build_container(\\n repr_elems, self.left_parenthesis, self.right_parenthesis)\",\n \"def tuple_gen(self, gen):\\n for r in gen:\\n yield self.convert_v6_to_tuple(r)\",\n \"def _polymorph_args_to_tuple( args):\\n\\n if len(args) == 1 and isinstance(args[0], Iterable):\\n args = args[0]\\n return list(tuple(args))\",\n \"def astuple(self):\\n try:\\n return tuple([x.astuple() for x in self])\\n except Exception:\\n pass\\n return tuple([x for x in self])\",\n \"def single_element_tuple():\\n single = (1,)\\n print(type(single)) # <type 'tuple'>\",\n \"def tupleize(num_items=None, conv=float, dtype=tuple):\\n def split_values(value):\\n \\\"\\\"\\\"Convert comma-separated string *value* to a tuple of numbers.\\\"\\\"\\\"\\n try:\\n result = dtype([conv(x) for x in value.split(',')])\\n except:\\n raise argparse.ArgumentTypeError('Expect comma-separated tuple')\\n\\n if num_items and len(result) != num_items:\\n raise argparse.ArgumentTypeError('Expected {} items'.format(num_items))\\n\\n return result\\n\\n return split_values\",\n \"def as_tuple(*values):\\n cleaned_values = []\\n for value in values:\\n if isinstance(value, (tuple, list)):\\n cleaned_values.extend(value)\\n else:\\n cleaned_values.append(value)\\n return tuple(cleaned_values)\",\n \"def list_to_tuple(list):\\n templist = []\\n for i in list:\\n try:\\n templist.append(int(i))\\n except ValueError:\\n print('Error. Please enter only integers.')\\n return ()\\n return tuple(templist)\",\n \"def make_tuple():\\n thing = 1, 2, 3, 4\\n print(type(thing))\",\n \"def element_to_tuple(list_of_elements):\\n return list(map(lambda x: tuple(x), list_of_elements))\",\n \"def try_tuple(obj):\\n # type: (Union[T, Tuple[T]]) -> Tuple[T]\\n if isinstance(obj, tuple):\\n return obj\\n\\n return obj, # NOTE the comma, made into tuple\",\n \"def astuple(v: Any) -> Tuple[Any, ...]:\\n return to_tuple(v, reuse_instances=False, convert_sets=False)\",\n \"def main():\\n sampleTuple = (100, 200, 300)\\n print(tupleStrFormat(sampleTuple))\",\n \"def is_tuple_of(seq, expected_type):\\n return is_seq_of(seq, expected_type, seq_type=tuple)\",\n \"def _tupleize(d):\\n return [(key, value) for key, value in d.items()]\",\n \"def test_as_tuple(self):\\n\\n vec = Vec3(7, 8, 9)\\n\\n self.assertEqual((7, 8, 9), vec.as_tuple())\",\n \"def triplewise(iterable):\\n # triplewise('ABCDEFG') -> ABC BCD CDE DEF EFG\\n for (a, _), (b, c) in pairwise(pairwise(iterable)):\\n yield a, b, c\",\n \"def pairwise(iterable: Iterable,\\n tuple_size: int):\\n return zip_longest(*(islice(it, pos, None) for pos, it in enumerate(tee(iterable, tuple_size))))\",\n \"def is_sequence_of_tuple(items):\\n return all(isinstance(item, tuple) for item in items)\",\n \"def toTupple(obj):\\n try:\\n return tuple(map(toTupple, obj))\\n except TypeError:\\n return obj\",\n \"def test_tuple_passed_as_iterable():\\n tree = Tree((10, 5, 100))\\n assert tree.root.value == 10\\n assert tree.root.left.value == 5\\n assert tree.root.right.value == 100\",\n \"def _tupstr(tuple_):\\n return ', '.join(list(map(str, tuple_)))\",\n \"def _silent_ntuple_ ( s , *args ) :\\n from Ostap.Utils import mute_py \\n with mute_py() : \\n tup = _TU.__nTuple__(s , *args )\\n logger.info ( 'Booked n-tuple %s' % tup )\\n return tup\",\n \"def hinted_tuple_hook(obj):\\n if '__tuple__' in obj:\\n return tuple(obj['items'])\\n return obj\",\n \"def _covert_list_tensor_to_tuple_tensor(list_of_tensor):\\n if isinstance(list_of_tensor, list):\\n tuple_of_tensor = ()\\n for tensor in list_of_tensor:\\n tuple_of_tensor += (tensor,)\\n return tuple_of_tensor\\n return list_of_tensor\",\n \"def unzip(iterable: Iterable[Tuple[Any, ...]]) -> Tuple[Iterator[Any], ...]:\\n first, iterator = _common.peek(iter(iterable))\\n if first is None:\\n return ()\\n tees = itertools.tee(iterator, len(first))\\n return (map(operator.itemgetter(i), tee) for i, tee in enumerate(tees))\",\n \"def _unpack_tuple(x):\\n if len(x) == 1:\\n return x[0]\\n else:\\n return x\",\n \"def _unpack_tuple(x):\\n if len(x) == 1:\\n return x[0]\\n else:\\n return x\",\n \"def _separate(xs):\\n if isinstance(xs, typing.Sequence):\\n return tuple(_single_separate(x) for x in xs)\\n else:\\n return _single_separate(xs)\",\n \"def tuple(self, arg: SeField[Any]) -> str:\\n if is_bare_tuple(arg.type):\\n return arg.varname\\n elif is_variable_tuple(arg.type):\\n earg = arg[0]\\n earg.name = \\\"v\\\"\\n return f\\\"tuple({self.render(earg)} for v in {arg.varname})\\\"\\n else:\\n rvalues = []\\n for i, _ in enumerate(type_args(arg.type)):\\n r = arg[i]\\n r.name = f\\\"{arg.varname}[{i}]\\\"\\n rvalues.append(self.render(r))\\n return f\\\"({', '.join(rvalues)},)\\\" # trailing , is required for single element tuples\",\n \"def serialize_tuple(self, obj):\\n return '(' + ''.join([self.serialize(i) for i in obj]) + 't'\",\n \"def tuple(self, spec):\\n return tuple(self(inner_spec) for inner_spec in spec)\",\n \"def __wrap_with_tuple(self) -> tuple:\\r\\n l = list()\\r\\n length = len(self.data)\\r\\n while self.idx < length:\\r\\n l.append(self.__parse())\\r\\n return tuple(l)\",\n \"def pairwise(iterable):\\n a = iter(iterable)\\n return zip(a, a, a)\",\n \"def testTypTagsTupleEnforced(self) -> None:\\n fake_typ_tuple = typing.cast(tuple, ['win', 'x86'])\\n with self.assertRaises(AssertionError):\\n _ = data_types.Result('test', fake_typ_tuple, (1, 10), 'build_id')\",\n \"def pairwise(iterable: Iterable[Any]) -> Sequence[Any]:\\n a, b = tee(iterable)\\n next(b, None)\\n return [\\\"\\\".join(t) for t in zip(a, b)]\",\n \"def no_parentheses():\\n weird_tuple = 1, 2, 3\\n print(weird_tuple) # (1, 2, 3)\\n print(type(weird_tuple)) # <type 'tuple'>\",\n \"def gen_4_tuples(it):\\n\\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))\",\n \"def gen_4_tuples(it):\\n\\n return list(zip(it[0::4], it[1::4], it[2::4], it[3::4]))\",\n \"def zipper_two_tuples_tests():\\n assert_with_message(zipper((1, 2, 3), (\\\"hello\\\", \\\"mr.\\\", \\\"world\\\")), [(1, \\\"hello\\\"), (2, \\\"mr.\\\"), (3, \\\"world\\\")])\\n assert_with_message(zipper((), (\\\"hello\\\", \\\"mr.\\\", \\\"world\\\")), [])\\n assert_with_message(zipper((1, 2, 3), ()), [])\\n assert_with_message(zipper((), ()), [])\\n print(\\\"All tests with two tuples as parameters passed!\\\")\",\n \"def prettyTuple(app, tup, seq=None, _asString=False, item=RESULT, **options):\\n\\n display = app.display\\n\\n if not display.check(\\\"prettyTuple\\\", options):\\n return \\\"\\\"\\n\\n dContext = display.distill(options)\\n colorMap = dContext.colorMap\\n highlights = dContext.highlights\\n condenseType = dContext.condenseType\\n condensed = dContext.condensed\\n\\n _browse = app._browse\\n inNb = app.inNb\\n asString = _browse or _asString\\n\\n if len(tup) == 0:\\n if asString:\\n return \\\"\\\"\\n else:\\n return\\n\\n api = app.api\\n N = api.N\\n sortKey = N.sortKey\\n\\n containers = {tup[0]} if condensed else condenseSet(api, tup, condenseType)\\n highlights = getTupleHighlights(api, tup, highlights, colorMap, condenseType)\\n seqRep = \\\"\\\" if seq is None else f\\\" <i>{seq}</i>\\\"\\n\\n if not asString:\\n dh(f\\\"<p><b>{item}</b>{seqRep}\\\", inNb=inNb)\\n if asString:\\n html = []\\n for t in sorted(containers, key=sortKey):\\n h = app.pretty(\\n t,\\n highlights=highlights,\\n **display.consume(options, \\\"highlights\\\"),\\n )\\n if asString:\\n html.append(h)\\n if asString:\\n return \\\"\\\".join(html)\",\n \"def tuple_ty(*tuple_types : MIRType) -> 'MIRTupleType':\\n return MIRTupleType(list(tuple_types))\",\n \"def test_insertion_for_each_element_in_iterable_tuple(empty_list):\\n b = (1, 2, 3)\\n bb = LinkedList([])\\n bb.insert(b)\\n assert len(bb) == 3\",\n \"def is_tuple(obj):\\n return type(obj) is tuple\",\n \"def pack_tuple(self, values):\\n assert isinstance(values, (tuple, list))\\n cardinality = [struct_L.pack(len(values))]\\n packed_items = [self.pack_field(v) for v in values]\\n return b''.join(itertools.chain(cardinality, packed_items))\",\n \"def batch_iter(iterable: Iterable[T], size: int) -> Iterator[Tuple[T]]:\\n # make sure we can deal with iterables like lists too\\n sourceiter = iter(iterable)\\n # call islice until it returns an empty tuple\\n return iter(lambda: tuple(islice(sourceiter, size)), ())\",\n \"def test_mix_tuple_issue_387(self):\\n assert_type_and_value(\\n tuple,\\n (42, 'Test'),\\n self.env(\\n 'MIX_TUPLE',\\n default=(0, ''),\\n cast=lambda t: tuple(\\n map(\\n lambda v: int(v) if v.isdigit() else v.strip(),\\n [c for c in t.strip('()').split(',')]\\n )\\n ),\\n )\\n )\",\n \"def totuple(self, arr):\\n\\n\\t\\ttry:\\n\\t\\t return tuple(self.totuple(i) for i in arr)\\n\\t\\texcept TypeError:\\n\\t\\t return arr\",\n \"def generate_from_tuple(t):\\n\\n data_generator(*t)\",\n \"def to_tuple(self) -> Tuple[Any, Iterable[Tuple]]:\\n return non_recursive_tree_to_tuple(self)\",\n \"def split_in_pairs(arg: Iterable) -> Iterable[Tuple]:\\n # We are using zip_longest with one clever hack:\\n # https://docs.python.org/3/library/itertools.html#itertools.zip_longest\\n # We create an iterator out of the list and then pass the same iterator to\\n # the function two times. Thus the function consumes a different element\\n # from the iterator each time and produces the desired result.\\n iterator = iter(arg)\\n return zip_longest(iterator, iterator)\",\n \"def test_single_tuple(self):\\n conn = self.connect()\\n c = conn.cursor()\\n self.safe_create_table(\\n conn, \\\"mystuff\\\", \\\"create table mystuff (id integer primary key)\\\"\\n )\\n c.execute(\\\"insert into mystuff (id) values (1)\\\")\\n c.execute(\\\"insert into mystuff (id) values (2)\\\")\\n c.execute(\\\"select id from mystuff where id in %s\\\", ((1,),))\\n self.assertEqual([(1,)], list(c.fetchall()))\\n c.close()\",\n \"def test_tuple_input(self):\\n \\n self._tuple1 = 1, 2, 3\\n self._tuple2 = 'yes', 'y', 'hey'\\n self.assertEqual(False, maps.map_list(self._tuple1))\\n self.assertEqual(False, maps.map_list(self._tuple2))\",\n \"def pairwise(iterable: Iterable[Any]) -> Iterable[Any]:\\n a, b = tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def pairwise(iterable):\\n a = iter(iterable)\\n return zip(a, a)\",\n \"def tupleofwords_to_wordoftuples(tupleofwords):\\n return list(zip_longest(*tupleofwords, fillvalue=None))\",\n \"def convert_to_tuple(v):\\n if not isinstance(v, tuple):\\n return tuple(v)\\n else:\\n return v\",\n \"def _list_to_tuple(v):\\n if isinstance(v, list):\\n return tuple(v)\\n return v\",\n \"def tuple_merge(tuples):\\n\\n\\t# Add your code here\\n\\treturn\",\n \"def pairwise(iterable):\\n a, b = itertools.tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def pairwise(iterable):\\n a, b = itertools.tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def pairwise(iterable):\\n a, b = itertools.tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def delimit_tuple(tuple_: tuple, delimiter=\\\",\\\"):\\n if not type(tuple_) == tuple:\\n raise TypeError(\\n \\\"Expected a list or tuple, \\\" \\\"but got {}\\\".format(type(tuple_).__name__)\\n )\\n return delimiter.join(map(str, tuple_))\",\n \"def unzip(seq: Iterable) -> tuple:\\n seq = iter(seq)\\n # check how many iterators we need\\n try:\\n first = tuple(next(seq))\\n except StopIteration:\\n return tuple()\\n # and create them\\n niters = len(first)\\n seqs = itertools.tee(itertoolz.cons(first, seq), niters)\\n return tuple(itertools.starmap(itertoolz.pluck, enumerate(seqs)))\",\n \"def create_record_tuple(ilist):\\n list_length = len(ilist)\\n if list_length:\\n rec_tuple = '('\\n for row in list[0:list_length-1]:\\n rec_tuple += str(row)\\n rec_tuple += ','\\n rec_tuple += str(list[list_length-1])\\n rec_tuple += ')'\\n else: rec_tuple = '()'\\n return rec_tuple\",\n \"def pairwise(iterable: Iterable):\\n a, b = tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def pairwise(iterable):\\n a, b = tee(iterable)\\n next(b, None)\\n return izip(a, b)\",\n \"def test_query_simple_tuple(self):\\n tab = 'query_test'\\n cols = ['col1', 'col2']\\n rows_in = [(1, 2), (2, 4), (3, 6)]\\n\\n with self.dbh.table_recreate(tab, cols, 'integer'):\\n self.dbh.insert_many(tab, cols, rows_in)\\n rows_out = self.dbh.query_simple(tab, cols, rowtype=tuple)\\n self.assertEqual(set(rows_in), set(rows_out))\",\n \"def to_tuple(self):\\n return tuple(self.to_list())\",\n \"def pairwise(iterable):\\r\\n a = iter(iterable)\\r\\n return izip(a, a)\",\n \"def test_complex_to_tuple():\\n\\n @type_checked\\n def _run_test(thing:(complex,)):\\n assert thing == (complex(15, 2),)\\n\\n _run_test(complex(15, 2))\",\n \"def test_defined_in_iter():\\n\\n @type_checked\\n def _run_test(thing:[(int, str, str)]):\\n for group in thing:\\n assert isinstance(group[0], int)\\n assert isinstance(group[1], str)\\n assert isinstance(group[2], str)\\n assert len(thing) == 4\\n\\n _run_test(thing=[\\n (12.3, None, False),\\n (\\\"12.1\\\", True, 1),\\n (False, 10, 12.1),\\n (True, 14.9, None),\\n ])\",\n \"def tuple_check(*args, func=None):\\n func = func or inspect.stack()[2][3]\\n for var in args:\\n if not isinstance(var, (tuple, collections.abc.Sequence)):\\n name = type(var).__name__\\n raise TupleError(\\n 'Function {} expected tuple, {} got instead.'.format(func, name))\",\n \"def create_type_tuple(*elems):\\n tuple = ast.Tuple()\\n\\n tuple.elts = []\\n for elem in elems:\\n tuple.elts.append(elem)\\n\\n return tuple\",\n \"def visit_tuple_type(self, left: TupleType) -> T:\",\n \"def _item_or_tuple(self, seq):\\n t = tuple(seq)\\n if self._is_multi:\\n return t\\n else:\\n return t[0]\",\n \"def hint_tuples(o):\\n if isinstance(o, tuple):\\n return dict(_type='tuple', items=o)\\n elif isinstance(o, list):\\n return [hint_tuples(el) for el in o]\\n else:\\n return o\",\n \"def get_tuples(outputs) -> list:\\n return list(map(get_tuples_helper, outputs))\",\n \"def unzip_finite(\\n iterable: Iterable[Tuple[Any, ...]],\\n) -> Tuple[Iterator[Any], ...]:\\n for zipped in zip(*iterable):\\n yield zipped\",\n \"def trigrams(content):\\n for item in range(len(content) - 2):\\n buld_tupls = tuple(contents[item: item + 2])\\n # test to make sure that two items are in a tuple\\n # print(buld_tupls)\\n # print(type(buld_tupls))\",\n \"def make_iterable(arg):\\n return arg if is_iterable(arg) else (arg,)\",\n \"def convert_tuple(self, v, t):\\n return tuple(self(v, t)\\n for v, t in zip(v, t.elements))\",\n \"def _convert_to_tuple(r):\\n if not r:\\n return r\\n else:\\n return (r[\\\"token\\\"], r[\\\"value\\\"], r[\\\"code\\\"], r[\\\"address\\\"],)\",\n \"def pairwise(iterable):\\n a, b = tee(iterable)\\n next(b, None)\\n return zip(a, b)\",\n \"def pairwise(iterable):\\n a, b = tee(iterable)\\n next(b, None)\\n return zip(a, b)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6921011","0.68820137","0.67969006","0.66930157","0.65410215","0.65340674","0.6524488","0.6501052","0.64999217","0.6474179","0.64328927","0.638195","0.634732","0.63379496","0.62362045","0.6152484","0.6152422","0.6125659","0.6123165","0.6112711","0.61111146","0.6080704","0.60720104","0.6033285","0.60284775","0.59703076","0.59702873","0.5963916","0.59503007","0.5947566","0.5945825","0.5939292","0.5935874","0.59356046","0.5935232","0.5923148","0.59115213","0.5899656","0.58825266","0.58589655","0.5857819","0.58556145","0.58492476","0.58492476","0.58231264","0.58228475","0.5813368","0.5805165","0.5800605","0.5799633","0.57909155","0.57814664","0.577986","0.57636565","0.57636565","0.57466125","0.5736174","0.57317966","0.57249993","0.5718358","0.5704447","0.56923115","0.56867176","0.56724334","0.56477946","0.56474864","0.56311166","0.56287915","0.5627999","0.56135535","0.5611074","0.5606533","0.56028533","0.55912703","0.5589169","0.5558059","0.5558059","0.5558059","0.5553914","0.5551784","0.55491436","0.55467594","0.55431396","0.5537255","0.5536388","0.5533684","0.5516615","0.5502803","0.5498137","0.5495418","0.54936194","0.54837537","0.5483529","0.54832816","0.54770446","0.5476716","0.5470889","0.546544","0.54633087","0.54626983","0.54626983"],"string":"[\n \"0.6921011\",\n \"0.68820137\",\n \"0.67969006\",\n \"0.66930157\",\n \"0.65410215\",\n \"0.65340674\",\n \"0.6524488\",\n \"0.6501052\",\n \"0.64999217\",\n \"0.6474179\",\n \"0.64328927\",\n \"0.638195\",\n \"0.634732\",\n \"0.63379496\",\n \"0.62362045\",\n \"0.6152484\",\n \"0.6152422\",\n \"0.6125659\",\n \"0.6123165\",\n \"0.6112711\",\n \"0.61111146\",\n \"0.6080704\",\n \"0.60720104\",\n \"0.6033285\",\n \"0.60284775\",\n \"0.59703076\",\n \"0.59702873\",\n \"0.5963916\",\n \"0.59503007\",\n \"0.5947566\",\n \"0.5945825\",\n \"0.5939292\",\n \"0.5935874\",\n \"0.59356046\",\n \"0.5935232\",\n \"0.5923148\",\n \"0.59115213\",\n \"0.5899656\",\n \"0.58825266\",\n \"0.58589655\",\n \"0.5857819\",\n \"0.58556145\",\n \"0.58492476\",\n \"0.58492476\",\n \"0.58231264\",\n \"0.58228475\",\n \"0.5813368\",\n \"0.5805165\",\n \"0.5800605\",\n \"0.5799633\",\n \"0.57909155\",\n \"0.57814664\",\n \"0.577986\",\n \"0.57636565\",\n \"0.57636565\",\n \"0.57466125\",\n \"0.5736174\",\n \"0.57317966\",\n \"0.57249993\",\n \"0.5718358\",\n \"0.5704447\",\n \"0.56923115\",\n \"0.56867176\",\n \"0.56724334\",\n \"0.56477946\",\n \"0.56474864\",\n \"0.56311166\",\n \"0.56287915\",\n \"0.5627999\",\n \"0.56135535\",\n \"0.5611074\",\n \"0.5606533\",\n \"0.56028533\",\n \"0.55912703\",\n \"0.5589169\",\n \"0.5558059\",\n \"0.5558059\",\n \"0.5558059\",\n \"0.5553914\",\n \"0.5551784\",\n \"0.55491436\",\n \"0.55467594\",\n \"0.55431396\",\n \"0.5537255\",\n \"0.5536388\",\n \"0.5533684\",\n \"0.5516615\",\n \"0.5502803\",\n \"0.5498137\",\n \"0.5495418\",\n \"0.54936194\",\n \"0.54837537\",\n \"0.5483529\",\n \"0.54832816\",\n \"0.54770446\",\n \"0.5476716\",\n \"0.5470889\",\n \"0.546544\",\n \"0.54633087\",\n \"0.54626983\",\n \"0.54626983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83781,"cells":{"query":{"kind":"string","value":"generate the input data dict for ONNXinferenceSession run"},"document":{"kind":"string","value":"def get_next(self) -> dict:\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 create_inputs_for_inference(builder, conf):\r\n\r\n inputs = dict()\r\n\r\n inputs[\"mel_spec_input\"] = builder.addInputTensor(popart.TensorInfo(_get_popart_type(conf.precision),\r\n [conf.samples_per_device,\r\n conf.mel_bands,\r\n conf.max_spectrogram_length]),\r\n \"mel_spec_input\")\r\n\r\n return inputs","def _do_infer(stream_manager_api, data_input):\n stream_name = b'segmentation'\n unique_id = stream_manager_api.SendData(\n stream_name, 0, data_input)\n if unique_id < 0:\n raise RuntimeError(\"Failed to send data to stream.\")\n\n keys = [b\"mxpi_tensorinfer0\"]\n keyVec = StringVector()\n for key in keys:\n keyVec.push_back(key)\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\n print(infer_result)\n if infer_result.size() == 0:\n print(\"infer_result is null\")\n exit()\n\n TensorList = MxpiDataType.MxpiTensorPackageList()\n TensorList.ParseFromString(infer_result[0].messageBuf)\n data = np.frombuffer(\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\n data = data.reshape(1, 19, 1024, 2048)\n return data","def create_training_args(self, input_dict, output_dict, exec_properties,\n executor_class_path, training_inputs,\n job_id) -> Dict[Text, Any]:\n pass","def create_inputs(self):\n return {}","def serving_input_fn():\n input_keys = tf.placeholder(\n dtype=tf.string, shape=[None], name='input_keys')\n\n with tf.name_scope('ReadInferenceData'):\n feature_dict, serialized_example = self._get_tensor_and_example(\n mode, shuffle=shuffle, num_epochs=num_epochs)\n\n # At serving time, the batch size will be 1. We need to reshape the\n # features to account for this.\n features = {}\n for key, tensor in iteritems(feature_dict):\n features[key] = tf.expand_dims(tensor, 0)\n tf.logging.info(key)\n tf.logging.info(features)\n\n inputs = {\n 'input_keys': input_keys,\n 'input_examples': serialized_example,\n }\n\n return tf.estimator.export.ServingInputReceiver(\n features=features, receiver_tensors=inputs)","def _input_fn(params):\n batch_size = params['batch_size']\n inputs, labels, lengths = sequence_example_lib.get_fake_data_batch(\n batch_size, input_size, padding_length)\n\n features = {\n 'inputs': inputs,\n 'lengths': lengths\n }\n return features, labels","def generate_input_data(self):\n for socket_name, c in self.__taskobject.inputs.items():\n if c['optional']:\n self.__inputs[socket_name] = {'data': None, 'enable': False}\n else:\n self.__inputs[socket_name] = {'data': None, 'enable': True}","def create_feed_dict(self, inputs_batch, labels_batch=None):\n ### YOUR CODE HERE\n feed_dict=dict()\n feed_dict[self.input_placeholder]=inputs_batch\n if labels_batch is not None:\n feed_dict[self.labels_placeholder]=labels_batch\n ### END YOUR CODE\n return feed_dict","def input_data_definitions(self):\n return {\n self.key_feature_maps: DataDefinition([-1, self.feature_maps_depth, self.feature_maps_height, self.feature_maps_width], [torch.Tensor], \"Batch of feature maps [BATCH_SIZE x FEAT_DEPTH x FEAT_HEIGHT x FEAT_WIDTH]\"),\n self.key_question_encodings: DataDefinition([-1, self.question_encoding_size], [torch.Tensor], \"Batch of encoded questions [BATCH_SIZE x QUESTION_ENCODING_SIZE]\"),\n }","def _infer(self,\n inputs,\n start_id=None,\n eos_id=None,\n max_gen_len=None,\n prev_input=None):\n results = {}\n enc_embed, dec_embed = self._encoder_decoder_network(\n src_token=inputs['src_token'],\n src_mask=inputs['src_mask'],\n tgt_token=inputs['tgt_token'],\n tgt_mask=inputs['tgt_mask'],\n src_pos=inputs['src_pos'],\n src_type=inputs['src_type'],\n src_turn=inputs['src_turn'])\n features = dec_embed[:, -1]\n features = self.pooler(features) if self.with_pool else features\n if self.example:\n results['features'] = features\n else:\n intent_logits = self.intent_classifier(features)\n intent_probs = self.softmax(intent_logits)\n results['intent_probs'] = intent_probs\n return results","def _buildInput (self):\n\n\t\tindata = self.config['input']\n\t\tif not isinstance (indata, dict):\n\t\t\tindata = ','.join(utils.alwaysList (indata))\t\t\t\n\t\t\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\n\t\t\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\n\t\t\t\n\t\t# expand to one key-channel pairs\n\t\tfor inkeys, invals in indata.iteritems():\n\t\t\tkeys = utils.split(inkeys, ',')\n\t\t\tif callable (invals):\n\t\t\t\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\n\t\t\t\tvals = vals.split()\n\t\t\telif isinstance (invals, basestring): # only for files: \"/a/b/*.txt, /a/c/*.txt\"\n\t\t\t\tvals = utils.split(invals, ',')\n\t\t\telif isinstance (invals, channel):\n\t\t\t\tvals = invals.split()\n\t\t\telif isinstance (invals, list):\n\t\t\t\tvals = channel.create(invals).split()\n\t\t\telse:\n\t\t\t\traise ValueError (\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\" % self._name())\n\t\t\t\n\t\t\twidth = len (vals)\n\t\t\tif len (keys) > width:\n\t\t\t\traise ValueError ('%s: Not enough data for input variables.\\nVarialbes: %s\\nData: %s' % (self._name(), keys, vals))\n\t\t\t\n\t\t\tfor i, key in enumerate(keys):\n\t\t\t\tintype = key.split(':')[-1]\n\t\t\t\tthekey = key.split(':')[0]\n\t\t\t\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\n\n\t\t\t\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\n\t\t\t\t\tintype = proc.IN_VARTYPE[0]\n\t\t\t\t\n\t\t\t\tif intype in proc.IN_FILESTYPE:\n\t\t\t\t\tfor x, v in enumerate(val):\n\t\t\t\t\t\tif isinstance (v, basestring):\n\t\t\t\t\t\t\tval[x] = channel.fromPath (v).toList()\n\t\t\t\t\n\t\t\t\tif self.length == 0: \n\t\t\t\t\tself.props['length'] = len (val)\n\t\t\t\tif self.length != len (val):\n\t\t\t\t\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\n\t\t\t\tself.props['indata'][thekey] = {\n\t\t\t\t\t'type': intype,\n\t\t\t\t\t'data': val\n\t\t\t\t}\n\t\t\tself.props['jobs'] = [None] * self.length","def run(self, input):\n return {}","def __init__(self):\n self.inputs = {}","def inference():\n if request.method == \"POST\":\n data = request.json #\n src_img = np.array(data[\"src\"]).astype(np.uint8) # Parsing data\n ref_img = np.array(data[\"ref\"]).astype(np.uint8) #\n ref_label = int(data[\"ref_label\"]) #\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\n return jsonify({\"result\": result.tolist()}) # Returning results into json","def input_fn():\n with tf.name_scope('ReadData'):\n tensor, _ = self._get_tensor_and_example(\n mode, shuffle=shuffle, num_epochs=num_epochs)\n\n with tf.name_scope('Batch'):\n batched = tf.train.batch(\n tensor,\n batch_size=self._batch_size,\n dynamic_pad=True,\n capacity=QUEUE_SCALING_FACTOR * self._batch_size)\n\n features = {key: batched[key] for key in self._feature_keys}\n labels = {}\n for label_tuple in self._label_keys:\n labels[label_tuple[0]] = tf.expand_dims(\n batched[label_tuple[0]], axis=-1)\n if label_tuple[1]:\n labels[label_tuple[0] + '.time_to_event'] = tf.expand_dims(\n batched[label_tuple[0] + '.time_of_event'] -\n batched['trigger_time_sec'],\n axis=-1)\n\n return features, labels","def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None,goal='IC',save_path_dir=None): #b/c it is single, models_list contains one model only\n running_loss = 0.0\n \n# outputs_list = []\n# representations_list = []\n# labels_list = []\n# modality_list = []\n# indices_list = []\n# task_names_list = []\n# attn_coefs_list = []\n# sentence_lens_list = []\n# class_labels_list = []\n# class_predictions_list = []\n \n \"\"\" Initialize Dictionaries to Store Results \"\"\" \n outputs_dict = dict()\n representations_dict = dict()\n attn_coefs_dict = dict()\n labels_dict = dict()\n sentence_lens_dict = dict()\n class_labels_dict = dict()\n class_predictions_dict = dict()\n epoch_bleu = dict()\n epoch_rouge = dict()\n epoch_meteor = dict()\n\n for dest_lang in token2id_dict.keys():\n outputs_dict[dest_lang] = list()\n attn_coefs_dict[dest_lang] = list()\n representations_dict[dest_lang] = list()\n labels_dict[dest_lang] = list()\n sentence_lens_dict[dest_lang] = list()\n class_labels_dict[dest_lang] = list()\n class_predictions_dict[dest_lang] = list()\n epoch_bleu[dest_lang] = 0\n epoch_rouge[dest_lang] = 0\n epoch_meteor[dest_lang] = 0\n\n batch_num = 0\n batch = 0\n #class label is that in IC setting, but class label is answer in VQA setting\n for inputs, text_indices, sentence_lens, class_labels, languages, document_level_text_indices, document_level_sentence_lens in tqdm(dataloaders[phase]):\n \"\"\" Weaning Off of Teacher Forcing in a Linear Manner \"\"\"\n #sampling_prob = (0.4/30000)*(batch+1)*(epoch_count+1)\n #uniform_value = np.random.uniform(0,1)\n #sampling = True if uniform_value < sampling_prob else False\n sampling = False\n batch += 1\n \"\"\" Send Data to Device \"\"\"\n inputs = inputs.to(device)\n class_labels = class_labels.to(device)\n #print(text_indices)\n with torch.set_grad_enabled('train1' in phase):# and inference == False): #('train' in phase and inference == False)\n \"\"\" Image Captioning Path \"\"\"\n if goal == 'IC':\n \"\"\" Perform Forward Pass i.e. Encoder and Decoder \"\"\"\n current_labels_dict = dict() #text\n# current_class_labels_dict = dict()\n# current_class_predictions_dict = dict()\n current_outputs_dict = dict()\n# current_attn_coefs_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n outputs, representations = model(inputs,current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],dest_lang,phase,sampling,device) #outputs is B x S x Words\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n #current_text_indices = current_text_indices[:,1:] # B x (S-1)\n if phase == 'train1':\n attn_coefs = 5\n class_predictions = 6\n loss = calculate_IC_loss(criterion,outputs,current_text_indices[:,1:],class_predictions,class_labels,attn_coefs,auxiliary_loss,attn_loss)\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \"\"\" Store Results \"\"\"\n current_labels_dict[dest_lang] = current_text_indices[:,1:].cpu().detach().numpy()\n# current_class_labels_dict[dest_lang] = class_labels\n# current_class_predictions_dict[dest_lang] = class_predictions\n current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\n# current_attn_coefs_dict[dest_lang] = attn_coefs\n# current_representations_dict[dest_lang] = representations\n #\"\"\" Detach Outputs and Attn Coefs To Avoid Memory Leakage \"\"\"\n #outputs = outputs.detach()\n #attn_coefs = attn_coefs.detach()\n current_text_indices.detach()\n elif goal == 'VQA':\n \"\"\" Perform Forward Pass and Get Answers \"\"\"\n outputs, representations, attn_coefs, class_predictions = model(inputs,text_indices,sentence_lens,id2embedding_dict,phase,device)\n \"\"\" Calculate MSE Loss \"\"\"\n #criterion = nn.MSELoss()\n #class_labels = class_labels.type(torch.float)\n \"\"\" Calculate CrossEntropyLoss \"\"\"\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n #print(outputs,outputs.shape)\n loss = criterion(outputs,class_labels)\n elif goal == 'Supervised': #encoder supervised pre-training\n h, representations, class_predictions = model(inputs)#,text_indices,sentence_lens,id2embedding_dict,phase,device)\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n loss = criterion(class_predictions,class_labels)\n elif goal == 'Text_Supervised':\n #h, class_predictions = model.supervised_forward(text_indices,sentence_lens,token2id_dict,id2embedding_dict,phase,device)\n criterion = nn.CrossEntropyLoss()\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n class_predictions = model.supervised_forward(current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],phase,device)\n loss = criterion(class_predictions,class_labels)\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n\n current_class_labels_dict[dest_lang] = class_labels.cpu().detach().numpy()\n current_class_predictions_dict[dest_lang] = class_predictions.cpu().detach().numpy()\n# current_representations_dict[dest_lang] = h\n #loss = criterion(class_predictions,class_labels)\n #print(loss)\n elif goal == 'Language_Change_Detection':\n criterion = nn.BCEWithLogitsLoss()\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n \"\"\" Forward Pass \"\"\"\n replacement_predictions, replacement_labels = model.language_change_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\n #replacement_labels = replacement_labels.type(torch.float) #needed for BCELoss\n \"\"\" Instance-Wise Loss Because Each Sentence is of a Different Length \"\"\"\n loss = 0\n for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\n current_loss = criterion(replacement_prediction,replacement_label)\n loss = loss + current_loss\n if i == len(replacement_predictions)-1:\n loss = loss / len(replacement_predictions)\n #loss = torch.mean(torch.tensor([criterion(replacement_prediction,replacement_label) for replacement_prediction,replacement_label in zip(replacement_predictions,replacement_labels)]))\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n \"\"\" Store Representations and Labels \"\"\"\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\n# current_representations_dict[dest_lang] = h \n elif goal == 'Language_Detection':\n criterion = nn.CrossEntropyLoss(ignore_index=0)\n class_labels = class_labels.type(torch.long)\n current_class_labels_dict = dict()\n current_class_predictions_dict = dict()\n# current_representations_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\n \"\"\" Forward Pass \"\"\"\n replacement_predictions, replacement_labels = model.language_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\n #replacement_labels = replacement_labels.type(torch.long) #needed for CrossEntropyLoss\n \"\"\" Instance-Wise Loss Because Each Sentence is of a Different Length \"\"\"\n# loss = 0\n# for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\n# replacement_label = replacement_label.type(torch.long)\n# current_loss = criterion(replacement_prediction,replacement_label)\n# loss = loss + current_loss\n# if i == len(replacement_predictions)-1:\n# loss = loss / len(replacement_predictions)\n #print(replacement_predictions.shape,replacement_labels.shape)\n loss = criterion(replacement_predictions.permute(0,2,1),replacement_labels)\n #print(loss)\n total_loss = total_loss + loss\n #print(dest_lang,total_loss)\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n \"\"\" Store Representations and Labels \"\"\"\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\n# current_representations_dict[dest_lang] = h\n elif goal == 'MLM':\n criterion = nn.CrossEntropyLoss(reduction='none')\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n outputs, replacement_predictions = model.MLM_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device) #outputs is B x S x Words\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n \"\"\" Obtain Applicable Loss Locations (i.e., Where Token Was Masked) \"\"\"\n token_loss_mask = torch.where(replacement_predictions == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\n #print(outputs.shape)\n #if phase == 'train1':\n \"\"\" Obtain Each Token's Loss \"\"\"\n token_loss = criterion(outputs.permute(0,2,1),current_text_indices)\n \"\"\" Retrieve Only Relevant Losses (Masked) \"\"\"\n loss = torch.mean(token_loss.masked_select(token_loss_mask))\n \"\"\" Aggregate Loss Across Languages \"\"\"\n total_loss = total_loss + loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \n del current_text_indices\n del token_loss\n del token_loss_mask\n# \"\"\" Store Results \"\"\"\n# current_labels_dict[dest_lang] = current_text_indices.cpu().detach().numpy()\n# current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\n elif goal == 'ELECTRA':\n generator_criterion = nn.CrossEntropyLoss(reduction='none')\n discriminator_criterion = nn.BCEWithLogitsLoss(reduction='none')\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n total_loss = 0\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Perform Forward Pass Through ELECTRA \"\"\"\n generator_outputs, generator_labels, discriminator_outputs, discriminator_labels = model.ELECTRA_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,sampling,device) #outputs is B x S x Words\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n \"\"\" Generator Loss Mask (i.e., Only Consider Originally Masked Tokens ) \"\"\"\n generator_token_loss_mask = torch.where(generator_labels == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\n \"\"\" Discrimiantor Loss Mask (i.e., Do Not Consider Padded Regions ) \"\"\"\n discriminator_labels = discriminator_labels.view_as(discriminator_outputs) \n discriminator_token_loss_mask = torch.ones_like(discriminator_labels)\n for i,sentence_len in zip(range(discriminator_token_loss_mask.shape[0]),current_sentence_lens):\n discriminator_token_loss_mask[i,sentence_len:] = 0\n \n #if phase == 'train1':\n \"\"\" Obtain Each Generator Token's Loss \"\"\"\n generator_token_loss = generator_criterion(generator_outputs.permute(0,2,1),current_text_indices) # B x S\n #print(generator_token_loss.shape,generator_token_loss_mask.shape)\n \"\"\" Retrieve Only Relevant Loss (Masked) \"\"\"\n generator_loss = torch.mean(generator_token_loss.masked_select(generator_token_loss_mask)) #scalar\n \n \"\"\" Obtain Each Discriminator Token's Loss \"\"\" \n discriminator_token_loss = discriminator_criterion(discriminator_outputs,discriminator_labels) # B x S\n #print(discriminator_token_loss.shape,discriminator_token_loss_mask.shape)\n \"\"\" Retrieve Only Relevant Loss (Masked) \"\"\"\n discriminator_loss = torch.mean(discriminator_token_loss.masked_select(discriminator_token_loss_mask.type(torch.bool))) #scalar\n \n #print(generator_loss,discriminator_loss)\n \"\"\" Aggregate Loss Across Languages \"\"\"\n total_loss = total_loss + generator_loss + discriminator_loss\n \"\"\" Average Loss if This is Final Loss Collected \"\"\"\n if dest_lang == list(text_indices.keys())[-1]:\n loss = total_loss / len(text_indices)\n \"\"\" Store Results \"\"\"\n# current_labels_dict[dest_lang] = discriminator_labels.cpu().detach().numpy()\n# current_outputs_dict[dest_lang] = discriminator_outputs.cpu().detach().numpy() #text\n elif goal == 'MARGE':\n# current_labels_dict = dict() #text\n# current_outputs_dict = dict()\n #total_loss = 0\n #for (dest_lang,current_text_indices),current_sentence_lens,current_languages in zip(text_indices.items(),sentence_lens.values(),languages.values()): #, sorted_indices, attn_coefs, class_predictions\n \"\"\" Randomly Choose Target Lang for This Mini-Batch \"\"\"\n #lang_list = list(text_indices.keys())\n #target_lang = random.sample(lang_list,1).item()\n #target_lang = 'de' #option to change based on dataset (MUST CHANGE IN PAD COLLATE)\n outputs, target_lang = model(text_indices,sentence_lens,languages,document_level_text_indices,document_level_sentence_lens,token2id_dict,id2embedding_dict,phase,device)\n \"\"\" Convert Text Indices/Targets to Tensor \"\"\"\n current_text_indices = text_indices[target_lang].to(device) #torch.tensor(current_text_indices,device=device)\n \"\"\" Remove '/START' Index from Target Indices \"\"\"\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\n #if phase == 'train1':\n \"\"\" Obtain Each Token's Loss \"\"\"\n loss = criterion(outputs.permute(0,2,1),current_text_indices)\n #print(loss)\n #\"\"\" Aggregate Loss Across Languages \"\"\"\n #total_loss = total_loss + loss\n #\"\"\" Average Loss if This is Final Loss Collected \"\"\"\n #if dest_lang == list(text_indices.keys())[-1]:\n # loss = total_loss / len(text_indices)\n# print(loss)\n# \"\"\" Store Results \"\"\"\n# current_labels_dict[target_lang] = current_text_indices.cpu().detach().numpy()\n# current_outputs_dict[target_lang] = outputs.cpu().detach().numpy() #text\n \n\n \"\"\" Backpropagation and Update Step \"\"\"\n if phase == 'train1': #only perform backprop for train1 phase \n loss.backward()\n \n \"\"\" Network Parameters \"\"\"\n if isinstance(optimizer,tuple):\n optimizer[0].step()\n \"\"\" Task-Instance Parameters \"\"\"\n optimizer[1].step() \n optimizer[0].zero_grad()\n optimizer[1].zero_grad()\n else:\n optimizer.step()\n optimizer.zero_grad()\n \n \"\"\" Calculate Metrics \"\"\"\n if goal == 'IC':\n if phase == 'train1':\n running_loss += loss.item() * inputs.shape[0]\n elif goal == 'VQA':\n running_loss += loss.item() * inputs.shape[0] \n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\n running_loss += loss.item() * inputs.shape[0] \n \n# \"\"\" These Need to be Language Specific \"\"\"\n \n if goal in ['IC']:\n batch_bleu = calculate_bleu_score(current_outputs_dict,current_labels_dict,token2id_dict)\n batch_rouge = calculate_rouge_score(current_outputs_dict,current_labels_dict,token2id_dict)\n batch_meteor = calculate_meteor_score(current_outputs_dict,current_labels_dict,token2id_dict) \n \n for dest_lang in batch_bleu.keys():\n epoch_bleu[dest_lang] = epoch_bleu[dest_lang] + (1/batch)*(batch_bleu[dest_lang] - epoch_bleu[dest_lang])\n epoch_rouge[dest_lang] = epoch_rouge[dest_lang] + (1/batch)*(batch_rouge[dest_lang] - epoch_rouge[dest_lang])\n epoch_meteor[dest_lang] = epoch_meteor[dest_lang] + (1/batch)*(batch_meteor[dest_lang] - epoch_meteor[dest_lang])\n \n if phase in ['val']:\n for dest_lang in text_indices.keys():\n predicted_sentences = convert_predicted_ids_to_sentences(current_outputs_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\n target_sentences = convert_target_ids_to_sentences(current_labels_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\n outputs_dict[dest_lang].extend(predicted_sentences)\n labels_dict[dest_lang].extend(target_sentences)\n \n elif goal in ['Language_Change_Detection','Language_Detection']:\n for dest_lang in text_indices.keys():\n if goal in ['Language_Change_Detection','Language_Detection']:\n \"\"\" Store Batch Data in The Dictionaries \"\"\"\n class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\n class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\n \n# elif goal in ['Text_Supervised']:\n## current_class_labels = current_class_labels_dict[dest_lang]\n## current_class_predictions = current_class_predictions_dict[dest_lang]\n## current_class_labels = current_class_labels.cpu().detach().numpy()\n## current_class_predictions = current_class_predictions.cpu().detach().numpy()\n# \n# \"\"\" Store Batch Data in The Dictionaries \"\"\"\n# #sentence_lens_dict[dest_lang].extend(current_sentence_lens)\n# class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\n# class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\n#\n# elif goal in ['MARGE']:\n# labels_dict[target_lang].extend(current_labels_dict[target_lang]) #.cpu().detach().numpy())\n# outputs_dict[target_lang].extend(current_outputs_dict[target_lang]) #.cpu().detach().numpy())\n# break # because only one target language per minibatch \n# if goal not in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\n## if current_labels_dict[dest_lang].data.dtype != torch.long:\n## current_labels_dict[dest_lang].data = current_labels_dict[dest_lang].data.type(torch.long)\n# \n## current_text_indices = current_labels_dict[dest_lang]\n## current_outputs = current_outputs_dict[dest_lang]\n## current_attn_coefs = current_attn_coefs_dict[dest_lang]\n## current_representations = current_representations_dict[dest_lang]\n# \"\"\" Store Batch Data in The Dictionaries \"\"\" \n# labels_dict[dest_lang].extend(current_labels_dict[dest_lang]) #.cpu().detach().numpy())\n# outputs_dict[dest_lang].extend(current_outputs_dict[dest_lang]) #.cpu().detach().numpy())\n## attn_coefs_dict[dest_lang].extend(current_attn_coefs.cpu().detach().numpy())\n## representations_dict[dest_lang].extend(current_representations.cpu().detach().numpy())\n## elif goal in ['Text_Supervised']:\n## current_representations = current_representations_dict[dest_lang]\n## representations_dict[dest_lang].extend(current_representations.squeeze().cpu().detach().numpy()) \n## else:\n## current_representations = current_representations_dict[dest_lang]\n## if goal in ['Language_Change_Detection','Language_Detection']:\n## current_representations = [representations.cpu().detach().numpy() for representations in current_representations]\n## else:\n## current_representations = current_representations.cpu().detach().numpy()\n## representations_dict[dest_lang].extend(current_representations) \n# \n## modality_list.append(modality)\n## indices_list.append(indices)\n## task_names_list.append(task_names)\n \n batch_num += 1\n #if batch_num == 2:\n # break\n \n #outputs_list, labels_list, modality_list, indices_list, task_names_list, pids_list = flatten_arrays(outputs_list,labels_list,modality_list,indices_list,task_names_list,pids_list)\n if goal == 'IC':\n if phase == 'train1':\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\n else:\n epoch_loss = 0 #filler\n elif goal in ['VQA','Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\n epoch_loss = running_loss / len(dataloaders[phase].dataset) \n \n \"\"\" Removed Recently \"\"\"\n #representations_list = np.concatenate(representations_list)\n \n if goal == 'IC':\n \"\"\" BLEU Score Evaluation \"\"\"\n# epoch_bleu = calculate_bleu_score(outputs_dict,labels_dict,token2id_dict)\n# epoch_rouge = calculate_rouge_score(outputs_dict,labels_dict,token2id_dict)\n# epoch_meteor = calculate_meteor_score(outputs_dict,labels_dict,token2id_dict) \n return epoch_loss, epoch_bleu, epoch_rouge, epoch_meteor, outputs_dict, labels_dict #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal == 'VQA':\n \"\"\" Accuracy of Answers \"\"\"\n epoch_acc = calculate_answer_accuracy(outputs_dict,class_labels_dict)\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\n if goal in ['Language_Change_Detection','Language_Detection']:\n epoch_acc = calculate_language_detection_accuracy(class_predictions_dict,class_labels_dict,goal)\n else:\n \"\"\" Accuracy of Answers \"\"\"\n epoch_acc = calculate_answer_accuracy(class_predictions_dict,class_labels_dict)\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\n elif goal in ['MLM','ELECTRA','MARGE']:\n return epoch_loss#, outputs_dict, labels_dict #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list","def input_data_definitions(self):\n return {\n self.key_inputs: DataDefinition(\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\n [list]*(self.num_inputs_dims-1) + [torch.Tensor],\n \"Batch of inputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\")\n }","def prepare(self):\n\n inp = self.config.get('predict.input', 'X:0')\n out = self.config.get('predict.output', 'output:0')\n\n # set input placeholder\n self.input = self.graph.get_tensor_by_name(inp)\n\n # set output operation\n if isinstance(out, str) or isinstance(out, unicode):\n self.output = {out: self.graph.get_tensor_by_name(out)}\n self.output_alone = True\n elif isinstance(out, list):\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\n self.output_alone = False\n else:\n raise LoaderException('incorrect predict.output type')","def export_inputs(self):\n vocab_dict = load_vocab_dict(self.text_vocab_file_path)\n vocab_size = len(vocab_dict)\n label_vocab_dict = load_vocab_dict(self.label_vocab_file_paths[0])\n label_vocab_size = len(label_vocab_dict)\n self.config['data']['vocab_size'] = vocab_size\n self.config['data']['label_vocab_size'] = label_vocab_size\n\n input_sentence = tf.placeholder(\n shape=(None,), dtype=tf.string, name=\"input_sentence\")\n\n input_pipeline_func = self.get_input_pipeline(for_export=True)\n\n token_ids = input_pipeline_func(input_sentence)\n token_ids_len = tf.map_fn(lambda x: compute_sen_lens(x, padding_token=0),\n token_ids)\n\n export_data = {\n \"export_inputs\": {\n \"input_sentence\": input_sentence\n },\n \"model_inputs\": {\n \"input_enc_x\": token_ids,\n \"input_x_len\": token_ids_len\n }\n }\n\n return export_data","def run(self, inputIn):\n measureList = self.inputToInternal(inputIn)\n outputDict = {}\n assert(len(self.features) == len(measureList))\n for metricInstance in self.metricsDict.values():\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\n for cnt in range(len(self.targets)):\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\"|\",\"_\")\n varName = metricInstance.name + '|' + nodeName\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\n outputDict[varName] = np.atleast_1d(output)\n return outputDict","def to_inference_module_input_from_dataframe(dataset: pd.DataFrame, config: ModelConfigDict, load_paths: bool=False, device: Optional[torch.device]=None) ->Dict[str, TorchscriptPreprocessingInput]:\n inputs = {}\n for if_config in config['input_features']:\n feature_inputs = to_inference_model_input_from_series(dataset[if_config[COLUMN]], if_config[TYPE], load_paths=load_paths, feature_config=if_config)\n feature_inputs = place_on_device(feature_inputs, device)\n inputs[if_config[NAME]] = feature_inputs\n return inputs","def feed(self, data):\n try:\n feed = {}\n for i in range(len(self.inputs)):\n feed[self.inputs[i]] = data[i]\n return feed\n except Exception:\n pass","def construct_inputs(\n cls,\n training_data: Dict[str, SupervisedDataset],\n task_feature: int,\n rank: Optional[int] = None,\n **kwargs: Any,\n ) -> Dict[str, Any]:\n inputs = super().construct_inputs(\n training_data=training_data, task_feature=task_feature, rank=rank, **kwargs\n )\n inputs.pop(\"task_covar_prior\")\n if \"train_Yvar\" not in inputs:\n inputs[\"train_Yvar\"] = None\n return inputs","def _train_input_fn():\n\t\tprint('\\n\\nRunning _train_input_fn\\n\\n')\n\t\tfeatures_placeholder = {\n\t\t\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), features['query_unigrams'][0].shape[0])),\n\t\t\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), features['doc_unigrams'][0][0].shape[0]))\n\t\t\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), len(features['query_unigrams'][0]))),\n\t\t\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), len(features['doc_unigrams'][0][0])))\n\t\t\t#k: tf.placeholder(tf.string, get_shape(v)) for k, v in six.iteritems(features)\n\t\t\tk: tf.placeholder(v.dtype, v.shape) for k, v in six.iteritems(features)\n\t\t\t#k: tf.sparse.placeholder(tf.string, [len(v)] + v[0].shape.as_list(), name=k) for k, v in six.iteritems(features)\n\t\t\t#k: tf.placeholder(tf.string, (len(v), len(v[0]), len(v[0][0]))) for k, v in six.iteritems(features)\n\t\t}\n\t\tlabels_placeholder = tf.placeholder(labels.dtype, labels.shape, name='label')\n\t\tdataset = tf.data.Dataset.from_tensor_slices((features_placeholder,\n\t\t\t\t\t\t\t\t\t\t\t\t\tlabels_placeholder))\n\t\t#dataset = dataset.shuffle(1000).repeat().batch(batch_size)\n\t\tdataset = dataset.shuffle(batch_size*10).repeat().batch(batch_size)\n\t\titerator = dataset.make_initializable_iterator()\n\t\tfeed_dict = {labels_placeholder: labels}\n\t\tfeed_dict.update(\n\t\t\t\t{features_placeholder[k]: features[k] for k in features_placeholder})\n\n\t\tprint('feed_dict')\n\t\tfor k,v in six.iteritems(feed_dict):\n\t\t\tprint(k.shape)\n\t\t#\tprint(v.shape)\n\t\trun_options = tf.RunOptions(report_tensor_allocations_upon_oom = True)\n\t\titerator_initializer_hook.iterator_initializer_fn = (\n\t\t\t\tlambda sess: sess.run(iterator.initializer, feed_dict=feed_dict, options=run_options))\n\t\treturn iterator.get_next()","def build_inputs(self):\n if self.mode == \"encode\":\n # Word embeddings are fed from an external vocabulary which has possibly\n # been expanded (see vocabulary_expansion.py).\n encode_ids1 = None\n encode_ids2 = None\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask1\")\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask2\")\n label = None\n\n elif self.mode == \"test\":\n encode_ids1 = None\n encode_ids2 = None\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask1\")\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask2\")\n label = None\n \n else:\n # Prefetch serialized tf.Example protos.\n input_queue = input_ops.prefetch_input_data(\n self.reader,\n self.config.input_file_pattern,\n shuffle=self.config.shuffle_input_data,\n capacity=self.config.input_queue_capacity,\n num_reader_threads=self.config.num_input_reader_threads)\n\n # Deserialize a batch.\n serialized = input_queue.dequeue_many(self.config.batch_size)\n s1, s2, label = input_ops.parse_example_batch(\n serialized)\n\n encode_ids1 = s1.ids\n encode_ids2 = s2.ids\n\n encode_mask1 = s1.mask\n encode_mask2 = s2.mask\n \n\n\n self.encode_ids1 = encode_ids1\n self.encode_ids2 = encode_ids2\n\n self.encode_mask1 = encode_mask1\n self.encode_mask2 = encode_mask2\n\n self.label = label","def get_inference_input_ppo_bootstrap(self):\n features = {\n 'mcts_features':\n tf.placeholder(tf.float32, shape=[None, self._env_state_space]),\n 'policy_features':\n tf.placeholder(tf.float32, shape=[None, self._env_state_space]),\n }\n return features","def _input_fn(params):\n # Retrieves the batch size for the current shard. The # of shards is\n # computed according to the input pipeline deployment. See\n # `tf.contrib.tpu.RunConfig` for details.\n batch_size = params['batch_size']\n inputs, labels, lengths = sequence_example_lib.get_padded_batch(\n file_paths, batch_size, input_size, padding_length)\n features = {\n 'inputs': inputs,\n 'lengths': lengths,\n }\n return features, labels","def train_input(config, params):\n \"\"\"\n rawimages: Nb x hf x wf x 3, tf.float32, in [0,1]\n rawlabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\n rawmetadata: Python dictionary with matadata (e.g. image shape, dtype)\n proimages: Nb x hf x wf x 3, tf.float32, in [0,1]\n prolabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\n \"\"\"\n # runconfig = config.runconfig\n # # otherconfig includes: train_preprocess, mappings\n # otherconfig = config.otherconfig\n # hparams = params\n\n # reading, mapping labels to problem from otherconfig['lids2cids'],\n # batching, preprocessing with otherconfig['train_preprocess'], output\n\n # no obvious use of prodata metadata for now\n with tf.variable_scope('input_pipeline'):\n values = None\n for num_dataset in range(len(params.tfrecords_list)): # , params.camvid_tfrecords_path]:\n if values is None:\n values = train_input_per_data(config, params, num_dataset)\n values = list(values) + [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\n else:\n _values = list(train_input_per_data(config, params, num_dataset)) + \\\n [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\n values = [tf.concat((value1, value2), 0) for value1, value2 in zip(values, _values)]\n\n features = {'rawimages': values[1],\n 'proimages': values[3],\n 'rawimagespaths': values[0][0],\n 'rawlabelspaths': values[0][1]}\n labels = {'rawlabels': values[2],\n 'prolabels': values[4],\n 'domainlabels': values[5]}\n return features, labels","def generate_update_dict(self, input_data, input_labels=None, batch_step=0):\n update_dict = dict()\n return update_dict","def prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def feed_inputs(self):\n feed_dict = collections.defaultdict(list)\n for i in range(self._pipe.batch_size):\n data = self.example_to_data(self._buffer.get())\n for k, v in data.items():\n feed_dict[k].append(v)\n for k, v in self.features.items():\n self._pipe.feed_input(self.features[k], feed_dict[k])","def create_dicts():\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')","def feed_training_args(self):\n return {}","def build_inference_graph(self):\n self.build_train_graph()","def _get_train_feed_dict(self, batch):\n raise NotImplementedError","def extract_input(config, params, num_take=None):\n num_prefetch = params.Nb*10\n if num_take is not None:\n num_take = max((num_take, params.Nb))\n num_prefetch = min((num_prefetch, num_take))\n mapping = params.inference_problem_def['lids2cids']\n with tf.device('/cpu:0'):\n dataset = tf.data.TFRecordDataset(params.predict_dir)\n if num_take is not None:\n dataset = dataset.take(num_take)\n dataset = dataset.repeat()\n dataset = dataset.map(parse_func, num_parallel_calls=8)\n dataset = dataset.map(\n lambda image, label, paths: (paths, *prepare_data(image, label, mapping, params)))\n dataset = dataset.map(lambda paths, image, label:\n (paths, image, label, *preprocess_evaluate(image, label, params)), num_parallel_calls=8)\n dataset = dataset.batch(params.Nb)\n dataset = dataset.prefetch(num_prefetch)\n iterator = dataset.make_one_shot_iterator()\n values = iterator.get_next()\n\n features = {'rawimages': values[1],\n 'proimages': values[3],\n 'rawimagespaths': values[0][0],\n 'rawlabelspaths': values[0][1]}\n labels = {'rawlabels': values[2],\n 'prolabels': values[4]}\n return features, labels","def _create_client_input(train_batch_size, test_batch_size, context=None):\n client_input = collections.OrderedDict()\n client_input['train_data'] = _create_dataset(train_batch_size)\n client_input['test_data'] = _create_dataset(test_batch_size)\n if context is not None:\n client_input['context'] = context\n return client_input","def main() -> Dict[int, int]:\n # DOCUMENTS DIRECTORY\n # Path of the directory that contains the .txt documents. One .txt document by company. IT NEEDS TO BE \"/data\" when you upload it in data challenge platform. For test in local, you can modifiy to match your data path.\n if dev:\n documents_directory = \"../example_dataset/data\"\n else: \n documents_directory = \"/data\"\n\n path_to_files: List[str] = [os.path.join(documents_directory, file) for file in os.listdir(documents_directory)]\n assert len(path_to_files) == 10 # 10 files in documents directory\n path_to_files.sort() # Sort list of path file by alphabetical order to match ground truth annotations order : IT IS ESSENTIAL.\n\n # INITIALIZATION OF YOUR OBJECTS\n data_model = FormDataModel.from_json_file(\n os.path.join(os.path.dirname(__file__), \"resources\", \"data-model.json\")\n )\n country_referential = CountryReferential.from_csv(\n os.path.join(os.path.dirname(__file__), \"resources\", \"countries_code.csv\")\n )\n form_company_filling = FormCompanyFilling([\n BasicExtractor(\n question_ids=NOT_COUNTRY_QUESTIONS_NUMBERS,\n form_data_model=data_model,\n ),\n BasicCountryExtractor(\n question_ids=COUNTRY_QUESTIONS_NUMBERS,\n form_data_model=data_model,\n country_code_referential=country_referential,\n\n )\n ])\n\n # COMPUTE PREDICTION BY FILE (ie company)\n print(\"##################################\")\n print(\"RUNNING PREDICTION\")\n results: Dict[int, int] = {}\n start_time = time.time()\n for i, path in enumerate(path_to_files):\n start = time.time()\n print(f\"File : {path}\")\n with open(path, \"r\") as input_file:\n text = input_file.read()\n print(\"... Encoding ...\")\n start_encoding = time.time()\n embeddings = model.encode(prepare_sentences(text))\n # embeddings = []\n print(\"Successfully encoded\")\n print(\"Encoding time : \", time.time() - start_encoding)\n\n form_company_response = form_company_filling.fill(text, embeddings, model)\n form_company_response.sort_by_question_id() # ESSENTIAL : Sort the response by question number for each company\n for answer in form_company_response.answers:\n question_number = answer.question_id + i * 22 # ESSENTIAL : each company has 22 questions. Each question_number in results should be unique\n results[question_number] = answer.answer_id\n # gc.collect()\n print(\"File time :\", time.time()-start, '\\n')\n # CHECK FORMAT RESULTS IS DATACHALLENGE PLATFORM COMPATIBLE\n assert len(results) == len(path_to_files) * (len(COUNTRY_QUESTIONS_NUMBERS) + len(NOT_COUNTRY_QUESTIONS_NUMBERS))\n assert set(list(results.keys())) == {i for i in range(1,221)}\n print(\"Full Time\", time.time()-start_time)\n return results","def inference():\n\n sents = request.get_json(force=True)['sents']\n\n vecs = tokenize_inputs(sents)\n results = model(vecs)\n\n result = dict()\n result['pred'] = [str(sample.numpy()[0]) for sample in results]\n \n response = flask.Response()\n response.headers.add(\"Access-Control-Allow-Origin\", \"*\")\n\n print(result)\n\n return result","def get_training_data_structure(x1, x2, y1, y2):\n return {input_id:{'group_1':x1, 'group_2':x2},\n output_id:{'group_1':y1, 'group_2':y2}}","def create_inputs_norb(path, is_train: bool,batch_size,epochs):\n\n # Create batched dataset\n dataset = input_fn(path, is_train,batch_size=batch_size, epochs=epochs)\n\n # Create one-shot iterator\n iterator = tf.compat.v1.data.make_one_shot_iterator(dataset)\n\n img, lab, cat, elv, azi, lit = iterator.get_next()\n\n output_dict = {'image': img,\n 'label': lab,\n 'category': cat,\n 'elevation': elv,\n 'azimuth': azi,\n 'lighting': lit}\n\n return output_dict","def infer():\n\n # Create StreamManagerApi object\n stream_manager_api = StreamManagerApi()\n # Use InitManager method init StreamManagerApi\n ret = stream_manager_api.InitManager()\n if ret != 0:\n print(\"Failed to init Stream manager, ret=%s\" % str(ret))\n exit()\n\n # create streams by pipeline config file\n with open(args.pipeline_path, \"rb\") as f:\n pipeline_str = f.read()\n\n # Configuring a stream\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\n if ret != 0:\n print(\"Failed to create Stream, ret=%s\" % str(ret))\n exit()\n\n # Construct the input of the stream\n data_input = MxDataInput()\n # Stream_name encoded in UTF-8\n stream_name = args.stream_name.encode()\n print(stream_name)\n predictions = []\n with open(args.label_path, 'rt') as f:\n val_cls = f.read().rstrip(\"\\n\").split(\"\\n\")\n val_cls_dict = {}\n for i, cls in enumerate(val_cls):\n val_cls_dict[i] = cls\n coco_gt = COCO(args.instances_path)\n classs_dict = {}\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\n for cat in cat_ids:\n classs_dict[cat[\"name\"]] = cat[\"id\"]\n\n for file_name in os.listdir(args.img_path):\n pred_data = []\n # Gets the Address of each image\n img_id = int(file_name.split('.')[0])\n file_path = args.img_path + file_name\n size = (cv2.imread(file_path)).shape\n\n # Read each photo in turn\n with open(file_path, \"rb\") as f:\n img_data = f.read()\n if not img_data:\n print(f\"read empty data from img:{file_name}\")\n continue\n # The element value img_data\n data_input.data = img_data\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\n pred_data.append({\"boxes\": boxes_output,\n \"box_scores\": scores_output,\n \"img_id\": img_id,\n \"image_shape\": size})\n\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\n print(f\"Inferred image:{file_name} success!\")\n\n # Save the result in JSON format\n if not os.path.exists(args.res_path):\n os.makedirs(args.res_path)\n with open(args.res_path + 'predictions_test.json', 'w') as f:\n json.dump(predictions, f)\n stream_manager_api.DestroyAllStreams()","def __generate_input_data(self):\n if not len(self.input_data) == 0:\n return\n\n try:\n self.input_data = s.load(open('output/input_data.p', 'rb'))\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n except:\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\n\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))","def generate_data(self):\n\n column_num = 1\n src_path = self.src_paths_after_pre_process\n target_path = self.tgt_paths_after_pre_process\n\n src_ds = load_textline_dataset([src_path], column_num)\n\n src_ds = src_ds[0]\n\n input_pipeline_func = self.get_input_pipeline(for_export=False)\n\n src_ds = src_ds.map(\n input_pipeline_func, num_parallel_calls=self.num_parallel_calls)\n\n src_size_ds = src_ds.map(\n lambda x: compute_sen_lens(x, padding_token=utils.PAD_IDX),\n num_parallel_calls=self.num_parallel_calls)\n\n src_ds = src_ds.map(\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\n\n if self.infer_without_label:\n data_set = tf.data.Dataset.zip((src_ds, src_size_ds))\n\n else:\n tgt = load_textline_dataset([target_path], column_num)\n tgt = tgt[0]\n tgt_out_ds = tgt.map(lambda x: x + ' ' + self.END_TOKEN)\n tgt_in_ds = tgt.map(lambda x: self.START_TOKEN + ' ' + x)\n\n tgt_in_ds = tgt_in_ds.map(\n lambda batch: self.text_pipeline_func(batch, self.max_dec_len, self.\n text_vocab_file_path),\n num_parallel_calls=self.num_parallel_calls)\n\n tgt_in_size_ds = tgt_in_ds.map(\n lambda x: compute_sen_lens(x, padding_token=utils.PAD_IDX),\n num_parallel_calls=self.num_parallel_calls)\n\n tgt_in_ds = tgt_in_ds.map(\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\n\n inp_ds = tf.data.Dataset.zip(\n (src_ds, src_size_ds, tgt_in_ds, tgt_in_size_ds))\n\n if self.use_label_vocab:\n target_vocab_file_path = self.label_vocab_file_paths[0]\n else:\n target_vocab_file_path = self.text_vocab_file_path\n tgt_out_ds = tgt_out_ds.map(\n lambda batch: self.text_pipeline_func(batch, self.max_dec_len,\n target_vocab_file_path),\n num_parallel_calls=self.num_parallel_calls)\n\n tgt_out_ds = tgt_out_ds.map(\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\n data_set = tf.data.Dataset.zip((inp_ds, tgt_out_ds))\n\n vocab_dict = load_vocab_dict(self.text_vocab_file_path)\n vocab_size = len(vocab_dict)\n label_vocab_dict = load_vocab_dict(self.label_vocab_file_paths[0])\n label_vocab_size = len(label_vocab_dict)\n data_size = get_file_len(self.src_paths_after_pre_process)\n self.config['data']['vocab_size'] = vocab_size\n self.config['data']['label_vocab_size'] = label_vocab_size\n self.config['data']['{}_data_size'.format(self.mode)] = data_size\n\n return data_set","def _predict_load(self, env_inputs):\n for app in self.system.apps:\n for node in self.system.nodes:\n data = self._load_data[app.id][node.id]\n for step in range(len(env_inputs)):\n data_index = step + self._current_index + 1\n value = None\n if data_index < len(data):\n value = data[data_index]\n else:\n value = self.environment_input.generated_load[app.id][node.id]\n env_inputs[step].generated_load[app.id][node.id] = value\n return env_inputs","def main():\n\n tok = T5Tokenizer.from_pretrained('t5-small')\n data = Data(\n xmi_dir=args.xmi_dir,\n tokenizer=tok,\n max_input_length=args.max_input_length,\n max_output_length=args.max_output_length,\n partition=args.partition,\n n_files=args.n_files)\n\n for index in range(len(data)):\n input_ids = data[index]['input_ids']\n output_ids = data[index]['labels']\n print(tok.decode(input_ids, skip_special_tokens=True))\n print(tok.decode(output_ids, skip_special_tokens=True))\n print()","def input_fn(params):\n batch_size = params[\"batch_size\"]\n\n d = tf.data.TFRecordDataset(input_file)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size = 100)\n\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record:_decode_record(record, name_to_features),\n batch_size = batch_size,\n drop_remainder=drop_remainder))\n return d","def get_output_data(\n self,\n inputs: Dict[str, Any]) -> Any:\n return inputs","def _load_data(self):\n self.mapper = Mapper()\n self.mapper.generate_vocabulary(self.review_summary_file)\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\n # Store all the mapper values in a dict for later recovery\n self.mapper_dict = dict()\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\n # Split into test and train data\n self._split_train_tst()","def input_fn(params):\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_file)\n if is_training:\n batch_size = params[\"train_batch_size\"]\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n else:\n batch_size = params[\"predict_batch_size\"]\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record: _decode_record(record, name_to_features),\n batch_size=batch_size,\n drop_remainder=drop_remainder))\n\n return d","def infer(self, request, datastore=None):\n model = request.get(\"model\")\n if not model:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n \"Model is not provided for Inference Task\",\n )\n\n task = self._infers.get(model)\n if not task:\n raise MONAILabelException(\n MONAILabelError.INVALID_INPUT,\n f\"Inference Task is not Initialized. There is no model '{model}' available\",\n )\n\n request = copy.deepcopy(request)\n request[\"description\"] = task.description\n\n image_id = request[\"image\"]\n if isinstance(image_id, str):\n datastore = datastore if datastore else self.datastore()\n if os.path.exists(image_id):\n request[\"save_label\"] = False\n else:\n request[\"image\"] = datastore.get_image_uri(request[\"image\"])\n\n if os.path.isdir(request[\"image\"]):\n logger.info(\"Input is a Directory; Consider it as DICOM\")\n\n logger.debug(f\"Image => {request['image']}\")\n else:\n request[\"save_label\"] = False\n\n if self._infers_threadpool:\n\n def run_infer_in_thread(t, r):\n handle_torch_linalg_multithread(r)\n return t(r)\n\n f = self._infers_threadpool.submit(run_infer_in_thread, t=task, r=request)\n result_file_name, result_json = f.result(request.get(\"timeout\", settings.MONAI_LABEL_INFER_TIMEOUT))\n else:\n result_file_name, result_json = task(request)\n\n label_id = None\n if result_file_name and os.path.exists(result_file_name):\n tag = request.get(\"label_tag\", DefaultLabelTag.ORIGINAL)\n save_label = request.get(\"save_label\", False)\n if save_label:\n label_id = datastore.save_label(\n image_id, result_file_name, tag, {\"model\": model, \"params\": result_json}\n )\n else:\n label_id = result_file_name\n\n return {\"label\": label_id, \"tag\": DefaultLabelTag.ORIGINAL, \"file\": result_file_name, \"params\": result_json}","def get_feed_dict(self, input_data, input_labels=None, dict_args=None, is_test=False):\n placeholders = [op.name\n for op\n in self.graph.get_operations()\n if (\"auto_placeholders\" in op.name\n and \"input_data\" not in op.name\n and \"input_label\" not in op.name)\n ]\n if input_labels is not None and hasattr(self, \"label_placeholder\"):\n feed_dict = {self.input_placeholder:input_data, self.label_placeholder:input_labels}\n else:\n feed_dict = {self.input_placeholder:input_data}\n for placeholder in placeholders:\n feed_dict[self.graph.get_tensor_by_name(placeholder+\":0\")] = (\n self.get_schedule(placeholder.split(\"/\")[1]))\n if dict_args is not None:\n feed_dict.update(dict_args)\n return feed_dict","def handle_input(data: dict):","def create_input_instances(self) -> dict:\n\n self.create_required_paths()\n return self.get_full_configuration()","def input_fn(params):\n #batch_size = params[\"batch_size\"]\n batch_size = FLAGS.train_batch_size if is_training else FLAGS.eval_batch_size\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_file)\n if is_training:\n if FLAGS.use_horovod:\n d = d.shard(hvd.size(), hvd.rank())\n d = d.repeat()\n d = d.shuffle(buffer_size=100, seed=FLAGS.random_seed)\n\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record: _decode_record(record, name_to_features),\n batch_size=batch_size,\n drop_remainder=drop_remainder))\n return d","def gen_data(self):\n\n # 1，read the source text\n inputs, labels = self.read_data()\n print(\"read finished\")\n\n # 2. word label index\n word_to_index, label_to_index = self.gen_word_label_index()\n # print(\"word_to_index\",word_to_index)\n # print(\"label_to_index\",label_to_index)\n print(\"vocab process finished\")\n #\n # 3，input to index\n inputs_idx = self.trans_to_index(inputs, word_to_index)\n # print((inputs_idx))\n print(\"index transform finished\")\n #\n # 4, padding\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\n # print(inputs_idx)\n print(\"padding finished\")\n\n # 6，label to index\n labels_idx = self.trans_label_to_index(labels, label_to_index)\n print(\"label index transform finished\")\n\n return np.array(inputs_idx), np.array(labels_idx)","def inference_preprocess(self):\n return","def input_config():\n run_dir = 'runs/ODEMnistClassification/8'\n epoch = 'latest'\n device = 'cpu'\n min_end_time = 10\n max_end_time = 100\n tol = 1e-3","def build_inputs(self):\n if self.mode == \"inference\":\n # In inference mode, images and inputs are fed via placeholders.\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_feed\")\n input_feed = tf.placeholder(\n dtype=tf.int64,\n shape=[None], # batch_size\n name=\"input_feed\")\n\n # Process image and insert batch dimensions.\n images = tf.expand_dims(self.load_image(image_feed), 0)\n input_seqs = tf.expand_dims(input_feed, 1)\n\n # No target sequences or input mask in inference mode.\n target_seqs = None\n input_mask = None\n else:\n def _load_example(serialized_example):\n encoded_image, caption = input_ops.parse_example(\n serialized_example,\n image_feature=self.config.image_feature_name,\n caption_feature=self.config.caption_feature_name)\n image = self.load_image(encoded_image)\n\n # strings.split expects a batch\n input_seqs, target_seqs, input_mask = input_ops.pad_caption_to_input(\n caption)\n return image, input_seqs, target_seqs, input_mask\n\n def _load_dataset(filename):\n return tf.data.TFRecordDataset(filename, buffer_size=16 * 1024 * 1024)\n\n df = tf.data.Dataset.list_files(\n self.config.input_file_pattern, shuffle=self.mode == \"train\")\n df = df.apply(\n tf.data.experimental.parallel_interleave(\n _load_dataset, cycle_length=64, sloppy=True))\n\n if self.mode == \"train\":\n df = df.repeat()\n df = df.shuffle(1024)\n\n df = df.apply(\n tf.data.experimental.map_and_batch(\n _load_example,\n self.config.batch_size,\n num_parallel_batches=8,\n drop_remainder=True))\n df = df.prefetch(8)\n images, input_seqs, target_seqs, input_mask = df.make_one_shot_iterator(\n ).get_next()\n\n self.images = images\n self.input_seqs = input_seqs\n self.target_seqs = target_seqs\n self.input_mask = input_mask","def processInputs(self):","def prepare_inputs(data, queries, tokenizer):\n # Prepare inputs\n table = pd.DataFrame.from_dict(data)\n inputs = tokenizer(table=table, queries=queries,truncation=True, padding=True,return_tensors=\"pt\").to(device)\n\n # Return things\n return table, inputs","def inputs(self):\n return {\n \"path_to_result_folder\": File_IO(self.node.inputs[0]),\n \"path_to_dtb_json_file\": File_IO(self.node.inputs[1]),\n \"path_to_reference_DTB\": File_IO(self.node.inputs[2])\n }","def data_prep_reg_go_def(xdata):\n xdata = np.asarray( xdata )\n x_dct = {'inputs': xdata}\n return x_dct","def gen_input(args, datareader, bkd_gids):\n As = {}\n Xs = {}\n for gid in bkd_gids:\n if gid not in As: As[gid] = torch.tensor(datareader.data['adj_list'][gid], dtype=torch.float)\n if gid not in Xs: Xs[gid] = torch.tensor(datareader.data['features'][gid], dtype=torch.float)\n Ainputs = {}\n Xinputs = {}\n \n if args.gtn_input_type == '1hop':\n for gid in bkd_gids:\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n elif args.gtn_input_type == '2hop':\n for gid in bkd_gids:\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\n torch.tensor(0.0, requires_grad=True))\n As[gid].fill_diagonal_(0.0)\n \n for gid in bkd_gids:\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n \n elif args.gtn_input_type == '1hop_degree': \n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\n \n for i in range(len(bkd_gids)):\n gid = bkd_gids[i]\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n \n elif args.gtn_input_type == '2hop_degree':\n for gid in bkd_gids:\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\n torch.tensor(0.0, requires_grad=True))\n As[gid].fill_diagonal_(0.0)\n \n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\n \n for i in range(len(bkd_gids)):\n gid = bkd_gids[i]\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n else: raise NotImplementedError('not support other types of aggregated inputs')\n\n # pad each input into maxi possible size (N, N) / (N, F)\n NodeMax = int(datareader.data['n_node_max'])\n FeatDim = np.array(datareader.data['features'][0]).shape[1]\n for gid in Ainputs.keys():\n a_input = Ainputs[gid]\n x_input = Xinputs[gid]\n \n add_dim = NodeMax - a_input.shape[0]\n Ainputs[gid] = np.pad(a_input, ((0, add_dim), (0, add_dim))).tolist()\n Xinputs[gid] = np.pad(x_input, ((0, add_dim), (0, 0))).tolist()\n Ainputs[gid] = torch.tensor(Ainputs[gid])\n Xinputs[gid] = torch.tensor(Xinputs[gid])\n\n return Ainputs, Xinputs","def read_inputs(self):\n #inputs \n inputs = {}\n # read inputs\n c = 1\n with open(self.path) as f:\n lines = f.readlines()\n for line in lines:\n data = line.rstrip(os.linesep).rstrip(',').split(',')\n input = np.array([np.float64(i) for i in data])\n inputs['image'+str(c)] = input\n c += 1\n\n\n\n return inputs","def input_data_definitions(self):\n input_defs = {\n self.key_targets: DataDefinition([-1], [torch.Tensor], \"Batch of targets, each being a single index [BATCH_SIZE]\")\n }\n\n if self.use_prediction_distributions:\n input_defs[self.key_predictions] = DataDefinition([-1, -1], [torch.Tensor], \"Batch of predictions, represented as tensor with probability distribution over classes [BATCH_SIZE x NUM_CLASSES]\")\n else: \n input_defs[self.key_predictions] = DataDefinition([-1], [torch.Tensor], \"Batch of predictions, represented as tensor with indices of predicted answers [BATCH_SIZE]\")\n\n if self.use_masking:\n input_defs[self.key_masks] = DataDefinition([-1], [torch.Tensor], \"Batch of masks [BATCH_SIZE]\")\n return input_defs","def input_fn(params):\n # batch_size = params[\"batch_size\"]\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_file)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=buffer_size)\n\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record: _decode_record(record, name_to_features),\n batch_size=batch_size,\n drop_remainder=drop_remainder))\n\n return d","def source_input(env, \r\n number, \r\n counter,\r\n generation,\r\n generation_list_come,\r\n generation_list_wait,\r\n generation_list_begin,\r\n generation_list_finish,\r\n df_simtime,\r\n generation_list_name,\r\n g1_list_name): \r\n# global g1_list_name\r\n for i in range(number):\r\n if i == 0:\r\n t = generation_list_come[i]#到达时间服从指数分布,此处的t为间隔时间\r\n else:\r\n t = generation_list_come[i] - generation_list_come[i-1]\r\n yield env.timeout(t)\r\n serve_time = np.random.choice(df_simtime['sim_time'])#得到模拟数据\r\n # print(serve_time)\r\n c = document(env, \r\n g1_list_name[i], \r\n generation, \r\n counter, \r\n time_in_fac,\r\n generation_list_begin,\r\n generation_list_wait,\r\n generation_list_finish,\r\n serve_time,\r\n generation_list_name)\r\n env.process(c)","def inference(self):\r\n\t\tfor partition, loader in self.loaders.items():\r\n\t\t\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\r\n\t\t\t\tloader)\r\n\t\t\tself.preds[partition] = {\r\n\t\t\t\t'tag': tags,\r\n\t\t\t\t'y': y,\r\n\t\t\t\t'y_hat': y_hat,\r\n\t\t\t\t# 'posteriors': post,\r\n\t\t\t\t# 'attentions': attentions\r\n\t\t\t}","def data():\n print (\"&\")\n res = {}\n\t\n # Load Data\n with open(DATA_PATH_TRAIN, 'rb') as f:\n data = pickle.load(f)\n\t\t\n for d in data:\n for j in range(len(d)):\n if not d[j][\"addinfo\"][\"path\"] in res:\n res[d[j][\"addinfo\"][\"path\"]] = {}\n d[j][\"environment\"][\"text\"] = d[j][\"addinfo\"][\"text\"]\n res[d[j][\"addinfo\"][\"path\"]][d[j][\"addinfo\"][\"line\"]] = d[j][\"environment\"]\n\t \t\n with open(DATA_PATH_TEST, 'rb') as f:\n data = pickle.load(f)\n\t\t\n for d in data:\n for j in range(len(d)):\n if not d[j][\"addinfo\"][\"path\"] in res:\n res[d[j][\"addinfo\"][\"path\"]] = {}\n d[j][\"environment\"][\"text\"] = d[j][\"addinfo\"][\"text\"]\n res[d[j][\"addinfo\"][\"path\"]][d[j][\"addinfo\"][\"line\"]] = d[j][\"environment\"]\n\t\t\t\n with open('tasks/env/data/data.json', 'w') as outfile:\n json.dump(res, outfile)","def __predict_input_fn(self):\n ## Recast spectra into dictionary for estimator\n features = {'flux': self.spectra_test}\n return features","def __train_input_fn(self):\n ## To ensure unbiased training, grab random labels to define batch\n labels = np.random.choice(np.unique(self.labels_train), self.batch_size)\n ## Then grab a random spectrum from each label\n spectra = np.zeros((self.batch_size, len(self.spectra_train[0])))\n for i,l in enumerate(labels):\n good = self.labels_train == l\n idx = np.random.choice(np.sum(good))\n spectra[i] = self.spectra_train[good][idx]\n ## Recast into dictionary for estimator\n features = {'flux': spectra}\n ## Convert labels to integers\n ilabels = [self.label_index_lookup[l] for l in labels]\n return features, ilabels","def build_inputs(self):\n # in prediction mode, we use a batch size of one\n batch_size = self.config.batch_size\n \n if self.mode == \"prediction\":\n batch_size = 1\n \n # In inference mode, images and inputs are fed via placeholders.\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_feed\") # shape: scalar value\n\n #image_fn_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_fn_feed\")\n \n #image_filename_queue = tf.train.string_input_producer([image_fn_feed]) # list of files to read\n \n #reader = tf.WholeFileReader()\n #_, image_feed = reader.read(image_filename_queue)\n \n \n text_feed = tf.placeholder(dtype=tf.int64,\n shape=[None, self.config.sentence_length], # shape 2D tensor - variable size (first dimension sentence sequence, second dimension token sequence (actually fixed size))\n name=\"text_feed\")\n \n # arbitrary labels (not used)\n mi_label = tf.constant(-1, dtype=tf.int64) \n sc_label = tf.constant(-1.0, dtype=tf.float32) \n\n image = self.process_image(image_feed)\n\n # Process image and insert batch dimensions.\n images = tf.expand_dims(self.process_image(image_feed), 0)\n input_seqs = tf.expand_dims(text_feed, 0) \n mi_labels = tf.expand_dims(mi_label, 0)\n sc_labels = tf.expand_dims(sc_label, 0)\n input_mask = tf.expand_dims(tf.constant([1], dtype=tf.int32) , 0)\n \n else:\n # Prefetch serialized SequenceExample protos.\n input_queue = input_ops.prefetch_input_data(\n self.reader,\n self.config.input_file_pattern,\n is_training=self.is_training(),\n batch_size=batch_size,\n values_per_shard=self.config.values_per_input_shard,\n input_queue_capacity_factor=self.config.input_queue_capacity_factor,\n num_reader_threads=self.config.num_input_reader_threads,\n mode=self.mode)\n\n # Image processing and random distortion. Split across multiple threads\n # with each thread applying a slightly different distortion.\n assert self.config.num_preprocess_threads % 2 == 0\n images_and_texts = []\n for thread_id in range(self.config.num_preprocess_threads):\n serialized_sequence_example = input_queue.dequeue()\n encoded_image, text, mi, sc = input_ops.parse_sequence_example(\n serialized_sequence_example,\n image_feature=self.config.image_feature_name,\n sentences_feature=self.config.sentences_feature_name,\n sentence_length=self.config.sentence_length,\n mi_feature=self.config.mi_feature_name,\n sc_feature=self.config.sc_feature_name)\n image = self.process_image(encoded_image, thread_id=thread_id)\n images_and_texts.append([image, text, mi, sc])\n\n # Batch inputs.\n queue_capacity = (2 * self.config.num_preprocess_threads *\n batch_size)\n images, input_seqs, mi_labels, sc_labels, input_mask = (\n input_ops.batch_with_dynamic_pad(images_and_texts,\n batch_size=batch_size,\n queue_capacity=queue_capacity))\n \n #print('Shapes') \n #print('Shape images: ' + str(images.get_shape()))\n #print('Shape input_seqs: ' + str(input_seqs.get_shape())) \n #print('Shape input_mask: ' + str(input_mask.get_shape())) \n\n self.images = images\n self.input_seqs = input_seqs\n if self.mode == \"prediction\":\n self.mi_labels = None\n self.sc_labels = None\n else:\n self.mi_labels = mi_labels\n self.sc_labels = sc_labels\n self.input_mask = input_mask","def inputs(self):\n pass","def _get_input_tensor_infos(self):\r\n input_tensor_infos = {}\r\n tensor_shape_list = []\r\n resize_tensor_list = []\r\n for input_tensor in self.model_inputs:\r\n tensor_name = input_tensor.name.rstrip()\r\n dtype = input_tensor.dtype\r\n shape = input_tensor.shape\r\n if -1 in shape or not shape:\r\n resize_tensor_list.append(input_tensor)\r\n shape = self.input_tensor_shapes.get(tensor_name, None)\r\n tensor_shape_list.append(list(shape))\r\n input_tensor_infos[tensor_name] = (shape, dtype)\r\n\r\n if not resize_tensor_list:\r\n self.logger.info(f'resize model input tensor '\r\n f'shape {resize_tensor_list} to {tensor_shape_list}')\r\n self.model_session.resize(resize_tensor_list, tensor_shape_list)\r\n self.model_inputs = self.model_session.get_inputs()\r\n\r\n return input_tensor_infos","def input_handling():\r\n # get program parameters from user\r\n k_in, n_in, Random = io.get_values()\r\n\r\n # Generation of n data points (2d or 3d)\r\n n, K, d, data, labels = io.sk_generator(n_in, k_in, Random)\r\n # Print description of Inputs and Random choices\r\n io.print_description(k_in, n_in, K, n, Random, d)\r\n\r\n return n, K, d, data, labels, Random","def input_setup(config):\n # Load data path, if is_train False, get test data\n data = load_data(config.is_train, config.test_img)\n \n # Make sub_input and sub_label, if is_train false more return nx, ny\n if config.is_train:\n \tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_train(data, config)\n else:\n\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_test(data, config)\n\n\n # Make list to numpy array. With this transform\n arrinput = np.asarray(sub_input_sequence) # [?, 41, 41, 3]\n arrlabel = np.asarray(sub_label_sequence) # [?, 41, 41, 3]\n make_data_hf(arrinput, arrlabel, config)\n\n return nx, ny","def _create_input_data(self):\n SCHEMA = parse_table_schema_from_json(\n '{\"fields\": [{\"name\": \"data\", \"type\": \"BYTES\"}]}')\n\n def format_record(record):\n # Since Synthetic Source returns data as a dictionary, we should skip one\n # of the part\n import base64\n return {'data': base64.b64encode(record[1])}\n\n with TestPipeline() as p:\n ( # pylint: disable=expression-not-assigned\n p\n | 'Produce rows' >> Read(\n SyntheticSource(self.parse_synthetic_source_options()))\n | 'Format' >> Map(format_record)\n | 'Write to BigQuery' >> WriteToBigQuery(\n dataset=self.input_dataset,\n table=self.input_table,\n schema=SCHEMA,\n create_disposition=BigQueryDisposition.CREATE_IF_NEEDED,\n write_disposition=BigQueryDisposition.WRITE_EMPTY))","def make_prediction(*,input_data) -> dict:\n\tdata = pd.read_json(input_data)\n\tprediction = _price_pipe.predict(data[config.FEATURES])\n\toutput = np.exp(prediction)\n\tresults = {'predictions':output,'version':_version}\n\t_logger.info(\n\t\tf'Making predictions with model version:{_version}'\n\t\tf'Inputs: {validated_data} '\n f'Predictions: {results}')\n\treturn results","def training_step(self, batch):\n return {}","def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass","def main():\n argparser = ArgumentParser()\n argparser.add_argument('--case', type=int, required=True,\n help='case number to create observations e.g. 1 if 1.json')\n args = argparser.parse_args()\n\n case = args.case\n observation_file = os.path.join(OBSERVATION_DIR, '{}.json'.format(case))\n with open(observation_file, 'r') as f:\n observation_config = json.load(f)\n\n nodes = observation_config['nodes']\n edges = observation_config['edges']\n observations = observation_config['observations']\n\n # solution part\n parameters = _get_learned_parameters(nodes=nodes, edges=edges, observations=observations)\n # end solution part\n\n # json only recognises floats, not np.float, so we need to cast the values into floats.\n for node, node_params in parameters.items():\n for param, val in node_params.items():\n node_params[param] = float(val)\n parameters[node] = node_params\n\n if not os.path.exists(PREDICTION_DIR):\n os.makedirs(PREDICTION_DIR)\n prediction_file = os.path.join(PREDICTION_DIR, '{}.json'.format(case))\n\n with open(prediction_file, 'w') as f:\n json.dump(parameters, f, indent=1)\n print('INFO: Results for test case {} are stored in {}'.format(case, prediction_file))","def inference_begin(self, data):\n return","def input_fn(params):\n\t\tbatch_size = params[\"batch_size\"]\n\t\toutput_buffer_size = batch_size * 1000\n\t\tmax_seq_len = {0: max_q_len, 1:max_p_len}\n\n\n\t\tdef extract_fn(data_record):\n\t\t\tif is_training:\n\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"raw_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"doc_ids0\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"doc_ids1\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"label\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t\t}\n\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\n\t\t\t\traw_query_ids = tf.cast(sample[\"raw_query_ids\"][:max_q_len], tf.int32)\n\t\t\t\traw_query_segment_ids = tf.cast(sample[\"raw_query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\traw_query_mask = tf.ones_like(raw_query_ids)\n\t\t\t\t# effective_raw_query_mask = tf.ones_like(query_ids)\n\t\t\t\teffective_raw_query_mask = tf.cast(sample[\"raw_query_mask\"][:max_q_len], tf.int32)\n\n\t\t\t\trewrite_query_ids = tf.cast(sample[\"rewrite_query_ids\"][:max_q_len], tf.int32)\n\t\t\t\trewrite_query_segment_ids = tf.cast(sample[\"rewrite_query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\trewrite_query_mask = tf.ones_like(rewrite_query_ids)\n\t\t\t\teffective_rewrite_query_mask = tf.cast(sample[\"rewrite_query_mask\"][:max_q_len], tf.int32)\n\n\n\t\t\t\tdoc0_ids = tf.cast(sample[\"doc_ids0\"][:max_p_len], tf.int32)\n\t\t\t\tdoc0_segment_ids = tf.zeros_like(doc0_ids)\n\t\t\t\tdoc0_mask = tf.ones_like(doc0_ids)\n\t\t\t\teffective_doc0_mask = tf.ones_like(doc0_ids)\n\n\n\t\t\t\tdoc1_ids = tf.cast(sample[\"doc_ids1\"][:max_p_len], tf.int32)\n\t\t\t\tdoc1_segment_ids = tf.zeros_like(doc1_ids)\n\t\t\t\tdoc1_mask = tf.ones_like(doc1_ids)\n\t\t\t\teffective_doc1_mask = tf.ones_like(doc1_ids)\n\n\n\t\t\t\tlabel = tf.cast(sample[\"label\"], tf.float32)\n\n\n\t\t\t\tfeatures = {\n\t\t\t\t\t\"raw_query_ids\": raw_query_ids,\n\t\t\t\t\t\"raw_query_segment_ids\": raw_query_segment_ids,\n\t\t\t\t\t\"raw_query_mask\": raw_query_mask,\n\t\t\t\t\t\"effective_raw_query_mask\": effective_raw_query_mask,\n\t\t\t\t\t\"rewrite_query_ids\": rewrite_query_ids,\n\t\t\t\t\t\"rewrite_query_segment_ids\": rewrite_query_segment_ids,\n\t\t\t\t\t\"rewrite_query_mask\": rewrite_query_mask,\n\t\t\t\t\t\"effective_rewrite_query_mask\": effective_rewrite_query_mask,\n\t\t\t\t\t\"doc0_ids\": doc0_ids,\n\t\t\t\t\t\"doc0_segment_ids\": doc0_segment_ids,\n\t\t\t\t\t\"doc0_mask\": doc0_mask,\n\t\t\t\t\t\"effective_doc0_mask\": effective_doc0_mask,\n\t\t\t\t\t\"doc1_ids\": doc1_ids,\n\t\t\t\t\t\"doc1_segment_ids\": doc1_segment_ids,\n\t\t\t\t\t\"doc1_mask\": doc1_mask,\n\t\t\t\t\t\"effective_doc1_mask\": effective_doc1_mask,\n\t\t\t\t\t\"label\": label,\n\t\t\t\t\t}\n\t\t\telse:\n\t\t\t\tif is_output:\n\t\t\t\t\tif doc_type==0:\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"raw_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"query_id\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\t\t\t\t\t\tinput_ids = tf.cast(sample[\"raw_query_ids\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tsegment_ids = tf.cast(sample[\"raw_query_segment_ids\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tinput_mask = tf.ones_like(input_ids)\n\t\t\t\t\t\teffective_input_mask = tf.cast(sample[\"raw_query_mask\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tdocid = tf.cast(sample[\"query_id\"], tf.int32)\n\t\t\t\t\t\tlabel = tf.cast(0, tf.int32) #dummy\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"input_ids\": input_ids,\n\t\t\t\t\t\t\t\"segment_ids\": segment_ids,\n\t\t\t\t\t\t\t\"input_mask\": input_mask,\n\t\t\t\t\t\t\t\"effective_input_mask\": effective_input_mask,\n\t\t\t\t\t\t\t\"docid\": docid,\n\t\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t\t}\n\t\t\t\t\telif doc_type==1:\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"doc_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"docid\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\t\t\t\t\t\tdoc_ids = sample[\"doc_ids\"][:max_seq_len[doc_type]]\n\n\t\t\t\t\t\tinput_ids = tf.cast(doc_ids, tf.int32)\n\t\t\t\t\t\tsegment_ids = tf.zeros_like(input_ids)\n\t\t\t\t\t\tinput_mask = tf.ones_like(input_ids)\n\t\t\t\t\t\tdocid = tf.cast(sample[\"docid\"], tf.int32)\n\t\t\t\t\t\tlabel = tf.cast(0, tf.int32) #dummy\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"input_ids\": input_ids,\n\t\t\t\t\t\t\t\"segment_ids\": segment_ids,\n\t\t\t\t\t\t\t\"input_mask\": input_mask,\n\t\t\t\t\t\t\t\"effective_input_mask\": input_mask,\n\t\t\t\t\t\t\t\"docid\": docid,\n\t\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t\t}\n\t\t\t\telif is_eval:\n\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\"query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"doc_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"label\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t}\n\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\n\t\t\t\t\tquery_ids = tf.cast(sample[\"query_ids\"][:max_q_len], tf.int32)\n\t\t\t\t\tquery_segment_ids = tf.cast(sample[\"query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\t\t# query_segment_ids = tf.zeros_like(query_ids)\n\t\t\t\t\tquery_mask = tf.ones_like(query_ids)\n\t\t\t\t\teffective_query_mask = tf.cast(sample[\"query_mask\"][:max_q_len], tf.int32)\n\t\t\t\t\t# effective_query_mask = tf.ones_like(query_ids)\n\n\t\t\t\t\tdocx_ids = tf.cast(sample[\"doc_ids\"][:max_p_len], tf.int32)\n\t\t\t\t\tdocx_segment_ids = tf.zeros_like(docx_ids)\n\t\t\t\t\tdocx_mask = tf.ones_like(docx_ids)\n\t\t\t\t\teffective_docx_mask = tf.ones_like(docx_ids)\n\n\n\t\t\t\t\tlabel = tf.cast(sample[\"label\"], tf.int32)\n\n\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\"query_ids\": query_ids,\n\t\t\t\t\t\t\"query_segment_ids\": query_segment_ids,\n\t\t\t\t\t\t\"query_mask\": query_mask,\n\t\t\t\t\t\t\"effective_query_mask\": effective_query_mask,\n\t\t\t\t\t\t\"docx_ids\": docx_ids,\n\t\t\t\t\t\t\"docx_segment_ids\": docx_segment_ids,\n\t\t\t\t\t\t\"docx_mask\": docx_mask,\n\t\t\t\t\t\t\"effective_docx_mask\": effective_docx_mask,\n\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t}\n\n\n\t\t\treturn features\n\n\t\tdataset = tf.data.TFRecordDataset([dataset_path])\n\t\tdataset = dataset.map(\n\t\t\textract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\n\n\t\tif is_training:\n\t\t\tdataset = dataset.repeat()\n\t\t\tdataset = dataset.shuffle(buffer_size=1000)\n\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\"raw_query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"raw_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"effective_raw_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"effective_rewrite_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"doc0_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc0_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc0_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"effective_doc0_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"effective_doc1_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"label\": []\n\t\t\t\t\t\t},\n\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\"raw_query_ids\": 0,\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": 0,\n\t\t\t\t\t\t\t\"raw_query_mask\": 0,\n\t\t\t\t\t\t\t\"effective_raw_query_mask\":0,\n\t\t\t\t\t\t\t\"rewrite_query_ids\": 0,\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": 0,\n\t\t\t\t\t\t\t\"rewrite_query_mask\": 0,\n\t\t\t\t\t\t\t\"effective_rewrite_query_mask\":0,\n\t\t\t\t\t\t\t\"doc0_ids\": 0,\n\t\t\t\t\t\t\t\"doc0_segment_ids\": 0,\n\t\t\t\t\t\t\t\"doc0_mask\": 0,\n\t\t\t\t\t\t\t\"effective_doc0_mask\": 0,\n\t\t\t\t\t\t\t\"doc1_ids\": 0,\n\t\t\t\t\t\t\t\"doc1_segment_ids\": 0,\n\t\t\t\t\t\t\t\"doc1_mask\": 0,\n\t\t\t\t\t\t\t\"effective_doc1_mask\": 0,\n\t\t\t\t\t\t\t\"label\": 0.0,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tdrop_remainder=True)\n\t\telse:\n\t\t\tif max_eval_examples:\n\t\t\t\t# Use at most this number of examples (debugging only).\n\t\t\t\tdataset = dataset.take(max_eval_examples)\n\t\t\tif is_output:\n\t\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\t\"input_ids\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"segment_ids\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"input_mask\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"effective_input_mask\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"docid\": [],\n\t\t\t\t\t\t\t\t\"label\": [],\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\t\"input_ids\": 0,\n\t\t\t\t\t\t\t\t\"segment_ids\": 0,\n\t\t\t\t\t\t\t\t\"input_mask\": 0,\n\t\t\t\t\t\t\t\t\"effective_input_mask\": 0,\n\t\t\t\t\t\t\t\t\"docid\": 0,\n\t\t\t\t\t\t\t\t\"label\": 0,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tdrop_remainder=True)\n\n\t\t\telif is_eval:\n\t\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\t\t\"query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"effective_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"docx_ids\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"docx_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"docx_mask\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"effective_docx_mask\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"label\": []\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\t\t\"query_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"query_segment_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"query_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"effective_query_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_segment_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"effective_docx_mask\":0,\n\t\t\t\t\t\t\t\t\t\"label\": 0,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tdrop_remainder=True)\n\t\treturn dataset","def _eval_input_fn():\n features_placeholder = {\n k: tf.compat.v1.placeholder(v.dtype, v.shape)\n for k, v in six.iteritems(features)\n }\n if use_multi_head:\n placeholder = tf.compat.v1.placeholder(labels.dtype, labels.shape)\n labels_placeholder = {\n _PRIMARY_HEAD: placeholder,\n _SECONDARY_HEAD: placeholder,\n }\n else:\n labels_placeholder = tf.compat.v1.placeholder(labels.dtype, labels.shape)\n dataset = tf.data.Dataset.from_tensors(\n (features_placeholder, labels_placeholder))\n iterator = tf.compat.v1.data.make_initializable_iterator(dataset)\n if use_multi_head:\n feed_dict = {\n labels_placeholder[head_name]: labels\n for head_name in labels_placeholder\n }\n else:\n feed_dict = {labels_placeholder: labels}\n\n feed_dict.update(\n {features_placeholder[k]: features[k] for k in features_placeholder})\n iterator_initializer_hook.iterator_initializer_fn = (\n lambda sess: sess.run(iterator.initializer, feed_dict=feed_dict))\n return iterator.get_next()","def inference(self, inputs):\n # NOTE: This makes the assumption that your model expects text to be tokenized\n # with \"input_ids\" and \"token_type_ids\" - which is true for some popular transformer models, e.g. bert.\n # If your transformer model expects different tokenization, adapt this code to suit\n # its expected input format.\n input_ids = inputs[\"input_ids\"]\n input_ids = input_ids.to(self.device)\n\n coarse_result = self.model.generate(input_ids = input_ids, )\n coarse_result = coarse_result.to(\"cpu\")\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\"original_length\"]+1:],\n skip_special_tokens = True)\n #logger.info(\"Model predicted: '%s'\", fined_result)\n\n return [fined_result]","def getTrainingData(self):\n raise NotImplementedError","def run(self, **inputs):\n if self.cached_model is None:\n self.cache_model(**inputs)\n for name, data in inputs.items():\n self.shared_vars[name].set_value(data)\n if self.mb and self.variational:\n self.minibatches = zip(self._mb_generator(inputs['gwas_gen']),\n self._mb_generator(inputs['gwas_phen']))\n self.trace = self._inference()\n return self.trace","def get_data_itr(**kwargs):\n batch_size = kwargs.pop('batch_size', 4)\n num_threads = kwargs.pop('num_threads', 8)\n fnames = kwargs.pop('fnames', [])\n q_capacity = kwargs.pop('q_capacity', 256)\n shuff = kwargs.pop('shuffle_input', True)\n serialized_keys = kwargs.pop('serialized_keys', data_constants.READER_FEAT_KEY_TYPE_MAP)\n out_type_keys = kwargs.pop('out_type_keys', data_constants.TF_FEAT_KEY_TYPE_MAP)\n feature_shapes = kwargs.pop('feature_shapes', data_constants.DATA_SHAPES)\n #This can still be invariant\n quantity_keys = {key: quant_type for key, quant_type in serialized_keys.items() if key[:2] == 'n_'}\n arr_key_type = {key: quant_type for key, quant_type in out_type_keys.items() if key[:2] != 'n_'}\n\n with tf.name_scope('input'):\n with tf.device('/cpu:0'):\n features_dict = {k: tf.FixedLenFeature((), t) for k, t in serialized_keys.items()}\n\n def _parser(serialized_example):\n features = tf.parse_single_example(serialized_example,\n features=features_dict)\n quant_features = {}\n for k, t in quantity_keys.items():\n quant_features[k[2:]] = tf.to_int32(features[k])\n\n arr_features = {}\n for k, t in arr_key_type.items():\n arr_features[k] = features[k]\n\n exam = _parse_el_example(arr_features,\n arr_key_type,\n quant_features)\n return exam\n\n dataset = tf.data.TFRecordDataset(fnames)\n\n if num_threads > 1:\n dataset = dataset.map(_parser, num_threads=num_threads)\n else:\n dataset = dataset.map(_parser)\n\n if shuff:\n dataset = dataset.shuffle(buffer_size=q_capacity)\n\n ordered_arr_key_type = sorted(arr_key_type.keys())\n pad_shape = tuple([feature_shapes[arr_k] for arr_k in ordered_arr_key_type])\n\n dataset = dataset.padded_batch(batch_size=batch_size,\n padded_shapes=pad_shape)\n itr = dataset.make_initializable_iterator()\n return itr, itr.get_next()","def create_training_args(self, input_dict: Dict[Text, List[types.Artifact]],\n output_dict: Dict[Text, List[types.Artifact]],\n exec_properties: Dict[Text, Any],\n executor_class_path: Text,\n training_inputs: Dict[Text, Any],\n job_id: Optional[Text]) -> Dict[Text, Any]:\n training_inputs = training_inputs.copy()\n\n json_inputs = artifact_utils.jsonify_artifact_dict(input_dict)\n logging.info('json_inputs=\\'%s\\'.', json_inputs)\n json_outputs = artifact_utils.jsonify_artifact_dict(output_dict)\n logging.info('json_outputs=\\'%s\\'.', json_outputs)\n json_exec_properties = json.dumps(exec_properties, sort_keys=True)\n logging.info('json_exec_properties=\\'%s\\'.', json_exec_properties)\n\n # We use custom containers to launch training on AI Platform (unified),\n # which invokes the specified image using the container's entrypoint. The\n # default entrypoint for TFX containers is to call scripts/run_executor.py.\n # The arguments below are passed to this run_executor entry to run the\n # executor specified in `executor_class_path`.\n container_command = _CONTAINER_COMMAND + [\n '--executor_class_path',\n executor_class_path,\n '--inputs',\n json_inputs,\n '--outputs',\n json_outputs,\n '--exec-properties',\n json_exec_properties,\n ]\n\n if not training_inputs.get('worker_pool_specs'):\n training_inputs['worker_pool_specs'] = [{}]\n\n for worker_pool_spec in training_inputs['worker_pool_specs']:\n if not worker_pool_spec.get('container_spec'):\n worker_pool_spec['container_spec'] = {\n 'image_uri': _TFX_IMAGE,\n }\n\n # Always use our own entrypoint instead of relying on container default.\n if 'command' in worker_pool_spec['container_spec']:\n logging.warn('Overriding custom value of container_spec.command')\n worker_pool_spec['container_spec']['command'] = container_command\n\n # Pop project_id so AIP doesn't complain about an unexpected parameter.\n # It's been a stowaway in aip_args and has finally reached its destination.\n project = training_inputs.pop('project')\n with telemetry_utils.scoped_labels(\n {telemetry_utils.LABEL_TFX_EXECUTOR: executor_class_path}):\n job_labels = telemetry_utils.get_labels_dict()\n\n # 'tfx_YYYYmmddHHMMSS' is the default job display name if not explicitly\n # specified.\n job_id = job_id or 'tfx_{}'.format(\n datetime.datetime.now().strftime('%Y%m%d%H%M%S'))\n\n training_args = {\n 'job_id': job_id,\n 'project': project,\n 'training_input': training_inputs,\n 'job_labels': job_labels\n }\n\n return training_args","def input_fn():\n d = tf.data.TFRecordDataset(input_file)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=sample_length)\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record: tf.parse_single_example(record, name_to_features),\n batch_size=batch_size,\n drop_remainder=drop_remainder))\n return d","def input_fn(params):\n batch_size = params[\"batch_size\"]\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_file)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.apply(\n tf.contrib.data.map_and_batch(\n lambda record: _decode_record(record, name_to_features),\n batch_size=batch_size,\n drop_remainder=drop_remainder,\n )\n )\n\n return d","def params_for_checkpoint(self):\n # We need real int types, not numpy.int64, not recognized by json\n # dumps.\n params = {\n 'nb_features_in': int(self.nb_features_in),\n 'nb_features_out': int(self.nb_features_out),\n 'key': self.key\n }\n return params","def enter_values(valuedata_to_enter):\n result={}\n\n for i in range(len(valuedata_to_enter)):\n paramdata = valuedata_to_enter[i]\n print(\"--[{}/{}]---{} ({})---\".format(i+1, len(valuedata_to_enter), paramdata[\"name\"], paramdata[\"vartype\"]))\n if \"desc\" in paramdata:\n print(\"Description: \" + paramdata[\"desc\"])\n final_value = None\n\n variable_type=paramdata[\"vartype\"]\n #simple variable types\n if variable_type==\"string\" or variable_type==\"real\" or variable_type==\"int\":\n inputted_value=input(\"\")\n if variable_type==\"string\":\n final_value = inputted_value\n elif inputted_value != \"\":\n if variable_type==\"real\":\n final_value = float(inputted_value)\n if variable_type==\"int\":\n final_value = int(inputted_value)\n #layer entry\n elif variable_type==\"layers\":\n stop_acquiring_layers=False\n final_value=[]\n print(\"Laissez vide pour arreter la saisie\")\n while not stop_acquiring_layers:\n inputted_value = input(\"Couche cachée #{}, nombre de neurones: \".format(len(final_value)+1))\n if inputted_value != \"\":\n final_value.append(int(inputted_value))\n else:\n stop_acquiring_layers = True\n #select from array\n elif variable_type==\"arrayelement\":\n array = paramdata[\"array\"]\n for i in range(len(array)):\n print(\"{}){}\".format(i, array[i]))\n\n selected_element = -1\n while not (selected_element >= 0 and selected_element < len(array)):\n selected_element = int(input(\"\"))\n final_value = array[selected_element]\n\n if final_value != None:\n result[paramdata[\"name\"]] = final_value\n return result","def data(request, data_pandas, data_pandas_truth, data_binary, data_binary_truth, data_tracks,\n data_tracks_no_detections, data_tracks_truth):\n return {\"pandas\": data_pandas,\n \"pandas_truth\": data_pandas_truth,\n \"binary\": data_binary,\n \"binary_truth\": data_binary_truth,\n \"tracks\": data_tracks,\n \"tracks_nd\": data_tracks_no_detections,\n \"tracks_truth\": data_tracks_truth}[request.param]","def generate_inputs_and_wrap_model(config_path, checkpoint_path, input_config):\n\n model = get_detector(cfg, checkpoint_path, device=\"cpu\")\n one_img, one_meta = preprocess_example_input(input_config)\n tensor_data = [one_img]\n model.forward = partial(model.forward, img_metas=[[one_meta]], return_loss=False)\n\n return model, tensor_data","def _train(self):\n self.train_acc.reset_states()\n self.val_acc.reset_states()\n self.train_loss.reset_states()\n self.val_loss.reset_states()\n\n self.train_ds.shuffle(buffer_size=1000)\n for idx, (x,y) in enumerate(self.train_ds):\n self.tf_train_step(x, y)\n\n for x,y in self.val_ds:\n self.tf_val_step(x, y)\n\n # It is important to return tf.Tensors as numpy objects.\n return {\n \"epoch\": self.iteration,\n \"loss_train\": self.train_loss.result().numpy(),\n \"loss_val\": self.val_loss.result().numpy(),\n \"acc_train\": self.train_acc.result().numpy(),\n \"acc_val\": self.val_acc.result().numpy(),\n }","def _prepare_input_for_export(args, kwargs):\n args, kwargs = _prepare_input_for_pytorch(args, kwargs)\n if not kwargs and len(args) > 0 and isinstance(args[-1], dict):\n onnx_inputs = args + ({},)\n elif kwargs:\n onnx_inputs = args + (kwargs,)\n else:\n onnx_inputs = args\n return onnx_inputs","def _process_task_inputs(self):\n _input = self._task.input\n log.debug('Input parsing for %s and node %s from container', self._task.project_id, self._task.internal_id)\n log.debug(_input)\n\n input_ports = dict()\n for port in _input:\n log.debug(port)\n self._process_task_input(port, input_ports)\n\n log.debug('DUMPING json')\n #dump json file\n if input_ports:\n file_name = os.path.join(self._executor.in_dir, 'input.json')\n with open(file_name, 'w') as f:\n json.dump(input_ports, f)\n\n log.debug('DUMPING DONE')","def test_export_dict_input_output(self):\n\n\n class Net(torch.nn.Module):\n \"\"\"\n Model using multiply as functional and module at different depths\n \"\"\"\n def __init__(self):\n super().__init__()\n self.layer = InputOutputDictModel()\n\n def forward(self, x):\n return self.layer(x)\n\n model = Net()\n\n # Add an empty dictionary as the last element to not treat as named arguments.\n # see torch.onnx.export() API for more details.\n dummy_input = (\n {'a': torch.randn(1, 10, 10, 10),\n 'b': torch.randn(1, 10, 10, 10),\n 'c': torch.randn(1, 10, 10, 10)\n }, {}\n )\n onnx_path = './data/MyModel.onnx'\n\n torch.onnx.export(model, dummy_input, onnx_path)\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input)\n\n onnx_model = onnx.load(onnx_path)\n onnx.checker.check_model(onnx_model)\n self.check_onnx_node_name_uniqueness(onnx_model)\n\n for node in onnx_model.graph.node:\n print(node.name)\n assert node.name.startswith('layer')","def build_input(self):\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\n return n_input, t_input, n_target, t_target, keep_prob"],"string":"[\n \"def create_inputs_for_inference(builder, conf):\\r\\n\\r\\n inputs = dict()\\r\\n\\r\\n inputs[\\\"mel_spec_input\\\"] = builder.addInputTensor(popart.TensorInfo(_get_popart_type(conf.precision),\\r\\n [conf.samples_per_device,\\r\\n conf.mel_bands,\\r\\n conf.max_spectrogram_length]),\\r\\n \\\"mel_spec_input\\\")\\r\\n\\r\\n return inputs\",\n \"def _do_infer(stream_manager_api, data_input):\\n stream_name = b'segmentation'\\n unique_id = stream_manager_api.SendData(\\n stream_name, 0, data_input)\\n if unique_id < 0:\\n raise RuntimeError(\\\"Failed to send data to stream.\\\")\\n\\n keys = [b\\\"mxpi_tensorinfer0\\\"]\\n keyVec = StringVector()\\n for key in keys:\\n keyVec.push_back(key)\\n infer_result = stream_manager_api.GetProtobuf(stream_name, 0, keyVec)\\n print(infer_result)\\n if infer_result.size() == 0:\\n print(\\\"infer_result is null\\\")\\n exit()\\n\\n TensorList = MxpiDataType.MxpiTensorPackageList()\\n TensorList.ParseFromString(infer_result[0].messageBuf)\\n data = np.frombuffer(\\n TensorList.tensorPackageVec[0].tensorVec[0].dataStr, dtype=np.float32)\\n data = data.reshape(1, 19, 1024, 2048)\\n return data\",\n \"def create_training_args(self, input_dict, output_dict, exec_properties,\\n executor_class_path, training_inputs,\\n job_id) -> Dict[Text, Any]:\\n pass\",\n \"def create_inputs(self):\\n return {}\",\n \"def serving_input_fn():\\n input_keys = tf.placeholder(\\n dtype=tf.string, shape=[None], name='input_keys')\\n\\n with tf.name_scope('ReadInferenceData'):\\n feature_dict, serialized_example = self._get_tensor_and_example(\\n mode, shuffle=shuffle, num_epochs=num_epochs)\\n\\n # At serving time, the batch size will be 1. We need to reshape the\\n # features to account for this.\\n features = {}\\n for key, tensor in iteritems(feature_dict):\\n features[key] = tf.expand_dims(tensor, 0)\\n tf.logging.info(key)\\n tf.logging.info(features)\\n\\n inputs = {\\n 'input_keys': input_keys,\\n 'input_examples': serialized_example,\\n }\\n\\n return tf.estimator.export.ServingInputReceiver(\\n features=features, receiver_tensors=inputs)\",\n \"def _input_fn(params):\\n batch_size = params['batch_size']\\n inputs, labels, lengths = sequence_example_lib.get_fake_data_batch(\\n batch_size, input_size, padding_length)\\n\\n features = {\\n 'inputs': inputs,\\n 'lengths': lengths\\n }\\n return features, labels\",\n \"def generate_input_data(self):\\n for socket_name, c in self.__taskobject.inputs.items():\\n if c['optional']:\\n self.__inputs[socket_name] = {'data': None, 'enable': False}\\n else:\\n self.__inputs[socket_name] = {'data': None, 'enable': True}\",\n \"def create_feed_dict(self, inputs_batch, labels_batch=None):\\n ### YOUR CODE HERE\\n feed_dict=dict()\\n feed_dict[self.input_placeholder]=inputs_batch\\n if labels_batch is not None:\\n feed_dict[self.labels_placeholder]=labels_batch\\n ### END YOUR CODE\\n return feed_dict\",\n \"def input_data_definitions(self):\\n return {\\n self.key_feature_maps: DataDefinition([-1, self.feature_maps_depth, self.feature_maps_height, self.feature_maps_width], [torch.Tensor], \\\"Batch of feature maps [BATCH_SIZE x FEAT_DEPTH x FEAT_HEIGHT x FEAT_WIDTH]\\\"),\\n self.key_question_encodings: DataDefinition([-1, self.question_encoding_size], [torch.Tensor], \\\"Batch of encoded questions [BATCH_SIZE x QUESTION_ENCODING_SIZE]\\\"),\\n }\",\n \"def _infer(self,\\n inputs,\\n start_id=None,\\n eos_id=None,\\n max_gen_len=None,\\n prev_input=None):\\n results = {}\\n enc_embed, dec_embed = self._encoder_decoder_network(\\n src_token=inputs['src_token'],\\n src_mask=inputs['src_mask'],\\n tgt_token=inputs['tgt_token'],\\n tgt_mask=inputs['tgt_mask'],\\n src_pos=inputs['src_pos'],\\n src_type=inputs['src_type'],\\n src_turn=inputs['src_turn'])\\n features = dec_embed[:, -1]\\n features = self.pooler(features) if self.with_pool else features\\n if self.example:\\n results['features'] = features\\n else:\\n intent_logits = self.intent_classifier(features)\\n intent_probs = self.softmax(intent_logits)\\n results['intent_probs'] = intent_probs\\n return results\",\n \"def _buildInput (self):\\n\\n\\t\\tindata = self.config['input']\\n\\t\\tif not isinstance (indata, dict):\\n\\t\\t\\tindata = ','.join(utils.alwaysList (indata))\\t\\t\\t\\n\\t\\t\\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\\n\\t\\t\\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\\n\\t\\t\\t\\n\\t\\t# expand to one key-channel pairs\\n\\t\\tfor inkeys, invals in indata.iteritems():\\n\\t\\t\\tkeys = utils.split(inkeys, ',')\\n\\t\\t\\tif callable (invals):\\n\\t\\t\\t\\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\\n\\t\\t\\t\\tvals = vals.split()\\n\\t\\t\\telif isinstance (invals, basestring): # only for files: \\\"/a/b/*.txt, /a/c/*.txt\\\"\\n\\t\\t\\t\\tvals = utils.split(invals, ',')\\n\\t\\t\\telif isinstance (invals, channel):\\n\\t\\t\\t\\tvals = invals.split()\\n\\t\\t\\telif isinstance (invals, list):\\n\\t\\t\\t\\tvals = channel.create(invals).split()\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise ValueError (\\\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\\\" % self._name())\\n\\t\\t\\t\\n\\t\\t\\twidth = len (vals)\\n\\t\\t\\tif len (keys) > width:\\n\\t\\t\\t\\traise ValueError ('%s: Not enough data for input variables.\\\\nVarialbes: %s\\\\nData: %s' % (self._name(), keys, vals))\\n\\t\\t\\t\\n\\t\\t\\tfor i, key in enumerate(keys):\\n\\t\\t\\t\\tintype = key.split(':')[-1]\\n\\t\\t\\t\\tthekey = key.split(':')[0]\\n\\t\\t\\t\\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\\n\\n\\t\\t\\t\\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\\n\\t\\t\\t\\t\\tintype = proc.IN_VARTYPE[0]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif intype in proc.IN_FILESTYPE:\\n\\t\\t\\t\\t\\tfor x, v in enumerate(val):\\n\\t\\t\\t\\t\\t\\tif isinstance (v, basestring):\\n\\t\\t\\t\\t\\t\\t\\tval[x] = channel.fromPath (v).toList()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif self.length == 0: \\n\\t\\t\\t\\t\\tself.props['length'] = len (val)\\n\\t\\t\\t\\tif self.length != len (val):\\n\\t\\t\\t\\t\\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\\n\\t\\t\\t\\tself.props['indata'][thekey] = {\\n\\t\\t\\t\\t\\t'type': intype,\\n\\t\\t\\t\\t\\t'data': val\\n\\t\\t\\t\\t}\\n\\t\\t\\tself.props['jobs'] = [None] * self.length\",\n \"def run(self, input):\\n return {}\",\n \"def __init__(self):\\n self.inputs = {}\",\n \"def inference():\\n if request.method == \\\"POST\\\":\\n data = request.json #\\n src_img = np.array(data[\\\"src\\\"]).astype(np.uint8) # Parsing data\\n ref_img = np.array(data[\\\"ref\\\"]).astype(np.uint8) #\\n ref_label = int(data[\\\"ref_label\\\"]) #\\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\\n return jsonify({\\\"result\\\": result.tolist()}) # Returning results into json\",\n \"def input_fn():\\n with tf.name_scope('ReadData'):\\n tensor, _ = self._get_tensor_and_example(\\n mode, shuffle=shuffle, num_epochs=num_epochs)\\n\\n with tf.name_scope('Batch'):\\n batched = tf.train.batch(\\n tensor,\\n batch_size=self._batch_size,\\n dynamic_pad=True,\\n capacity=QUEUE_SCALING_FACTOR * self._batch_size)\\n\\n features = {key: batched[key] for key in self._feature_keys}\\n labels = {}\\n for label_tuple in self._label_keys:\\n labels[label_tuple[0]] = tf.expand_dims(\\n batched[label_tuple[0]], axis=-1)\\n if label_tuple[1]:\\n labels[label_tuple[0] + '.time_to_event'] = tf.expand_dims(\\n batched[label_tuple[0] + '.time_of_event'] -\\n batched['trigger_time_sec'],\\n axis=-1)\\n\\n return features, labels\",\n \"def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None,goal='IC',save_path_dir=None): #b/c it is single, models_list contains one model only\\n running_loss = 0.0\\n \\n# outputs_list = []\\n# representations_list = []\\n# labels_list = []\\n# modality_list = []\\n# indices_list = []\\n# task_names_list = []\\n# attn_coefs_list = []\\n# sentence_lens_list = []\\n# class_labels_list = []\\n# class_predictions_list = []\\n \\n \\\"\\\"\\\" Initialize Dictionaries to Store Results \\\"\\\"\\\" \\n outputs_dict = dict()\\n representations_dict = dict()\\n attn_coefs_dict = dict()\\n labels_dict = dict()\\n sentence_lens_dict = dict()\\n class_labels_dict = dict()\\n class_predictions_dict = dict()\\n epoch_bleu = dict()\\n epoch_rouge = dict()\\n epoch_meteor = dict()\\n\\n for dest_lang in token2id_dict.keys():\\n outputs_dict[dest_lang] = list()\\n attn_coefs_dict[dest_lang] = list()\\n representations_dict[dest_lang] = list()\\n labels_dict[dest_lang] = list()\\n sentence_lens_dict[dest_lang] = list()\\n class_labels_dict[dest_lang] = list()\\n class_predictions_dict[dest_lang] = list()\\n epoch_bleu[dest_lang] = 0\\n epoch_rouge[dest_lang] = 0\\n epoch_meteor[dest_lang] = 0\\n\\n batch_num = 0\\n batch = 0\\n #class label is that in IC setting, but class label is answer in VQA setting\\n for inputs, text_indices, sentence_lens, class_labels, languages, document_level_text_indices, document_level_sentence_lens in tqdm(dataloaders[phase]):\\n \\\"\\\"\\\" Weaning Off of Teacher Forcing in a Linear Manner \\\"\\\"\\\"\\n #sampling_prob = (0.4/30000)*(batch+1)*(epoch_count+1)\\n #uniform_value = np.random.uniform(0,1)\\n #sampling = True if uniform_value < sampling_prob else False\\n sampling = False\\n batch += 1\\n \\\"\\\"\\\" Send Data to Device \\\"\\\"\\\"\\n inputs = inputs.to(device)\\n class_labels = class_labels.to(device)\\n #print(text_indices)\\n with torch.set_grad_enabled('train1' in phase):# and inference == False): #('train' in phase and inference == False)\\n \\\"\\\"\\\" Image Captioning Path \\\"\\\"\\\"\\n if goal == 'IC':\\n \\\"\\\"\\\" Perform Forward Pass i.e. Encoder and Decoder \\\"\\\"\\\"\\n current_labels_dict = dict() #text\\n# current_class_labels_dict = dict()\\n# current_class_predictions_dict = dict()\\n current_outputs_dict = dict()\\n# current_attn_coefs_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, representations = model(inputs,current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n #current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n if phase == 'train1':\\n attn_coefs = 5\\n class_predictions = 6\\n loss = calculate_IC_loss(criterion,outputs,current_text_indices[:,1:],class_predictions,class_labels,attn_coefs,auxiliary_loss,attn_loss)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n current_labels_dict[dest_lang] = current_text_indices[:,1:].cpu().detach().numpy()\\n# current_class_labels_dict[dest_lang] = class_labels\\n# current_class_predictions_dict[dest_lang] = class_predictions\\n current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n# current_attn_coefs_dict[dest_lang] = attn_coefs\\n# current_representations_dict[dest_lang] = representations\\n #\\\"\\\"\\\" Detach Outputs and Attn Coefs To Avoid Memory Leakage \\\"\\\"\\\"\\n #outputs = outputs.detach()\\n #attn_coefs = attn_coefs.detach()\\n current_text_indices.detach()\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Perform Forward Pass and Get Answers \\\"\\\"\\\"\\n outputs, representations, attn_coefs, class_predictions = model(inputs,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Calculate MSE Loss \\\"\\\"\\\"\\n #criterion = nn.MSELoss()\\n #class_labels = class_labels.type(torch.float)\\n \\\"\\\"\\\" Calculate CrossEntropyLoss \\\"\\\"\\\"\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n #print(outputs,outputs.shape)\\n loss = criterion(outputs,class_labels)\\n elif goal == 'Supervised': #encoder supervised pre-training\\n h, representations, class_predictions = model(inputs)#,text_indices,sentence_lens,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n loss = criterion(class_predictions,class_labels)\\n elif goal == 'Text_Supervised':\\n #h, class_predictions = model.supervised_forward(text_indices,sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n criterion = nn.CrossEntropyLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n class_predictions = model.supervised_forward(current_text_indices,current_sentence_lens,token2id_dict[dest_lang],id2embedding_dict[dest_lang],phase,device)\\n loss = criterion(class_predictions,class_labels)\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n\\n current_class_labels_dict[dest_lang] = class_labels.cpu().detach().numpy()\\n current_class_predictions_dict[dest_lang] = class_predictions.cpu().detach().numpy()\\n# current_representations_dict[dest_lang] = h\\n #loss = criterion(class_predictions,class_labels)\\n #print(loss)\\n elif goal == 'Language_Change_Detection':\\n criterion = nn.BCEWithLogitsLoss()\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_change_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.float) #needed for BCELoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n loss = 0\\n for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n current_loss = criterion(replacement_prediction,replacement_label)\\n loss = loss + current_loss\\n if i == len(replacement_predictions)-1:\\n loss = loss / len(replacement_predictions)\\n #loss = torch.mean(torch.tensor([criterion(replacement_prediction,replacement_label) for replacement_prediction,replacement_label in zip(replacement_predictions,replacement_labels)]))\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h \\n elif goal == 'Language_Detection':\\n criterion = nn.CrossEntropyLoss(ignore_index=0)\\n class_labels = class_labels.type(torch.long)\\n current_class_labels_dict = dict()\\n current_class_predictions_dict = dict()\\n# current_representations_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()):\\n \\\"\\\"\\\" Forward Pass \\\"\\\"\\\"\\n replacement_predictions, replacement_labels = model.language_detection_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device)\\n #replacement_labels = replacement_labels.type(torch.long) #needed for CrossEntropyLoss\\n \\\"\\\"\\\" Instance-Wise Loss Because Each Sentence is of a Different Length \\\"\\\"\\\"\\n# loss = 0\\n# for i,(replacement_prediction,replacement_label) in enumerate(zip(replacement_predictions,replacement_labels)):\\n# replacement_label = replacement_label.type(torch.long)\\n# current_loss = criterion(replacement_prediction,replacement_label)\\n# loss = loss + current_loss\\n# if i == len(replacement_predictions)-1:\\n# loss = loss / len(replacement_predictions)\\n #print(replacement_predictions.shape,replacement_labels.shape)\\n loss = criterion(replacement_predictions.permute(0,2,1),replacement_labels)\\n #print(loss)\\n total_loss = total_loss + loss\\n #print(dest_lang,total_loss)\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n \\\"\\\"\\\" Store Representations and Labels \\\"\\\"\\\"\\n current_class_predictions_dict[dest_lang] = [predictions.cpu().detach().numpy() for predictions in replacement_predictions]\\n current_class_labels_dict[dest_lang] = [labels.cpu().detach().numpy() for labels in replacement_labels]\\n# current_representations_dict[dest_lang] = h\\n elif goal == 'MLM':\\n criterion = nn.CrossEntropyLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n outputs, replacement_predictions = model.MLM_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Obtain Applicable Loss Locations (i.e., Where Token Was Masked) \\\"\\\"\\\"\\n token_loss_mask = torch.where(replacement_predictions == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n #print(outputs.shape)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n token_loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n \\\"\\\"\\\" Retrieve Only Relevant Losses (Masked) \\\"\\\"\\\"\\n loss = torch.mean(token_loss.masked_select(token_loss_mask))\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\n del current_text_indices\\n del token_loss\\n del token_loss_mask\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = outputs.cpu().detach().numpy() #text\\n elif goal == 'ELECTRA':\\n generator_criterion = nn.CrossEntropyLoss(reduction='none')\\n discriminator_criterion = nn.BCEWithLogitsLoss(reduction='none')\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n total_loss = 0\\n for (dest_lang,current_text_indices),current_sentence_lens in zip(text_indices.items(),sentence_lens.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = current_text_indices.to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Perform Forward Pass Through ELECTRA \\\"\\\"\\\"\\n generator_outputs, generator_labels, discriminator_outputs, discriminator_labels = model.ELECTRA_forward(current_text_indices,current_sentence_lens,token2id_dict,id2embedding_dict,dest_lang,phase,sampling,device) #outputs is B x S x Words\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n \\\"\\\"\\\" Generator Loss Mask (i.e., Only Consider Originally Masked Tokens ) \\\"\\\"\\\"\\n generator_token_loss_mask = torch.where(generator_labels == 1,torch.tensor(1,device=device),torch.tensor(0,device=device)).type(torch.bool)\\n \\\"\\\"\\\" Discrimiantor Loss Mask (i.e., Do Not Consider Padded Regions ) \\\"\\\"\\\"\\n discriminator_labels = discriminator_labels.view_as(discriminator_outputs) \\n discriminator_token_loss_mask = torch.ones_like(discriminator_labels)\\n for i,sentence_len in zip(range(discriminator_token_loss_mask.shape[0]),current_sentence_lens):\\n discriminator_token_loss_mask[i,sentence_len:] = 0\\n \\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Generator Token's Loss \\\"\\\"\\\"\\n generator_token_loss = generator_criterion(generator_outputs.permute(0,2,1),current_text_indices) # B x S\\n #print(generator_token_loss.shape,generator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n generator_loss = torch.mean(generator_token_loss.masked_select(generator_token_loss_mask)) #scalar\\n \\n \\\"\\\"\\\" Obtain Each Discriminator Token's Loss \\\"\\\"\\\" \\n discriminator_token_loss = discriminator_criterion(discriminator_outputs,discriminator_labels) # B x S\\n #print(discriminator_token_loss.shape,discriminator_token_loss_mask.shape)\\n \\\"\\\"\\\" Retrieve Only Relevant Loss (Masked) \\\"\\\"\\\"\\n discriminator_loss = torch.mean(discriminator_token_loss.masked_select(discriminator_token_loss_mask.type(torch.bool))) #scalar\\n \\n #print(generator_loss,discriminator_loss)\\n \\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n total_loss = total_loss + generator_loss + discriminator_loss\\n \\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n if dest_lang == list(text_indices.keys())[-1]:\\n loss = total_loss / len(text_indices)\\n \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[dest_lang] = discriminator_labels.cpu().detach().numpy()\\n# current_outputs_dict[dest_lang] = discriminator_outputs.cpu().detach().numpy() #text\\n elif goal == 'MARGE':\\n# current_labels_dict = dict() #text\\n# current_outputs_dict = dict()\\n #total_loss = 0\\n #for (dest_lang,current_text_indices),current_sentence_lens,current_languages in zip(text_indices.items(),sentence_lens.values(),languages.values()): #, sorted_indices, attn_coefs, class_predictions\\n \\\"\\\"\\\" Randomly Choose Target Lang for This Mini-Batch \\\"\\\"\\\"\\n #lang_list = list(text_indices.keys())\\n #target_lang = random.sample(lang_list,1).item()\\n #target_lang = 'de' #option to change based on dataset (MUST CHANGE IN PAD COLLATE)\\n outputs, target_lang = model(text_indices,sentence_lens,languages,document_level_text_indices,document_level_sentence_lens,token2id_dict,id2embedding_dict,phase,device)\\n \\\"\\\"\\\" Convert Text Indices/Targets to Tensor \\\"\\\"\\\"\\n current_text_indices = text_indices[target_lang].to(device) #torch.tensor(current_text_indices,device=device)\\n \\\"\\\"\\\" Remove '/START' Index from Target Indices \\\"\\\"\\\"\\n current_text_indices = current_text_indices[:,1:] # B x (S-1)\\n #if phase == 'train1':\\n \\\"\\\"\\\" Obtain Each Token's Loss \\\"\\\"\\\"\\n loss = criterion(outputs.permute(0,2,1),current_text_indices)\\n #print(loss)\\n #\\\"\\\"\\\" Aggregate Loss Across Languages \\\"\\\"\\\"\\n #total_loss = total_loss + loss\\n #\\\"\\\"\\\" Average Loss if This is Final Loss Collected \\\"\\\"\\\"\\n #if dest_lang == list(text_indices.keys())[-1]:\\n # loss = total_loss / len(text_indices)\\n# print(loss)\\n# \\\"\\\"\\\" Store Results \\\"\\\"\\\"\\n# current_labels_dict[target_lang] = current_text_indices.cpu().detach().numpy()\\n# current_outputs_dict[target_lang] = outputs.cpu().detach().numpy() #text\\n \\n\\n \\\"\\\"\\\" Backpropagation and Update Step \\\"\\\"\\\"\\n if phase == 'train1': #only perform backprop for train1 phase \\n loss.backward()\\n \\n \\\"\\\"\\\" Network Parameters \\\"\\\"\\\"\\n if isinstance(optimizer,tuple):\\n optimizer[0].step()\\n \\\"\\\"\\\" Task-Instance Parameters \\\"\\\"\\\"\\n optimizer[1].step() \\n optimizer[0].zero_grad()\\n optimizer[1].zero_grad()\\n else:\\n optimizer.step()\\n optimizer.zero_grad()\\n \\n \\\"\\\"\\\" Calculate Metrics \\\"\\\"\\\"\\n if goal == 'IC':\\n if phase == 'train1':\\n running_loss += loss.item() * inputs.shape[0]\\n elif goal == 'VQA':\\n running_loss += loss.item() * inputs.shape[0] \\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n running_loss += loss.item() * inputs.shape[0] \\n \\n# \\\"\\\"\\\" These Need to be Language Specific \\\"\\\"\\\"\\n \\n if goal in ['IC']:\\n batch_bleu = calculate_bleu_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_rouge = calculate_rouge_score(current_outputs_dict,current_labels_dict,token2id_dict)\\n batch_meteor = calculate_meteor_score(current_outputs_dict,current_labels_dict,token2id_dict) \\n \\n for dest_lang in batch_bleu.keys():\\n epoch_bleu[dest_lang] = epoch_bleu[dest_lang] + (1/batch)*(batch_bleu[dest_lang] - epoch_bleu[dest_lang])\\n epoch_rouge[dest_lang] = epoch_rouge[dest_lang] + (1/batch)*(batch_rouge[dest_lang] - epoch_rouge[dest_lang])\\n epoch_meteor[dest_lang] = epoch_meteor[dest_lang] + (1/batch)*(batch_meteor[dest_lang] - epoch_meteor[dest_lang])\\n \\n if phase in ['val']:\\n for dest_lang in text_indices.keys():\\n predicted_sentences = convert_predicted_ids_to_sentences(current_outputs_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n target_sentences = convert_target_ids_to_sentences(current_labels_dict[dest_lang],token2id_dict[dest_lang],dest_lang)\\n outputs_dict[dest_lang].extend(predicted_sentences)\\n labels_dict[dest_lang].extend(target_sentences)\\n \\n elif goal in ['Language_Change_Detection','Language_Detection']:\\n for dest_lang in text_indices.keys():\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n \\n# elif goal in ['Text_Supervised']:\\n## current_class_labels = current_class_labels_dict[dest_lang]\\n## current_class_predictions = current_class_predictions_dict[dest_lang]\\n## current_class_labels = current_class_labels.cpu().detach().numpy()\\n## current_class_predictions = current_class_predictions.cpu().detach().numpy()\\n# \\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\"\\n# #sentence_lens_dict[dest_lang].extend(current_sentence_lens)\\n# class_labels_dict[dest_lang].extend(current_class_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# class_predictions_dict[dest_lang].extend(current_class_predictions_dict[dest_lang]) #.cpu().detach().numpy())\\n#\\n# elif goal in ['MARGE']:\\n# labels_dict[target_lang].extend(current_labels_dict[target_lang]) #.cpu().detach().numpy())\\n# outputs_dict[target_lang].extend(current_outputs_dict[target_lang]) #.cpu().detach().numpy())\\n# break # because only one target language per minibatch \\n# if goal not in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n## if current_labels_dict[dest_lang].data.dtype != torch.long:\\n## current_labels_dict[dest_lang].data = current_labels_dict[dest_lang].data.type(torch.long)\\n# \\n## current_text_indices = current_labels_dict[dest_lang]\\n## current_outputs = current_outputs_dict[dest_lang]\\n## current_attn_coefs = current_attn_coefs_dict[dest_lang]\\n## current_representations = current_representations_dict[dest_lang]\\n# \\\"\\\"\\\" Store Batch Data in The Dictionaries \\\"\\\"\\\" \\n# labels_dict[dest_lang].extend(current_labels_dict[dest_lang]) #.cpu().detach().numpy())\\n# outputs_dict[dest_lang].extend(current_outputs_dict[dest_lang]) #.cpu().detach().numpy())\\n## attn_coefs_dict[dest_lang].extend(current_attn_coefs.cpu().detach().numpy())\\n## representations_dict[dest_lang].extend(current_representations.cpu().detach().numpy())\\n## elif goal in ['Text_Supervised']:\\n## current_representations = current_representations_dict[dest_lang]\\n## representations_dict[dest_lang].extend(current_representations.squeeze().cpu().detach().numpy()) \\n## else:\\n## current_representations = current_representations_dict[dest_lang]\\n## if goal in ['Language_Change_Detection','Language_Detection']:\\n## current_representations = [representations.cpu().detach().numpy() for representations in current_representations]\\n## else:\\n## current_representations = current_representations.cpu().detach().numpy()\\n## representations_dict[dest_lang].extend(current_representations) \\n# \\n## modality_list.append(modality)\\n## indices_list.append(indices)\\n## task_names_list.append(task_names)\\n \\n batch_num += 1\\n #if batch_num == 2:\\n # break\\n \\n #outputs_list, labels_list, modality_list, indices_list, task_names_list, pids_list = flatten_arrays(outputs_list,labels_list,modality_list,indices_list,task_names_list,pids_list)\\n if goal == 'IC':\\n if phase == 'train1':\\n epoch_loss = running_loss / len(dataloaders[phase].dataset)\\n else:\\n epoch_loss = 0 #filler\\n elif goal in ['VQA','Supervised','Text_Supervised','Language_Change_Detection','Language_Detection','MLM','ELECTRA','MARGE']:\\n epoch_loss = running_loss / len(dataloaders[phase].dataset) \\n \\n \\\"\\\"\\\" Removed Recently \\\"\\\"\\\"\\n #representations_list = np.concatenate(representations_list)\\n \\n if goal == 'IC':\\n \\\"\\\"\\\" BLEU Score Evaluation \\\"\\\"\\\"\\n# epoch_bleu = calculate_bleu_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_rouge = calculate_rouge_score(outputs_dict,labels_dict,token2id_dict)\\n# epoch_meteor = calculate_meteor_score(outputs_dict,labels_dict,token2id_dict) \\n return epoch_loss, epoch_bleu, epoch_rouge, epoch_meteor, outputs_dict, labels_dict #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal == 'VQA':\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(outputs_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['Supervised','Text_Supervised','Language_Change_Detection','Language_Detection']:\\n if goal in ['Language_Change_Detection','Language_Detection']:\\n epoch_acc = calculate_language_detection_accuracy(class_predictions_dict,class_labels_dict,goal)\\n else:\\n \\\"\\\"\\\" Accuracy of Answers \\\"\\\"\\\"\\n epoch_acc = calculate_answer_accuracy(class_predictions_dict,class_labels_dict)\\n return epoch_loss, epoch_acc #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\\n elif goal in ['MLM','ELECTRA','MARGE']:\\n return epoch_loss#, outputs_dict, labels_dict #representations_list, labels_list #, modality_list, indices_list, task_names_list, class_labels_list, attn_coefs_list, sentence_lens_list\",\n \"def input_data_definitions(self):\\n return {\\n self.key_inputs: DataDefinition(\\n [-1]*(self.num_inputs_dims-1) + [self.input_size],\\n [list]*(self.num_inputs_dims-1) + [torch.Tensor],\\n \\\"Batch of inputs [DIM 1 x DIM 2 x ... x INPUT_SIZE]\\\")\\n }\",\n \"def prepare(self):\\n\\n inp = self.config.get('predict.input', 'X:0')\\n out = self.config.get('predict.output', 'output:0')\\n\\n # set input placeholder\\n self.input = self.graph.get_tensor_by_name(inp)\\n\\n # set output operation\\n if isinstance(out, str) or isinstance(out, unicode):\\n self.output = {out: self.graph.get_tensor_by_name(out)}\\n self.output_alone = True\\n elif isinstance(out, list):\\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\\n self.output_alone = False\\n else:\\n raise LoaderException('incorrect predict.output type')\",\n \"def export_inputs(self):\\n vocab_dict = load_vocab_dict(self.text_vocab_file_path)\\n vocab_size = len(vocab_dict)\\n label_vocab_dict = load_vocab_dict(self.label_vocab_file_paths[0])\\n label_vocab_size = len(label_vocab_dict)\\n self.config['data']['vocab_size'] = vocab_size\\n self.config['data']['label_vocab_size'] = label_vocab_size\\n\\n input_sentence = tf.placeholder(\\n shape=(None,), dtype=tf.string, name=\\\"input_sentence\\\")\\n\\n input_pipeline_func = self.get_input_pipeline(for_export=True)\\n\\n token_ids = input_pipeline_func(input_sentence)\\n token_ids_len = tf.map_fn(lambda x: compute_sen_lens(x, padding_token=0),\\n token_ids)\\n\\n export_data = {\\n \\\"export_inputs\\\": {\\n \\\"input_sentence\\\": input_sentence\\n },\\n \\\"model_inputs\\\": {\\n \\\"input_enc_x\\\": token_ids,\\n \\\"input_x_len\\\": token_ids_len\\n }\\n }\\n\\n return export_data\",\n \"def run(self, inputIn):\\n measureList = self.inputToInternal(inputIn)\\n outputDict = {}\\n assert(len(self.features) == len(measureList))\\n for metricInstance in self.metricsDict.values():\\n metricEngine = MetricDistributor.factory.returnInstance('MetricDistributor', metricInstance)\\n for cnt in range(len(self.targets)):\\n nodeName = (str(self.targets[cnt]) + '_' + str(self.features[cnt])).replace(\\\"|\\\",\\\"_\\\")\\n varName = metricInstance.name + '|' + nodeName\\n output = metricEngine.evaluate(measureList[cnt], weights=self.weight, multiOutput=self.multiOutput)\\n outputDict[varName] = np.atleast_1d(output)\\n return outputDict\",\n \"def to_inference_module_input_from_dataframe(dataset: pd.DataFrame, config: ModelConfigDict, load_paths: bool=False, device: Optional[torch.device]=None) ->Dict[str, TorchscriptPreprocessingInput]:\\n inputs = {}\\n for if_config in config['input_features']:\\n feature_inputs = to_inference_model_input_from_series(dataset[if_config[COLUMN]], if_config[TYPE], load_paths=load_paths, feature_config=if_config)\\n feature_inputs = place_on_device(feature_inputs, device)\\n inputs[if_config[NAME]] = feature_inputs\\n return inputs\",\n \"def feed(self, data):\\n try:\\n feed = {}\\n for i in range(len(self.inputs)):\\n feed[self.inputs[i]] = data[i]\\n return feed\\n except Exception:\\n pass\",\n \"def construct_inputs(\\n cls,\\n training_data: Dict[str, SupervisedDataset],\\n task_feature: int,\\n rank: Optional[int] = None,\\n **kwargs: Any,\\n ) -> Dict[str, Any]:\\n inputs = super().construct_inputs(\\n training_data=training_data, task_feature=task_feature, rank=rank, **kwargs\\n )\\n inputs.pop(\\\"task_covar_prior\\\")\\n if \\\"train_Yvar\\\" not in inputs:\\n inputs[\\\"train_Yvar\\\"] = None\\n return inputs\",\n \"def _train_input_fn():\\n\\t\\tprint('\\\\n\\\\nRunning _train_input_fn\\\\n\\\\n')\\n\\t\\tfeatures_placeholder = {\\n\\t\\t\\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), features['query_unigrams'][0].shape[0])),\\n\\t\\t\\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), features['doc_unigrams'][0][0].shape[0]))\\n\\t\\t\\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), len(features['query_unigrams'][0]))),\\n\\t\\t\\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), len(features['doc_unigrams'][0][0])))\\n\\t\\t\\t#k: tf.placeholder(tf.string, get_shape(v)) for k, v in six.iteritems(features)\\n\\t\\t\\tk: tf.placeholder(v.dtype, v.shape) for k, v in six.iteritems(features)\\n\\t\\t\\t#k: tf.sparse.placeholder(tf.string, [len(v)] + v[0].shape.as_list(), name=k) for k, v in six.iteritems(features)\\n\\t\\t\\t#k: tf.placeholder(tf.string, (len(v), len(v[0]), len(v[0][0]))) for k, v in six.iteritems(features)\\n\\t\\t}\\n\\t\\tlabels_placeholder = tf.placeholder(labels.dtype, labels.shape, name='label')\\n\\t\\tdataset = tf.data.Dataset.from_tensor_slices((features_placeholder,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlabels_placeholder))\\n\\t\\t#dataset = dataset.shuffle(1000).repeat().batch(batch_size)\\n\\t\\tdataset = dataset.shuffle(batch_size*10).repeat().batch(batch_size)\\n\\t\\titerator = dataset.make_initializable_iterator()\\n\\t\\tfeed_dict = {labels_placeholder: labels}\\n\\t\\tfeed_dict.update(\\n\\t\\t\\t\\t{features_placeholder[k]: features[k] for k in features_placeholder})\\n\\n\\t\\tprint('feed_dict')\\n\\t\\tfor k,v in six.iteritems(feed_dict):\\n\\t\\t\\tprint(k.shape)\\n\\t\\t#\\tprint(v.shape)\\n\\t\\trun_options = tf.RunOptions(report_tensor_allocations_upon_oom = True)\\n\\t\\titerator_initializer_hook.iterator_initializer_fn = (\\n\\t\\t\\t\\tlambda sess: sess.run(iterator.initializer, feed_dict=feed_dict, options=run_options))\\n\\t\\treturn iterator.get_next()\",\n \"def build_inputs(self):\\n if self.mode == \\\"encode\\\":\\n # Word embeddings are fed from an external vocabulary which has possibly\\n # been expanded (see vocabulary_expansion.py).\\n encode_ids1 = None\\n encode_ids2 = None\\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask1\\\")\\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask2\\\")\\n label = None\\n\\n elif self.mode == \\\"test\\\":\\n encode_ids1 = None\\n encode_ids2 = None\\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask1\\\")\\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask2\\\")\\n label = None\\n \\n else:\\n # Prefetch serialized tf.Example protos.\\n input_queue = input_ops.prefetch_input_data(\\n self.reader,\\n self.config.input_file_pattern,\\n shuffle=self.config.shuffle_input_data,\\n capacity=self.config.input_queue_capacity,\\n num_reader_threads=self.config.num_input_reader_threads)\\n\\n # Deserialize a batch.\\n serialized = input_queue.dequeue_many(self.config.batch_size)\\n s1, s2, label = input_ops.parse_example_batch(\\n serialized)\\n\\n encode_ids1 = s1.ids\\n encode_ids2 = s2.ids\\n\\n encode_mask1 = s1.mask\\n encode_mask2 = s2.mask\\n \\n\\n\\n self.encode_ids1 = encode_ids1\\n self.encode_ids2 = encode_ids2\\n\\n self.encode_mask1 = encode_mask1\\n self.encode_mask2 = encode_mask2\\n\\n self.label = label\",\n \"def get_inference_input_ppo_bootstrap(self):\\n features = {\\n 'mcts_features':\\n tf.placeholder(tf.float32, shape=[None, self._env_state_space]),\\n 'policy_features':\\n tf.placeholder(tf.float32, shape=[None, self._env_state_space]),\\n }\\n return features\",\n \"def _input_fn(params):\\n # Retrieves the batch size for the current shard. The # of shards is\\n # computed according to the input pipeline deployment. See\\n # `tf.contrib.tpu.RunConfig` for details.\\n batch_size = params['batch_size']\\n inputs, labels, lengths = sequence_example_lib.get_padded_batch(\\n file_paths, batch_size, input_size, padding_length)\\n features = {\\n 'inputs': inputs,\\n 'lengths': lengths,\\n }\\n return features, labels\",\n \"def train_input(config, params):\\n \\\"\\\"\\\"\\n rawimages: Nb x hf x wf x 3, tf.float32, in [0,1]\\n rawlabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\\n rawmetadata: Python dictionary with matadata (e.g. image shape, dtype)\\n proimages: Nb x hf x wf x 3, tf.float32, in [0,1]\\n prolabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\\n \\\"\\\"\\\"\\n # runconfig = config.runconfig\\n # # otherconfig includes: train_preprocess, mappings\\n # otherconfig = config.otherconfig\\n # hparams = params\\n\\n # reading, mapping labels to problem from otherconfig['lids2cids'],\\n # batching, preprocessing with otherconfig['train_preprocess'], output\\n\\n # no obvious use of prodata metadata for now\\n with tf.variable_scope('input_pipeline'):\\n values = None\\n for num_dataset in range(len(params.tfrecords_list)): # , params.camvid_tfrecords_path]:\\n if values is None:\\n values = train_input_per_data(config, params, num_dataset)\\n values = list(values) + [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\\n else:\\n _values = list(train_input_per_data(config, params, num_dataset)) + \\\\\\n [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\\n values = [tf.concat((value1, value2), 0) for value1, value2 in zip(values, _values)]\\n\\n features = {'rawimages': values[1],\\n 'proimages': values[3],\\n 'rawimagespaths': values[0][0],\\n 'rawlabelspaths': values[0][1]}\\n labels = {'rawlabels': values[2],\\n 'prolabels': values[4],\\n 'domainlabels': values[5]}\\n return features, labels\",\n \"def generate_update_dict(self, input_data, input_labels=None, batch_step=0):\\n update_dict = dict()\\n return update_dict\",\n \"def prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def feed_inputs(self):\\n feed_dict = collections.defaultdict(list)\\n for i in range(self._pipe.batch_size):\\n data = self.example_to_data(self._buffer.get())\\n for k, v in data.items():\\n feed_dict[k].append(v)\\n for k, v in self.features.items():\\n self._pipe.feed_input(self.features[k], feed_dict[k])\",\n \"def create_dicts():\\n load_data_for_dict('data/atis/train/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/valid/seq.in', 'data/atis/voc/vocabulary.json')\\n load_data_for_dict('data/atis/test/seq.in', 'data/atis/voc/vocabulary.json') \\n load_data_for_dict('data/atis/train/seq.out', 'data/atis/voc/slot_vocabulary.json')\",\n \"def feed_training_args(self):\\n return {}\",\n \"def build_inference_graph(self):\\n self.build_train_graph()\",\n \"def _get_train_feed_dict(self, batch):\\n raise NotImplementedError\",\n \"def extract_input(config, params, num_take=None):\\n num_prefetch = params.Nb*10\\n if num_take is not None:\\n num_take = max((num_take, params.Nb))\\n num_prefetch = min((num_prefetch, num_take))\\n mapping = params.inference_problem_def['lids2cids']\\n with tf.device('/cpu:0'):\\n dataset = tf.data.TFRecordDataset(params.predict_dir)\\n if num_take is not None:\\n dataset = dataset.take(num_take)\\n dataset = dataset.repeat()\\n dataset = dataset.map(parse_func, num_parallel_calls=8)\\n dataset = dataset.map(\\n lambda image, label, paths: (paths, *prepare_data(image, label, mapping, params)))\\n dataset = dataset.map(lambda paths, image, label:\\n (paths, image, label, *preprocess_evaluate(image, label, params)), num_parallel_calls=8)\\n dataset = dataset.batch(params.Nb)\\n dataset = dataset.prefetch(num_prefetch)\\n iterator = dataset.make_one_shot_iterator()\\n values = iterator.get_next()\\n\\n features = {'rawimages': values[1],\\n 'proimages': values[3],\\n 'rawimagespaths': values[0][0],\\n 'rawlabelspaths': values[0][1]}\\n labels = {'rawlabels': values[2],\\n 'prolabels': values[4]}\\n return features, labels\",\n \"def _create_client_input(train_batch_size, test_batch_size, context=None):\\n client_input = collections.OrderedDict()\\n client_input['train_data'] = _create_dataset(train_batch_size)\\n client_input['test_data'] = _create_dataset(test_batch_size)\\n if context is not None:\\n client_input['context'] = context\\n return client_input\",\n \"def main() -> Dict[int, int]:\\n # DOCUMENTS DIRECTORY\\n # Path of the directory that contains the .txt documents. One .txt document by company. IT NEEDS TO BE \\\"/data\\\" when you upload it in data challenge platform. For test in local, you can modifiy to match your data path.\\n if dev:\\n documents_directory = \\\"../example_dataset/data\\\"\\n else: \\n documents_directory = \\\"/data\\\"\\n\\n path_to_files: List[str] = [os.path.join(documents_directory, file) for file in os.listdir(documents_directory)]\\n assert len(path_to_files) == 10 # 10 files in documents directory\\n path_to_files.sort() # Sort list of path file by alphabetical order to match ground truth annotations order : IT IS ESSENTIAL.\\n\\n # INITIALIZATION OF YOUR OBJECTS\\n data_model = FormDataModel.from_json_file(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"data-model.json\\\")\\n )\\n country_referential = CountryReferential.from_csv(\\n os.path.join(os.path.dirname(__file__), \\\"resources\\\", \\\"countries_code.csv\\\")\\n )\\n form_company_filling = FormCompanyFilling([\\n BasicExtractor(\\n question_ids=NOT_COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n ),\\n BasicCountryExtractor(\\n question_ids=COUNTRY_QUESTIONS_NUMBERS,\\n form_data_model=data_model,\\n country_code_referential=country_referential,\\n\\n )\\n ])\\n\\n # COMPUTE PREDICTION BY FILE (ie company)\\n print(\\\"##################################\\\")\\n print(\\\"RUNNING PREDICTION\\\")\\n results: Dict[int, int] = {}\\n start_time = time.time()\\n for i, path in enumerate(path_to_files):\\n start = time.time()\\n print(f\\\"File : {path}\\\")\\n with open(path, \\\"r\\\") as input_file:\\n text = input_file.read()\\n print(\\\"... Encoding ...\\\")\\n start_encoding = time.time()\\n embeddings = model.encode(prepare_sentences(text))\\n # embeddings = []\\n print(\\\"Successfully encoded\\\")\\n print(\\\"Encoding time : \\\", time.time() - start_encoding)\\n\\n form_company_response = form_company_filling.fill(text, embeddings, model)\\n form_company_response.sort_by_question_id() # ESSENTIAL : Sort the response by question number for each company\\n for answer in form_company_response.answers:\\n question_number = answer.question_id + i * 22 # ESSENTIAL : each company has 22 questions. Each question_number in results should be unique\\n results[question_number] = answer.answer_id\\n # gc.collect()\\n print(\\\"File time :\\\", time.time()-start, '\\\\n')\\n # CHECK FORMAT RESULTS IS DATACHALLENGE PLATFORM COMPATIBLE\\n assert len(results) == len(path_to_files) * (len(COUNTRY_QUESTIONS_NUMBERS) + len(NOT_COUNTRY_QUESTIONS_NUMBERS))\\n assert set(list(results.keys())) == {i for i in range(1,221)}\\n print(\\\"Full Time\\\", time.time()-start_time)\\n return results\",\n \"def inference():\\n\\n sents = request.get_json(force=True)['sents']\\n\\n vecs = tokenize_inputs(sents)\\n results = model(vecs)\\n\\n result = dict()\\n result['pred'] = [str(sample.numpy()[0]) for sample in results]\\n \\n response = flask.Response()\\n response.headers.add(\\\"Access-Control-Allow-Origin\\\", \\\"*\\\")\\n\\n print(result)\\n\\n return result\",\n \"def get_training_data_structure(x1, x2, y1, y2):\\n return {input_id:{'group_1':x1, 'group_2':x2},\\n output_id:{'group_1':y1, 'group_2':y2}}\",\n \"def create_inputs_norb(path, is_train: bool,batch_size,epochs):\\n\\n # Create batched dataset\\n dataset = input_fn(path, is_train,batch_size=batch_size, epochs=epochs)\\n\\n # Create one-shot iterator\\n iterator = tf.compat.v1.data.make_one_shot_iterator(dataset)\\n\\n img, lab, cat, elv, azi, lit = iterator.get_next()\\n\\n output_dict = {'image': img,\\n 'label': lab,\\n 'category': cat,\\n 'elevation': elv,\\n 'azimuth': azi,\\n 'lighting': lit}\\n\\n return output_dict\",\n \"def infer():\\n\\n # Create StreamManagerApi object\\n stream_manager_api = StreamManagerApi()\\n # Use InitManager method init StreamManagerApi\\n ret = stream_manager_api.InitManager()\\n if ret != 0:\\n print(\\\"Failed to init Stream manager, ret=%s\\\" % str(ret))\\n exit()\\n\\n # create streams by pipeline config file\\n with open(args.pipeline_path, \\\"rb\\\") as f:\\n pipeline_str = f.read()\\n\\n # Configuring a stream\\n ret = stream_manager_api.CreateMultipleStreams(pipeline_str)\\n if ret != 0:\\n print(\\\"Failed to create Stream, ret=%s\\\" % str(ret))\\n exit()\\n\\n # Construct the input of the stream\\n data_input = MxDataInput()\\n # Stream_name encoded in UTF-8\\n stream_name = args.stream_name.encode()\\n print(stream_name)\\n predictions = []\\n with open(args.label_path, 'rt') as f:\\n val_cls = f.read().rstrip(\\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n val_cls_dict = {}\\n for i, cls in enumerate(val_cls):\\n val_cls_dict[i] = cls\\n coco_gt = COCO(args.instances_path)\\n classs_dict = {}\\n cat_ids = coco_gt.loadCats(coco_gt.getCatIds())\\n for cat in cat_ids:\\n classs_dict[cat[\\\"name\\\"]] = cat[\\\"id\\\"]\\n\\n for file_name in os.listdir(args.img_path):\\n pred_data = []\\n # Gets the Address of each image\\n img_id = int(file_name.split('.')[0])\\n file_path = args.img_path + file_name\\n size = (cv2.imread(file_path)).shape\\n\\n # Read each photo in turn\\n with open(file_path, \\\"rb\\\") as f:\\n img_data = f.read()\\n if not img_data:\\n print(f\\\"read empty data from img:{file_name}\\\")\\n continue\\n # The element value img_data\\n data_input.data = img_data\\n boxes_output, scores_output = send_data_get_output(stream_name, data_input, stream_manager_api)\\n pred_data.append({\\\"boxes\\\": boxes_output,\\n \\\"box_scores\\\": scores_output,\\n \\\"img_id\\\": img_id,\\n \\\"image_shape\\\": size})\\n\\n parse_img_infer_result(pred_data[0], predictions, val_cls_dict, classs_dict)\\n print(f\\\"Inferred image:{file_name} success!\\\")\\n\\n # Save the result in JSON format\\n if not os.path.exists(args.res_path):\\n os.makedirs(args.res_path)\\n with open(args.res_path + 'predictions_test.json', 'w') as f:\\n json.dump(predictions, f)\\n stream_manager_api.DestroyAllStreams()\",\n \"def __generate_input_data(self):\\n if not len(self.input_data) == 0:\\n return\\n\\n try:\\n self.input_data = s.load(open('output/input_data.p', 'rb'))\\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n except:\\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\\n\\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))\",\n \"def generate_data(self):\\n\\n column_num = 1\\n src_path = self.src_paths_after_pre_process\\n target_path = self.tgt_paths_after_pre_process\\n\\n src_ds = load_textline_dataset([src_path], column_num)\\n\\n src_ds = src_ds[0]\\n\\n input_pipeline_func = self.get_input_pipeline(for_export=False)\\n\\n src_ds = src_ds.map(\\n input_pipeline_func, num_parallel_calls=self.num_parallel_calls)\\n\\n src_size_ds = src_ds.map(\\n lambda x: compute_sen_lens(x, padding_token=utils.PAD_IDX),\\n num_parallel_calls=self.num_parallel_calls)\\n\\n src_ds = src_ds.map(\\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\\n\\n if self.infer_without_label:\\n data_set = tf.data.Dataset.zip((src_ds, src_size_ds))\\n\\n else:\\n tgt = load_textline_dataset([target_path], column_num)\\n tgt = tgt[0]\\n tgt_out_ds = tgt.map(lambda x: x + ' ' + self.END_TOKEN)\\n tgt_in_ds = tgt.map(lambda x: self.START_TOKEN + ' ' + x)\\n\\n tgt_in_ds = tgt_in_ds.map(\\n lambda batch: self.text_pipeline_func(batch, self.max_dec_len, self.\\n text_vocab_file_path),\\n num_parallel_calls=self.num_parallel_calls)\\n\\n tgt_in_size_ds = tgt_in_ds.map(\\n lambda x: compute_sen_lens(x, padding_token=utils.PAD_IDX),\\n num_parallel_calls=self.num_parallel_calls)\\n\\n tgt_in_ds = tgt_in_ds.map(\\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\\n\\n inp_ds = tf.data.Dataset.zip(\\n (src_ds, src_size_ds, tgt_in_ds, tgt_in_size_ds))\\n\\n if self.use_label_vocab:\\n target_vocab_file_path = self.label_vocab_file_paths[0]\\n else:\\n target_vocab_file_path = self.text_vocab_file_path\\n tgt_out_ds = tgt_out_ds.map(\\n lambda batch: self.text_pipeline_func(batch, self.max_dec_len,\\n target_vocab_file_path),\\n num_parallel_calls=self.num_parallel_calls)\\n\\n tgt_out_ds = tgt_out_ds.map(\\n self.exclude_padding, num_parallel_calls=self.num_parallel_calls)\\n data_set = tf.data.Dataset.zip((inp_ds, tgt_out_ds))\\n\\n vocab_dict = load_vocab_dict(self.text_vocab_file_path)\\n vocab_size = len(vocab_dict)\\n label_vocab_dict = load_vocab_dict(self.label_vocab_file_paths[0])\\n label_vocab_size = len(label_vocab_dict)\\n data_size = get_file_len(self.src_paths_after_pre_process)\\n self.config['data']['vocab_size'] = vocab_size\\n self.config['data']['label_vocab_size'] = label_vocab_size\\n self.config['data']['{}_data_size'.format(self.mode)] = data_size\\n\\n return data_set\",\n \"def _predict_load(self, env_inputs):\\n for app in self.system.apps:\\n for node in self.system.nodes:\\n data = self._load_data[app.id][node.id]\\n for step in range(len(env_inputs)):\\n data_index = step + self._current_index + 1\\n value = None\\n if data_index < len(data):\\n value = data[data_index]\\n else:\\n value = self.environment_input.generated_load[app.id][node.id]\\n env_inputs[step].generated_load[app.id][node.id] = value\\n return env_inputs\",\n \"def main():\\n\\n tok = T5Tokenizer.from_pretrained('t5-small')\\n data = Data(\\n xmi_dir=args.xmi_dir,\\n tokenizer=tok,\\n max_input_length=args.max_input_length,\\n max_output_length=args.max_output_length,\\n partition=args.partition,\\n n_files=args.n_files)\\n\\n for index in range(len(data)):\\n input_ids = data[index]['input_ids']\\n output_ids = data[index]['labels']\\n print(tok.decode(input_ids, skip_special_tokens=True))\\n print(tok.decode(output_ids, skip_special_tokens=True))\\n print()\",\n \"def input_fn(params):\\n batch_size = params[\\\"batch_size\\\"]\\n\\n d = tf.data.TFRecordDataset(input_file)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size = 100)\\n\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record:_decode_record(record, name_to_features),\\n batch_size = batch_size,\\n drop_remainder=drop_remainder))\\n return d\",\n \"def get_output_data(\\n self,\\n inputs: Dict[str, Any]) -> Any:\\n return inputs\",\n \"def _load_data(self):\\n self.mapper = Mapper()\\n self.mapper.generate_vocabulary(self.review_summary_file)\\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\\n # Store all the mapper values in a dict for later recovery\\n self.mapper_dict = dict()\\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\\n # Split into test and train data\\n self._split_train_tst()\",\n \"def input_fn(params):\\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_file)\\n if is_training:\\n batch_size = params[\\\"train_batch_size\\\"]\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n else:\\n batch_size = params[\\\"predict_batch_size\\\"]\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record: _decode_record(record, name_to_features),\\n batch_size=batch_size,\\n drop_remainder=drop_remainder))\\n\\n return d\",\n \"def infer(self, request, datastore=None):\\n model = request.get(\\\"model\\\")\\n if not model:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n \\\"Model is not provided for Inference Task\\\",\\n )\\n\\n task = self._infers.get(model)\\n if not task:\\n raise MONAILabelException(\\n MONAILabelError.INVALID_INPUT,\\n f\\\"Inference Task is not Initialized. There is no model '{model}' available\\\",\\n )\\n\\n request = copy.deepcopy(request)\\n request[\\\"description\\\"] = task.description\\n\\n image_id = request[\\\"image\\\"]\\n if isinstance(image_id, str):\\n datastore = datastore if datastore else self.datastore()\\n if os.path.exists(image_id):\\n request[\\\"save_label\\\"] = False\\n else:\\n request[\\\"image\\\"] = datastore.get_image_uri(request[\\\"image\\\"])\\n\\n if os.path.isdir(request[\\\"image\\\"]):\\n logger.info(\\\"Input is a Directory; Consider it as DICOM\\\")\\n\\n logger.debug(f\\\"Image => {request['image']}\\\")\\n else:\\n request[\\\"save_label\\\"] = False\\n\\n if self._infers_threadpool:\\n\\n def run_infer_in_thread(t, r):\\n handle_torch_linalg_multithread(r)\\n return t(r)\\n\\n f = self._infers_threadpool.submit(run_infer_in_thread, t=task, r=request)\\n result_file_name, result_json = f.result(request.get(\\\"timeout\\\", settings.MONAI_LABEL_INFER_TIMEOUT))\\n else:\\n result_file_name, result_json = task(request)\\n\\n label_id = None\\n if result_file_name and os.path.exists(result_file_name):\\n tag = request.get(\\\"label_tag\\\", DefaultLabelTag.ORIGINAL)\\n save_label = request.get(\\\"save_label\\\", False)\\n if save_label:\\n label_id = datastore.save_label(\\n image_id, result_file_name, tag, {\\\"model\\\": model, \\\"params\\\": result_json}\\n )\\n else:\\n label_id = result_file_name\\n\\n return {\\\"label\\\": label_id, \\\"tag\\\": DefaultLabelTag.ORIGINAL, \\\"file\\\": result_file_name, \\\"params\\\": result_json}\",\n \"def get_feed_dict(self, input_data, input_labels=None, dict_args=None, is_test=False):\\n placeholders = [op.name\\n for op\\n in self.graph.get_operations()\\n if (\\\"auto_placeholders\\\" in op.name\\n and \\\"input_data\\\" not in op.name\\n and \\\"input_label\\\" not in op.name)\\n ]\\n if input_labels is not None and hasattr(self, \\\"label_placeholder\\\"):\\n feed_dict = {self.input_placeholder:input_data, self.label_placeholder:input_labels}\\n else:\\n feed_dict = {self.input_placeholder:input_data}\\n for placeholder in placeholders:\\n feed_dict[self.graph.get_tensor_by_name(placeholder+\\\":0\\\")] = (\\n self.get_schedule(placeholder.split(\\\"/\\\")[1]))\\n if dict_args is not None:\\n feed_dict.update(dict_args)\\n return feed_dict\",\n \"def handle_input(data: dict):\",\n \"def create_input_instances(self) -> dict:\\n\\n self.create_required_paths()\\n return self.get_full_configuration()\",\n \"def input_fn(params):\\n #batch_size = params[\\\"batch_size\\\"]\\n batch_size = FLAGS.train_batch_size if is_training else FLAGS.eval_batch_size\\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_file)\\n if is_training:\\n if FLAGS.use_horovod:\\n d = d.shard(hvd.size(), hvd.rank())\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100, seed=FLAGS.random_seed)\\n\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record: _decode_record(record, name_to_features),\\n batch_size=batch_size,\\n drop_remainder=drop_remainder))\\n return d\",\n \"def gen_data(self):\\n\\n # 1，read the source text\\n inputs, labels = self.read_data()\\n print(\\\"read finished\\\")\\n\\n # 2. word label index\\n word_to_index, label_to_index = self.gen_word_label_index()\\n # print(\\\"word_to_index\\\",word_to_index)\\n # print(\\\"label_to_index\\\",label_to_index)\\n print(\\\"vocab process finished\\\")\\n #\\n # 3，input to index\\n inputs_idx = self.trans_to_index(inputs, word_to_index)\\n # print((inputs_idx))\\n print(\\\"index transform finished\\\")\\n #\\n # 4, padding\\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\\n # print(inputs_idx)\\n print(\\\"padding finished\\\")\\n\\n # 6，label to index\\n labels_idx = self.trans_label_to_index(labels, label_to_index)\\n print(\\\"label index transform finished\\\")\\n\\n return np.array(inputs_idx), np.array(labels_idx)\",\n \"def inference_preprocess(self):\\n return\",\n \"def input_config():\\n run_dir = 'runs/ODEMnistClassification/8'\\n epoch = 'latest'\\n device = 'cpu'\\n min_end_time = 10\\n max_end_time = 100\\n tol = 1e-3\",\n \"def build_inputs(self):\\n if self.mode == \\\"inference\\\":\\n # In inference mode, images and inputs are fed via placeholders.\\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_feed\\\")\\n input_feed = tf.placeholder(\\n dtype=tf.int64,\\n shape=[None], # batch_size\\n name=\\\"input_feed\\\")\\n\\n # Process image and insert batch dimensions.\\n images = tf.expand_dims(self.load_image(image_feed), 0)\\n input_seqs = tf.expand_dims(input_feed, 1)\\n\\n # No target sequences or input mask in inference mode.\\n target_seqs = None\\n input_mask = None\\n else:\\n def _load_example(serialized_example):\\n encoded_image, caption = input_ops.parse_example(\\n serialized_example,\\n image_feature=self.config.image_feature_name,\\n caption_feature=self.config.caption_feature_name)\\n image = self.load_image(encoded_image)\\n\\n # strings.split expects a batch\\n input_seqs, target_seqs, input_mask = input_ops.pad_caption_to_input(\\n caption)\\n return image, input_seqs, target_seqs, input_mask\\n\\n def _load_dataset(filename):\\n return tf.data.TFRecordDataset(filename, buffer_size=16 * 1024 * 1024)\\n\\n df = tf.data.Dataset.list_files(\\n self.config.input_file_pattern, shuffle=self.mode == \\\"train\\\")\\n df = df.apply(\\n tf.data.experimental.parallel_interleave(\\n _load_dataset, cycle_length=64, sloppy=True))\\n\\n if self.mode == \\\"train\\\":\\n df = df.repeat()\\n df = df.shuffle(1024)\\n\\n df = df.apply(\\n tf.data.experimental.map_and_batch(\\n _load_example,\\n self.config.batch_size,\\n num_parallel_batches=8,\\n drop_remainder=True))\\n df = df.prefetch(8)\\n images, input_seqs, target_seqs, input_mask = df.make_one_shot_iterator(\\n ).get_next()\\n\\n self.images = images\\n self.input_seqs = input_seqs\\n self.target_seqs = target_seqs\\n self.input_mask = input_mask\",\n \"def processInputs(self):\",\n \"def prepare_inputs(data, queries, tokenizer):\\n # Prepare inputs\\n table = pd.DataFrame.from_dict(data)\\n inputs = tokenizer(table=table, queries=queries,truncation=True, padding=True,return_tensors=\\\"pt\\\").to(device)\\n\\n # Return things\\n return table, inputs\",\n \"def inputs(self):\\n return {\\n \\\"path_to_result_folder\\\": File_IO(self.node.inputs[0]),\\n \\\"path_to_dtb_json_file\\\": File_IO(self.node.inputs[1]),\\n \\\"path_to_reference_DTB\\\": File_IO(self.node.inputs[2])\\n }\",\n \"def data_prep_reg_go_def(xdata):\\n xdata = np.asarray( xdata )\\n x_dct = {'inputs': xdata}\\n return x_dct\",\n \"def gen_input(args, datareader, bkd_gids):\\n As = {}\\n Xs = {}\\n for gid in bkd_gids:\\n if gid not in As: As[gid] = torch.tensor(datareader.data['adj_list'][gid], dtype=torch.float)\\n if gid not in Xs: Xs[gid] = torch.tensor(datareader.data['features'][gid], dtype=torch.float)\\n Ainputs = {}\\n Xinputs = {}\\n \\n if args.gtn_input_type == '1hop':\\n for gid in bkd_gids:\\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n elif args.gtn_input_type == '2hop':\\n for gid in bkd_gids:\\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\\n torch.tensor(0.0, requires_grad=True))\\n As[gid].fill_diagonal_(0.0)\\n \\n for gid in bkd_gids:\\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n \\n elif args.gtn_input_type == '1hop_degree': \\n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\\n \\n for i in range(len(bkd_gids)):\\n gid = bkd_gids[i]\\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n \\n elif args.gtn_input_type == '2hop_degree':\\n for gid in bkd_gids:\\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\\n torch.tensor(0.0, requires_grad=True))\\n As[gid].fill_diagonal_(0.0)\\n \\n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\\n \\n for i in range(len(bkd_gids)):\\n gid = bkd_gids[i]\\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\\n \\n else: raise NotImplementedError('not support other types of aggregated inputs')\\n\\n # pad each input into maxi possible size (N, N) / (N, F)\\n NodeMax = int(datareader.data['n_node_max'])\\n FeatDim = np.array(datareader.data['features'][0]).shape[1]\\n for gid in Ainputs.keys():\\n a_input = Ainputs[gid]\\n x_input = Xinputs[gid]\\n \\n add_dim = NodeMax - a_input.shape[0]\\n Ainputs[gid] = np.pad(a_input, ((0, add_dim), (0, add_dim))).tolist()\\n Xinputs[gid] = np.pad(x_input, ((0, add_dim), (0, 0))).tolist()\\n Ainputs[gid] = torch.tensor(Ainputs[gid])\\n Xinputs[gid] = torch.tensor(Xinputs[gid])\\n\\n return Ainputs, Xinputs\",\n \"def read_inputs(self):\\n #inputs \\n inputs = {}\\n # read inputs\\n c = 1\\n with open(self.path) as f:\\n lines = f.readlines()\\n for line in lines:\\n data = line.rstrip(os.linesep).rstrip(',').split(',')\\n input = np.array([np.float64(i) for i in data])\\n inputs['image'+str(c)] = input\\n c += 1\\n\\n\\n\\n return inputs\",\n \"def input_data_definitions(self):\\n input_defs = {\\n self.key_targets: DataDefinition([-1], [torch.Tensor], \\\"Batch of targets, each being a single index [BATCH_SIZE]\\\")\\n }\\n\\n if self.use_prediction_distributions:\\n input_defs[self.key_predictions] = DataDefinition([-1, -1], [torch.Tensor], \\\"Batch of predictions, represented as tensor with probability distribution over classes [BATCH_SIZE x NUM_CLASSES]\\\")\\n else: \\n input_defs[self.key_predictions] = DataDefinition([-1], [torch.Tensor], \\\"Batch of predictions, represented as tensor with indices of predicted answers [BATCH_SIZE]\\\")\\n\\n if self.use_masking:\\n input_defs[self.key_masks] = DataDefinition([-1], [torch.Tensor], \\\"Batch of masks [BATCH_SIZE]\\\")\\n return input_defs\",\n \"def input_fn(params):\\n # batch_size = params[\\\"batch_size\\\"]\\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_file)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=buffer_size)\\n\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record: _decode_record(record, name_to_features),\\n batch_size=batch_size,\\n drop_remainder=drop_remainder))\\n\\n return d\",\n \"def source_input(env, \\r\\n number, \\r\\n counter,\\r\\n generation,\\r\\n generation_list_come,\\r\\n generation_list_wait,\\r\\n generation_list_begin,\\r\\n generation_list_finish,\\r\\n df_simtime,\\r\\n generation_list_name,\\r\\n g1_list_name): \\r\\n# global g1_list_name\\r\\n for i in range(number):\\r\\n if i == 0:\\r\\n t = generation_list_come[i]#到达时间服从指数分布,此处的t为间隔时间\\r\\n else:\\r\\n t = generation_list_come[i] - generation_list_come[i-1]\\r\\n yield env.timeout(t)\\r\\n serve_time = np.random.choice(df_simtime['sim_time'])#得到模拟数据\\r\\n # print(serve_time)\\r\\n c = document(env, \\r\\n g1_list_name[i], \\r\\n generation, \\r\\n counter, \\r\\n time_in_fac,\\r\\n generation_list_begin,\\r\\n generation_list_wait,\\r\\n generation_list_finish,\\r\\n serve_time,\\r\\n generation_list_name)\\r\\n env.process(c)\",\n \"def inference(self):\\r\\n\\t\\tfor partition, loader in self.loaders.items():\\r\\n\\t\\t\\tavg_loss, (y, y_hat), post, attentions, tags = self.eval_loader(\\r\\n\\t\\t\\t\\tloader)\\r\\n\\t\\t\\tself.preds[partition] = {\\r\\n\\t\\t\\t\\t'tag': tags,\\r\\n\\t\\t\\t\\t'y': y,\\r\\n\\t\\t\\t\\t'y_hat': y_hat,\\r\\n\\t\\t\\t\\t# 'posteriors': post,\\r\\n\\t\\t\\t\\t# 'attentions': attentions\\r\\n\\t\\t\\t}\",\n \"def data():\\n print (\\\"&\\\")\\n res = {}\\n\\t\\n # Load Data\\n with open(DATA_PATH_TRAIN, 'rb') as f:\\n data = pickle.load(f)\\n\\t\\t\\n for d in data:\\n for j in range(len(d)):\\n if not d[j][\\\"addinfo\\\"][\\\"path\\\"] in res:\\n res[d[j][\\\"addinfo\\\"][\\\"path\\\"]] = {}\\n d[j][\\\"environment\\\"][\\\"text\\\"] = d[j][\\\"addinfo\\\"][\\\"text\\\"]\\n res[d[j][\\\"addinfo\\\"][\\\"path\\\"]][d[j][\\\"addinfo\\\"][\\\"line\\\"]] = d[j][\\\"environment\\\"]\\n\\t \\t\\n with open(DATA_PATH_TEST, 'rb') as f:\\n data = pickle.load(f)\\n\\t\\t\\n for d in data:\\n for j in range(len(d)):\\n if not d[j][\\\"addinfo\\\"][\\\"path\\\"] in res:\\n res[d[j][\\\"addinfo\\\"][\\\"path\\\"]] = {}\\n d[j][\\\"environment\\\"][\\\"text\\\"] = d[j][\\\"addinfo\\\"][\\\"text\\\"]\\n res[d[j][\\\"addinfo\\\"][\\\"path\\\"]][d[j][\\\"addinfo\\\"][\\\"line\\\"]] = d[j][\\\"environment\\\"]\\n\\t\\t\\t\\n with open('tasks/env/data/data.json', 'w') as outfile:\\n json.dump(res, outfile)\",\n \"def __predict_input_fn(self):\\n ## Recast spectra into dictionary for estimator\\n features = {'flux': self.spectra_test}\\n return features\",\n \"def __train_input_fn(self):\\n ## To ensure unbiased training, grab random labels to define batch\\n labels = np.random.choice(np.unique(self.labels_train), self.batch_size)\\n ## Then grab a random spectrum from each label\\n spectra = np.zeros((self.batch_size, len(self.spectra_train[0])))\\n for i,l in enumerate(labels):\\n good = self.labels_train == l\\n idx = np.random.choice(np.sum(good))\\n spectra[i] = self.spectra_train[good][idx]\\n ## Recast into dictionary for estimator\\n features = {'flux': spectra}\\n ## Convert labels to integers\\n ilabels = [self.label_index_lookup[l] for l in labels]\\n return features, ilabels\",\n \"def build_inputs(self):\\n # in prediction mode, we use a batch size of one\\n batch_size = self.config.batch_size\\n \\n if self.mode == \\\"prediction\\\":\\n batch_size = 1\\n \\n # In inference mode, images and inputs are fed via placeholders.\\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_feed\\\") # shape: scalar value\\n\\n #image_fn_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_fn_feed\\\")\\n \\n #image_filename_queue = tf.train.string_input_producer([image_fn_feed]) # list of files to read\\n \\n #reader = tf.WholeFileReader()\\n #_, image_feed = reader.read(image_filename_queue)\\n \\n \\n text_feed = tf.placeholder(dtype=tf.int64,\\n shape=[None, self.config.sentence_length], # shape 2D tensor - variable size (first dimension sentence sequence, second dimension token sequence (actually fixed size))\\n name=\\\"text_feed\\\")\\n \\n # arbitrary labels (not used)\\n mi_label = tf.constant(-1, dtype=tf.int64) \\n sc_label = tf.constant(-1.0, dtype=tf.float32) \\n\\n image = self.process_image(image_feed)\\n\\n # Process image and insert batch dimensions.\\n images = tf.expand_dims(self.process_image(image_feed), 0)\\n input_seqs = tf.expand_dims(text_feed, 0) \\n mi_labels = tf.expand_dims(mi_label, 0)\\n sc_labels = tf.expand_dims(sc_label, 0)\\n input_mask = tf.expand_dims(tf.constant([1], dtype=tf.int32) , 0)\\n \\n else:\\n # Prefetch serialized SequenceExample protos.\\n input_queue = input_ops.prefetch_input_data(\\n self.reader,\\n self.config.input_file_pattern,\\n is_training=self.is_training(),\\n batch_size=batch_size,\\n values_per_shard=self.config.values_per_input_shard,\\n input_queue_capacity_factor=self.config.input_queue_capacity_factor,\\n num_reader_threads=self.config.num_input_reader_threads,\\n mode=self.mode)\\n\\n # Image processing and random distortion. Split across multiple threads\\n # with each thread applying a slightly different distortion.\\n assert self.config.num_preprocess_threads % 2 == 0\\n images_and_texts = []\\n for thread_id in range(self.config.num_preprocess_threads):\\n serialized_sequence_example = input_queue.dequeue()\\n encoded_image, text, mi, sc = input_ops.parse_sequence_example(\\n serialized_sequence_example,\\n image_feature=self.config.image_feature_name,\\n sentences_feature=self.config.sentences_feature_name,\\n sentence_length=self.config.sentence_length,\\n mi_feature=self.config.mi_feature_name,\\n sc_feature=self.config.sc_feature_name)\\n image = self.process_image(encoded_image, thread_id=thread_id)\\n images_and_texts.append([image, text, mi, sc])\\n\\n # Batch inputs.\\n queue_capacity = (2 * self.config.num_preprocess_threads *\\n batch_size)\\n images, input_seqs, mi_labels, sc_labels, input_mask = (\\n input_ops.batch_with_dynamic_pad(images_and_texts,\\n batch_size=batch_size,\\n queue_capacity=queue_capacity))\\n \\n #print('Shapes') \\n #print('Shape images: ' + str(images.get_shape()))\\n #print('Shape input_seqs: ' + str(input_seqs.get_shape())) \\n #print('Shape input_mask: ' + str(input_mask.get_shape())) \\n\\n self.images = images\\n self.input_seqs = input_seqs\\n if self.mode == \\\"prediction\\\":\\n self.mi_labels = None\\n self.sc_labels = None\\n else:\\n self.mi_labels = mi_labels\\n self.sc_labels = sc_labels\\n self.input_mask = input_mask\",\n \"def inputs(self):\\n pass\",\n \"def _get_input_tensor_infos(self):\\r\\n input_tensor_infos = {}\\r\\n tensor_shape_list = []\\r\\n resize_tensor_list = []\\r\\n for input_tensor in self.model_inputs:\\r\\n tensor_name = input_tensor.name.rstrip()\\r\\n dtype = input_tensor.dtype\\r\\n shape = input_tensor.shape\\r\\n if -1 in shape or not shape:\\r\\n resize_tensor_list.append(input_tensor)\\r\\n shape = self.input_tensor_shapes.get(tensor_name, None)\\r\\n tensor_shape_list.append(list(shape))\\r\\n input_tensor_infos[tensor_name] = (shape, dtype)\\r\\n\\r\\n if not resize_tensor_list:\\r\\n self.logger.info(f'resize model input tensor '\\r\\n f'shape {resize_tensor_list} to {tensor_shape_list}')\\r\\n self.model_session.resize(resize_tensor_list, tensor_shape_list)\\r\\n self.model_inputs = self.model_session.get_inputs()\\r\\n\\r\\n return input_tensor_infos\",\n \"def input_handling():\\r\\n # get program parameters from user\\r\\n k_in, n_in, Random = io.get_values()\\r\\n\\r\\n # Generation of n data points (2d or 3d)\\r\\n n, K, d, data, labels = io.sk_generator(n_in, k_in, Random)\\r\\n # Print description of Inputs and Random choices\\r\\n io.print_description(k_in, n_in, K, n, Random, d)\\r\\n\\r\\n return n, K, d, data, labels, Random\",\n \"def input_setup(config):\\n # Load data path, if is_train False, get test data\\n data = load_data(config.is_train, config.test_img)\\n \\n # Make sub_input and sub_label, if is_train false more return nx, ny\\n if config.is_train:\\n \\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_train(data, config)\\n else:\\n\\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_test(data, config)\\n\\n\\n # Make list to numpy array. With this transform\\n arrinput = np.asarray(sub_input_sequence) # [?, 41, 41, 3]\\n arrlabel = np.asarray(sub_label_sequence) # [?, 41, 41, 3]\\n make_data_hf(arrinput, arrlabel, config)\\n\\n return nx, ny\",\n \"def _create_input_data(self):\\n SCHEMA = parse_table_schema_from_json(\\n '{\\\"fields\\\": [{\\\"name\\\": \\\"data\\\", \\\"type\\\": \\\"BYTES\\\"}]}')\\n\\n def format_record(record):\\n # Since Synthetic Source returns data as a dictionary, we should skip one\\n # of the part\\n import base64\\n return {'data': base64.b64encode(record[1])}\\n\\n with TestPipeline() as p:\\n ( # pylint: disable=expression-not-assigned\\n p\\n | 'Produce rows' >> Read(\\n SyntheticSource(self.parse_synthetic_source_options()))\\n | 'Format' >> Map(format_record)\\n | 'Write to BigQuery' >> WriteToBigQuery(\\n dataset=self.input_dataset,\\n table=self.input_table,\\n schema=SCHEMA,\\n create_disposition=BigQueryDisposition.CREATE_IF_NEEDED,\\n write_disposition=BigQueryDisposition.WRITE_EMPTY))\",\n \"def make_prediction(*,input_data) -> dict:\\n\\tdata = pd.read_json(input_data)\\n\\tprediction = _price_pipe.predict(data[config.FEATURES])\\n\\toutput = np.exp(prediction)\\n\\tresults = {'predictions':output,'version':_version}\\n\\t_logger.info(\\n\\t\\tf'Making predictions with model version:{_version}'\\n\\t\\tf'Inputs: {validated_data} '\\n f'Predictions: {results}')\\n\\treturn results\",\n \"def training_step(self, batch):\\n return {}\",\n \"def inference(model, data, diagnostics, seed, extra_fitting_args):\\n pass\",\n \"def main():\\n argparser = ArgumentParser()\\n argparser.add_argument('--case', type=int, required=True,\\n help='case number to create observations e.g. 1 if 1.json')\\n args = argparser.parse_args()\\n\\n case = args.case\\n observation_file = os.path.join(OBSERVATION_DIR, '{}.json'.format(case))\\n with open(observation_file, 'r') as f:\\n observation_config = json.load(f)\\n\\n nodes = observation_config['nodes']\\n edges = observation_config['edges']\\n observations = observation_config['observations']\\n\\n # solution part\\n parameters = _get_learned_parameters(nodes=nodes, edges=edges, observations=observations)\\n # end solution part\\n\\n # json only recognises floats, not np.float, so we need to cast the values into floats.\\n for node, node_params in parameters.items():\\n for param, val in node_params.items():\\n node_params[param] = float(val)\\n parameters[node] = node_params\\n\\n if not os.path.exists(PREDICTION_DIR):\\n os.makedirs(PREDICTION_DIR)\\n prediction_file = os.path.join(PREDICTION_DIR, '{}.json'.format(case))\\n\\n with open(prediction_file, 'w') as f:\\n json.dump(parameters, f, indent=1)\\n print('INFO: Results for test case {} are stored in {}'.format(case, prediction_file))\",\n \"def inference_begin(self, data):\\n return\",\n \"def input_fn(params):\\n\\t\\tbatch_size = params[\\\"batch_size\\\"]\\n\\t\\toutput_buffer_size = batch_size * 1000\\n\\t\\tmax_seq_len = {0: max_q_len, 1:max_p_len}\\n\\n\\n\\t\\tdef extract_fn(data_record):\\n\\t\\t\\tif is_training:\\n\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids0\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids1\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\n\\t\\t\\t\\traw_query_ids = tf.cast(sample[\\\"raw_query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\traw_query_segment_ids = tf.cast(sample[\\\"raw_query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\traw_query_mask = tf.ones_like(raw_query_ids)\\n\\t\\t\\t\\t# effective_raw_query_mask = tf.ones_like(query_ids)\\n\\t\\t\\t\\teffective_raw_query_mask = tf.cast(sample[\\\"raw_query_mask\\\"][:max_q_len], tf.int32)\\n\\n\\t\\t\\t\\trewrite_query_ids = tf.cast(sample[\\\"rewrite_query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\trewrite_query_segment_ids = tf.cast(sample[\\\"rewrite_query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\trewrite_query_mask = tf.ones_like(rewrite_query_ids)\\n\\t\\t\\t\\teffective_rewrite_query_mask = tf.cast(sample[\\\"rewrite_query_mask\\\"][:max_q_len], tf.int32)\\n\\n\\n\\t\\t\\t\\tdoc0_ids = tf.cast(sample[\\\"doc_ids0\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\tdoc0_segment_ids = tf.zeros_like(doc0_ids)\\n\\t\\t\\t\\tdoc0_mask = tf.ones_like(doc0_ids)\\n\\t\\t\\t\\teffective_doc0_mask = tf.ones_like(doc0_ids)\\n\\n\\n\\t\\t\\t\\tdoc1_ids = tf.cast(sample[\\\"doc_ids1\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\tdoc1_segment_ids = tf.zeros_like(doc1_ids)\\n\\t\\t\\t\\tdoc1_mask = tf.ones_like(doc1_ids)\\n\\t\\t\\t\\teffective_doc1_mask = tf.ones_like(doc1_ids)\\n\\n\\n\\t\\t\\t\\tlabel = tf.cast(sample[\\\"label\\\"], tf.float32)\\n\\n\\n\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": raw_query_ids,\\n\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": raw_query_segment_ids,\\n\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": raw_query_mask,\\n\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\": effective_raw_query_mask,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": rewrite_query_ids,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": rewrite_query_segment_ids,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": rewrite_query_mask,\\n\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\": effective_rewrite_query_mask,\\n\\t\\t\\t\\t\\t\\\"doc0_ids\\\": doc0_ids,\\n\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": doc0_segment_ids,\\n\\t\\t\\t\\t\\t\\\"doc0_mask\\\": doc0_mask,\\n\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": effective_doc0_mask,\\n\\t\\t\\t\\t\\t\\\"doc1_ids\\\": doc1_ids,\\n\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": doc1_segment_ids,\\n\\t\\t\\t\\t\\t\\\"doc1_mask\\\": doc1_mask,\\n\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": effective_doc1_mask,\\n\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif is_output:\\n\\t\\t\\t\\t\\tif doc_type==0:\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"query_id\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\t\\t\\t\\t\\t\\tinput_ids = tf.cast(sample[\\\"raw_query_ids\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tsegment_ids = tf.cast(sample[\\\"raw_query_segment_ids\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tinput_mask = tf.ones_like(input_ids)\\n\\t\\t\\t\\t\\t\\teffective_input_mask = tf.cast(sample[\\\"raw_query_mask\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tdocid = tf.cast(sample[\\\"query_id\\\"], tf.int32)\\n\\t\\t\\t\\t\\t\\tlabel = tf.cast(0, tf.int32) #dummy\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": input_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": effective_input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": docid,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telif doc_type==1:\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\t\\t\\t\\t\\t\\tdoc_ids = sample[\\\"doc_ids\\\"][:max_seq_len[doc_type]]\\n\\n\\t\\t\\t\\t\\t\\tinput_ids = tf.cast(doc_ids, tf.int32)\\n\\t\\t\\t\\t\\t\\tsegment_ids = tf.zeros_like(input_ids)\\n\\t\\t\\t\\t\\t\\tinput_mask = tf.ones_like(input_ids)\\n\\t\\t\\t\\t\\t\\tdocid = tf.cast(sample[\\\"docid\\\"], tf.int32)\\n\\t\\t\\t\\t\\t\\tlabel = tf.cast(0, tf.int32) #dummy\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": input_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": docid,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\telif is_eval:\\n\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"doc_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"label\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\n\\t\\t\\t\\t\\tquery_ids = tf.cast(sample[\\\"query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\tquery_segment_ids = tf.cast(sample[\\\"query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\t# query_segment_ids = tf.zeros_like(query_ids)\\n\\t\\t\\t\\t\\tquery_mask = tf.ones_like(query_ids)\\n\\t\\t\\t\\t\\teffective_query_mask = tf.cast(sample[\\\"query_mask\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\t# effective_query_mask = tf.ones_like(query_ids)\\n\\n\\t\\t\\t\\t\\tdocx_ids = tf.cast(sample[\\\"doc_ids\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\t\\tdocx_segment_ids = tf.zeros_like(docx_ids)\\n\\t\\t\\t\\t\\tdocx_mask = tf.ones_like(docx_ids)\\n\\t\\t\\t\\t\\teffective_docx_mask = tf.ones_like(docx_ids)\\n\\n\\n\\t\\t\\t\\t\\tlabel = tf.cast(sample[\\\"label\\\"], tf.int32)\\n\\n\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": query_ids,\\n\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": query_segment_ids,\\n\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": query_mask,\\n\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": effective_query_mask,\\n\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": docx_ids,\\n\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": docx_segment_ids,\\n\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": docx_mask,\\n\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\": effective_docx_mask,\\n\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\treturn features\\n\\n\\t\\tdataset = tf.data.TFRecordDataset([dataset_path])\\n\\t\\tdataset = dataset.map(\\n\\t\\t\\textract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\\n\\n\\t\\tif is_training:\\n\\t\\t\\tdataset = dataset.repeat()\\n\\t\\t\\tdataset = dataset.shuffle(buffer_size=1000)\\n\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": []\\n\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0.0,\\n\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\t\\telse:\\n\\t\\t\\tif max_eval_examples:\\n\\t\\t\\t\\t# Use at most this number of examples (debugging only).\\n\\t\\t\\t\\tdataset = dataset.take(max_eval_examples)\\n\\t\\t\\tif is_output:\\n\\t\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": [],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": [],\\n\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\n\\t\\t\\telif is_eval:\\n\\t\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": []\\n\\t\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\t\\treturn dataset\",\n \"def _eval_input_fn():\\n features_placeholder = {\\n k: tf.compat.v1.placeholder(v.dtype, v.shape)\\n for k, v in six.iteritems(features)\\n }\\n if use_multi_head:\\n placeholder = tf.compat.v1.placeholder(labels.dtype, labels.shape)\\n labels_placeholder = {\\n _PRIMARY_HEAD: placeholder,\\n _SECONDARY_HEAD: placeholder,\\n }\\n else:\\n labels_placeholder = tf.compat.v1.placeholder(labels.dtype, labels.shape)\\n dataset = tf.data.Dataset.from_tensors(\\n (features_placeholder, labels_placeholder))\\n iterator = tf.compat.v1.data.make_initializable_iterator(dataset)\\n if use_multi_head:\\n feed_dict = {\\n labels_placeholder[head_name]: labels\\n for head_name in labels_placeholder\\n }\\n else:\\n feed_dict = {labels_placeholder: labels}\\n\\n feed_dict.update(\\n {features_placeholder[k]: features[k] for k in features_placeholder})\\n iterator_initializer_hook.iterator_initializer_fn = (\\n lambda sess: sess.run(iterator.initializer, feed_dict=feed_dict))\\n return iterator.get_next()\",\n \"def inference(self, inputs):\\n # NOTE: This makes the assumption that your model expects text to be tokenized\\n # with \\\"input_ids\\\" and \\\"token_type_ids\\\" - which is true for some popular transformer models, e.g. bert.\\n # If your transformer model expects different tokenization, adapt this code to suit\\n # its expected input format.\\n input_ids = inputs[\\\"input_ids\\\"]\\n input_ids = input_ids.to(self.device)\\n\\n coarse_result = self.model.generate(input_ids = input_ids, )\\n coarse_result = coarse_result.to(\\\"cpu\\\")\\n fined_result = self.tokenizer.decode(coarse_result[0].tolist()[inputs[\\\"original_length\\\"]+1:],\\n skip_special_tokens = True)\\n #logger.info(\\\"Model predicted: '%s'\\\", fined_result)\\n\\n return [fined_result]\",\n \"def getTrainingData(self):\\n raise NotImplementedError\",\n \"def run(self, **inputs):\\n if self.cached_model is None:\\n self.cache_model(**inputs)\\n for name, data in inputs.items():\\n self.shared_vars[name].set_value(data)\\n if self.mb and self.variational:\\n self.minibatches = zip(self._mb_generator(inputs['gwas_gen']),\\n self._mb_generator(inputs['gwas_phen']))\\n self.trace = self._inference()\\n return self.trace\",\n \"def get_data_itr(**kwargs):\\n batch_size = kwargs.pop('batch_size', 4)\\n num_threads = kwargs.pop('num_threads', 8)\\n fnames = kwargs.pop('fnames', [])\\n q_capacity = kwargs.pop('q_capacity', 256)\\n shuff = kwargs.pop('shuffle_input', True)\\n serialized_keys = kwargs.pop('serialized_keys', data_constants.READER_FEAT_KEY_TYPE_MAP)\\n out_type_keys = kwargs.pop('out_type_keys', data_constants.TF_FEAT_KEY_TYPE_MAP)\\n feature_shapes = kwargs.pop('feature_shapes', data_constants.DATA_SHAPES)\\n #This can still be invariant\\n quantity_keys = {key: quant_type for key, quant_type in serialized_keys.items() if key[:2] == 'n_'}\\n arr_key_type = {key: quant_type for key, quant_type in out_type_keys.items() if key[:2] != 'n_'}\\n\\n with tf.name_scope('input'):\\n with tf.device('/cpu:0'):\\n features_dict = {k: tf.FixedLenFeature((), t) for k, t in serialized_keys.items()}\\n\\n def _parser(serialized_example):\\n features = tf.parse_single_example(serialized_example,\\n features=features_dict)\\n quant_features = {}\\n for k, t in quantity_keys.items():\\n quant_features[k[2:]] = tf.to_int32(features[k])\\n\\n arr_features = {}\\n for k, t in arr_key_type.items():\\n arr_features[k] = features[k]\\n\\n exam = _parse_el_example(arr_features,\\n arr_key_type,\\n quant_features)\\n return exam\\n\\n dataset = tf.data.TFRecordDataset(fnames)\\n\\n if num_threads > 1:\\n dataset = dataset.map(_parser, num_threads=num_threads)\\n else:\\n dataset = dataset.map(_parser)\\n\\n if shuff:\\n dataset = dataset.shuffle(buffer_size=q_capacity)\\n\\n ordered_arr_key_type = sorted(arr_key_type.keys())\\n pad_shape = tuple([feature_shapes[arr_k] for arr_k in ordered_arr_key_type])\\n\\n dataset = dataset.padded_batch(batch_size=batch_size,\\n padded_shapes=pad_shape)\\n itr = dataset.make_initializable_iterator()\\n return itr, itr.get_next()\",\n \"def create_training_args(self, input_dict: Dict[Text, List[types.Artifact]],\\n output_dict: Dict[Text, List[types.Artifact]],\\n exec_properties: Dict[Text, Any],\\n executor_class_path: Text,\\n training_inputs: Dict[Text, Any],\\n job_id: Optional[Text]) -> Dict[Text, Any]:\\n training_inputs = training_inputs.copy()\\n\\n json_inputs = artifact_utils.jsonify_artifact_dict(input_dict)\\n logging.info('json_inputs=\\\\'%s\\\\'.', json_inputs)\\n json_outputs = artifact_utils.jsonify_artifact_dict(output_dict)\\n logging.info('json_outputs=\\\\'%s\\\\'.', json_outputs)\\n json_exec_properties = json.dumps(exec_properties, sort_keys=True)\\n logging.info('json_exec_properties=\\\\'%s\\\\'.', json_exec_properties)\\n\\n # We use custom containers to launch training on AI Platform (unified),\\n # which invokes the specified image using the container's entrypoint. The\\n # default entrypoint for TFX containers is to call scripts/run_executor.py.\\n # The arguments below are passed to this run_executor entry to run the\\n # executor specified in `executor_class_path`.\\n container_command = _CONTAINER_COMMAND + [\\n '--executor_class_path',\\n executor_class_path,\\n '--inputs',\\n json_inputs,\\n '--outputs',\\n json_outputs,\\n '--exec-properties',\\n json_exec_properties,\\n ]\\n\\n if not training_inputs.get('worker_pool_specs'):\\n training_inputs['worker_pool_specs'] = [{}]\\n\\n for worker_pool_spec in training_inputs['worker_pool_specs']:\\n if not worker_pool_spec.get('container_spec'):\\n worker_pool_spec['container_spec'] = {\\n 'image_uri': _TFX_IMAGE,\\n }\\n\\n # Always use our own entrypoint instead of relying on container default.\\n if 'command' in worker_pool_spec['container_spec']:\\n logging.warn('Overriding custom value of container_spec.command')\\n worker_pool_spec['container_spec']['command'] = container_command\\n\\n # Pop project_id so AIP doesn't complain about an unexpected parameter.\\n # It's been a stowaway in aip_args and has finally reached its destination.\\n project = training_inputs.pop('project')\\n with telemetry_utils.scoped_labels(\\n {telemetry_utils.LABEL_TFX_EXECUTOR: executor_class_path}):\\n job_labels = telemetry_utils.get_labels_dict()\\n\\n # 'tfx_YYYYmmddHHMMSS' is the default job display name if not explicitly\\n # specified.\\n job_id = job_id or 'tfx_{}'.format(\\n datetime.datetime.now().strftime('%Y%m%d%H%M%S'))\\n\\n training_args = {\\n 'job_id': job_id,\\n 'project': project,\\n 'training_input': training_inputs,\\n 'job_labels': job_labels\\n }\\n\\n return training_args\",\n \"def input_fn():\\n d = tf.data.TFRecordDataset(input_file)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=sample_length)\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record: tf.parse_single_example(record, name_to_features),\\n batch_size=batch_size,\\n drop_remainder=drop_remainder))\\n return d\",\n \"def input_fn(params):\\n batch_size = params[\\\"batch_size\\\"]\\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_file)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.apply(\\n tf.contrib.data.map_and_batch(\\n lambda record: _decode_record(record, name_to_features),\\n batch_size=batch_size,\\n drop_remainder=drop_remainder,\\n )\\n )\\n\\n return d\",\n \"def params_for_checkpoint(self):\\n # We need real int types, not numpy.int64, not recognized by json\\n # dumps.\\n params = {\\n 'nb_features_in': int(self.nb_features_in),\\n 'nb_features_out': int(self.nb_features_out),\\n 'key': self.key\\n }\\n return params\",\n \"def enter_values(valuedata_to_enter):\\n result={}\\n\\n for i in range(len(valuedata_to_enter)):\\n paramdata = valuedata_to_enter[i]\\n print(\\\"--[{}/{}]---{} ({})---\\\".format(i+1, len(valuedata_to_enter), paramdata[\\\"name\\\"], paramdata[\\\"vartype\\\"]))\\n if \\\"desc\\\" in paramdata:\\n print(\\\"Description: \\\" + paramdata[\\\"desc\\\"])\\n final_value = None\\n\\n variable_type=paramdata[\\\"vartype\\\"]\\n #simple variable types\\n if variable_type==\\\"string\\\" or variable_type==\\\"real\\\" or variable_type==\\\"int\\\":\\n inputted_value=input(\\\"\\\")\\n if variable_type==\\\"string\\\":\\n final_value = inputted_value\\n elif inputted_value != \\\"\\\":\\n if variable_type==\\\"real\\\":\\n final_value = float(inputted_value)\\n if variable_type==\\\"int\\\":\\n final_value = int(inputted_value)\\n #layer entry\\n elif variable_type==\\\"layers\\\":\\n stop_acquiring_layers=False\\n final_value=[]\\n print(\\\"Laissez vide pour arreter la saisie\\\")\\n while not stop_acquiring_layers:\\n inputted_value = input(\\\"Couche cachée #{}, nombre de neurones: \\\".format(len(final_value)+1))\\n if inputted_value != \\\"\\\":\\n final_value.append(int(inputted_value))\\n else:\\n stop_acquiring_layers = True\\n #select from array\\n elif variable_type==\\\"arrayelement\\\":\\n array = paramdata[\\\"array\\\"]\\n for i in range(len(array)):\\n print(\\\"{}){}\\\".format(i, array[i]))\\n\\n selected_element = -1\\n while not (selected_element >= 0 and selected_element < len(array)):\\n selected_element = int(input(\\\"\\\"))\\n final_value = array[selected_element]\\n\\n if final_value != None:\\n result[paramdata[\\\"name\\\"]] = final_value\\n return result\",\n \"def data(request, data_pandas, data_pandas_truth, data_binary, data_binary_truth, data_tracks,\\n data_tracks_no_detections, data_tracks_truth):\\n return {\\\"pandas\\\": data_pandas,\\n \\\"pandas_truth\\\": data_pandas_truth,\\n \\\"binary\\\": data_binary,\\n \\\"binary_truth\\\": data_binary_truth,\\n \\\"tracks\\\": data_tracks,\\n \\\"tracks_nd\\\": data_tracks_no_detections,\\n \\\"tracks_truth\\\": data_tracks_truth}[request.param]\",\n \"def generate_inputs_and_wrap_model(config_path, checkpoint_path, input_config):\\n\\n model = get_detector(cfg, checkpoint_path, device=\\\"cpu\\\")\\n one_img, one_meta = preprocess_example_input(input_config)\\n tensor_data = [one_img]\\n model.forward = partial(model.forward, img_metas=[[one_meta]], return_loss=False)\\n\\n return model, tensor_data\",\n \"def _train(self):\\n self.train_acc.reset_states()\\n self.val_acc.reset_states()\\n self.train_loss.reset_states()\\n self.val_loss.reset_states()\\n\\n self.train_ds.shuffle(buffer_size=1000)\\n for idx, (x,y) in enumerate(self.train_ds):\\n self.tf_train_step(x, y)\\n\\n for x,y in self.val_ds:\\n self.tf_val_step(x, y)\\n\\n # It is important to return tf.Tensors as numpy objects.\\n return {\\n \\\"epoch\\\": self.iteration,\\n \\\"loss_train\\\": self.train_loss.result().numpy(),\\n \\\"loss_val\\\": self.val_loss.result().numpy(),\\n \\\"acc_train\\\": self.train_acc.result().numpy(),\\n \\\"acc_val\\\": self.val_acc.result().numpy(),\\n }\",\n \"def _prepare_input_for_export(args, kwargs):\\n args, kwargs = _prepare_input_for_pytorch(args, kwargs)\\n if not kwargs and len(args) > 0 and isinstance(args[-1], dict):\\n onnx_inputs = args + ({},)\\n elif kwargs:\\n onnx_inputs = args + (kwargs,)\\n else:\\n onnx_inputs = args\\n return onnx_inputs\",\n \"def _process_task_inputs(self):\\n _input = self._task.input\\n log.debug('Input parsing for %s and node %s from container', self._task.project_id, self._task.internal_id)\\n log.debug(_input)\\n\\n input_ports = dict()\\n for port in _input:\\n log.debug(port)\\n self._process_task_input(port, input_ports)\\n\\n log.debug('DUMPING json')\\n #dump json file\\n if input_ports:\\n file_name = os.path.join(self._executor.in_dir, 'input.json')\\n with open(file_name, 'w') as f:\\n json.dump(input_ports, f)\\n\\n log.debug('DUMPING DONE')\",\n \"def test_export_dict_input_output(self):\\n\\n\\n class Net(torch.nn.Module):\\n \\\"\\\"\\\"\\n Model using multiply as functional and module at different depths\\n \\\"\\\"\\\"\\n def __init__(self):\\n super().__init__()\\n self.layer = InputOutputDictModel()\\n\\n def forward(self, x):\\n return self.layer(x)\\n\\n model = Net()\\n\\n # Add an empty dictionary as the last element to not treat as named arguments.\\n # see torch.onnx.export() API for more details.\\n dummy_input = (\\n {'a': torch.randn(1, 10, 10, 10),\\n 'b': torch.randn(1, 10, 10, 10),\\n 'c': torch.randn(1, 10, 10, 10)\\n }, {}\\n )\\n onnx_path = './data/MyModel.onnx'\\n\\n torch.onnx.export(model, dummy_input, onnx_path)\\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input)\\n\\n onnx_model = onnx.load(onnx_path)\\n onnx.checker.check_model(onnx_model)\\n self.check_onnx_node_name_uniqueness(onnx_model)\\n\\n for node in onnx_model.graph.node:\\n print(node.name)\\n assert node.name.startswith('layer')\",\n \"def build_input(self):\\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n return n_input, t_input, n_target, t_target, keep_prob\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6266671","0.6177044","0.61287516","0.60989565","0.60571","0.60435206","0.6002842","0.5988043","0.59797364","0.59707093","0.5946096","0.5901443","0.58849496","0.58652824","0.58643454","0.58619016","0.58595145","0.5857554","0.5846563","0.58404577","0.58380324","0.5836631","0.5836481","0.58313864","0.5823195","0.57981884","0.5781361","0.57812226","0.57616514","0.57541186","0.57480323","0.57478154","0.57477313","0.57391983","0.57277876","0.5720632","0.5710859","0.5705327","0.57051665","0.57047486","0.57018024","0.5698055","0.56969804","0.5678453","0.56733334","0.564092","0.56402874","0.5634084","0.5633625","0.5630709","0.5623231","0.5622381","0.56221265","0.56135255","0.5607902","0.56027794","0.5601882","0.5601834","0.5601831","0.55798155","0.55730754","0.55721974","0.5569949","0.55674946","0.5557063","0.5555709","0.55544573","0.5545004","0.55412805","0.5540753","0.5537699","0.55356646","0.5533364","0.55326027","0.5530804","0.5527986","0.5527482","0.5521549","0.5517861","0.5516426","0.551464","0.5509264","0.55049914","0.54961205","0.54916435","0.5490557","0.5490321","0.54897255","0.54891205","0.5488899","0.54842633","0.5481505","0.5479862","0.5477871","0.54710317","0.54698175","0.54629123","0.5461019","0.54597265","0.54566187","0.5453474"],"string":"[\n \"0.6266671\",\n \"0.6177044\",\n \"0.61287516\",\n \"0.60989565\",\n \"0.60571\",\n \"0.60435206\",\n \"0.6002842\",\n \"0.5988043\",\n \"0.59797364\",\n \"0.59707093\",\n \"0.5946096\",\n \"0.5901443\",\n \"0.58849496\",\n \"0.58652824\",\n \"0.58643454\",\n \"0.58619016\",\n \"0.58595145\",\n \"0.5857554\",\n \"0.5846563\",\n \"0.58404577\",\n \"0.58380324\",\n \"0.5836631\",\n \"0.5836481\",\n \"0.58313864\",\n \"0.5823195\",\n \"0.57981884\",\n \"0.5781361\",\n \"0.57812226\",\n \"0.57616514\",\n \"0.57541186\",\n \"0.57480323\",\n \"0.57478154\",\n \"0.57477313\",\n \"0.57391983\",\n \"0.57277876\",\n \"0.5720632\",\n \"0.5710859\",\n \"0.5705327\",\n \"0.57051665\",\n \"0.57047486\",\n \"0.57018024\",\n \"0.5698055\",\n \"0.56969804\",\n \"0.5678453\",\n \"0.56733334\",\n \"0.564092\",\n \"0.56402874\",\n \"0.5634084\",\n \"0.5633625\",\n \"0.5630709\",\n \"0.5623231\",\n \"0.5622381\",\n \"0.56221265\",\n \"0.56135255\",\n \"0.5607902\",\n \"0.56027794\",\n \"0.5601882\",\n \"0.5601834\",\n \"0.5601831\",\n \"0.55798155\",\n \"0.55730754\",\n \"0.55721974\",\n \"0.5569949\",\n \"0.55674946\",\n \"0.5557063\",\n \"0.5555709\",\n \"0.55544573\",\n \"0.5545004\",\n \"0.55412805\",\n \"0.5540753\",\n \"0.5537699\",\n \"0.55356646\",\n \"0.5533364\",\n \"0.55326027\",\n \"0.5530804\",\n \"0.5527986\",\n \"0.5527482\",\n \"0.5521549\",\n \"0.5517861\",\n \"0.5516426\",\n \"0.551464\",\n \"0.5509264\",\n \"0.55049914\",\n \"0.54961205\",\n \"0.54916435\",\n \"0.5490557\",\n \"0.5490321\",\n \"0.54897255\",\n \"0.54891205\",\n \"0.5488899\",\n \"0.54842633\",\n \"0.5481505\",\n \"0.5479862\",\n \"0.5477871\",\n \"0.54710317\",\n \"0.54698175\",\n \"0.54629123\",\n \"0.5461019\",\n \"0.54597265\",\n \"0.54566187\",\n \"0.5453474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83782,"cells":{"query":{"kind":"string","value":"reset the execution providers to execute the collect_data. It triggers to recreating inference session."},"document":{"kind":"string","value":"def set_execution_providers(self, execution_providers=[\"CPUExecutionProvider\"]): # noqa: B006\n self.execution_providers = execution_providers\n self.create_inference_session()"},"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 reset(self):\n for provider in self.providers.values():\n provider.reset()\n\n for observation in self.observations.values():\n observation.reset()","def on_reset_after_execution(self):\n pass","def interactive_reset(self):\n # Set the initial state\n\n self.dataset.reset()\n\n self.current_turn = 0\n self.current_function = None\n self.query = \"\"\n self.query_vector = np.ones(self.dataset.getVocabularySize())\n self.keywords={\"provided\":set(), \"rejected\":set()}\n self.functions_rejected=set()\n self.result_index = 0\n self.dont_know = False\n\n self.history={\n 'system_action': {\"action\": self.SYSTEM_OPENING_ACT},\n 'user_action': None\n }","def reset(self):\n # Attempt to reset data loader\n self.data_loader_iter = iter(self.data_loader)\n self.num_batches = 0\n\n # Make sure calibrator will check the cache again when reset.\n self.cache_contents = None","def reinit(self):\n self.logger.info(\"Reinit called. Clear the population.\")\n self.set_init_population([], perf_name=None)\n self._gt_rollouts = []\n self._gt_scores = []","def reset():\n\n global optimizer_data\n global optimizer_len\n\n optimizer_data = []\n optimizer_len = 0\n return","def _clear_and_run(self, run_time, sync_time=0.0):\n # pylint: disable=protected-access\n\n # extra post prerun algorithms\n for projection in self._data_writer.iterate_projections():\n projection._clear_cache()\n\n super(SpiNNaker, self).run(run_time, sync_time)\n # extra post run algorithms\n for projection in self._data_writer.iterate_projections():\n projection._clear_cache()","def _clear_results(self):\n self.sentence_data = []","def clean_up_executors(self):\n pass","def reset(self) -> None:\n self.statistics = defaultdict(self._mp_hack)\n self._ddp_backend = get_backend()","def reset(self) -> None:\n self.statistics = defaultdict(self._mp_hack)\n self._ddp_backend = get_backend()","def reset(self) -> None:\n self.statistics = defaultdict(self._mp_hack)\n self._ddp_backend = get_backend()","def reset(self):\n if not self._data_writer.is_ran_last():\n if not self._data_writer.is_ran_ever():\n logger.error(\"Ignoring the reset before the run\")\n else:\n logger.error(\"Ignoring the repeated reset call\")\n return\n for population in self._data_writer.iterate_populations():\n population._cache_data() # pylint: disable=protected-access\n\n # Call superclass implementation\n AbstractSpinnakerBase.reset(self)","def _reset(self):\n self._set(\"_n_init_features\", None)\n self._set(\"_n_output_features\", None)\n self._set(\"_n_intervals\", None)\n self._set(\"_mapper\", {})\n self._set(\"_cpp_preprocessor\", None)\n self._set(\"_fitted\", False)","def reset_results(self):\n self.stream.ResultClear()\n self.trigger.ResultClear()","def _reset(self):\n self._model._reset()\n super(RDPAnalyzer, self)._reset()","def reset_iterator(self):\n if self.data_loader:\n self.data_iterator = self.data_loader.__iter__()\n else:\n self.data_iterator = None","def reInitAndRun(self):\n self.playlists = self.readPlaylistData()\n self.audioDF = self.readAudioData(shouldProcess=True)\n self.clusterLabels = []\n self.models = Clusterers(k=len(self.playlists))\n self.processAndCluster()\n self.analyzeResults()","def clear_temporary_data(self):\n self.extract_list = []\n self.transform_result = {}","def reset(self):\n self.in_compact_method = False\n self.in_setup = False\n self.autoname_cursor = dict()","def shutdown_training(self):\n\n self._train_data_set = None\n self._test_data_set = None","def reset_execution_info(self):\n self._start = None\n self._end = None\n self.log_stdout = None\n self.log_stderr = None\n self._success = None","def finalize(self):\n super().finalize()\n self.save_run_data()","def _clean_up_experiment(self):\n if self.module_name == \"keras\":\n K.clear_session()","def _clear_results(self):\n # Schedule existing analysis results for deletion next save call\n for key in self._analysis_results.keys():\n self._deleted_analysis_results.append(key)\n self._analysis_results = ThreadSafeOrderedDict()\n # Schedule existing figures for deletion next save call\n for key in self._figures.keys():\n self._deleted_figures.append(key)\n self._figures = ThreadSafeOrderedDict()","def reset(self) -> None:\n self._successful = False\n self._measurement_covariance = None\n self._measurements = None\n self._base_frame_directions = None\n self._temperatures = None\n self._postfit_covariance = None\n self._postfit_residuals = None\n self._jacobian = None\n self._a_priori_state_covariance = None","def Reset(self):\n self._results = []","def _reset_seeds(self) -> None:\n self._seeds = [None for _ in range(self.num_envs)]","def reset_iter(self):\n def _clear_queue(queue):\n if queue is not None:\n while not queue.empty():\n queue.get(block=True)\n queue.task_done()\n\n def _stop_executor(executor):\n if executor is not None:\n executor.shutdown()\n\n self._stop_flag = True\n\n _clear_queue(self._prefetch_queue)\n _clear_queue(self._batch_queue)\n _clear_queue(self._prefetch_count)\n\n _stop_executor(self._executor)\n _stop_executor(self._service_executor)\n\n self._executor = None\n self._service_executor = None\n self._prefetch_count = None\n self._prefetch_queue = None\n self._batch_queue = None\n self._batch_generator = None\n self._rest_batch = None\n\n if self.dataset is not None:\n self.dataset.reset_iter()\n\n self._init_variables_before_run()","def clear_passes(self):\n # Note that we deliberately do not clear passes_by_name. This means\n # that we can still look up and explicitly run the standard passes,\n # they just won't be avaiable by default.\n\n self.passes = []\n self.passes_awaiting_requeue = []\n self.pass_queues = {c: [] for c in PassClassification}\n\n self.known_programs = set()","def reset_data(self):\n\n # Callback object to run, step and reset the model properly.\n self.residential = True\n self.callback_obj = None\n self.data = self.model.measurements.get_bokeh_vis_data()\n\n # Check if it's the initial reset (create new sources) or a reset button\n # click (update .data only)\n try:\n self.source.data = self.data\n self.line_source.data = self.data[self.data.agent_type == 'system']\n self.update_filters()\n self.update_data()\n\n # Reset is clicked --> update .data only\n except AttributeError:\n self.source = ColumnDataSource(self.data)\n self.line_source = ColumnDataSource(\n self.data[self.data.agent_type == 'system'])","def reset_training_data(self):\n logger.info(\"resetting training data\")\n if self.shuffle:\n random.shuffle(self.tweets)\n self.batch_generator = self.get_batch()","def _reset(self):\n self.use_gpu = torch.cuda.is_available()\n if self.use_gpu:\n self.model = self.model.cuda()\n self.hist_train_psnr = []\n self.hist_val_psnr = []\n self.hist_loss = []","def reset(self):\n self.epochs = 0\n self.num_classes = 2 # Minimum of 2 classes\n self._random_state = check_random_state(self.random_state)\n if self.base_estimators:\n self.experts = [\n self.WeightedExpert(\n cp.deepcopy(be), 1, self.labels)\n for be in self.base_estimators\n ]\n else:\n self.experts = [\n self._construct_new_expert()\n ]","def teardown_provider(self):\n pass","def reset(self):\n self._open_activity_count = 0\n self._decisions = []\n self._tasks = TaskRegistry()","def reset():\n _runtime.reset()","def reset_data():\n global detections_results, detector\n detections_results = []\n ricoh_data = []\n if detector:\n detector.reinit_tracker()\n return render_camera_view()","def re_init(self):\n self.latent.re_init()\n if 're_init' in dir(self.inference_model):\n self.inference_model.re_init()\n if 're_init' in dir(self.generative_model):\n self.generative_model.re_init()","def reset(self):\n self.performed_transformations = False","def reset(self):\n\t\tself.keywords = []\n\t\tself.locations = []\n\t\tself.usernames = []\n\n\t\tself._reset_buffer()","def _soft_reset(self):\n self._reset_specific_envs(self.episodes_done)\n self._update_other_info()","def reset(self, executor):\n if j.data.types.string.check(executor):\n key = executor\n elif executor.type == 'ssh':\n key = '%s:%s:%s' % (executor.addr, executor.port, executor.login)\n else:\n raise j.exceptions.Input(message='executor type not recognize.')\n if key in self._executors:\n exe = self._executors[key]\n j.tools.cuisine.reset(exe.cuisine)\n del self._executors[key]","def _evaluate(self) -> dict:\n self.load()\n self.evaluate_all()\n self.finalize_results()\n log.debug(\"Clearing global instrumentation variables\")\n del_globals()","def run(self, data={}, refresh=False):\n if refresh:\n print('Refreshing: %s' % self._name)\n\n local_data = deepcopy(data)\n\n self._func(local_data)\n self._save_fingerprint()\n self._save_data(local_data)\n else:\n if self._fingerprint() != self._load_fingerprint():\n print('Running: %s' % self._name)\n\n local_data = deepcopy(data)\n\n self._func(local_data)\n self._save_fingerprint()\n self._save_data(local_data)\n\n refresh = True\n else:\n print('Loaded from cache: %s' % self._name)\n\n local_data = self._load_data()\n\n for analysis in self._next_analyses:\n analysis.run(local_data, refresh)","def reset(self):\n\n self.type = None\n self.additional_context = \"\"\n super().reset()","def _hard_reset(self):\n self._reset_specific_envs(np.ones_like(self.episodes_done))\n self._update_other_info()","def run_pending_inits(self, session):\n while self._init_ops:\n session.run(self._init_ops.pop(0))","def reset(self):\n self.command_stack = []\n self.refresh_table_asap = False\n\n self.scripts = set()\n\n # TODO: Implement\n # make sure to reset the connection state in the event that we were\n # watching something\n # if self.watching and self.connection:\n # try:\n # # call this manually since our unwatch or\n # # immediate_execute_command methods can call reset()\n # self.connection.send_command('UNWATCH')\n # self.connection.read_response()\n # except ConnectionError:\n # # disconnect will also remove any previous WATCHes\n # self.connection.disconnect()\n\n # clean up the other instance attributes\n self.watching = False\n self.explicit_transaction = False\n\n # TODO: Implement\n # we can safely return the connection to the pool here since we're\n # sure we're no longer WATCHing anything\n # if self.connection:\n # self.connection_pool.release(self.connection)\n # self.connection = None","def reset(self):\n self.pred_classes.clear()\n self.gold_classes.clear()\n self.pred_probas.clear()\n self.gold_probas.clear()\n self.loss = 0\n self.nb_batches = 0\n self.prec_rec_f1 = None\n self.acc = None\n self.mcc = None","def reset(self):\n inv_perm = np.argsort(self._current_order)\n self._current_order = self._current_order[inv_perm]\n self.inputs = self.inputs[inv_perm]\n self.targets = self.targets[inv_perm]\n self.target_ids = self.target_ids[inv_perm]\n self.new_epoch()","def _reset(self) -> None:\n self.images = []\n self.activations = []\n self.labels = []\n self.preds = []\n self.n_found = 0","def reset(self):\n self.kw_func = {**self.default_func}\n self.kw_var = {}\n self.kw_lines = []\n self.status_listener = None\n self.line_count = 0\n self.case_id = 0\n if self.run_signal:\n self.run_signal.stop = False\n self._have_record_res = False","def _data_reset(self):\n conn = self.get_connection()\n\n elements = {\n **self.domain.registry.aggregates,\n **self.domain.registry.entities,\n **self.domain.registry.views,\n }\n for _, element_record in elements.items():\n provider = current_domain.providers[element_record.cls.meta_.provider]\n repo = self.domain.repository_for(element_record.cls)\n\n model_cls = repo._model\n if provider.conn_info[\n \"DATABASE\"\n ] == Database.ELASTICSEARCH.value and conn.indices.exists(\n model_cls._index._name\n ):\n conn.delete_by_query(\n refresh=True,\n index=model_cls._index._name,\n body={\"query\": {\"match_all\": {}}},\n )","def _reset():\n global g_list_of_classifier\n global g_state\n\n g_state = False\n g_list_of_classifier = disco_classifiers([])","def reset(self):\n # self.compile_time = 0.\n self.fct_call_time = 0.0\n self.fct_callcount = 0\n self.vm_call_time = 0.0\n self.apply_time = {}\n self.apply_callcount = {}\n # self.apply_cimpl = None\n # self.message = None","def reset(self):\n # FIXME: this state does not make sense\n self.reset_creation_info()\n self.reset_document()\n self.reset_package()\n self.reset_file_stat()\n self.reset_reviews()\n self.reset_annotations()\n self.reset_extr_lics()","def reset(self):\n logger.info(\"resetting worker #%i\", self.myid)\n self.model.projection = self.model.projection.empty_like()\n self.finished = False","def reset(self):\n # FIXME: this state does not make sense\n self.reset_creation_info()\n self.reset_document()\n self.reset_package()\n self.reset_file_stat()\n self.reset_reviews()\n self.reset_annotations()\n self.reset_extr_lics()\n self.reset_snippet()","def startEvaluationMode(self):\r\n self.storeDataRef = self.dataRef","def reset(self):\n self.mode = 0\n self.graphs = [[], [], []]\n self.coefficients = []\n self.sample = []","def reset_train_results(self):\n self.train_loss_results = {}\n self.train_accuracy_results = {}\n self.train_pred_results = {}","def reset(self):\n\n self.simple_cache = {}\n self.complex_cache = {}\n self.target_cache = {}","def reset(self):\n self.dynamic_predictions = {}\n self.position = 0\n self.references = []","def reset(self):\n self.loss = []\n self.funcargs = []\n self.nSteps = 0 \n self.converged = False","def _reset(self, env_id: np.ndarray) -> None:","def reset(self):\n\n self.results = []\n self._plot()","def context_reset(self):\n self._context_state = None\n logging.info('Resetting the context')","def init_stage(self):\n\n self.estimators_ = []","def reset(self):\n\n self.results = {}","def reset(self):\n\t\tself.graph = OrderedDict()\n\t\tself.bottoms = OrderedDict()\n\t\tself.output_shape = OrderedDict()\n\t\tself.cur_tensor = None\n\t\tself.cur_id = None\n\t\tself.tmp_list = []\n\t\tself.log_init()","def reset(self):\n self._data = []","def cleanup_and_reset(self):\n self.mem.set(self.mem.META_PLAN, None)\n self.mem.set(self.mem.META_GOALS, None)\n self.mem.set(self.mem.META_CURR_GOAL, None)","def reset(self): # we can have stateful kernels now\n raise NotImplementedError()","def reset_data(self):\n self.data = []","def reinitialize_all(cls):\n cls._inited.clear()","def reset(self):\n inv_perm = np.argsort(self._current_order)\n self._current_order = self._current_order[inv_perm]\n self.inputs = self.inputs[inv_perm]\n self.targets = self.targets[inv_perm]\n self.new_epoch()","def _reset(self):\r\n self._state = self.INITIALIZING\r\n self._option_values = options.Values()\r\n self._argv = []","def _reconfigure_outputs(self):\n self._new_variables = []\n self.used_variables = []\n if not self.reconfigured: # safety to call it once\n # Generate new vars\n for p in self.preprocess_x:\n for var in p.new_vars:\n self.variables.append(var)\n self._new_variables.append(var)\n self.used_variables = self.variables.copy()\n for p in self.preprocess_x:\n # Eliminate vars\n for var in p.eliminated_vars:\n id = self.used_variables.index(var)\n del(self.used_variables[id])\n self.reconfigured = True","def reset(self):\n self.observation = None\n self.episode_done = True","def stopEvaluationMode(self):\r\n self.dataRef = self.storeDataRef","def resetUsers():\n global pollResults\n pollResults = dict()\n emitResults()","def reset(self):\n # type: () -> None\n self._all_scalar_oids = []\n self._use_scalar_oids_cache = False","def reset_launcher(self):\n self.input_so_far = ''\n self.launcher_curr_pos = None\n self.find_new_matches = True\n self.matches = {}\n self.view_buffer = None\n self.curr_buf = None\n self.curr_buf_pos = None\n self.mapper = {}\n self.nohidden_set = False\n self.selection_pending = False\n self.mark_map = {}\n self.cache = []","def reset(self):\n self.cache = EvaluationCache(\n loop=self.loop,\n keycalc=self.compute_ref,\n keytransform=self.get_actual_ref\n )\n self.reference_map = {}\n self.constructors = {\n prim: cons()\n for prim, cons in self._constructors.items()\n }","def hard_reset() -> NoReturn:","def teardown(self):\n self.logger.debug('Teardown GRPCDataRuntime')\n\n self._data_request_handler.close()\n start = time.time()\n while self._pending_tasks and time.time() - start < 1.0:\n self._update_pending_tasks()\n time.sleep(0.1)\n self._loop.stop()\n self._loop.close()\n\n super().teardown()","def reset_iterators(self):\r\n\r\n self.default_dict['iterators'] = []\r\n self.default_dict['iterator_names'] = {}\r\n self.dd_changed = True","def _reset(self):\n pass","def _collect_data(self) -> None:\n self.set_websocket_data()\n self.set_stratum_data()\n self.set_cache_data()\n self.collect_peer_connection_metrics()\n self.set_tx_storage_data()","def reset(self):\n self.algo_state = {}\n self.actual_repetitions = 0\n self.next_session = -1\n self.last_session = -1\n self.past_quality = []","def _backend_run(self):\n results = None\n return results","def refresh(self):\n self.proxies = self._init_proxies(self.proxy_providers)","def clear(self):\n self._plot_data_cache = {}\n self._outstanding_requests = {}","def reset(self):\n self.source_data = self.get_dict_from_range(None, None)\n self.selection_bounds = None\n self.selection = []\n for c in self.callbacks[\"reset_data\"]:\n c()\n if self.context is not None:\n self.context.doc.add_next_tick_callback(self.update_source)","def reset(self, **kwargs):\n # '_reset' depends on the 'backend'\n self._reset(**kwargs)","def _reset(self) -> None:","def _reset(self) -> None:","def reset_results(self, action_instance_id, session):\n yield","def reset(self):\n # Set the initial state\n\n if self.training:\n self.previous_position = self.nb_items\n\n # Various conversation features to be reported\n self.first_appearance = -1\n self.sugg_penalty = 0\n self.info_penalty = 0\n self.eli_kw_observed = False\n self.eli_query_observed = False\n\n self.dataset.reset()\n self.user.reset()\n\n self.current_turn = 0\n self.current_function = None\n self.query = \"\"\n self.query_vector = np.ones(self.dataset.getVocabularySize())\n self.keywords={\"provided\":set(), \"rejected\":set()}\n self.functions_rejected=set()\n self.result_index = 0\n self.dont_know = False\n\n self.history={\n 'system_action': {\"action\": self.SYSTEM_OPENING_ACT},\n 'user_action': None\n }\n user_action = self.user.respond(self.history[\"system_action\"])\n self.first_response = self.processUserAction(user_action)\n observation = self.generateObservation()\n return observation"],"string":"[\n \"def reset(self):\\n for provider in self.providers.values():\\n provider.reset()\\n\\n for observation in self.observations.values():\\n observation.reset()\",\n \"def on_reset_after_execution(self):\\n pass\",\n \"def interactive_reset(self):\\n # Set the initial state\\n\\n self.dataset.reset()\\n\\n self.current_turn = 0\\n self.current_function = None\\n self.query = \\\"\\\"\\n self.query_vector = np.ones(self.dataset.getVocabularySize())\\n self.keywords={\\\"provided\\\":set(), \\\"rejected\\\":set()}\\n self.functions_rejected=set()\\n self.result_index = 0\\n self.dont_know = False\\n\\n self.history={\\n 'system_action': {\\\"action\\\": self.SYSTEM_OPENING_ACT},\\n 'user_action': None\\n }\",\n \"def reset(self):\\n # Attempt to reset data loader\\n self.data_loader_iter = iter(self.data_loader)\\n self.num_batches = 0\\n\\n # Make sure calibrator will check the cache again when reset.\\n self.cache_contents = None\",\n \"def reinit(self):\\n self.logger.info(\\\"Reinit called. Clear the population.\\\")\\n self.set_init_population([], perf_name=None)\\n self._gt_rollouts = []\\n self._gt_scores = []\",\n \"def reset():\\n\\n global optimizer_data\\n global optimizer_len\\n\\n optimizer_data = []\\n optimizer_len = 0\\n return\",\n \"def _clear_and_run(self, run_time, sync_time=0.0):\\n # pylint: disable=protected-access\\n\\n # extra post prerun algorithms\\n for projection in self._data_writer.iterate_projections():\\n projection._clear_cache()\\n\\n super(SpiNNaker, self).run(run_time, sync_time)\\n # extra post run algorithms\\n for projection in self._data_writer.iterate_projections():\\n projection._clear_cache()\",\n \"def _clear_results(self):\\n self.sentence_data = []\",\n \"def clean_up_executors(self):\\n pass\",\n \"def reset(self) -> None:\\n self.statistics = defaultdict(self._mp_hack)\\n self._ddp_backend = get_backend()\",\n \"def reset(self) -> None:\\n self.statistics = defaultdict(self._mp_hack)\\n self._ddp_backend = get_backend()\",\n \"def reset(self) -> None:\\n self.statistics = defaultdict(self._mp_hack)\\n self._ddp_backend = get_backend()\",\n \"def reset(self):\\n if not self._data_writer.is_ran_last():\\n if not self._data_writer.is_ran_ever():\\n logger.error(\\\"Ignoring the reset before the run\\\")\\n else:\\n logger.error(\\\"Ignoring the repeated reset call\\\")\\n return\\n for population in self._data_writer.iterate_populations():\\n population._cache_data() # pylint: disable=protected-access\\n\\n # Call superclass implementation\\n AbstractSpinnakerBase.reset(self)\",\n \"def _reset(self):\\n self._set(\\\"_n_init_features\\\", None)\\n self._set(\\\"_n_output_features\\\", None)\\n self._set(\\\"_n_intervals\\\", None)\\n self._set(\\\"_mapper\\\", {})\\n self._set(\\\"_cpp_preprocessor\\\", None)\\n self._set(\\\"_fitted\\\", False)\",\n \"def reset_results(self):\\n self.stream.ResultClear()\\n self.trigger.ResultClear()\",\n \"def _reset(self):\\n self._model._reset()\\n super(RDPAnalyzer, self)._reset()\",\n \"def reset_iterator(self):\\n if self.data_loader:\\n self.data_iterator = self.data_loader.__iter__()\\n else:\\n self.data_iterator = None\",\n \"def reInitAndRun(self):\\n self.playlists = self.readPlaylistData()\\n self.audioDF = self.readAudioData(shouldProcess=True)\\n self.clusterLabels = []\\n self.models = Clusterers(k=len(self.playlists))\\n self.processAndCluster()\\n self.analyzeResults()\",\n \"def clear_temporary_data(self):\\n self.extract_list = []\\n self.transform_result = {}\",\n \"def reset(self):\\n self.in_compact_method = False\\n self.in_setup = False\\n self.autoname_cursor = dict()\",\n \"def shutdown_training(self):\\n\\n self._train_data_set = None\\n self._test_data_set = None\",\n \"def reset_execution_info(self):\\n self._start = None\\n self._end = None\\n self.log_stdout = None\\n self.log_stderr = None\\n self._success = None\",\n \"def finalize(self):\\n super().finalize()\\n self.save_run_data()\",\n \"def _clean_up_experiment(self):\\n if self.module_name == \\\"keras\\\":\\n K.clear_session()\",\n \"def _clear_results(self):\\n # Schedule existing analysis results for deletion next save call\\n for key in self._analysis_results.keys():\\n self._deleted_analysis_results.append(key)\\n self._analysis_results = ThreadSafeOrderedDict()\\n # Schedule existing figures for deletion next save call\\n for key in self._figures.keys():\\n self._deleted_figures.append(key)\\n self._figures = ThreadSafeOrderedDict()\",\n \"def reset(self) -> None:\\n self._successful = False\\n self._measurement_covariance = None\\n self._measurements = None\\n self._base_frame_directions = None\\n self._temperatures = None\\n self._postfit_covariance = None\\n self._postfit_residuals = None\\n self._jacobian = None\\n self._a_priori_state_covariance = None\",\n \"def Reset(self):\\n self._results = []\",\n \"def _reset_seeds(self) -> None:\\n self._seeds = [None for _ in range(self.num_envs)]\",\n \"def reset_iter(self):\\n def _clear_queue(queue):\\n if queue is not None:\\n while not queue.empty():\\n queue.get(block=True)\\n queue.task_done()\\n\\n def _stop_executor(executor):\\n if executor is not None:\\n executor.shutdown()\\n\\n self._stop_flag = True\\n\\n _clear_queue(self._prefetch_queue)\\n _clear_queue(self._batch_queue)\\n _clear_queue(self._prefetch_count)\\n\\n _stop_executor(self._executor)\\n _stop_executor(self._service_executor)\\n\\n self._executor = None\\n self._service_executor = None\\n self._prefetch_count = None\\n self._prefetch_queue = None\\n self._batch_queue = None\\n self._batch_generator = None\\n self._rest_batch = None\\n\\n if self.dataset is not None:\\n self.dataset.reset_iter()\\n\\n self._init_variables_before_run()\",\n \"def clear_passes(self):\\n # Note that we deliberately do not clear passes_by_name. This means\\n # that we can still look up and explicitly run the standard passes,\\n # they just won't be avaiable by default.\\n\\n self.passes = []\\n self.passes_awaiting_requeue = []\\n self.pass_queues = {c: [] for c in PassClassification}\\n\\n self.known_programs = set()\",\n \"def reset_data(self):\\n\\n # Callback object to run, step and reset the model properly.\\n self.residential = True\\n self.callback_obj = None\\n self.data = self.model.measurements.get_bokeh_vis_data()\\n\\n # Check if it's the initial reset (create new sources) or a reset button\\n # click (update .data only)\\n try:\\n self.source.data = self.data\\n self.line_source.data = self.data[self.data.agent_type == 'system']\\n self.update_filters()\\n self.update_data()\\n\\n # Reset is clicked --> update .data only\\n except AttributeError:\\n self.source = ColumnDataSource(self.data)\\n self.line_source = ColumnDataSource(\\n self.data[self.data.agent_type == 'system'])\",\n \"def reset_training_data(self):\\n logger.info(\\\"resetting training data\\\")\\n if self.shuffle:\\n random.shuffle(self.tweets)\\n self.batch_generator = self.get_batch()\",\n \"def _reset(self):\\n self.use_gpu = torch.cuda.is_available()\\n if self.use_gpu:\\n self.model = self.model.cuda()\\n self.hist_train_psnr = []\\n self.hist_val_psnr = []\\n self.hist_loss = []\",\n \"def reset(self):\\n self.epochs = 0\\n self.num_classes = 2 # Minimum of 2 classes\\n self._random_state = check_random_state(self.random_state)\\n if self.base_estimators:\\n self.experts = [\\n self.WeightedExpert(\\n cp.deepcopy(be), 1, self.labels)\\n for be in self.base_estimators\\n ]\\n else:\\n self.experts = [\\n self._construct_new_expert()\\n ]\",\n \"def teardown_provider(self):\\n pass\",\n \"def reset(self):\\n self._open_activity_count = 0\\n self._decisions = []\\n self._tasks = TaskRegistry()\",\n \"def reset():\\n _runtime.reset()\",\n \"def reset_data():\\n global detections_results, detector\\n detections_results = []\\n ricoh_data = []\\n if detector:\\n detector.reinit_tracker()\\n return render_camera_view()\",\n \"def re_init(self):\\n self.latent.re_init()\\n if 're_init' in dir(self.inference_model):\\n self.inference_model.re_init()\\n if 're_init' in dir(self.generative_model):\\n self.generative_model.re_init()\",\n \"def reset(self):\\n self.performed_transformations = False\",\n \"def reset(self):\\n\\t\\tself.keywords = []\\n\\t\\tself.locations = []\\n\\t\\tself.usernames = []\\n\\n\\t\\tself._reset_buffer()\",\n \"def _soft_reset(self):\\n self._reset_specific_envs(self.episodes_done)\\n self._update_other_info()\",\n \"def reset(self, executor):\\n if j.data.types.string.check(executor):\\n key = executor\\n elif executor.type == 'ssh':\\n key = '%s:%s:%s' % (executor.addr, executor.port, executor.login)\\n else:\\n raise j.exceptions.Input(message='executor type not recognize.')\\n if key in self._executors:\\n exe = self._executors[key]\\n j.tools.cuisine.reset(exe.cuisine)\\n del self._executors[key]\",\n \"def _evaluate(self) -> dict:\\n self.load()\\n self.evaluate_all()\\n self.finalize_results()\\n log.debug(\\\"Clearing global instrumentation variables\\\")\\n del_globals()\",\n \"def run(self, data={}, refresh=False):\\n if refresh:\\n print('Refreshing: %s' % self._name)\\n\\n local_data = deepcopy(data)\\n\\n self._func(local_data)\\n self._save_fingerprint()\\n self._save_data(local_data)\\n else:\\n if self._fingerprint() != self._load_fingerprint():\\n print('Running: %s' % self._name)\\n\\n local_data = deepcopy(data)\\n\\n self._func(local_data)\\n self._save_fingerprint()\\n self._save_data(local_data)\\n\\n refresh = True\\n else:\\n print('Loaded from cache: %s' % self._name)\\n\\n local_data = self._load_data()\\n\\n for analysis in self._next_analyses:\\n analysis.run(local_data, refresh)\",\n \"def reset(self):\\n\\n self.type = None\\n self.additional_context = \\\"\\\"\\n super().reset()\",\n \"def _hard_reset(self):\\n self._reset_specific_envs(np.ones_like(self.episodes_done))\\n self._update_other_info()\",\n \"def run_pending_inits(self, session):\\n while self._init_ops:\\n session.run(self._init_ops.pop(0))\",\n \"def reset(self):\\n self.command_stack = []\\n self.refresh_table_asap = False\\n\\n self.scripts = set()\\n\\n # TODO: Implement\\n # make sure to reset the connection state in the event that we were\\n # watching something\\n # if self.watching and self.connection:\\n # try:\\n # # call this manually since our unwatch or\\n # # immediate_execute_command methods can call reset()\\n # self.connection.send_command('UNWATCH')\\n # self.connection.read_response()\\n # except ConnectionError:\\n # # disconnect will also remove any previous WATCHes\\n # self.connection.disconnect()\\n\\n # clean up the other instance attributes\\n self.watching = False\\n self.explicit_transaction = False\\n\\n # TODO: Implement\\n # we can safely return the connection to the pool here since we're\\n # sure we're no longer WATCHing anything\\n # if self.connection:\\n # self.connection_pool.release(self.connection)\\n # self.connection = None\",\n \"def reset(self):\\n self.pred_classes.clear()\\n self.gold_classes.clear()\\n self.pred_probas.clear()\\n self.gold_probas.clear()\\n self.loss = 0\\n self.nb_batches = 0\\n self.prec_rec_f1 = None\\n self.acc = None\\n self.mcc = None\",\n \"def reset(self):\\n inv_perm = np.argsort(self._current_order)\\n self._current_order = self._current_order[inv_perm]\\n self.inputs = self.inputs[inv_perm]\\n self.targets = self.targets[inv_perm]\\n self.target_ids = self.target_ids[inv_perm]\\n self.new_epoch()\",\n \"def _reset(self) -> None:\\n self.images = []\\n self.activations = []\\n self.labels = []\\n self.preds = []\\n self.n_found = 0\",\n \"def reset(self):\\n self.kw_func = {**self.default_func}\\n self.kw_var = {}\\n self.kw_lines = []\\n self.status_listener = None\\n self.line_count = 0\\n self.case_id = 0\\n if self.run_signal:\\n self.run_signal.stop = False\\n self._have_record_res = False\",\n \"def _data_reset(self):\\n conn = self.get_connection()\\n\\n elements = {\\n **self.domain.registry.aggregates,\\n **self.domain.registry.entities,\\n **self.domain.registry.views,\\n }\\n for _, element_record in elements.items():\\n provider = current_domain.providers[element_record.cls.meta_.provider]\\n repo = self.domain.repository_for(element_record.cls)\\n\\n model_cls = repo._model\\n if provider.conn_info[\\n \\\"DATABASE\\\"\\n ] == Database.ELASTICSEARCH.value and conn.indices.exists(\\n model_cls._index._name\\n ):\\n conn.delete_by_query(\\n refresh=True,\\n index=model_cls._index._name,\\n body={\\\"query\\\": {\\\"match_all\\\": {}}},\\n )\",\n \"def _reset():\\n global g_list_of_classifier\\n global g_state\\n\\n g_state = False\\n g_list_of_classifier = disco_classifiers([])\",\n \"def reset(self):\\n # self.compile_time = 0.\\n self.fct_call_time = 0.0\\n self.fct_callcount = 0\\n self.vm_call_time = 0.0\\n self.apply_time = {}\\n self.apply_callcount = {}\\n # self.apply_cimpl = None\\n # self.message = None\",\n \"def reset(self):\\n # FIXME: this state does not make sense\\n self.reset_creation_info()\\n self.reset_document()\\n self.reset_package()\\n self.reset_file_stat()\\n self.reset_reviews()\\n self.reset_annotations()\\n self.reset_extr_lics()\",\n \"def reset(self):\\n logger.info(\\\"resetting worker #%i\\\", self.myid)\\n self.model.projection = self.model.projection.empty_like()\\n self.finished = False\",\n \"def reset(self):\\n # FIXME: this state does not make sense\\n self.reset_creation_info()\\n self.reset_document()\\n self.reset_package()\\n self.reset_file_stat()\\n self.reset_reviews()\\n self.reset_annotations()\\n self.reset_extr_lics()\\n self.reset_snippet()\",\n \"def startEvaluationMode(self):\\r\\n self.storeDataRef = self.dataRef\",\n \"def reset(self):\\n self.mode = 0\\n self.graphs = [[], [], []]\\n self.coefficients = []\\n self.sample = []\",\n \"def reset_train_results(self):\\n self.train_loss_results = {}\\n self.train_accuracy_results = {}\\n self.train_pred_results = {}\",\n \"def reset(self):\\n\\n self.simple_cache = {}\\n self.complex_cache = {}\\n self.target_cache = {}\",\n \"def reset(self):\\n self.dynamic_predictions = {}\\n self.position = 0\\n self.references = []\",\n \"def reset(self):\\n self.loss = []\\n self.funcargs = []\\n self.nSteps = 0 \\n self.converged = False\",\n \"def _reset(self, env_id: np.ndarray) -> None:\",\n \"def reset(self):\\n\\n self.results = []\\n self._plot()\",\n \"def context_reset(self):\\n self._context_state = None\\n logging.info('Resetting the context')\",\n \"def init_stage(self):\\n\\n self.estimators_ = []\",\n \"def reset(self):\\n\\n self.results = {}\",\n \"def reset(self):\\n\\t\\tself.graph = OrderedDict()\\n\\t\\tself.bottoms = OrderedDict()\\n\\t\\tself.output_shape = OrderedDict()\\n\\t\\tself.cur_tensor = None\\n\\t\\tself.cur_id = None\\n\\t\\tself.tmp_list = []\\n\\t\\tself.log_init()\",\n \"def reset(self):\\n self._data = []\",\n \"def cleanup_and_reset(self):\\n self.mem.set(self.mem.META_PLAN, None)\\n self.mem.set(self.mem.META_GOALS, None)\\n self.mem.set(self.mem.META_CURR_GOAL, None)\",\n \"def reset(self): # we can have stateful kernels now\\n raise NotImplementedError()\",\n \"def reset_data(self):\\n self.data = []\",\n \"def reinitialize_all(cls):\\n cls._inited.clear()\",\n \"def reset(self):\\n inv_perm = np.argsort(self._current_order)\\n self._current_order = self._current_order[inv_perm]\\n self.inputs = self.inputs[inv_perm]\\n self.targets = self.targets[inv_perm]\\n self.new_epoch()\",\n \"def _reset(self):\\r\\n self._state = self.INITIALIZING\\r\\n self._option_values = options.Values()\\r\\n self._argv = []\",\n \"def _reconfigure_outputs(self):\\n self._new_variables = []\\n self.used_variables = []\\n if not self.reconfigured: # safety to call it once\\n # Generate new vars\\n for p in self.preprocess_x:\\n for var in p.new_vars:\\n self.variables.append(var)\\n self._new_variables.append(var)\\n self.used_variables = self.variables.copy()\\n for p in self.preprocess_x:\\n # Eliminate vars\\n for var in p.eliminated_vars:\\n id = self.used_variables.index(var)\\n del(self.used_variables[id])\\n self.reconfigured = True\",\n \"def reset(self):\\n self.observation = None\\n self.episode_done = True\",\n \"def stopEvaluationMode(self):\\r\\n self.dataRef = self.storeDataRef\",\n \"def resetUsers():\\n global pollResults\\n pollResults = dict()\\n emitResults()\",\n \"def reset(self):\\n # type: () -> None\\n self._all_scalar_oids = []\\n self._use_scalar_oids_cache = False\",\n \"def reset_launcher(self):\\n self.input_so_far = ''\\n self.launcher_curr_pos = None\\n self.find_new_matches = True\\n self.matches = {}\\n self.view_buffer = None\\n self.curr_buf = None\\n self.curr_buf_pos = None\\n self.mapper = {}\\n self.nohidden_set = False\\n self.selection_pending = False\\n self.mark_map = {}\\n self.cache = []\",\n \"def reset(self):\\n self.cache = EvaluationCache(\\n loop=self.loop,\\n keycalc=self.compute_ref,\\n keytransform=self.get_actual_ref\\n )\\n self.reference_map = {}\\n self.constructors = {\\n prim: cons()\\n for prim, cons in self._constructors.items()\\n }\",\n \"def hard_reset() -> NoReturn:\",\n \"def teardown(self):\\n self.logger.debug('Teardown GRPCDataRuntime')\\n\\n self._data_request_handler.close()\\n start = time.time()\\n while self._pending_tasks and time.time() - start < 1.0:\\n self._update_pending_tasks()\\n time.sleep(0.1)\\n self._loop.stop()\\n self._loop.close()\\n\\n super().teardown()\",\n \"def reset_iterators(self):\\r\\n\\r\\n self.default_dict['iterators'] = []\\r\\n self.default_dict['iterator_names'] = {}\\r\\n self.dd_changed = True\",\n \"def _reset(self):\\n pass\",\n \"def _collect_data(self) -> None:\\n self.set_websocket_data()\\n self.set_stratum_data()\\n self.set_cache_data()\\n self.collect_peer_connection_metrics()\\n self.set_tx_storage_data()\",\n \"def reset(self):\\n self.algo_state = {}\\n self.actual_repetitions = 0\\n self.next_session = -1\\n self.last_session = -1\\n self.past_quality = []\",\n \"def _backend_run(self):\\n results = None\\n return results\",\n \"def refresh(self):\\n self.proxies = self._init_proxies(self.proxy_providers)\",\n \"def clear(self):\\n self._plot_data_cache = {}\\n self._outstanding_requests = {}\",\n \"def reset(self):\\n self.source_data = self.get_dict_from_range(None, None)\\n self.selection_bounds = None\\n self.selection = []\\n for c in self.callbacks[\\\"reset_data\\\"]:\\n c()\\n if self.context is not None:\\n self.context.doc.add_next_tick_callback(self.update_source)\",\n \"def reset(self, **kwargs):\\n # '_reset' depends on the 'backend'\\n self._reset(**kwargs)\",\n \"def _reset(self) -> None:\",\n \"def _reset(self) -> None:\",\n \"def reset_results(self, action_instance_id, session):\\n yield\",\n \"def reset(self):\\n # Set the initial state\\n\\n if self.training:\\n self.previous_position = self.nb_items\\n\\n # Various conversation features to be reported\\n self.first_appearance = -1\\n self.sugg_penalty = 0\\n self.info_penalty = 0\\n self.eli_kw_observed = False\\n self.eli_query_observed = False\\n\\n self.dataset.reset()\\n self.user.reset()\\n\\n self.current_turn = 0\\n self.current_function = None\\n self.query = \\\"\\\"\\n self.query_vector = np.ones(self.dataset.getVocabularySize())\\n self.keywords={\\\"provided\\\":set(), \\\"rejected\\\":set()}\\n self.functions_rejected=set()\\n self.result_index = 0\\n self.dont_know = False\\n\\n self.history={\\n 'system_action': {\\\"action\\\": self.SYSTEM_OPENING_ACT},\\n 'user_action': None\\n }\\n user_action = self.user.respond(self.history[\\\"system_action\\\"])\\n self.first_response = self.processUserAction(user_action)\\n observation = self.generateObservation()\\n return observation\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6323081","0.58850425","0.58387077","0.5724095","0.57188416","0.56691223","0.5652778","0.5533942","0.5513653","0.55113894","0.55113894","0.55113894","0.5511064","0.55093247","0.54930425","0.54805976","0.54596144","0.5457072","0.54517335","0.5450865","0.5438392","0.5420219","0.53787446","0.53768665","0.53653216","0.5336131","0.53280646","0.53238714","0.5321112","0.5304395","0.5302872","0.52948976","0.5284326","0.5277189","0.5271823","0.52677447","0.5248068","0.5245038","0.5235916","0.52350634","0.5222336","0.52141124","0.52117926","0.52102166","0.52075917","0.5202459","0.5201378","0.51896924","0.5183545","0.5183326","0.5180271","0.51765615","0.5170392","0.5169727","0.5163604","0.5160847","0.51532","0.51481795","0.5141256","0.51412463","0.5136947","0.5131618","0.5131407","0.51313347","0.5130387","0.512981","0.5124366","0.51215345","0.5121467","0.51143044","0.511249","0.51118654","0.51084024","0.5095852","0.5094832","0.5092004","0.50904846","0.50901747","0.50881624","0.50782394","0.5076297","0.50703967","0.506477","0.5057895","0.50574106","0.5054405","0.5053569","0.50511295","0.50498265","0.5048525","0.50408244","0.5039091","0.5035259","0.5035207","0.503458","0.50339705","0.5023424","0.5023424","0.5022537","0.5018474"],"string":"[\n \"0.6323081\",\n \"0.58850425\",\n \"0.58387077\",\n \"0.5724095\",\n \"0.57188416\",\n \"0.56691223\",\n \"0.5652778\",\n \"0.5533942\",\n \"0.5513653\",\n \"0.55113894\",\n \"0.55113894\",\n \"0.55113894\",\n \"0.5511064\",\n \"0.55093247\",\n \"0.54930425\",\n \"0.54805976\",\n \"0.54596144\",\n \"0.5457072\",\n \"0.54517335\",\n \"0.5450865\",\n \"0.5438392\",\n \"0.5420219\",\n \"0.53787446\",\n \"0.53768665\",\n \"0.53653216\",\n \"0.5336131\",\n \"0.53280646\",\n \"0.53238714\",\n \"0.5321112\",\n \"0.5304395\",\n \"0.5302872\",\n \"0.52948976\",\n \"0.5284326\",\n \"0.5277189\",\n \"0.5271823\",\n \"0.52677447\",\n \"0.5248068\",\n \"0.5245038\",\n \"0.5235916\",\n \"0.52350634\",\n \"0.5222336\",\n \"0.52141124\",\n \"0.52117926\",\n \"0.52102166\",\n \"0.52075917\",\n \"0.5202459\",\n \"0.5201378\",\n \"0.51896924\",\n \"0.5183545\",\n \"0.5183326\",\n \"0.5180271\",\n \"0.51765615\",\n \"0.5170392\",\n \"0.5169727\",\n \"0.5163604\",\n \"0.5160847\",\n \"0.51532\",\n \"0.51481795\",\n \"0.5141256\",\n \"0.51412463\",\n \"0.5136947\",\n \"0.5131618\",\n \"0.5131407\",\n \"0.51313347\",\n \"0.5130387\",\n \"0.512981\",\n \"0.5124366\",\n \"0.51215345\",\n \"0.5121467\",\n \"0.51143044\",\n \"0.511249\",\n \"0.51118654\",\n \"0.51084024\",\n \"0.5095852\",\n \"0.5094832\",\n \"0.5092004\",\n \"0.50904846\",\n \"0.50901747\",\n \"0.50881624\",\n \"0.50782394\",\n \"0.5076297\",\n \"0.50703967\",\n \"0.506477\",\n \"0.5057895\",\n \"0.50574106\",\n \"0.5054405\",\n \"0.5053569\",\n \"0.50511295\",\n \"0.50498265\",\n \"0.5048525\",\n \"0.50408244\",\n \"0.5039091\",\n \"0.5035259\",\n \"0.5035207\",\n \"0.503458\",\n \"0.50339705\",\n \"0.5023424\",\n \"0.5023424\",\n \"0.5022537\",\n \"0.5018474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6150363"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83783,"cells":{"query":{"kind":"string","value":"create an OnnxRuntime InferenceSession."},"document":{"kind":"string","value":"def create_inference_session(self):\n sess_options = onnxruntime.SessionOptions()\n sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_DISABLE_ALL\n self.infer_session = onnxruntime.InferenceSession(\n self.augmented_model_path,\n sess_options=sess_options,\n providers=self.execution_providers,\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 init_ort_session(self, onnx_path):\n # Setup options for optimization\n sess_options = ort.SessionOptions()\n sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL\n sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL\n\n self.ort_session = ort.InferenceSession(onnx_path,\n sess_options=sess_options)","def create_session(checkpoint_path, target_device):\n if target_device == 'GPU':\n providers = ['CUDAExecutionProvider']\n elif target_device in ('CPU', 'Ascend'):\n providers = ['CPUExecutionProvider']\n else:\n raise ValueError(f\"Unsupported target device '{target_device}'. Expected one of: 'CPU', 'GPU', 'Ascend'\")\n session = ort.InferenceSession(checkpoint_path, providers=providers)\n input_names = [x.name for x in session.get_inputs()]\n return session, input_names","def inference_session(self, **kwargs) -> InferenceSession:\n\n with InferenceSession(self.sequence_manager, **kwargs) as session, self.use_session(session):\n yield session","def startSession():\n sess = tf.InteractiveSession()\n tf.global_variables_initializer().run()\n return sess","def _create_infer_session(self):\r\n model_session = mslite.Model()\r\n model_session.build_from_file(self.model_file,\r\n self.model_type,\r\n self.context)\r\n return model_session","def run_onnxruntime(self, model_path, inputs, output_names):\n import onnxruntime as rt\n m = rt.InferenceSession(model_path)\n results = m.run(output_names, inputs)\n return results","def get_engine(onnx_file_path, input_shape, max_batch_size=1, engine_file_path=\"\"):\n\n def build_engine():\n \"\"\"Takes an ONNX file and creates a TensorRT engine to run inference with\"\"\"\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, \\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\n\n builder.max_workspace_size = TRT_MAX_WORKSPACE_SIZE\n builder.max_batch_size = max_batch_size\n\n # Parse model file\n if not os.path.exists(onnx_file_path):\n print('ONNX file {} not found.'.format(onnx_file_path))\n exit(1)\n\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\n with open(onnx_file_path, 'rb') as model:\n print('Beginning ONNX file parsing')\n if not parser.parse(model.read()):\n print ('ERROR: Failed to parse the ONNX file.')\n for error in range(parser.num_errors):\n print (parser.get_error(error))\n return None\n\n network.get_input(0).shape = input_shape\n print('Completed parsing of ONNX file')\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\n engine = builder.build_cuda_engine(network)\n print('Completed creating Engine: num layers %d -> %d' %\n (network.num_layers, engine.num_layers),\n file=sys.stderr)\n return engine\n\n if os.path.exists(engine_file_path):\n # If a serialized engine exists, use it instead of building an engine.\n print(\"Reading engine from file {}\".format(engine_file_path))\n with open(engine_file_path, \"rb\") as f, trt.Runtime(TRT_LOGGER) as runtime:\n return runtime.deserialize_cuda_engine(f.read())\n else:\n return build_engine()","def initiate_session(self):\n config=tf.compat.v1.ConfigProto()\n config.gpu_options.allow_growth=True # dynamically grow the memory used on the GPU\n config.log_device_placement=True # to log device placement (on which device the operation ran)\n # (nothing gets printed in Jupyter, only if you run it standalone)\n sess=tf.compat.v1.Session(config=config)\n tf.compat.v1.keras.backend.set_session(sess)","def _new_session(self):\n # Create a new session for this model, initialize\n # variables, and save / restore from checkpoint.\n sess_cfg = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)\n sess_cfg.gpu_options.allow_growth = True\n self._session = tf.Session('', config=sess_cfg)\n self._session.run([self.meval.init])\n\n return self._session","def __init__(self, config):\n self.config = config\n etat.UsesTFSession.__init__(self)\n\n # Get path to model\n self.config.download_model_if_necessary()\n model_path = self.config.model_path\n\n # Load model\n self._prefix = \"main\"\n self._graph = etat.load_graph(model_path, prefix=self._prefix)\n self._sess = None\n\n # Load class labels\n labels_map = etal.load_labels_map(self.config.labels_path)\n self._class_labels = etal.get_class_labels(labels_map)\n self._num_classes = len(self._class_labels)\n\n # Get network\n network_name = self.config.network_name\n network_fn = nf.get_network_fn(\n network_name, num_classes=self._num_classes, is_training=False\n )\n self.img_size = network_fn.default_image_size\n\n # Get input operation\n self._input_op = self._graph.get_operation_by_name(\n self._prefix + \"/\" + self.config.input_name\n )\n\n # Get feature operation, if necessary\n features_name = None\n if self.config.generate_features:\n if self.config.features_name:\n features_name = self.config.features_name\n elif network_name in _DEFAULT_FEATURES_NAMES:\n features_name = _DEFAULT_FEATURES_NAMES[network_name]\n if features_name is not None:\n self._features_op = self._graph.get_operation_by_name(\n self._prefix + \"/\" + features_name\n )\n else:\n self._features_op = None\n\n # Get output operation\n if self.config.output_name:\n output_name = self.config.output_name\n else:\n output_name = _DEFAULT_OUTPUT_NAMES.get(network_name, None)\n if output_name is None:\n raise ValueError(\n \"`output_name` was not provided and network `%s` was not \"\n \"found in default outputs map\" % network_name\n )\n self._output_op = self._graph.get_operation_by_name(\n self._prefix + \"/\" + output_name\n )\n\n # Setup preprocessing\n self._transforms = self._make_preprocessing_fcn(\n network_name, self.config.preprocessing_fcn\n )\n self._preprocess = True\n\n self._last_features = None\n self._last_probs = None","def build_engine():\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, \\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\n\n builder.max_workspace_size = TRT_MAX_WORKSPACE_SIZE\n builder.max_batch_size = max_batch_size\n\n # Parse model file\n if not os.path.exists(onnx_file_path):\n print('ONNX file {} not found.'.format(onnx_file_path))\n exit(1)\n\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\n with open(onnx_file_path, 'rb') as model:\n print('Beginning ONNX file parsing')\n if not parser.parse(model.read()):\n print ('ERROR: Failed to parse the ONNX file.')\n for error in range(parser.num_errors):\n print (parser.get_error(error))\n return None\n\n network.get_input(0).shape = input_shape\n print('Completed parsing of ONNX file')\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\n engine = builder.build_cuda_engine(network)\n print('Completed creating Engine: num layers %d -> %d' %\n (network.num_layers, engine.num_layers),\n file=sys.stderr)\n return engine","def _init_session(self):\n self.sess = tf.Session(graph=self.g)\n self.sess.run(self.init)","def __init__(self, namespace):\n super(HaystackInferenceSession, self).__init__(\n approximate=True, load_brick=True\n )\n self._generated_triples = []\n self._BLDG = rdflib.Namespace(namespace)\n self._filters = [\n lambda x: not x.startswith(\"his\"),\n lambda x: not x.endswith(\"Ref\"),\n lambda x: not x.startswith(\"cur\"),\n lambda x: x != (\"disMacro\"),\n lambda x: x != \"navName\",\n lambda x: x != \"tz\",\n lambda x: x != \"mod\",\n lambda x: x != \"id\",\n ]\n self._point_tags = [\n \"point\",\n \"sensor\",\n \"command\",\n \"setpoint\",\n \"alarm\",\n \"status\",\n \"parameter\",\n \"limit\",\n ]","def _init_session(self):\n self.sess = tf.Session(config=self.config, graph=self.g)\n self.sess.run(self.init)","def make_session(num_cpu, graph=None):\n tf_config = tf.compat.v1.ConfigProto(\n allow_soft_placement=True,\n inter_op_parallelism_threads=num_cpu,\n intra_op_parallelism_threads=num_cpu)\n\n # Prevent tensorflow from taking all the gpu memory.\n tf_config.gpu_options.allow_growth = True\n\n return tf.compat.v1.Session(config=tf_config, graph=graph)","def get_engine(max_batch_size=1, onnx_file_path=\"\", engine_file_path=\"\", \\\r\n fp32_mode=False, fp16_mode=False, mix_mode=False, calibration_stream=None, calibration_table_path=\"\",\r\n save_engine=False, strategy=None,log=None):\r\n\r\n def build_engine(max_batch_size, save_engine):\r\n \"\"\"Takes an ONNX file and creates a TensorRT engine to run inference with\"\"\"\r\n # 1 << NetworkDefinitionCreationFlag.EXPLICIT_BATCH\r\n with trt.Builder(TRT_LOGGER) as builder, \\\r\n builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) as network, \\\r\n trt.OnnxParser(network, TRT_LOGGER) as parser:\r\n\r\n # parse onnx model file\r\n if not os.path.exists(onnx_file_path):\r\n quit('ONNX file {} not found'.format(onnx_file_path))\r\n log.logger.info('Loading ONNX file from path {}...'.format(onnx_file_path))\r\n with open(onnx_file_path, 'rb') as model:\r\n log.logger.info('Beginning ONNX file parsing')\r\n parser.parse(model.read())\r\n # modify the orignal onnx network\r\n count = 0;\r\n for i in range(network.num_layers):\r\n net = network.get_layer(i)\r\n if (net.type == trt.LayerType.CONVOLUTION and 'Conv' in net.name):\r\n count = count + 1;\r\n # network.mark_output(net.get_output(0))\r\n log2.logger.info('----1----network.num_layers:' + str(\r\n network.num_layers) + ' .the number of the conv is:' + str(count) + '\\n')\r\n log2.logger.info(net.name + '\\n')\r\n log2.logger.info(str(net.type) + '\\n')\r\n activate = network.add_activation(input=net.get_output(0),\r\n type=trt.ActivationType.CLIP) # return a layer\r\n if (strategy == None):\r\n log.logger.error('strategy error!')\r\n activate.beta = pow(2, strategy[count - 1] - 1) - 1\r\n activate.alpha = -pow(2, strategy[count - 1] - 1)\r\n activate.name = 'CLIP_%d' % i\r\n log2.logger.info(activate.name + ' beta is ' + str(activate.beta) + ' and alpha is ' + str(\r\n activate.alpha) + '\\n')\r\n # get the layer next to conv,and input the output of the activation layer.\r\n net_next = network.get_layer(i + 1)\r\n net_next.set_input(0, activate.get_output(0))\r\n log2.logger.info(net_next.name + '\\n')\r\n log2.logger.info(str(net_next.type) + '\\n')\r\n\r\n net_next2 = network.get_layer(i + 2)\r\n net_next2.set_input(0, net_next.get_output(0))\r\n net_next2.set_input(1, activate.get_output(0))\r\n log2.logger.info(net_next2.name + '\\n')\r\n log2.logger.info(str(net_next2.type) + '\\n')\r\n log2.logger.info('----2----network.num_layers:' + str(network.num_layers) + '\\n')\r\n assert network.num_layers > 0, 'Failed to parse ONNX model. \\\r\n Please check if the ONNX model is compatible '\r\n log.logger.info('Completed parsing of ONNX file')\r\n log.logger.info('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\r\n\r\n # build trt engine\r\n if mix_mode:\r\n builder.max_batch_size = max_batch_size\r\n builder.int8_mode = mix_mode\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'\r\n builder.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('Mix mode enabled')\r\n if fp16_mode:\r\n builder.strict_type_constraints = True\r\n builder.max_batch_size = max_batch_size\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n builder.fp16_mode = fp16_mode\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('fp16 modify mode enabled')\r\n if fp32_mode:\r\n builder.max_batch_size = max_batch_size\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('fp32 modify mode enabled')\r\n if engine is None:\r\n log.logger.error('Failed to create the engine')\r\n return None\r\n log.logger.info(\"Completed creating the engine\")\r\n if save_engine:\r\n with open(engine_file_path, \"wb\") as f:\r\n f.write(engine.serialize())\r\n return engine\r\n\r\n if os.path.exists(engine_file_path):\r\n # If a serialized engine exists, load it instead of building a new one.\r\n log.logger.info(\"Reading engine from file {}\".format(engine_file_path))\r\n with open(engine_file_path, \"rb\") as f, trt.Runtime(TRT_LOGGER) as runtime:\r\n return runtime.deserialize_cuda_engine(f.read())\r\n else:\r\n return build_engine(max_batch_size, save_engine)","def make_session(config=None, num_cpu=None, make_default=False, graph=None):\n if num_cpu is None:\n num_cpu = int(os.getenv('RCALL_NUM_CPU', multiprocessing.cpu_count()))\n if config is None:\n config = tf.ConfigProto(\n allow_soft_placement=True,\n inter_op_parallelism_threads=num_cpu,\n intra_op_parallelism_threads=num_cpu)\n config.gpu_options.allow_growth = True\n\n if make_default:\n return tf.InteractiveSession(config=config, graph=graph)\n else:\n return tf.Session(config=config, graph=graph)","def get_engine(onnx_file_path, engine_file_path=\"\"):\n def build_engine():\n \"\"\"Takes an ONNX file and creates a TensorRT engine to run inference with\"\"\"\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\n builder.max_workspace_size = 1 << 30 # 1GB\n builder.max_batch_size = 1\n builder.fp16_mode = mode_fp16\n # builder.int8_mode = mode_int8\n # Parse model file\n if not os.path.exists(onnx_file_path):\n print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))\n exit(0)\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\n with open(onnx_file_path, 'rb') as model:\n print('Beginning ONNX file parsing')\n parser.parse(model.read())\n print('Completed parsing of ONNX file')\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\n engine = builder.build_cuda_engine(network)\n print(\"Completed creating Engine\")\n with open(engine_file_path, \"wb\") as f:\n f.write(engine.serialize())\n return engine\n\n if os.path.exists(engine_file_path):\n # If a serialized engine exists, use it instead of building an engine.\n print(\"engine file already exits at {}\".format(engine_file_path))\n \n else:\n return build_engine()","def build_engine():\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\n builder.max_workspace_size = 1 << 30 # 1GB\n builder.max_batch_size = 1\n builder.fp16_mode = mode_fp16\n # builder.int8_mode = mode_int8\n # Parse model file\n if not os.path.exists(onnx_file_path):\n print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))\n exit(0)\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\n with open(onnx_file_path, 'rb') as model:\n print('Beginning ONNX file parsing')\n parser.parse(model.read())\n print('Completed parsing of ONNX file')\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\n engine = builder.build_cuda_engine(network)\n print(\"Completed creating Engine\")\n with open(engine_file_path, \"wb\") as f:\n f.write(engine.serialize())\n return engine","def _build_inference_graph(self):\n tf.contrib.framework.create_global_step()\n in0 = tf.Variable(1.0)\n in1 = tf.contrib.framework.local_variable(2.0)\n fake_table = tf.Variable(\n 3.0, trainable=False, collections=['fake_tables'],\n name='fake_table_var')\n in0.graph.add_to_collections(\n [tf.GraphKeys.TABLE_INITIALIZERS], fake_table.initializer)\n out = in0 + in1 + fake_table\n return in0, in1, out","def __init__(self, session, input_size, seq_size, output_size, learning_rate, model_name, net_name):\n self.session = session\n self.input_size = input_size\n self.seq_size = seq_size\n self.output_size = output_size\n\n self.learning_rate = learning_rate\n self.net_name = net_name\n self.x = None\n self.model_name = model_name\n\n self._build_network()","def create_new_session():\n database_engine = create_engine(SQLITE_FILE)\n DeclarativeBase.metadata.create_all(database_engine)\n DeclarativeBase.bind = database_engine\n\n session = sessionmaker()\n session.configure(bind=database_engine)\n\n return session()","def make_model(self):\n onnx_graph = onnx.helper.make_graph(\n self._nodes, self._name, self._inputs, self._outputs, self._initializers\n )\n kwargs = {}\n kwargs[\"opset_imports\"] = self._get_opsets()\n kwargs[\"producer_name\"] = \"TVM Relay\"\n kwargs[\"producer_version\"] = tvm.__version__\n\n return onnx.helper.make_model(onnx_graph, **kwargs)","def new_session(self):\n self._session = self.vspk.NUVSDSession(\n username=self.user,\n password=self.password,\n enterprise=self.enterprise,\n api_url=self.uri)\n\n self._session.start()\n if not self.default_enterprise:\n self.default_enterprise = self.get_enterprise_by_name(\n self.default_netpartition_name)\n\n self.assertIsNotNone(self.default_enterprise,\n \"Should have a default \"\n \"enterprise for Nuage plugin\")\n\n return self._session","def create_session(uri: str = os.environ.get(\"OBSERVATORY_DB_URI\"), connect_args=None, poolclass=None):\n\n if uri is None:\n raise ValueError(\n \"observatory.api.orm.create_session: please set the create_session `uri` parameter \"\n \"or the environment variable OBSERVATORY_DB_URI with a valid PostgreSQL workflow string\"\n )\n\n if connect_args is None:\n connect_args = dict()\n\n engine = create_engine(uri, convert_unicode=True, connect_args=connect_args, poolclass=poolclass)\n s = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))\n Base.query = s.query_property()\n Base.metadata.create_all(bind=engine) # create all tables.\n\n return s","def create_sparksession():\n return SparkSession.builder.\\\n appName(\"Transforming the historical parking occupancy and blockface datasets\").\\\n getOrCreate()","def create_inception_graph():\n with tf.Session() as sess:\n model_filename = os.path.join(\n FLAGS['model_dir'], 'classify_image_graph_def.pb')\n\n with gfile.FastGFile(model_filename, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = (\n tf.import_graph_def(graph_def, name='', return_elements=[\n BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME,\n RESIZED_INPUT_TENSOR_NAME]))\n\n return sess.graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor","def __init__(self, path):\n self.graph = tf.Graph()\n\n graph_def = None\n tf.reset_default_graph()\n with tf.gfile.GFile(path, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def get_session():\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n return tf.Session(config=config)","def create_session_factory(self, engine):\n\n raise CoreNotImplementedError()","def create_graph():\n with tf.gfile.FastGFile(os.path.join(\n config['inference']['model_dir'], 'output_graph.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def, name='')","def inference_mode_on():\n Layer.inference_mode = True\n with ng.metadata(mode=\"inference\"):\n yield\n Layer.inference_mode = False","def main():\n get_engine(onnx_file_path, engine_file_path)","def connect(cls):\n engine = create_engine(cls._build_uri(), echo=False)\n cls.Session = sessionmaker()\n cls.Session.configure(bind=engine)","def start(self):\n self.sess = tf.Session()\n tf.global_variables_initializer().run(session=self.sess)","def init_interactive(cls=None, runtime=None):\n \n # Determine default model class (which is a Widget if ui is imported)\n if cls is None and 'flexx.ui' in sys.modules:\n from .. import ui\n cls = ui.Widget\n \n # Create the default session\n session = manager.get_default_session()\n if session is None:\n session = manager.create_default_session(cls)\n else:\n return # default session already running\n\n # Launch web runtime, the server will wait for the connection\n server = current_server()\n host, port = server.serving\n url = '%s:%i/%s/?session_id=%s' % (host, port, session.app_name, session.id)\n session._runtime = launch('http://' + url, runtime=runtime)","def __create_execution_engine(self):\n target = self.binding.Target.from_default_triple()\n target_machine = target.create_target_machine()\n backing_mod = binding.parse_assembly(\"\")\n engine = binding.create_mcjit_compiler(backing_mod, target_machine)\n self.engine = engine","def make_session(num_cpu=None, make_default=False):\n if num_cpu is None:\n num_cpu = int(os.getenv('RCALL_NUM_CPU', multiprocessing.cpu_count()))\n tf_config = tf.ConfigProto(\n inter_op_parallelism_threads=num_cpu,\n intra_op_parallelism_threads=num_cpu)\n tf_config.gpu_options.allocator_type = 'BFC'\n if make_default:\n return tf.InteractiveSession(config=tf_config)\n else:\n return tf.Session(config=tf_config)","def test_run_inference(self, start_server_single_model_onnx):\n\n _, ports = start_server_single_model_onnx\n\n # Connect to grpc service\n stub = create_channel(port=ports[\"grpc_port\"])\n\n imgs_v1_224 = np.ones(ResnetONNX.input_shape, ResnetONNX.dtype)\n output = infer(imgs_v1_224, input_tensor=ResnetONNX.input_name, grpc_stub=stub,\n model_spec_name=ResnetONNX.name,\n model_spec_version=None,\n output_tensors=[ResnetONNX.output_name])\n logger.info(\"Output shape: {}\".format(output[ResnetONNX.output_name].shape))\n assert output[ResnetONNX.output_name].shape == ResnetONNX.output_shape, ERROR_SHAPE","def prepare_session(sess):\n init = tf.global_variables_initializer()\n sess.run(init)","def _new_session(self, m):\n # Create a new session for this model, initialize\n # variables, and save / restore from\n # checkpoint.\n self._session = tf.Session(\n '',\n config=tf.ConfigProto(\n allow_soft_placement=True, log_device_placement=False))\n self.session.run(m.init)\n\n # Load in a previous checkpoint, or save this one\n self.extract_model_spec()\n try:\n yield\n finally:\n tf.Session.reset('')\n self._session = None","def __init__(self, session, input_size, output_size, name):\n self.session = session\n self.input_size = input_size\n self.output_size = output_size\n self.net_name = name\n\n self._build_network()","def build_engine(max_batch_size, save_engine):\r\n # 1 << NetworkDefinitionCreationFlag.EXPLICIT_BATCH\r\n with trt.Builder(TRT_LOGGER) as builder, \\\r\n builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) as network, \\\r\n trt.OnnxParser(network, TRT_LOGGER) as parser:\r\n\r\n # parse onnx model file\r\n if not os.path.exists(onnx_file_path):\r\n quit('ONNX file {} not found'.format(onnx_file_path))\r\n log.logger.info('Loading ONNX file from path {}...'.format(onnx_file_path))\r\n with open(onnx_file_path, 'rb') as model:\r\n log.logger.info('Beginning ONNX file parsing')\r\n parser.parse(model.read())\r\n # modify the orignal onnx network\r\n count = 0;\r\n for i in range(network.num_layers):\r\n net = network.get_layer(i)\r\n if (net.type == trt.LayerType.CONVOLUTION and 'Conv' in net.name):\r\n count = count + 1;\r\n # network.mark_output(net.get_output(0))\r\n log2.logger.info('----1----network.num_layers:' + str(\r\n network.num_layers) + ' .the number of the conv is:' + str(count) + '\\n')\r\n log2.logger.info(net.name + '\\n')\r\n log2.logger.info(str(net.type) + '\\n')\r\n activate = network.add_activation(input=net.get_output(0),\r\n type=trt.ActivationType.CLIP) # return a layer\r\n if (strategy == None):\r\n log.logger.error('strategy error!')\r\n activate.beta = pow(2, strategy[count - 1] - 1) - 1\r\n activate.alpha = -pow(2, strategy[count - 1] - 1)\r\n activate.name = 'CLIP_%d' % i\r\n log2.logger.info(activate.name + ' beta is ' + str(activate.beta) + ' and alpha is ' + str(\r\n activate.alpha) + '\\n')\r\n # get the layer next to conv,and input the output of the activation layer.\r\n net_next = network.get_layer(i + 1)\r\n net_next.set_input(0, activate.get_output(0))\r\n log2.logger.info(net_next.name + '\\n')\r\n log2.logger.info(str(net_next.type) + '\\n')\r\n\r\n net_next2 = network.get_layer(i + 2)\r\n net_next2.set_input(0, net_next.get_output(0))\r\n net_next2.set_input(1, activate.get_output(0))\r\n log2.logger.info(net_next2.name + '\\n')\r\n log2.logger.info(str(net_next2.type) + '\\n')\r\n log2.logger.info('----2----network.num_layers:' + str(network.num_layers) + '\\n')\r\n assert network.num_layers > 0, 'Failed to parse ONNX model. \\\r\n Please check if the ONNX model is compatible '\r\n log.logger.info('Completed parsing of ONNX file')\r\n log.logger.info('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\r\n\r\n # build trt engine\r\n if mix_mode:\r\n builder.max_batch_size = max_batch_size\r\n builder.int8_mode = mix_mode\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'\r\n builder.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('Mix mode enabled')\r\n if fp16_mode:\r\n builder.strict_type_constraints = True\r\n builder.max_batch_size = max_batch_size\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n builder.fp16_mode = fp16_mode\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('fp16 modify mode enabled')\r\n if fp32_mode:\r\n builder.max_batch_size = max_batch_size\r\n builder.max_workspace_size = 1 << 30 # 1GB\r\n engine = builder.build_cuda_engine(network)\r\n log.logger.info('fp32 modify mode enabled')\r\n if engine is None:\r\n log.logger.error('Failed to create the engine')\r\n return None\r\n log.logger.info(\"Completed creating the engine\")\r\n if save_engine:\r\n with open(engine_file_path, \"wb\") as f:\r\n f.write(engine.serialize())\r\n return engine","def get_session(config=None):\n sess = tf.get_default_session()\n if sess is None:\n sess = make_session(config=config, make_default=True)\n return sess","def _initialize_session(self):\n config = tf.ConfigProto()\n # restrict model GPU memory utilization to min required\n config.gpu_options.allow_growth = True\n self.sess = tf.Session(config=config)\n tf_ver = int(tf.__version__.split('.')[1])\n if TF_VERSION <= 0.10:\n self.sess.run(tf.initialize_all_variables())\n logswriter = tf.train.SummaryWriter\n else:\n self.sess.run(tf.global_variables_initializer())\n logswriter = tf.summary.FileWriter\n self.saver = tf.train.Saver()\n self.summary_writer = logswriter(self.logs_path, graph=self.sess.graph) # change by ccx, add the graph_def","def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\n network = {}\n network['layers'] = []\n network['test_input'] = None\n network['test_output'] = None\n network['scale'] = 1.0\n\n model = onnx.load(model_name)\n nodes = model.graph.node\n inits = model.graph.initializer\n\n idx = get_node_index(nodes, first_node_name)\n if idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\n assert(idx != None)\n\n last_idx = get_node_index(nodes, last_node_name)\n if last_idx == None:\n if verbose:\n print('{} does not exist\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\n assert(last_idx != None)\n\n while True:\n node = nodes[idx]\n if verbose:\n print(node.name, node.op_type)\n src_node = get_node_source(nodes, node.input[0])\n if src_node == None:\n input_id = node.input[0]\n else:\n input_id = src_node.output[0]\n output_id = node.output[0]\n\n\n if len(network['layers']) == 0:\n previous = None\n else:\n previous = network['layers'][-1]\n for layer in network['layers']:\n if layer['output_id'] == input_id:\n previous = layer\n\n input_shapes, output_shapes = get_shapes(activations, stats, node)\n assert len(output_shapes) == 1, \"Multi-output nodes not supported\"\n output_shape = output_shapes[0]\n if node.op_type == \"Conv\":\n c, m, n = input_shapes[0]\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\n\n group = get_attr(node, 'group')\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\n if not group:\n group = 1\n if not strides:\n strides = [1, 1]\n if not dilations:\n dilations = [1, 1]\n\n use_strided = 0\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\n\n if DO_STRIDES and not ignore_strides:\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\n use_strided = 1\n previous['output_strides'] = strides\n if verbose:\n print('adding output strides to previous node')\n\n m = m + (m % strides[0])\n n = n + (n % strides[1])\n if int(np.prod(input_shapes[0])) != int(c*m*n):\n if verbose:\n print('adjusting size for strided maps')\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\n\n w = get_tensor(inits, node.input[1])\n kernels, channels, _, _ = w.shape\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n conv_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(c*m*n),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels * group,\n 'kernels': kernels,\n 'kernel_shape': kernel_shape,\n 'dilations': dilations,\n 'strides': strides,\n 'group': group,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'use_cvi': 0,\n 'use_depthwise': 0,\n 'use_strided': use_strided,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n conv_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(kernels)]\n conv_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n\n network['layers'].append(conv_layer)\n\n elif node.op_type == \"Gemm\":\n w = get_tensor(inits, node.input[1])\n output_size, input_size = w.shape\n\n if len(node.input) == 3:\n b = get_tensor(inits, node.input[2])\n\n gemm_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(np.prod(input_shapes[0])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'gemm_input_size': input_size,\n 'gemm_output_size': output_size,\n 'input_id': input_id,\n 'output_id': output_id,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"biases\": [],\n \"weights\": [],\n \"sublayers\": [],\n }\n\n w = w.flatten().tolist()\n gemm_layer['weights'] = base64.b64encode(struct.pack(\"f\"*len(w), *w)).decode()\n\n if len(node.input) == 3:\n b = b.flatten().tolist()\n else:\n b = [0 for _ in range(output_size)]\n gemm_layer['biases'] = base64.b64encode(struct.pack(\"f\"*len(b), *b)).decode()\n network['layers'].append(gemm_layer)\n\n elif node.op_type in multipath_nodes:\n node_inputs = get_previous_nodes(nodes, node)\n shapes = input_shapes\n\n if node.op_type == \"Sum\":\n assert(all([x == shapes[0] for x in shapes[1:]]))\n elif node.op_type == \"Concat\":\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\n\n buf = node_inputs[0].name\n if node.op_type == \"Concat\":\n buf = output_id\n\n buffer_offset = 0\n for n, node_input in enumerate(node_inputs):\n noutput = node_input.output[0]\n for l, layer in enumerate(network['layers']):\n if layer['output_id'] == noutput: # if layer pointing to this node\n network['layers'][l]['output_id'] = buf # rename layer's output\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\n if layer['input_id'] == noutput:\n network['layers'][l]['input_id'] = buf #TODO\n\n buffer_offset += int(np.prod(input_shapes[n]))\n\n if node.op_type == \"Sum\":\n channels, m, n = shape3d(output_shape)\n sum_layer = {\n 'op_type': \"Sum\",\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': node_inputs[0].name,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'num_inputs': len(node.input),\n \"sublayers\": [],\n }\n network['layers'].append(sum_layer)\n\n elif node.op_type == \"Identity\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n identity_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(identity_layer)\n\n elif node.op_type == \"LRN\":\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n lrn_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'alpha': get_attr(node, 'alpha'),\n 'beta': get_attr(node, 'beta'),\n 'bias': get_attr(node, 'bias'),\n 'size': get_attr(node, 'size'),\n 'scale': 1.0,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n }\n network['layers'].append(lrn_layer)\n\n elif node.op_type == \"Scale\":\n scale_sublayer = {\n 'op_type': 'Scale',\n 'name': node.name,\n \"use_replay\": 1,\n 'scale': get_attr(node, 'scale'),\n }\n previous['sublayers'].append(scale_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"GlobalAveragePool\", \"GlobalMaxPool\"]:\n assert(previous['n'] == previous['m'])\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type.replace('Global', ''),\n 'name': node.name,\n 'use_replay': 0,\n 'kernel_shape': [previous['m'], previous['n']],\n 'strides': [previous['m'], previous['n']],\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n\n elif node.op_type in [\"MaxPool\", \"AveragePool\"]:\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\n\n if node.op_type == \"AveragePool\": #TODO quick fix for tf average pool quirk\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\n kernel_shape = [previous['m'], previous['n']]\n strides = np.asarray(get_attr(node, 'strides')).tolist()\n if strides is None:\n strides = [ 1 for _ in kernel_shape]\n pads = pads6(node)\n pool_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'kernel_shape': kernel_shape,\n 'strides': strides,\n 'pads': pads,\n }\n previous['sublayers'].append(pool_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type == \"PRelu\":\n slope = get_tensor(inits, node.input[1])\n slope = slope.flatten().tolist()\n prelu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'slope': slope,\n }\n previous['sublayers'].append(prelu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"LeakyRelu\":\n alpha = get_attr(node, 'alpha')\n if alpha is None:\n alpha = .01\n leaky_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'alpha': alpha\n }\n previous['sublayers'].append(leaky_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Relu\":\n relu_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(relu_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Clip\":\n clip_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'min': float(get_tensor(inits,node.input[1])),\n 'max': float(get_tensor(inits,node.input[2])),\n }\n previous['sublayers'].append(clip_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type == \"Pad\":\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\n value = int(get_tensor(inits,node.input[2]))\n if value < -1:\n value = -1\n if value > 1:\n value = 1\n pad_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'value': value,\n 'pads': pads,\n }\n previous['sublayers'].append(pad_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n previous['output_shape'] = (output_shape)\n elif node.op_type in [\"Add\", \"Mul\", \"Sub\", \"Div\"]:\n\n skip = False\n if node.op_type == \"Mul\":\n next_nodes = get_node_inputs(nodes, node.output[0])\n if node.name == nodes[-1].name:\n if verbose:\n print('removing final scale node')\n skip = True\n\n elif previous['op_type'] in [\"LRN\"]:\n if verbose:\n print('skipping mul after lrn')\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n previous['scale'] = float(array[0])\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\n\n skip = True\n\n elif next_nodes[0].op_type in [\"Softmax\"]:\n if verbose:\n print('skipping mul before softmax')\n skip = True\n\n array = get_tensor(inits, node.input[1])\n if array is None:\n array = get_tensor(inits, node.input[0])\n c = activations[node.input[1]].shape[1]\n else:\n c = input_shapes[0][0]\n\n if node.op_type == \"Add\": # TODO for scalar Add\n dims = len(np.squeeze(array).shape)\n if dims == 0:\n array = np.ones((c, 1)) * array\n\n dims = len(np.squeeze(array).shape)\n if c == 1 and dims == 0:\n dims = 1\n\n array = array.flatten().tolist()\n # force_broadcast_2 = False\n # if force_broadcast_2:\n # # if c != 1 and dims == 0:\n # if c != 1 and dims == 0 and node.op_type != \"Mul\": # TODO forcing to broadcast 2 not broadcast 3\n # dims = 1\n # array = [array[0] for _ in range(c)]\n\n if not skip:\n arithmetic_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'dims': dims,\n 'array': array,\n }\n previous['sublayers'].append(arithmetic_sublayer)\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Abs\", \"Max\", \"Mean\", \"Min\", \"Neg\", \"Not\"]:\n unary_sublayer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n }\n previous['sublayers'].append(unary_sublayer)\n previous['output_id'] = output_id\n previous['output_size'] = int(np.prod(output_shape))\n\n elif node.op_type == \"Reshape\":\n dims = get_tensor(inits, node.input[1])\n\n if len(dims) == 4 and dims[-1] == 2:\n idx += 6\n node = nodes[idx]\n output_id = node.output[0]\n _, output_shapes = get_shapes(activations, stats, node)\n output_shape = output_shapes[0]\n channels, m, n = shape3d(output_shape)\n reorg_layer = {\n 'op_type': \"Reorg\",\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape': output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n \"stride\": int(dims[-1]),\n }\n network['layers'].append(reorg_layer)\n else:\n previous['output_id'] = output_id\n\n elif node.op_type in [\"Flatten\",'Cast']:\n previous['output_id'] = output_id\n elif node.op_type == \"Resize\":\n scales = get_tensor(inits, node.input[2])\n assert(scales[0] == 1 and scales[1] == 1)\n scale = float(scales[2])\n mode = get_attr(node, 'mode').decode()\n assert(mode == 'nearest' or mode == 'linear')\n shapes = input_shapes[:1]\n channels, m, n = shape3d(output_shape)\n in_size= [d for d in one_elem(input_shapes)[1:]]\n replay = 0 if in_size == [1,1] else 1\n resize_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': replay,\n 'input_size': int(np.prod(one_elem(input_shapes))),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'mode' :mode,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(resize_layer)\n elif node.op_type == \"ArgMax\":\n input_shape = one_elem(input_shapes)\n channels, m, n = shape3d(input_shape)\n argmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': [float(scales[2]),float(scales[3])],\n }\n network['layers'].append(argmax_layer)\n\n elif node.op_type == \"Softmax\":\n prev = get_previous_nodes(nodes, node)[0]\n if prev.op_type == \"Mul\":\n scale = get_tensor(inits, prev.input[1])\n scale = scale.flatten().tolist()\n else:\n scale = [1.0]\n if len(scale) > 1:\n raise NotImplementedError(\"Broadcast scale not implemented for softmax\")\n\n shapes = input_shapes\n channels, m, n = shape3d(output_shape)\n softmax_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 0,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n \"sublayers\": [],\n 'scale': scale,\n 'size': len(scale),\n }\n network['layers'].append(softmax_layer)\n\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\n # previous['sublayers'].append(softmax_sublayer)\n # previous['output_id'] = output_id\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\n\n elif node.op_type == \"Transpose\":\n shapes = input_shapes\n\n channels, m, n = shape3d(output_shape)\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\n transpose_layer = {\n 'op_type': node.op_type,\n 'name': node.name,\n 'use_replay': 1,\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\n 'output_size': int(np.prod(output_shape)),\n 'output_shape':output_shape,\n 'input_id': input_id,\n 'output_id': output_id,\n 'channels': channels,\n 'm': m,\n 'n': n,\n 'dma_offset': 0,\n 'buffer_offset': 0,\n 'permutation':permutation,\n \"sublayers\": [],\n }\n network['layers'].append(transpose_layer)\n else:\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\n\n idx += 1\n if idx > last_idx:\n break\n\n unsigned_network_inputs = input_type == np.uint8\n\n if CVI_1x1:\n network = mxp_gemm_to_conv(network)\n\n network = mxp_set_replay(network, io_info)\n network = mxp_set_cvi(network)\n network = mxp_set_unsigned(network, unsigned_network_inputs)\n\n if inline_depthwise:\n network = mxp_inline_depthwise(network)\n\n network = mxp_describe_layers(network)\n network = mxp_number_buffers(network)\n buffers = mxp_size_buffers(network)\n network = mxp_number_sublayers(network)\n\n network['num_layers'] = len(network['layers'])\n network['buffers'] = buffers\n\n return network","def get_obex_session(client, source_adr, target_adr):\n # session = client.CreateSession(\"58:C9:35:2F:A1:EF\", {\"Target\":\"opp\", \"Source\":\"9C:B6:D0:8C:5D:D6\"})\n session = client.CreateSession(target_adr, {\"Target\":\"opp\", \"Source\":source_adr})\n return session","def __init__(self, MY_GRAPH_PATH):\n self.graph = tf.Graph()\n\n graph_def = None\n with tf.gfile.FastGFile(MY_GRAPH_PATH, 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def _create_inference_model(pl_module):\n new_model = get_model(pl_module.hparams)\n new_model.normalization_metrics = AnomalyScoreDistribution().cpu()\n new_model.load_state_dict(pl_module.state_dict())\n return new_model","def create_execution_engine():\n # Create a target machine representing the host\n target = llvm.Target.from_default_triple()\n target_machine = target.create_target_machine()\n # And an execution engine with an empty backing module\n backing_mod = llvm.parse_assembly(\"\")\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\n return engine","def create_execution_engine():\n # Create a target machine representing the host\n target = llvm.Target.from_default_triple()\n target_machine = target.create_target_machine()\n # And an execution engine with an empty backing module\n backing_mod = llvm.parse_assembly(\"\")\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\n return engine","def create_execution_engine():\n # Create a target machine representing the host\n target = llvm.Target.from_default_triple()\n target_machine = target.create_target_machine()\n # And an execution engine with an empty backing module\n backing_mod = llvm.parse_assembly(\"\")\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\n return engine","def _initialize_session(par_interface, protocol_name, hints=()):\n test_id_path = os.path.join(\n os.path.dirname(__file__),\n \"data\",\n f\"{protocol_name}\",\n \"image_classification\",\n \"test_ids.csv\",\n )\n test_ids = list(map(str.strip, open(test_id_path, \"r\").readlines()))\n # Testing if session was sucessfully initalized\n session_id = par_interface.session_request(\n test_ids, f\"{protocol_name}\", \"image_classification\", \"0.1.1\", list(hints)\n )\n return session_id","def make_tflite_inference(ndvi_img_array, model_interpreter):\n # Get input and output tensors.\n input_details = model_interpreter.get_input_details()\n output_details = model_interpreter.get_output_details()\n\n # Get Input shape\n input_shape = input_details[0]['shape']\n input_data = ndvi_img_array.reshape(input_shape)\n\n model_interpreter.set_tensor(input_details[0]['index'], input_data)\n model_interpreter.invoke()\n\n outputs = []\n\n for tensor in output_details:\n output_data = model_interpreter.get_tensor(tensor['index'])\n outputs.append(output_data[0][0])\n\n prediction = outputs[0]\n\n return prediction","def inference_with_graph(graph_def, image):\n\n\twith tf.Graph().as_default() as graph:\n\n\t\twith tf.Session() as sess:\n\n\t\t\t# Import a graph_def into the current default Graph\n\t\t\tprint(\"import graph\")\t\n\t\t\tinput_, predictions = tf.import_graph_def(graph_def, name='', \n\t\t\t\treturn_elements=input_output_placeholders)\n\t\t\t\n\t\t\tcamera.start_preview()\n\t\t\tcamera.resolution = (640, 480)\n\t\t\tcamera.framerate = 32\n\n\t\t\ttimer.timer('predictions.eval')\t\n\n\t\t\ttime_res = []\n\t\t\tfor i in range(10):\n\n\t\t\t\tcamera.capture(stream, format='jpeg')\n\t\t\t\tstream.seek(0)\n\t\t\t\timage = Image.open(stream)\n\t\t\t\tshape = tuple(INPUT_SIZE[1:])\n\t\t\t\timage = image.resize(shape, Image.ANTIALIAS)\n\t\t\t\timage_arr = np.array(image, dtype=np.float32) / 255.0\t\t\t\t\n\n\t\t\t\tpred_val = predictions.eval(feed_dict={input_: [image_arr]})\n\t\t\t\tprint(pred_val)\n\t\t\t\ttimer.timer()\n\t\t\t\t#time_res.append(0)\n\t\t\t\t#print('index={0}, label={1}'.format(index, label))\n\n\t\t\tcamera.stop_preview()\t\n\t\t\tprint(camera.resolution)\n\n\t\t\t#print('mean time = {0}'.format(np.mean(time_res)))\n\n\t\t\t#return index","def start_inference_process(VD, CD):\n \n if VD['inference_process'] == None:\n VD['terminal_output'] += \"\\nCreating inference process...\\n\"\n VD['window']['terminal_text'].update(VD['terminal_output'])\n event, values = VD['window'].read(timeout=0)\n ap.create_process(VD, CD)\n \n VD['terminal_output'] += \"Created inference process.\\n\"\n else:\n VD['terminal_output'] += \"An inference process is already active.\"","def get_session():\n # See: https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n session = tf.Session(config=config)\n return session","def __init__(self,\n qnn,\n optimizer,\n session,\n state_shape,\n actions_count,\n reply_memory_size=100,\n minibatch_size=32,\n final_exploration_probability=0.05,\n exploration_period=1000,\n discount_factor=0.95,\n unrollings_num=16,\n target_freeze_period=1000,\n ):\n\n self.prediction_nn = qnn\n self.target_nn = qnn.clone()\n self.optimizer = optimizer\n\n self.state_shape = state_shape\n self.actions_count = actions_count\n\n self.experience = deque()\n self.reply_memory_size = reply_memory_size\n self.current_episode = []\n self.unrollings_num = unrollings_num\n self.minibatch_size = minibatch_size\n\n self.epsilon_initial = 1.0\n self.epsilon_final = final_exploration_probability\n self.exploration_period = exploration_period\n self.discount = discount_factor\n self.freeze_period = target_freeze_period\n\n self.action_requests = 0\n self.iteration = 0\n\n self.session = session\n\n self.build_graph()","def __init__(self, session):\n self.sess = session","def __init__(self):\r\n # create a session id\r\n self.session = ViSession()","def create_graph():\n\t# Creates graph from saved graph_def.pb.\n\twith tf.gfile.FastGFile('./models/inception_v4.pb', 'rb') as f:\n\t\tgraph_def = tf.GraphDef()\n\t\tgraph_def.ParseFromString(f.read())\n\t\t_ = tf.import_graph_def(graph_def, name='')","def test_init(self):\n\n # Default values are neo4j defaults, EXCEPT the password.\n address = os.environ.get('NEO4J_ADDRESS', 'bolt://localhost:7687')\n user = os.environ.get('NEO4J_USERNAME', 'neo4j')\n passw = os.environ.get('NEO4J_PASSWORD', 'neo42j')\n ontpath = \"scientio/examples/example_ontology.yaml\"\n\n o = Ontology(path_to_yaml=str(ontpath))\n s = Session(ontology=o, neo4j_address=address,\n neo4j_username=user, neo4j_password=passw)\n\n n = Node(metatype=o.get_type('Person'))\n n.set_name('Test')\n n_response = s.create(n)\n\n # TODO make smarter\n assert (n_response is not None)","def _build_graph(self):\n\n self.graph = tf.Graph()\n\n # set self.graph as default graph\n with self.graph.as_default():\n # # clear old variables\n # tf.reset_default_graph()\n\n # set random seed\n if self.random_seed is not None:\n tf.set_random_seed(self.random_seed)\n\n self._create_placeholders()\n self._create_variables()\n\n self._create_prediction()\n\n self._create_loss()\n self._create_optimizer()\n\n self._init = tf.global_variables_initializer()\n\n self.saver = tf.train.Saver()\n\n # create session\n self.sess = tf.Session(graph=self.graph)","def __init__(self, tarball_path):\n self.graph = tf.Graph()\n\n graph_def = None\n graph_def = tf.GraphDef.FromString(open(tarball_path + \"/frozen_inference_graph.pb\", \"rb\").read()) \n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def setup_session():\n print(\"Setting up session\")\n engine = setup_engine()\n Base.metadata.bin = engine\n\n DBSession = sessionmaker(bind=engine)\n session = DBSession()\n\n return session","def define_nmt(hidden_size, batch_size, en_timesteps, en_vsize, fr_timesteps, fr_vsize):\n\n # Define an input sequence and process it.\n if batch_size:\n encoder_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inputs')\n decoder_inputs = Input(batch_shape=(batch_size, fr_timesteps - 1, fr_vsize), name='decoder_inputs')\n else:\n encoder_inputs = Input(shape=(en_timesteps, en_vsize), name='encoder_inputs')\n if fr_timesteps:\n decoder_inputs = Input(shape=(fr_timesteps - 1, fr_vsize), name='decoder_inputs')\n else:\n decoder_inputs = Input(shape=(None, fr_vsize), name='decoder_inputs')\n\n # Encoder GRU\n encoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='encoder_gru')\n encoder_out, encoder_state = encoder_gru(encoder_inputs)\n\n # Set up the decoder GRU, using `encoder_states` as initial state.\n decoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='decoder_gru')\n decoder_out, decoder_state = decoder_gru(decoder_inputs, initial_state=encoder_state)\n\n # Attention layer\n attn_layer = AttentionLayer(name='attention_layer')\n attn_out, attn_states = attn_layer([encoder_out, decoder_out])\n\n # Concat attention input and decoder GRU output\n decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([decoder_out, attn_out])\n\n # Dense layer\n dense = Dense(fr_vsize, activation='softmax', name='softmax_layer')\n dense_time = TimeDistributed(dense, name='time_distributed_layer')\n decoder_pred = dense_time(decoder_concat_input)\n\n # Full model\n full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\n full_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics = ['accuracy'])\n\n full_model.summary()\n\n \"\"\" Inference model \"\"\"\n batch_size = 1\n\n \"\"\" Encoder (Inference) model \"\"\"\n encoder_inf_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inf_inputs')\n encoder_inf_out, encoder_inf_state = encoder_gru(encoder_inf_inputs)\n encoder_model = Model(inputs=encoder_inf_inputs, outputs=[encoder_inf_out, encoder_inf_state])\n\n \"\"\" Decoder (Inference) model \"\"\"\n decoder_inf_inputs = Input(batch_shape=(batch_size, 1, fr_vsize), name='decoder_word_inputs')\n encoder_inf_states = Input(batch_shape=(batch_size, en_timesteps, hidden_size), name='encoder_inf_states')\n decoder_init_state = Input(batch_shape=(batch_size, hidden_size), name='decoder_init')\n\n decoder_inf_out, decoder_inf_state = decoder_gru(decoder_inf_inputs, initial_state=decoder_init_state)\n attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\n decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_inf_out, attn_inf_out])\n decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\n decoder_model = Model(inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\n outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state])\n\n return full_model, encoder_model, decoder_model","def session(self):\n ssn = pn_session(self._impl)\n if ssn is None:\n raise (SessionException(\"Session allocation failed.\"))\n else:\n return Session(ssn)","def create_session(url):\n # type: (str) -> qi.Session\n application = qi.Application([NAOqiBackend.__name__, \"--qi-url={}\".format(url)])\n try: application.start()\n except RuntimeError as e:\n raise RuntimeError(\"Couldn't connect to robot @ {}\\n\\tOriginal Error: {}\".format(url, e))\n return application.session","def make_env():\n aigym_path = \"video/\"\n env = retro.make(game='MortalKombatII-Genesis',state='Level1.LiuKangVsJax')\n env = wrappers.Monitor(env, aigym_path,video_callable=False ,force=True) #, video_callable=False \n env = ObservationWraperMK(env)\n env = PlayerOneNetworkControllerWrapper(env)\n env._max_episode_steps = 350\n #env.render()\n\n return env","def init_target_net(self, sess):\n sess.run(self.init_target_net_op)","def __init__(self, config):\n\n engine = self.__my_create_engine(config)\n\n if not engine:\n raise Exception(\"No engine created\")\n\n engine.connect()\n #metadata = MetaData(bind=engine)\n Session = sessionmaker(bind=engine)\n\n # Set the objects to work with\n self.session = Session()","def Session(ioname, echo=True):\n from sqlalchemy import create_engine\n from sqlalchemy.orm import sessionmaker\n dbpath = userenv.joinpath('scanbox', ioname, 'db.sqlite3')\n engine = create_engine('sqlite:///{}'.format(dbpath),\n echo=echo, convert_unicode=True)\n return sessionmaker(engine, autocommit=False)","def inference(model, image, batch_size):\n image = Variable(image)\n image = image.cuda()\n return common.time_inference(inference_func=model, \n inference_func_args={'x': image}, \n batch_size=batch_size)","def build_inference_graph(self):\n self.build_train_graph()","def _create_model(self):\n if torch.cuda.is_available():\n model = torch.jit.load(self.torch_jit).cuda()\n else:\n model = torch.jit.load(self.torch_jit)\n model.eval()\n return model","def make_atari(env, num_frames, device, action_stack=False):\n try:\n noop_action = env.get_action_meanings().index(\"NOOP\")\n except ValueError:\n print(\"Cannot find NOOP in env, defaulting to 0\")\n noop_action = 0\n env = AtariPreprocess(env)\n env = MaxAndSkipEnv(env, 4)\n env = FrameStack(env, num_frames, device)\n # env = TorchTensorObservation(env, device)\n return env","def __init__(self, model_path, img_width, img_height, gpu_fraction=1.0):\n # Create session first with requested gpu_fraction parameter\n config = tf.compat.v1.ConfigProto()\n config.gpu_options.allow_growth = True\n config.gpu_options.per_process_gpu_memory_fraction = gpu_fraction\n self.tf_session = tf.compat.v1.Session(config=config)\n\n with tf.io.gfile.GFile(model_path, 'rb') as graph_file:\n # Load graph off of disk into a graph definition\n graph_def = tf.compat.v1.GraphDef()\n graph_def.ParseFromString(graph_file.read())\n self.input_tensor, self.output_tensor = tf.import_graph_def(\n graph_def,\n return_elements=['input_1:0', 'cumsum_values_1:0'])\n\n self.img_width = img_width\n self.img_height = img_height","def __init__(self, tf_session):\n self._sess = tf_session","def use_session(self, session: Optional[InferenceSession]) -> InferenceSession:\n\n token = self._active_session.set(session)\n try:\n yield session\n finally:\n self._active_session.reset(token)","def create_session(self, transport):\n session_id = self.session_id_allocator.allocate()\n session = self.SESSION_CLS(self, transport, session_id)\n self.sessions[session.id] = session\n return session","def initialize_session(self):\n self.logger.info(\"Initializing tf session\")\n self.sess = tf.compat.v1.Session()\n self.sess.run(tf.compat.v1.global_variables_initializer())\n self.saver = tf.compat.v1.train.Saver()","def __init__(self, tarball_path):\n self.graph = tf.Graph()\n\n graph_def = None\n graph_def = tf.GraphDef.FromString(open(tarball_path + \"/frozen_inference_graph.pb\", \"rb\").read()) \n\n if graph_def is None:\n raise RuntimeError('Cannot find inference graph in tar archive.')\n\n with self.graph.as_default():\n tf.import_graph_def(graph_def, name='')\n\n self.sess = tf.Session(graph=self.graph)","def create_network(self):\n\n print ('Creating network, changing data will have no effect beyond this point.')\n n = IMNN.IMNN(parameters=self.parameters)\n\n if self.load_network:\n n.restore_network()\n else:\n n.setup(network = self.network, load_data = self.data)\n\n return n","def inference():\n print(\"setting up vgg initialized conv layers ...\")\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\n\n mean = model_data['normalization'][0][0][0]\n mean_pixel = np.mean(mean, axis=(0, 1))\n\n weights = np.squeeze(model_data['layers'])\n\n\n with tf.variable_scope(\"inference\"):\n vgg_net(weights)","def _set_session(self):\n self.__session = sessionmaker(bind=self.__engine)()","def make_session():\n import aiohttp\n conn = aiohttp.TCPConnector(limit_per_host=int(\n os.getenv('AIO_CONN_LIMIT', 10)))\n timeout = aiohttp.ClientTimeout(\n total=int(os.getenv('AIO_TOTAL_TIMEOUT', 80)),\n connect=int(os.getenv('AIO_CONN_TIMEOUT', 15)),\n sock_read=int(os.getenv('AOI_READ_TIMEOUT', 30)),\n sock_connect=int(os.getenv('AIO_CONN_TIMEOUT', 15)),\n )\n s = aiohttp.ClientSession(connector=conn, timeout=timeout)\n return s","def construct_graph(network_class: Type[InferenceNetwork],\n config: Path, checkpoint_dir: str,\n batch_size: int,\n batches_per_step: int,\n image_filenames: Tuple[str],\n loop: bool,\n preprocess_fn: Callable,\n num_ipus: int,\n mode: str,\n save_graph_pb: bool) -> Tuple[tf.Operation, tf.Operation, tf.Operation]:\n # Model specific config\n with open(config.as_posix()) as file_stream:\n try:\n config_dict = yaml.safe_load(file_stream)\n except yaml.YAMLError as exc:\n tf.logging.error(exc)\n\n config_dict['network_name'] = config.stem\n if 'dtype' not in config_dict:\n config_dict[\"dtype\"] = 'float16'\n\n # Create inference optimized frozen graph definition\n network = network_class(input_shape=config_dict[\"input_shape\"],\n num_outputs=1000, batch_size=batch_size,\n data_type=config_dict['dtype'],\n config=config_dict,\n checkpoint_dir=checkpoint_dir)\n\n # Export frozen graph to event file to view in Tensorboard\"\n if save_graph_pb:\n log_dir = Path(f\"{config_dict['network_name']}_graph\")\n graph_filename = f\"{log_dir}/{config_dict['network_name']}_graph.pb\"\n if not log_dir.exists():\n log_dir.mkdir()\n with tf.io.gfile.GFile(graph_filename, \"wb\") as f:\n f.write(network.optimized_graph.SerializeToString())\n logging.info(\"%d ops in the final graph.\" % len(network.optimized_graph.node))\n import_to_tensorboard(graph_filename, log_dir=log_dir.as_posix())\n\n # Reset graph before creating one on the IPU\n tf.reset_default_graph()\n\n # Create dataset\n dataset = get_dataset(image_filenames, batch_size, loop=loop, preprocess_fn=preprocess_fn,\n img_width=config_dict[\"input_shape\"][1],\n img_height=config_dict[\"input_shape\"][0], dtype=config_dict['dtype'])\n\n # Set up graph on device, connect infeed and outfeed to the graph.\n num_replicas = num_ipus if mode == 'replicated' else 1\n infeed_queue = ipu_infeed_queue.IPUInfeedQueue(dataset, device_ordinal=0, feed_name=\"infeed\",\n replication_factor=num_replicas)\n outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(device_ordinal=0, feed_name=\"outfeed\",\n outfeed_mode=ipu_outfeed_queue.IPUOutfeedMode.ALL,\n replication_factor=num_replicas)\n\n def comp_fn():\n def body(img):\n with scopes.ipu_scope('/device:IPU:0'):\n probs = tf.import_graph_def(network.optimized_graph,\n input_map={network.graph_input: img},\n name=\"optimized\",\n return_elements=[network.graph_output])[0]\n outfeed_op = outfeed_queue.enqueue(probs)\n # Note that enqueue happens on the IPU.\n return outfeed_op\n\n return loops.repeat(batches_per_step,\n body,\n [],\n infeed_queue)\n\n loop_op = ipu_compiler.compile(comp_fn, [])\n\n # The dequeue of the outfeed needs to happen on the CPU.\n with tf.device('cpu'):\n outfeed_dequeue = outfeed_queue.dequeue()\n\n ipu_utils.move_variable_initialization_to_cpu()\n return loop_op, infeed_queue.initializer, outfeed_dequeue","def trainSession(self, session):\n pass","def create_session(\n self,\n environ: str,\n session_request_to_use: typing.Optional[SessionRequest] = None,\n ) -> Session:\n self.poll_sessions() # make sure there is an up to date picture of Sessions before proceeding\n self.check_session_can_start(session_request_to_use)\n return self.perform_session_create(\n environ, self.project.session_parameters.serialize()\n )","def create_graph():\n # Creates graph from saved graph_def.pb.\n with tf.gfile.FastGFile(os.path.join(FLAGS.model_dir, r'/home/lg/Desktop/finetune/frozen_inception_v3_299.pb'), 'rb') as f:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f.read())\n _ = tf.import_graph_def(graph_def,return_elements=['InceptionV3/Predictions/Reshape_1:0'], name='lg')","def createInfectApp(tx, query, id, ipid, date):\n tx.run(query, id=id, ipid=ipid, date=date)","def create_session(self, transport):\n session = self.SESSION_CLS(self, transport, 0)\n self.session = session\n return session","def initialize_session(self):\n self.logger.info(\"Initializing tf session\")\n session_conf = tf.ConfigProto(\n allow_soft_placement=self.FLAGS.allow_soft_placement,\n log_device_placement=self.FLAGS.log_device_placement)\n self.session = tf.Session(config=session_conf)\n self.session.run(tf.global_variables_initializer())\n try: \n self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=self.FLAGS.num_checkpoints)\n except:\n pass","def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.exec_network = infer_network.load_model\\\n (args.model, args.device, args.cpu_extension)\n # extract information about model input layer\n (b, c, input_height, input_width) = infer_network.get_input_shape()\n\n ### TODO: Handle the input stream ###\n # extenstion of input file\n input_extension = os.path.splitext(args.input)[1].lower()\n supported_vid_exts = ['.mp4', '.mpeg', '.avi', '.mkv']\n supported_img_exts = [\".bmp\",\".dib\", \".jpeg\", \".jp2\", \".jpg\", \".jpe\",\\\n \".png\", \".pbm\", \".pgm\", \".ppm\", \".sr\", \".ras\", \".tiff\", \".tif\"]\n single_image_mode = False\n # if input is camera\n if args.input.upper() == 'CAM':\n capture = cv2.VideoCapture(0)\n \n # if input is video\n elif input_extension in supported_vid_exts:\n capture = cv2.VideoCapture(args.input)\n \n # if input is image\n elif input_extension in supported_img_exts:\n single_image_mode = True\n capture = cv2.VideoCapture(args.input) \n capture.open(args.input)\n else:\n sys.exit(\"FATAL ERROR : The format of your input file is not supported\" \\\n \"\\nsupported extensions are : \" + \", \".join(supported_exts))\n prev_count = 0\n total_persons = 0\n ### TODO: Loop until stream is over ###\n while (capture.isOpened()):\n ### TODO: Read from the video capture ###\n ret, frame = capture.read()\n if not ret:\n break\n ### TODO: Pre-process the image as needed ###\n image = preprocessing(frame, input_width, input_height)\n ### TODO: Start asynchronous inference for specified request ###\n start_time = time.time()\n # run inference\n infer_network.exec_net(image)\n ### TODO: Wait for the result ###\n if infer_network.wait() == 0:\n infer_time = time.time() - start_time\n ### TODO: Get the results of the inference request ###\n outputs = infer_network.get_output()[0][0]\n ### Take model output and extract number of detections with confidence exceeding threshold\n ### and draw bounding boxes around detections\n out_image, current_count = apply_threshold(outputs, frame, prob_threshold)\n \n # show inference time on image\n cv2.putText(out_image, \"inference time: {:.5f} ms\".format(infer_time), (30, 30),\\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\n \n ### TODO: Extract any desired stats from the results ###\n # when any person exit\n if current_count < prev_count:\n ### Topic \"person/duration\": key of \"duration\" ###\n # send duration to mqtt server client\n client.publish(\"person/duration\", json.dumps({\"duration\": time.time() - p_start}))\n\n # when new person enters\n if current_count > prev_count:\n total_persons += current_count - prev_count\n p_start = time.time()\n \n prev_count = current_count\n \n ### TODO: Calculate and send relevant information on ###\n ### current_count, total_count and duration to the MQTT server ###\n ### Topic \"person\": keys of \"count\" and \"total\" ###\n client.publish(\"person\", json.dumps({\"count\": current_count,\"total\": total_persons}))\n ### TODO: Send the frame to the FFMPEG server ###\n sys.stdout.buffer.write(out_image)\n sys.stdout.buffer.flush()\n ### TODO: Write an output image if `single_image_mode` ###\n if single_image_mode:\n cv2.imwrite(\"output_frame.png\", out_image)\n # release resources\n capture.release()\n cv2.destroyAllWindows()\n client.disconnect()\n del infer_network","def __init__(self, agent, make_env=lambda:gym.make(\"SpaceInvaders-v0\"), n_games=1, max_size=None,\n preprocess_observation = lambda obs:obs,agent_step=None):\n if not isinstance(make_env, function):\n env_name = make_env\n make_env = lambda: gym.make(env_name)\n\n #create atari games\n self.make_env = make_env\n self.envs = [self.make_env() for _ in range(n_games)]\n self.preprocess_observation = preprocess_observation\n\n\n #initial observations\n self.prev_observations = [self.preprocess_observation(make_env.reset()) for make_env in self.envs]\n\n #agent memory variables (if you use recurrent networks\n self.prev_memory_states = [np.zeros((n_games,)+tuple(mem.output_shape[1:]),\n dtype=get_layer_dtype(mem))\n for mem in agent.agent_states]\n\n #save agent\n self.agent = agent\n self.agent_step = agent_step or agent.get_react_function()\n\n # Create experience replay environment\n self.experience_replay = SessionPoolEnvironment(observations=agent.observation_layers,\n actions=agent.action_layers,\n agent_memories=agent.agent_states)\n self.max_size = max_size\n\n #whether particular session has just been terminated and needs restarting\n self.just_ended = [False] * len(self.envs)","def _GetTrtGraph(self, gdef, precision_mode, is_dynamic_op):\n return trt.create_inference_graph(\n input_graph_def=gdef,\n outputs=[OUTPUT_NAME],\n max_batch_size=self._input.shape[0],\n max_workspace_size_bytes=1 << 25,\n precision_mode=precision_mode,\n minimum_segment_size=2,\n is_dynamic_op=is_dynamic_op)","def initialize_session(self):\r\n self.logger.info(\"Initializing tf session\")\r\n self.sess = tf.Session()\r\n self.sess.run(tf.global_variables_initializer())\r\n self.saver = tf.train.Saver()","def create_engine(self, input):\n return","def from_onnx(self, graph):\n # parse network inputs, aka parameters\n for init_tensor in graph.initializer:\n if not init_tensor.name.strip():\n raise ValueError(\"Tensor's name is required.\")\n self._params[init_tensor.name] = self._parse_array(init_tensor)\n\n # converting GraphProto message\n for i in graph.input:\n if i.name in self._params:\n # i is a param instead of input\n name_param = 'param_{}'.format(self._num_param)\n self._num_param += 1\n self._params[name_param] = self._params.pop(i.name)\n self._nodes[name_param] = mx.sym.Variable(name=name_param,\n shape=self._params[name_param].shape)\n self._renames[i.name] = name_param\n else:\n name_input = 'input_{}'.format(self._num_input)\n self._num_input += 1\n self._nodes[name_input] = mx.sym.Variable(name=name_input)\n self._renames[i.name] = name_input\n\n # constructing nodes, nodes are stored as directed acyclic graph\n # converting NodeProto message\n for node in graph.node:\n op_name = node.op_type\n node_name = node.name.strip()\n node_name = node_name if node_name else None\n onnx_attr = self._parse_attr(node.attribute)\n new_op, mx_attr = _convert_operator(op_name, onnx_attr)\n inputs = [self._nodes[self._renames.get(i, i)] for i in node.input]\n\n # some workarounds for onnx problem\n mx_attr = self._fix_bias(new_op, mx_attr, len(inputs))\n mx_attr = self._fix_channels(new_op, mx_attr, list(node.input))\n self._fix_bias_shape(node.op_type, node.input, onnx_attr)\n\n # calling again to get new symbols after some workarounds\n inputs = [self._nodes[self._renames.get(i, i)] for i in node.input]\n\n # onnx's Gemm operator also supports broadcasting C input which\n # mxnet's equivalent linalg_gemm doesn't. So using combination of\n # transpose and FullyConnected operators.\n if op_name == 'Gemm':\n new_op, inputs, mx_attr = self._fix_gemm('FullyConnected', inputs, onnx_attr)\n\n # onnx slice works on multiple axes whereas mxnet's slice_axis is for single axis\n if op_name == 'Slice':\n op = self._fix_slice(inputs, mx_attr)\n elif op_name == 'AveragePool' and onnx_attr.get('pads') is not None or \\\n op_name == 'MaxPool' and onnx_attr.get('pads') is not None:\n op = self._fix_pooling(op_name, inputs, onnx_attr)\n elif op_name == 'Squeeze':\n op = self._fix_squeeze(inputs, mx_attr)\n else:\n op = new_op(name=node_name, *inputs, **mx_attr)\n\n node_output = self._fix_outputs(op_name, node.output)\n\n assert len(node_output) == len(op.list_outputs()), (\n \"Number of output mismatch {} vs {} in {}.\".format(\n len(node_output), len(op.list_outputs()), op_name))\n for k, i in zip(list(node_output), range(len(node_output))):\n self._nodes[k] = op[i]\n # now return the outputs\n out = [self._nodes[i.name] for i in graph.output]\n if len(out) > 1:\n out = mx.sym.Group(out)\n else:\n out = out[0]\n return out, self._params","def __init__(self, sess, network, learning_rate=0.1, discount_factor=0.99):\n self.sess = sess\n self.learning_rate = learning_rate\n self.discount_factor = discount_factor\n self.network = network\n self.defineUpdateOperations()\n self.init = tf.global_variables_initializer()\n self.initialize_variables()"],"string":"[\n \"def init_ort_session(self, onnx_path):\\n # Setup options for optimization\\n sess_options = ort.SessionOptions()\\n sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL\\n sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL\\n\\n self.ort_session = ort.InferenceSession(onnx_path,\\n sess_options=sess_options)\",\n \"def create_session(checkpoint_path, target_device):\\n if target_device == 'GPU':\\n providers = ['CUDAExecutionProvider']\\n elif target_device in ('CPU', 'Ascend'):\\n providers = ['CPUExecutionProvider']\\n else:\\n raise ValueError(f\\\"Unsupported target device '{target_device}'. Expected one of: 'CPU', 'GPU', 'Ascend'\\\")\\n session = ort.InferenceSession(checkpoint_path, providers=providers)\\n input_names = [x.name for x in session.get_inputs()]\\n return session, input_names\",\n \"def inference_session(self, **kwargs) -> InferenceSession:\\n\\n with InferenceSession(self.sequence_manager, **kwargs) as session, self.use_session(session):\\n yield session\",\n \"def startSession():\\n sess = tf.InteractiveSession()\\n tf.global_variables_initializer().run()\\n return sess\",\n \"def _create_infer_session(self):\\r\\n model_session = mslite.Model()\\r\\n model_session.build_from_file(self.model_file,\\r\\n self.model_type,\\r\\n self.context)\\r\\n return model_session\",\n \"def run_onnxruntime(self, model_path, inputs, output_names):\\n import onnxruntime as rt\\n m = rt.InferenceSession(model_path)\\n results = m.run(output_names, inputs)\\n return results\",\n \"def get_engine(onnx_file_path, input_shape, max_batch_size=1, engine_file_path=\\\"\\\"):\\n\\n def build_engine():\\n \\\"\\\"\\\"Takes an ONNX file and creates a TensorRT engine to run inference with\\\"\\\"\\\"\\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, \\\\\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\\n\\n builder.max_workspace_size = TRT_MAX_WORKSPACE_SIZE\\n builder.max_batch_size = max_batch_size\\n\\n # Parse model file\\n if not os.path.exists(onnx_file_path):\\n print('ONNX file {} not found.'.format(onnx_file_path))\\n exit(1)\\n\\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\\n with open(onnx_file_path, 'rb') as model:\\n print('Beginning ONNX file parsing')\\n if not parser.parse(model.read()):\\n print ('ERROR: Failed to parse the ONNX file.')\\n for error in range(parser.num_errors):\\n print (parser.get_error(error))\\n return None\\n\\n network.get_input(0).shape = input_shape\\n print('Completed parsing of ONNX file')\\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\n engine = builder.build_cuda_engine(network)\\n print('Completed creating Engine: num layers %d -> %d' %\\n (network.num_layers, engine.num_layers),\\n file=sys.stderr)\\n return engine\\n\\n if os.path.exists(engine_file_path):\\n # If a serialized engine exists, use it instead of building an engine.\\n print(\\\"Reading engine from file {}\\\".format(engine_file_path))\\n with open(engine_file_path, \\\"rb\\\") as f, trt.Runtime(TRT_LOGGER) as runtime:\\n return runtime.deserialize_cuda_engine(f.read())\\n else:\\n return build_engine()\",\n \"def initiate_session(self):\\n config=tf.compat.v1.ConfigProto()\\n config.gpu_options.allow_growth=True # dynamically grow the memory used on the GPU\\n config.log_device_placement=True # to log device placement (on which device the operation ran)\\n # (nothing gets printed in Jupyter, only if you run it standalone)\\n sess=tf.compat.v1.Session(config=config)\\n tf.compat.v1.keras.backend.set_session(sess)\",\n \"def _new_session(self):\\n # Create a new session for this model, initialize\\n # variables, and save / restore from checkpoint.\\n sess_cfg = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)\\n sess_cfg.gpu_options.allow_growth = True\\n self._session = tf.Session('', config=sess_cfg)\\n self._session.run([self.meval.init])\\n\\n return self._session\",\n \"def __init__(self, config):\\n self.config = config\\n etat.UsesTFSession.__init__(self)\\n\\n # Get path to model\\n self.config.download_model_if_necessary()\\n model_path = self.config.model_path\\n\\n # Load model\\n self._prefix = \\\"main\\\"\\n self._graph = etat.load_graph(model_path, prefix=self._prefix)\\n self._sess = None\\n\\n # Load class labels\\n labels_map = etal.load_labels_map(self.config.labels_path)\\n self._class_labels = etal.get_class_labels(labels_map)\\n self._num_classes = len(self._class_labels)\\n\\n # Get network\\n network_name = self.config.network_name\\n network_fn = nf.get_network_fn(\\n network_name, num_classes=self._num_classes, is_training=False\\n )\\n self.img_size = network_fn.default_image_size\\n\\n # Get input operation\\n self._input_op = self._graph.get_operation_by_name(\\n self._prefix + \\\"/\\\" + self.config.input_name\\n )\\n\\n # Get feature operation, if necessary\\n features_name = None\\n if self.config.generate_features:\\n if self.config.features_name:\\n features_name = self.config.features_name\\n elif network_name in _DEFAULT_FEATURES_NAMES:\\n features_name = _DEFAULT_FEATURES_NAMES[network_name]\\n if features_name is not None:\\n self._features_op = self._graph.get_operation_by_name(\\n self._prefix + \\\"/\\\" + features_name\\n )\\n else:\\n self._features_op = None\\n\\n # Get output operation\\n if self.config.output_name:\\n output_name = self.config.output_name\\n else:\\n output_name = _DEFAULT_OUTPUT_NAMES.get(network_name, None)\\n if output_name is None:\\n raise ValueError(\\n \\\"`output_name` was not provided and network `%s` was not \\\"\\n \\\"found in default outputs map\\\" % network_name\\n )\\n self._output_op = self._graph.get_operation_by_name(\\n self._prefix + \\\"/\\\" + output_name\\n )\\n\\n # Setup preprocessing\\n self._transforms = self._make_preprocessing_fcn(\\n network_name, self.config.preprocessing_fcn\\n )\\n self._preprocess = True\\n\\n self._last_features = None\\n self._last_probs = None\",\n \"def build_engine():\\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, \\\\\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\\n\\n builder.max_workspace_size = TRT_MAX_WORKSPACE_SIZE\\n builder.max_batch_size = max_batch_size\\n\\n # Parse model file\\n if not os.path.exists(onnx_file_path):\\n print('ONNX file {} not found.'.format(onnx_file_path))\\n exit(1)\\n\\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\\n with open(onnx_file_path, 'rb') as model:\\n print('Beginning ONNX file parsing')\\n if not parser.parse(model.read()):\\n print ('ERROR: Failed to parse the ONNX file.')\\n for error in range(parser.num_errors):\\n print (parser.get_error(error))\\n return None\\n\\n network.get_input(0).shape = input_shape\\n print('Completed parsing of ONNX file')\\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\n engine = builder.build_cuda_engine(network)\\n print('Completed creating Engine: num layers %d -> %d' %\\n (network.num_layers, engine.num_layers),\\n file=sys.stderr)\\n return engine\",\n \"def _init_session(self):\\n self.sess = tf.Session(graph=self.g)\\n self.sess.run(self.init)\",\n \"def __init__(self, namespace):\\n super(HaystackInferenceSession, self).__init__(\\n approximate=True, load_brick=True\\n )\\n self._generated_triples = []\\n self._BLDG = rdflib.Namespace(namespace)\\n self._filters = [\\n lambda x: not x.startswith(\\\"his\\\"),\\n lambda x: not x.endswith(\\\"Ref\\\"),\\n lambda x: not x.startswith(\\\"cur\\\"),\\n lambda x: x != (\\\"disMacro\\\"),\\n lambda x: x != \\\"navName\\\",\\n lambda x: x != \\\"tz\\\",\\n lambda x: x != \\\"mod\\\",\\n lambda x: x != \\\"id\\\",\\n ]\\n self._point_tags = [\\n \\\"point\\\",\\n \\\"sensor\\\",\\n \\\"command\\\",\\n \\\"setpoint\\\",\\n \\\"alarm\\\",\\n \\\"status\\\",\\n \\\"parameter\\\",\\n \\\"limit\\\",\\n ]\",\n \"def _init_session(self):\\n self.sess = tf.Session(config=self.config, graph=self.g)\\n self.sess.run(self.init)\",\n \"def make_session(num_cpu, graph=None):\\n tf_config = tf.compat.v1.ConfigProto(\\n allow_soft_placement=True,\\n inter_op_parallelism_threads=num_cpu,\\n intra_op_parallelism_threads=num_cpu)\\n\\n # Prevent tensorflow from taking all the gpu memory.\\n tf_config.gpu_options.allow_growth = True\\n\\n return tf.compat.v1.Session(config=tf_config, graph=graph)\",\n \"def get_engine(max_batch_size=1, onnx_file_path=\\\"\\\", engine_file_path=\\\"\\\", \\\\\\r\\n fp32_mode=False, fp16_mode=False, mix_mode=False, calibration_stream=None, calibration_table_path=\\\"\\\",\\r\\n save_engine=False, strategy=None,log=None):\\r\\n\\r\\n def build_engine(max_batch_size, save_engine):\\r\\n \\\"\\\"\\\"Takes an ONNX file and creates a TensorRT engine to run inference with\\\"\\\"\\\"\\r\\n # 1 << NetworkDefinitionCreationFlag.EXPLICIT_BATCH\\r\\n with trt.Builder(TRT_LOGGER) as builder, \\\\\\r\\n builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) as network, \\\\\\r\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\\r\\n\\r\\n # parse onnx model file\\r\\n if not os.path.exists(onnx_file_path):\\r\\n quit('ONNX file {} not found'.format(onnx_file_path))\\r\\n log.logger.info('Loading ONNX file from path {}...'.format(onnx_file_path))\\r\\n with open(onnx_file_path, 'rb') as model:\\r\\n log.logger.info('Beginning ONNX file parsing')\\r\\n parser.parse(model.read())\\r\\n # modify the orignal onnx network\\r\\n count = 0;\\r\\n for i in range(network.num_layers):\\r\\n net = network.get_layer(i)\\r\\n if (net.type == trt.LayerType.CONVOLUTION and 'Conv' in net.name):\\r\\n count = count + 1;\\r\\n # network.mark_output(net.get_output(0))\\r\\n log2.logger.info('----1----network.num_layers:' + str(\\r\\n network.num_layers) + ' .the number of the conv is:' + str(count) + '\\\\n')\\r\\n log2.logger.info(net.name + '\\\\n')\\r\\n log2.logger.info(str(net.type) + '\\\\n')\\r\\n activate = network.add_activation(input=net.get_output(0),\\r\\n type=trt.ActivationType.CLIP) # return a layer\\r\\n if (strategy == None):\\r\\n log.logger.error('strategy error!')\\r\\n activate.beta = pow(2, strategy[count - 1] - 1) - 1\\r\\n activate.alpha = -pow(2, strategy[count - 1] - 1)\\r\\n activate.name = 'CLIP_%d' % i\\r\\n log2.logger.info(activate.name + ' beta is ' + str(activate.beta) + ' and alpha is ' + str(\\r\\n activate.alpha) + '\\\\n')\\r\\n # get the layer next to conv,and input the output of the activation layer.\\r\\n net_next = network.get_layer(i + 1)\\r\\n net_next.set_input(0, activate.get_output(0))\\r\\n log2.logger.info(net_next.name + '\\\\n')\\r\\n log2.logger.info(str(net_next.type) + '\\\\n')\\r\\n\\r\\n net_next2 = network.get_layer(i + 2)\\r\\n net_next2.set_input(0, net_next.get_output(0))\\r\\n net_next2.set_input(1, activate.get_output(0))\\r\\n log2.logger.info(net_next2.name + '\\\\n')\\r\\n log2.logger.info(str(net_next2.type) + '\\\\n')\\r\\n log2.logger.info('----2----network.num_layers:' + str(network.num_layers) + '\\\\n')\\r\\n assert network.num_layers > 0, 'Failed to parse ONNX model. \\\\\\r\\n Please check if the ONNX model is compatible '\\r\\n log.logger.info('Completed parsing of ONNX file')\\r\\n log.logger.info('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\r\\n\\r\\n # build trt engine\\r\\n if mix_mode:\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.int8_mode = mix_mode\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'\\r\\n builder.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('Mix mode enabled')\\r\\n if fp16_mode:\\r\\n builder.strict_type_constraints = True\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n builder.fp16_mode = fp16_mode\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('fp16 modify mode enabled')\\r\\n if fp32_mode:\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('fp32 modify mode enabled')\\r\\n if engine is None:\\r\\n log.logger.error('Failed to create the engine')\\r\\n return None\\r\\n log.logger.info(\\\"Completed creating the engine\\\")\\r\\n if save_engine:\\r\\n with open(engine_file_path, \\\"wb\\\") as f:\\r\\n f.write(engine.serialize())\\r\\n return engine\\r\\n\\r\\n if os.path.exists(engine_file_path):\\r\\n # If a serialized engine exists, load it instead of building a new one.\\r\\n log.logger.info(\\\"Reading engine from file {}\\\".format(engine_file_path))\\r\\n with open(engine_file_path, \\\"rb\\\") as f, trt.Runtime(TRT_LOGGER) as runtime:\\r\\n return runtime.deserialize_cuda_engine(f.read())\\r\\n else:\\r\\n return build_engine(max_batch_size, save_engine)\",\n \"def make_session(config=None, num_cpu=None, make_default=False, graph=None):\\n if num_cpu is None:\\n num_cpu = int(os.getenv('RCALL_NUM_CPU', multiprocessing.cpu_count()))\\n if config is None:\\n config = tf.ConfigProto(\\n allow_soft_placement=True,\\n inter_op_parallelism_threads=num_cpu,\\n intra_op_parallelism_threads=num_cpu)\\n config.gpu_options.allow_growth = True\\n\\n if make_default:\\n return tf.InteractiveSession(config=config, graph=graph)\\n else:\\n return tf.Session(config=config, graph=graph)\",\n \"def get_engine(onnx_file_path, engine_file_path=\\\"\\\"):\\n def build_engine():\\n \\\"\\\"\\\"Takes an ONNX file and creates a TensorRT engine to run inference with\\\"\\\"\\\"\\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\\n builder.max_workspace_size = 1 << 30 # 1GB\\n builder.max_batch_size = 1\\n builder.fp16_mode = mode_fp16\\n # builder.int8_mode = mode_int8\\n # Parse model file\\n if not os.path.exists(onnx_file_path):\\n print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))\\n exit(0)\\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\\n with open(onnx_file_path, 'rb') as model:\\n print('Beginning ONNX file parsing')\\n parser.parse(model.read())\\n print('Completed parsing of ONNX file')\\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\n engine = builder.build_cuda_engine(network)\\n print(\\\"Completed creating Engine\\\")\\n with open(engine_file_path, \\\"wb\\\") as f:\\n f.write(engine.serialize())\\n return engine\\n\\n if os.path.exists(engine_file_path):\\n # If a serialized engine exists, use it instead of building an engine.\\n print(\\\"engine file already exits at {}\\\".format(engine_file_path))\\n \\n else:\\n return build_engine()\",\n \"def build_engine():\\n with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:\\n builder.max_workspace_size = 1 << 30 # 1GB\\n builder.max_batch_size = 1\\n builder.fp16_mode = mode_fp16\\n # builder.int8_mode = mode_int8\\n # Parse model file\\n if not os.path.exists(onnx_file_path):\\n print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))\\n exit(0)\\n print('Loading ONNX file from path {}...'.format(onnx_file_path))\\n with open(onnx_file_path, 'rb') as model:\\n print('Beginning ONNX file parsing')\\n parser.parse(model.read())\\n print('Completed parsing of ONNX file')\\n print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\n engine = builder.build_cuda_engine(network)\\n print(\\\"Completed creating Engine\\\")\\n with open(engine_file_path, \\\"wb\\\") as f:\\n f.write(engine.serialize())\\n return engine\",\n \"def _build_inference_graph(self):\\n tf.contrib.framework.create_global_step()\\n in0 = tf.Variable(1.0)\\n in1 = tf.contrib.framework.local_variable(2.0)\\n fake_table = tf.Variable(\\n 3.0, trainable=False, collections=['fake_tables'],\\n name='fake_table_var')\\n in0.graph.add_to_collections(\\n [tf.GraphKeys.TABLE_INITIALIZERS], fake_table.initializer)\\n out = in0 + in1 + fake_table\\n return in0, in1, out\",\n \"def __init__(self, session, input_size, seq_size, output_size, learning_rate, model_name, net_name):\\n self.session = session\\n self.input_size = input_size\\n self.seq_size = seq_size\\n self.output_size = output_size\\n\\n self.learning_rate = learning_rate\\n self.net_name = net_name\\n self.x = None\\n self.model_name = model_name\\n\\n self._build_network()\",\n \"def create_new_session():\\n database_engine = create_engine(SQLITE_FILE)\\n DeclarativeBase.metadata.create_all(database_engine)\\n DeclarativeBase.bind = database_engine\\n\\n session = sessionmaker()\\n session.configure(bind=database_engine)\\n\\n return session()\",\n \"def make_model(self):\\n onnx_graph = onnx.helper.make_graph(\\n self._nodes, self._name, self._inputs, self._outputs, self._initializers\\n )\\n kwargs = {}\\n kwargs[\\\"opset_imports\\\"] = self._get_opsets()\\n kwargs[\\\"producer_name\\\"] = \\\"TVM Relay\\\"\\n kwargs[\\\"producer_version\\\"] = tvm.__version__\\n\\n return onnx.helper.make_model(onnx_graph, **kwargs)\",\n \"def new_session(self):\\n self._session = self.vspk.NUVSDSession(\\n username=self.user,\\n password=self.password,\\n enterprise=self.enterprise,\\n api_url=self.uri)\\n\\n self._session.start()\\n if not self.default_enterprise:\\n self.default_enterprise = self.get_enterprise_by_name(\\n self.default_netpartition_name)\\n\\n self.assertIsNotNone(self.default_enterprise,\\n \\\"Should have a default \\\"\\n \\\"enterprise for Nuage plugin\\\")\\n\\n return self._session\",\n \"def create_session(uri: str = os.environ.get(\\\"OBSERVATORY_DB_URI\\\"), connect_args=None, poolclass=None):\\n\\n if uri is None:\\n raise ValueError(\\n \\\"observatory.api.orm.create_session: please set the create_session `uri` parameter \\\"\\n \\\"or the environment variable OBSERVATORY_DB_URI with a valid PostgreSQL workflow string\\\"\\n )\\n\\n if connect_args is None:\\n connect_args = dict()\\n\\n engine = create_engine(uri, convert_unicode=True, connect_args=connect_args, poolclass=poolclass)\\n s = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))\\n Base.query = s.query_property()\\n Base.metadata.create_all(bind=engine) # create all tables.\\n\\n return s\",\n \"def create_sparksession():\\n return SparkSession.builder.\\\\\\n appName(\\\"Transforming the historical parking occupancy and blockface datasets\\\").\\\\\\n getOrCreate()\",\n \"def create_inception_graph():\\n with tf.Session() as sess:\\n model_filename = os.path.join(\\n FLAGS['model_dir'], 'classify_image_graph_def.pb')\\n\\n with gfile.FastGFile(model_filename, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n bottleneck_tensor, jpeg_data_tensor, resized_input_tensor = (\\n tf.import_graph_def(graph_def, name='', return_elements=[\\n BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME,\\n RESIZED_INPUT_TENSOR_NAME]))\\n\\n return sess.graph, bottleneck_tensor, jpeg_data_tensor, resized_input_tensor\",\n \"def __init__(self, path):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n tf.reset_default_graph()\\n with tf.gfile.GFile(path, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def get_session():\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n return tf.Session(config=config)\",\n \"def create_session_factory(self, engine):\\n\\n raise CoreNotImplementedError()\",\n \"def create_graph():\\n with tf.gfile.FastGFile(os.path.join(\\n config['inference']['model_dir'], 'output_graph.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def, name='')\",\n \"def inference_mode_on():\\n Layer.inference_mode = True\\n with ng.metadata(mode=\\\"inference\\\"):\\n yield\\n Layer.inference_mode = False\",\n \"def main():\\n get_engine(onnx_file_path, engine_file_path)\",\n \"def connect(cls):\\n engine = create_engine(cls._build_uri(), echo=False)\\n cls.Session = sessionmaker()\\n cls.Session.configure(bind=engine)\",\n \"def start(self):\\n self.sess = tf.Session()\\n tf.global_variables_initializer().run(session=self.sess)\",\n \"def init_interactive(cls=None, runtime=None):\\n \\n # Determine default model class (which is a Widget if ui is imported)\\n if cls is None and 'flexx.ui' in sys.modules:\\n from .. import ui\\n cls = ui.Widget\\n \\n # Create the default session\\n session = manager.get_default_session()\\n if session is None:\\n session = manager.create_default_session(cls)\\n else:\\n return # default session already running\\n\\n # Launch web runtime, the server will wait for the connection\\n server = current_server()\\n host, port = server.serving\\n url = '%s:%i/%s/?session_id=%s' % (host, port, session.app_name, session.id)\\n session._runtime = launch('http://' + url, runtime=runtime)\",\n \"def __create_execution_engine(self):\\n target = self.binding.Target.from_default_triple()\\n target_machine = target.create_target_machine()\\n backing_mod = binding.parse_assembly(\\\"\\\")\\n engine = binding.create_mcjit_compiler(backing_mod, target_machine)\\n self.engine = engine\",\n \"def make_session(num_cpu=None, make_default=False):\\n if num_cpu is None:\\n num_cpu = int(os.getenv('RCALL_NUM_CPU', multiprocessing.cpu_count()))\\n tf_config = tf.ConfigProto(\\n inter_op_parallelism_threads=num_cpu,\\n intra_op_parallelism_threads=num_cpu)\\n tf_config.gpu_options.allocator_type = 'BFC'\\n if make_default:\\n return tf.InteractiveSession(config=tf_config)\\n else:\\n return tf.Session(config=tf_config)\",\n \"def test_run_inference(self, start_server_single_model_onnx):\\n\\n _, ports = start_server_single_model_onnx\\n\\n # Connect to grpc service\\n stub = create_channel(port=ports[\\\"grpc_port\\\"])\\n\\n imgs_v1_224 = np.ones(ResnetONNX.input_shape, ResnetONNX.dtype)\\n output = infer(imgs_v1_224, input_tensor=ResnetONNX.input_name, grpc_stub=stub,\\n model_spec_name=ResnetONNX.name,\\n model_spec_version=None,\\n output_tensors=[ResnetONNX.output_name])\\n logger.info(\\\"Output shape: {}\\\".format(output[ResnetONNX.output_name].shape))\\n assert output[ResnetONNX.output_name].shape == ResnetONNX.output_shape, ERROR_SHAPE\",\n \"def prepare_session(sess):\\n init = tf.global_variables_initializer()\\n sess.run(init)\",\n \"def _new_session(self, m):\\n # Create a new session for this model, initialize\\n # variables, and save / restore from\\n # checkpoint.\\n self._session = tf.Session(\\n '',\\n config=tf.ConfigProto(\\n allow_soft_placement=True, log_device_placement=False))\\n self.session.run(m.init)\\n\\n # Load in a previous checkpoint, or save this one\\n self.extract_model_spec()\\n try:\\n yield\\n finally:\\n tf.Session.reset('')\\n self._session = None\",\n \"def __init__(self, session, input_size, output_size, name):\\n self.session = session\\n self.input_size = input_size\\n self.output_size = output_size\\n self.net_name = name\\n\\n self._build_network()\",\n \"def build_engine(max_batch_size, save_engine):\\r\\n # 1 << NetworkDefinitionCreationFlag.EXPLICIT_BATCH\\r\\n with trt.Builder(TRT_LOGGER) as builder, \\\\\\r\\n builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) as network, \\\\\\r\\n trt.OnnxParser(network, TRT_LOGGER) as parser:\\r\\n\\r\\n # parse onnx model file\\r\\n if not os.path.exists(onnx_file_path):\\r\\n quit('ONNX file {} not found'.format(onnx_file_path))\\r\\n log.logger.info('Loading ONNX file from path {}...'.format(onnx_file_path))\\r\\n with open(onnx_file_path, 'rb') as model:\\r\\n log.logger.info('Beginning ONNX file parsing')\\r\\n parser.parse(model.read())\\r\\n # modify the orignal onnx network\\r\\n count = 0;\\r\\n for i in range(network.num_layers):\\r\\n net = network.get_layer(i)\\r\\n if (net.type == trt.LayerType.CONVOLUTION and 'Conv' in net.name):\\r\\n count = count + 1;\\r\\n # network.mark_output(net.get_output(0))\\r\\n log2.logger.info('----1----network.num_layers:' + str(\\r\\n network.num_layers) + ' .the number of the conv is:' + str(count) + '\\\\n')\\r\\n log2.logger.info(net.name + '\\\\n')\\r\\n log2.logger.info(str(net.type) + '\\\\n')\\r\\n activate = network.add_activation(input=net.get_output(0),\\r\\n type=trt.ActivationType.CLIP) # return a layer\\r\\n if (strategy == None):\\r\\n log.logger.error('strategy error!')\\r\\n activate.beta = pow(2, strategy[count - 1] - 1) - 1\\r\\n activate.alpha = -pow(2, strategy[count - 1] - 1)\\r\\n activate.name = 'CLIP_%d' % i\\r\\n log2.logger.info(activate.name + ' beta is ' + str(activate.beta) + ' and alpha is ' + str(\\r\\n activate.alpha) + '\\\\n')\\r\\n # get the layer next to conv,and input the output of the activation layer.\\r\\n net_next = network.get_layer(i + 1)\\r\\n net_next.set_input(0, activate.get_output(0))\\r\\n log2.logger.info(net_next.name + '\\\\n')\\r\\n log2.logger.info(str(net_next.type) + '\\\\n')\\r\\n\\r\\n net_next2 = network.get_layer(i + 2)\\r\\n net_next2.set_input(0, net_next.get_output(0))\\r\\n net_next2.set_input(1, activate.get_output(0))\\r\\n log2.logger.info(net_next2.name + '\\\\n')\\r\\n log2.logger.info(str(net_next2.type) + '\\\\n')\\r\\n log2.logger.info('----2----network.num_layers:' + str(network.num_layers) + '\\\\n')\\r\\n assert network.num_layers > 0, 'Failed to parse ONNX model. \\\\\\r\\n Please check if the ONNX model is compatible '\\r\\n log.logger.info('Completed parsing of ONNX file')\\r\\n log.logger.info('Building an engine from file {}; this may take a while...'.format(onnx_file_path))\\r\\n\\r\\n # build trt engine\\r\\n if mix_mode:\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.int8_mode = mix_mode\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'\\r\\n builder.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('Mix mode enabled')\\r\\n if fp16_mode:\\r\\n builder.strict_type_constraints = True\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n builder.fp16_mode = fp16_mode\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('fp16 modify mode enabled')\\r\\n if fp32_mode:\\r\\n builder.max_batch_size = max_batch_size\\r\\n builder.max_workspace_size = 1 << 30 # 1GB\\r\\n engine = builder.build_cuda_engine(network)\\r\\n log.logger.info('fp32 modify mode enabled')\\r\\n if engine is None:\\r\\n log.logger.error('Failed to create the engine')\\r\\n return None\\r\\n log.logger.info(\\\"Completed creating the engine\\\")\\r\\n if save_engine:\\r\\n with open(engine_file_path, \\\"wb\\\") as f:\\r\\n f.write(engine.serialize())\\r\\n return engine\",\n \"def get_session(config=None):\\n sess = tf.get_default_session()\\n if sess is None:\\n sess = make_session(config=config, make_default=True)\\n return sess\",\n \"def _initialize_session(self):\\n config = tf.ConfigProto()\\n # restrict model GPU memory utilization to min required\\n config.gpu_options.allow_growth = True\\n self.sess = tf.Session(config=config)\\n tf_ver = int(tf.__version__.split('.')[1])\\n if TF_VERSION <= 0.10:\\n self.sess.run(tf.initialize_all_variables())\\n logswriter = tf.train.SummaryWriter\\n else:\\n self.sess.run(tf.global_variables_initializer())\\n logswriter = tf.summary.FileWriter\\n self.saver = tf.train.Saver()\\n self.summary_writer = logswriter(self.logs_path, graph=self.sess.graph) # change by ccx, add the graph_def\",\n \"def generate_mxp_graph(model_name, activations, stats, first_node_name, last_node_name, io_info,\\n input_type, ignore_strides=False, inline_depthwise=False, verbose=False):\\n network = {}\\n network['layers'] = []\\n network['test_input'] = None\\n network['test_output'] = None\\n network['scale'] = 1.0\\n\\n model = onnx.load(model_name)\\n nodes = model.graph.node\\n inits = model.graph.initializer\\n\\n idx = get_node_index(nodes, first_node_name)\\n if idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(first_node_name, mname))\\n assert(idx != None)\\n\\n last_idx = get_node_index(nodes, last_node_name)\\n if last_idx == None:\\n if verbose:\\n print('{} does not exist\\\\nopen {} in Netron + check spelling'.format(last_node_name, mname))\\n assert(last_idx != None)\\n\\n while True:\\n node = nodes[idx]\\n if verbose:\\n print(node.name, node.op_type)\\n src_node = get_node_source(nodes, node.input[0])\\n if src_node == None:\\n input_id = node.input[0]\\n else:\\n input_id = src_node.output[0]\\n output_id = node.output[0]\\n\\n\\n if len(network['layers']) == 0:\\n previous = None\\n else:\\n previous = network['layers'][-1]\\n for layer in network['layers']:\\n if layer['output_id'] == input_id:\\n previous = layer\\n\\n input_shapes, output_shapes = get_shapes(activations, stats, node)\\n assert len(output_shapes) == 1, \\\"Multi-output nodes not supported\\\"\\n output_shape = output_shapes[0]\\n if node.op_type == \\\"Conv\\\":\\n c, m, n = input_shapes[0]\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n assert(get_attr(node, 'pads') == None or not any(get_attr(node, 'pads')))\\n\\n group = get_attr(node, 'group')\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n dilations = np.asarray(get_attr(node, 'dilations')).tolist()\\n if not group:\\n group = 1\\n if not strides:\\n strides = [1, 1]\\n if not dilations:\\n dilations = [1, 1]\\n\\n use_strided = 0\\n assert(strides == [1, 1] or strides == [2, 2] or strides == [4, 4])\\n\\n if DO_STRIDES and not ignore_strides:\\n if (strides[0] > 1 or strides[1] > 1) and group == 1: # TODO handle depthwise as well\\n assert(previous['output_size'] == int(np.prod(input_shapes[0])))\\n use_strided = 1\\n previous['output_strides'] = strides\\n if verbose:\\n print('adding output strides to previous node')\\n\\n m = m + (m % strides[0])\\n n = n + (n % strides[1])\\n if int(np.prod(input_shapes[0])) != int(c*m*n):\\n if verbose:\\n print('adjusting size for strided maps')\\n previous['output_size'] = int(c*4*m//strides[0]*n//strides[1])\\n previous['output_shape'] = (c*4,m//strides[0],n//strides[1])\\n\\n w = get_tensor(inits, node.input[1])\\n kernels, channels, _, _ = w.shape\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n conv_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(c*m*n),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels * group,\\n 'kernels': kernels,\\n 'kernel_shape': kernel_shape,\\n 'dilations': dilations,\\n 'strides': strides,\\n 'group': group,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'use_cvi': 0,\\n 'use_depthwise': 0,\\n 'use_strided': use_strided,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n conv_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(kernels)]\\n conv_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n\\n network['layers'].append(conv_layer)\\n\\n elif node.op_type == \\\"Gemm\\\":\\n w = get_tensor(inits, node.input[1])\\n output_size, input_size = w.shape\\n\\n if len(node.input) == 3:\\n b = get_tensor(inits, node.input[2])\\n\\n gemm_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(np.prod(input_shapes[0])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'gemm_input_size': input_size,\\n 'gemm_output_size': output_size,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"biases\\\": [],\\n \\\"weights\\\": [],\\n \\\"sublayers\\\": [],\\n }\\n\\n w = w.flatten().tolist()\\n gemm_layer['weights'] = base64.b64encode(struct.pack(\\\"f\\\"*len(w), *w)).decode()\\n\\n if len(node.input) == 3:\\n b = b.flatten().tolist()\\n else:\\n b = [0 for _ in range(output_size)]\\n gemm_layer['biases'] = base64.b64encode(struct.pack(\\\"f\\\"*len(b), *b)).decode()\\n network['layers'].append(gemm_layer)\\n\\n elif node.op_type in multipath_nodes:\\n node_inputs = get_previous_nodes(nodes, node)\\n shapes = input_shapes\\n\\n if node.op_type == \\\"Sum\\\":\\n assert(all([x == shapes[0] for x in shapes[1:]]))\\n elif node.op_type == \\\"Concat\\\":\\n assert(all([x[1:] == shapes[0][1:] for x in shapes[1:]]))\\n\\n buf = node_inputs[0].name\\n if node.op_type == \\\"Concat\\\":\\n buf = output_id\\n\\n buffer_offset = 0\\n for n, node_input in enumerate(node_inputs):\\n noutput = node_input.output[0]\\n for l, layer in enumerate(network['layers']):\\n if layer['output_id'] == noutput: # if layer pointing to this node\\n network['layers'][l]['output_id'] = buf # rename layer's output\\n network['layers'][l]['buffer_offset'] = buffer_offset # and offset appropriately\\n if layer['input_id'] == noutput:\\n network['layers'][l]['input_id'] = buf #TODO\\n\\n buffer_offset += int(np.prod(input_shapes[n]))\\n\\n if node.op_type == \\\"Sum\\\":\\n channels, m, n = shape3d(output_shape)\\n sum_layer = {\\n 'op_type': \\\"Sum\\\",\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': node_inputs[0].name,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'num_inputs': len(node.input),\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(sum_layer)\\n\\n elif node.op_type == \\\"Identity\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n identity_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(identity_layer)\\n\\n elif node.op_type == \\\"LRN\\\":\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n lrn_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'alpha': get_attr(node, 'alpha'),\\n 'beta': get_attr(node, 'beta'),\\n 'bias': get_attr(node, 'bias'),\\n 'size': get_attr(node, 'size'),\\n 'scale': 1.0,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(lrn_layer)\\n\\n elif node.op_type == \\\"Scale\\\":\\n scale_sublayer = {\\n 'op_type': 'Scale',\\n 'name': node.name,\\n \\\"use_replay\\\": 1,\\n 'scale': get_attr(node, 'scale'),\\n }\\n previous['sublayers'].append(scale_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"GlobalAveragePool\\\", \\\"GlobalMaxPool\\\"]:\\n assert(previous['n'] == previous['m'])\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type.replace('Global', ''),\\n 'name': node.name,\\n 'use_replay': 0,\\n 'kernel_shape': [previous['m'], previous['n']],\\n 'strides': [previous['m'], previous['n']],\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n\\n elif node.op_type in [\\\"MaxPool\\\", \\\"AveragePool\\\"]:\\n kernel_shape = np.asarray(get_attr(node, 'kernel_shape')).tolist()\\n\\n if node.op_type == \\\"AveragePool\\\": #TODO quick fix for tf average pool quirk\\n if kernel_shape[0] * kernel_shape[1] == previous['m'] * previous['n']:\\n kernel_shape = [previous['m'], previous['n']]\\n strides = np.asarray(get_attr(node, 'strides')).tolist()\\n if strides is None:\\n strides = [ 1 for _ in kernel_shape]\\n pads = pads6(node)\\n pool_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'kernel_shape': kernel_shape,\\n 'strides': strides,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pool_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type == \\\"PRelu\\\":\\n slope = get_tensor(inits, node.input[1])\\n slope = slope.flatten().tolist()\\n prelu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'slope': slope,\\n }\\n previous['sublayers'].append(prelu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"LeakyRelu\\\":\\n alpha = get_attr(node, 'alpha')\\n if alpha is None:\\n alpha = .01\\n leaky_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'alpha': alpha\\n }\\n previous['sublayers'].append(leaky_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Relu\\\":\\n relu_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(relu_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Clip\\\":\\n clip_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'min': float(get_tensor(inits,node.input[1])),\\n 'max': float(get_tensor(inits,node.input[2])),\\n }\\n previous['sublayers'].append(clip_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type == \\\"Pad\\\":\\n pads = pads6(get_tensor(inits,node.input[1]).tolist())\\n value = int(get_tensor(inits,node.input[2]))\\n if value < -1:\\n value = -1\\n if value > 1:\\n value = 1\\n pad_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'value': value,\\n 'pads': pads,\\n }\\n previous['sublayers'].append(pad_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n previous['output_shape'] = (output_shape)\\n elif node.op_type in [\\\"Add\\\", \\\"Mul\\\", \\\"Sub\\\", \\\"Div\\\"]:\\n\\n skip = False\\n if node.op_type == \\\"Mul\\\":\\n next_nodes = get_node_inputs(nodes, node.output[0])\\n if node.name == nodes[-1].name:\\n if verbose:\\n print('removing final scale node')\\n skip = True\\n\\n elif previous['op_type'] in [\\\"LRN\\\"]:\\n if verbose:\\n print('skipping mul after lrn')\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n previous['scale'] = float(array[0])\\n print('skipping mul after lrn', previous['scale'], previous['input_id'], previous['output_id'])\\n\\n skip = True\\n\\n elif next_nodes[0].op_type in [\\\"Softmax\\\"]:\\n if verbose:\\n print('skipping mul before softmax')\\n skip = True\\n\\n array = get_tensor(inits, node.input[1])\\n if array is None:\\n array = get_tensor(inits, node.input[0])\\n c = activations[node.input[1]].shape[1]\\n else:\\n c = input_shapes[0][0]\\n\\n if node.op_type == \\\"Add\\\": # TODO for scalar Add\\n dims = len(np.squeeze(array).shape)\\n if dims == 0:\\n array = np.ones((c, 1)) * array\\n\\n dims = len(np.squeeze(array).shape)\\n if c == 1 and dims == 0:\\n dims = 1\\n\\n array = array.flatten().tolist()\\n # force_broadcast_2 = False\\n # if force_broadcast_2:\\n # # if c != 1 and dims == 0:\\n # if c != 1 and dims == 0 and node.op_type != \\\"Mul\\\": # TODO forcing to broadcast 2 not broadcast 3\\n # dims = 1\\n # array = [array[0] for _ in range(c)]\\n\\n if not skip:\\n arithmetic_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'dims': dims,\\n 'array': array,\\n }\\n previous['sublayers'].append(arithmetic_sublayer)\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Abs\\\", \\\"Max\\\", \\\"Mean\\\", \\\"Min\\\", \\\"Neg\\\", \\\"Not\\\"]:\\n unary_sublayer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n }\\n previous['sublayers'].append(unary_sublayer)\\n previous['output_id'] = output_id\\n previous['output_size'] = int(np.prod(output_shape))\\n\\n elif node.op_type == \\\"Reshape\\\":\\n dims = get_tensor(inits, node.input[1])\\n\\n if len(dims) == 4 and dims[-1] == 2:\\n idx += 6\\n node = nodes[idx]\\n output_id = node.output[0]\\n _, output_shapes = get_shapes(activations, stats, node)\\n output_shape = output_shapes[0]\\n channels, m, n = shape3d(output_shape)\\n reorg_layer = {\\n 'op_type': \\\"Reorg\\\",\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape': output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n \\\"stride\\\": int(dims[-1]),\\n }\\n network['layers'].append(reorg_layer)\\n else:\\n previous['output_id'] = output_id\\n\\n elif node.op_type in [\\\"Flatten\\\",'Cast']:\\n previous['output_id'] = output_id\\n elif node.op_type == \\\"Resize\\\":\\n scales = get_tensor(inits, node.input[2])\\n assert(scales[0] == 1 and scales[1] == 1)\\n scale = float(scales[2])\\n mode = get_attr(node, 'mode').decode()\\n assert(mode == 'nearest' or mode == 'linear')\\n shapes = input_shapes[:1]\\n channels, m, n = shape3d(output_shape)\\n in_size= [d for d in one_elem(input_shapes)[1:]]\\n replay = 0 if in_size == [1,1] else 1\\n resize_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': replay,\\n 'input_size': int(np.prod(one_elem(input_shapes))),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'mode' :mode,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(resize_layer)\\n elif node.op_type == \\\"ArgMax\\\":\\n input_shape = one_elem(input_shapes)\\n channels, m, n = shape3d(input_shape)\\n argmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': [float(scales[2]),float(scales[3])],\\n }\\n network['layers'].append(argmax_layer)\\n\\n elif node.op_type == \\\"Softmax\\\":\\n prev = get_previous_nodes(nodes, node)[0]\\n if prev.op_type == \\\"Mul\\\":\\n scale = get_tensor(inits, prev.input[1])\\n scale = scale.flatten().tolist()\\n else:\\n scale = [1.0]\\n if len(scale) > 1:\\n raise NotImplementedError(\\\"Broadcast scale not implemented for softmax\\\")\\n\\n shapes = input_shapes\\n channels, m, n = shape3d(output_shape)\\n softmax_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 0,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n \\\"sublayers\\\": [],\\n 'scale': scale,\\n 'size': len(scale),\\n }\\n network['layers'].append(softmax_layer)\\n\\n # softmax_sublayer = {u'op_type': u'Softmax', 'scale': 1.0}\\n # previous['sublayers'].append(softmax_sublayer)\\n # previous['output_id'] = output_id\\n # print('warning SOFTMAX ignored!... fine if last layer and sorting outputs')\\n\\n elif node.op_type == \\\"Transpose\\\":\\n shapes = input_shapes\\n\\n channels, m, n = shape3d(output_shape)\\n permutation =[p-1 for p in get_attr(node, 'perm')[1:]]\\n transpose_layer = {\\n 'op_type': node.op_type,\\n 'name': node.name,\\n 'use_replay': 1,\\n 'input_size': int(sum([np.prod(s) for s in input_shapes])),\\n 'output_size': int(np.prod(output_shape)),\\n 'output_shape':output_shape,\\n 'input_id': input_id,\\n 'output_id': output_id,\\n 'channels': channels,\\n 'm': m,\\n 'n': n,\\n 'dma_offset': 0,\\n 'buffer_offset': 0,\\n 'permutation':permutation,\\n \\\"sublayers\\\": [],\\n }\\n network['layers'].append(transpose_layer)\\n else:\\n raise RuntimeError('Unknown node type:{} '.format(node.op_type))\\n\\n idx += 1\\n if idx > last_idx:\\n break\\n\\n unsigned_network_inputs = input_type == np.uint8\\n\\n if CVI_1x1:\\n network = mxp_gemm_to_conv(network)\\n\\n network = mxp_set_replay(network, io_info)\\n network = mxp_set_cvi(network)\\n network = mxp_set_unsigned(network, unsigned_network_inputs)\\n\\n if inline_depthwise:\\n network = mxp_inline_depthwise(network)\\n\\n network = mxp_describe_layers(network)\\n network = mxp_number_buffers(network)\\n buffers = mxp_size_buffers(network)\\n network = mxp_number_sublayers(network)\\n\\n network['num_layers'] = len(network['layers'])\\n network['buffers'] = buffers\\n\\n return network\",\n \"def get_obex_session(client, source_adr, target_adr):\\n # session = client.CreateSession(\\\"58:C9:35:2F:A1:EF\\\", {\\\"Target\\\":\\\"opp\\\", \\\"Source\\\":\\\"9C:B6:D0:8C:5D:D6\\\"})\\n session = client.CreateSession(target_adr, {\\\"Target\\\":\\\"opp\\\", \\\"Source\\\":source_adr})\\n return session\",\n \"def __init__(self, MY_GRAPH_PATH):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n with tf.gfile.FastGFile(MY_GRAPH_PATH, 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def _create_inference_model(pl_module):\\n new_model = get_model(pl_module.hparams)\\n new_model.normalization_metrics = AnomalyScoreDistribution().cpu()\\n new_model.load_state_dict(pl_module.state_dict())\\n return new_model\",\n \"def create_execution_engine():\\n # Create a target machine representing the host\\n target = llvm.Target.from_default_triple()\\n target_machine = target.create_target_machine()\\n # And an execution engine with an empty backing module\\n backing_mod = llvm.parse_assembly(\\\"\\\")\\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\\n return engine\",\n \"def create_execution_engine():\\n # Create a target machine representing the host\\n target = llvm.Target.from_default_triple()\\n target_machine = target.create_target_machine()\\n # And an execution engine with an empty backing module\\n backing_mod = llvm.parse_assembly(\\\"\\\")\\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\\n return engine\",\n \"def create_execution_engine():\\n # Create a target machine representing the host\\n target = llvm.Target.from_default_triple()\\n target_machine = target.create_target_machine()\\n # And an execution engine with an empty backing module\\n backing_mod = llvm.parse_assembly(\\\"\\\")\\n engine = llvm.create_mcjit_compiler(backing_mod, target_machine)\\n return engine\",\n \"def _initialize_session(par_interface, protocol_name, hints=()):\\n test_id_path = os.path.join(\\n os.path.dirname(__file__),\\n \\\"data\\\",\\n f\\\"{protocol_name}\\\",\\n \\\"image_classification\\\",\\n \\\"test_ids.csv\\\",\\n )\\n test_ids = list(map(str.strip, open(test_id_path, \\\"r\\\").readlines()))\\n # Testing if session was sucessfully initalized\\n session_id = par_interface.session_request(\\n test_ids, f\\\"{protocol_name}\\\", \\\"image_classification\\\", \\\"0.1.1\\\", list(hints)\\n )\\n return session_id\",\n \"def make_tflite_inference(ndvi_img_array, model_interpreter):\\n # Get input and output tensors.\\n input_details = model_interpreter.get_input_details()\\n output_details = model_interpreter.get_output_details()\\n\\n # Get Input shape\\n input_shape = input_details[0]['shape']\\n input_data = ndvi_img_array.reshape(input_shape)\\n\\n model_interpreter.set_tensor(input_details[0]['index'], input_data)\\n model_interpreter.invoke()\\n\\n outputs = []\\n\\n for tensor in output_details:\\n output_data = model_interpreter.get_tensor(tensor['index'])\\n outputs.append(output_data[0][0])\\n\\n prediction = outputs[0]\\n\\n return prediction\",\n \"def inference_with_graph(graph_def, image):\\n\\n\\twith tf.Graph().as_default() as graph:\\n\\n\\t\\twith tf.Session() as sess:\\n\\n\\t\\t\\t# Import a graph_def into the current default Graph\\n\\t\\t\\tprint(\\\"import graph\\\")\\t\\n\\t\\t\\tinput_, predictions = tf.import_graph_def(graph_def, name='', \\n\\t\\t\\t\\treturn_elements=input_output_placeholders)\\n\\t\\t\\t\\n\\t\\t\\tcamera.start_preview()\\n\\t\\t\\tcamera.resolution = (640, 480)\\n\\t\\t\\tcamera.framerate = 32\\n\\n\\t\\t\\ttimer.timer('predictions.eval')\\t\\n\\n\\t\\t\\ttime_res = []\\n\\t\\t\\tfor i in range(10):\\n\\n\\t\\t\\t\\tcamera.capture(stream, format='jpeg')\\n\\t\\t\\t\\tstream.seek(0)\\n\\t\\t\\t\\timage = Image.open(stream)\\n\\t\\t\\t\\tshape = tuple(INPUT_SIZE[1:])\\n\\t\\t\\t\\timage = image.resize(shape, Image.ANTIALIAS)\\n\\t\\t\\t\\timage_arr = np.array(image, dtype=np.float32) / 255.0\\t\\t\\t\\t\\n\\n\\t\\t\\t\\tpred_val = predictions.eval(feed_dict={input_: [image_arr]})\\n\\t\\t\\t\\tprint(pred_val)\\n\\t\\t\\t\\ttimer.timer()\\n\\t\\t\\t\\t#time_res.append(0)\\n\\t\\t\\t\\t#print('index={0}, label={1}'.format(index, label))\\n\\n\\t\\t\\tcamera.stop_preview()\\t\\n\\t\\t\\tprint(camera.resolution)\\n\\n\\t\\t\\t#print('mean time = {0}'.format(np.mean(time_res)))\\n\\n\\t\\t\\t#return index\",\n \"def start_inference_process(VD, CD):\\n \\n if VD['inference_process'] == None:\\n VD['terminal_output'] += \\\"\\\\nCreating inference process...\\\\n\\\"\\n VD['window']['terminal_text'].update(VD['terminal_output'])\\n event, values = VD['window'].read(timeout=0)\\n ap.create_process(VD, CD)\\n \\n VD['terminal_output'] += \\\"Created inference process.\\\\n\\\"\\n else:\\n VD['terminal_output'] += \\\"An inference process is already active.\\\"\",\n \"def get_session():\\n # See: https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n session = tf.Session(config=config)\\n return session\",\n \"def __init__(self,\\n qnn,\\n optimizer,\\n session,\\n state_shape,\\n actions_count,\\n reply_memory_size=100,\\n minibatch_size=32,\\n final_exploration_probability=0.05,\\n exploration_period=1000,\\n discount_factor=0.95,\\n unrollings_num=16,\\n target_freeze_period=1000,\\n ):\\n\\n self.prediction_nn = qnn\\n self.target_nn = qnn.clone()\\n self.optimizer = optimizer\\n\\n self.state_shape = state_shape\\n self.actions_count = actions_count\\n\\n self.experience = deque()\\n self.reply_memory_size = reply_memory_size\\n self.current_episode = []\\n self.unrollings_num = unrollings_num\\n self.minibatch_size = minibatch_size\\n\\n self.epsilon_initial = 1.0\\n self.epsilon_final = final_exploration_probability\\n self.exploration_period = exploration_period\\n self.discount = discount_factor\\n self.freeze_period = target_freeze_period\\n\\n self.action_requests = 0\\n self.iteration = 0\\n\\n self.session = session\\n\\n self.build_graph()\",\n \"def __init__(self, session):\\n self.sess = session\",\n \"def __init__(self):\\r\\n # create a session id\\r\\n self.session = ViSession()\",\n \"def create_graph():\\n\\t# Creates graph from saved graph_def.pb.\\n\\twith tf.gfile.FastGFile('./models/inception_v4.pb', 'rb') as f:\\n\\t\\tgraph_def = tf.GraphDef()\\n\\t\\tgraph_def.ParseFromString(f.read())\\n\\t\\t_ = tf.import_graph_def(graph_def, name='')\",\n \"def test_init(self):\\n\\n # Default values are neo4j defaults, EXCEPT the password.\\n address = os.environ.get('NEO4J_ADDRESS', 'bolt://localhost:7687')\\n user = os.environ.get('NEO4J_USERNAME', 'neo4j')\\n passw = os.environ.get('NEO4J_PASSWORD', 'neo42j')\\n ontpath = \\\"scientio/examples/example_ontology.yaml\\\"\\n\\n o = Ontology(path_to_yaml=str(ontpath))\\n s = Session(ontology=o, neo4j_address=address,\\n neo4j_username=user, neo4j_password=passw)\\n\\n n = Node(metatype=o.get_type('Person'))\\n n.set_name('Test')\\n n_response = s.create(n)\\n\\n # TODO make smarter\\n assert (n_response is not None)\",\n \"def _build_graph(self):\\n\\n self.graph = tf.Graph()\\n\\n # set self.graph as default graph\\n with self.graph.as_default():\\n # # clear old variables\\n # tf.reset_default_graph()\\n\\n # set random seed\\n if self.random_seed is not None:\\n tf.set_random_seed(self.random_seed)\\n\\n self._create_placeholders()\\n self._create_variables()\\n\\n self._create_prediction()\\n\\n self._create_loss()\\n self._create_optimizer()\\n\\n self._init = tf.global_variables_initializer()\\n\\n self.saver = tf.train.Saver()\\n\\n # create session\\n self.sess = tf.Session(graph=self.graph)\",\n \"def __init__(self, tarball_path):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n graph_def = tf.GraphDef.FromString(open(tarball_path + \\\"/frozen_inference_graph.pb\\\", \\\"rb\\\").read()) \\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def setup_session():\\n print(\\\"Setting up session\\\")\\n engine = setup_engine()\\n Base.metadata.bin = engine\\n\\n DBSession = sessionmaker(bind=engine)\\n session = DBSession()\\n\\n return session\",\n \"def define_nmt(hidden_size, batch_size, en_timesteps, en_vsize, fr_timesteps, fr_vsize):\\n\\n # Define an input sequence and process it.\\n if batch_size:\\n encoder_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inputs')\\n decoder_inputs = Input(batch_shape=(batch_size, fr_timesteps - 1, fr_vsize), name='decoder_inputs')\\n else:\\n encoder_inputs = Input(shape=(en_timesteps, en_vsize), name='encoder_inputs')\\n if fr_timesteps:\\n decoder_inputs = Input(shape=(fr_timesteps - 1, fr_vsize), name='decoder_inputs')\\n else:\\n decoder_inputs = Input(shape=(None, fr_vsize), name='decoder_inputs')\\n\\n # Encoder GRU\\n encoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='encoder_gru')\\n encoder_out, encoder_state = encoder_gru(encoder_inputs)\\n\\n # Set up the decoder GRU, using `encoder_states` as initial state.\\n decoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='decoder_gru')\\n decoder_out, decoder_state = decoder_gru(decoder_inputs, initial_state=encoder_state)\\n\\n # Attention layer\\n attn_layer = AttentionLayer(name='attention_layer')\\n attn_out, attn_states = attn_layer([encoder_out, decoder_out])\\n\\n # Concat attention input and decoder GRU output\\n decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([decoder_out, attn_out])\\n\\n # Dense layer\\n dense = Dense(fr_vsize, activation='softmax', name='softmax_layer')\\n dense_time = TimeDistributed(dense, name='time_distributed_layer')\\n decoder_pred = dense_time(decoder_concat_input)\\n\\n # Full model\\n full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\\n full_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics = ['accuracy'])\\n\\n full_model.summary()\\n\\n \\\"\\\"\\\" Inference model \\\"\\\"\\\"\\n batch_size = 1\\n\\n \\\"\\\"\\\" Encoder (Inference) model \\\"\\\"\\\"\\n encoder_inf_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inf_inputs')\\n encoder_inf_out, encoder_inf_state = encoder_gru(encoder_inf_inputs)\\n encoder_model = Model(inputs=encoder_inf_inputs, outputs=[encoder_inf_out, encoder_inf_state])\\n\\n \\\"\\\"\\\" Decoder (Inference) model \\\"\\\"\\\"\\n decoder_inf_inputs = Input(batch_shape=(batch_size, 1, fr_vsize), name='decoder_word_inputs')\\n encoder_inf_states = Input(batch_shape=(batch_size, en_timesteps, hidden_size), name='encoder_inf_states')\\n decoder_init_state = Input(batch_shape=(batch_size, hidden_size), name='decoder_init')\\n\\n decoder_inf_out, decoder_inf_state = decoder_gru(decoder_inf_inputs, initial_state=decoder_init_state)\\n attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\\n decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_inf_out, attn_inf_out])\\n decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\\n decoder_model = Model(inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\\n outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state])\\n\\n return full_model, encoder_model, decoder_model\",\n \"def session(self):\\n ssn = pn_session(self._impl)\\n if ssn is None:\\n raise (SessionException(\\\"Session allocation failed.\\\"))\\n else:\\n return Session(ssn)\",\n \"def create_session(url):\\n # type: (str) -> qi.Session\\n application = qi.Application([NAOqiBackend.__name__, \\\"--qi-url={}\\\".format(url)])\\n try: application.start()\\n except RuntimeError as e:\\n raise RuntimeError(\\\"Couldn't connect to robot @ {}\\\\n\\\\tOriginal Error: {}\\\".format(url, e))\\n return application.session\",\n \"def make_env():\\n aigym_path = \\\"video/\\\"\\n env = retro.make(game='MortalKombatII-Genesis',state='Level1.LiuKangVsJax')\\n env = wrappers.Monitor(env, aigym_path,video_callable=False ,force=True) #, video_callable=False \\n env = ObservationWraperMK(env)\\n env = PlayerOneNetworkControllerWrapper(env)\\n env._max_episode_steps = 350\\n #env.render()\\n\\n return env\",\n \"def init_target_net(self, sess):\\n sess.run(self.init_target_net_op)\",\n \"def __init__(self, config):\\n\\n engine = self.__my_create_engine(config)\\n\\n if not engine:\\n raise Exception(\\\"No engine created\\\")\\n\\n engine.connect()\\n #metadata = MetaData(bind=engine)\\n Session = sessionmaker(bind=engine)\\n\\n # Set the objects to work with\\n self.session = Session()\",\n \"def Session(ioname, echo=True):\\n from sqlalchemy import create_engine\\n from sqlalchemy.orm import sessionmaker\\n dbpath = userenv.joinpath('scanbox', ioname, 'db.sqlite3')\\n engine = create_engine('sqlite:///{}'.format(dbpath),\\n echo=echo, convert_unicode=True)\\n return sessionmaker(engine, autocommit=False)\",\n \"def inference(model, image, batch_size):\\n image = Variable(image)\\n image = image.cuda()\\n return common.time_inference(inference_func=model, \\n inference_func_args={'x': image}, \\n batch_size=batch_size)\",\n \"def build_inference_graph(self):\\n self.build_train_graph()\",\n \"def _create_model(self):\\n if torch.cuda.is_available():\\n model = torch.jit.load(self.torch_jit).cuda()\\n else:\\n model = torch.jit.load(self.torch_jit)\\n model.eval()\\n return model\",\n \"def make_atari(env, num_frames, device, action_stack=False):\\n try:\\n noop_action = env.get_action_meanings().index(\\\"NOOP\\\")\\n except ValueError:\\n print(\\\"Cannot find NOOP in env, defaulting to 0\\\")\\n noop_action = 0\\n env = AtariPreprocess(env)\\n env = MaxAndSkipEnv(env, 4)\\n env = FrameStack(env, num_frames, device)\\n # env = TorchTensorObservation(env, device)\\n return env\",\n \"def __init__(self, model_path, img_width, img_height, gpu_fraction=1.0):\\n # Create session first with requested gpu_fraction parameter\\n config = tf.compat.v1.ConfigProto()\\n config.gpu_options.allow_growth = True\\n config.gpu_options.per_process_gpu_memory_fraction = gpu_fraction\\n self.tf_session = tf.compat.v1.Session(config=config)\\n\\n with tf.io.gfile.GFile(model_path, 'rb') as graph_file:\\n # Load graph off of disk into a graph definition\\n graph_def = tf.compat.v1.GraphDef()\\n graph_def.ParseFromString(graph_file.read())\\n self.input_tensor, self.output_tensor = tf.import_graph_def(\\n graph_def,\\n return_elements=['input_1:0', 'cumsum_values_1:0'])\\n\\n self.img_width = img_width\\n self.img_height = img_height\",\n \"def __init__(self, tf_session):\\n self._sess = tf_session\",\n \"def use_session(self, session: Optional[InferenceSession]) -> InferenceSession:\\n\\n token = self._active_session.set(session)\\n try:\\n yield session\\n finally:\\n self._active_session.reset(token)\",\n \"def create_session(self, transport):\\n session_id = self.session_id_allocator.allocate()\\n session = self.SESSION_CLS(self, transport, session_id)\\n self.sessions[session.id] = session\\n return session\",\n \"def initialize_session(self):\\n self.logger.info(\\\"Initializing tf session\\\")\\n self.sess = tf.compat.v1.Session()\\n self.sess.run(tf.compat.v1.global_variables_initializer())\\n self.saver = tf.compat.v1.train.Saver()\",\n \"def __init__(self, tarball_path):\\n self.graph = tf.Graph()\\n\\n graph_def = None\\n graph_def = tf.GraphDef.FromString(open(tarball_path + \\\"/frozen_inference_graph.pb\\\", \\\"rb\\\").read()) \\n\\n if graph_def is None:\\n raise RuntimeError('Cannot find inference graph in tar archive.')\\n\\n with self.graph.as_default():\\n tf.import_graph_def(graph_def, name='')\\n\\n self.sess = tf.Session(graph=self.graph)\",\n \"def create_network(self):\\n\\n print ('Creating network, changing data will have no effect beyond this point.')\\n n = IMNN.IMNN(parameters=self.parameters)\\n\\n if self.load_network:\\n n.restore_network()\\n else:\\n n.setup(network = self.network, load_data = self.data)\\n\\n return n\",\n \"def inference():\\n print(\\\"setting up vgg initialized conv layers ...\\\")\\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\\n\\n mean = model_data['normalization'][0][0][0]\\n mean_pixel = np.mean(mean, axis=(0, 1))\\n\\n weights = np.squeeze(model_data['layers'])\\n\\n\\n with tf.variable_scope(\\\"inference\\\"):\\n vgg_net(weights)\",\n \"def _set_session(self):\\n self.__session = sessionmaker(bind=self.__engine)()\",\n \"def make_session():\\n import aiohttp\\n conn = aiohttp.TCPConnector(limit_per_host=int(\\n os.getenv('AIO_CONN_LIMIT', 10)))\\n timeout = aiohttp.ClientTimeout(\\n total=int(os.getenv('AIO_TOTAL_TIMEOUT', 80)),\\n connect=int(os.getenv('AIO_CONN_TIMEOUT', 15)),\\n sock_read=int(os.getenv('AOI_READ_TIMEOUT', 30)),\\n sock_connect=int(os.getenv('AIO_CONN_TIMEOUT', 15)),\\n )\\n s = aiohttp.ClientSession(connector=conn, timeout=timeout)\\n return s\",\n \"def construct_graph(network_class: Type[InferenceNetwork],\\n config: Path, checkpoint_dir: str,\\n batch_size: int,\\n batches_per_step: int,\\n image_filenames: Tuple[str],\\n loop: bool,\\n preprocess_fn: Callable,\\n num_ipus: int,\\n mode: str,\\n save_graph_pb: bool) -> Tuple[tf.Operation, tf.Operation, tf.Operation]:\\n # Model specific config\\n with open(config.as_posix()) as file_stream:\\n try:\\n config_dict = yaml.safe_load(file_stream)\\n except yaml.YAMLError as exc:\\n tf.logging.error(exc)\\n\\n config_dict['network_name'] = config.stem\\n if 'dtype' not in config_dict:\\n config_dict[\\\"dtype\\\"] = 'float16'\\n\\n # Create inference optimized frozen graph definition\\n network = network_class(input_shape=config_dict[\\\"input_shape\\\"],\\n num_outputs=1000, batch_size=batch_size,\\n data_type=config_dict['dtype'],\\n config=config_dict,\\n checkpoint_dir=checkpoint_dir)\\n\\n # Export frozen graph to event file to view in Tensorboard\\\"\\n if save_graph_pb:\\n log_dir = Path(f\\\"{config_dict['network_name']}_graph\\\")\\n graph_filename = f\\\"{log_dir}/{config_dict['network_name']}_graph.pb\\\"\\n if not log_dir.exists():\\n log_dir.mkdir()\\n with tf.io.gfile.GFile(graph_filename, \\\"wb\\\") as f:\\n f.write(network.optimized_graph.SerializeToString())\\n logging.info(\\\"%d ops in the final graph.\\\" % len(network.optimized_graph.node))\\n import_to_tensorboard(graph_filename, log_dir=log_dir.as_posix())\\n\\n # Reset graph before creating one on the IPU\\n tf.reset_default_graph()\\n\\n # Create dataset\\n dataset = get_dataset(image_filenames, batch_size, loop=loop, preprocess_fn=preprocess_fn,\\n img_width=config_dict[\\\"input_shape\\\"][1],\\n img_height=config_dict[\\\"input_shape\\\"][0], dtype=config_dict['dtype'])\\n\\n # Set up graph on device, connect infeed and outfeed to the graph.\\n num_replicas = num_ipus if mode == 'replicated' else 1\\n infeed_queue = ipu_infeed_queue.IPUInfeedQueue(dataset, device_ordinal=0, feed_name=\\\"infeed\\\",\\n replication_factor=num_replicas)\\n outfeed_queue = ipu_outfeed_queue.IPUOutfeedQueue(device_ordinal=0, feed_name=\\\"outfeed\\\",\\n outfeed_mode=ipu_outfeed_queue.IPUOutfeedMode.ALL,\\n replication_factor=num_replicas)\\n\\n def comp_fn():\\n def body(img):\\n with scopes.ipu_scope('/device:IPU:0'):\\n probs = tf.import_graph_def(network.optimized_graph,\\n input_map={network.graph_input: img},\\n name=\\\"optimized\\\",\\n return_elements=[network.graph_output])[0]\\n outfeed_op = outfeed_queue.enqueue(probs)\\n # Note that enqueue happens on the IPU.\\n return outfeed_op\\n\\n return loops.repeat(batches_per_step,\\n body,\\n [],\\n infeed_queue)\\n\\n loop_op = ipu_compiler.compile(comp_fn, [])\\n\\n # The dequeue of the outfeed needs to happen on the CPU.\\n with tf.device('cpu'):\\n outfeed_dequeue = outfeed_queue.dequeue()\\n\\n ipu_utils.move_variable_initialization_to_cpu()\\n return loop_op, infeed_queue.initializer, outfeed_dequeue\",\n \"def trainSession(self, session):\\n pass\",\n \"def create_session(\\n self,\\n environ: str,\\n session_request_to_use: typing.Optional[SessionRequest] = None,\\n ) -> Session:\\n self.poll_sessions() # make sure there is an up to date picture of Sessions before proceeding\\n self.check_session_can_start(session_request_to_use)\\n return self.perform_session_create(\\n environ, self.project.session_parameters.serialize()\\n )\",\n \"def create_graph():\\n # Creates graph from saved graph_def.pb.\\n with tf.gfile.FastGFile(os.path.join(FLAGS.model_dir, r'/home/lg/Desktop/finetune/frozen_inception_v3_299.pb'), 'rb') as f:\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f.read())\\n _ = tf.import_graph_def(graph_def,return_elements=['InceptionV3/Predictions/Reshape_1:0'], name='lg')\",\n \"def createInfectApp(tx, query, id, ipid, date):\\n tx.run(query, id=id, ipid=ipid, date=date)\",\n \"def create_session(self, transport):\\n session = self.SESSION_CLS(self, transport, 0)\\n self.session = session\\n return session\",\n \"def initialize_session(self):\\n self.logger.info(\\\"Initializing tf session\\\")\\n session_conf = tf.ConfigProto(\\n allow_soft_placement=self.FLAGS.allow_soft_placement,\\n log_device_placement=self.FLAGS.log_device_placement)\\n self.session = tf.Session(config=session_conf)\\n self.session.run(tf.global_variables_initializer())\\n try: \\n self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=self.FLAGS.num_checkpoints)\\n except:\\n pass\",\n \"def infer_on_stream(args, client):\\n # Initialise the class\\n infer_network = Network()\\n # Set Probability threshold for detections\\n prob_threshold = args.prob_threshold\\n\\n ### TODO: Load the model through `infer_network` ###\\n infer_network.exec_network = infer_network.load_model\\\\\\n (args.model, args.device, args.cpu_extension)\\n # extract information about model input layer\\n (b, c, input_height, input_width) = infer_network.get_input_shape()\\n\\n ### TODO: Handle the input stream ###\\n # extenstion of input file\\n input_extension = os.path.splitext(args.input)[1].lower()\\n supported_vid_exts = ['.mp4', '.mpeg', '.avi', '.mkv']\\n supported_img_exts = [\\\".bmp\\\",\\\".dib\\\", \\\".jpeg\\\", \\\".jp2\\\", \\\".jpg\\\", \\\".jpe\\\",\\\\\\n \\\".png\\\", \\\".pbm\\\", \\\".pgm\\\", \\\".ppm\\\", \\\".sr\\\", \\\".ras\\\", \\\".tiff\\\", \\\".tif\\\"]\\n single_image_mode = False\\n # if input is camera\\n if args.input.upper() == 'CAM':\\n capture = cv2.VideoCapture(0)\\n \\n # if input is video\\n elif input_extension in supported_vid_exts:\\n capture = cv2.VideoCapture(args.input)\\n \\n # if input is image\\n elif input_extension in supported_img_exts:\\n single_image_mode = True\\n capture = cv2.VideoCapture(args.input) \\n capture.open(args.input)\\n else:\\n sys.exit(\\\"FATAL ERROR : The format of your input file is not supported\\\" \\\\\\n \\\"\\\\nsupported extensions are : \\\" + \\\", \\\".join(supported_exts))\\n prev_count = 0\\n total_persons = 0\\n ### TODO: Loop until stream is over ###\\n while (capture.isOpened()):\\n ### TODO: Read from the video capture ###\\n ret, frame = capture.read()\\n if not ret:\\n break\\n ### TODO: Pre-process the image as needed ###\\n image = preprocessing(frame, input_width, input_height)\\n ### TODO: Start asynchronous inference for specified request ###\\n start_time = time.time()\\n # run inference\\n infer_network.exec_net(image)\\n ### TODO: Wait for the result ###\\n if infer_network.wait() == 0:\\n infer_time = time.time() - start_time\\n ### TODO: Get the results of the inference request ###\\n outputs = infer_network.get_output()[0][0]\\n ### Take model output and extract number of detections with confidence exceeding threshold\\n ### and draw bounding boxes around detections\\n out_image, current_count = apply_threshold(outputs, frame, prob_threshold)\\n \\n # show inference time on image\\n cv2.putText(out_image, \\\"inference time: {:.5f} ms\\\".format(infer_time), (30, 30),\\\\\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\\n \\n ### TODO: Extract any desired stats from the results ###\\n # when any person exit\\n if current_count < prev_count:\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n # send duration to mqtt server client\\n client.publish(\\\"person/duration\\\", json.dumps({\\\"duration\\\": time.time() - p_start}))\\n\\n # when new person enters\\n if current_count > prev_count:\\n total_persons += current_count - prev_count\\n p_start = time.time()\\n \\n prev_count = current_count\\n \\n ### TODO: Calculate and send relevant information on ###\\n ### current_count, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": current_count,\\\"total\\\": total_persons}))\\n ### TODO: Send the frame to the FFMPEG server ###\\n sys.stdout.buffer.write(out_image)\\n sys.stdout.buffer.flush()\\n ### TODO: Write an output image if `single_image_mode` ###\\n if single_image_mode:\\n cv2.imwrite(\\\"output_frame.png\\\", out_image)\\n # release resources\\n capture.release()\\n cv2.destroyAllWindows()\\n client.disconnect()\\n del infer_network\",\n \"def __init__(self, agent, make_env=lambda:gym.make(\\\"SpaceInvaders-v0\\\"), n_games=1, max_size=None,\\n preprocess_observation = lambda obs:obs,agent_step=None):\\n if not isinstance(make_env, function):\\n env_name = make_env\\n make_env = lambda: gym.make(env_name)\\n\\n #create atari games\\n self.make_env = make_env\\n self.envs = [self.make_env() for _ in range(n_games)]\\n self.preprocess_observation = preprocess_observation\\n\\n\\n #initial observations\\n self.prev_observations = [self.preprocess_observation(make_env.reset()) for make_env in self.envs]\\n\\n #agent memory variables (if you use recurrent networks\\n self.prev_memory_states = [np.zeros((n_games,)+tuple(mem.output_shape[1:]),\\n dtype=get_layer_dtype(mem))\\n for mem in agent.agent_states]\\n\\n #save agent\\n self.agent = agent\\n self.agent_step = agent_step or agent.get_react_function()\\n\\n # Create experience replay environment\\n self.experience_replay = SessionPoolEnvironment(observations=agent.observation_layers,\\n actions=agent.action_layers,\\n agent_memories=agent.agent_states)\\n self.max_size = max_size\\n\\n #whether particular session has just been terminated and needs restarting\\n self.just_ended = [False] * len(self.envs)\",\n \"def _GetTrtGraph(self, gdef, precision_mode, is_dynamic_op):\\n return trt.create_inference_graph(\\n input_graph_def=gdef,\\n outputs=[OUTPUT_NAME],\\n max_batch_size=self._input.shape[0],\\n max_workspace_size_bytes=1 << 25,\\n precision_mode=precision_mode,\\n minimum_segment_size=2,\\n is_dynamic_op=is_dynamic_op)\",\n \"def initialize_session(self):\\r\\n self.logger.info(\\\"Initializing tf session\\\")\\r\\n self.sess = tf.Session()\\r\\n self.sess.run(tf.global_variables_initializer())\\r\\n self.saver = tf.train.Saver()\",\n \"def create_engine(self, input):\\n return\",\n \"def from_onnx(self, graph):\\n # parse network inputs, aka parameters\\n for init_tensor in graph.initializer:\\n if not init_tensor.name.strip():\\n raise ValueError(\\\"Tensor's name is required.\\\")\\n self._params[init_tensor.name] = self._parse_array(init_tensor)\\n\\n # converting GraphProto message\\n for i in graph.input:\\n if i.name in self._params:\\n # i is a param instead of input\\n name_param = 'param_{}'.format(self._num_param)\\n self._num_param += 1\\n self._params[name_param] = self._params.pop(i.name)\\n self._nodes[name_param] = mx.sym.Variable(name=name_param,\\n shape=self._params[name_param].shape)\\n self._renames[i.name] = name_param\\n else:\\n name_input = 'input_{}'.format(self._num_input)\\n self._num_input += 1\\n self._nodes[name_input] = mx.sym.Variable(name=name_input)\\n self._renames[i.name] = name_input\\n\\n # constructing nodes, nodes are stored as directed acyclic graph\\n # converting NodeProto message\\n for node in graph.node:\\n op_name = node.op_type\\n node_name = node.name.strip()\\n node_name = node_name if node_name else None\\n onnx_attr = self._parse_attr(node.attribute)\\n new_op, mx_attr = _convert_operator(op_name, onnx_attr)\\n inputs = [self._nodes[self._renames.get(i, i)] for i in node.input]\\n\\n # some workarounds for onnx problem\\n mx_attr = self._fix_bias(new_op, mx_attr, len(inputs))\\n mx_attr = self._fix_channels(new_op, mx_attr, list(node.input))\\n self._fix_bias_shape(node.op_type, node.input, onnx_attr)\\n\\n # calling again to get new symbols after some workarounds\\n inputs = [self._nodes[self._renames.get(i, i)] for i in node.input]\\n\\n # onnx's Gemm operator also supports broadcasting C input which\\n # mxnet's equivalent linalg_gemm doesn't. So using combination of\\n # transpose and FullyConnected operators.\\n if op_name == 'Gemm':\\n new_op, inputs, mx_attr = self._fix_gemm('FullyConnected', inputs, onnx_attr)\\n\\n # onnx slice works on multiple axes whereas mxnet's slice_axis is for single axis\\n if op_name == 'Slice':\\n op = self._fix_slice(inputs, mx_attr)\\n elif op_name == 'AveragePool' and onnx_attr.get('pads') is not None or \\\\\\n op_name == 'MaxPool' and onnx_attr.get('pads') is not None:\\n op = self._fix_pooling(op_name, inputs, onnx_attr)\\n elif op_name == 'Squeeze':\\n op = self._fix_squeeze(inputs, mx_attr)\\n else:\\n op = new_op(name=node_name, *inputs, **mx_attr)\\n\\n node_output = self._fix_outputs(op_name, node.output)\\n\\n assert len(node_output) == len(op.list_outputs()), (\\n \\\"Number of output mismatch {} vs {} in {}.\\\".format(\\n len(node_output), len(op.list_outputs()), op_name))\\n for k, i in zip(list(node_output), range(len(node_output))):\\n self._nodes[k] = op[i]\\n # now return the outputs\\n out = [self._nodes[i.name] for i in graph.output]\\n if len(out) > 1:\\n out = mx.sym.Group(out)\\n else:\\n out = out[0]\\n return out, self._params\",\n \"def __init__(self, sess, network, learning_rate=0.1, discount_factor=0.99):\\n self.sess = sess\\n self.learning_rate = learning_rate\\n self.discount_factor = discount_factor\\n self.network = network\\n self.defineUpdateOperations()\\n self.init = tf.global_variables_initializer()\\n self.initialize_variables()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64287347","0.63863736","0.6347452","0.5931692","0.5925455","0.58672893","0.5637707","0.5620587","0.5582713","0.55574703","0.550082","0.5489399","0.547671","0.54669124","0.5439374","0.54066926","0.5406201","0.53796494","0.5331371","0.5314776","0.5209954","0.52020407","0.51801413","0.5177638","0.51704043","0.5151103","0.5147202","0.51352847","0.5131458","0.51177883","0.5106465","0.5093686","0.5093392","0.5047511","0.50453454","0.501921","0.50154567","0.5002283","0.4989843","0.49894744","0.49872258","0.49788967","0.49523872","0.49505576","0.4948257","0.49313816","0.49310714","0.49308786","0.49202693","0.49183315","0.49183315","0.49183315","0.49126863","0.49012354","0.4897552","0.4894719","0.4893123","0.4883336","0.4863881","0.48573112","0.4844762","0.48255643","0.48249155","0.4814564","0.4808358","0.48083228","0.48046055","0.4802678","0.47931942","0.4791449","0.47911912","0.47861114","0.47856414","0.47780493","0.47660333","0.47639468","0.475864","0.47533977","0.47523388","0.47508302","0.474972","0.47450793","0.47433242","0.4742112","0.47362846","0.4731293","0.47290447","0.47276232","0.4723384","0.47204176","0.47201487","0.47193852","0.47042555","0.46972242","0.46946177","0.46892598","0.46881962","0.46817777","0.4681387","0.4678847"],"string":"[\n \"0.64287347\",\n \"0.63863736\",\n \"0.6347452\",\n \"0.5931692\",\n \"0.5925455\",\n \"0.58672893\",\n \"0.5637707\",\n \"0.5620587\",\n \"0.5582713\",\n \"0.55574703\",\n \"0.550082\",\n \"0.5489399\",\n \"0.547671\",\n \"0.54669124\",\n \"0.5439374\",\n \"0.54066926\",\n \"0.5406201\",\n \"0.53796494\",\n \"0.5331371\",\n \"0.5314776\",\n \"0.5209954\",\n \"0.52020407\",\n \"0.51801413\",\n \"0.5177638\",\n \"0.51704043\",\n \"0.5151103\",\n \"0.5147202\",\n \"0.51352847\",\n \"0.5131458\",\n \"0.51177883\",\n \"0.5106465\",\n \"0.5093686\",\n \"0.5093392\",\n \"0.5047511\",\n \"0.50453454\",\n \"0.501921\",\n \"0.50154567\",\n \"0.5002283\",\n \"0.4989843\",\n \"0.49894744\",\n \"0.49872258\",\n \"0.49788967\",\n \"0.49523872\",\n \"0.49505576\",\n \"0.4948257\",\n \"0.49313816\",\n \"0.49310714\",\n \"0.49308786\",\n \"0.49202693\",\n \"0.49183315\",\n \"0.49183315\",\n \"0.49183315\",\n \"0.49126863\",\n \"0.49012354\",\n \"0.4897552\",\n \"0.4894719\",\n \"0.4893123\",\n \"0.4883336\",\n \"0.4863881\",\n \"0.48573112\",\n \"0.4844762\",\n \"0.48255643\",\n \"0.48249155\",\n \"0.4814564\",\n \"0.4808358\",\n \"0.48083228\",\n \"0.48046055\",\n \"0.4802678\",\n \"0.47931942\",\n \"0.4791449\",\n \"0.47911912\",\n \"0.47861114\",\n \"0.47856414\",\n \"0.47780493\",\n \"0.47660333\",\n \"0.47639468\",\n \"0.475864\",\n \"0.47533977\",\n \"0.47523388\",\n \"0.47508302\",\n \"0.474972\",\n \"0.47450793\",\n \"0.47433242\",\n \"0.4742112\",\n \"0.47362846\",\n \"0.4731293\",\n \"0.47290447\",\n \"0.47276232\",\n \"0.4723384\",\n \"0.47204176\",\n \"0.47201487\",\n \"0.47193852\",\n \"0.47042555\",\n \"0.46972242\",\n \"0.46946177\",\n \"0.46892598\",\n \"0.46881962\",\n \"0.46817777\",\n \"0.4681387\",\n \"0.4678847\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82782066"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83784,"cells":{"query":{"kind":"string","value":"select input/output tensors of candidate nodes to calibrate."},"document":{"kind":"string","value":"def select_tensors_to_calibrate(self, model: ModelProto):\n value_infos = {vi.name: vi for vi in model.graph.value_info}\n value_infos.update({ot.name: ot for ot in model.graph.output})\n value_infos.update({it.name: it for it in model.graph.input})\n initializer = {init.name for init in model.graph.initializer}\n\n tensors_to_calibrate = set()\n tensor_type_to_calibrate = {TensorProto.FLOAT}\n\n for node in model.graph.node:\n if not self.op_types_to_calibrate or node.op_type in self.op_types_to_calibrate:\n for tensor_name in itertools.chain(node.input, node.output):\n if tensor_name in value_infos:\n vi = value_infos[tensor_name]\n if (\n vi.type.HasField(\"tensor_type\")\n and (vi.type.tensor_type.elem_type in tensor_type_to_calibrate)\n and (tensor_name not in initializer)\n ):\n tensors_to_calibrate.add(tensor_name)\n\n return tensors_to_calibrate, value_infos"},"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 learning_Utility(self):\n # Shape the input that we give to the neural network with the value of sensors, the previous actions the life of the agent \n # Get the results from the sensors according the different movement executed by the agent \n sensors_result_N = self.agent.sensors(self, direction=3) + self.agent.get_energy_coarsed()+\\\n self.agent.rotate_previousAction(3)+[self.agent.get_previous_collision()]\n sensors_result_O = self.agent.sensors(self, direction=2) + self.agent.get_energy_coarsed()+\\\n self.agent.rotate_previousAction(2) + [self.agent.get_previous_collision()]\n sensors_result_S = self.agent.sensors(self, direction=1) + self.agent.get_energy_coarsed()+\\\n self.agent.rotate_previousAction(1) + [self.agent.get_previous_collision()]\n sensors_result_E = self.agent.sensors(self, direction=0) + self.agent.get_energy_coarsed()+\\\n self.agent.rotate_previousAction(0) + [self.agent.get_previous_collision()]\n\n input_nn_N = np.asarray(sensors_result_N).astype(int) # input when the Nord action is performed \n input_nn_O = np.asarray(sensors_result_O).astype(int) # input when the West action is performed\n input_nn_S = np.asarray(sensors_result_S).astype(int) # input when the South action is performed\n input_nn_E = np.asarray(sensors_result_E).astype(int) # input when the West action is performed\n\n self.input_list = [input_nn_E.reshape(1,145),\n input_nn_S.reshape(1,145),\n input_nn_O.reshape(1,145),\n input_nn_N.reshape(1,145)]\n self.U_list = [self.nn.predict(i) for i in self.input_list ] #The utility according the different acts performed \n return self.actionSelector() #Select the action acording a propbabilitics distribution given in the paper","def _doCalibration(self):\n self._cmdCalibration(2)","def compute_data(self) -> TensorsData:\n\n if len(self.intermediate_outputs) == 0:\n return self.calibrate_tensors_range\n\n output_names = [self.infer_session.get_outputs()[i].name for i in range(len(self.intermediate_outputs[0]))]\n output_dicts_list = [\n dict(zip(output_names, intermediate_output)) for intermediate_output in self.intermediate_outputs\n ]\n\n merged_output_dict = {}\n for d in output_dicts_list:\n for k, v in d.items():\n merged_output_dict.setdefault(k, []).append(v)\n added_output_names = output_names[self.num_model_outputs :]\n calibrate_tensor_names = [\n added_output_names[i].rpartition(\"_\")[0] for i in range(0, len(added_output_names), 2)\n ] # output names\n\n merged_added_output_dict = {\n i: merged_output_dict[i] for i in merged_output_dict if i not in self.model_original_outputs\n }\n\n pairs = []\n for i in range(0, len(added_output_names), 2):\n min_value = 0\n max_value = 0\n if self.moving_average:\n min_value_array = np.mean(merged_added_output_dict[added_output_names[i]], axis=0)\n max_value_array = np.mean(merged_added_output_dict[added_output_names[i + 1]], axis=0)\n else:\n min_value_array = min(merged_added_output_dict[added_output_names[i]])\n max_value_array = max(merged_added_output_dict[added_output_names[i + 1]])\n if type(min_value_array) == int or min_value_array.size > 0:\n min_value = float(min_value_array)\n if type(max_value_array) == int or max_value_array.size > 0:\n max_value = float(max_value_array)\n\n if self.symmetric:\n max_absolute_value = max(abs(min_value), abs(max_value))\n pairs.append(tuple([-max_absolute_value, max_absolute_value]))\n else:\n pairs.append(tuple([min_value, max_value]))\n\n new_calibrate_tensors_range = TensorsData(CalibrationMethod.MinMax, dict(zip(calibrate_tensor_names, pairs)))\n if self.calibrate_tensors_range:\n self.calibrate_tensors_range = self.merge_range(self.calibrate_tensors_range, new_calibrate_tensors_range)\n else:\n self.calibrate_tensors_range = new_calibrate_tensors_range\n\n return self.calibrate_tensors_range","def _learn_node_parameter_w(outputs, inputs=None):\n num_inputs = 0 if inputs is None else inputs.shape[1]\n weights = np.zeros(shape=num_inputs + 1)\n\n \"\"\" YOUR CODE HERE \"\"\"\n # Ax = b, A\n N_observe = outputs.shape[0]\n A = np.zeros(shape = (num_inputs+1, num_inputs+1))\n for i in range(A.shape[0]):\n for j in range(A.shape[1]):\n if i==0 and j==0:\n A[i][j] = N_observe\n elif i==0 and j!=0:\n A[i][j] = np.sum(inputs[:,j-1])\n elif i!=0 and j==0:\n A[i][j] = np.sum(inputs[:,i-1])\n else:\n for k in range(N_observe):\n A[i][j] += inputs[k,i-1]*inputs[k, j-1]\n b = np.zeros(shape=num_inputs + 1)\n for i in range(len(b)):\n if i==0:\n b[i] = np.sum(outputs)\n else:\n for k in range(N_observe):\n b[i] += inputs[k,i-1]*outputs[k]\n\n weights = np.linalg.solve(A, b)\n \"\"\" END YOUR CODE HERE \"\"\"\n\n return weights","def __init__(self, in_channels, out_channels=None, kernel_size=None, stride=1, dilation=1, groups=1,\n rd_ratio=1./16, rd_channels=None, rd_divisor=8, keep_3x3=True, split_input=True,\n act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, aa_layer=None, drop_layer=None):\n super(SelectiveKernel, self).__init__()\n out_channels = out_channels or in_channels\n kernel_size = kernel_size or [3, 5] # default to one 3x3 and one 5x5 branch. 5x5 -> 3x3 + dilation\n _kernel_valid(kernel_size)\n if not isinstance(kernel_size, list):\n kernel_size = [kernel_size] * 2\n if keep_3x3:\n dilation = [dilation * (k - 1) // 2 for k in kernel_size]\n kernel_size = [3] * len(kernel_size)\n else:\n dilation = [dilation] * len(kernel_size)\n self.num_paths = len(kernel_size)\n self.in_channels = in_channels\n self.out_channels = out_channels\n self.split_input = split_input\n if self.split_input:\n assert in_channels % self.num_paths == 0\n in_channels = in_channels // self.num_paths\n groups = min(out_channels, groups)\n\n conv_kwargs = dict(\n stride=stride, groups=groups, act_layer=act_layer, norm_layer=norm_layer,\n aa_layer=aa_layer, drop_layer=drop_layer)\n self.paths = nn.ModuleList([\n ConvNormActAa(in_channels, out_channels, kernel_size=k, dilation=d, **conv_kwargs)\n for k, d in zip(kernel_size, dilation)])\n\n attn_channels = rd_channels or make_divisible(out_channels * rd_ratio, divisor=rd_divisor)\n self.attn = SelectiveKernelAttn(out_channels, self.num_paths, attn_channels)","def fit_select(rel_src_pos, node_pos, node_orients, outlier_percent, error):\n _, n_srcs, n_nodes = rel_src_pos.shape\n n_select = int((1 - outlier_percent) * n_srcs)\n devs = np.zeros((n_srcs, n_nodes, n_nodes - 1))\n rot_mats = dsm.rot_angle2rot_mat(node_orients)\n src_pos_candidates = np.einsum('abc, bdc -> adc', rot_mats, rel_src_pos)\n src_pos_candidates += np.expand_dims(node_pos, 1)\n for node_id in range(n_nodes):\n dev = (src_pos_candidates[:, :, node_id, None]\n - np.delete(src_pos_candidates[:, :], node_id, axis=-1))\n devs[:, node_id] = np.linalg.norm(dev, axis=0)\n dist2neighbors = np.mean(devs, -1)\n return np.argsort(error + dist2neighbors, axis=0)[:n_select]","def candidate(self, input_r_state, ctrl):\n kernel = tf.get_variable(\n 'kernel', [self._concat_size, self._num_units, self._num_modules])\n bias = tf.get_variable(\n 'bias', [1, self._num_units, self._num_modules],\n initializer=tf.zeros_initializer())\n\n square_kernel = tf.reshape(kernel, [self._concat_size, -1])\n multiplied = tf.reshape(tf.matmul(input_r_state, square_kernel),\n [-1, self._num_units, self._num_modules])\n\n all_outputs = self._activation(multiplied + bias)\n scaled_outputs = tf.matmul(all_outputs, tf.expand_dims(ctrl, axis=-1))\n return tf.squeeze(scaled_outputs, axis=-1)","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def optimize(opt):\n # load new target\n if opt.is_poly:\n target_mesh = om.read_polymesh(opt.model)\n else:\n target_mesh = om.read_trimesh(opt.model)\n target_shape_arr = target_mesh.points()\n target_shape = target_shape_arr.copy()\n target_shape = torch.from_numpy(\n target_shape[:, :3].astype(np.float32)).cuda()\n target_shape.unsqueeze_(0)\n\n target_faces_arr = target_mesh.face_vertex_indices()\n target_faces = target_faces_arr.copy()\n target_faces = torch.from_numpy(\n target_faces[:, :3].astype(np.int64)).cuda()\n target_faces.unsqueeze_(0)\n\n states = torch.load(opt.ckpt)\n if \"states\" in states:\n states = states[\"states\"]\n cage_v = states[\"template_vertices\"].transpose(1, 2).cuda()\n cage_f = states[\"template_faces\"].cuda()\n shape_v = states[\"source_vertices\"].transpose(1, 2).cuda()\n shape_f = states[\"source_faces\"].cuda()\n\n if os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")) and os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")):\n new_label_path = opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")\n logger.info(\"Loading picked labels {} and {}\".format(orig_label_path, new_label_path))\n new_label = pd.read_csv(new_label_path, delimiter=\" \",skiprows=1, header=None)\n orig_label = pd.read_csv(orig_label_path, delimiter=\" \",skiprows=1, header=None)\n orig_label_name = orig_label.iloc[:,5]\n new_label_name = new_label.iloc[:,5].tolist()\n new_to_orig_idx = []\n for i, name in enumerate(new_label_name):\n matched_idx = orig_label_name[orig_label_name==name].index\n if matched_idx.size == 1:\n new_to_orig_idx.append((i, matched_idx[0]))\n new_to_orig_idx = np.array(new_to_orig_idx)\n if new_label.shape[1] == 10:\n new_vidx = new_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,0]]\n target_points = target_shape[:, new_vidx, :]\n else:\n new_label_points = torch.from_numpy(new_label.iloc[:,6:9].to_numpy().astype(np.float32))\n target_points = new_label_points.unsqueeze(0).cuda()\n target_points, new_vidx, _ = faiss_knn(1, target_points, target_shape, NCHW=False)\n target_points = target_points.squeeze(2) # B,N,3\n new_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\n new_label.to_csv(new_label_path, sep=\" \", header=[str(new_label.shape[0])]+[\"\"]*(new_label.shape[1]-1), index=False)\n target_points = target_points[:, new_to_orig_idx[:,0], :]\n\n target_points = target_points.cuda()\n source_shape, _ = read_trimesh(opt.source_model)\n source_shape = torch.from_numpy(source_shape[None, :,:3]).float()\n if orig_label.shape[1] == 10:\n orig_vidx = orig_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,1]]\n source_points = source_shape[:, orig_vidx, :]\n else:\n orig_label_points = torch.from_numpy(orig_label.iloc[:,6:9].to_numpy().astype(np.float32))\n source_points = orig_label_points.unsqueeze(0)\n # find the closest point on the original meshes\n source_points, new_vidx, _ = faiss_knn(1, source_points, source_shape, NCHW=False)\n source_points = source_points.squeeze(2) # B,N,3\n orig_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\n orig_label.to_csv(orig_label_path, sep=\" \", header=[str(orig_label.shape[0])]+[\"\"]*(orig_label.shape[1]-1), index=False)\n source_points = source_points[:,new_to_orig_idx[:,1],:]\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n source_points = source_points.cuda()\n # # shift target so that the belly match\n # try:\n # orig_bellyUp_idx = orig_label_name[orig_label_name==\"bellUp\"].index[0]\n # orig_bellyUp = orig_label_points[orig_bellyUp_idx, :]\n # new_bellyUp_idx = [i for i, i2 in new_to_orig_idx if i2==orig_bellyUp_idx][0]\n # new_bellyUp = new_label_points[new_bellyUp_idx,:]\n # target_points += (orig_bellyUp - new_bellyUp)\n # except Exception as e:\n # logger.warn(\"Couldn\\'t match belly to belly\")\n # traceback.print_exc(file=sys.stdout)\n\n # source_points[0] = center_bounding_box(source_points[0])[0]\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")) and \\\n os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")):\n logger.info(\"Could not find {}. Assuming SMPL model\".format(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")))\n source_shape, source_faces = read_trimesh(opt.source_model)\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\n \"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\".format(\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \".picked\"))\n # align faces not vertices\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")\n logger.info(\"Loading picked labels {}\".format(orig_label_path))\n orig_label = pd.read_csv(orig_label_path, delimiter=\" \",skiprows=1, header=None)\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\n idx = torch.from_numpy(orig_label.iloc[:,1].to_numpy()).long()\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, source_faces[:, idx, :, None].expand(-1, -1, -1, 3))\n source_points = source_points.mean(dim=-2)\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, target_faces[:, idx, :, None].expand(-1, -1, -1, 3))\n target_points = target_points.mean(dim=-2)\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")):\n logger.info(\"Could not find {}. Assuming SMPL model\".format(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")))\n source_shape, source_faces = read_trimesh(opt.source_model)\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\n \"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\".format(\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \".picked\"))\n source_shape, source_faces = read_trimesh(opt.source_model)\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\n # select a subset of faces, otherwise optimization is too slow\n idx = torch.from_numpy(np.random.permutation(2048)).cuda().long()\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, source_faces[:, idx,:, None].expand(-1, -1, -1, 3))\n source_points = source_points.mean(dim=-2)\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, target_faces[:,idx,: None].expand(-1, -1, -1, 3))\n target_points = target_points.mean(dim=-2)\n\n\n target_points = target_points[:, idx]\n source_points = source_points[:, idx]\n\n\n target_shape[0], target_center, target_scale = center_bounding_box(target_shape[0])\n _, _, source_scale = center_bounding_box(shape_v[0])\n # scale according y axis (body height)\n target_scale_factor = (source_scale/target_scale)[0,1]\n target_shape *= target_scale_factor\n target_points -= target_center\n target_points = (target_points*target_scale_factor).detach()\n # make sure test use the normalized\n target_shape_arr[:] = target_shape[0].cpu().numpy()\n om.write_mesh(os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\n os.path.basename(opt.model))[0]+\"_normalized.obj\"), target_mesh)\n opt.model = os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\n os.path.basename(opt.model))[0]+\"_normalized.obj\")\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \"template-initial.obj\"),\n shape_v[0].cpu().numpy(), shape_f[0].cpu().numpy())\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \"cage-initial.obj\"),\n cage_v[0].cpu().numpy(), cage_f[0].cpu().numpy())\n save_ply(target_points[0].cpu().numpy(), os.path.join(\n opt.log_dir, opt.subdir, \"target_points.ply\"))\n save_ply(source_points[0].cpu().numpy(), os.path.join(\n opt.log_dir, opt.subdir, \"source_points.ply\"))\n logger.info(\"Optimizing for {} corresponding vertices\".format(\n target_points.shape[1]))\n\n cage_init = cage_v.clone().detach()\n lap_loss = MeshLaplacianLoss(torch.nn.MSELoss(reduction=\"none\"), use_cot=True,\n use_norm=True, consistent_topology=True, precompute_L=True)\n mvc_reg_loss = MVCRegularizer(threshold=50, beta=1.0, alpha=0.0)\n cage_v.requires_grad_(True)\n optimizer = torch.optim.Adam([cage_v], lr=opt.lr, betas=(0.5, 0.9))\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer, int(opt.nepochs*0.4), gamma=0.5, last_epoch=-1)\n\n if opt.dim == 3:\n weights_ref = mean_value_coordinates_3D(\n source_points, cage_init, cage_f, verbose=False)\n else:\n raise NotImplementedError\n\n for t in range(opt.nepochs):\n optimizer.zero_grad()\n weights = mean_value_coordinates_3D(\n target_points, cage_v, cage_f, verbose=False)\n loss_mvc = torch.mean((weights-weights_ref)**2)\n # reg = torch.sum((cage_init-cage_v)**2, dim=-1)*1e-4\n reg = torch.tensor(0.0).cuda()\n if opt.clap_weight > 0:\n reg = lap_loss(cage_init, cage_v, face=cage_f)*opt.clap_weight\n reg = reg.mean()\n if opt.mvc_weight > 0:\n reg += mvc_reg_loss(weights)*opt.mvc_weight\n\n loss = loss_mvc + reg\n if (t+1) % 50 == 0:\n print(\"t {}/{} mvc_loss: {} reg: {}\".format(t, opt.nepochs, loss_mvc.item(), reg.item()))\n\n if loss_mvc.item() < 5e-6:\n break\n loss.backward()\n optimizer.step()\n scheduler.step()\n\n return cage_v, cage_f","def _reset_parameters(self):\n self._solver_input[\"P\"] = cvxopt.matrix(2.0 * self.opt.P(self.p).toarray())\n self._solver_input[\"q\"] = cvxopt.matrix(self.opt.q(self.p).toarray().flatten())\n if self.opt_type in CONSTRAINED_OPT:\n if self.opt.nk > 0:\n self._solver_input[\"G\"] = cvxopt.matrix(-self.opt.M(self.p).toarray())\n self._solver_input[\"h\"] = cvxopt.matrix(\n self.opt.c(self.p).toarray().flatten()\n )\n if self.opt.na > 0:\n self._solver_input[\"A\"] = cvxopt.matrix(self.opt.A(self.p).toarray())\n self._solver_input[\"b\"] = cvxopt.matrix(-self.opt.b(self.p).toarray())","def cfdProcessNodeTopology(self):\r\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\r\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)","def setupConnections(self):\n self.T1Button.connect('clicked(bool)', self.onApplyButton)\n self.RViewButton.connect('clicked(bool)', self.onApplyRViewButton)\n self.CheckButton.connect('stateChanged(int)', self.onCheckbuttonChecked)\n self.LLE_Selector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.onSelectLLENode)\n self.LLN_Selector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.onSelectLLNNode)\n self.Aref_Selector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.onSelectArefNode)\n\n self.ThSlider_LLE.Slider.connect(\"positionsChanged(double,double)\",self.ThSlider_LLE.onSliderChanged)\n self.ThSlider_LLE.SpinBoxL.connect(\"valueChanged(int)\", self.ThSlider_LLE.onSpinBoxLChanged)\n self.ThSlider_LLE.SpinBoxR.connect(\"valueChanged(int)\", self.ThSlider_LLE.onSpinBoxRChanged)\n \n self.ThSlider_LLN.Slider.connect(\"positionsChanged(double,double)\",self.ThSlider_LLN.onSliderChanged)\n self.ThSlider_LLN.SpinBoxL.connect(\"valueChanged(int)\", self.ThSlider_LLN.onSpinBoxLChanged)\n self.ThSlider_LLN.SpinBoxR.connect(\"valueChanged(int)\", self.ThSlider_LLN.onSpinBoxRChanged) \n\n self.ThSlider_ECV.Slider.connect(\"positionsChanged(double,double)\",self.ThSlider_ECV.onSliderChanged)\n self.ThSlider_ECV.SpinBoxL.connect(\"valueChanged(int)\", self.ThSlider_ECV.onSpinBoxLChanged)\n self.ThSlider_ECV.SpinBoxR.connect(\"valueChanged(int)\", self.ThSlider_ECV.onSpinBoxRChanged)\n \n self.Stats.segmentationSelector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.Stats.onScalarSelectorChanged)\n self.Stats.scalarSelector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.Stats.onScalarSelectorChanged)\n self.Stats.scalarSelector2.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.Stats.onScalarSelector2Changed)\n self.Stats.SButton.connect('clicked(bool)', self.onApplyGetStatistics)\n\n self.NativeT1_Selector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.onSelectNT1Node)\n self.EnhancedT1_Selector.connect(\"currentNodeChanged(vtkMRMLNode*)\", self.onSelectET1Node)\n self.SB_NBlodd.connect(\"valueChanged(Double)\", self.onSpinBoxNBChanged)\n self.SB_EBlodd.connect(\"valueChanged(Double)\", self.onSpinBoxEBChanged)\n self.SB_Haematocrit.connect(\"valueChanged(Double)\", self.onSpinBoxHChanged)\n self.ECVButton.connect('clicked(bool)',self.onApplyECVButton)","def feature_selection(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\n\t# percentile selector\n\tpercentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask = best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\t# model based selector\n\tmodel_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask = best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\t# iterative based selector\n\titerative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask = best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\tall_scores = []\n\n\tregressor.fit(train_features, train_similarity_target)\n\tprint(\"The score on all features: %.3f\" % regressor.score(test_features, test_similarity_target))\n\tall_scores.append(regressor.score(test_features, test_similarity_target))\n\n\t# show results for the percentile selector\n\tall_scores.append(percentile_score)\n\n\t# show results for the model based selector\n\tall_scores.append(model_based_score)\n\n\t# show results for the iterative based selector\n\tall_scores.append(iterative_based_score)\n\n\tmax_value_position = all_scores.index(max(all_scores))\n\n\tif max_value_position == 0:\n\t\tprint(\"Returning all features!\\n\")\n\t\treturn train_features, test_features\n\telif max_value_position == 1:\n\t\tpercentile_mask = build_mask(percentile_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'percentile_mask.txt')\n\t\tdebug_data(percentile_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the percentile selector!\\n\")\n\t\treturn percentile_selector, percentile_train_features_selected, percentile_test_features_selected\n\telif max_value_position == 2:\n\t\tmodel_based_mask = build_mask(model_based_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'model_based_mask.txt')\n\t\tdebug_data(model_based_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the model based selector!\\n\")\n\t\treturn model_based_selector, model_based_train_features_selected, model_based_test_features_selected\n\telse:\n\t\titerative_based_mask = build_mask(iterative_based_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'iterative_based_mask.txt')\n\t\tdebug_data(iterative_based_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the iterative based selector!\\n\")\n\t\treturn iterative_based_selector, iterative_based_train_features_selected, iterative_based_test_features_selected","def __initilization(self,node_set):\n \n print \"*********************************\"\n \n for x in node_set:\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\n \n print \"Forward/Backward Algorithm Initialization Done!\"","def _learn_node_parameter_var(outputs, weights, inputs):\n var = 0.\n\n \"\"\" YOUR CODE HERE \"\"\"\n temp = 0\n N_observe = outputs.shape[0]\n if inputs is None:\n temp = np.sum((outputs-weights[0])**2)\n else:\n for i in range(N_observe):\n temp += (outputs[i] - (np.sum(weights[1:] * inputs[i]) +weights[0]))**2\n var = temp/N_observe\n\n\n\n \"\"\" END YOUR CODE HERE \"\"\"\n\n return var","def switch_to_tuned_inputs(self):\n \n self.h_e=self.inputs_flat.T\n self.h=np.vstack([self.h_e,self.h_i])","def input_nodes(self):\n pass","def __init__(self, channels, num_paths=2, attn_channels=32, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d):\n super(SelectiveKernelAttn, self).__init__()\n self.num_paths = num_paths\n self.fc_reduce = nn.Conv2d(channels, attn_channels, kernel_size=1, bias=False)\n self.bn = norm_layer(attn_channels)\n self.act = act_layer(inplace=True)\n self.fc_select = nn.Conv2d(attn_channels, channels * num_paths, kernel_size=1, bias=False)","def call(self, inputs, **kwargs):\n inputs_expanded = K.expand_dims(inputs, axis=1)\n #print('inputs_expanded', inputs_expanded.shape)\n #print('robust_mean', self.robust_mean.shape)\n\n x_minus_mu = inputs_expanded - self.robust_mean\n #print('x_minus_mu', x_minus_mu.shape)\n\n left_term = list()\n for i in range(self.n_clusters):\n x = x_minus_mu[:, i, :]\n left = K.dot(x, self.inv_covmat[i])\n left = K.expand_dims(left, axis=1)\n if len(left_term) == 0:\n left_term = left\n else:\n #left_term = K.stack([left_term, left], axis=1)\n left_term = K.concatenate([left_term, left], axis=1)\n\n #print('inv_covmat', self.inv_covmat.shape)\n #print('left_term', left_term.shape)\n\n left_term_T = K.permute_dimensions(left_term, (1, 0, 2))\n x_minus_mu_T = K.permute_dimensions(x_minus_mu, (1, 0, 2))\n #print('x_minus_mu_T', x_minus_mu_T.shape)\n #print('left_term_T', left_term_T.shape)\n\n mahal = K.batch_dot(left_term_T, x_minus_mu_T, axes=[2, 2])\n #print('mahal', mahal.shape)\n\n mahal_diagonal = list()\n for i in range(self.n_clusters):\n m = mahal[i, :, :]\n diagonal = tf.linalg.tensor_diag_part(m)\n diagonal = K.expand_dims(diagonal, axis=1)\n\n if len(mahal_diagonal) == 0:\n mahal_diagonal = diagonal\n else:\n #mahal_diagonal = K.stack([mahal_diagonal, diagonal], axis=1)\n mahal_diagonal = K.concatenate(\n [mahal_diagonal, diagonal], axis=1)\n\n #print('mahal_diagonal', mahal_diagonal.shape)\n\n md = K.sqrt(mahal_diagonal)\n #print('md', md.shape)\n\n divide_alpha = md / self.alpha\n\n # the numnerator in q_ịj formular in the paper\n numerator = 1.0 / (1.0 + divide_alpha)\n numerator **= (self.alpha + 1.0) / 2.0\n\n denominator = K.sum(numerator, axis=1)\n\n quiu = K.transpose(numerator) / denominator\n quiu = K.transpose(quiu)\n\n #print('quiu', quiu.shape)\n\n return quiu","def select_features(self):\n print 'tuning alpha'\n hyper_params_model = lm.LassoCV(normalize=True, n_jobs=-1).fit(\n self.data.loc[self.train_index, self.features_], self.data.loc[self.train_index, self.target_name])\n print 'alpha is: {}'.format(hyper_params_model.alpha_)\n print 'fitting lasso to get coefficients'\n model = lm.Lasso(alpha=hyper_params_model.alpha_, normalize=True)\n model.fit(self.data.loc[self.train_index, self.features_],\n self.data.loc[self.train_index, self.target_name])\n with open('lasso_coefficients.txt', 'w') as f:\n for coef, feature in sorted(zip(model.coef_, self.features_)):\n f.write('{} : {}\\n'.format(feature, coef))\n if coef not in [-0.0, 0.0]:\n self.selected_features_.append(feature)","def selectOptimalExposureCallback(self):\n rospy.loginfo('Starting automatic exposure selection algorithm')\n\n # Start searching for the optimal exposure\n best_exp_pass1 = self.runPass(range(100, 27100, 3000), rate=self.rate)\n # first pass, find coarse exposure\n if best_exp_pass1 > 0:\n rospy.loginfo('First pass: success!')\n rospy.loginfo(\n 'Best exposure in first pass: {}'.format(best_exp_pass1))\n\n # second pass, refine the exposure\n exp_range = [int(exp) for exp in np.linspace(\n 0.9*best_exp_pass1, 1.1*best_exp_pass1, 10)]\n best_exp_pass2 = self.runPass(exp_range, rate=self.rate)\n\n if best_exp_pass2 > 0:\n rospy.loginfo('Second pass: success!')\n rospy.loginfo(\n 'Best exposure in second pass: {}'.format(best_exp_pass2))\n optimal_exposure = best_exp_pass2\n else:\n rospy.logerr(\n 'Second pass: failure\\nSetting the best exposure found in first pass')\n optimal_exposure = best_exp_pass1\n\n self.client.update_configuration({\"exposure\": optimal_exposure})\n self.reset()\n\n else:\n rospy.logerr(\n 'First pass: failure\\nCould not auto-set the exposure')","def solve(self):\n\t\t# row and column to control the selected corner\n\t\tcurrent_positions = [0, 0]\n\t\tmax_row = self.result_index[self.__ROW_INDEX]-1\n\t\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\n\t\twhile self.matrix[max_row][max_col] != 0:\n\t\t\tcurrent_row = current_positions[self.__ROW_INDEX]\n\t\t\tcurrent_column = current_positions[self.__COLUMN_INDEX]\n\t\t\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\n\t\t\tactual_weight = self.matrix[current_row][current_column]\n\t\t\tactual_result_weight = multiplier_selected[1]\n\t\t\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\n\t\t\tself.matrix[max_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[current_row][max_col] -= actual_result_weight\n\t\t\tself.matrix[max_row][current_column] -= actual_result_weight\n\t\t\tcurrent_positions[multiplier_selected[0]] += 1","def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\n\n width = imgs.shape[-2]\n height = imgs.shape[-1]\n num_img = imgs.shape[0]\n\n # Compute valid scales\n scales = []\n cur_width = width\n cur_height = height\n cur_factor = 1\n while cur_width >= 12 and cur_height >= 12:\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\n\n w = cur_width\n h = cur_height\n scales.append((w, h, cur_factor))\n\n cur_factor *= factor\n cur_width = math.ceil(cur_width * factor)\n cur_height = math.ceil(cur_height * factor)\n\n # Get candidate boxesi ph\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n candidate_scores = torch.empty(0, device=self.device)\n candidate_offsets = torch.empty(\n 0, dtype=torch.float32, device=self.device)\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for w, h, f in scales:\n resize_img = torch.nn.functional.interpolate(\n imgs, size=(w, h), mode='bilinear')\n p_distribution, box_regs, _ = self.pnet(resize_img)\n\n candidate, scores, offsets, img_labels = self._generate_bboxes(\n p_distribution, box_regs, f, threshold)\n\n candidate_boxes = torch.cat([candidate_boxes, candidate])\n candidate_scores = torch.cat([candidate_scores, scores])\n candidate_offsets = torch.cat([candidate_offsets, offsets])\n all_img_labels = torch.cat([all_img_labels, img_labels])\n\n \n if candidate_boxes.shape[0] != 0:\n candidate_boxes = self._calibrate_box(\n candidate_boxes, candidate_offsets)\n candidate_boxes = self._convert_to_square(candidate_boxes)\n candidate_boxes = self._refine_boxes(\n candidate_boxes, width, height)\n \n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\n for i in range(num_img):\n mask = all_img_labels == i\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\n candidate_scores[mask].cpu().numpy(), nms_threshold)\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\n\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\n else:\n return candidate_boxes","def training_batch_selection(train_set_size, input_img):\n\n input_dims = input_img.shape\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\n all_data_indices = all_data_indices.reshape(input_dims[:-1])\n\n conf = get_config()\n inside = int(np.floor(conf[\"inside_part\"]))\n outside = int(np.floor(conf[\"outside_part\"]))\n cx = ii.image.c_x\n cy = ii.image.c_y\n\n # Find the position of the crop in the image and determine part least affected by radial distortion\n center_x = (conf[\"crop\"][\"left_top\"]['x'] + conf[\"crop\"][\"size\"][\"height\"]/2)*2/ii.image.height-1.\n center_y = (conf[\"crop\"][\"left_top\"]['y'] + conf[\"crop\"][\"size\"][\"width\"]/2)*2/ii.image.width-1.\n\n left_right_center = max(min((center_y-cy)*2, 1), -1)\n top_bot_center = max(min((center_x - cx) * 2, 1), -1)\n\n # DEBUG: set your own center\n # left_right_center = 0\n # top_bot_center = 0\n\n from_x = int(round(inside*(1.-top_bot_center)))\n to_x = min(-int(round(inside*(1.+top_bot_center))), -1)\n from_y = int(round(inside*(1.-left_right_center)))\n to_y = min(-int(round(inside*(1.+left_right_center))), -1)\n\n # Exclude part that is minimally affected by radial distortion\n selection_exclude = all_data_indices[from_x:to_x, from_y:to_y]\n selection_exclude = selection_exclude.reshape(-1)\n\n # Exclude outer border in order to avoid index out of bounds\n selection_include = all_data_indices[outside:-outside,\n outside:-outside]\n selection_include = selection_include.reshape(-1)\n\n selection = [x for x in selection_include if x not in selection_exclude]\n selection = np.random.permutation(selection)\n\n # DEBUG: forcing larger training set\n train_set_size = int(train_set_size*2)\n\n selection = selection[:train_set_size]\n\n # DEBUG: display image region for selection\n image = input_img.reshape(-1)\n image[:] = 0\n image[selection_include] = input_img.reshape(-1)[selection_include]\n image[selection_exclude] = 0\n image = image.reshape(input_dims[0], input_dims[1])\n Verbose.imshow(image, Verbose.debug)\n\n return selection","def _prepare_input(\n self, data: Union[Dict[str, torch.Tensor], torch.Tensor, np.ndarray]\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n\n # convert ot dict\n if isinstance(data, torch.Tensor):\n p4 = data\n data = dict()\n data[\"p4\"] = p4\n elif isinstance(data, np.ndarray):\n p4 = torch.from_numpy(data)\n data = dict()\n data[\"p4\"] = p4\n\n node_ps = data[\"p4\"].to(device=self.device, dtype=self.dtype) * self.scale\n if self.jet_features:\n jet_p = torch.sum(node_ps, dim=-2).unsqueeze(-2)\n node_ps = torch.cat((node_ps, jet_p), dim=-2)\n\n scalars = normsq4(node_ps).abs().sqrt().unsqueeze(-1)\n if self.jet_features:\n jet_mass = (\n normsq4(torch.sum(node_ps, dim=-2))\n .unsqueeze(-1)\n .unsqueeze(-1)\n .repeat(1, self.num_input_particles, 1)\n )\n scalars = torch.cat((scalars, jet_mass), dim=-1)\n\n # Calculate node masks and edge masks\n if \"labels\" in data:\n node_mask = data[\"labels\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n elif \"masks\" in data:\n node_mask = data[\"masks\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n elif \"mask\" in data:\n node_mask = data[\"mask\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n else:\n node_mask = data[\"p4\"][..., 0] != 0\n node_mask = node_mask.to(device=self.device, dtype=torch.uint8)\n if self.jet_features:\n jet_mask = torch.ones_like(node_mask[..., 0:1])\n jet_mask = jet_mask.to(device=self.device, dtype=torch.uint8)\n node_mask = torch.cat((node_mask, jet_mask), dim=-1)\n edge_mask = node_mask.unsqueeze(1) * node_mask.unsqueeze(2)\n\n if \"scalars\" in data.keys():\n # (0,0) representation\n scalars = torch.cat(\n [scalars, data[\"scalars\"].to(device=self.device, dtype=self.dtype)],\n dim=-1,\n )\n\n return scalars, node_ps, node_mask, edge_mask","def best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\n\tmodel_based_score = 0\n\tscaling_factors = [\"0.25*mean\", \"0.5*mean\", \"median\", \"1.25*mean\", \"1.5*mean\"]\n\t# scaling_factors = [\"0.5*mean\", \"median\"]\n\tmodel_based_selector = None\n\tmodel_based_train_features_selected = None\n\tmodel_based_test_features_selected = None\n\n\tfor factor in scaling_factors:\n\t\tprint(factor)\n\t\ttemp_model_based_selector = SelectFromModel(RandomForestRegressor(n_estimators=100), threshold=factor)\n\t\ttemp_model_based_selector.fit(train_features, train_similarity_target)\n\t\ttemp_model_based_train_features_selected = temp_model_based_selector.transform(train_features)\n\t\ttemp_model_based_test_features_selected = temp_model_based_selector.transform(test_features)\n\n\t\tregressor.fit(temp_model_based_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_model_based_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Model Based Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > model_based_score:\n\t\t\tmodel_based_score = temp_score\n\t\t\tmodel_based_selector = temp_model_based_selector\n\t\t\tmodel_based_train_features_selected = temp_model_based_train_features_selected\n\t\t\tmodel_based_test_features_selected = temp_model_based_test_features_selected\n\n\tmodel_based_mask = model_based_selector.get_support()\n\tprint(\"This is the model based mask: \")\n\tprint(model_based_mask)\n\n\treturn model_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask","def __call__(self, inputs: np.ndarray):\n # Denote the impact the inputs have directly on the outputs\n output_inputs: np.ndarray = np.matmul(self.in2out, inputs.transpose()).transpose()\n \n # Denote the impact hidden nodes have on the outputs, if there are hidden nodes\n if self.n_hidden > 0:\n # Nice to know:\n # - np.transpose() will transpose the tensor\n # - np.matmul(tensor1, tensor2) will perform a matrix multiplication between tensor and tensor2\n \n # The activation is defined by:\n # - the inputs mapping to the hidden nodes\n # - the hidden nodes mapping to themselves\n # - the hidden nodes' biases\n \n # 1) Propagate the hidden nodes\n self.hidden_act = self.act_f(np.matmul(self.in2hid, inputs.transpose()).transpose() +\n np.matmul(self.hid2hid, self.hidden_act.transpose()).transpose() +\n self.hidden_biases)\n \n # 2) Execute the RNN nodes if they exists (updating current hidden state)\n for i, rnn_idx in enumerate(self.rnn_idx):\n self.rnn_state[:, i] = self.rnn_array[i](\n np.concatenate((self.in2hid[rnn_idx] * inputs,\n self.hid2hid[rnn_idx] * self.hidden_act),\n axis=1)[self.rnn_map[i]].reshape(self.bs, self.rnn_array[i].input_size)\n )\n self.hidden_act[:, rnn_idx] = self.rnn_state[:, i, 0]\n \n # 3) Propagate hidden-values to the outputs\n output_inputs += np.matmul(self.hid2out, self.hidden_act.transpose()).transpose()\n \n # Define the values of the outputs, which is the sum of their received inputs and their corresponding bias\n self.output_act = self.act_f(output_inputs + self.output_biases)\n return self.output_act","def calibrate(self, x, y) -> None:\n pass","def reset_parameters(self) -> None:\n \n self.classifier.apply(xavier)\n if len(self.old_cols) > 0:\n self.adaptor1.apply(xavier)\n self.adaptor2.apply(xavier)","def train_models_change_nodes(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, beta, nodes, print_cost = True, is_charge = False):\n \n results = {}\n params = {}\n\n try:\n for n in nodes:\n accs, parameters = model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, n, beta, 1.0, False, True, print_cost, is_charge)\n \n results[n] = accs[3]\n params[n] = parameters\n \n except KeyboardInterrupt: # allow for exiting the for loop in case we want to stop testing all the hyperparameters; to use, press Ctrl+C in terminal\n pass\n \n best = min(results, key=results.get)\n mapes = [results[l] for l in nodes]\n\n if print_cost:\n plt.plot(nodes, mapes)\n plt.ylabel('MAPE')\n plt.xlabel('# of nodes in hidden layer')\n plt.title(\"learning rate = {}, mini-batch = {}, beta = {}\".format(learning_rate, minibatch_size, beta))\n plt.show()\n \n return results, best, params[best]","def torch_NN(nn_in, \n nn_out, \n min_ar, \n max_ar, \n er_tar,\n main_win: tk.Toplevel, \n min_n=0, \n max_n=0, \n n_epochs=200, \n conf=[1,1,1], \n funs=[tr.nn.Sigmoid(), 0], \n lr=0.001, \n sect_ner=False, \n train_test=False, \n retrain=False, \n spl_coef=0.1,\n root_width=200, \n root_height=200, \n root_x=50, \n root_y=50):\n tr.manual_seed(42)\n in_orig=tr.from_numpy(np.array(nn_in.copy())).float()\n out_orig=tr.from_numpy(np.array(nn_out.copy())).float()\n if train_test or retrain:\n nn_in=tr.from_numpy(np.array(nn_in)).float()\n nn_out=tr.from_numpy(np.array(nn_out)).float()\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\n a=int(len(dataset)*(1-spl_coef))\n data_trn, data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\n else:\n nn_in=tr.from_numpy(np.array(nn_in)).float()\n nn_out=tr.from_numpy(np.array(nn_out)).float()\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\n dataloader = tr.utils.data.DataLoader(dataset, shuffle=False, batch_size=len(dataset))\n data_test = 0\n if sect_ner:\n for i in range(len(conf)-2):\n conf[i+1] = min_n\n for i in range(1, len(conf)-1):\n min_loss=200000\n b=conf[i]\n for j in range(min_n, max_n+1):\n conf[i]=j\n nn_obj = Net_tr(conf, funs)\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\n y_pred = nn_obj.forward(nn_in)\n loss_val = loss(y_pred, nn_out, nn_obj)\n a=loss_val.item()\n print(\"Current configuration:\", conf, \";\\t Loss:\", a, \"%\")\n loss_val.backward()\n optimizer.step()\n if a<min_loss:\n min_loss=a\n b=j\n conf[i]=b\n neurons_number_info(conf, root_height + root_y, root_x)\n print(\"Best configuration:\", conf)\n nn_obj = Net_tr(conf, funs)\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\n loss_test=[]\n loss_tr=[]\n epochs_sum = 0\n train = True\n lin_tr = None\n can_tr = None\n lin_test = None \n can_test = None\n vert_coef = None\n hor_coef = None\n while train == True:\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_torch(nn_obj, dataloader, data_test, n_epochs, epochs_sum, optimizer, loss_tr, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\n train_win = Continue_Train(err, epochs_sum)\n main_win.wait_window(train_win)\n train = train_win.answer\n if not train_win.answer:\n return nn_obj, conf, vert_coef, hor_coef\n #train = False\n nn_obj.eval()\n return nn_obj, conf, vert_coef, hor_coef","def target_tensors(self):\n return None","def before_train(self, logs=None):\n self.config = self.trainer.config\n self.unrolled = self.trainer.config.unrolled\n self.device = self.trainer.config.device\n self.model = self.trainer.model\n self.optimizer = self.trainer.optimizer\n self.lr_scheduler = self.trainer.lr_scheduler\n self.loss = self.trainer.loss\n self.search_alg = SearchAlgorithm(SearchSpace())\n self._set_algorithm_model(self.model)\n self.trainer.train_loader = self.trainer._init_dataloader(mode='train')\n self.trainer.valid_loader = self.trainer._init_dataloader(mode='val')\n normal_selected_idxs = torch.tensor(len(self.model.alphas_normal) * [-1],\n requires_grad=False, dtype=torch.int).cuda()\n reduce_selected_idxs = torch.tensor(len(self.model.alphas_reduce) * [-1],\n requires_grad=False, dtype=torch.int).cuda()\n normal_candidate_flags = torch.tensor(len(self.model.alphas_normal) * [True],\n requires_grad=False, dtype=torch.bool).cuda()\n reduce_candidate_flags = torch.tensor(len(self.model.alphas_reduce) * [True],\n requires_grad=False, dtype=torch.bool).cuda()\n logging.info('normal_selected_idxs: {}'.format(normal_selected_idxs))\n logging.info('reduce_selected_idxs: {}'.format(reduce_selected_idxs))\n logging.info('normal_candidate_flags: {}'.format(normal_candidate_flags))\n logging.info('reduce_candidate_flags: {}'.format(reduce_candidate_flags))\n self.model.normal_selected_idxs = normal_selected_idxs\n self.model.reduce_selected_idxs = reduce_selected_idxs\n self.model.normal_candidate_flags = normal_candidate_flags\n self.model.reduce_candidate_flags = reduce_candidate_flags\n logging.info(F.softmax(torch.stack(self.model.alphas_normal, dim=0), dim=-1).detach())\n logging.info(F.softmax(torch.stack(self.model.alphas_reduce, dim=0), dim=-1).detach())\n self.normal_probs_history = []\n self.reduce_probs_history = []","def forward(self, x):\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\n sources = list()\n loc = list()\n conf = list()\n\n # 对输入图像卷积到conv4_3，将特征添加到sources中\n for k in range(23):\n x = self.vgg[k](x)\n\n s = self.L2Norm(x)\n sources.append(s)\n\n # 继续卷积到conv7，将特征添加到sources中\n for k in range(23, len(self.vgg)):\n x = self.vgg[k](x)\n sources.append(x)\n\n # 继续利用额外的卷积层计算，并将特征添加到sources中\n for k, v in enumerate(self.extras):\n x = F.relu(v(x), inplace=True)\n if k % 2 == 1: # 间隔一层\n sources.append(x)\n\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\n for (x, l, c) in zip(sources, self.loc, self.conf):\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\n\n if self.phase == \"test\":\n output = self.detect(\n loc.view(loc.size(0), -1, 4), # loc preds\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\n self.priors.type(type(x.data)) # default boxes\n )\n else:\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\n output = (\n loc.view(loc.size(0), -1, 4),\n conf.view(conf.size(0), -1, self.num_classes),\n self.priors\n )\n return output","def _pick(self):\n self._source = self._chooser(self.targets, self.cat, self._kwargs,\n self._cat_kwargs)\n if self.input_container != \"other\":\n assert self._source.container == self.input_container\n\n self.metadata['target'] = self._source.metadata\n if self.container is None:\n self.container = self._source.container","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def select_model():\r\n from sklearn import tree\r\n import graphviz\r\n\r\n ValidationSetAndLabels = AllSets[1]\r\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\r\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\r\n\r\n TrainingSetAndLabels = AllSets[2]\r\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\r\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\r\n\r\n \"\"\"\r\n This is the code to select the best hyperparameter (part b)\r\n\r\n for SplitCriterion in ['entropy', 'gini']:\r\n print \"Criterion: \" + SplitCriterion + '\\n'\r\n\r\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\r\n print \"max_depth: \" + str(MaxDepth) + '\\n'\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n print \"Accuracy for this test is: %f %%\" %Accuracy\r\n print '\\n'\r\n\r\n print '\\n'\r\n \"\"\"\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\r\n\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\r\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\r\n class_names=TrainLabels.flatten().astype(str))\r\n graph = graphviz.Source(dot_data)\r\n graph.render(\"output\")","def train(self, decision_outputs, true_assignments):\n t_decision_outputs = self.__transform_to_uniform_decision_tensor(decision_outputs, self.coverage)\n super().train(t_decision_outputs, true_assignments)","def train_and_evaluate_circuit(self):\n self.learner_params['circuit'] = self._create_circuit_evaluator\n self.learner = CircuitLearner(hyperparams=self.learner_params)\n self.learner.train_circuit(steps = self.training_params[\"steps\"], tensors_to_log = self.log)\n\n final_params = self.learner.get_circuit_parameters()\n \n for name, value in final_params.items():\n if \"Variable\" not in name:\n print(\"Parameter {} has the final value {}.\".format(name, value))\n\n for gate in self.gates_structure:\n gate_name = gate[2][\"name\"]\n for param_name in final_params:\n if gate_name in param_name:\n final_value = final_params[param_name]\n gate[2][\"constant\"] = final_value\n break\n\n all_results = []\n circuit_output = self._get_circuit_output()\n cost_tensor = self._loss_function(circuit_output)\n init = tf.global_variables_initializer()\n with tf.Session() as sess:\n sess.run(init)\n circuit_output = sess.run(circuit_output)\n cost_value = sess.run(cost_tensor)\n\n print(\"Total cost:\", cost_value)\n return cost_value","def apply_neurons(self):\n for neuron in range(self.n_outputs):\n self.uf_activate(neuron)","def _handleInput(self, paramInput):\n super()._handleInput(paramInput)\n settings, notFound = paramInput.findNodesAndExtractValues(['C', 'dual', 'penalty', 'l1_ratio', 'tol', 'fit_intercept',\n 'solver','intercept_scaling', 'max_iter', 'multi_class',\n 'class_weight', 'random_state'])\n # notFound must be empty\n assert(not notFound)\n self.initializeModel(settings)","def apply(self, node_x, edge_x, sources, targets):\n\n node_x = GraphConvBlock(node_x, edge_x, sources, targets, features=32)\n node_x = nn.relu(node_x)\n\n node_x = GraphConvBlock(node_x, edge_x, sources, targets, features=2)\n node_x = nn.log_softmax(node_x)\n\n return node_x","def compute(self) -> None:\n \n self.model.eval()\n \n with torch.no_grad():\n for (input, target, _) in self.loader:\n\n # self.model = self.model.train(False) # TEST @lacoupe\n output, _ = self.model(input)\n \n output = (output >= 0.5)\n \n for out, tar in zip(output, target):\n \n tar = bool(tar)\n \n if out and tar:\n self.confusion['true_positive'] += 1\n elif not out and not tar:\n self.confusion['true_negative'] += 1\n elif out and not tar:\n self.confusion['false_positive'] += 1\n elif not out and tar:\n self.confusion['false_negative'] += 1\n \n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\n / sum(list(self.confusion.values()))\n \n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\n self.precision = 0.\n else:\n self.precision = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\n \n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\n self.recall = 0.\n else:\n self.recall = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\n \n if (self.precision + self.recall) == 0.:\n self.f1_score = 0.\n else:\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)","def __init__(self, x_train0, cx_train0, cx_train_mask, cx_validation0,\n cx_validation_mask, cx_validation, x_validation, theta,\n auto_lr=0.01, weight_decay=0):\n self.sample_num = x_train0.shape[0] # The number of samples\n self.num_nodes = x_train0.shape[1] # The number of nodes of each graph\n self.feat_num = x_train0.shape[2] # The number of features\n\n self.x_train0 = x_train0 # The real training set after preprocessing\n self.cx_train0 = cx_train0 # The corrupted training set after preprocessing\n self.cx_train_mask = cx_train_mask # The mask of the corrupted training set\n\n self.cx_validation0 = cx_validation0 # The corrupted validation set after preprocessing\n self.cx_validation_mask = cx_validation_mask # The mask of the corrupted validation set\n self.cx_validation = cx_validation # The corrupted validation set before preprocessing\n self.x_validation = x_validation # The real validation set before preprocessing\n\n self.theta = theta # the theta value for the cost function\n self.auto_lr = auto_lr # learning rate\n self.weight_decay = weight_decay # weight decay\n\n self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n print(\"ConvA is running on\", self.device)\n print(\"The version of PyTorch is\", torch.__version__)\n\n from ConvA_models import ConvAutoencoderModel\n \"\"\"\n Autoencoder with spatio-temporal graph convolutional layers.\n \"\"\"\n # construct an autoencoder\n self.conv_autoencoder = ConvAutoencoderModel(num_nodes=self.num_nodes,\n feat_num=self.feat_num).to(self.device)\n # construct an optimizer\n self.optim_auto = torch.optim.Adam(self.conv_autoencoder.parameters(),\n lr=self.auto_lr,\n betas=(0.9, 0.999),\n weight_decay=self.weight_decay)\n # and a learning rate scheduler\n self.lr_scheduler = torch.optim.lr_scheduler.StepLR(self.optim_auto,\n step_size=5,\n gamma=0.9)\n return","def select_model_inputs_outputs(model, outputs=None, inputs=None,\n infer_shapes=False, overwrite=None,\n verbose=0, fLOG=None):\n if inputs is not None and not isinstance(inputs, list):\n inputs = [inputs]\n if outputs is not None and not isinstance(outputs, list):\n outputs = [outputs]\n if inputs is None:\n inputs = [i.name for i in model.graph.input]\n if outputs is None:\n outputs = [o.name for o in model.graph.output]\n\n mark_var = {}\n for out in enumerate_model_node_outputs(model):\n mark_var[out] = 0\n for inp in inputs:\n mark_var[inp] = 0\n for out in outputs:\n if out not in mark_var:\n raise ValueError( # pragma: no cover\n \"Output '{}' not found in model.\".format(out))\n mark_var[out] = 1\n\n nodes = model.graph.node[::-1]\n mark_op = {}\n for node in nodes:\n mark_op[node.name] = 0\n\n # We mark all the nodes we need to keep.\n nb = 1\n while nb > 0:\n nb = 0\n for node in nodes:\n if mark_op[node.name] == 1:\n continue\n mod = False\n for out in node.output:\n if mark_var[out] == 1:\n mark_op[node.name] = 1\n mod = True\n break\n if not mod:\n continue\n\n nb += 1\n for inp in node.input:\n if inp in inputs:\n continue\n if mark_var.get(inp, 0) == 1:\n continue\n mark_var[inp] = 1\n nb += 1\n\n # All nodes verifies mark_op[node.name] == 1\n keep_nodes = [node for node in nodes if mark_op[node.name] == 1]\n\n known_shapes = {}\n if infer_shapes:\n shapes = shape_inference.infer_shapes(model)\n for shape in shapes.graph.value_info: # pylint: disable=E1101\n known_shapes[shape.name] = shape.type\n for shape in shapes.graph.input: # pylint: disable=E1101\n known_shapes[shape.name] = shape.type\n for shape in shapes.graph.output: # pylint: disable=E1101\n known_shapes[shape.name] = shape.type\n else:\n for shape in model.graph.input: # pylint: disable=E1101\n known_shapes[shape.name] = shape.type\n for shape in model.graph.output: # pylint: disable=E1101\n known_shapes[shape.name] = shape.type\n\n var_in = []\n for name in inputs:\n if overwrite is not None and name in overwrite:\n dtype, shape = overwrite[name]\n proto_dtype = guess_proto_dtype(dtype)\n value_info = helper.make_tensor_value_info(\n name, proto_dtype, shape)\n elif name in known_shapes:\n info = known_shapes[name].tensor_type\n proto_dtype = info.elem_type\n if proto_dtype == 0:\n value_info = helper.ValueInfoProto()\n value_info.name = name\n else:\n shape = [getattr(d, 'dim_value', None) for d in info.shape.dim]\n shape = [None if s == 0 else s for s in shape]\n value_info = helper.make_tensor_value_info(\n name, proto_dtype, shape)\n else:\n value_info = helper.ValueInfoProto()\n value_info.name = name\n var_in.append(value_info)\n\n var_out = []\n for name in outputs:\n if overwrite is not None and name in overwrite:\n dtype, shape = overwrite[name]\n proto_dtype = guess_proto_dtype(dtype)\n value_info = helper.make_tensor_value_info(\n name, proto_dtype, shape)\n elif name in known_shapes:\n info = known_shapes[name].tensor_type\n proto_dtype = info.elem_type\n if proto_dtype == 0:\n value_info = helper.ValueInfoProto()\n value_info.name = name\n else:\n shape = [getattr(d, 'dim_value', None) for d in info.shape.dim]\n shape = [None if s == 0 else s for s in shape]\n value_info = helper.make_tensor_value_info(\n name, proto_dtype, shape)\n else:\n value_info = helper.ValueInfoProto()\n value_info.name = name\n var_out.append(value_info)\n\n if verbose > 0 and fLOG is not None: # pragma: no cover\n fLOG(\"[select_model_inputs_outputs] nodes %r --> %r\" % (\n len(model.graph.node), len(keep_nodes)))\n fLOG(\"[select_model_inputs_outputs] inputs: %r\" % var_in)\n fLOG(\"[select_model_inputs_outputs] inputs: %r\" % var_out)\n\n graph = helper.make_graph(keep_nodes, model.graph.name, var_in,\n var_out, model.graph.initializer)\n onnx_model = helper.make_model(graph)\n onnx_model.ir_version = model.ir_version\n onnx_model.producer_name = model.producer_name\n onnx_model.producer_version = model.producer_version\n onnx_model.domain = model.domain\n onnx_model.model_version = model.model_version\n onnx_model.doc_string = model.doc_string\n if len(model.metadata_props) > 0: # pragma: no cover\n values = {p.key: p.value for p in model.metadata_props}\n helper.set_model_props(onnx_model, values)\n\n del onnx_model.opset_import[:] # pylint: disable=E1101\n for oimp in model.opset_import:\n op_set = onnx_model.opset_import.add() # pylint: disable=E1101\n op_set.domain = oimp.domain\n op_set.version = oimp.version\n return onnx_model","def select(self):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n\n best_bic_score = float(\"inf\")\n best_model = self.base_model(self.n_constant)\n for n in range(self.min_n_components, self.max_n_components + 1):\n try:\n # bic = - 2*log(likelihood) + p*log(N)\n # N is number of data points\n # p => number of parameters\n # p = initial state occupation probabilities\n # + transition probabilities\n # + emission probabilities\n # initial state occupation probabilities, can be obtained from n,\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\n # transition probabilities => n*(n - 1)\n # emission probabilities => n * num_features * 2 = num_means + num_covar\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\n # p = n*n + 2*n*num_features - 1\n\n model = self.base_model(n)\n log_likelihood = model.score(self.X, self.lengths)\n num_features = len(self.X[0])\n log_n = math.log(self.X.shape[0])\n\n p = n*n + 2*n*num_features - 1\n bic = -2 * log_likelihood + p * log_n\n if bic < best_bic_score:\n best_bic_score = bic\n best_model = model\n except:\n continue\n\n return best_model","def precompute(self, features, mode, params):\n return None","def make_default_inputs(filtered_dot_file):\n# w_kernel = pickle.load(open(\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-3.p\", \"rb\" ))\n# w_kernel = pickle.load(open(\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-2.p\", \"rb\" ))\n# w_kernel = pickle.load(open(\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-4.p\", \"rb\" ))\n w_kernel = pickle.load(open(\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-new-2.p\", \"rb\" ))\n filtered = pickle.load(open(filtered_dot_file, \"rb\" ))\n \n n_inputs = 200\n centres = np.random.randn(n_inputs,2)\n mag = np.sum(centres**2, axis=1)**(1/2)\n centres = 155 * centres.T / mag\n centres = centres * np.random.rand(n_inputs)**(1/2)\n centres = np.round(centres).astype('int')\n centres = centres + 199 #put in image centre\n \n inputs = get_inputs(w_kernel, filtered, centres.T)\n \n pickle.dump(inputs, open(filtered_dot_file.replace('-filt.p', '-inputs.p'), \"wb\" ))","def update(self):\n\n self._eps_count += 1\n if self._replay.size >= self._min_replay_size:\n for _ in range(self._learning_updates):\n samples_indices, minibatch = self._replay.sample(self._batch_size)\n tf_minibatch = [tf.constant(mat, dtype=tf_type) for mat, tf_type in zip(minibatch, [tf.float32, tf.int32, tf.float32, tf.float32, tf.float32])]\n self._learn(*tf_minibatch)\n\n self._learn_iter_counter += 1\n if (self._target_update_period > 1) and (self._learn_iter_counter % self._target_update_period == 0):\n self._update_target_nets()","def run():\n cons_in, soln_in, disc = make_discriminator()\n target, loss, accuracy, optimiser = make_training_nodes(disc)\n training_set_sampler = make_sampler(cons_in, soln_in, target)\n test_set_sampler = make_sampler(cons_in, soln_in, target)\n\n disc.get_session().run(tf.global_variables_initializer())\n\n fit(\n disc.get_session(),\n optimiser,\n training_set_sampler,\n 250,\n 2000,\n 32,\n [(\"Loss\", loss), (\"Accuracy\", accuracy)],\n )\n\n print(\n \"Validation accuracy: {}\".format(\n disc.feed(accuracy, test_set_sampler.batch(1024))\n )\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: disc.feed(\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\n )[0],\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )","def do_calibration(x,y,z,temperature,cp, optimal_t=25):\n # if temperature is used for calibration:\n if temperature is not None:\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\n temp_dev = np.empty(len(temperature.data))\n for i in range(len(temperature.data)):\n temp_dev[i] = temperature.data[i] - optimal_t\n\n x.data = cp[\"x_offset\"] + (temp_dev * cp[\"x_temp_offset\"]) + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (temp_dev * cp[\"y_temp_offset\"]) + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (temp_dev * cp[\"z_temp_offset\"]) + (z.data * cp[\"z_scale\"])\n\n x.temp_offset = cp[\"x_temp_offset\"]\n y.temp_offset = cp[\"y_temp_offset\"]\n z.temp_offset = cp[\"z_temp_offset\"]\n\n # if temperature is not used for calibration:\n else:\n x.data = cp[\"x_offset\"] + (x.data * cp[\"x_scale\"])\n y.data = cp[\"y_offset\"] + (y.data * cp[\"y_scale\"])\n z.data = cp[\"z_offset\"] + (z.data * cp[\"z_scale\"])\n\n x.offset = cp[\"x_offset\"]\n x.scale = cp[\"x_scale\"]\n x.calibrated = True\n\n y.offset = cp[\"y_offset\"]\n y.scale = cp[\"y_scale\"]\n y.calibrated = True\n\n z.offset = cp[\"z_offset\"]\n z.scale = cp[\"z_scale\"]\n z.calibrated = True","def set_weights_to_layers(self, candidate):\r\n last_idx = 0\r\n\r\n # Iterate over every layer\r\n for layer_idx in range(0, self.num_layers, 1):\r\n if layer_idx %2 == 0 : \r\n # Get layer dimensions\r\n w_shape = self.layers[layer_idx].weight.shape\r\n w_numel = np.prod(w_shape)\r\n if self.bias :\r\n b_shape = self.layers[layer_idx].bias.shape\r\n b_numel = np.prod(b_shape)\r\n # Decode the candidate and get weight, bias matrices\r\n weight = candidate[last_idx:last_idx + w_numel].reshape(w_shape)\r\n last_idx += w_numel\r\n if self.bias :\r\n bias = candidate[last_idx:last_idx + b_numel].reshape(b_shape)\r\n last_idx += b_numel\r\n else :\r\n bias = []\r\n\r\n# if self.gpu:\r\n# weight = weight.to(device='cuda:'+str(model.rank))\r\n# if self.bias:\r\n# bias = bias.to(device='cuda:'+str(model.rank))\r\n# # Set layer weight, bias\r\n self.layers[layer_idx].weight = torch.nn.Parameter(weight)\r\n if self.bias :\r\n self.layers[layer_idx].bias = torch.nn.Parameter(bias)","def train(self, **kwargs):\n self.solver.train(**kwargs)","def _compute_outputs(self, *args, **kwargs):\n pass\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\n # self.logits = self.outputs[0][0]\n # self.probs = torch.softmax(self.logits, 1)","def compute_all(self) -> None:\n self.compute_j_matrix()\n self.compute_outter_distribution()\n self.compute_max_prior()\n self.compute_max_poutter()","def fit(self):\n self._minuit_problem.migrad() # run optimizer\n self._status = 0 if self._minuit_problem.migrad_ok() else 1","def apply(self, inputs):\n raise NotImplementedError()","def fit(self, data_matrix, target=None):\n self.selected_instances = self.selector.fit_transform(data_matrix, target=target)\n if self.scale:\n self.scale = False\n self.scaler.fit(self.transform(data_matrix))\n self.scale = True\n return self","def gate_activation(recurrent_net, inputs):\n score, select = torch.zeros(len(inputs)), torch.zeros(len(inputs))\n for (i, xi) in enumerate(inputs):\n out = recurrent_net.activate(xi.view(1, 1))\n select[i], score[i] = out.view(2)\n score, select = score.numpy(), select.numpy()\n mask = (select > 0.5)\n return mask, score","def call(self, inputs):\n if self.backward_compatible:\n kernel = tf.keras.backend.reshape(self.kernel, self.kernel_shape)\n bias = (tf.keras.backend.reshape(self.bias, self.bias_shape)\n if self.use_bias else None)\n else:\n kernel = self.kernel\n bias = self.bias\n\n if self.output_projection:\n ret = tf.einsum(\"abcd,cde->abe\", inputs, kernel)\n else:\n ret = tf.einsum(\"abc,cde->abde\", inputs, kernel)\n if self.use_bias:\n ret += bias\n if self.activation is not None:\n return self.activation(ret)\n return ret","async def compute(self, *args):\n\n if self.is_output:\n await self.output_compute(*args)\n else:\n await self.input_compute(*args)","def selectFeatures(k_features=5, *args):\n X, y = args\n skb = SelectKBest(k=k_features)\n return skb.fit_transform(X, y)","def do_calibration(self):\n goal = CalculateParametersGoal()\n self.calibrate_client.send_goal(goal)\n self.calibrate_client.wait_for_result()\n result = self.calibrate_client.get_result()\n rospy.loginfo('Received the calibration results')\n if result.number_of_images is 0:\n rospy.logerr('Failed to calibrate the camera.')\n else:\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)","def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\n return calibrate(self.model, dataset)","def _reset_parameters(self) -> None:\n self._setup_input = {\n \"P\": csc_matrix(2.0 * self.opt.P(self.p).toarray()),\n \"q\": self.opt.q(self.p).toarray().flatten(),\n }\n if self.opt_type in CONSTRAINED_OPT:\n A = self.opt.A(self.p)\n b = self.opt.b(self.p)\n self._setup_input[\"A\"] = csc_matrix(\n cs.vertcat(self.opt.M(self.p), A, -A).toarray()\n )\n self._setup_input[\"l\"] = (\n cs.vertcat(-self.opt.c(self.p), -b, b).toarray().flatten()\n )","def _select_node(self, logits):\n\n # assert tf.reduce_all(logits) == logits, \"Probs should not contain any nans\"\n\n if self.decode_type == \"greedy\":\n selected = torch.argmax(logits, dim=-1) # (batch_size, 1)\n\n elif self.decode_type == \"sampling\":\n # logits has a shape of (batch_size, 1, n_nodes), we have to squeeze it\n # to (batch_size, n_nodes) since tf.random.categorical requires matrix\n cat_dist = Categorical(logits=logits[:, 0, :]) # creates categorical distribution from tensor (batch_size)\n selected = cat_dist.sample() # takes a single sample from distribution\n else:\n assert False, \"Unknown decode type\"\n\n return torch.squeeze(selected, -1) # (batch_size,)","def activate(self, inputs, max_iters=10, verbose=False):\n # Node activation values\n self.node_vals = np.zeros(self.A.shape[0])\n\n # Bool to check if node was activated in the current time step\n self.active_nodes = np.zeros((self.A.shape[0]), dtype=bool)\n\n # Label inputs and bias as active\n self.active_nodes[self.inputs] = True\n self.active_nodes[self.bias] = True\n\n # While some output nodes are inactive, pass the signal farther\n # through the network\n\n i=0\n # while not self.active_nodes[self.outputs].all():\n while True:\n\n # Activate inputs\n # NOTE: This step disallows recurrent connections between hidden and input nodes\n\n self.node_vals[self.inputs] = inputs\n self.node_vals[self.bias] = 1.\n\n # Drive the activations one time step farther through the network\n self.node_vals = self.A.dot(self.node_vals)\n\n # Keep track of new node activations\n self.active_nodes = (self.A != 0).dot(self.active_nodes) + self.active_nodes\n\n # Apply sigmoid to active nodes\n self.node_vals[self.active_nodes] = self.sigmoid(self.node_vals[self.active_nodes])\n if verbose:\n print(self.node_vals)\n\n\n\n i += 1\n # Stop if the number of iterations exceeds max_iters\n if i > max_iters:\n break\n #\n # return np.array([np.nan]*len(self.outputs))\n\n return self.node_vals[self.outputs]","def forward(self, node_scalars, node_mask):\n # Reshape\n node_shape = node_scalars.permute(1,2,3,4,0).shape[:2] + (2*self.num_scalars,)\n node_scalars = node_scalars.view(node_shape)\n\n # First MLP applied to each node\n x = self.mlp1(node_scalars)\n\n # Reshape to sum over each node in graphs, setting non-existent nodes to zero.\n node_mask = node_mask.unsqueeze(-1)\n x = torch.where(node_mask, x, self.zero).sum(1)\n\n # Prediction on permutation invariant representation of graphs\n predict = self.mlp2(x)\n\n return predict","def test_known(self):\n\n selector = PCovCUR(n_to_select=12)\n selector.fit(self.X, self.y)\n\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))","def test_oss_sk_estimator():\n check_estimator(OneSidedSelection)","def infer_outputs(self):\n # TF lack a supported API for invoking shape inference directly,\n # so we instantiate a dummy graph and create a dummy Operation object\n temp_graph = tf.Graph()\n with temp_graph.as_default():\n input_placeholders = [tf.placeholder(shape=t.shape, dtype=t.dtype) for\n t in self._inputs]\n # See the docs for tf.Operation for important notes about the semantics\n # of each arg to the following constructor.\n dummy_op = tf.Operation(self.to_node_def(), temp_graph,\n inputs=input_placeholders)\n self.set_outputs_from_pairs([(o.dtype, o.shape)\n for o in dummy_op.outputs])\n # set_outputs_from_pairs() increments the version counter, so we don't\n # need to. Also, we haven't added edges to the graph until these\n # outputs are connected to another node's inputs.","def choose_action(self, node: dict, exploit: bool = False) -> tuple:\n best_val = -np.inf\n mcts_policy = torch.zeros(1, len(node[\"childs\"])).cuda(self.controller.device)\n n_children = len(node[\"childs\"])\n\n # Get back to the root node and evaluate its children. Choose the best estimated action\n # and move to the next node. This next node will become the new root\n for num in range(n_children):\n child = node[\"childs\"][num]\n if child[\"prior\"] > 0.0:\n Q = (\n child[\"total_action_value\"] / child[\"visit_count\"]\n if child[\"visit_count\"] > 0.0\n else 0.0\n )\n mcts_policy[0, num] = child[\"visit_count\"]\n if Q > best_val:\n best_val = Q\n action_choice = num\n\n if not exploit:\n policy = torch.pow(mcts_policy, self.temperature)\n policy = policy / policy.sum()\n act = int(torch.multinomial(policy, 1)[0, 0])\n mcts_policy = mcts_policy / mcts_policy.sum()\n # print(self.normal_entropy(mcts_policy))\n return mcts_policy, act\n else:\n mcts_policy = mcts_policy / mcts_policy.sum()\n return mcts_policy, action_choice","def select_candidates(self, X, y, candidate_mask, train_mask):\n\n return self.best_heuristic(X=X, y=y, candidate_mask=candidate_mask,\n train_mask=train_mask, classifier=self.classifier,\n n_candidates=self.n_candidates, random_state=self.pool_rng.randint(1000),\n **self.h_kwargs)","def calibrate(self, param_start):\n return self.get_pnames(), self.model.fit().params.values","def update_target(self):\n if self.soft:\n self.soft_update_target(self.critic1_target, self.critic1)\n self.soft_update_target(self.critic2_target, self.critic2)\n else:\n if self.learn_cur % self.learn_replace == 0:\n self.critic1_target.load_state_dict(self.critic1.state_dict())\n self.critic2_target.load_state_dict(self.critic2.state_dict())","def calibrate(self, Otrain, Ftrain, Feval):\n return Otrain[0] * np.ones(len(Feval))","def __call__(self, *args, **kwargs):\n output, changes = self._call(self.vc.tensors(), kwargs, *args)\n self.vc.assign(changes)\n return output","def select(self):\n\t\twarnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n\t\tscore_best = float(\"inf\")\n\t\tbest_model = None\n\t\tfor numStates in range(self.min_n_components, self.max_n_components + 1):\n\t\t\ttry:\n\t\t\t\tmodel = self.base_model(numStates)\n\t\t\t\tlog_l = model.score(self.X, self.lengths)\n\t\t\t\tp = numStates\n\t\t\t\tlog_n = np.log(len(self.lengths))\n\t\t\t\tscore = -2 * log_l + p * log_n\n\t\t\t\tif score < score_best:\n\t\t\t\t\tscore_best = score\n\t\t\t\t\tbest_model = model\n\t\t\texcept Exception as e:\n\t\t\t\tpass\n\n\t\twhile best_model is None:\n\t\t\tbest_model = self.base_model(np.random.randint(self.min_n_components, self.max_n_components + 1))\n\n\t\treturn best_model","def _reduce(self, x, y):\n ind = self.ind_\n n_samples, n_features = x.shape\n n_features_selected = sum(ind)\n\n for _ in range(self.iters, self.max_iter):\n if np.count_nonzero(ind) == 0:\n warnings.warn(\n \"Sparsity parameter is too big ({}) and eliminated all coeficients\".format(self.threshold)\n )\n coef = np.zeros_like(ind, dtype=float)\n break\n\n coef = self._regress(x[:, ind], y, self.alpha)\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\n\n if sum(ind) == n_features_selected or self._no_change():\n # could not (further) select important features\n break\n else:\n warnings.warn(\n \"STRidge._reduce did not converge after {} iterations.\".format(self.max_iter),\n ConvergenceWarning,\n )\n try:\n coef\n except NameError:\n coef = self.coef_\n warnings.warn(\"STRidge._reduce has no iterations left to determine coef\", ConvergenceWarning)\n self.coef_ = coef\n self.ind_ = ind","def best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\n\titerative_based_score = 0\n\t# given that all pairs use the same amount of features, the position 0 was arbitrarily selected to compute the number of features being used\n\tmin_number_features = int(0.15*len(train_features[0]))\n\tmax_number_features = int(0.85*len(train_features[0]))\n\n\t# min_number_features = 19\n\t# max_number_features = 20\n\n\titerative_based_selector = None\n\titerative_based_train_features_selected = None\n\titerative_based_test_features_selected = None\n\n\tfor i in range(min_number_features, max_number_features):\n\t\tprint(i)\n\t\ttemp_iterative_based_selector = RFE(RandomForestRegressor(n_estimators=100), n_features_to_select=i)\n\t\ttemp_iterative_based_selector.fit(train_features, train_similarity_target)\n\t\ttemp_iterative_based_train_features_selected = temp_iterative_based_selector.transform(train_features)\n\t\ttemp_iterative_based_test_features_selected = temp_iterative_based_selector.transform(test_features)\n\n\t\tregressor.fit(temp_iterative_based_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_iterative_based_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Iterative Based Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > iterative_based_score:\n\t\t\titerative_based_score = temp_score\n\t\t\titerative_based_selector = temp_iterative_based_selector\n\t\t\titerative_based_train_features_selected = temp_iterative_based_train_features_selected\n\t\t\titerative_based_test_features_selected = temp_iterative_based_test_features_selected\n\n\titerative_based_mask = iterative_based_selector.get_support()\n\tprint(\"This is the iterative based mask: \")\n\tprint(iterative_based_mask)\n\n\treturn iterative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def choose_action( self):\n \"\"\"greedy, random, e-greedy, boltzmann, bayesian\"\"\"\n\tif self.exploration == \"greedy\":\n #Choose an action with the maximum expected value.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"random\":\n #Choose an action randomly.\n a = env.action_space.sample()\n if self.exploration == \"e-greedy\":\n #Choose an action by greedily (with e chance of random action) from the Q-network\n if np.random.rand(1) < e or total_steps < pre_train_steps:\n a = env.action_space.sample()\n else:\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"boltzmann\":\n #Choose an action probabilistically, with weights relative to the Q-values.\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\n a = np.random.choice(Q_d[0],p=Q_d[0])\n a = np.argmax(Q_d[0] == a)\n return a\n if self.exploration == \"bayesian\":\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\n a = a[0]\n return a","def __call__(self, *inputs):\n if not inputs:\n raise ValueError(\"Inputs are mandatory for the DeterministicNNNode\")\n \n l = len(inputs)\n if l % 2:\n raise ValueError(\"Odd number of inputs\")\n \n islot_to_itensor = [{'loc' : inputs[i], 'scale' : inputs[i+1]} for i \n in range(l/2)]\n return self.build_outputs(islot_to_itensor)","def evaluation(x_selected, y, state_of_art=False):\n # check_number_of_clusters(X_selected)\n # n_clusters = best_number_of_clusters\n\n y_true = np.asarray(y)\n\n if state_of_art:\n avg_sil, model = get_results(x_selected, [max(y_true)])\n else:\n avg_sil, model = get_results(x_selected)\n\n # using GPU\n #avg_sil, model = get_results_from_GPU(x_selected)\n\n \"\"\" VALID DISTANCES METRICS\n 'euclidean', 'l2', 'l1', 'manhattan', 'cityblock',\n 'braycurtis', 'canberra', 'chebyshev', 'correlation',\n 'cosine', 'dice', 'hamming', 'jaccard', 'kulsinski',\n 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto',\n 'russellrao', 'seuclidean', 'sokalmichener',\n 'sokalsneath', 'sqeuclidean', 'yule', \"wminkowski\"\n \n max([\n metrics.silhouette_score(x_selected, model.labels_, metric='euclidean'),\n metrics.silhouette_score(x_selected, model.labels_, metric='cosine'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='manhattan'),\n metrics.silhouette_score(x_selected, model.labels_, metric='braycurtis'),\n metrics.silhouette_score(x_selected, model.labels_, metric='canberra'),\n metrics.silhouette_score(x_selected, model.labels_, metric='chebyshev'),\n metrics.silhouette_score(x_selected, model.labels_, metric='hamming'),\n metrics.silhouette_score(x_selected, model.labels_, metric='jaccard'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='russellrao'),\n metrics.silhouette_score(x_selected, model.labels_, metric='sokalsneath'),\n metrics.silhouette_score(x_selected, model.labels_, metric='yule'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='kulsinski'),\n metrics.silhouette_score(x_selected, model.labels_, metric='cityblock')\n ])\"\"\"\n\n y_predict = model.labels_\n\n for i in range(0, len(y_predict)):\n y_predict[i] = y_predict[i] + 1\n\n # inercia = k_means.inertia_\n inertia = model.inertia_\n\n # calculate NMI\n nmi = v_measure_score(y_true, y_predict)\n # nmi = 0\n\n # calculate corrected rand\n corrected_rand = adjusted_rand_score(y_true, y_predict)\n # corrected_rand = 0\n\n # calculate f-measure\n f_measure = f1_score(y_true, y_predict, average='micro')\n\n # calculate ACC\n\n label1 = np.unique(y_true)\n label2 = np.unique(y_predict)\n if len(label1) == len(label2):\n y_permuted_predict = best_map(y_true, y_predict)\n acc = accuracy_score(y_true, y_permuted_predict)\n else:\n acc = 0\n\n logger.log(\"KMeans model has\"\n \" avg_sil = \" + str(avg_sil) +\n \" and NMI = \" + str(nmi) +\n \" and CR = \" + str(corrected_rand) +\n \" and f-measure = \" + str(f_measure), True)\n\n # calculate cluster.stats\n # dgene = stats.dist(x_selected, method='euclidean')\n\n \"\"\" fpc_result = fpc.cluster_stats(dgene,\n model.labels_,\n G2=False,\n G3=False,\n silhouette=True,\n sepwithnoise=True,\n noisecluster=True,\n wgap=True)\n\n stats_fpc = pandas2ri.ri2py(fpc_result)\"\"\"\n\n # Compute Hopkins statistic for iris dataset\n # nrow = X_selected.shape[0]\n # res = factoextra.get_clust_tendency(X_selected, n=nrow - 1, graph=False)\n # print(\"hopkins test: \"+ str(res[0]))\n # hopkins_test = res\n\n # dunn = stats_fpc[24][0]\n # dunn2 = stats_fpc[25][0]\n # entropy = stats_fpc[26][0]\n # ch = stats_fpc[28][0]\n\n dunn = 0\n dunn2 = 0\n entropy = 0\n ch = 0\n\n # inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure\n return ClusteringResults(max(y_predict), inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure)","def engage(self):\n # no sigmoid for the inputs and bias\n if layer != 0:\n self.outputValue = sigmoid(inputSum);\n\n for connection in self.outputConnections:\n if connection.enabled == True:\n #connection will have toNode\n connection.toNode.inputSum += connection.weight * self.outputValue;","def set_choices(self):\n self.check_idxs()\n np.random.seed()\n self.choices = np.random.choice(self.running_idxs, self.num_selections)\n self.running_idxs = np.delete(self.running_idxs, self.choices)\n self.choices = torch.tensor(self.choices).cuda()","def train_candidates(nb_layers = 4, nb_neurons = 300, p_drop = 0.15, nb_exp = 50):\n\n print(\"Calculation will be performed on {}\".format(device))\n \n # custom data loader, automatically sent to device\n ds = imelt.data_loader()\n\n for i in range(nb_exp):\n\n print(\"Training model {}\".format(i))\n print(\"...\\n\")\n name = \"./model/candidates/l\"+str(nb_layers)+\"_n\"+str(nb_neurons)+\"_p\"+str(p_drop)+\"_m\"+str(i)+\".pth\"\n\n # declaring model\n neuralmodel = imelt.model(ds.x_visco_train.shape[1],nb_neurons,nb_layers,ds.nb_channels_raman,\n activation_function = torch.nn.GELU(), p_drop=p_drop\n )\n\n # criterion for match\n criterion = torch.nn.MSELoss(reduction='mean')\n criterion.to(device) # sending criterion on device\n\n # we initialize the output bias and send the neural net on device\n neuralmodel.output_bias_init()\n neuralmodel = neuralmodel.float()\n neuralmodel.to(device)\n\n optimizer = torch.optim.Adam(neuralmodel.parameters(), lr = 0.0003, weight_decay=0.00) # optimizer\n neuralmodel, record_train_loss, record_valid_loss = imelt.training(neuralmodel, ds, criterion, optimizer, \n save_switch=True, save_name=name, nb_folds=1, train_patience=400, min_delta=0.05, verbose=True)","def val(self, subset):\n self.set_eval()\n if \"syn\" in subset:\n try:\n inputs = self.syn_val_iter.__next__()\n except StopIteration:\n print('Stopped as the iteration has reached to the END, and reloading the dataloader')\n self.syn_val_iter = iter(self.syn_val_loader)\n inputs = self.syn_val_iter.__next__()\n self.syn_or_real = 'syn'\n elif \"real\" in subset:\n try:\n inputs = self.real_val_iter.__next__()\n except StopIteration:\n print('Stopped as the iteration has reached to the END, and reloading the dataloader')\n self.real_val_iter = iter(self.real_val_loader)\n inputs = self.real_val_iter.__next__()\n self.syn_or_real = 'real'\n else:\n raise RuntimeError(\"Need proper validation loader choose syn or real or real_eigen\")\n\n # Move all available tensors to GPU memory\n for key, ipt in inputs.items():\n if type(key) == tuple or key == \"depth_gt\":\n inputs[key] = ipt.to(self.device)\n\n outputs, losses = {}, {}\n with torch.no_grad():\n # Estimated depth and segmentation\n outputs_d, losses_d = self.process_batch(inputs)\n outputs.update(outputs_d)\n losses.update(losses_d)\n\n if \"depth_gt\" in inputs:\n self.compute_depth_losses(inputs, outputs, losses)\n\n self.log(\"val_\" + self.syn_or_real, inputs, outputs, losses)\n del inputs, outputs, losses\n\n self.set_train()","def compute_output(self):\n x, y = self.input_nodes\n print(x.name, y.name)\n self.output_value = backend.dot(x.output_value, y.output_value)\n return self.output_value","def predict_select_outputs(\n self,\n X,\n select_outputs_csr,\n pred_params=None,\n **kwargs,\n ):\n if X.dtype != np.float32:\n raise ValueError(\"X.dtype = {} is not supported\".format(X.dtype))\n if not isinstance(X, smat.csr_matrix) and not (\n isinstance(X, np.ndarray) and X.flags[\"C_CONTIGUOUS\"]\n ):\n raise ValueError(\"type(X) = {} is not supported\".format(type(X)))\n if X.shape[1] != self.nr_features:\n raise ValueError(\"Feature dimension of query matrix does not match weight matrix\")\n\n if not isinstance(select_outputs_csr, smat.csr_matrix):\n raise ValueError(\n \"type(select_outputs_csr) = {} is not supported\".format(type(select_outputs_csr))\n )\n if select_outputs_csr.shape[1] != self.nr_labels:\n raise ValueError(\"Label dimension of select output matrix does not match\")\n\n if X.shape[0] != select_outputs_csr.shape[0]:\n raise ValueError(\"Instance dimension of query and select output matrix do not match\")\n\n # construct pred_params\n if pred_params is None:\n pred_params = self.get_pred_params()\n elif isinstance(pred_params, self.PredParams):\n pred_params = self.PredParams.from_dict(pred_params)\n pred_params = self._duplicate_fields_with_name_ending_with_chain(\n pred_params, self.PredParams, self.depth\n )\n else:\n raise ValueError(\"unknown type(pred_params)!!\")\n pred_params.override_with_kwargs(kwargs)\n\n if self.is_predict_only:\n for layer_depth in range(self.depth):\n if self.get_weight_matrix_type(layer_depth) != \"CSC\":\n raise NotImplementedError(\n \"is_predict_only=True not supported for weight_matrix_type = {}\".format(\n self.weight_matrix_type\n )\n )\n\n old_chain = self.get_pred_params().model_chain\n new_chain = pred_params.model_chain\n\n # check if post_processor is valid (support by C++) after overriding\n if all(\n old_p.post_processor == new_p.post_processor\n for (old_p, new_p) in zip(old_chain, new_chain)\n ):\n overridden_post_processor = None\n elif all(new_chain[0].post_processor == new_p.post_processor for new_p in new_chain):\n overridden_post_processor = new_chain[0].post_processor\n else:\n raise NotImplementedError(\n \"when is_predict_only=True, post_processor is not supported for overriddng\"\n )\n\n # Call C++ code\n pred_alloc = ScipyCompressedSparseAllocator()\n clib.xlinear_predict_select_outputs(\n self.model_chain,\n X,\n select_outputs_csr,\n overridden_post_processor,\n kwargs.get(\"threads\", -1),\n pred_alloc,\n )\n\n return pred_alloc.get()\n else:\n select_outputs_csrs = []\n select_outputs_csrs.insert(0, select_outputs_csr)\n for d in range(self.depth - 2, -1, -1):\n prev_csr = clib.sparse_matmul(\n select_outputs_csrs[0],\n self.model_chain[d + 1].C,\n threads=kwargs.get(\"threads\", -1),\n ).tocsr()\n select_outputs_csrs.insert(0, prev_csr)\n\n prev_pred_csr = None\n for d in range(self.depth):\n prev_pred_csr = self.model_chain[d].predict_select_outputs(\n X=X,\n select_outputs_csr=select_outputs_csrs[d],\n csr_codes=prev_pred_csr,\n pred_params=pred_params.model_chain[d],\n threads=kwargs.get(\"threads\", -1),\n )\n\n return prev_pred_csr","def calculate_calibration(filename, nx=9, ny=6):\n # Make a list of calibration images\n img = cv2.imread(filename)\n\n # Convert to grayscale\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # Find the chessboard corners\n objpoints = []\n imgpoints = []\n objp = np.zeros((ny*nx, 3), np.float32)\n objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2)\n\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\n if not ret:\n return None\n\n imgpoints.append(corners)\n objpoints.append(objp)\n\n ret, mtx, dist, a, b = cv2.calibrateCamera(\n objpoints, imgpoints,\n gray.shape[::-1], None, None\n )\n return img, corners, mtx, dist","def __call__(self , x,y):\n # selcet features , return scores and selected indices\n scores , features = self._feature_selection(x , y)\n # transform data with selected features\n return x[:,features] , scores","def compute(self, inputs, outputs):\n\n log.info(f\"Start optimisation iteration: {Rt.counter}\")\n\n # Update the geometry dictionary\n for name, infos in Rt.geom_dict.items():\n infos[1].append(inputs[name][0])\n\n if Rt.counter == 0:\n\n # For the first iteration, update the CPACS file from previous module\n cpacs_in = Rt.modules[0].cpacs_in\n cpacs_out = Rt.modules[0].cpacs_out\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\n\n else:\n\n for m, module in enumerate(Rt.modules):\n\n # Increment name of output CPACS file\n Rt.modules[m].cpacs_out = Path(\n Rt.modules[m].cpacs_out.parents[0],\n \"iter_\" + str(Rt.counter).rjust(2, \"0\") + \".xml\",\n )\n\n if m == 0:\n\n # Use output of the last module of the previous iteration as input\n Rt.modules[m].cpacs_in = Rt.modules[-1].cpacs_out\n\n # Update the geometry of the CPACS file\n cpacs_in = Rt.modules[m].cpacs_in\n cpacs_out = Rt.modules[m].cpacs_out\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\n\n # # The first module of the loop must update its output where the input\n # # was saved because it has been updated by \"update_cpacs_file\" function.\n # Rt.modules[m].cpacs_in = Rt.modules[m].cpacs_out\n\n else:\n\n # Increment name of input CPACS file\n Rt.modules[m].cpacs_in = Path(\n Rt.modules[m].cpacs_in.parents[0],\n \"iter_\" + str(Rt.counter).rjust(2, \"0\") + \".xml\",\n )\n\n Rt.counter += 1","def call(self, inputs)->Any:\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\n input_tensor = unpacked_inputs[0]\n attention_mask = unpacked_inputs[1]\n output_tensor = input_tensor\n\n all_layer_outputs = []\n for layer in self.layers:\n output_tensor, attention_scores = layer(output_tensor, attention_mask)\n all_layer_outputs.append((output_tensor, attention_scores))\n\n return all_layer_outputs","def select_actions(self, inputs, avail_actions, tformat, info, hidden_states=None, test_mode=False, **kwargs):\n noise_params = kwargs.get(\"noise_params\", None)\n\n T_env = info[\"T_env\"]\n test_suffix = \"\" if not test_mode else \"_test\"\n\n if self.args.agent_level1_share_params:\n\n # --------------------- LEVEL 1\n\n if self.is_obs_noise(test_mode):\n inputs_level1, inputs_level1_tformat = _build_model_inputs(self.input_columns_level1_noisy,\n inputs,\n to_variable=True,\n inputs_tformat=tformat)\n inputs_level1_tformat = \"a*bs*t*v\"\n else:\n inputs_level1, inputs_level1_tformat = _build_model_inputs(self.input_columns_level1,\n inputs,\n to_variable=True,\n inputs_tformat=tformat)\n if self.args.debug_mode:\n _check_nan(inputs_level1)\n\n out_level1, hidden_states_level1, losses_level1, tformat_level1 = self.model.model_level1(inputs_level1[\"agent_input_level1\"],\n hidden_states=hidden_states[\"level1\"],\n loss_fn=None,\n tformat=inputs_level1_tformat,\n n_agents=self.n_agents,\n test_mode=test_mode,\n **kwargs)\n\n\n if self.args.debug_mode:\n _check_nan(inputs_level1)\n\n if self.is_obs_noise(test_mode):\n # have to do correlated sampling of what pair id everyone agrees on\n bs = out_level1.shape[_bsdim(inputs_level1_tformat)]\n ftype = th.FloatTensor if not out_level1.is_cuda else th.cuda.FloatTensor\n sampled_pair_ids = ftype(*out_level1.shape[:-1], 1)\n for _b in range(bs):\n ps = out_level1[:, _b]\n rn = np.random.random()\n for _a in range(ps.shape[0]):\n act = 0\n s = ps[_a, 0, act]\n while s <= rn:\n act += 1\n s += ps[_a, 0, act]\n sampled_pair_ids[_a, _b, 0, :] = act\n\n modified_inputs_level1 = inputs_level1\n selected_actions_format_level1 = \"a*bs*t*v\"\n else:\n # TODO: This is the pair-product encoded ID of both selected pairs.\n sampled_pair_ids, modified_inputs_level1, selected_actions_format_level1 = self.action_selector.select_action({\"policies\":out_level1},\n avail_actions=None,\n tformat=tformat_level1,\n test_mode=test_mode)\n _check_nan(sampled_pair_ids)\n\n if self.args.debug_mode in [\"level2_actions_fixed_pair\"]:\n \"\"\"\n DEBUG MODE: LEVEL2 ACTIONS FIXED PAIR\n Here we pick level2 actions from a fixed agent pair (0,1) and the third action from IQL\n \"\"\"\n assert self.n_agents == 3, \"only makes sense in n_agents=3 scenario\"\n sampled_pair_ids.fill_(0.0)\n\n # sample which pairs should be selected\n # TODO: HAVE TO ADAPT THIS FOR NOISY OBS!\n if self.is_obs_noise(test_mode):\n self.selected_actions_format = selected_actions_format_level1\n else:\n self.actions_level1 = sampled_pair_ids.clone()\n self.selected_actions_format = selected_actions_format_level1\n self.policies_level1 = modified_inputs_level1.squeeze(0).clone()\n\n if self.is_obs_noise(test_mode):\n inputs_level2, inputs_level2_tformat = _build_model_inputs(self.input_columns_level2_noisy,\n inputs,\n to_variable=True,\n inputs_tformat=tformat,\n )\n else:\n inputs_level2, inputs_level2_tformat = _build_model_inputs(self.input_columns_level2,\n inputs,\n to_variable=True,\n inputs_tformat=tformat,\n )\n\n assert self.args.agent_level2_share_params, \"not implemented!\"\n\n\n if \"avail_actions_pair\" in inputs_level2[\"agent_input_level2\"]:\n pairwise_avail_actions = inputs_level2[\"agent_input_level2\"][\"avail_actions_pair\"]\n else:\n assert False, \"NOT SUPPORTED CURRENTLY.\"\n avail_actions1, params_aa1, tformat_aa1 = _to_batch(inputs_level2[\"agent_input_level2\"][\"avail_actions_id1\"], inputs_level2_tformat)\n avail_actions2, params_aa2, _ = _to_batch(inputs_level2[\"agent_input_level2\"][\"avail_actions_id2\"], inputs_level2_tformat)\n pairwise_avail_actions = th.bmm(avail_actions1.unsqueeze(2), avail_actions2.unsqueeze(1))\n pairwise_avail_actions = _from_batch(pairwise_avail_actions, params_aa2, tformat_aa1)\n\n ttype = th.cuda.FloatTensor if pairwise_avail_actions.is_cuda else th.FloatTensor\n delegation_avails = Variable(ttype(pairwise_avail_actions.shape[0],\n pairwise_avail_actions.shape[1],\n pairwise_avail_actions.shape[2], 1).fill_(1.0), requires_grad=False)\n pairwise_avail_actions = th.cat([delegation_avails, pairwise_avail_actions], dim=_vdim(tformat))\n\n\n out_level2, hidden_states_level2, losses_level2, tformat_level2 \\\n = self.model.models[\"level2_{}\".format(0)](inputs_level2[\"agent_input_level2\"],\n hidden_states=hidden_states[\"level2\"],\n loss_fn=None,\n tformat=inputs_level2_tformat,\n # sampled_pair_ids=sampled_pair_ids, # UNUSED?\n pairwise_avail_actions=pairwise_avail_actions,\n test_mode=test_mode,\n seq_lens=inputs[\"agent_input_level2__agent0\"].seq_lens,\n **kwargs)\n\n if self.is_obs_noise(test_mode):\n\n # have to do correlated sampling of what pair id everyone agrees on\n bs = out_level2.shape[_bsdim(inputs_level2_tformat)]\n ftype = th.FloatTensor if not out_level2.is_cuda else th.cuda.FloatTensor\n pair_sampled_actions = ftype(*out_level2.shape[:-1], 1).view(int(out_level2.shape[0]/2),\n 2,\n *out_level2.shape[1:-1],\n 1)\n for _b in range(bs):\n ps = out_level2.view(int(out_level2.shape[0]/2),\n 2,\n *out_level2.shape[1:])[:, :, _b]\n avail_actions = pairwise_avail_actions.view(int(out_level2.shape[0]/2),\n 2,\n *out_level2.shape[1:])[:, :, _b]\n\n _sum0 = th.sum(ps[:, 0] * avail_actions[:, 0], dim=-1, keepdim=True)\n _sum0_mask = (_sum0 == 0.0)\n _sum0.masked_fill_(_sum0_mask, 1.0)\n ps[:, 0] = ps[:, 0] * avail_actions[:, 0] / _sum0\n\n _sum1 = th.sum(ps[:, 1] * avail_actions[:, 1], dim=-1, keepdim=True)\n _sum1_mask = (_sum1 == 0.0)\n _sum1.masked_fill_(_sum1_mask, 1.0)\n ps[:, 1] = ps[:, 1] * avail_actions[:, 1] / _sum1\n\n rns = np.random.random(ps.shape[0]) #one seed for each pair / batch\n for _a in range(ps.shape[0]):\n for _j in range(2):\n act = 0\n s = ps[_a, _j, 0, act]\n while s <= rns[_a]:\n act += 1\n s += ps[_a, _j, 0, act]\n if act == 122: # DEBUG\n a = 5\n pass\n pair_sampled_actions[_a, _j, _b, 0, :] = act\n\n # TODO: Fix the return values so I can debug in episode buffer!!!\n modified_inputs_level2 = inputs_level2\n selected_actions_format_level2 = \"a*bs*t*v\"\n else:\n\n # TODO: Implement for noisy obs!! # Need again correlated sampling\n pair_sampled_actions, \\\n modified_inputs_level2, \\\n selected_actions_format_level2 = self.action_selector.select_action({\"policies\":out_level2},\n avail_actions=pairwise_avail_actions.data,\n tformat=tformat_level2,\n test_mode=test_mode)\n # if th.sum(pair_sampled_actions == 26.0) > 0.0:\n # a = 5\n\n if sampled_pair_ids.shape[_tdim(tformat_level1)] > 1: # only used for mackrl sampling\n sampled_pairs = th.cat([ self.magic_map[sampled_pair_ids[:,:,_t:_t+1,:].long()].squeeze(2) for _t in range(sampled_pair_ids.shape[_tdim(tformat_level1)]) ],\n dim=_tdim(tformat_level1))\n else:\n sampled_pairs = self.magic_map[sampled_pair_ids.long()].squeeze(2)\n\n self.actions_level2 = pair_sampled_actions.clone()\n\n if self.is_obs_noise(test_mode):\n self.actions_level2_sampled = []\n for _aid in range(self.n_agents):\n self.actions_level2_sampled.append([])\n for i in range(sampled_pairs.shape[-1]):\n self.actions_level2_sampled[_aid].append(\n pair_sampled_actions[:, i].gather(0, sampled_pairs[_aid:_aid+1, :, :, i:i + 1].long()))\n self.actions_level2_sampled[_aid] = th.cat(self.actions_level2_sampled[_aid], 0)\n else:\n # ToDO: Gather across all selected pairs!!\n self.actions_level2_sampled = []\n for i in range(sampled_pairs.shape[-1]):\n self.actions_level2_sampled.append(pair_sampled_actions.gather(0, sampled_pairs[:,:,:,i:i+1].long()))\n\n self.actions_level2_sampled = th.cat(self.actions_level2_sampled, 0)\n self.selected_actions_format_level2 = selected_actions_format_level2\n self.policies_level2 = modified_inputs_level2.clone()\n\n\n inputs_level3, inputs_level3_tformat = _build_model_inputs(self.input_columns_level3,\n inputs,\n to_variable=True,\n inputs_tformat=tformat,\n )\n\n action_tensor = None\n if self.is_obs_noise(test_mode):\n action_tensor = ttype(self.n_agents,\n sampled_pairs.shape[_bsdim(tformat)],\n sampled_pairs.shape[_tdim(tformat)],\n 1).fill_(float(\"nan\"))\n for _bid in range(sampled_pairs.shape[_bsdim(tformat)]):\n # each agent has it's own assumptions about what pair-wise actions were sampled!\n for _aid in range(self.n_agents):\n # work out which pair id agent _aid is in (if any) and whether at first or second position\n partid = None\n posid = None\n #for _partid, _part in enumerate(_ordered_2_agent_pairings(self.n_agents)):\n combid = int(sampled_pair_ids[_aid, _bid, 0, 0].item())\n part = list(_ordered_2_agent_pairings(self.n_agents))[combid]\n for pid, p in enumerate(part):\n agentids = _pairing_id_2_agent_ids(p, self.n_agents)\n if agentids[0] == _aid:\n partid = pid\n posid = 0\n break\n if agentids[1] == _aid:\n partid = pid\n posid = 1\n break\n pass\n if partid is not None:\n # ok so what actions did agent _aid finally select?\n joint_act = self.actions_level2_sampled[_aid][partid,_bid,0,0].item()\n joint_act_dec = _joint_actions_2_action_pair(int(joint_act), self.n_actions)\n if joint_act_dec == 11: # DEBUG\n a = 5\n if joint_act_dec != 0: # else delegate\n action_tensor[_aid,_bid,0,:] = joint_act_dec[posid]\n else:\n # decentralized anyway!\n pass\n else:\n action_tensor = ttype(self.n_agents,\n pair_sampled_actions.shape[_bsdim(tformat)],\n pair_sampled_actions.shape[_tdim(tformat)],\n 1).fill_(float(\"nan\"))\n for i in range(sampled_pairs.shape[-1]):\n sampled_pair = sampled_pairs[:,:,:,i:i+1]\n pair_id1, pair_id2 = _pairing_id_2_agent_ids__tensor(sampled_pair, self.n_agents,\n \"a*bs*t*v\") # sampled_pair_ids.squeeze(0).squeeze(2).view(-1), self.n_agents)\n\n avail_actions1 = inputs_level3[\"agent_input_level3\"][\"avail_actions\"].gather(\n _adim(inputs_level3_tformat), Variable(pair_id1.repeat(1, 1, 1, inputs_level3[\"agent_input_level3\"][\n \"avail_actions\"].shape[_vdim(inputs_level3_tformat)])))\n avail_actions2 = inputs_level3[\"agent_input_level3\"][\"avail_actions\"].gather(\n _adim(inputs_level3_tformat), Variable(pair_id2.repeat(1, 1, 1, inputs_level3[\"agent_input_level3\"][\n \"avail_actions\"].shape[_vdim(inputs_level3_tformat)])))\n\n # selected_level_2_actions = pair_sampled_actions.gather(0, sampled_pair_ids.long())\n this_pair_sampled_actions = pair_sampled_actions.gather(0, sampled_pair.long())\n\n actions1, actions2 = _joint_actions_2_action_pair_aa(this_pair_sampled_actions.clone(),\n self.n_actions,\n avail_actions1,\n avail_actions2)\n # count how often level2 actions are un-available at level 3\n # TODO: Verify that 'this_pair_sampled_actions != 0' is the right thing to do!!\n pair_action_unavail_rate = (th.mean(((actions1 != actions1) & (this_pair_sampled_actions != 0)).float()).item() +\n th.mean(((actions2 != actions2) & (this_pair_sampled_actions != 0)).float()).item()) / 2.0\n if pair_action_unavail_rate != 0.0 and hasattr(self.args, \"mackrl_delegate_if_zero_ck\") and self.args.mackrl_delegate_if_zero_ck:\n #assert False, \"pair action unavail HAS to be zero in mackrl_delegate_if_zero_ck setting!\"\n self.logging_struct.py_logger.warning(\"ERROR: pair action unavail HAS to be zero in mackrl_delegate_if_zero_ck setting!\")\n\n self._add_stat(\"pair_action_unavail_rate__runner\",\n pair_action_unavail_rate,\n T_env=T_env,\n suffix=test_suffix,\n to_sacred=False)\n\n # Now check whether any of the pair_sampled_actions violate individual agent constraints on avail_actions\n ttype = th.cuda.FloatTensor if self.args.use_cuda else th.FloatTensor\n\n\n action_tensor.scatter_(0, pair_id1, actions1)\n action_tensor.scatter_(0, pair_id2, actions2)\n\n avail_actions_level3 = inputs_level3[\"agent_input_level3\"][\"avail_actions\"].clone().data\n self.avail_actions = avail_actions_level3.clone()\n\n inputs_level3[\"agent_input_level3\"][\"avail_actions\"] = Variable(avail_actions_level3,\n requires_grad=False)\n\n out_level3, hidden_states_level3, losses_level3, tformat_level3 = self.model.models[\"level3_{}\".format(0)](inputs_level3[\"agent_input_level3\"],\n hidden_states=hidden_states[\"level3\"],\n loss_fn=None,\n tformat=inputs_level3_tformat,\n test_mode=test_mode,\n seq_lens=inputs[\"agent_input_level3__agent0\"].seq_lens,\n **kwargs)\n # extract available actions\n avail_actions_level3 = inputs_level3[\"agent_input_level3\"][\"avail_actions\"]\n\n individual_actions, \\\n modified_inputs_level3, \\\n selected_actions_format_level3 = self.action_selector.select_action({\"policies\":out_level3},\n avail_actions=avail_actions_level3.data,\n tformat=tformat_level3,\n test_mode=test_mode)\n\n self.actions_level3 = individual_actions\n action_tensor[action_tensor != action_tensor] = individual_actions[action_tensor != action_tensor]\n\n # set states beyond episode termination to NaN\n if self.is_obs_noise(test_mode):\n action_tensor = _pad_nan(action_tensor, tformat=tformat_level3,\n seq_lens=inputs[\"agent_input_level1__agent0\"].seq_lens) # DEBUG\n else:\n action_tensor = _pad_nan(action_tensor, tformat=tformat_level3, seq_lens=inputs[\"agent_input_level1\"].seq_lens) # DEBUG\n # l2 = action_tensor.squeeze() # DEBUG\n if self.args.debug_mode in [\"level3_actions_only\"]:\n \"\"\"\n DEBUG MODE: LEVEL3 ACTIONS ONLY\n Here we just pick actions from level3 - should therefore just correspond to vanilla COMA!\n \"\"\"\n action_tensor = individual_actions\n\n self.final_actions = action_tensor.clone()\n if th.sum(self.final_actions == 11).item() > 0: # DEBUG\n a = 5\n pass\n\n if self.is_obs_noise(test_mode):\n selected_actions_list = []\n selected_actions_list += [dict(name=\"actions\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.final_actions)]\n modified_inputs_list = []\n else:\n #self.actions_level3 = individual_actions.clone()\n self.selected_actions_format_level3 = selected_actions_format_level3\n self.policies_level3 = modified_inputs_level3.clone()\n self.avail_actions_active = avail_actions_level3.data\n\n selected_actions_list = []\n for _i in range(_n_agent_pair_samples(self.n_agents) if self.args.n_pair_samples is None else self.args.n_pair_samples): #_n_agent_pair_samples(self.n_agents)):\n selected_actions_list += [dict(name=\"actions_level1__sample{}\".format(_i),\n data=self.actions_level1[_i])]\n for _i in range(_n_agent_pair_samples(self.n_agents)):\n selected_actions_list += [dict(name=\"actions_level2__sample{}\".format(_i),\n data=self.actions_level2_sampled[_i])] # TODO: BUG!?\n selected_actions_list += [dict(name=\"actions_level2\",\n select_agent_ids=list(range(_n_agent_pairings(self.n_agents))),\n data=self.actions_level2)]\n selected_actions_list += [dict(name=\"actions_level3\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.actions_level3)]\n selected_actions_list += [dict(name=\"actions\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.final_actions)]\n\n modified_inputs_list = []\n modified_inputs_list += [dict(name=\"policies_level1\",\n data=self.policies_level1)]\n for _i in range(_n_agent_pair_samples(self.n_agents)):\n modified_inputs_list += [dict(name=\"policies_level2__sample{}\".format(_i),\n data=self.policies_level2[_i])]\n modified_inputs_list += [dict(name=\"policies_level3\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.policies_level3)]\n modified_inputs_list += [dict(name=\"avail_actions_active\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.avail_actions_active)]\n modified_inputs_list += [dict(name=\"avail_actions\",\n select_agent_ids=list(range(self.n_agents)),\n data=self.avail_actions)]\n\n #modified_inputs_list += [dict(name=\"avail_actions\",\n # select_agent_ids=list(range(self.n_agents)),\n # data=self.avail_actions)]\n\n selected_actions_list += [dict(name=\"actions_onehot\",\n select_agent_ids=list(range(self.n_agents)),\n data=_onehot(self.final_actions, rng=(0, self.n_actions)))]\n\n hidden_states = dict(level1=hidden_states_level1,\n level2=hidden_states_level2,\n level3=hidden_states_level3)\n\n return hidden_states, selected_actions_list, modified_inputs_list, self.selected_actions_format\n\n pass\n\n else:\n assert False, \"Not implemented\"","def _init_fns_predict_feature(self, cfg):\n self._fns_predict_feature = []\n self._feature_sizes = []\n if (cfg.feature_layers is None): \n return\n\n if not isinstance(cfg.feature_layers, collections.Iterable):\n cfg.feature_layers = [cfg.feature_layers]\n\n for i, f_idx in enumerate(cfg.feature_layers):\n f_layer = self.net.layers[f_idx]\n\n if (hasattr(f_layer, 'output_dim')):\n self._feature_sizes.append(f_layer.output_dim)\n\n elif (hasattr(f_layer, 'output_shape')):\n self._feature_sizes.append(f_layer.output_shape[1])\n\n else:\n raise Exception(\"Feature layers chosen are invalid. \" +\n \"`cfg.feature_layers`\")\n\n # IMPORTANT: \n # Retrieves the output tensor(s) of a layer at a given node.\n # f_layer.get_output_at(node_index): \n\n # Retrieves the output tensor(s) of a layer (only applicable if\n # the layer has exactly one inbound node, i.e. if it is connected\n # to one incoming layer).\n # f_layer.output\n self._fns_predict_feature.append(\n K.function(self.net.inputs + [K.learning_phase()],\n [f_layer.output]))","def _select_masks_to_boundaries(self, select_masks):\n\n def _merge(node_covers, select_idx):\n \"\"\"\n node_covers [[s1, e1], [s2, e2], ..., [sn, en]]\n \"\"\"\n new_node_covers = []\n for i in range(len(node_covers) - 1):\n if i == select_idx:\n merge_node_boundary = [node_covers[select_idx][0], node_covers[select_idx + 1][1]]\n new_node_covers.append(merge_node_boundary)\n elif i < select_idx:\n new_node_covers.append(node_covers[i])\n else:\n new_node_covers.append(node_covers[i + 1])\n return new_node_covers, merge_node_boundary\n batch_size = select_masks[0].size()[0]\n max_length = select_masks[0].size()[1] + 1\n combine_matrix = torch.rand(batch_size, max_length, 2).long()\n for j in range(max_length):\n combine_matrix[:, j, :] = j\n results = []\n for batch_idx in range(batch_size):\n node_covers = combine_matrix[batch_idx, :, :].numpy().tolist()\n result = []\n for node_idx in range(max_length - 2):\n select = select_masks[node_idx][batch_idx, :]\n select_idx = torch.nonzero(select).data[0][0]\n node_covers, merge_boundary = _merge(node_covers, select_idx)\n result.append(merge_boundary)\n results.append(result)\n results = torch.LongTensor(results)\n return results","def call(self, inputs):\n for index,layer in enumerate(self.list_cnn):\n if index == 0:\n out = layer(inputs)\n else:\n if self.residual:\n prev_out = out\n cur_out = layer(out)\n if self.use_batchnorm:\n cur_out = layers.BatchNormalization()(cur_out)\n if self.use_dropout:\n cur_out = layers.Dropout(0.2)(cur_out)\n out = prev_out + cur_out\n else:\n out = layer(out)\n out = self.output_layer(out)\n if self.use_pool:\n out = self.pool(out)\n out = self.flatten(out)\n out = self.classify(out)\n return out","def run(self, model):\n activation_statistics = self._stats_collector.get_statistics_for_algorithm(self.name)\n\n act_nodes = mu.get_nodes_by_type(model, self._act_types)\n for act_node in act_nodes:\n if act_node.fullname not in activation_statistics:\n logger.debug('Stats After {} not found!'.format(act_node.fullname))\n continue\n min_after_act = np.min(activation_statistics[act_node.fullname]['min_per_tensor'])\n max_after_act = np.max(activation_statistics[act_node.fullname]['max_per_tensor'])\n clamp_attrs = {'min': min_after_act, 'max': max_after_act}\n clamp_name = act_node.name + '/min_max_Clamp'\n clamp_node = ge.create_node(act_node.graph, clamp_name, 'AttributedClamp', clamp_attrs)\n clamp_node['fullname'] = nu.reset_node_fullname(act_node.fullname, clamp_name)\n\n dest_ports = act_node.out_port(0).get_destinations()\n act_node.out_port(0).disconnect()\n clamp_node.in_port(0).connect(act_node.out_port(0))\n\n for dest_port in dest_ports:\n dest_port.connect(clamp_node.out_port(0))\n return model"],"string":"[\n \"def learning_Utility(self):\\n # Shape the input that we give to the neural network with the value of sensors, the previous actions the life of the agent \\n # Get the results from the sensors according the different movement executed by the agent \\n sensors_result_N = self.agent.sensors(self, direction=3) + self.agent.get_energy_coarsed()+\\\\\\n self.agent.rotate_previousAction(3)+[self.agent.get_previous_collision()]\\n sensors_result_O = self.agent.sensors(self, direction=2) + self.agent.get_energy_coarsed()+\\\\\\n self.agent.rotate_previousAction(2) + [self.agent.get_previous_collision()]\\n sensors_result_S = self.agent.sensors(self, direction=1) + self.agent.get_energy_coarsed()+\\\\\\n self.agent.rotate_previousAction(1) + [self.agent.get_previous_collision()]\\n sensors_result_E = self.agent.sensors(self, direction=0) + self.agent.get_energy_coarsed()+\\\\\\n self.agent.rotate_previousAction(0) + [self.agent.get_previous_collision()]\\n\\n input_nn_N = np.asarray(sensors_result_N).astype(int) # input when the Nord action is performed \\n input_nn_O = np.asarray(sensors_result_O).astype(int) # input when the West action is performed\\n input_nn_S = np.asarray(sensors_result_S).astype(int) # input when the South action is performed\\n input_nn_E = np.asarray(sensors_result_E).astype(int) # input when the West action is performed\\n\\n self.input_list = [input_nn_E.reshape(1,145),\\n input_nn_S.reshape(1,145),\\n input_nn_O.reshape(1,145),\\n input_nn_N.reshape(1,145)]\\n self.U_list = [self.nn.predict(i) for i in self.input_list ] #The utility according the different acts performed \\n return self.actionSelector() #Select the action acording a propbabilitics distribution given in the paper\",\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def compute_data(self) -> TensorsData:\\n\\n if len(self.intermediate_outputs) == 0:\\n return self.calibrate_tensors_range\\n\\n output_names = [self.infer_session.get_outputs()[i].name for i in range(len(self.intermediate_outputs[0]))]\\n output_dicts_list = [\\n dict(zip(output_names, intermediate_output)) for intermediate_output in self.intermediate_outputs\\n ]\\n\\n merged_output_dict = {}\\n for d in output_dicts_list:\\n for k, v in d.items():\\n merged_output_dict.setdefault(k, []).append(v)\\n added_output_names = output_names[self.num_model_outputs :]\\n calibrate_tensor_names = [\\n added_output_names[i].rpartition(\\\"_\\\")[0] for i in range(0, len(added_output_names), 2)\\n ] # output names\\n\\n merged_added_output_dict = {\\n i: merged_output_dict[i] for i in merged_output_dict if i not in self.model_original_outputs\\n }\\n\\n pairs = []\\n for i in range(0, len(added_output_names), 2):\\n min_value = 0\\n max_value = 0\\n if self.moving_average:\\n min_value_array = np.mean(merged_added_output_dict[added_output_names[i]], axis=0)\\n max_value_array = np.mean(merged_added_output_dict[added_output_names[i + 1]], axis=0)\\n else:\\n min_value_array = min(merged_added_output_dict[added_output_names[i]])\\n max_value_array = max(merged_added_output_dict[added_output_names[i + 1]])\\n if type(min_value_array) == int or min_value_array.size > 0:\\n min_value = float(min_value_array)\\n if type(max_value_array) == int or max_value_array.size > 0:\\n max_value = float(max_value_array)\\n\\n if self.symmetric:\\n max_absolute_value = max(abs(min_value), abs(max_value))\\n pairs.append(tuple([-max_absolute_value, max_absolute_value]))\\n else:\\n pairs.append(tuple([min_value, max_value]))\\n\\n new_calibrate_tensors_range = TensorsData(CalibrationMethod.MinMax, dict(zip(calibrate_tensor_names, pairs)))\\n if self.calibrate_tensors_range:\\n self.calibrate_tensors_range = self.merge_range(self.calibrate_tensors_range, new_calibrate_tensors_range)\\n else:\\n self.calibrate_tensors_range = new_calibrate_tensors_range\\n\\n return self.calibrate_tensors_range\",\n \"def _learn_node_parameter_w(outputs, inputs=None):\\n num_inputs = 0 if inputs is None else inputs.shape[1]\\n weights = np.zeros(shape=num_inputs + 1)\\n\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # Ax = b, A\\n N_observe = outputs.shape[0]\\n A = np.zeros(shape = (num_inputs+1, num_inputs+1))\\n for i in range(A.shape[0]):\\n for j in range(A.shape[1]):\\n if i==0 and j==0:\\n A[i][j] = N_observe\\n elif i==0 and j!=0:\\n A[i][j] = np.sum(inputs[:,j-1])\\n elif i!=0 and j==0:\\n A[i][j] = np.sum(inputs[:,i-1])\\n else:\\n for k in range(N_observe):\\n A[i][j] += inputs[k,i-1]*inputs[k, j-1]\\n b = np.zeros(shape=num_inputs + 1)\\n for i in range(len(b)):\\n if i==0:\\n b[i] = np.sum(outputs)\\n else:\\n for k in range(N_observe):\\n b[i] += inputs[k,i-1]*outputs[k]\\n\\n weights = np.linalg.solve(A, b)\\n \\\"\\\"\\\" END YOUR CODE HERE \\\"\\\"\\\"\\n\\n return weights\",\n \"def __init__(self, in_channels, out_channels=None, kernel_size=None, stride=1, dilation=1, groups=1,\\n rd_ratio=1./16, rd_channels=None, rd_divisor=8, keep_3x3=True, split_input=True,\\n act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, aa_layer=None, drop_layer=None):\\n super(SelectiveKernel, self).__init__()\\n out_channels = out_channels or in_channels\\n kernel_size = kernel_size or [3, 5] # default to one 3x3 and one 5x5 branch. 5x5 -> 3x3 + dilation\\n _kernel_valid(kernel_size)\\n if not isinstance(kernel_size, list):\\n kernel_size = [kernel_size] * 2\\n if keep_3x3:\\n dilation = [dilation * (k - 1) // 2 for k in kernel_size]\\n kernel_size = [3] * len(kernel_size)\\n else:\\n dilation = [dilation] * len(kernel_size)\\n self.num_paths = len(kernel_size)\\n self.in_channels = in_channels\\n self.out_channels = out_channels\\n self.split_input = split_input\\n if self.split_input:\\n assert in_channels % self.num_paths == 0\\n in_channels = in_channels // self.num_paths\\n groups = min(out_channels, groups)\\n\\n conv_kwargs = dict(\\n stride=stride, groups=groups, act_layer=act_layer, norm_layer=norm_layer,\\n aa_layer=aa_layer, drop_layer=drop_layer)\\n self.paths = nn.ModuleList([\\n ConvNormActAa(in_channels, out_channels, kernel_size=k, dilation=d, **conv_kwargs)\\n for k, d in zip(kernel_size, dilation)])\\n\\n attn_channels = rd_channels or make_divisible(out_channels * rd_ratio, divisor=rd_divisor)\\n self.attn = SelectiveKernelAttn(out_channels, self.num_paths, attn_channels)\",\n \"def fit_select(rel_src_pos, node_pos, node_orients, outlier_percent, error):\\n _, n_srcs, n_nodes = rel_src_pos.shape\\n n_select = int((1 - outlier_percent) * n_srcs)\\n devs = np.zeros((n_srcs, n_nodes, n_nodes - 1))\\n rot_mats = dsm.rot_angle2rot_mat(node_orients)\\n src_pos_candidates = np.einsum('abc, bdc -> adc', rot_mats, rel_src_pos)\\n src_pos_candidates += np.expand_dims(node_pos, 1)\\n for node_id in range(n_nodes):\\n dev = (src_pos_candidates[:, :, node_id, None]\\n - np.delete(src_pos_candidates[:, :], node_id, axis=-1))\\n devs[:, node_id] = np.linalg.norm(dev, axis=0)\\n dist2neighbors = np.mean(devs, -1)\\n return np.argsort(error + dist2neighbors, axis=0)[:n_select]\",\n \"def candidate(self, input_r_state, ctrl):\\n kernel = tf.get_variable(\\n 'kernel', [self._concat_size, self._num_units, self._num_modules])\\n bias = tf.get_variable(\\n 'bias', [1, self._num_units, self._num_modules],\\n initializer=tf.zeros_initializer())\\n\\n square_kernel = tf.reshape(kernel, [self._concat_size, -1])\\n multiplied = tf.reshape(tf.matmul(input_r_state, square_kernel),\\n [-1, self._num_units, self._num_modules])\\n\\n all_outputs = self._activation(multiplied + bias)\\n scaled_outputs = tf.matmul(all_outputs, tf.expand_dims(ctrl, axis=-1))\\n return tf.squeeze(scaled_outputs, axis=-1)\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def optimize(opt):\\n # load new target\\n if opt.is_poly:\\n target_mesh = om.read_polymesh(opt.model)\\n else:\\n target_mesh = om.read_trimesh(opt.model)\\n target_shape_arr = target_mesh.points()\\n target_shape = target_shape_arr.copy()\\n target_shape = torch.from_numpy(\\n target_shape[:, :3].astype(np.float32)).cuda()\\n target_shape.unsqueeze_(0)\\n\\n target_faces_arr = target_mesh.face_vertex_indices()\\n target_faces = target_faces_arr.copy()\\n target_faces = torch.from_numpy(\\n target_faces[:, :3].astype(np.int64)).cuda()\\n target_faces.unsqueeze_(0)\\n\\n states = torch.load(opt.ckpt)\\n if \\\"states\\\" in states:\\n states = states[\\\"states\\\"]\\n cage_v = states[\\\"template_vertices\\\"].transpose(1, 2).cuda()\\n cage_f = states[\\\"template_faces\\\"].cuda()\\n shape_v = states[\\\"source_vertices\\\"].transpose(1, 2).cuda()\\n shape_f = states[\\\"source_faces\\\"].cuda()\\n\\n if os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")) and os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")):\\n new_label_path = opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")\\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")\\n logger.info(\\\"Loading picked labels {} and {}\\\".format(orig_label_path, new_label_path))\\n new_label = pd.read_csv(new_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n orig_label = pd.read_csv(orig_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n orig_label_name = orig_label.iloc[:,5]\\n new_label_name = new_label.iloc[:,5].tolist()\\n new_to_orig_idx = []\\n for i, name in enumerate(new_label_name):\\n matched_idx = orig_label_name[orig_label_name==name].index\\n if matched_idx.size == 1:\\n new_to_orig_idx.append((i, matched_idx[0]))\\n new_to_orig_idx = np.array(new_to_orig_idx)\\n if new_label.shape[1] == 10:\\n new_vidx = new_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,0]]\\n target_points = target_shape[:, new_vidx, :]\\n else:\\n new_label_points = torch.from_numpy(new_label.iloc[:,6:9].to_numpy().astype(np.float32))\\n target_points = new_label_points.unsqueeze(0).cuda()\\n target_points, new_vidx, _ = faiss_knn(1, target_points, target_shape, NCHW=False)\\n target_points = target_points.squeeze(2) # B,N,3\\n new_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\\n new_label.to_csv(new_label_path, sep=\\\" \\\", header=[str(new_label.shape[0])]+[\\\"\\\"]*(new_label.shape[1]-1), index=False)\\n target_points = target_points[:, new_to_orig_idx[:,0], :]\\n\\n target_points = target_points.cuda()\\n source_shape, _ = read_trimesh(opt.source_model)\\n source_shape = torch.from_numpy(source_shape[None, :,:3]).float()\\n if orig_label.shape[1] == 10:\\n orig_vidx = orig_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,1]]\\n source_points = source_shape[:, orig_vidx, :]\\n else:\\n orig_label_points = torch.from_numpy(orig_label.iloc[:,6:9].to_numpy().astype(np.float32))\\n source_points = orig_label_points.unsqueeze(0)\\n # find the closest point on the original meshes\\n source_points, new_vidx, _ = faiss_knn(1, source_points, source_shape, NCHW=False)\\n source_points = source_points.squeeze(2) # B,N,3\\n orig_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\\n orig_label.to_csv(orig_label_path, sep=\\\" \\\", header=[str(orig_label.shape[0])]+[\\\"\\\"]*(orig_label.shape[1]-1), index=False)\\n source_points = source_points[:,new_to_orig_idx[:,1],:]\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n source_points = source_points.cuda()\\n # # shift target so that the belly match\\n # try:\\n # orig_bellyUp_idx = orig_label_name[orig_label_name==\\\"bellUp\\\"].index[0]\\n # orig_bellyUp = orig_label_points[orig_bellyUp_idx, :]\\n # new_bellyUp_idx = [i for i, i2 in new_to_orig_idx if i2==orig_bellyUp_idx][0]\\n # new_bellyUp = new_label_points[new_bellyUp_idx,:]\\n # target_points += (orig_bellyUp - new_bellyUp)\\n # except Exception as e:\\n # logger.warn(\\\"Couldn\\\\'t match belly to belly\\\")\\n # traceback.print_exc(file=sys.stdout)\\n\\n # source_points[0] = center_bounding_box(source_points[0])[0]\\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")) and \\\\\\n os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")):\\n logger.info(\\\"Could not find {}. Assuming SMPL model\\\".format(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\\\\n \\\"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\\\".format(\\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\"))\\n # align faces not vertices\\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")\\n logger.info(\\\"Loading picked labels {}\\\".format(orig_label_path))\\n orig_label = pd.read_csv(orig_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\\n idx = torch.from_numpy(orig_label.iloc[:,1].to_numpy()).long()\\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, source_faces[:, idx, :, None].expand(-1, -1, -1, 3))\\n source_points = source_points.mean(dim=-2)\\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, target_faces[:, idx, :, None].expand(-1, -1, -1, 3))\\n target_points = target_points.mean(dim=-2)\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")):\\n logger.info(\\\"Could not find {}. Assuming SMPL model\\\".format(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\\\\n \\\"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\\\".format(\\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\"))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n\\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\\n # select a subset of faces, otherwise optimization is too slow\\n idx = torch.from_numpy(np.random.permutation(2048)).cuda().long()\\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, source_faces[:, idx,:, None].expand(-1, -1, -1, 3))\\n source_points = source_points.mean(dim=-2)\\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, target_faces[:,idx,: None].expand(-1, -1, -1, 3))\\n target_points = target_points.mean(dim=-2)\\n\\n\\n target_points = target_points[:, idx]\\n source_points = source_points[:, idx]\\n\\n\\n target_shape[0], target_center, target_scale = center_bounding_box(target_shape[0])\\n _, _, source_scale = center_bounding_box(shape_v[0])\\n # scale according y axis (body height)\\n target_scale_factor = (source_scale/target_scale)[0,1]\\n target_shape *= target_scale_factor\\n target_points -= target_center\\n target_points = (target_points*target_scale_factor).detach()\\n # make sure test use the normalized\\n target_shape_arr[:] = target_shape[0].cpu().numpy()\\n om.write_mesh(os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\\n os.path.basename(opt.model))[0]+\\\"_normalized.obj\\\"), target_mesh)\\n opt.model = os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\\n os.path.basename(opt.model))[0]+\\\"_normalized.obj\\\")\\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \\\"template-initial.obj\\\"),\\n shape_v[0].cpu().numpy(), shape_f[0].cpu().numpy())\\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \\\"cage-initial.obj\\\"),\\n cage_v[0].cpu().numpy(), cage_f[0].cpu().numpy())\\n save_ply(target_points[0].cpu().numpy(), os.path.join(\\n opt.log_dir, opt.subdir, \\\"target_points.ply\\\"))\\n save_ply(source_points[0].cpu().numpy(), os.path.join(\\n opt.log_dir, opt.subdir, \\\"source_points.ply\\\"))\\n logger.info(\\\"Optimizing for {} corresponding vertices\\\".format(\\n target_points.shape[1]))\\n\\n cage_init = cage_v.clone().detach()\\n lap_loss = MeshLaplacianLoss(torch.nn.MSELoss(reduction=\\\"none\\\"), use_cot=True,\\n use_norm=True, consistent_topology=True, precompute_L=True)\\n mvc_reg_loss = MVCRegularizer(threshold=50, beta=1.0, alpha=0.0)\\n cage_v.requires_grad_(True)\\n optimizer = torch.optim.Adam([cage_v], lr=opt.lr, betas=(0.5, 0.9))\\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer, int(opt.nepochs*0.4), gamma=0.5, last_epoch=-1)\\n\\n if opt.dim == 3:\\n weights_ref = mean_value_coordinates_3D(\\n source_points, cage_init, cage_f, verbose=False)\\n else:\\n raise NotImplementedError\\n\\n for t in range(opt.nepochs):\\n optimizer.zero_grad()\\n weights = mean_value_coordinates_3D(\\n target_points, cage_v, cage_f, verbose=False)\\n loss_mvc = torch.mean((weights-weights_ref)**2)\\n # reg = torch.sum((cage_init-cage_v)**2, dim=-1)*1e-4\\n reg = torch.tensor(0.0).cuda()\\n if opt.clap_weight > 0:\\n reg = lap_loss(cage_init, cage_v, face=cage_f)*opt.clap_weight\\n reg = reg.mean()\\n if opt.mvc_weight > 0:\\n reg += mvc_reg_loss(weights)*opt.mvc_weight\\n\\n loss = loss_mvc + reg\\n if (t+1) % 50 == 0:\\n print(\\\"t {}/{} mvc_loss: {} reg: {}\\\".format(t, opt.nepochs, loss_mvc.item(), reg.item()))\\n\\n if loss_mvc.item() < 5e-6:\\n break\\n loss.backward()\\n optimizer.step()\\n scheduler.step()\\n\\n return cage_v, cage_f\",\n \"def _reset_parameters(self):\\n self._solver_input[\\\"P\\\"] = cvxopt.matrix(2.0 * self.opt.P(self.p).toarray())\\n self._solver_input[\\\"q\\\"] = cvxopt.matrix(self.opt.q(self.p).toarray().flatten())\\n if self.opt_type in CONSTRAINED_OPT:\\n if self.opt.nk > 0:\\n self._solver_input[\\\"G\\\"] = cvxopt.matrix(-self.opt.M(self.p).toarray())\\n self._solver_input[\\\"h\\\"] = cvxopt.matrix(\\n self.opt.c(self.p).toarray().flatten()\\n )\\n if self.opt.na > 0:\\n self._solver_input[\\\"A\\\"] = cvxopt.matrix(self.opt.A(self.p).toarray())\\n self._solver_input[\\\"b\\\"] = cvxopt.matrix(-self.opt.b(self.p).toarray())\",\n \"def cfdProcessNodeTopology(self):\\r\\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\\r\\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)\",\n \"def setupConnections(self):\\n self.T1Button.connect('clicked(bool)', self.onApplyButton)\\n self.RViewButton.connect('clicked(bool)', self.onApplyRViewButton)\\n self.CheckButton.connect('stateChanged(int)', self.onCheckbuttonChecked)\\n self.LLE_Selector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.onSelectLLENode)\\n self.LLN_Selector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.onSelectLLNNode)\\n self.Aref_Selector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.onSelectArefNode)\\n\\n self.ThSlider_LLE.Slider.connect(\\\"positionsChanged(double,double)\\\",self.ThSlider_LLE.onSliderChanged)\\n self.ThSlider_LLE.SpinBoxL.connect(\\\"valueChanged(int)\\\", self.ThSlider_LLE.onSpinBoxLChanged)\\n self.ThSlider_LLE.SpinBoxR.connect(\\\"valueChanged(int)\\\", self.ThSlider_LLE.onSpinBoxRChanged)\\n \\n self.ThSlider_LLN.Slider.connect(\\\"positionsChanged(double,double)\\\",self.ThSlider_LLN.onSliderChanged)\\n self.ThSlider_LLN.SpinBoxL.connect(\\\"valueChanged(int)\\\", self.ThSlider_LLN.onSpinBoxLChanged)\\n self.ThSlider_LLN.SpinBoxR.connect(\\\"valueChanged(int)\\\", self.ThSlider_LLN.onSpinBoxRChanged) \\n\\n self.ThSlider_ECV.Slider.connect(\\\"positionsChanged(double,double)\\\",self.ThSlider_ECV.onSliderChanged)\\n self.ThSlider_ECV.SpinBoxL.connect(\\\"valueChanged(int)\\\", self.ThSlider_ECV.onSpinBoxLChanged)\\n self.ThSlider_ECV.SpinBoxR.connect(\\\"valueChanged(int)\\\", self.ThSlider_ECV.onSpinBoxRChanged)\\n \\n self.Stats.segmentationSelector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.Stats.onScalarSelectorChanged)\\n self.Stats.scalarSelector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.Stats.onScalarSelectorChanged)\\n self.Stats.scalarSelector2.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.Stats.onScalarSelector2Changed)\\n self.Stats.SButton.connect('clicked(bool)', self.onApplyGetStatistics)\\n\\n self.NativeT1_Selector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.onSelectNT1Node)\\n self.EnhancedT1_Selector.connect(\\\"currentNodeChanged(vtkMRMLNode*)\\\", self.onSelectET1Node)\\n self.SB_NBlodd.connect(\\\"valueChanged(Double)\\\", self.onSpinBoxNBChanged)\\n self.SB_EBlodd.connect(\\\"valueChanged(Double)\\\", self.onSpinBoxEBChanged)\\n self.SB_Haematocrit.connect(\\\"valueChanged(Double)\\\", self.onSpinBoxHChanged)\\n self.ECVButton.connect('clicked(bool)',self.onApplyECVButton)\",\n \"def feature_selection(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\\n\\t# percentile selector\\n\\tpercentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask = best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\t# model based selector\\n\\tmodel_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask = best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\t# iterative based selector\\n\\titerative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask = best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\tall_scores = []\\n\\n\\tregressor.fit(train_features, train_similarity_target)\\n\\tprint(\\\"The score on all features: %.3f\\\" % regressor.score(test_features, test_similarity_target))\\n\\tall_scores.append(regressor.score(test_features, test_similarity_target))\\n\\n\\t# show results for the percentile selector\\n\\tall_scores.append(percentile_score)\\n\\n\\t# show results for the model based selector\\n\\tall_scores.append(model_based_score)\\n\\n\\t# show results for the iterative based selector\\n\\tall_scores.append(iterative_based_score)\\n\\n\\tmax_value_position = all_scores.index(max(all_scores))\\n\\n\\tif max_value_position == 0:\\n\\t\\tprint(\\\"Returning all features!\\\\n\\\")\\n\\t\\treturn train_features, test_features\\n\\telif max_value_position == 1:\\n\\t\\tpercentile_mask = build_mask(percentile_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'percentile_mask.txt')\\n\\t\\tdebug_data(percentile_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the percentile selector!\\\\n\\\")\\n\\t\\treturn percentile_selector, percentile_train_features_selected, percentile_test_features_selected\\n\\telif max_value_position == 2:\\n\\t\\tmodel_based_mask = build_mask(model_based_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'model_based_mask.txt')\\n\\t\\tdebug_data(model_based_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the model based selector!\\\\n\\\")\\n\\t\\treturn model_based_selector, model_based_train_features_selected, model_based_test_features_selected\\n\\telse:\\n\\t\\titerative_based_mask = build_mask(iterative_based_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'iterative_based_mask.txt')\\n\\t\\tdebug_data(iterative_based_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the iterative based selector!\\\\n\\\")\\n\\t\\treturn iterative_based_selector, iterative_based_train_features_selected, iterative_based_test_features_selected\",\n \"def __initilization(self,node_set):\\n \\n print \\\"*********************************\\\"\\n \\n for x in node_set:\\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\\n \\n print \\\"Forward/Backward Algorithm Initialization Done!\\\"\",\n \"def _learn_node_parameter_var(outputs, weights, inputs):\\n var = 0.\\n\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n temp = 0\\n N_observe = outputs.shape[0]\\n if inputs is None:\\n temp = np.sum((outputs-weights[0])**2)\\n else:\\n for i in range(N_observe):\\n temp += (outputs[i] - (np.sum(weights[1:] * inputs[i]) +weights[0]))**2\\n var = temp/N_observe\\n\\n\\n\\n \\\"\\\"\\\" END YOUR CODE HERE \\\"\\\"\\\"\\n\\n return var\",\n \"def switch_to_tuned_inputs(self):\\n \\n self.h_e=self.inputs_flat.T\\n self.h=np.vstack([self.h_e,self.h_i])\",\n \"def input_nodes(self):\\n pass\",\n \"def __init__(self, channels, num_paths=2, attn_channels=32, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d):\\n super(SelectiveKernelAttn, self).__init__()\\n self.num_paths = num_paths\\n self.fc_reduce = nn.Conv2d(channels, attn_channels, kernel_size=1, bias=False)\\n self.bn = norm_layer(attn_channels)\\n self.act = act_layer(inplace=True)\\n self.fc_select = nn.Conv2d(attn_channels, channels * num_paths, kernel_size=1, bias=False)\",\n \"def call(self, inputs, **kwargs):\\n inputs_expanded = K.expand_dims(inputs, axis=1)\\n #print('inputs_expanded', inputs_expanded.shape)\\n #print('robust_mean', self.robust_mean.shape)\\n\\n x_minus_mu = inputs_expanded - self.robust_mean\\n #print('x_minus_mu', x_minus_mu.shape)\\n\\n left_term = list()\\n for i in range(self.n_clusters):\\n x = x_minus_mu[:, i, :]\\n left = K.dot(x, self.inv_covmat[i])\\n left = K.expand_dims(left, axis=1)\\n if len(left_term) == 0:\\n left_term = left\\n else:\\n #left_term = K.stack([left_term, left], axis=1)\\n left_term = K.concatenate([left_term, left], axis=1)\\n\\n #print('inv_covmat', self.inv_covmat.shape)\\n #print('left_term', left_term.shape)\\n\\n left_term_T = K.permute_dimensions(left_term, (1, 0, 2))\\n x_minus_mu_T = K.permute_dimensions(x_minus_mu, (1, 0, 2))\\n #print('x_minus_mu_T', x_minus_mu_T.shape)\\n #print('left_term_T', left_term_T.shape)\\n\\n mahal = K.batch_dot(left_term_T, x_minus_mu_T, axes=[2, 2])\\n #print('mahal', mahal.shape)\\n\\n mahal_diagonal = list()\\n for i in range(self.n_clusters):\\n m = mahal[i, :, :]\\n diagonal = tf.linalg.tensor_diag_part(m)\\n diagonal = K.expand_dims(diagonal, axis=1)\\n\\n if len(mahal_diagonal) == 0:\\n mahal_diagonal = diagonal\\n else:\\n #mahal_diagonal = K.stack([mahal_diagonal, diagonal], axis=1)\\n mahal_diagonal = K.concatenate(\\n [mahal_diagonal, diagonal], axis=1)\\n\\n #print('mahal_diagonal', mahal_diagonal.shape)\\n\\n md = K.sqrt(mahal_diagonal)\\n #print('md', md.shape)\\n\\n divide_alpha = md / self.alpha\\n\\n # the numnerator in q_ịj formular in the paper\\n numerator = 1.0 / (1.0 + divide_alpha)\\n numerator **= (self.alpha + 1.0) / 2.0\\n\\n denominator = K.sum(numerator, axis=1)\\n\\n quiu = K.transpose(numerator) / denominator\\n quiu = K.transpose(quiu)\\n\\n #print('quiu', quiu.shape)\\n\\n return quiu\",\n \"def select_features(self):\\n print 'tuning alpha'\\n hyper_params_model = lm.LassoCV(normalize=True, n_jobs=-1).fit(\\n self.data.loc[self.train_index, self.features_], self.data.loc[self.train_index, self.target_name])\\n print 'alpha is: {}'.format(hyper_params_model.alpha_)\\n print 'fitting lasso to get coefficients'\\n model = lm.Lasso(alpha=hyper_params_model.alpha_, normalize=True)\\n model.fit(self.data.loc[self.train_index, self.features_],\\n self.data.loc[self.train_index, self.target_name])\\n with open('lasso_coefficients.txt', 'w') as f:\\n for coef, feature in sorted(zip(model.coef_, self.features_)):\\n f.write('{} : {}\\\\n'.format(feature, coef))\\n if coef not in [-0.0, 0.0]:\\n self.selected_features_.append(feature)\",\n \"def selectOptimalExposureCallback(self):\\n rospy.loginfo('Starting automatic exposure selection algorithm')\\n\\n # Start searching for the optimal exposure\\n best_exp_pass1 = self.runPass(range(100, 27100, 3000), rate=self.rate)\\n # first pass, find coarse exposure\\n if best_exp_pass1 > 0:\\n rospy.loginfo('First pass: success!')\\n rospy.loginfo(\\n 'Best exposure in first pass: {}'.format(best_exp_pass1))\\n\\n # second pass, refine the exposure\\n exp_range = [int(exp) for exp in np.linspace(\\n 0.9*best_exp_pass1, 1.1*best_exp_pass1, 10)]\\n best_exp_pass2 = self.runPass(exp_range, rate=self.rate)\\n\\n if best_exp_pass2 > 0:\\n rospy.loginfo('Second pass: success!')\\n rospy.loginfo(\\n 'Best exposure in second pass: {}'.format(best_exp_pass2))\\n optimal_exposure = best_exp_pass2\\n else:\\n rospy.logerr(\\n 'Second pass: failure\\\\nSetting the best exposure found in first pass')\\n optimal_exposure = best_exp_pass1\\n\\n self.client.update_configuration({\\\"exposure\\\": optimal_exposure})\\n self.reset()\\n\\n else:\\n rospy.logerr(\\n 'First pass: failure\\\\nCould not auto-set the exposure')\",\n \"def solve(self):\\n\\t\\t# row and column to control the selected corner\\n\\t\\tcurrent_positions = [0, 0]\\n\\t\\tmax_row = self.result_index[self.__ROW_INDEX]-1\\n\\t\\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\\n\\t\\twhile self.matrix[max_row][max_col] != 0:\\n\\t\\t\\tcurrent_row = current_positions[self.__ROW_INDEX]\\n\\t\\t\\tcurrent_column = current_positions[self.__COLUMN_INDEX]\\n\\t\\t\\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\\n\\t\\t\\tactual_weight = self.matrix[current_row][current_column]\\n\\t\\t\\tactual_result_weight = multiplier_selected[1]\\n\\t\\t\\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\\n\\t\\t\\tself.matrix[max_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[current_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[max_row][current_column] -= actual_result_weight\\n\\t\\t\\tcurrent_positions[multiplier_selected[0]] += 1\",\n \"def stage_one(self, imgs, threshold, factor, minsize, nms_threshold):\\n\\n width = imgs.shape[-2]\\n height = imgs.shape[-1]\\n num_img = imgs.shape[0]\\n\\n # Compute valid scales\\n scales = []\\n cur_width = width\\n cur_height = height\\n cur_factor = 1\\n while cur_width >= 12 and cur_height >= 12:\\n if 12 / cur_factor >= minsize: # Ignore boxes that smaller than minsize\\n\\n w = cur_width\\n h = cur_height\\n scales.append((w, h, cur_factor))\\n\\n cur_factor *= factor\\n cur_width = math.ceil(cur_width * factor)\\n cur_height = math.ceil(cur_height * factor)\\n\\n # Get candidate boxesi ph\\n candidate_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n candidate_scores = torch.empty(0, device=self.device)\\n candidate_offsets = torch.empty(\\n 0, dtype=torch.float32, device=self.device)\\n all_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for w, h, f in scales:\\n resize_img = torch.nn.functional.interpolate(\\n imgs, size=(w, h), mode='bilinear')\\n p_distribution, box_regs, _ = self.pnet(resize_img)\\n\\n candidate, scores, offsets, img_labels = self._generate_bboxes(\\n p_distribution, box_regs, f, threshold)\\n\\n candidate_boxes = torch.cat([candidate_boxes, candidate])\\n candidate_scores = torch.cat([candidate_scores, scores])\\n candidate_offsets = torch.cat([candidate_offsets, offsets])\\n all_img_labels = torch.cat([all_img_labels, img_labels])\\n\\n \\n if candidate_boxes.shape[0] != 0:\\n candidate_boxes = self._calibrate_box(\\n candidate_boxes, candidate_offsets)\\n candidate_boxes = self._convert_to_square(candidate_boxes)\\n candidate_boxes = self._refine_boxes(\\n candidate_boxes, width, height)\\n \\n final_boxes = torch.empty(0, dtype=torch.int32, device=self.device)\\n final_img_labels = torch.empty(0, dtype=torch.int32, device=self.device)\\n for i in range(num_img):\\n mask = all_img_labels == i\\n keep = func.nms(candidate_boxes[mask].cpu().numpy(),\\n candidate_scores[mask].cpu().numpy(), nms_threshold)\\n final_boxes = torch.cat([final_boxes, candidate_boxes[mask][keep]])\\n final_img_labels = torch.cat([final_img_labels, all_img_labels[mask][keep]])\\n\\n return torch.cat([final_boxes, final_img_labels.unsqueeze(1 )], -1)\\n else:\\n return candidate_boxes\",\n \"def training_batch_selection(train_set_size, input_img):\\n\\n input_dims = input_img.shape\\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\\n all_data_indices = all_data_indices.reshape(input_dims[:-1])\\n\\n conf = get_config()\\n inside = int(np.floor(conf[\\\"inside_part\\\"]))\\n outside = int(np.floor(conf[\\\"outside_part\\\"]))\\n cx = ii.image.c_x\\n cy = ii.image.c_y\\n\\n # Find the position of the crop in the image and determine part least affected by radial distortion\\n center_x = (conf[\\\"crop\\\"][\\\"left_top\\\"]['x'] + conf[\\\"crop\\\"][\\\"size\\\"][\\\"height\\\"]/2)*2/ii.image.height-1.\\n center_y = (conf[\\\"crop\\\"][\\\"left_top\\\"]['y'] + conf[\\\"crop\\\"][\\\"size\\\"][\\\"width\\\"]/2)*2/ii.image.width-1.\\n\\n left_right_center = max(min((center_y-cy)*2, 1), -1)\\n top_bot_center = max(min((center_x - cx) * 2, 1), -1)\\n\\n # DEBUG: set your own center\\n # left_right_center = 0\\n # top_bot_center = 0\\n\\n from_x = int(round(inside*(1.-top_bot_center)))\\n to_x = min(-int(round(inside*(1.+top_bot_center))), -1)\\n from_y = int(round(inside*(1.-left_right_center)))\\n to_y = min(-int(round(inside*(1.+left_right_center))), -1)\\n\\n # Exclude part that is minimally affected by radial distortion\\n selection_exclude = all_data_indices[from_x:to_x, from_y:to_y]\\n selection_exclude = selection_exclude.reshape(-1)\\n\\n # Exclude outer border in order to avoid index out of bounds\\n selection_include = all_data_indices[outside:-outside,\\n outside:-outside]\\n selection_include = selection_include.reshape(-1)\\n\\n selection = [x for x in selection_include if x not in selection_exclude]\\n selection = np.random.permutation(selection)\\n\\n # DEBUG: forcing larger training set\\n train_set_size = int(train_set_size*2)\\n\\n selection = selection[:train_set_size]\\n\\n # DEBUG: display image region for selection\\n image = input_img.reshape(-1)\\n image[:] = 0\\n image[selection_include] = input_img.reshape(-1)[selection_include]\\n image[selection_exclude] = 0\\n image = image.reshape(input_dims[0], input_dims[1])\\n Verbose.imshow(image, Verbose.debug)\\n\\n return selection\",\n \"def _prepare_input(\\n self, data: Union[Dict[str, torch.Tensor], torch.Tensor, np.ndarray]\\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\\n\\n # convert ot dict\\n if isinstance(data, torch.Tensor):\\n p4 = data\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n elif isinstance(data, np.ndarray):\\n p4 = torch.from_numpy(data)\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n\\n node_ps = data[\\\"p4\\\"].to(device=self.device, dtype=self.dtype) * self.scale\\n if self.jet_features:\\n jet_p = torch.sum(node_ps, dim=-2).unsqueeze(-2)\\n node_ps = torch.cat((node_ps, jet_p), dim=-2)\\n\\n scalars = normsq4(node_ps).abs().sqrt().unsqueeze(-1)\\n if self.jet_features:\\n jet_mass = (\\n normsq4(torch.sum(node_ps, dim=-2))\\n .unsqueeze(-1)\\n .unsqueeze(-1)\\n .repeat(1, self.num_input_particles, 1)\\n )\\n scalars = torch.cat((scalars, jet_mass), dim=-1)\\n\\n # Calculate node masks and edge masks\\n if \\\"labels\\\" in data:\\n node_mask = data[\\\"labels\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"masks\\\" in data:\\n node_mask = data[\\\"masks\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"mask\\\" in data:\\n node_mask = data[\\\"mask\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n else:\\n node_mask = data[\\\"p4\\\"][..., 0] != 0\\n node_mask = node_mask.to(device=self.device, dtype=torch.uint8)\\n if self.jet_features:\\n jet_mask = torch.ones_like(node_mask[..., 0:1])\\n jet_mask = jet_mask.to(device=self.device, dtype=torch.uint8)\\n node_mask = torch.cat((node_mask, jet_mask), dim=-1)\\n edge_mask = node_mask.unsqueeze(1) * node_mask.unsqueeze(2)\\n\\n if \\\"scalars\\\" in data.keys():\\n # (0,0) representation\\n scalars = torch.cat(\\n [scalars, data[\\\"scalars\\\"].to(device=self.device, dtype=self.dtype)],\\n dim=-1,\\n )\\n\\n return scalars, node_ps, node_mask, edge_mask\",\n \"def best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\\n\\tmodel_based_score = 0\\n\\tscaling_factors = [\\\"0.25*mean\\\", \\\"0.5*mean\\\", \\\"median\\\", \\\"1.25*mean\\\", \\\"1.5*mean\\\"]\\n\\t# scaling_factors = [\\\"0.5*mean\\\", \\\"median\\\"]\\n\\tmodel_based_selector = None\\n\\tmodel_based_train_features_selected = None\\n\\tmodel_based_test_features_selected = None\\n\\n\\tfor factor in scaling_factors:\\n\\t\\tprint(factor)\\n\\t\\ttemp_model_based_selector = SelectFromModel(RandomForestRegressor(n_estimators=100), threshold=factor)\\n\\t\\ttemp_model_based_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_model_based_train_features_selected = temp_model_based_selector.transform(train_features)\\n\\t\\ttemp_model_based_test_features_selected = temp_model_based_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_model_based_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_model_based_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Model Based Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > model_based_score:\\n\\t\\t\\tmodel_based_score = temp_score\\n\\t\\t\\tmodel_based_selector = temp_model_based_selector\\n\\t\\t\\tmodel_based_train_features_selected = temp_model_based_train_features_selected\\n\\t\\t\\tmodel_based_test_features_selected = temp_model_based_test_features_selected\\n\\n\\tmodel_based_mask = model_based_selector.get_support()\\n\\tprint(\\\"This is the model based mask: \\\")\\n\\tprint(model_based_mask)\\n\\n\\treturn model_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask\",\n \"def __call__(self, inputs: np.ndarray):\\n # Denote the impact the inputs have directly on the outputs\\n output_inputs: np.ndarray = np.matmul(self.in2out, inputs.transpose()).transpose()\\n \\n # Denote the impact hidden nodes have on the outputs, if there are hidden nodes\\n if self.n_hidden > 0:\\n # Nice to know:\\n # - np.transpose() will transpose the tensor\\n # - np.matmul(tensor1, tensor2) will perform a matrix multiplication between tensor and tensor2\\n \\n # The activation is defined by:\\n # - the inputs mapping to the hidden nodes\\n # - the hidden nodes mapping to themselves\\n # - the hidden nodes' biases\\n \\n # 1) Propagate the hidden nodes\\n self.hidden_act = self.act_f(np.matmul(self.in2hid, inputs.transpose()).transpose() +\\n np.matmul(self.hid2hid, self.hidden_act.transpose()).transpose() +\\n self.hidden_biases)\\n \\n # 2) Execute the RNN nodes if they exists (updating current hidden state)\\n for i, rnn_idx in enumerate(self.rnn_idx):\\n self.rnn_state[:, i] = self.rnn_array[i](\\n np.concatenate((self.in2hid[rnn_idx] * inputs,\\n self.hid2hid[rnn_idx] * self.hidden_act),\\n axis=1)[self.rnn_map[i]].reshape(self.bs, self.rnn_array[i].input_size)\\n )\\n self.hidden_act[:, rnn_idx] = self.rnn_state[:, i, 0]\\n \\n # 3) Propagate hidden-values to the outputs\\n output_inputs += np.matmul(self.hid2out, self.hidden_act.transpose()).transpose()\\n \\n # Define the values of the outputs, which is the sum of their received inputs and their corresponding bias\\n self.output_act = self.act_f(output_inputs + self.output_biases)\\n return self.output_act\",\n \"def calibrate(self, x, y) -> None:\\n pass\",\n \"def reset_parameters(self) -> None:\\n \\n self.classifier.apply(xavier)\\n if len(self.old_cols) > 0:\\n self.adaptor1.apply(xavier)\\n self.adaptor2.apply(xavier)\",\n \"def train_models_change_nodes(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, beta, nodes, print_cost = True, is_charge = False):\\n \\n results = {}\\n params = {}\\n\\n try:\\n for n in nodes:\\n accs, parameters = model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, n, beta, 1.0, False, True, print_cost, is_charge)\\n \\n results[n] = accs[3]\\n params[n] = parameters\\n \\n except KeyboardInterrupt: # allow for exiting the for loop in case we want to stop testing all the hyperparameters; to use, press Ctrl+C in terminal\\n pass\\n \\n best = min(results, key=results.get)\\n mapes = [results[l] for l in nodes]\\n\\n if print_cost:\\n plt.plot(nodes, mapes)\\n plt.ylabel('MAPE')\\n plt.xlabel('# of nodes in hidden layer')\\n plt.title(\\\"learning rate = {}, mini-batch = {}, beta = {}\\\".format(learning_rate, minibatch_size, beta))\\n plt.show()\\n \\n return results, best, params[best]\",\n \"def torch_NN(nn_in, \\n nn_out, \\n min_ar, \\n max_ar, \\n er_tar,\\n main_win: tk.Toplevel, \\n min_n=0, \\n max_n=0, \\n n_epochs=200, \\n conf=[1,1,1], \\n funs=[tr.nn.Sigmoid(), 0], \\n lr=0.001, \\n sect_ner=False, \\n train_test=False, \\n retrain=False, \\n spl_coef=0.1,\\n root_width=200, \\n root_height=200, \\n root_x=50, \\n root_y=50):\\n tr.manual_seed(42)\\n in_orig=tr.from_numpy(np.array(nn_in.copy())).float()\\n out_orig=tr.from_numpy(np.array(nn_out.copy())).float()\\n if train_test or retrain:\\n nn_in=tr.from_numpy(np.array(nn_in)).float()\\n nn_out=tr.from_numpy(np.array(nn_out)).float()\\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\\n a=int(len(dataset)*(1-spl_coef))\\n data_trn, data_test=tr.utils.data.random_split(dataset, [a,int(len(dataset)-a)],generator=tr.Generator().manual_seed(42))\\n dataloader = tr.utils.data.DataLoader(data_trn, shuffle=False, batch_size=len(data_trn))\\n else:\\n nn_in=tr.from_numpy(np.array(nn_in)).float()\\n nn_out=tr.from_numpy(np.array(nn_out)).float()\\n dataset = tr.utils.data.TensorDataset(nn_in, nn_out)\\n dataloader = tr.utils.data.DataLoader(dataset, shuffle=False, batch_size=len(dataset))\\n data_test = 0\\n if sect_ner:\\n for i in range(len(conf)-2):\\n conf[i+1] = min_n\\n for i in range(1, len(conf)-1):\\n min_loss=200000\\n b=conf[i]\\n for j in range(min_n, max_n+1):\\n conf[i]=j\\n nn_obj = Net_tr(conf, funs)\\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\\n y_pred = nn_obj.forward(nn_in)\\n loss_val = loss(y_pred, nn_out, nn_obj)\\n a=loss_val.item()\\n print(\\\"Current configuration:\\\", conf, \\\";\\\\t Loss:\\\", a, \\\"%\\\")\\n loss_val.backward()\\n optimizer.step()\\n if a<min_loss:\\n min_loss=a\\n b=j\\n conf[i]=b\\n neurons_number_info(conf, root_height + root_y, root_x)\\n print(\\\"Best configuration:\\\", conf)\\n nn_obj = Net_tr(conf, funs)\\n optimizer = tr.optim.Adam(nn_obj.parameters(), lr=lr)\\n nn_obj.alph_bet(in_orig,out_orig, min_ar, max_ar)\\n loss_test=[]\\n loss_tr=[]\\n epochs_sum = 0\\n train = True\\n lin_tr = None\\n can_tr = None\\n lin_test = None \\n can_test = None\\n vert_coef = None\\n hor_coef = None\\n while train == True:\\n nn_obj, vert_coef, hor_coef, epochs_sum, err, lin_tr, can_tr, lin_test, can_test = train_body_torch(nn_obj, dataloader, data_test, n_epochs, epochs_sum, optimizer, loss_tr, loss_test, er_tar, train_test, retrain, root_width, root_height, root_x, root_y, lin_tr, can_tr, lin_test, can_test, vert_coef, hor_coef)\\n train_win = Continue_Train(err, epochs_sum)\\n main_win.wait_window(train_win)\\n train = train_win.answer\\n if not train_win.answer:\\n return nn_obj, conf, vert_coef, hor_coef\\n #train = False\\n nn_obj.eval()\\n return nn_obj, conf, vert_coef, hor_coef\",\n \"def target_tensors(self):\\n return None\",\n \"def before_train(self, logs=None):\\n self.config = self.trainer.config\\n self.unrolled = self.trainer.config.unrolled\\n self.device = self.trainer.config.device\\n self.model = self.trainer.model\\n self.optimizer = self.trainer.optimizer\\n self.lr_scheduler = self.trainer.lr_scheduler\\n self.loss = self.trainer.loss\\n self.search_alg = SearchAlgorithm(SearchSpace())\\n self._set_algorithm_model(self.model)\\n self.trainer.train_loader = self.trainer._init_dataloader(mode='train')\\n self.trainer.valid_loader = self.trainer._init_dataloader(mode='val')\\n normal_selected_idxs = torch.tensor(len(self.model.alphas_normal) * [-1],\\n requires_grad=False, dtype=torch.int).cuda()\\n reduce_selected_idxs = torch.tensor(len(self.model.alphas_reduce) * [-1],\\n requires_grad=False, dtype=torch.int).cuda()\\n normal_candidate_flags = torch.tensor(len(self.model.alphas_normal) * [True],\\n requires_grad=False, dtype=torch.bool).cuda()\\n reduce_candidate_flags = torch.tensor(len(self.model.alphas_reduce) * [True],\\n requires_grad=False, dtype=torch.bool).cuda()\\n logging.info('normal_selected_idxs: {}'.format(normal_selected_idxs))\\n logging.info('reduce_selected_idxs: {}'.format(reduce_selected_idxs))\\n logging.info('normal_candidate_flags: {}'.format(normal_candidate_flags))\\n logging.info('reduce_candidate_flags: {}'.format(reduce_candidate_flags))\\n self.model.normal_selected_idxs = normal_selected_idxs\\n self.model.reduce_selected_idxs = reduce_selected_idxs\\n self.model.normal_candidate_flags = normal_candidate_flags\\n self.model.reduce_candidate_flags = reduce_candidate_flags\\n logging.info(F.softmax(torch.stack(self.model.alphas_normal, dim=0), dim=-1).detach())\\n logging.info(F.softmax(torch.stack(self.model.alphas_reduce, dim=0), dim=-1).detach())\\n self.normal_probs_history = []\\n self.reduce_probs_history = []\",\n \"def forward(self, x):\\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\\n sources = list()\\n loc = list()\\n conf = list()\\n\\n # 对输入图像卷积到conv4_3，将特征添加到sources中\\n for k in range(23):\\n x = self.vgg[k](x)\\n\\n s = self.L2Norm(x)\\n sources.append(s)\\n\\n # 继续卷积到conv7，将特征添加到sources中\\n for k in range(23, len(self.vgg)):\\n x = self.vgg[k](x)\\n sources.append(x)\\n\\n # 继续利用额外的卷积层计算，并将特征添加到sources中\\n for k, v in enumerate(self.extras):\\n x = F.relu(v(x), inplace=True)\\n if k % 2 == 1: # 间隔一层\\n sources.append(x)\\n\\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\\n for (x, l, c) in zip(sources, self.loc, self.conf):\\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\\n\\n if self.phase == \\\"test\\\":\\n output = self.detect(\\n loc.view(loc.size(0), -1, 4), # loc preds\\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\\n self.priors.type(type(x.data)) # default boxes\\n )\\n else:\\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\\n output = (\\n loc.view(loc.size(0), -1, 4),\\n conf.view(conf.size(0), -1, self.num_classes),\\n self.priors\\n )\\n return output\",\n \"def _pick(self):\\n self._source = self._chooser(self.targets, self.cat, self._kwargs,\\n self._cat_kwargs)\\n if self.input_container != \\\"other\\\":\\n assert self._source.container == self.input_container\\n\\n self.metadata['target'] = self._source.metadata\\n if self.container is None:\\n self.container = self._source.container\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def select_model():\\r\\n from sklearn import tree\\r\\n import graphviz\\r\\n\\r\\n ValidationSetAndLabels = AllSets[1]\\r\\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n TrainingSetAndLabels = AllSets[2]\\r\\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n This is the code to select the best hyperparameter (part b)\\r\\n\\r\\n for SplitCriterion in ['entropy', 'gini']:\\r\\n print \\\"Criterion: \\\" + SplitCriterion + '\\\\n'\\r\\n\\r\\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\\r\\n print \\\"max_depth: \\\" + str(MaxDepth) + '\\\\n'\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n print \\\"Accuracy for this test is: %f %%\\\" %Accuracy\\r\\n print '\\\\n'\\r\\n\\r\\n print '\\\\n'\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\\r\\n\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\\r\\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\\r\\n class_names=TrainLabels.flatten().astype(str))\\r\\n graph = graphviz.Source(dot_data)\\r\\n graph.render(\\\"output\\\")\",\n \"def train(self, decision_outputs, true_assignments):\\n t_decision_outputs = self.__transform_to_uniform_decision_tensor(decision_outputs, self.coverage)\\n super().train(t_decision_outputs, true_assignments)\",\n \"def train_and_evaluate_circuit(self):\\n self.learner_params['circuit'] = self._create_circuit_evaluator\\n self.learner = CircuitLearner(hyperparams=self.learner_params)\\n self.learner.train_circuit(steps = self.training_params[\\\"steps\\\"], tensors_to_log = self.log)\\n\\n final_params = self.learner.get_circuit_parameters()\\n \\n for name, value in final_params.items():\\n if \\\"Variable\\\" not in name:\\n print(\\\"Parameter {} has the final value {}.\\\".format(name, value))\\n\\n for gate in self.gates_structure:\\n gate_name = gate[2][\\\"name\\\"]\\n for param_name in final_params:\\n if gate_name in param_name:\\n final_value = final_params[param_name]\\n gate[2][\\\"constant\\\"] = final_value\\n break\\n\\n all_results = []\\n circuit_output = self._get_circuit_output()\\n cost_tensor = self._loss_function(circuit_output)\\n init = tf.global_variables_initializer()\\n with tf.Session() as sess:\\n sess.run(init)\\n circuit_output = sess.run(circuit_output)\\n cost_value = sess.run(cost_tensor)\\n\\n print(\\\"Total cost:\\\", cost_value)\\n return cost_value\",\n \"def apply_neurons(self):\\n for neuron in range(self.n_outputs):\\n self.uf_activate(neuron)\",\n \"def _handleInput(self, paramInput):\\n super()._handleInput(paramInput)\\n settings, notFound = paramInput.findNodesAndExtractValues(['C', 'dual', 'penalty', 'l1_ratio', 'tol', 'fit_intercept',\\n 'solver','intercept_scaling', 'max_iter', 'multi_class',\\n 'class_weight', 'random_state'])\\n # notFound must be empty\\n assert(not notFound)\\n self.initializeModel(settings)\",\n \"def apply(self, node_x, edge_x, sources, targets):\\n\\n node_x = GraphConvBlock(node_x, edge_x, sources, targets, features=32)\\n node_x = nn.relu(node_x)\\n\\n node_x = GraphConvBlock(node_x, edge_x, sources, targets, features=2)\\n node_x = nn.log_softmax(node_x)\\n\\n return node_x\",\n \"def compute(self) -> None:\\n \\n self.model.eval()\\n \\n with torch.no_grad():\\n for (input, target, _) in self.loader:\\n\\n # self.model = self.model.train(False) # TEST @lacoupe\\n output, _ = self.model(input)\\n \\n output = (output >= 0.5)\\n \\n for out, tar in zip(output, target):\\n \\n tar = bool(tar)\\n \\n if out and tar:\\n self.confusion['true_positive'] += 1\\n elif not out and not tar:\\n self.confusion['true_negative'] += 1\\n elif out and not tar:\\n self.confusion['false_positive'] += 1\\n elif not out and tar:\\n self.confusion['false_negative'] += 1\\n \\n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\\\\n / sum(list(self.confusion.values()))\\n \\n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\\n self.precision = 0.\\n else:\\n self.precision = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\\n \\n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\\n self.recall = 0.\\n else:\\n self.recall = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\\n \\n if (self.precision + self.recall) == 0.:\\n self.f1_score = 0.\\n else:\\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)\",\n \"def __init__(self, x_train0, cx_train0, cx_train_mask, cx_validation0,\\n cx_validation_mask, cx_validation, x_validation, theta,\\n auto_lr=0.01, weight_decay=0):\\n self.sample_num = x_train0.shape[0] # The number of samples\\n self.num_nodes = x_train0.shape[1] # The number of nodes of each graph\\n self.feat_num = x_train0.shape[2] # The number of features\\n\\n self.x_train0 = x_train0 # The real training set after preprocessing\\n self.cx_train0 = cx_train0 # The corrupted training set after preprocessing\\n self.cx_train_mask = cx_train_mask # The mask of the corrupted training set\\n\\n self.cx_validation0 = cx_validation0 # The corrupted validation set after preprocessing\\n self.cx_validation_mask = cx_validation_mask # The mask of the corrupted validation set\\n self.cx_validation = cx_validation # The corrupted validation set before preprocessing\\n self.x_validation = x_validation # The real validation set before preprocessing\\n\\n self.theta = theta # the theta value for the cost function\\n self.auto_lr = auto_lr # learning rate\\n self.weight_decay = weight_decay # weight decay\\n\\n self.device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n print(\\\"ConvA is running on\\\", self.device)\\n print(\\\"The version of PyTorch is\\\", torch.__version__)\\n\\n from ConvA_models import ConvAutoencoderModel\\n \\\"\\\"\\\"\\n Autoencoder with spatio-temporal graph convolutional layers.\\n \\\"\\\"\\\"\\n # construct an autoencoder\\n self.conv_autoencoder = ConvAutoencoderModel(num_nodes=self.num_nodes,\\n feat_num=self.feat_num).to(self.device)\\n # construct an optimizer\\n self.optim_auto = torch.optim.Adam(self.conv_autoencoder.parameters(),\\n lr=self.auto_lr,\\n betas=(0.9, 0.999),\\n weight_decay=self.weight_decay)\\n # and a learning rate scheduler\\n self.lr_scheduler = torch.optim.lr_scheduler.StepLR(self.optim_auto,\\n step_size=5,\\n gamma=0.9)\\n return\",\n \"def select_model_inputs_outputs(model, outputs=None, inputs=None,\\n infer_shapes=False, overwrite=None,\\n verbose=0, fLOG=None):\\n if inputs is not None and not isinstance(inputs, list):\\n inputs = [inputs]\\n if outputs is not None and not isinstance(outputs, list):\\n outputs = [outputs]\\n if inputs is None:\\n inputs = [i.name for i in model.graph.input]\\n if outputs is None:\\n outputs = [o.name for o in model.graph.output]\\n\\n mark_var = {}\\n for out in enumerate_model_node_outputs(model):\\n mark_var[out] = 0\\n for inp in inputs:\\n mark_var[inp] = 0\\n for out in outputs:\\n if out not in mark_var:\\n raise ValueError( # pragma: no cover\\n \\\"Output '{}' not found in model.\\\".format(out))\\n mark_var[out] = 1\\n\\n nodes = model.graph.node[::-1]\\n mark_op = {}\\n for node in nodes:\\n mark_op[node.name] = 0\\n\\n # We mark all the nodes we need to keep.\\n nb = 1\\n while nb > 0:\\n nb = 0\\n for node in nodes:\\n if mark_op[node.name] == 1:\\n continue\\n mod = False\\n for out in node.output:\\n if mark_var[out] == 1:\\n mark_op[node.name] = 1\\n mod = True\\n break\\n if not mod:\\n continue\\n\\n nb += 1\\n for inp in node.input:\\n if inp in inputs:\\n continue\\n if mark_var.get(inp, 0) == 1:\\n continue\\n mark_var[inp] = 1\\n nb += 1\\n\\n # All nodes verifies mark_op[node.name] == 1\\n keep_nodes = [node for node in nodes if mark_op[node.name] == 1]\\n\\n known_shapes = {}\\n if infer_shapes:\\n shapes = shape_inference.infer_shapes(model)\\n for shape in shapes.graph.value_info: # pylint: disable=E1101\\n known_shapes[shape.name] = shape.type\\n for shape in shapes.graph.input: # pylint: disable=E1101\\n known_shapes[shape.name] = shape.type\\n for shape in shapes.graph.output: # pylint: disable=E1101\\n known_shapes[shape.name] = shape.type\\n else:\\n for shape in model.graph.input: # pylint: disable=E1101\\n known_shapes[shape.name] = shape.type\\n for shape in model.graph.output: # pylint: disable=E1101\\n known_shapes[shape.name] = shape.type\\n\\n var_in = []\\n for name in inputs:\\n if overwrite is not None and name in overwrite:\\n dtype, shape = overwrite[name]\\n proto_dtype = guess_proto_dtype(dtype)\\n value_info = helper.make_tensor_value_info(\\n name, proto_dtype, shape)\\n elif name in known_shapes:\\n info = known_shapes[name].tensor_type\\n proto_dtype = info.elem_type\\n if proto_dtype == 0:\\n value_info = helper.ValueInfoProto()\\n value_info.name = name\\n else:\\n shape = [getattr(d, 'dim_value', None) for d in info.shape.dim]\\n shape = [None if s == 0 else s for s in shape]\\n value_info = helper.make_tensor_value_info(\\n name, proto_dtype, shape)\\n else:\\n value_info = helper.ValueInfoProto()\\n value_info.name = name\\n var_in.append(value_info)\\n\\n var_out = []\\n for name in outputs:\\n if overwrite is not None and name in overwrite:\\n dtype, shape = overwrite[name]\\n proto_dtype = guess_proto_dtype(dtype)\\n value_info = helper.make_tensor_value_info(\\n name, proto_dtype, shape)\\n elif name in known_shapes:\\n info = known_shapes[name].tensor_type\\n proto_dtype = info.elem_type\\n if proto_dtype == 0:\\n value_info = helper.ValueInfoProto()\\n value_info.name = name\\n else:\\n shape = [getattr(d, 'dim_value', None) for d in info.shape.dim]\\n shape = [None if s == 0 else s for s in shape]\\n value_info = helper.make_tensor_value_info(\\n name, proto_dtype, shape)\\n else:\\n value_info = helper.ValueInfoProto()\\n value_info.name = name\\n var_out.append(value_info)\\n\\n if verbose > 0 and fLOG is not None: # pragma: no cover\\n fLOG(\\\"[select_model_inputs_outputs] nodes %r --> %r\\\" % (\\n len(model.graph.node), len(keep_nodes)))\\n fLOG(\\\"[select_model_inputs_outputs] inputs: %r\\\" % var_in)\\n fLOG(\\\"[select_model_inputs_outputs] inputs: %r\\\" % var_out)\\n\\n graph = helper.make_graph(keep_nodes, model.graph.name, var_in,\\n var_out, model.graph.initializer)\\n onnx_model = helper.make_model(graph)\\n onnx_model.ir_version = model.ir_version\\n onnx_model.producer_name = model.producer_name\\n onnx_model.producer_version = model.producer_version\\n onnx_model.domain = model.domain\\n onnx_model.model_version = model.model_version\\n onnx_model.doc_string = model.doc_string\\n if len(model.metadata_props) > 0: # pragma: no cover\\n values = {p.key: p.value for p in model.metadata_props}\\n helper.set_model_props(onnx_model, values)\\n\\n del onnx_model.opset_import[:] # pylint: disable=E1101\\n for oimp in model.opset_import:\\n op_set = onnx_model.opset_import.add() # pylint: disable=E1101\\n op_set.domain = oimp.domain\\n op_set.version = oimp.version\\n return onnx_model\",\n \"def select(self):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n\\n best_bic_score = float(\\\"inf\\\")\\n best_model = self.base_model(self.n_constant)\\n for n in range(self.min_n_components, self.max_n_components + 1):\\n try:\\n # bic = - 2*log(likelihood) + p*log(N)\\n # N is number of data points\\n # p => number of parameters\\n # p = initial state occupation probabilities\\n # + transition probabilities\\n # + emission probabilities\\n # initial state occupation probabilities, can be obtained from n,\\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\\n # transition probabilities => n*(n - 1)\\n # emission probabilities => n * num_features * 2 = num_means + num_covar\\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\\n # p = n*n + 2*n*num_features - 1\\n\\n model = self.base_model(n)\\n log_likelihood = model.score(self.X, self.lengths)\\n num_features = len(self.X[0])\\n log_n = math.log(self.X.shape[0])\\n\\n p = n*n + 2*n*num_features - 1\\n bic = -2 * log_likelihood + p * log_n\\n if bic < best_bic_score:\\n best_bic_score = bic\\n best_model = model\\n except:\\n continue\\n\\n return best_model\",\n \"def precompute(self, features, mode, params):\\n return None\",\n \"def make_default_inputs(filtered_dot_file):\\n# w_kernel = pickle.load(open(\\\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-3.p\\\", \\\"rb\\\" ))\\n# w_kernel = pickle.load(open(\\\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-2.p\\\", \\\"rb\\\" ))\\n# w_kernel = pickle.load(open(\\\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-4.p\\\", \\\"rb\\\" ))\\n w_kernel = pickle.load(open(\\\"/Users/bptripp/code/nengo-FPGA/v1/dog-gabor-weights-new-2.p\\\", \\\"rb\\\" ))\\n filtered = pickle.load(open(filtered_dot_file, \\\"rb\\\" ))\\n \\n n_inputs = 200\\n centres = np.random.randn(n_inputs,2)\\n mag = np.sum(centres**2, axis=1)**(1/2)\\n centres = 155 * centres.T / mag\\n centres = centres * np.random.rand(n_inputs)**(1/2)\\n centres = np.round(centres).astype('int')\\n centres = centres + 199 #put in image centre\\n \\n inputs = get_inputs(w_kernel, filtered, centres.T)\\n \\n pickle.dump(inputs, open(filtered_dot_file.replace('-filt.p', '-inputs.p'), \\\"wb\\\" ))\",\n \"def update(self):\\n\\n self._eps_count += 1\\n if self._replay.size >= self._min_replay_size:\\n for _ in range(self._learning_updates):\\n samples_indices, minibatch = self._replay.sample(self._batch_size)\\n tf_minibatch = [tf.constant(mat, dtype=tf_type) for mat, tf_type in zip(minibatch, [tf.float32, tf.int32, tf.float32, tf.float32, tf.float32])]\\n self._learn(*tf_minibatch)\\n\\n self._learn_iter_counter += 1\\n if (self._target_update_period > 1) and (self._learn_iter_counter % self._target_update_period == 0):\\n self._update_target_nets()\",\n \"def run():\\n cons_in, soln_in, disc = make_discriminator()\\n target, loss, accuracy, optimiser = make_training_nodes(disc)\\n training_set_sampler = make_sampler(cons_in, soln_in, target)\\n test_set_sampler = make_sampler(cons_in, soln_in, target)\\n\\n disc.get_session().run(tf.global_variables_initializer())\\n\\n fit(\\n disc.get_session(),\\n optimiser,\\n training_set_sampler,\\n 250,\\n 2000,\\n 32,\\n [(\\\"Loss\\\", loss), (\\\"Accuracy\\\", accuracy)],\\n )\\n\\n print(\\n \\\"Validation accuracy: {}\\\".format(\\n disc.feed(accuracy, test_set_sampler.batch(1024))\\n )\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: disc.feed(\\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\\n )[0],\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\",\n \"def do_calibration(x,y,z,temperature,cp, optimal_t=25):\\n # if temperature is used for calibration:\\n if temperature is not None:\\n # create an array of T - optimal_T (temperature minus the optimal temperature) i.e. the deviation in T from the optimum\\n temp_dev = np.empty(len(temperature.data))\\n for i in range(len(temperature.data)):\\n temp_dev[i] = temperature.data[i] - optimal_t\\n\\n x.data = cp[\\\"x_offset\\\"] + (temp_dev * cp[\\\"x_temp_offset\\\"]) + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (temp_dev * cp[\\\"y_temp_offset\\\"]) + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (temp_dev * cp[\\\"z_temp_offset\\\"]) + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.temp_offset = cp[\\\"x_temp_offset\\\"]\\n y.temp_offset = cp[\\\"y_temp_offset\\\"]\\n z.temp_offset = cp[\\\"z_temp_offset\\\"]\\n\\n # if temperature is not used for calibration:\\n else:\\n x.data = cp[\\\"x_offset\\\"] + (x.data * cp[\\\"x_scale\\\"])\\n y.data = cp[\\\"y_offset\\\"] + (y.data * cp[\\\"y_scale\\\"])\\n z.data = cp[\\\"z_offset\\\"] + (z.data * cp[\\\"z_scale\\\"])\\n\\n x.offset = cp[\\\"x_offset\\\"]\\n x.scale = cp[\\\"x_scale\\\"]\\n x.calibrated = True\\n\\n y.offset = cp[\\\"y_offset\\\"]\\n y.scale = cp[\\\"y_scale\\\"]\\n y.calibrated = True\\n\\n z.offset = cp[\\\"z_offset\\\"]\\n z.scale = cp[\\\"z_scale\\\"]\\n z.calibrated = True\",\n \"def set_weights_to_layers(self, candidate):\\r\\n last_idx = 0\\r\\n\\r\\n # Iterate over every layer\\r\\n for layer_idx in range(0, self.num_layers, 1):\\r\\n if layer_idx %2 == 0 : \\r\\n # Get layer dimensions\\r\\n w_shape = self.layers[layer_idx].weight.shape\\r\\n w_numel = np.prod(w_shape)\\r\\n if self.bias :\\r\\n b_shape = self.layers[layer_idx].bias.shape\\r\\n b_numel = np.prod(b_shape)\\r\\n # Decode the candidate and get weight, bias matrices\\r\\n weight = candidate[last_idx:last_idx + w_numel].reshape(w_shape)\\r\\n last_idx += w_numel\\r\\n if self.bias :\\r\\n bias = candidate[last_idx:last_idx + b_numel].reshape(b_shape)\\r\\n last_idx += b_numel\\r\\n else :\\r\\n bias = []\\r\\n\\r\\n# if self.gpu:\\r\\n# weight = weight.to(device='cuda:'+str(model.rank))\\r\\n# if self.bias:\\r\\n# bias = bias.to(device='cuda:'+str(model.rank))\\r\\n# # Set layer weight, bias\\r\\n self.layers[layer_idx].weight = torch.nn.Parameter(weight)\\r\\n if self.bias :\\r\\n self.layers[layer_idx].bias = torch.nn.Parameter(bias)\",\n \"def train(self, **kwargs):\\n self.solver.train(**kwargs)\",\n \"def _compute_outputs(self, *args, **kwargs):\\n pass\\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\\n # self.logits = self.outputs[0][0]\\n # self.probs = torch.softmax(self.logits, 1)\",\n \"def compute_all(self) -> None:\\n self.compute_j_matrix()\\n self.compute_outter_distribution()\\n self.compute_max_prior()\\n self.compute_max_poutter()\",\n \"def fit(self):\\n self._minuit_problem.migrad() # run optimizer\\n self._status = 0 if self._minuit_problem.migrad_ok() else 1\",\n \"def apply(self, inputs):\\n raise NotImplementedError()\",\n \"def fit(self, data_matrix, target=None):\\n self.selected_instances = self.selector.fit_transform(data_matrix, target=target)\\n if self.scale:\\n self.scale = False\\n self.scaler.fit(self.transform(data_matrix))\\n self.scale = True\\n return self\",\n \"def gate_activation(recurrent_net, inputs):\\n score, select = torch.zeros(len(inputs)), torch.zeros(len(inputs))\\n for (i, xi) in enumerate(inputs):\\n out = recurrent_net.activate(xi.view(1, 1))\\n select[i], score[i] = out.view(2)\\n score, select = score.numpy(), select.numpy()\\n mask = (select > 0.5)\\n return mask, score\",\n \"def call(self, inputs):\\n if self.backward_compatible:\\n kernel = tf.keras.backend.reshape(self.kernel, self.kernel_shape)\\n bias = (tf.keras.backend.reshape(self.bias, self.bias_shape)\\n if self.use_bias else None)\\n else:\\n kernel = self.kernel\\n bias = self.bias\\n\\n if self.output_projection:\\n ret = tf.einsum(\\\"abcd,cde->abe\\\", inputs, kernel)\\n else:\\n ret = tf.einsum(\\\"abc,cde->abde\\\", inputs, kernel)\\n if self.use_bias:\\n ret += bias\\n if self.activation is not None:\\n return self.activation(ret)\\n return ret\",\n \"async def compute(self, *args):\\n\\n if self.is_output:\\n await self.output_compute(*args)\\n else:\\n await self.input_compute(*args)\",\n \"def selectFeatures(k_features=5, *args):\\n X, y = args\\n skb = SelectKBest(k=k_features)\\n return skb.fit_transform(X, y)\",\n \"def do_calibration(self):\\n goal = CalculateParametersGoal()\\n self.calibrate_client.send_goal(goal)\\n self.calibrate_client.wait_for_result()\\n result = self.calibrate_client.get_result()\\n rospy.loginfo('Received the calibration results')\\n if result.number_of_images is 0:\\n rospy.logerr('Failed to calibrate the camera.')\\n else:\\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)\",\n \"def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\\n return calibrate(self.model, dataset)\",\n \"def _reset_parameters(self) -> None:\\n self._setup_input = {\\n \\\"P\\\": csc_matrix(2.0 * self.opt.P(self.p).toarray()),\\n \\\"q\\\": self.opt.q(self.p).toarray().flatten(),\\n }\\n if self.opt_type in CONSTRAINED_OPT:\\n A = self.opt.A(self.p)\\n b = self.opt.b(self.p)\\n self._setup_input[\\\"A\\\"] = csc_matrix(\\n cs.vertcat(self.opt.M(self.p), A, -A).toarray()\\n )\\n self._setup_input[\\\"l\\\"] = (\\n cs.vertcat(-self.opt.c(self.p), -b, b).toarray().flatten()\\n )\",\n \"def _select_node(self, logits):\\n\\n # assert tf.reduce_all(logits) == logits, \\\"Probs should not contain any nans\\\"\\n\\n if self.decode_type == \\\"greedy\\\":\\n selected = torch.argmax(logits, dim=-1) # (batch_size, 1)\\n\\n elif self.decode_type == \\\"sampling\\\":\\n # logits has a shape of (batch_size, 1, n_nodes), we have to squeeze it\\n # to (batch_size, n_nodes) since tf.random.categorical requires matrix\\n cat_dist = Categorical(logits=logits[:, 0, :]) # creates categorical distribution from tensor (batch_size)\\n selected = cat_dist.sample() # takes a single sample from distribution\\n else:\\n assert False, \\\"Unknown decode type\\\"\\n\\n return torch.squeeze(selected, -1) # (batch_size,)\",\n \"def activate(self, inputs, max_iters=10, verbose=False):\\n # Node activation values\\n self.node_vals = np.zeros(self.A.shape[0])\\n\\n # Bool to check if node was activated in the current time step\\n self.active_nodes = np.zeros((self.A.shape[0]), dtype=bool)\\n\\n # Label inputs and bias as active\\n self.active_nodes[self.inputs] = True\\n self.active_nodes[self.bias] = True\\n\\n # While some output nodes are inactive, pass the signal farther\\n # through the network\\n\\n i=0\\n # while not self.active_nodes[self.outputs].all():\\n while True:\\n\\n # Activate inputs\\n # NOTE: This step disallows recurrent connections between hidden and input nodes\\n\\n self.node_vals[self.inputs] = inputs\\n self.node_vals[self.bias] = 1.\\n\\n # Drive the activations one time step farther through the network\\n self.node_vals = self.A.dot(self.node_vals)\\n\\n # Keep track of new node activations\\n self.active_nodes = (self.A != 0).dot(self.active_nodes) + self.active_nodes\\n\\n # Apply sigmoid to active nodes\\n self.node_vals[self.active_nodes] = self.sigmoid(self.node_vals[self.active_nodes])\\n if verbose:\\n print(self.node_vals)\\n\\n\\n\\n i += 1\\n # Stop if the number of iterations exceeds max_iters\\n if i > max_iters:\\n break\\n #\\n # return np.array([np.nan]*len(self.outputs))\\n\\n return self.node_vals[self.outputs]\",\n \"def forward(self, node_scalars, node_mask):\\n # Reshape\\n node_shape = node_scalars.permute(1,2,3,4,0).shape[:2] + (2*self.num_scalars,)\\n node_scalars = node_scalars.view(node_shape)\\n\\n # First MLP applied to each node\\n x = self.mlp1(node_scalars)\\n\\n # Reshape to sum over each node in graphs, setting non-existent nodes to zero.\\n node_mask = node_mask.unsqueeze(-1)\\n x = torch.where(node_mask, x, self.zero).sum(1)\\n\\n # Prediction on permutation invariant representation of graphs\\n predict = self.mlp2(x)\\n\\n return predict\",\n \"def test_known(self):\\n\\n selector = PCovCUR(n_to_select=12)\\n selector.fit(self.X, self.y)\\n\\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))\",\n \"def test_oss_sk_estimator():\\n check_estimator(OneSidedSelection)\",\n \"def infer_outputs(self):\\n # TF lack a supported API for invoking shape inference directly,\\n # so we instantiate a dummy graph and create a dummy Operation object\\n temp_graph = tf.Graph()\\n with temp_graph.as_default():\\n input_placeholders = [tf.placeholder(shape=t.shape, dtype=t.dtype) for\\n t in self._inputs]\\n # See the docs for tf.Operation for important notes about the semantics\\n # of each arg to the following constructor.\\n dummy_op = tf.Operation(self.to_node_def(), temp_graph,\\n inputs=input_placeholders)\\n self.set_outputs_from_pairs([(o.dtype, o.shape)\\n for o in dummy_op.outputs])\\n # set_outputs_from_pairs() increments the version counter, so we don't\\n # need to. Also, we haven't added edges to the graph until these\\n # outputs are connected to another node's inputs.\",\n \"def choose_action(self, node: dict, exploit: bool = False) -> tuple:\\n best_val = -np.inf\\n mcts_policy = torch.zeros(1, len(node[\\\"childs\\\"])).cuda(self.controller.device)\\n n_children = len(node[\\\"childs\\\"])\\n\\n # Get back to the root node and evaluate its children. Choose the best estimated action\\n # and move to the next node. This next node will become the new root\\n for num in range(n_children):\\n child = node[\\\"childs\\\"][num]\\n if child[\\\"prior\\\"] > 0.0:\\n Q = (\\n child[\\\"total_action_value\\\"] / child[\\\"visit_count\\\"]\\n if child[\\\"visit_count\\\"] > 0.0\\n else 0.0\\n )\\n mcts_policy[0, num] = child[\\\"visit_count\\\"]\\n if Q > best_val:\\n best_val = Q\\n action_choice = num\\n\\n if not exploit:\\n policy = torch.pow(mcts_policy, self.temperature)\\n policy = policy / policy.sum()\\n act = int(torch.multinomial(policy, 1)[0, 0])\\n mcts_policy = mcts_policy / mcts_policy.sum()\\n # print(self.normal_entropy(mcts_policy))\\n return mcts_policy, act\\n else:\\n mcts_policy = mcts_policy / mcts_policy.sum()\\n return mcts_policy, action_choice\",\n \"def select_candidates(self, X, y, candidate_mask, train_mask):\\n\\n return self.best_heuristic(X=X, y=y, candidate_mask=candidate_mask,\\n train_mask=train_mask, classifier=self.classifier,\\n n_candidates=self.n_candidates, random_state=self.pool_rng.randint(1000),\\n **self.h_kwargs)\",\n \"def calibrate(self, param_start):\\n return self.get_pnames(), self.model.fit().params.values\",\n \"def update_target(self):\\n if self.soft:\\n self.soft_update_target(self.critic1_target, self.critic1)\\n self.soft_update_target(self.critic2_target, self.critic2)\\n else:\\n if self.learn_cur % self.learn_replace == 0:\\n self.critic1_target.load_state_dict(self.critic1.state_dict())\\n self.critic2_target.load_state_dict(self.critic2.state_dict())\",\n \"def calibrate(self, Otrain, Ftrain, Feval):\\n return Otrain[0] * np.ones(len(Feval))\",\n \"def __call__(self, *args, **kwargs):\\n output, changes = self._call(self.vc.tensors(), kwargs, *args)\\n self.vc.assign(changes)\\n return output\",\n \"def select(self):\\n\\t\\twarnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n\\t\\tscore_best = float(\\\"inf\\\")\\n\\t\\tbest_model = None\\n\\t\\tfor numStates in range(self.min_n_components, self.max_n_components + 1):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tmodel = self.base_model(numStates)\\n\\t\\t\\t\\tlog_l = model.score(self.X, self.lengths)\\n\\t\\t\\t\\tp = numStates\\n\\t\\t\\t\\tlog_n = np.log(len(self.lengths))\\n\\t\\t\\t\\tscore = -2 * log_l + p * log_n\\n\\t\\t\\t\\tif score < score_best:\\n\\t\\t\\t\\t\\tscore_best = score\\n\\t\\t\\t\\t\\tbest_model = model\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tpass\\n\\n\\t\\twhile best_model is None:\\n\\t\\t\\tbest_model = self.base_model(np.random.randint(self.min_n_components, self.max_n_components + 1))\\n\\n\\t\\treturn best_model\",\n \"def _reduce(self, x, y):\\n ind = self.ind_\\n n_samples, n_features = x.shape\\n n_features_selected = sum(ind)\\n\\n for _ in range(self.iters, self.max_iter):\\n if np.count_nonzero(ind) == 0:\\n warnings.warn(\\n \\\"Sparsity parameter is too big ({}) and eliminated all coeficients\\\".format(self.threshold)\\n )\\n coef = np.zeros_like(ind, dtype=float)\\n break\\n\\n coef = self._regress(x[:, ind], y, self.alpha)\\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\\n\\n if sum(ind) == n_features_selected or self._no_change():\\n # could not (further) select important features\\n break\\n else:\\n warnings.warn(\\n \\\"STRidge._reduce did not converge after {} iterations.\\\".format(self.max_iter),\\n ConvergenceWarning,\\n )\\n try:\\n coef\\n except NameError:\\n coef = self.coef_\\n warnings.warn(\\\"STRidge._reduce has no iterations left to determine coef\\\", ConvergenceWarning)\\n self.coef_ = coef\\n self.ind_ = ind\",\n \"def best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\\n\\titerative_based_score = 0\\n\\t# given that all pairs use the same amount of features, the position 0 was arbitrarily selected to compute the number of features being used\\n\\tmin_number_features = int(0.15*len(train_features[0]))\\n\\tmax_number_features = int(0.85*len(train_features[0]))\\n\\n\\t# min_number_features = 19\\n\\t# max_number_features = 20\\n\\n\\titerative_based_selector = None\\n\\titerative_based_train_features_selected = None\\n\\titerative_based_test_features_selected = None\\n\\n\\tfor i in range(min_number_features, max_number_features):\\n\\t\\tprint(i)\\n\\t\\ttemp_iterative_based_selector = RFE(RandomForestRegressor(n_estimators=100), n_features_to_select=i)\\n\\t\\ttemp_iterative_based_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_iterative_based_train_features_selected = temp_iterative_based_selector.transform(train_features)\\n\\t\\ttemp_iterative_based_test_features_selected = temp_iterative_based_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_iterative_based_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_iterative_based_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Iterative Based Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > iterative_based_score:\\n\\t\\t\\titerative_based_score = temp_score\\n\\t\\t\\titerative_based_selector = temp_iterative_based_selector\\n\\t\\t\\titerative_based_train_features_selected = temp_iterative_based_train_features_selected\\n\\t\\t\\titerative_based_test_features_selected = temp_iterative_based_test_features_selected\\n\\n\\titerative_based_mask = iterative_based_selector.get_support()\\n\\tprint(\\\"This is the iterative based mask: \\\")\\n\\tprint(iterative_based_mask)\\n\\n\\treturn iterative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def choose_action( self):\\n \\\"\\\"\\\"greedy, random, e-greedy, boltzmann, bayesian\\\"\\\"\\\"\\n\\tif self.exploration == \\\"greedy\\\":\\n #Choose an action with the maximum expected value.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"random\\\":\\n #Choose an action randomly.\\n a = env.action_space.sample()\\n if self.exploration == \\\"e-greedy\\\":\\n #Choose an action by greedily (with e chance of random action) from the Q-network\\n if np.random.rand(1) < e or total_steps < pre_train_steps:\\n a = env.action_space.sample()\\n else:\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"boltzmann\\\":\\n #Choose an action probabilistically, with weights relative to the Q-values.\\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\\n a = np.random.choice(Q_d[0],p=Q_d[0])\\n a = np.argmax(Q_d[0] == a)\\n return a\\n if self.exploration == \\\"bayesian\\\":\\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\\n a = a[0]\\n return a\",\n \"def __call__(self, *inputs):\\n if not inputs:\\n raise ValueError(\\\"Inputs are mandatory for the DeterministicNNNode\\\")\\n \\n l = len(inputs)\\n if l % 2:\\n raise ValueError(\\\"Odd number of inputs\\\")\\n \\n islot_to_itensor = [{'loc' : inputs[i], 'scale' : inputs[i+1]} for i \\n in range(l/2)]\\n return self.build_outputs(islot_to_itensor)\",\n \"def evaluation(x_selected, y, state_of_art=False):\\n # check_number_of_clusters(X_selected)\\n # n_clusters = best_number_of_clusters\\n\\n y_true = np.asarray(y)\\n\\n if state_of_art:\\n avg_sil, model = get_results(x_selected, [max(y_true)])\\n else:\\n avg_sil, model = get_results(x_selected)\\n\\n # using GPU\\n #avg_sil, model = get_results_from_GPU(x_selected)\\n\\n \\\"\\\"\\\" VALID DISTANCES METRICS\\n 'euclidean', 'l2', 'l1', 'manhattan', 'cityblock',\\n 'braycurtis', 'canberra', 'chebyshev', 'correlation',\\n 'cosine', 'dice', 'hamming', 'jaccard', 'kulsinski',\\n 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto',\\n 'russellrao', 'seuclidean', 'sokalmichener',\\n 'sokalsneath', 'sqeuclidean', 'yule', \\\"wminkowski\\\"\\n \\n max([\\n metrics.silhouette_score(x_selected, model.labels_, metric='euclidean'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='cosine'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='manhattan'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='braycurtis'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='canberra'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='chebyshev'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='hamming'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='jaccard'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='russellrao'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='sokalsneath'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='yule'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='kulsinski'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='cityblock')\\n ])\\\"\\\"\\\"\\n\\n y_predict = model.labels_\\n\\n for i in range(0, len(y_predict)):\\n y_predict[i] = y_predict[i] + 1\\n\\n # inercia = k_means.inertia_\\n inertia = model.inertia_\\n\\n # calculate NMI\\n nmi = v_measure_score(y_true, y_predict)\\n # nmi = 0\\n\\n # calculate corrected rand\\n corrected_rand = adjusted_rand_score(y_true, y_predict)\\n # corrected_rand = 0\\n\\n # calculate f-measure\\n f_measure = f1_score(y_true, y_predict, average='micro')\\n\\n # calculate ACC\\n\\n label1 = np.unique(y_true)\\n label2 = np.unique(y_predict)\\n if len(label1) == len(label2):\\n y_permuted_predict = best_map(y_true, y_predict)\\n acc = accuracy_score(y_true, y_permuted_predict)\\n else:\\n acc = 0\\n\\n logger.log(\\\"KMeans model has\\\"\\n \\\" avg_sil = \\\" + str(avg_sil) +\\n \\\" and NMI = \\\" + str(nmi) +\\n \\\" and CR = \\\" + str(corrected_rand) +\\n \\\" and f-measure = \\\" + str(f_measure), True)\\n\\n # calculate cluster.stats\\n # dgene = stats.dist(x_selected, method='euclidean')\\n\\n \\\"\\\"\\\" fpc_result = fpc.cluster_stats(dgene,\\n model.labels_,\\n G2=False,\\n G3=False,\\n silhouette=True,\\n sepwithnoise=True,\\n noisecluster=True,\\n wgap=True)\\n\\n stats_fpc = pandas2ri.ri2py(fpc_result)\\\"\\\"\\\"\\n\\n # Compute Hopkins statistic for iris dataset\\n # nrow = X_selected.shape[0]\\n # res = factoextra.get_clust_tendency(X_selected, n=nrow - 1, graph=False)\\n # print(\\\"hopkins test: \\\"+ str(res[0]))\\n # hopkins_test = res\\n\\n # dunn = stats_fpc[24][0]\\n # dunn2 = stats_fpc[25][0]\\n # entropy = stats_fpc[26][0]\\n # ch = stats_fpc[28][0]\\n\\n dunn = 0\\n dunn2 = 0\\n entropy = 0\\n ch = 0\\n\\n # inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure\\n return ClusteringResults(max(y_predict), inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure)\",\n \"def engage(self):\\n # no sigmoid for the inputs and bias\\n if layer != 0:\\n self.outputValue = sigmoid(inputSum);\\n\\n for connection in self.outputConnections:\\n if connection.enabled == True:\\n #connection will have toNode\\n connection.toNode.inputSum += connection.weight * self.outputValue;\",\n \"def set_choices(self):\\n self.check_idxs()\\n np.random.seed()\\n self.choices = np.random.choice(self.running_idxs, self.num_selections)\\n self.running_idxs = np.delete(self.running_idxs, self.choices)\\n self.choices = torch.tensor(self.choices).cuda()\",\n \"def train_candidates(nb_layers = 4, nb_neurons = 300, p_drop = 0.15, nb_exp = 50):\\n\\n print(\\\"Calculation will be performed on {}\\\".format(device))\\n \\n # custom data loader, automatically sent to device\\n ds = imelt.data_loader()\\n\\n for i in range(nb_exp):\\n\\n print(\\\"Training model {}\\\".format(i))\\n print(\\\"...\\\\n\\\")\\n name = \\\"./model/candidates/l\\\"+str(nb_layers)+\\\"_n\\\"+str(nb_neurons)+\\\"_p\\\"+str(p_drop)+\\\"_m\\\"+str(i)+\\\".pth\\\"\\n\\n # declaring model\\n neuralmodel = imelt.model(ds.x_visco_train.shape[1],nb_neurons,nb_layers,ds.nb_channels_raman,\\n activation_function = torch.nn.GELU(), p_drop=p_drop\\n )\\n\\n # criterion for match\\n criterion = torch.nn.MSELoss(reduction='mean')\\n criterion.to(device) # sending criterion on device\\n\\n # we initialize the output bias and send the neural net on device\\n neuralmodel.output_bias_init()\\n neuralmodel = neuralmodel.float()\\n neuralmodel.to(device)\\n\\n optimizer = torch.optim.Adam(neuralmodel.parameters(), lr = 0.0003, weight_decay=0.00) # optimizer\\n neuralmodel, record_train_loss, record_valid_loss = imelt.training(neuralmodel, ds, criterion, optimizer, \\n save_switch=True, save_name=name, nb_folds=1, train_patience=400, min_delta=0.05, verbose=True)\",\n \"def val(self, subset):\\n self.set_eval()\\n if \\\"syn\\\" in subset:\\n try:\\n inputs = self.syn_val_iter.__next__()\\n except StopIteration:\\n print('Stopped as the iteration has reached to the END, and reloading the dataloader')\\n self.syn_val_iter = iter(self.syn_val_loader)\\n inputs = self.syn_val_iter.__next__()\\n self.syn_or_real = 'syn'\\n elif \\\"real\\\" in subset:\\n try:\\n inputs = self.real_val_iter.__next__()\\n except StopIteration:\\n print('Stopped as the iteration has reached to the END, and reloading the dataloader')\\n self.real_val_iter = iter(self.real_val_loader)\\n inputs = self.real_val_iter.__next__()\\n self.syn_or_real = 'real'\\n else:\\n raise RuntimeError(\\\"Need proper validation loader choose syn or real or real_eigen\\\")\\n\\n # Move all available tensors to GPU memory\\n for key, ipt in inputs.items():\\n if type(key) == tuple or key == \\\"depth_gt\\\":\\n inputs[key] = ipt.to(self.device)\\n\\n outputs, losses = {}, {}\\n with torch.no_grad():\\n # Estimated depth and segmentation\\n outputs_d, losses_d = self.process_batch(inputs)\\n outputs.update(outputs_d)\\n losses.update(losses_d)\\n\\n if \\\"depth_gt\\\" in inputs:\\n self.compute_depth_losses(inputs, outputs, losses)\\n\\n self.log(\\\"val_\\\" + self.syn_or_real, inputs, outputs, losses)\\n del inputs, outputs, losses\\n\\n self.set_train()\",\n \"def compute_output(self):\\n x, y = self.input_nodes\\n print(x.name, y.name)\\n self.output_value = backend.dot(x.output_value, y.output_value)\\n return self.output_value\",\n \"def predict_select_outputs(\\n self,\\n X,\\n select_outputs_csr,\\n pred_params=None,\\n **kwargs,\\n ):\\n if X.dtype != np.float32:\\n raise ValueError(\\\"X.dtype = {} is not supported\\\".format(X.dtype))\\n if not isinstance(X, smat.csr_matrix) and not (\\n isinstance(X, np.ndarray) and X.flags[\\\"C_CONTIGUOUS\\\"]\\n ):\\n raise ValueError(\\\"type(X) = {} is not supported\\\".format(type(X)))\\n if X.shape[1] != self.nr_features:\\n raise ValueError(\\\"Feature dimension of query matrix does not match weight matrix\\\")\\n\\n if not isinstance(select_outputs_csr, smat.csr_matrix):\\n raise ValueError(\\n \\\"type(select_outputs_csr) = {} is not supported\\\".format(type(select_outputs_csr))\\n )\\n if select_outputs_csr.shape[1] != self.nr_labels:\\n raise ValueError(\\\"Label dimension of select output matrix does not match\\\")\\n\\n if X.shape[0] != select_outputs_csr.shape[0]:\\n raise ValueError(\\\"Instance dimension of query and select output matrix do not match\\\")\\n\\n # construct pred_params\\n if pred_params is None:\\n pred_params = self.get_pred_params()\\n elif isinstance(pred_params, self.PredParams):\\n pred_params = self.PredParams.from_dict(pred_params)\\n pred_params = self._duplicate_fields_with_name_ending_with_chain(\\n pred_params, self.PredParams, self.depth\\n )\\n else:\\n raise ValueError(\\\"unknown type(pred_params)!!\\\")\\n pred_params.override_with_kwargs(kwargs)\\n\\n if self.is_predict_only:\\n for layer_depth in range(self.depth):\\n if self.get_weight_matrix_type(layer_depth) != \\\"CSC\\\":\\n raise NotImplementedError(\\n \\\"is_predict_only=True not supported for weight_matrix_type = {}\\\".format(\\n self.weight_matrix_type\\n )\\n )\\n\\n old_chain = self.get_pred_params().model_chain\\n new_chain = pred_params.model_chain\\n\\n # check if post_processor is valid (support by C++) after overriding\\n if all(\\n old_p.post_processor == new_p.post_processor\\n for (old_p, new_p) in zip(old_chain, new_chain)\\n ):\\n overridden_post_processor = None\\n elif all(new_chain[0].post_processor == new_p.post_processor for new_p in new_chain):\\n overridden_post_processor = new_chain[0].post_processor\\n else:\\n raise NotImplementedError(\\n \\\"when is_predict_only=True, post_processor is not supported for overriddng\\\"\\n )\\n\\n # Call C++ code\\n pred_alloc = ScipyCompressedSparseAllocator()\\n clib.xlinear_predict_select_outputs(\\n self.model_chain,\\n X,\\n select_outputs_csr,\\n overridden_post_processor,\\n kwargs.get(\\\"threads\\\", -1),\\n pred_alloc,\\n )\\n\\n return pred_alloc.get()\\n else:\\n select_outputs_csrs = []\\n select_outputs_csrs.insert(0, select_outputs_csr)\\n for d in range(self.depth - 2, -1, -1):\\n prev_csr = clib.sparse_matmul(\\n select_outputs_csrs[0],\\n self.model_chain[d + 1].C,\\n threads=kwargs.get(\\\"threads\\\", -1),\\n ).tocsr()\\n select_outputs_csrs.insert(0, prev_csr)\\n\\n prev_pred_csr = None\\n for d in range(self.depth):\\n prev_pred_csr = self.model_chain[d].predict_select_outputs(\\n X=X,\\n select_outputs_csr=select_outputs_csrs[d],\\n csr_codes=prev_pred_csr,\\n pred_params=pred_params.model_chain[d],\\n threads=kwargs.get(\\\"threads\\\", -1),\\n )\\n\\n return prev_pred_csr\",\n \"def calculate_calibration(filename, nx=9, ny=6):\\n # Make a list of calibration images\\n img = cv2.imread(filename)\\n\\n # Convert to grayscale\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # Find the chessboard corners\\n objpoints = []\\n imgpoints = []\\n objp = np.zeros((ny*nx, 3), np.float32)\\n objp[:, :2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2)\\n\\n ret, corners = cv2.findChessboardCorners(gray, (nx, ny), None)\\n if not ret:\\n return None\\n\\n imgpoints.append(corners)\\n objpoints.append(objp)\\n\\n ret, mtx, dist, a, b = cv2.calibrateCamera(\\n objpoints, imgpoints,\\n gray.shape[::-1], None, None\\n )\\n return img, corners, mtx, dist\",\n \"def __call__(self , x,y):\\n # selcet features , return scores and selected indices\\n scores , features = self._feature_selection(x , y)\\n # transform data with selected features\\n return x[:,features] , scores\",\n \"def compute(self, inputs, outputs):\\n\\n log.info(f\\\"Start optimisation iteration: {Rt.counter}\\\")\\n\\n # Update the geometry dictionary\\n for name, infos in Rt.geom_dict.items():\\n infos[1].append(inputs[name][0])\\n\\n if Rt.counter == 0:\\n\\n # For the first iteration, update the CPACS file from previous module\\n cpacs_in = Rt.modules[0].cpacs_in\\n cpacs_out = Rt.modules[0].cpacs_out\\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\\n\\n else:\\n\\n for m, module in enumerate(Rt.modules):\\n\\n # Increment name of output CPACS file\\n Rt.modules[m].cpacs_out = Path(\\n Rt.modules[m].cpacs_out.parents[0],\\n \\\"iter_\\\" + str(Rt.counter).rjust(2, \\\"0\\\") + \\\".xml\\\",\\n )\\n\\n if m == 0:\\n\\n # Use output of the last module of the previous iteration as input\\n Rt.modules[m].cpacs_in = Rt.modules[-1].cpacs_out\\n\\n # Update the geometry of the CPACS file\\n cpacs_in = Rt.modules[m].cpacs_in\\n cpacs_out = Rt.modules[m].cpacs_out\\n update_cpacs_file(cpacs_in, cpacs_out, Rt.geom_dict)\\n\\n # # The first module of the loop must update its output where the input\\n # # was saved because it has been updated by \\\"update_cpacs_file\\\" function.\\n # Rt.modules[m].cpacs_in = Rt.modules[m].cpacs_out\\n\\n else:\\n\\n # Increment name of input CPACS file\\n Rt.modules[m].cpacs_in = Path(\\n Rt.modules[m].cpacs_in.parents[0],\\n \\\"iter_\\\" + str(Rt.counter).rjust(2, \\\"0\\\") + \\\".xml\\\",\\n )\\n\\n Rt.counter += 1\",\n \"def call(self, inputs)->Any:\\n unpacked_inputs = tf_utils.unpack_inputs(inputs)\\n input_tensor = unpacked_inputs[0]\\n attention_mask = unpacked_inputs[1]\\n output_tensor = input_tensor\\n\\n all_layer_outputs = []\\n for layer in self.layers:\\n output_tensor, attention_scores = layer(output_tensor, attention_mask)\\n all_layer_outputs.append((output_tensor, attention_scores))\\n\\n return all_layer_outputs\",\n \"def select_actions(self, inputs, avail_actions, tformat, info, hidden_states=None, test_mode=False, **kwargs):\\n noise_params = kwargs.get(\\\"noise_params\\\", None)\\n\\n T_env = info[\\\"T_env\\\"]\\n test_suffix = \\\"\\\" if not test_mode else \\\"_test\\\"\\n\\n if self.args.agent_level1_share_params:\\n\\n # --------------------- LEVEL 1\\n\\n if self.is_obs_noise(test_mode):\\n inputs_level1, inputs_level1_tformat = _build_model_inputs(self.input_columns_level1_noisy,\\n inputs,\\n to_variable=True,\\n inputs_tformat=tformat)\\n inputs_level1_tformat = \\\"a*bs*t*v\\\"\\n else:\\n inputs_level1, inputs_level1_tformat = _build_model_inputs(self.input_columns_level1,\\n inputs,\\n to_variable=True,\\n inputs_tformat=tformat)\\n if self.args.debug_mode:\\n _check_nan(inputs_level1)\\n\\n out_level1, hidden_states_level1, losses_level1, tformat_level1 = self.model.model_level1(inputs_level1[\\\"agent_input_level1\\\"],\\n hidden_states=hidden_states[\\\"level1\\\"],\\n loss_fn=None,\\n tformat=inputs_level1_tformat,\\n n_agents=self.n_agents,\\n test_mode=test_mode,\\n **kwargs)\\n\\n\\n if self.args.debug_mode:\\n _check_nan(inputs_level1)\\n\\n if self.is_obs_noise(test_mode):\\n # have to do correlated sampling of what pair id everyone agrees on\\n bs = out_level1.shape[_bsdim(inputs_level1_tformat)]\\n ftype = th.FloatTensor if not out_level1.is_cuda else th.cuda.FloatTensor\\n sampled_pair_ids = ftype(*out_level1.shape[:-1], 1)\\n for _b in range(bs):\\n ps = out_level1[:, _b]\\n rn = np.random.random()\\n for _a in range(ps.shape[0]):\\n act = 0\\n s = ps[_a, 0, act]\\n while s <= rn:\\n act += 1\\n s += ps[_a, 0, act]\\n sampled_pair_ids[_a, _b, 0, :] = act\\n\\n modified_inputs_level1 = inputs_level1\\n selected_actions_format_level1 = \\\"a*bs*t*v\\\"\\n else:\\n # TODO: This is the pair-product encoded ID of both selected pairs.\\n sampled_pair_ids, modified_inputs_level1, selected_actions_format_level1 = self.action_selector.select_action({\\\"policies\\\":out_level1},\\n avail_actions=None,\\n tformat=tformat_level1,\\n test_mode=test_mode)\\n _check_nan(sampled_pair_ids)\\n\\n if self.args.debug_mode in [\\\"level2_actions_fixed_pair\\\"]:\\n \\\"\\\"\\\"\\n DEBUG MODE: LEVEL2 ACTIONS FIXED PAIR\\n Here we pick level2 actions from a fixed agent pair (0,1) and the third action from IQL\\n \\\"\\\"\\\"\\n assert self.n_agents == 3, \\\"only makes sense in n_agents=3 scenario\\\"\\n sampled_pair_ids.fill_(0.0)\\n\\n # sample which pairs should be selected\\n # TODO: HAVE TO ADAPT THIS FOR NOISY OBS!\\n if self.is_obs_noise(test_mode):\\n self.selected_actions_format = selected_actions_format_level1\\n else:\\n self.actions_level1 = sampled_pair_ids.clone()\\n self.selected_actions_format = selected_actions_format_level1\\n self.policies_level1 = modified_inputs_level1.squeeze(0).clone()\\n\\n if self.is_obs_noise(test_mode):\\n inputs_level2, inputs_level2_tformat = _build_model_inputs(self.input_columns_level2_noisy,\\n inputs,\\n to_variable=True,\\n inputs_tformat=tformat,\\n )\\n else:\\n inputs_level2, inputs_level2_tformat = _build_model_inputs(self.input_columns_level2,\\n inputs,\\n to_variable=True,\\n inputs_tformat=tformat,\\n )\\n\\n assert self.args.agent_level2_share_params, \\\"not implemented!\\\"\\n\\n\\n if \\\"avail_actions_pair\\\" in inputs_level2[\\\"agent_input_level2\\\"]:\\n pairwise_avail_actions = inputs_level2[\\\"agent_input_level2\\\"][\\\"avail_actions_pair\\\"]\\n else:\\n assert False, \\\"NOT SUPPORTED CURRENTLY.\\\"\\n avail_actions1, params_aa1, tformat_aa1 = _to_batch(inputs_level2[\\\"agent_input_level2\\\"][\\\"avail_actions_id1\\\"], inputs_level2_tformat)\\n avail_actions2, params_aa2, _ = _to_batch(inputs_level2[\\\"agent_input_level2\\\"][\\\"avail_actions_id2\\\"], inputs_level2_tformat)\\n pairwise_avail_actions = th.bmm(avail_actions1.unsqueeze(2), avail_actions2.unsqueeze(1))\\n pairwise_avail_actions = _from_batch(pairwise_avail_actions, params_aa2, tformat_aa1)\\n\\n ttype = th.cuda.FloatTensor if pairwise_avail_actions.is_cuda else th.FloatTensor\\n delegation_avails = Variable(ttype(pairwise_avail_actions.shape[0],\\n pairwise_avail_actions.shape[1],\\n pairwise_avail_actions.shape[2], 1).fill_(1.0), requires_grad=False)\\n pairwise_avail_actions = th.cat([delegation_avails, pairwise_avail_actions], dim=_vdim(tformat))\\n\\n\\n out_level2, hidden_states_level2, losses_level2, tformat_level2 \\\\\\n = self.model.models[\\\"level2_{}\\\".format(0)](inputs_level2[\\\"agent_input_level2\\\"],\\n hidden_states=hidden_states[\\\"level2\\\"],\\n loss_fn=None,\\n tformat=inputs_level2_tformat,\\n # sampled_pair_ids=sampled_pair_ids, # UNUSED?\\n pairwise_avail_actions=pairwise_avail_actions,\\n test_mode=test_mode,\\n seq_lens=inputs[\\\"agent_input_level2__agent0\\\"].seq_lens,\\n **kwargs)\\n\\n if self.is_obs_noise(test_mode):\\n\\n # have to do correlated sampling of what pair id everyone agrees on\\n bs = out_level2.shape[_bsdim(inputs_level2_tformat)]\\n ftype = th.FloatTensor if not out_level2.is_cuda else th.cuda.FloatTensor\\n pair_sampled_actions = ftype(*out_level2.shape[:-1], 1).view(int(out_level2.shape[0]/2),\\n 2,\\n *out_level2.shape[1:-1],\\n 1)\\n for _b in range(bs):\\n ps = out_level2.view(int(out_level2.shape[0]/2),\\n 2,\\n *out_level2.shape[1:])[:, :, _b]\\n avail_actions = pairwise_avail_actions.view(int(out_level2.shape[0]/2),\\n 2,\\n *out_level2.shape[1:])[:, :, _b]\\n\\n _sum0 = th.sum(ps[:, 0] * avail_actions[:, 0], dim=-1, keepdim=True)\\n _sum0_mask = (_sum0 == 0.0)\\n _sum0.masked_fill_(_sum0_mask, 1.0)\\n ps[:, 0] = ps[:, 0] * avail_actions[:, 0] / _sum0\\n\\n _sum1 = th.sum(ps[:, 1] * avail_actions[:, 1], dim=-1, keepdim=True)\\n _sum1_mask = (_sum1 == 0.0)\\n _sum1.masked_fill_(_sum1_mask, 1.0)\\n ps[:, 1] = ps[:, 1] * avail_actions[:, 1] / _sum1\\n\\n rns = np.random.random(ps.shape[0]) #one seed for each pair / batch\\n for _a in range(ps.shape[0]):\\n for _j in range(2):\\n act = 0\\n s = ps[_a, _j, 0, act]\\n while s <= rns[_a]:\\n act += 1\\n s += ps[_a, _j, 0, act]\\n if act == 122: # DEBUG\\n a = 5\\n pass\\n pair_sampled_actions[_a, _j, _b, 0, :] = act\\n\\n # TODO: Fix the return values so I can debug in episode buffer!!!\\n modified_inputs_level2 = inputs_level2\\n selected_actions_format_level2 = \\\"a*bs*t*v\\\"\\n else:\\n\\n # TODO: Implement for noisy obs!! # Need again correlated sampling\\n pair_sampled_actions, \\\\\\n modified_inputs_level2, \\\\\\n selected_actions_format_level2 = self.action_selector.select_action({\\\"policies\\\":out_level2},\\n avail_actions=pairwise_avail_actions.data,\\n tformat=tformat_level2,\\n test_mode=test_mode)\\n # if th.sum(pair_sampled_actions == 26.0) > 0.0:\\n # a = 5\\n\\n if sampled_pair_ids.shape[_tdim(tformat_level1)] > 1: # only used for mackrl sampling\\n sampled_pairs = th.cat([ self.magic_map[sampled_pair_ids[:,:,_t:_t+1,:].long()].squeeze(2) for _t in range(sampled_pair_ids.shape[_tdim(tformat_level1)]) ],\\n dim=_tdim(tformat_level1))\\n else:\\n sampled_pairs = self.magic_map[sampled_pair_ids.long()].squeeze(2)\\n\\n self.actions_level2 = pair_sampled_actions.clone()\\n\\n if self.is_obs_noise(test_mode):\\n self.actions_level2_sampled = []\\n for _aid in range(self.n_agents):\\n self.actions_level2_sampled.append([])\\n for i in range(sampled_pairs.shape[-1]):\\n self.actions_level2_sampled[_aid].append(\\n pair_sampled_actions[:, i].gather(0, sampled_pairs[_aid:_aid+1, :, :, i:i + 1].long()))\\n self.actions_level2_sampled[_aid] = th.cat(self.actions_level2_sampled[_aid], 0)\\n else:\\n # ToDO: Gather across all selected pairs!!\\n self.actions_level2_sampled = []\\n for i in range(sampled_pairs.shape[-1]):\\n self.actions_level2_sampled.append(pair_sampled_actions.gather(0, sampled_pairs[:,:,:,i:i+1].long()))\\n\\n self.actions_level2_sampled = th.cat(self.actions_level2_sampled, 0)\\n self.selected_actions_format_level2 = selected_actions_format_level2\\n self.policies_level2 = modified_inputs_level2.clone()\\n\\n\\n inputs_level3, inputs_level3_tformat = _build_model_inputs(self.input_columns_level3,\\n inputs,\\n to_variable=True,\\n inputs_tformat=tformat,\\n )\\n\\n action_tensor = None\\n if self.is_obs_noise(test_mode):\\n action_tensor = ttype(self.n_agents,\\n sampled_pairs.shape[_bsdim(tformat)],\\n sampled_pairs.shape[_tdim(tformat)],\\n 1).fill_(float(\\\"nan\\\"))\\n for _bid in range(sampled_pairs.shape[_bsdim(tformat)]):\\n # each agent has it's own assumptions about what pair-wise actions were sampled!\\n for _aid in range(self.n_agents):\\n # work out which pair id agent _aid is in (if any) and whether at first or second position\\n partid = None\\n posid = None\\n #for _partid, _part in enumerate(_ordered_2_agent_pairings(self.n_agents)):\\n combid = int(sampled_pair_ids[_aid, _bid, 0, 0].item())\\n part = list(_ordered_2_agent_pairings(self.n_agents))[combid]\\n for pid, p in enumerate(part):\\n agentids = _pairing_id_2_agent_ids(p, self.n_agents)\\n if agentids[0] == _aid:\\n partid = pid\\n posid = 0\\n break\\n if agentids[1] == _aid:\\n partid = pid\\n posid = 1\\n break\\n pass\\n if partid is not None:\\n # ok so what actions did agent _aid finally select?\\n joint_act = self.actions_level2_sampled[_aid][partid,_bid,0,0].item()\\n joint_act_dec = _joint_actions_2_action_pair(int(joint_act), self.n_actions)\\n if joint_act_dec == 11: # DEBUG\\n a = 5\\n if joint_act_dec != 0: # else delegate\\n action_tensor[_aid,_bid,0,:] = joint_act_dec[posid]\\n else:\\n # decentralized anyway!\\n pass\\n else:\\n action_tensor = ttype(self.n_agents,\\n pair_sampled_actions.shape[_bsdim(tformat)],\\n pair_sampled_actions.shape[_tdim(tformat)],\\n 1).fill_(float(\\\"nan\\\"))\\n for i in range(sampled_pairs.shape[-1]):\\n sampled_pair = sampled_pairs[:,:,:,i:i+1]\\n pair_id1, pair_id2 = _pairing_id_2_agent_ids__tensor(sampled_pair, self.n_agents,\\n \\\"a*bs*t*v\\\") # sampled_pair_ids.squeeze(0).squeeze(2).view(-1), self.n_agents)\\n\\n avail_actions1 = inputs_level3[\\\"agent_input_level3\\\"][\\\"avail_actions\\\"].gather(\\n _adim(inputs_level3_tformat), Variable(pair_id1.repeat(1, 1, 1, inputs_level3[\\\"agent_input_level3\\\"][\\n \\\"avail_actions\\\"].shape[_vdim(inputs_level3_tformat)])))\\n avail_actions2 = inputs_level3[\\\"agent_input_level3\\\"][\\\"avail_actions\\\"].gather(\\n _adim(inputs_level3_tformat), Variable(pair_id2.repeat(1, 1, 1, inputs_level3[\\\"agent_input_level3\\\"][\\n \\\"avail_actions\\\"].shape[_vdim(inputs_level3_tformat)])))\\n\\n # selected_level_2_actions = pair_sampled_actions.gather(0, sampled_pair_ids.long())\\n this_pair_sampled_actions = pair_sampled_actions.gather(0, sampled_pair.long())\\n\\n actions1, actions2 = _joint_actions_2_action_pair_aa(this_pair_sampled_actions.clone(),\\n self.n_actions,\\n avail_actions1,\\n avail_actions2)\\n # count how often level2 actions are un-available at level 3\\n # TODO: Verify that 'this_pair_sampled_actions != 0' is the right thing to do!!\\n pair_action_unavail_rate = (th.mean(((actions1 != actions1) & (this_pair_sampled_actions != 0)).float()).item() +\\n th.mean(((actions2 != actions2) & (this_pair_sampled_actions != 0)).float()).item()) / 2.0\\n if pair_action_unavail_rate != 0.0 and hasattr(self.args, \\\"mackrl_delegate_if_zero_ck\\\") and self.args.mackrl_delegate_if_zero_ck:\\n #assert False, \\\"pair action unavail HAS to be zero in mackrl_delegate_if_zero_ck setting!\\\"\\n self.logging_struct.py_logger.warning(\\\"ERROR: pair action unavail HAS to be zero in mackrl_delegate_if_zero_ck setting!\\\")\\n\\n self._add_stat(\\\"pair_action_unavail_rate__runner\\\",\\n pair_action_unavail_rate,\\n T_env=T_env,\\n suffix=test_suffix,\\n to_sacred=False)\\n\\n # Now check whether any of the pair_sampled_actions violate individual agent constraints on avail_actions\\n ttype = th.cuda.FloatTensor if self.args.use_cuda else th.FloatTensor\\n\\n\\n action_tensor.scatter_(0, pair_id1, actions1)\\n action_tensor.scatter_(0, pair_id2, actions2)\\n\\n avail_actions_level3 = inputs_level3[\\\"agent_input_level3\\\"][\\\"avail_actions\\\"].clone().data\\n self.avail_actions = avail_actions_level3.clone()\\n\\n inputs_level3[\\\"agent_input_level3\\\"][\\\"avail_actions\\\"] = Variable(avail_actions_level3,\\n requires_grad=False)\\n\\n out_level3, hidden_states_level3, losses_level3, tformat_level3 = self.model.models[\\\"level3_{}\\\".format(0)](inputs_level3[\\\"agent_input_level3\\\"],\\n hidden_states=hidden_states[\\\"level3\\\"],\\n loss_fn=None,\\n tformat=inputs_level3_tformat,\\n test_mode=test_mode,\\n seq_lens=inputs[\\\"agent_input_level3__agent0\\\"].seq_lens,\\n **kwargs)\\n # extract available actions\\n avail_actions_level3 = inputs_level3[\\\"agent_input_level3\\\"][\\\"avail_actions\\\"]\\n\\n individual_actions, \\\\\\n modified_inputs_level3, \\\\\\n selected_actions_format_level3 = self.action_selector.select_action({\\\"policies\\\":out_level3},\\n avail_actions=avail_actions_level3.data,\\n tformat=tformat_level3,\\n test_mode=test_mode)\\n\\n self.actions_level3 = individual_actions\\n action_tensor[action_tensor != action_tensor] = individual_actions[action_tensor != action_tensor]\\n\\n # set states beyond episode termination to NaN\\n if self.is_obs_noise(test_mode):\\n action_tensor = _pad_nan(action_tensor, tformat=tformat_level3,\\n seq_lens=inputs[\\\"agent_input_level1__agent0\\\"].seq_lens) # DEBUG\\n else:\\n action_tensor = _pad_nan(action_tensor, tformat=tformat_level3, seq_lens=inputs[\\\"agent_input_level1\\\"].seq_lens) # DEBUG\\n # l2 = action_tensor.squeeze() # DEBUG\\n if self.args.debug_mode in [\\\"level3_actions_only\\\"]:\\n \\\"\\\"\\\"\\n DEBUG MODE: LEVEL3 ACTIONS ONLY\\n Here we just pick actions from level3 - should therefore just correspond to vanilla COMA!\\n \\\"\\\"\\\"\\n action_tensor = individual_actions\\n\\n self.final_actions = action_tensor.clone()\\n if th.sum(self.final_actions == 11).item() > 0: # DEBUG\\n a = 5\\n pass\\n\\n if self.is_obs_noise(test_mode):\\n selected_actions_list = []\\n selected_actions_list += [dict(name=\\\"actions\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.final_actions)]\\n modified_inputs_list = []\\n else:\\n #self.actions_level3 = individual_actions.clone()\\n self.selected_actions_format_level3 = selected_actions_format_level3\\n self.policies_level3 = modified_inputs_level3.clone()\\n self.avail_actions_active = avail_actions_level3.data\\n\\n selected_actions_list = []\\n for _i in range(_n_agent_pair_samples(self.n_agents) if self.args.n_pair_samples is None else self.args.n_pair_samples): #_n_agent_pair_samples(self.n_agents)):\\n selected_actions_list += [dict(name=\\\"actions_level1__sample{}\\\".format(_i),\\n data=self.actions_level1[_i])]\\n for _i in range(_n_agent_pair_samples(self.n_agents)):\\n selected_actions_list += [dict(name=\\\"actions_level2__sample{}\\\".format(_i),\\n data=self.actions_level2_sampled[_i])] # TODO: BUG!?\\n selected_actions_list += [dict(name=\\\"actions_level2\\\",\\n select_agent_ids=list(range(_n_agent_pairings(self.n_agents))),\\n data=self.actions_level2)]\\n selected_actions_list += [dict(name=\\\"actions_level3\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.actions_level3)]\\n selected_actions_list += [dict(name=\\\"actions\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.final_actions)]\\n\\n modified_inputs_list = []\\n modified_inputs_list += [dict(name=\\\"policies_level1\\\",\\n data=self.policies_level1)]\\n for _i in range(_n_agent_pair_samples(self.n_agents)):\\n modified_inputs_list += [dict(name=\\\"policies_level2__sample{}\\\".format(_i),\\n data=self.policies_level2[_i])]\\n modified_inputs_list += [dict(name=\\\"policies_level3\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.policies_level3)]\\n modified_inputs_list += [dict(name=\\\"avail_actions_active\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.avail_actions_active)]\\n modified_inputs_list += [dict(name=\\\"avail_actions\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=self.avail_actions)]\\n\\n #modified_inputs_list += [dict(name=\\\"avail_actions\\\",\\n # select_agent_ids=list(range(self.n_agents)),\\n # data=self.avail_actions)]\\n\\n selected_actions_list += [dict(name=\\\"actions_onehot\\\",\\n select_agent_ids=list(range(self.n_agents)),\\n data=_onehot(self.final_actions, rng=(0, self.n_actions)))]\\n\\n hidden_states = dict(level1=hidden_states_level1,\\n level2=hidden_states_level2,\\n level3=hidden_states_level3)\\n\\n return hidden_states, selected_actions_list, modified_inputs_list, self.selected_actions_format\\n\\n pass\\n\\n else:\\n assert False, \\\"Not implemented\\\"\",\n \"def _init_fns_predict_feature(self, cfg):\\n self._fns_predict_feature = []\\n self._feature_sizes = []\\n if (cfg.feature_layers is None): \\n return\\n\\n if not isinstance(cfg.feature_layers, collections.Iterable):\\n cfg.feature_layers = [cfg.feature_layers]\\n\\n for i, f_idx in enumerate(cfg.feature_layers):\\n f_layer = self.net.layers[f_idx]\\n\\n if (hasattr(f_layer, 'output_dim')):\\n self._feature_sizes.append(f_layer.output_dim)\\n\\n elif (hasattr(f_layer, 'output_shape')):\\n self._feature_sizes.append(f_layer.output_shape[1])\\n\\n else:\\n raise Exception(\\\"Feature layers chosen are invalid. \\\" +\\n \\\"`cfg.feature_layers`\\\")\\n\\n # IMPORTANT: \\n # Retrieves the output tensor(s) of a layer at a given node.\\n # f_layer.get_output_at(node_index): \\n\\n # Retrieves the output tensor(s) of a layer (only applicable if\\n # the layer has exactly one inbound node, i.e. if it is connected\\n # to one incoming layer).\\n # f_layer.output\\n self._fns_predict_feature.append(\\n K.function(self.net.inputs + [K.learning_phase()],\\n [f_layer.output]))\",\n \"def _select_masks_to_boundaries(self, select_masks):\\n\\n def _merge(node_covers, select_idx):\\n \\\"\\\"\\\"\\n node_covers [[s1, e1], [s2, e2], ..., [sn, en]]\\n \\\"\\\"\\\"\\n new_node_covers = []\\n for i in range(len(node_covers) - 1):\\n if i == select_idx:\\n merge_node_boundary = [node_covers[select_idx][0], node_covers[select_idx + 1][1]]\\n new_node_covers.append(merge_node_boundary)\\n elif i < select_idx:\\n new_node_covers.append(node_covers[i])\\n else:\\n new_node_covers.append(node_covers[i + 1])\\n return new_node_covers, merge_node_boundary\\n batch_size = select_masks[0].size()[0]\\n max_length = select_masks[0].size()[1] + 1\\n combine_matrix = torch.rand(batch_size, max_length, 2).long()\\n for j in range(max_length):\\n combine_matrix[:, j, :] = j\\n results = []\\n for batch_idx in range(batch_size):\\n node_covers = combine_matrix[batch_idx, :, :].numpy().tolist()\\n result = []\\n for node_idx in range(max_length - 2):\\n select = select_masks[node_idx][batch_idx, :]\\n select_idx = torch.nonzero(select).data[0][0]\\n node_covers, merge_boundary = _merge(node_covers, select_idx)\\n result.append(merge_boundary)\\n results.append(result)\\n results = torch.LongTensor(results)\\n return results\",\n \"def call(self, inputs):\\n for index,layer in enumerate(self.list_cnn):\\n if index == 0:\\n out = layer(inputs)\\n else:\\n if self.residual:\\n prev_out = out\\n cur_out = layer(out)\\n if self.use_batchnorm:\\n cur_out = layers.BatchNormalization()(cur_out)\\n if self.use_dropout:\\n cur_out = layers.Dropout(0.2)(cur_out)\\n out = prev_out + cur_out\\n else:\\n out = layer(out)\\n out = self.output_layer(out)\\n if self.use_pool:\\n out = self.pool(out)\\n out = self.flatten(out)\\n out = self.classify(out)\\n return out\",\n \"def run(self, model):\\n activation_statistics = self._stats_collector.get_statistics_for_algorithm(self.name)\\n\\n act_nodes = mu.get_nodes_by_type(model, self._act_types)\\n for act_node in act_nodes:\\n if act_node.fullname not in activation_statistics:\\n logger.debug('Stats After {} not found!'.format(act_node.fullname))\\n continue\\n min_after_act = np.min(activation_statistics[act_node.fullname]['min_per_tensor'])\\n max_after_act = np.max(activation_statistics[act_node.fullname]['max_per_tensor'])\\n clamp_attrs = {'min': min_after_act, 'max': max_after_act}\\n clamp_name = act_node.name + '/min_max_Clamp'\\n clamp_node = ge.create_node(act_node.graph, clamp_name, 'AttributedClamp', clamp_attrs)\\n clamp_node['fullname'] = nu.reset_node_fullname(act_node.fullname, clamp_name)\\n\\n dest_ports = act_node.out_port(0).get_destinations()\\n act_node.out_port(0).disconnect()\\n clamp_node.in_port(0).connect(act_node.out_port(0))\\n\\n for dest_port in dest_ports:\\n dest_port.connect(clamp_node.out_port(0))\\n return model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5132529","0.5103128","0.50717694","0.50447917","0.5014779","0.50001043","0.49974504","0.49860495","0.49711442","0.49643132","0.49161378","0.49030358","0.49007672","0.48981002","0.48850143","0.485468","0.48339158","0.48284072","0.48257983","0.47925872","0.478387","0.4782977","0.47763422","0.4749418","0.4748281","0.47465968","0.47409898","0.47217214","0.4717686","0.47097737","0.46873918","0.46648285","0.46637663","0.46588528","0.46532488","0.46482366","0.46454176","0.46434912","0.46333456","0.46260214","0.4613885","0.46137834","0.46103156","0.46045965","0.4600711","0.45952678","0.45900527","0.45875597","0.45834735","0.45806935","0.45802578","0.45752817","0.45704073","0.45692655","0.4568445","0.45634654","0.45609844","0.45527908","0.45480886","0.45475227","0.4543303","0.45383263","0.45380008","0.45377868","0.45376584","0.45294186","0.45282355","0.45253876","0.45200115","0.45189828","0.4517138","0.45124415","0.45083615","0.45075807","0.45042285","0.45031053","0.44996113","0.44819117","0.44718724","0.4471621","0.44714087","0.44694296","0.44677773","0.44665593","0.44664344","0.4465791","0.44652805","0.44614077","0.44595987","0.44591284","0.44564217","0.44509044","0.44475037","0.44419578","0.44400936","0.4438088","0.44379538","0.443792","0.4435536","0.44347897"],"string":"[\n \"0.5132529\",\n \"0.5103128\",\n \"0.50717694\",\n \"0.50447917\",\n \"0.5014779\",\n \"0.50001043\",\n \"0.49974504\",\n \"0.49860495\",\n \"0.49711442\",\n \"0.49643132\",\n \"0.49161378\",\n \"0.49030358\",\n \"0.49007672\",\n \"0.48981002\",\n \"0.48850143\",\n \"0.485468\",\n \"0.48339158\",\n \"0.48284072\",\n \"0.48257983\",\n \"0.47925872\",\n \"0.478387\",\n \"0.4782977\",\n \"0.47763422\",\n \"0.4749418\",\n \"0.4748281\",\n \"0.47465968\",\n \"0.47409898\",\n \"0.47217214\",\n \"0.4717686\",\n \"0.47097737\",\n \"0.46873918\",\n \"0.46648285\",\n \"0.46637663\",\n \"0.46588528\",\n \"0.46532488\",\n \"0.46482366\",\n \"0.46454176\",\n \"0.46434912\",\n \"0.46333456\",\n \"0.46260214\",\n \"0.4613885\",\n \"0.46137834\",\n \"0.46103156\",\n \"0.46045965\",\n \"0.4600711\",\n \"0.45952678\",\n \"0.45900527\",\n \"0.45875597\",\n \"0.45834735\",\n \"0.45806935\",\n \"0.45802578\",\n \"0.45752817\",\n \"0.45704073\",\n \"0.45692655\",\n \"0.4568445\",\n \"0.45634654\",\n \"0.45609844\",\n \"0.45527908\",\n \"0.45480886\",\n \"0.45475227\",\n \"0.4543303\",\n \"0.45383263\",\n \"0.45380008\",\n \"0.45377868\",\n \"0.45376584\",\n \"0.45294186\",\n \"0.45282355\",\n \"0.45253876\",\n \"0.45200115\",\n \"0.45189828\",\n \"0.4517138\",\n \"0.45124415\",\n \"0.45083615\",\n \"0.45075807\",\n \"0.45042285\",\n \"0.45031053\",\n \"0.44996113\",\n \"0.44819117\",\n \"0.44718724\",\n \"0.4471621\",\n \"0.44714087\",\n \"0.44694296\",\n \"0.44677773\",\n \"0.44665593\",\n \"0.44664344\",\n \"0.4465791\",\n \"0.44652805\",\n \"0.44614077\",\n \"0.44595987\",\n \"0.44591284\",\n \"0.44564217\",\n \"0.44509044\",\n \"0.44475037\",\n \"0.44419578\",\n \"0.44400936\",\n \"0.4438088\",\n \"0.44379538\",\n \"0.443792\",\n \"0.4435536\",\n \"0.44347897\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5722057"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83785,"cells":{"query":{"kind":"string","value":"Adds ReduceMin and ReduceMax nodes to all quantization_candidates op type nodes in model and ensures their outputs are stored as part of the graph output"},"document":{"kind":"string","value":"def augment_graph(self):\n tensors, _ = self.select_tensors_to_calibrate(self.model)\n reshape_shape_name = str(uuid.uuid4())\n reshape_shape = numpy_helper.from_array(np.array([1], dtype=np.int64), reshape_shape_name)\n self.model.graph.initializer.append(reshape_shape)\n\n def add_reduce_min_max(tensor_name, reduce_op_name):\n # When doing ReduceMax/ReduceMin, ORT can't reduce on dim with value of 0 if 'keepdims' is false.\n # To make the code simple, we always let keepdims to be 1.\n keepdims = 1\n\n # Adding ReduceMin/ReduceMax nodes: ReduceMin/ReduceMax -> Reshape-> (output)\n reduce_output = tensor_name + \"_\" + reduce_op_name\n intermediate_output = reduce_output + \"_Reshape\"\n reduce_node = onnx.helper.make_node(\n reduce_op_name, [tensor_name], [intermediate_output], keepdims=keepdims, name=reduce_output\n )\n\n reshape_node = onnx.helper.make_node(\n \"Reshape\",\n inputs=[intermediate_output, reshape_shape_name],\n outputs=[reduce_output],\n name=intermediate_output,\n )\n\n self.model.graph.node.extend([reduce_node, reshape_node])\n self.model.graph.output.append(helper.make_tensor_value_info(reduce_output, TensorProto.FLOAT, [1]))\n\n for tensor in tensors:\n add_reduce_min_max(tensor, \"ReduceMin\")\n add_reduce_min_max(tensor, \"ReduceMax\")\n\n onnx.save(\n self.model,\n self.augmented_model_path,\n save_as_external_data=self.use_external_data_format,\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 convert_reduce(g, op, block):\n\n op_map = {\n \"reduce_all\": \"all\",\n \"reduce_any\": \"any\",\n \"reduce_max\": \"max\",\n \"reduce_min\": \"min\",\n \"reduce_prod\": \"prod\",\n \"reduce_sum\": \"sum\",\n \"reduce_mean\": \"mean\",\n }\n op_name = op_map[op.type]\n input_x = g.get_node(op.input(\"X\")[0])\n axis = op.attr(\"dim\")\n if op.attr(\"reduce_all\"):\n axis = None\n keepdims = op.attr(\"keep_dim\")\n out = get_relay_op(op_name)(input_x, axis=axis, keepdims=keepdims)\n if not axis and not keepdims:\n # use `expand_dims` to solve the following situation\n # for TVM, the shape of `out` will be (, )\n # for Paddle, the shape of `out` will be [1]\n out = _op.expand_dims(out, axis=0)\n g.add_node(op.output(\"Out\")[0], out)","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def _collect_ipt_and_opt_nodes(self):\n for name, node in self._nodes_collection.items():\n if node.in_degree == 0:\n # NOTICE: what's usage of `scope`?\n self._input_nodes.append(name)\n\n if node.out_degree == 0:\n self._output_nodes.append(name)","def reduce(self, app, nodes, result):","def convert_roipooling(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n pooled_shape = convert_string_to_list(attrs.get('pooled_size'))\n scale = float(attrs.get(\"spatial_scale\"))\n\n node = onnx.helper.make_node(\n 'MaxRoiPool',\n input_nodes,\n [name],\n pooled_shape=pooled_shape,\n spatial_scale=scale,\n name=name\n )\n return [node]","def run(self, model):\n activation_statistics = self._stats_collector.get_statistics_for_algorithm(self.name)\n\n act_nodes = mu.get_nodes_by_type(model, self._act_types)\n for act_node in act_nodes:\n if act_node.fullname not in activation_statistics:\n logger.debug('Stats After {} not found!'.format(act_node.fullname))\n continue\n min_after_act = np.min(activation_statistics[act_node.fullname]['min_per_tensor'])\n max_after_act = np.max(activation_statistics[act_node.fullname]['max_per_tensor'])\n clamp_attrs = {'min': min_after_act, 'max': max_after_act}\n clamp_name = act_node.name + '/min_max_Clamp'\n clamp_node = ge.create_node(act_node.graph, clamp_name, 'AttributedClamp', clamp_attrs)\n clamp_node['fullname'] = nu.reset_node_fullname(act_node.fullname, clamp_name)\n\n dest_ports = act_node.out_port(0).get_destinations()\n act_node.out_port(0).disconnect()\n clamp_node.in_port(0).connect(act_node.out_port(0))\n\n for dest_port in dest_ports:\n dest_port.connect(clamp_node.out_port(0))\n return model","def common_optimization(m):\n logger.info(\"Doing nodes fusion and replacement... \")\n m = other.polish_model(m)\n g = m.graph\n other.transpose_B_in_Gemm(g)\n fusing.fuse_BN_into_Gemm(g)\n fusing.fuse_BN_with_Reshape_into_Gemm(g)\n fusing.fuse_Gemm_into_Gemm(g)\n fusing.fuse_consecutive_reducemean(g)\n fusing.fuse_slice_nodes_into_conv(g)\n fusing.fuse_relu_min_into_clip(g)\n other.duplicate_shared_Flatten(g)\n replacing.replace_average_pool_with_GAP(g)\n\n m = other.polish_model(m)\n g = m.graph\n\n replacing.replace_Squeeze_with_Reshape(g)\n replacing.replace_Unsqueeze_with_Reshape(g)\n replacing.replace_Reshape_with_Flatten(g)\n replacing.replace_ReduceMean_with_GlobalAveragePool(g)\n replacing.replace_Sum_with_Adds(g)\n replacing.replace_constant_input_concat_with_pad(g)\n other.topological_sort(g)\n return m","def convert_max(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdims\")\n\n if axes is not None:\n node = onnx.helper.make_node(\n 'ReduceMax',\n inputs=input_nodes,\n outputs=[name],\n axes=axes,\n keepdims=keepdims,\n name=name\n )\n\n return [node]\n else:\n node = onnx.helper.make_node(\n 'ReduceMax',\n inputs=input_nodes,\n outputs=[name],\n keepdims=keepdims,\n name=name\n )\n\n return [node]","def generate_output_graph_ranges(self, max_name_value):\n for node_name, value in max_name_value.items():\n if node_name not in self.graph_info:\n continue\n\n min_node = node_def_pb2.NodeDef()\n min_node.op = \"HostConst\" if self.device == \"gpu\" else \"Const\"\n min_node_postfix = \"/frozen_min\"\n min_node.name = node_name + min_node_postfix\n min_node.attr[\"dtype\"].CopyFrom(\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\n min_node.attr[\"value\"].CopyFrom(\n attr_value_pb2.AttrValue(\n tensor=tensor_util.make_tensor_proto(float(value[0]),\n dtypes.float32, [])))\n\n max_node = node_def_pb2.NodeDef()\n max_node.op = \"HostConst\" if self.device == \"gpu\" else \"Const\"\n max_node_postfix = \"/frozen_max\"\n max_node.name = node_name + max_node_postfix\n max_node.attr[\"dtype\"].CopyFrom(\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\n max_node.attr[\"value\"].CopyFrom(\n attr_value_pb2.AttrValue(\n tensor=tensor_util.make_tensor_proto(float(value[1]),\n dtypes.float32, [])))\n output_node_name = self.graph_info[node_name].outputs[0]\n self.cur_graph.replace_const_node(min_node,\n [Helper.node_name_from_input(output_node_name)],\n node_name + ':0')\n self.cur_graph.replace_const_node(max_node,\n [Helper.node_name_from_input(output_node_name)],\n node_name + ':1')\n self.cur_graph.remove_node(node_name)\n\n self.requant_min_max[node_name] = [\n tensor_util.MakeNdarray(min_node.attr[\"value\"].tensor),\n tensor_util.MakeNdarray(max_node.attr[\"value\"].tensor)\n ]\n\n self.scale_info[self.postfix] = self.requant_min_max\n # {\n # \"__requant_min_max\":\n # {requant_range_name:[min,max],}\n # \"__min\":\n # {node_name_min:[min]}\n # \"__max\":\n # {node_name_max:[max]}\n # }\n return GraphAnalyzer().dump_graph(), self.scale_info","def _reduce(self, x, y):\n coef = self._update_parallel_coef_constraints(x)\n self.coef_ = coef.T","def enumerate_compatible_opset(model, opset_min=-1, opset_max=-1, # pylint: disable=R0914\n check_runtime=True, debug=False,\n runtime='python', dump_folder=None,\n store_models=False, benchmark=False,\n assume_finite=True, node_time=False,\n fLOG=print, filter_exp=None,\n verbose=0, time_kwargs=None,\n extended_list=False, dump_all=False,\n n_features=None, skip_long_test=True,\n filter_scenario=None, time_kwargs_fact=None,\n time_limit=4, n_jobs=None):\n if opset_min == -1:\n opset_min = __max_supported_opset__ # pragma: no cover\n if opset_max == -1:\n opset_max = __max_supported_opset__ # pragma: no cover\n if verbose > 0 and fLOG is not None:\n fLOG(\n f\"[enumerate_compatible_opset] opset in [{opset_min}, {opset_max}].\")\n if verbose > 1 and fLOG:\n fLOG(\n f\"[enumerate_compatible_opset] validate class '{model.__name__}'.\")\n if verbose > 2:\n fLOG(model)\n\n if time_kwargs is None:\n time_kwargs = default_time_kwargs()\n problems, extras = _retrieve_problems_extra(\n model, verbose, fLOG, extended_list)\n if isinstance(problems, dict):\n yield problems # pragma: no cover\n problems = [] # pragma: no cover\n\n if opset_max is None:\n opset_max = __max_supported_opset__ # pragma: no cover\n opsets = list(range(opset_min, opset_max + 1)) # pragma: no cover\n opsets.append(None) # pragma: no cover\n else:\n opsets = list(range(opset_min, opset_max + 1))\n\n if extras is None:\n problems = []\n yield {'name': model.__name__, 'skl_version': sklearn_version,\n '_0problem_exc': 'SKIPPED'}\n\n if not isinstance(n_features, list):\n n_features = [n_features]\n\n for prob in problems:\n if filter_exp is not None and not filter_exp(model, prob):\n continue\n for n_feature in n_features:\n if verbose >= 2 and fLOG is not None:\n fLOG(\"[enumerate_compatible_opset] problem={} n_feature={}\".format(\n prob, n_feature))\n\n (X_train, X_test, y_train,\n y_test, Xort_test,\n init_types, conv_options, method_name,\n output_index, dofit, predict_kwargs) = _get_problem_data(prob, n_feature)\n\n for scenario_extra in extras:\n subset_problems = None\n optimisations = None\n new_conv_options = None\n if len(scenario_extra) > 2:\n options = scenario_extra[2]\n if isinstance(options, dict):\n subset_problems = options.get('subset_problems', None)\n optimisations = options.get('optim', None)\n new_conv_options = options.get('conv_options', None)\n else:\n subset_problems = options\n\n if subset_problems and isinstance(subset_problems, (list, set)):\n if prob not in subset_problems:\n # Skips unrelated problem for a specific configuration.\n continue\n elif subset_problems is not None:\n raise RuntimeError( # pragma: no cover\n \"subset_problems must be a set or a list not {}.\".format(\n subset_problems))\n\n try:\n scenario, extra = scenario_extra[:2]\n except TypeError as e: # pragma: no cover\n raise TypeError(\n \"Unable to interpret 'scenario_extra'\\n{}\".format(\n scenario_extra)) from e\n if optimisations is None:\n optimisations = [None]\n if new_conv_options is None:\n new_conv_options = [{}]\n\n if (filter_scenario is not None and\n not filter_scenario(model, prob, scenario,\n extra, new_conv_options)):\n continue\n\n if verbose >= 2 and fLOG is not None:\n fLOG(\"[enumerate_compatible_opset] ##############################\")\n fLOG(\"[enumerate_compatible_opset] scenario={} optim={} extra={} dofit={} (problem={})\".format(\n scenario, optimisations, extra, dofit, prob))\n\n # training\n obs = {'scenario': scenario, 'name': model.__name__,\n 'skl_version': sklearn_version, 'problem': prob,\n 'method_name': method_name, 'output_index': output_index,\n 'fit': dofit, 'conv_options': conv_options,\n 'idtype': Xort_test.dtype, 'predict_kwargs': predict_kwargs,\n 'init_types': init_types, 'inst': extra if extra else None,\n 'n_features': X_train.shape[1] if len(X_train.shape) == 2 else 1}\n inst = None\n extra = set_n_jobs(model, extra, n_jobs=n_jobs)\n try:\n inst = model(**extra)\n except TypeError as e: # pragma: no cover\n if debug: # pragma: no cover\n raise\n if \"__init__() missing\" not in str(e):\n raise RuntimeError(\n \"Unable to instantiate model '{}'.\\nextra=\\n{}\".format(\n model.__name__, pprint.pformat(extra))) from e\n yield obs.copy()\n continue\n\n if not _dofit_model(dofit, obs, inst, X_train, y_train, X_test, y_test,\n Xort_test, init_types, store_models,\n debug, verbose, fLOG):\n yield obs.copy()\n continue\n\n # statistics about the trained model\n skl_infos = analyze_model(inst)\n for k, v in skl_infos.items():\n obs['fit_' + k] = v\n\n # runtime\n ypred = _run_skl_prediction(\n obs, check_runtime, assume_finite, inst,\n method_name, predict_kwargs, X_test,\n benchmark, debug, verbose, time_kwargs,\n skip_long_test, time_kwargs_fact, fLOG)\n if isinstance(ypred, Exception):\n yield obs.copy()\n continue\n\n for run_obs in _call_conv_runtime_opset(\n obs=obs.copy(), opsets=opsets, debug=debug,\n new_conv_options=new_conv_options,\n model=model, prob=prob, scenario=scenario,\n extra=extra, extras=extras, conv_options=conv_options,\n init_types=init_types, inst=inst,\n optimisations=optimisations, verbose=verbose,\n benchmark=benchmark, runtime=runtime,\n filter_scenario=filter_scenario,\n X_test=X_test, y_test=y_test, ypred=ypred,\n Xort_test=Xort_test, method_name=method_name,\n check_runtime=check_runtime,\n output_index=output_index,\n kwargs=dict(\n dump_all=dump_all,\n dump_folder=dump_folder,\n node_time=node_time,\n skip_long_test=skip_long_test,\n store_models=store_models,\n time_kwargs=_multiply_time_kwargs(\n time_kwargs, time_kwargs_fact, inst)\n ),\n time_limit=time_limit,\n fLOG=fLOG):\n yield run_obs","def _legal_operations(self, model, tabu_list=[], max_indegree=None):\n\n local_score = self.scoring_method.local_score\n nodes = model.event_nodes\n potential_new_edges = (set(permutations(nodes, 2)) -\n set(model.edges()) -\n set([(Y, X) for (X, Y) in model.edges()]) -\n set([X for X, Y in model.relation_map.items() if len(Y) == 0]))\n\n for (X, Y) in potential_new_edges: # (1) add single edge\n if nx.is_directed_acyclic_graph(nx.DiGraph(list(model.edges()) + [(X, Y)])):\n if self.valid_temporal_relations([(X, Y)], model):\n operation = ('+', (X, Y))\n if operation not in tabu_list:\n old_parents = list(model.get_parents(Y))\n new_parents = old_parents + [X]\n if max_indegree is None or len(new_parents) <= max_indegree:\n temporal_node_parents = [X, Y]\n temporal_node = ITBN.temporal_node_marker + X + \"_\" + Y\n score_delta = (local_score(Y, new_parents) -\n local_score(Y, old_parents) +\n local_score(temporal_node, temporal_node_parents))\n yield(operation, score_delta)\n\n for (X, Y) in model.event_edges(): # (2) remove single edge\n operation = ('-', (X, Y))\n if operation not in tabu_list:\n old_parents = list(model.get_parents(Y))\n new_parents = old_parents[:]\n new_parents.remove(X)\n temporal_node_parents = [X, Y]\n temporal_node = ITBN.temporal_node_marker + X + \"_\" + Y\n score_delta = (local_score(Y, new_parents) -\n local_score(Y, old_parents) -\n local_score(temporal_node, temporal_node_parents))\n yield(operation, score_delta)\n\n for (X, Y) in model.event_edges(): # (3) flip single edge\n if len(model.relation_map[(Y, X)]) > 0:\n new_edges = list(model.edges()) + [(Y, X)]\n new_edges.remove((X, Y))\n if nx.is_directed_acyclic_graph(nx.DiGraph(new_edges)):\n if self.valid_temporal_relations([(X, Y)], model):\n operation = ('flip', (X, Y))\n if operation not in tabu_list and ('flip', (Y, X)) not in tabu_list:\n old_X_parents = list(model.get_parents(X))\n old_Y_parents = list(model.get_parents(Y))\n new_X_parents = old_X_parents + [Y]\n new_Y_parents = old_Y_parents[:]\n new_Y_parents.remove(X)\n if max_indegree is None or len(new_X_parents) <= max_indegree:\n temporal_node_parents = [Y, X]\n temporal_node = ITBN.temporal_node_marker + Y + \"_\" + X\n old_temp_node_parents = [X, Y]\n old_temp_node = ITBN.temporal_node_marker + X + \"_\" + Y\n score_delta = (local_score(X, new_X_parents) +\n local_score(Y, new_Y_parents) -\n local_score(X, old_X_parents) -\n local_score(Y, old_Y_parents) +\n local_score(temporal_node, temporal_node_parents) -\n local_score(old_temp_node, old_temp_node_parents))\n yield(operation, score_delta)","def modify_cpu(self, ask_questions=True):\n\n # Get the CPU layout\n CpuUtils.get_cpu_layout_from_all_nodes(self._nodes)\n\n for i in self._nodes.items():\n node = i[1]\n total_cpus = 0\n total_cpus_per_slice = 0\n cpus_per_node = {}\n numa_nodes = []\n cores = []\n cpu_layout = self.get_cpu_layout(node)\n\n # Assume the number of cpus per slice is always the same as the\n # first slice\n first_node = \"0\"\n for cpu in cpu_layout:\n if cpu[\"node\"] != first_node:\n break\n total_cpus_per_slice += 1\n\n # Get the total number of cpus, cores, and numa nodes from the\n # cpu layout\n for cpul in cpu_layout:\n numa_node = cpul[\"node\"]\n core = cpul[\"core\"]\n cpu = cpul[\"cpu\"]\n total_cpus += 1\n\n if numa_node not in cpus_per_node:\n cpus_per_node[numa_node] = []\n cpuperslice = int(cpu) % total_cpus_per_slice\n if cpuperslice == 0:\n cpus_per_node[numa_node].append(\n (int(cpu), int(cpu) + total_cpus_per_slice - 1)\n )\n if numa_node not in numa_nodes:\n numa_nodes.append(numa_node)\n if core not in cores:\n cores.append(core)\n node[\"cpu\"][\"cpus_per_node\"] = cpus_per_node\n\n # Ask the user some questions\n if ask_questions and total_cpus >= 4:\n self._modify_cpu_questions(node, total_cpus, numa_nodes)\n\n # Populate the interfaces with the numa node\n if \"interfaces\" in node:\n ikeys = node[\"interfaces\"].keys()\n VPPUtil.get_interfaces_numa_node(node, *tuple(ikeys))\n\n # We don't want to write the cpuinfo\n node[\"cpuinfo\"] = \"\"\n\n # Write the configs\n self._update_auto_config()\n self.updateconfig()","def _create_reduceOp(cls, onnx_node, inputs, opset_version):\n axes = onnx_node.getattr(\"axes\", None)\n keepdims = onnx_node.getattr(\"keepdims\", 1)\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\n opset_version)\n return _, forward(axes, keepdims)","def find_quantizer_nodes_to_cut(\n graph: NNCFGraph,\n quantizer_node: NNCFNode,\n quantizer_metatypes: List[OperatorMetatype],\n const_metatypes: List[OperatorMetatype],\n quantizable_metatypes: List[OperatorMetatype],\n quantize_agnostic_metatypes: List[OperatorMetatype],\n) -> Tuple[List[NNCFNode], List[NNCFNode]]:\n\n def _parse_node_relatives(node: NNCFNode, is_parents: bool):\n if node.metatype in quantizable_metatypes:\n ops_to_return_in_orig_prec.add(node)\n\n relatives = graph.get_previous_nodes(node) if is_parents else graph.get_next_nodes(node)\n for relative in relatives:\n if relative.metatype in quantizer_metatypes:\n if is_parents:\n if relative in seen_children:\n continue\n if relative not in to_cut:\n to_cut.append(relative)\n to_see_children.append(relative)\n else:\n seen_children.append(relative)\n elif relative.metatype not in const_metatypes:\n if relative not in seen_parents:\n to_see_parents.append(relative)\n if relative not in seen_children and relative.metatype in quantize_agnostic_metatypes:\n to_see_children.append(relative)\n\n seen_list = seen_parents if is_parents else seen_children\n seen_list.append(node)\n\n seen_children, seen_parents = [], []\n to_see_children, to_see_parents = [quantizer_node], []\n to_cut = [quantizer_node]\n ops_to_return_in_orig_prec = set()\n\n while to_see_parents or to_see_children:\n if to_see_children:\n _parse_node_relatives(to_see_children.pop(), is_parents=False)\n if to_see_parents:\n _parse_node_relatives(to_see_parents.pop(), is_parents=True)\n\n return to_cut, list(ops_to_return_in_orig_prec)","def optimize(cls, onnx_model):\n\n input2node = cls.map_input_and_node(onnx_model)\n output2node = cls.map_output_and_node(onnx_model)\n\n standalone_nodes = cls.find_standalone_nodes(onnx_model, input2node,\n output2node)\n for node in standalone_nodes:\n cls.remove_node_from_onnx(node, onnx_model)\n print_log(f'Remove node {node.name}')\n\n redundant_inits = cls.find_redundant_initializers(\n onnx_model, input2node)\n for init in redundant_inits:\n cls.remove_initializer_from_onnx(init, onnx_model)\n print_log(f'Remove initializer {init.name}')\n\n sorted_onnx_model = cls.topo_sort(onnx_model)\n\n return sorted_onnx_model","def apply(self, model, layer_quantize_map, quantize_registry, mode):\n\n transforms = [\n vitis_8bit_quantize_transforms.InputLayerQuantize(\n quantize_registry.get_input_quantizer(), mode),\n vitis_8bit_quantize_transforms.ConvActivationQuantize(),\n vitis_8bit_quantize_transforms.AddActivationQuantize(),\n ]\n return model_transformer.ModelTransformer(model, transforms,\n set(layer_quantize_map.keys()),\n layer_quantize_map).transform()","def convert_prod(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdims\")\n\n if axes is not None:\n node = onnx.helper.make_node(\n 'ReduceProd',\n inputs=input_nodes,\n outputs=[name],\n axes=axes,\n keepdims=keepdims,\n name=name\n )\n\n return [node]\n else:\n node = onnx.helper.make_node(\n 'ReduceProd',\n inputs=input_nodes,\n outputs=[name],\n keepdims=keepdims,\n name=name\n )\n\n return [node]","def __call__(self, graph: Data, n_min: int, nodes_to_keep: List[int] = None, exhaustive: bool = False):\n nodes_to_keep = nodes_to_keep if nodes_to_keep is not None else []\n mcts = self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)\n\n for iteration in range(self.m):\n mcts.search_one_iteration()\n\n explanation = mcts.best_leaf_node()\n\n return explanation.node_set, mcts","def get_GNS_cut_reduced(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_2):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n #print \"Min GNS cut value = \" + str(m.objVal)\n #print \"GNS cut edges:\"\n cut_set_edges = []\n for u,v in edges:\n if e[u,v].x != 0:\n #print (u,v), str(G[u][v]['capacity'])\n cut_set_edges.append((u,v, G[u][v]['capacity']))\n return (m.objVal, cut_set_edges)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n return None, None\n\n except GurobiError:\n print ('Error report from Gurobi')","def model_with_postprocessing_nodes():\n\n inputs = tf.keras.Input(shape=(10, 10, 3,))\n x = tf.keras.layers.Conv2D(16, (3, 3))(inputs)\n _ = tf.keras.layers.MaxPool2D()(x)\n x = tf.keras.layers.Conv2D(8, (2, 2))(x)\n x = tf.keras.layers.Flatten()(x)\n x = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\"model_with_postprocessing_nodes\")(x)\n\n labels_placeholder = tf.compat.v1.placeholder_with_default(tf.constant(1, shape=(1, 10)),\n shape=[None, 10],\n name='labels')\n\n confidences = tf.nn.softmax(x, axis=1, name='confidences')\n categorical_preds = tf.argmax(confidences, axis=1, name='categorical_preds')\n categorical_labels = tf.argmax(labels_placeholder, axis=1, name='categorical_labels')\n correct_predictions = tf.equal(categorical_labels, categorical_preds)\n _ = tf.reduce_mean(tf.cast(correct_predictions, tf.float32), name='top1-acc')\n _ = tf.reduce_mean(tf.cast(tf.nn.in_top_k(predictions=confidences,\n targets=tf.cast(categorical_labels, tf.int32),\n k=5), tf.float32), name='top5-acc')","def generate_output_graph(self, max_name_value):\n for node_name, value in max_name_value.items():\n node_name = node_name.replace(\":\", \"__port__\").replace(\"^\", \"__hat__\")\n if node_name not in self.graph_info:\n continue\n new_node = node_def_pb2.NodeDef()\n new_node.op = \"Const\"\n new_node_postfix = \"/frozen_{}_only\".format(''.join(\n [x for x in self.postfix if x.isalpha()]))\n new_node.name = node_name + new_node_postfix\n new_node.attr[\"dtype\"].CopyFrom(\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\n new_node.attr[\"value\"].CopyFrom(\n attr_value_pb2.AttrValue(\n tensor=tensor_util.make_tensor_proto(float(value),\n dtypes.float32, [])))\n output_node_name = self.graph_info[node_name].outputs[0]\n self.cur_graph.replace_const_node(new_node,\n [Helper.node_name_from_input(output_node_name)],\n node_name)\n self.cur_graph.remove_node(node_name)\n\n self.quantizeV2_min_max[node_name] = tensor_util.MakeNdarray(\n new_node.attr[\"value\"].tensor\n )\n self.scale_info[self.postfix[:-1]] = self.quantizeV2_min_max\n\n return GraphAnalyzer().dump_graph(), self.scale_info","def convert_sum(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdims\")\n\n if axes:\n node = onnx.helper.make_node(\n 'ReduceSum',\n inputs=input_nodes,\n outputs=[name],\n axes=axes,\n keepdims=keepdims,\n name=name\n )\n else:\n node = onnx.helper.make_node(\n 'ReduceSum',\n inputs=input_nodes,\n outputs=[name],\n keepdims=keepdims,\n name=name\n )\n return [node]","def convert_min(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n mx_axis = attrs.get(\"axis\", None)\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\n\n keepdims = get_boolean_attribute_value(attrs, \"keepdims\")\n\n if axes is not None:\n node = onnx.helper.make_node(\n 'ReduceMin',\n inputs=input_nodes,\n outputs=[name],\n axes=axes,\n keepdims=keepdims,\n name=name\n )\n\n return [node]\n else:\n node = onnx.helper.make_node(\n 'ReduceMin',\n inputs=input_nodes,\n outputs=[name],\n keepdims=keepdims,\n name=name\n )\n\n return [node]","def quantize(model: nn.Module,\n precision: str = 'int8',\n accelerator: str = None,\n use_ipex: bool = False,\n calib_dataloader: DataLoader = None,\n metric: Metric = None,\n accuracy_criterion: dict = None,\n approach: str = 'static',\n method: str = None,\n conf: str = None,\n tuning_strategy: str = None,\n timeout: int = None,\n max_trials: int = None,\n input_sample=None,\n thread_num: int = None,\n onnxruntime_session_options=None,\n logging: bool = True,\n **export_kwargs):\n return InferenceOptimizer.quantize(model=model,\n precision=precision,\n accelerator=accelerator,\n use_ipex=use_ipex,\n calib_dataloader=calib_dataloader,\n metric=metric,\n accuracy_criterion=accuracy_criterion,\n approach=approach,\n method=method,\n conf=conf,\n tuning_strategy=tuning_strategy,\n timeout=timeout,\n max_trials=max_trials,\n input_sample=input_sample,\n thread_num=thread_num,\n onnxruntime_session_options=onnxruntime_session_options,\n logging=logging,\n **export_kwargs)","def all_views_max_pool(input_layer, network_type, stride=(2, 2)):\r\n if network_type == \"CC\":\r\n\r\n\r\n input_l_cc, input_r_cc = input_layer\r\n\r\n output_l_cc = tf.nn.max_pool(input_l_cc, ksize=[1, stride[0], stride[1], 1], strides=[1, stride[0], stride[1], 1],\r\n padding='SAME')\r\n output_r_cc = tf.nn.max_pool(input_r_cc, ksize=[1, stride[0], stride[1], 1], strides=[1, stride[0], stride[1], 1],\r\n padding='SAME')\r\n\r\n output = (output_l_cc, output_r_cc)\r\n\r\n return output\r\n else:\r\n input_l_mlo, input_r_mlo = input_layer\r\n\r\n output_l_mlo = tf.nn.max_pool(input_l_mlo, ksize=[1, stride[0], stride[1], 1],\r\n strides=[1, stride[0], stride[1], 1],\r\n padding='SAME')\r\n output_r_mlo = tf.nn.max_pool(input_r_mlo, ksize=[1, stride[0], stride[1], 1],\r\n strides=[1, stride[0], stride[1], 1],\r\n padding='SAME')\r\n\r\n output = (output_l_mlo, output_r_mlo)\r\n\r\n return output","def reduce_run():","def compute(self, node, input_vals):\r\n raise NotImplementedError","def maximize(self):\n raise NotImplementedError","def quantize_whole_model(net, bits=8):\n cluster_centers = []\n assert isinstance(net, nn.Module)\n layer_ind = 0\n for n, m in net.named_modules():\n if isinstance(m, PrunedConv):\n \"\"\"\n Apply quantization for the PrunedConv layer.\n --------------Your Code---------------------\n \"\"\"\n\n # Cluster the Weights\n num_centroid = pow(2, bits)\n\n all_weight = m.conv.weight.data.cpu().detach().numpy()\n weight_shape = all_weight.shape\n \n all_weight = all_weight.reshape(-1,1)\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\n\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\n\n # Generate Code Book\n cluster_center = kmeans.cluster_centers_.flatten()\n\n # Quantize\n indexs = kmeans.predict(all_weight)\n indexs = indexs.reshape(weight_shape)\n \n vmap = np.vectorize(lambda x:cluster_center[x])\n m.conv.weight.data = torch.from_numpy(vmap(indexs)).to(device)\n \n _cluster_center = [ \"{0:b}\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\n cluster_centers.append(_cluster_center)\n\n layer_ind += 1\n print(\"Complete %d layers quantization...\" %layer_ind)\n \n elif isinstance(m, PruneLinear):\n \"\"\"\n Apply quantization for the PrunedLinear layer.\n --------------Your Code---------------------\n \"\"\"\n \n # Cluster the Weights\n num_centroid = pow(2, bits)\n \n all_weight = m.linear.weight.data.cpu().detach().numpy()\n weight_shape = all_weight.shape\n\n all_weight = all_weight.reshape(-1,1)\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\n \n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\n \n # Generate Code Book\n cluster_center = kmeans.cluster_centers_.flatten()\n\n # Quantize\n indexs = kmeans.predict(all_weight)\n indexs = indexs.reshape(weight_shape)\n\n vmap = np.vectorize(lambda x:cluster_center[x])\n m.linear.weight.data = torch.from_numpy(vmap(indexs)).to(device)\n \n _cluster_center = [ \"{0:b}\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\n cluster_centers.append(_cluster_center)\n \n layer_ind += 1\n print(\"Complete %d layers quantization...\" %layer_ind)\n \n return np.array(cluster_centers)","def build_resnet152(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \n temp = res3a_feats\n for i in range(1, 8):\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\n res3b7_feats = temp\n \n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n temp = res4a_feats\n for i in range(1, 36):\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\n res4b35_feats = temp\n\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def test_max_expansion(self):\n\n circuit, params = self.make_qnode_and_params(\"device\")\n\n assert circuit.max_expansion == 10\n info = qml.specs(circuit, max_expansion=0)(params)\n assert circuit.max_expansion == 10\n\n assert len(info) == 11\n\n gate_sizes = defaultdict(int, {5: 1})\n gate_types = defaultdict(int, {\"BasicEntanglerLayers\": 1})\n expected_resources = qml.resource.Resources(\n num_wires=5, num_gates=1, gate_types=gate_types, gate_sizes=gate_sizes, depth=1\n )\n assert info[\"resources\"] == expected_resources\n assert info[\"num_observables\"] == 1\n assert info[\"num_device_wires\"] == 5\n assert info[\"device_name\"] == \"default.qubit.autograd\"\n assert info[\"diff_method\"] == \"best\"\n assert info[\"gradient_fn\"] == \"backprop\"","def main(supply):\n\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\n # between each pair. For instance, the arc from node 0 to node 1 has a\n # capacity of 15 and a unit cost of 4.\n\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\n\n # Define an array of supplies at each node.\n supplies = supply\n\n\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n\n # Add each arc.\n for i in range(0, len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\n capacities[i], unit_costs[i])\n\n # Add node supplies.\n\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n\n\n # Find the minimum cost flow between node 0 and node 4.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n flag = 1\n optimal_flows = np.zeros(36)\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # save answer to the variable\n optimal_flows[i] = min_cost_flow.Flow(i)\n return flag, optimal_flows\n else:\n print('There was an issue with the min cost flow input.')\n flag = 0\n return flag, 0","def local_cut_useless_reduce(node):\r\n if isinstance(node.op, T.CAReduce):\r\n summed, = node.inputs\r\n # if reduce were doing anything, the output ndim would be reduced\r\n if summed.type == node.outputs[0].type:\r\n return [summed]","def fit(self):\n self._minuit_problem.migrad() # run optimizer\n self._status = 0 if self._minuit_problem.migrad_ok() else 1","def __call__(self, **kwargs):\n segname = 'block_{}_expand_relu'\n blocks = [13, 6, 3, 1]\n skips = [self._backbone.get_layer(segname.format(i)) for i in blocks]\n backbone_out = self._backbone.get_layer('block_16_project')\n\n p5 = self._fpn_block(backbone_out.output, skips[0].output)\n p4 = self._fpn_block(p5, skips[1].output)\n p3 = self._fpn_block(p4, skips[2].output)\n p2 = self._fpn_block(p3, skips[3].output)\n\n s5 = self._conv_block(p5, 128)\n s4 = self._conv_block(p4, 128)\n s3 = self._conv_block(p3, 128)\n s2 = self._conv_block(p2, 128)\n\n s5 = tf.keras.layers.UpSampling2D(\n size=(8, 8),\n interpolation='nearest'\n )(s5)\n\n s4 = tf.keras.layers.UpSampling2D(\n size=(4, 4),\n interpolation='nearest'\n )(s4)\n\n s3 = tf.keras.layers.UpSampling2D(\n size=(2, 2),\n interpolation='nearest'\n )(s3)\n\n concat = [s5, s4, s3, s2]\n x = tf.keras.layers.Concatenate()(concat)\n x = tf.keras.layers.Conv2D(\n 64,\n kernel_size=3,\n padding='same',\n kernel_initializer='he_uniform'\n )(x)\n\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.Activation('relu')(x)\n x = tf.keras.layers.UpSampling2D((2, 2))(x)\n\n x = tf.keras.layers.Conv2D(\n 1,\n kernel_size=3,\n padding='same',\n kernel_initializer='he_uniform'\n )(x)\n\n out = tf.keras.layers.Activation('sigmoid')(x)\n model = tf.keras.models.Model(\n inputs=self._backbone.input,\n outputs=out\n )\n\n return model","def solve(self, **kwargs):\n\n sorted_compute_nodes = sorted(\n self.physical.compute_nodes,\n key=lambda x: self.physical.cores(x) * 1000 + self.physical.memory(x),\n reverse=True,\n )\n\n for n_partitions_to_try in range(\n self.lower_bound(), len(sorted_compute_nodes) + 1\n ):\n\n # partitioning of virtual nodes in n_partitions_to_try partitions\n k_partition = get_partitions(\n self.virtual.g, n_partitions=n_partitions_to_try\n )\n\n # subset of hosts of size n_partitions_to_try\n chosen_physical = sorted_compute_nodes[:n_partitions_to_try]\n\n #\n # check if the partitioning is a feasible solution\n #\n try:\n # virtual nodes to physical nodes assignment\n res_node_mapping = {}\n\n # iterate over each pair (physical_node i, virtual nodes assigned to i)\n for physical_node, assigned_virtual_nodes in zip(\n chosen_physical, k_partition\n ):\n # keep track of the node physical resources used\n cores_used = memory_used = 0\n # check if node resources are not exceeded:\n for virtual_node in assigned_virtual_nodes:\n # cpu cores\n cores_used += self.virtual.req_cores(virtual_node)\n if self.physical.cores(physical_node) < cores_used:\n raise NodeResourceError(physical_node, \"cpu cores\")\n # memory\n memory_used += self.virtual.req_memory(virtual_node)\n if self.physical.memory(physical_node) < memory_used:\n raise NodeResourceError(physical_node, \"memory\")\n # assign the virtual nodes to a physical node\n res_node_mapping[virtual_node] = physical_node\n\n #\n # virtual links to physical links assignment\n #\n res_link_mapping = {}\n rate_used = defaultdict(int)\n\n # iterate over each virtual link between two virtual nodes not mapped on the same physical machine\n for (u, v) in (\n (u, v)\n for (u, v) in self.virtual.sorted_edges()\n if res_node_mapping[u] != res_node_mapping[v]\n ):\n\n res_link_mapping[(u, v)] = []\n\n # physical nodes on which u and v have been placed\n phy_u, phy_v = res_node_mapping[u], res_node_mapping[v]\n\n # for each link in the physical path\n for (i, j, device_id) in self.physical.find_path(\n phy_u,\n phy_v,\n req_rate=self.virtual.req_rate(u, v),\n used_rate=rate_used,\n ):\n # else update the rate\n rate_used[(i, j, device_id)] += self.virtual.req_rate(u, v)\n\n res_link_mapping[(u, v)].append((i, device_id, j))\n\n # build solution from the output\n self.solution = Solution.build_solution(\n self.virtual, self.physical, res_node_mapping, res_link_mapping\n )\n self.status = Solved\n return Solved\n\n except (NodeResourceError, NoPathFoundError):\n # unfeasible, increase the number of partitions to be used\n pass\n else:\n self.status = Infeasible\n return Infeasible","def enumerate_validated_operator_opsets(verbose=0, opset_min=-1, opset_max=-1,\n check_runtime=True, debug=False, runtime='python',\n models=None, dump_folder=None, store_models=False,\n benchmark=False, skip_models=None,\n assume_finite=True, node_time=False,\n fLOG=print, filter_exp=None,\n versions=False, extended_list=False,\n time_kwargs=None, dump_all=False,\n n_features=None, skip_long_test=True,\n fail_bad_results=False,\n filter_scenario=None,\n time_kwargs_fact=None,\n time_limit=4, n_jobs=None):\n register_converters()\n register_rewritten_operators()\n register_new_operators()\n\n ops = _enumerate_validated_operator_opsets_ops(\n extended_list, models, skip_models)\n\n if verbose > 0:\n\n def iterate():\n for i, row in enumerate(ops): # pragma: no cover\n fLOG(f\"{i + 1}/{len(ops)} - {row}\")\n yield row\n\n if verbose >= 11:\n verbose -= 10 # pragma: no cover\n loop = iterate() # pragma: no cover\n else:\n try:\n from tqdm import trange\n\n def iterate_tqdm():\n with trange(len(ops)) as t:\n for i in t:\n row = ops[i]\n disp = row['name'] + \" \" * (28 - len(row['name']))\n t.set_description(f\"{disp}\")\n yield row\n\n loop = iterate_tqdm()\n\n except ImportError: # pragma: no cover\n loop = iterate()\n else:\n loop = ops\n\n if versions:\n add_versions = _enumerate_validated_operator_opsets_version(runtime)\n else:\n add_versions = {}\n\n current_opset = __max_supported_opset__\n if opset_min == -1:\n opset_min = __max_supported_opset__\n if opset_max == -1:\n opset_max = __max_supported_opset__\n if verbose > 0 and fLOG is not None:\n fLOG(\"[enumerate_validated_operator_opsets] opset in [{}, {}].\".format(\n opset_min, opset_max))\n for row in loop:\n\n model = row['cl']\n if verbose > 1:\n fLOG(f\"[enumerate_validated_operator_opsets] - model='{model}'\")\n\n for obs in enumerate_compatible_opset(\n model, opset_min=opset_min, opset_max=opset_max,\n check_runtime=check_runtime, runtime=runtime,\n debug=debug, dump_folder=dump_folder,\n store_models=store_models, benchmark=benchmark,\n fLOG=fLOG, filter_exp=filter_exp,\n assume_finite=assume_finite, node_time=node_time,\n verbose=verbose, extended_list=extended_list,\n time_kwargs=time_kwargs, dump_all=dump_all,\n n_features=n_features, skip_long_test=skip_long_test,\n filter_scenario=filter_scenario,\n time_kwargs_fact=time_kwargs_fact,\n time_limit=time_limit, n_jobs=n_jobs):\n\n for mandkey in ('inst', 'method_name', 'problem',\n 'scenario'):\n if '_0problem_exc' in obs:\n continue\n if mandkey not in obs:\n raise ValueError(\"Missing key '{}' in\\n{}\".format(\n mandkey, pprint.pformat(obs))) # pragma: no cover\n if verbose > 1:\n fLOG('[enumerate_validated_operator_opsets] - OBS')\n if verbose > 2:\n fLOG(\" \", obs)\n else:\n obs_log = {k: v for k,\n v in obs.items() if 'lambda-' not in k}\n fLOG(\" \", obs_log)\n elif verbose > 0 and \"_0problem_exc\" in obs:\n fLOG(\" ???\", obs) # pragma: no cover\n\n diff = obs.get('max_rel_diff_batch', None)\n batch = 'max_rel_diff_batch' in obs and diff is not None\n op1 = obs.get('domain_opset_', '')\n op2 = obs.get('domain_opset_ai.onnx.ml', '')\n op = f'{op1}/{op2}'\n\n obs['available'] = \"?\"\n if diff is not None:\n if diff < 1e-5:\n obs['available'] = 'OK'\n elif diff < 0.0001:\n obs['available'] = 'e<0.0001' # pragma: no cover\n elif diff < 0.001:\n obs['available'] = 'e<0.001'\n elif diff < 0.01:\n obs['available'] = 'e<0.01' # pragma: no cover\n elif diff < 0.1:\n obs['available'] = 'e<0.1'\n else:\n obs['available'] = f\"ERROR->={diff:1.1f}\"\n obs['available'] += '-' + op\n if not batch:\n obs['available'] += \"-NOBATCH\" # pragma: no cover\n if fail_bad_results and 'e<' in obs['available']:\n raise RuntimeBadResultsError(\n f\"Wrong results '{obs['available']}'.\", obs) # pragma: no cover\n\n excs = []\n for k, v in sorted(obs.items()):\n if k.endswith('_exc'):\n excs.append((k, v))\n break\n if 'opset' not in obs:\n # It fails before the conversion happens.\n obs['opset'] = current_opset\n if obs['opset'] == current_opset and len(excs) > 0:\n k, v = excs[0]\n obs['available'] = f'ERROR-{k}'\n obs['available-ERROR'] = v\n\n if 'bench-skl' in obs:\n b1 = obs['bench-skl']\n if 'bench-batch' in obs:\n b2 = obs['bench-batch']\n else:\n b2 = None\n if b1 is not None and b2 is not None:\n for k in b1:\n if k in b2 and b2[k] is not None and b1[k] is not None:\n key = 'time-ratio-N=%d' % k\n obs[key] = b2[k]['average'] / b1[k]['average']\n key = 'time-ratio-N=%d-min' % k\n obs[key] = b2[k]['min_exec'] / b1[k]['max_exec']\n key = 'time-ratio-N=%d-max' % k\n obs[key] = b2[k]['max_exec'] / b1[k]['min_exec']\n\n obs.update(row)\n obs.update(add_versions)\n yield obs.copy()","def inference(self):\n logging.info('Mincut inference')\n\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\n # set label\n [positive_label, _] = self._cut.partition\n positive_label = set(positive_label) - {self._v_plus}\n self._graph.delete_vertices([self._v_minus, self._v_plus])\n y = np.zeros(self._graph.vcount()) # re-construct y\n y[list(positive_label)] = 1\n self._graph.vs['label'] = y.astype(int)","def apply(self, model, layer_quantize_map, remove_dropout, fold_conv_bn,\n fold_bn, replace_relu6, include_cle, cle_steps):\n\n transforms = []\n if remove_dropout:\n transforms.append(vitis_optimize_transforms.RemoveDropout())\n\n if fold_conv_bn:\n transforms.append(vitis_optimize_transforms.Conv2DBatchNormFold())\n\n if fold_bn:\n transforms.append(vitis_optimize_transforms.BatchNormFold())\n\n if replace_relu6:\n transforms.append(vitis_optimize_transforms.ReplaceReLU6WithReLU())\n\n transformed_model, layer_quantize_map = model_transformer.ModelTransformer(\n model, transforms, None, layer_quantize_map).transform()\n\n # Cross Layer Equalization\n if include_cle:\n cle_transforms = [\n vitis_optimize_transforms.ConvConvCLE(),\n vitis_optimize_transforms.ConvActConvCLE(),\n ]\n progbar = keras.utils.Progbar(cle_steps)\n print('[INFO] Start CrossLayerEqualization...')\n for i in range(cle_steps):\n progbar.update(i + 1)\n tmp_model, tmp_layer_quantize_map = transformed_model, layer_quantize_map\n transformed_model, layer_quantize_map = model_transformer.ModelTransformer(\n tmp_model, cle_transforms, None,\n tmp_layer_quantize_map).transform()\n print('[INFO] CrossLayerEqualization Done.')\n return transformed_model, layer_quantize_map","def maximize(self, budget, optimizer):\n\n\t\tpass","def reduce(nodes):\r\n accum = tc.mean(nodes.mailbox['m'], 1).cuda()\r\n return {'h': accum}","def apply_nodes(self, func=\"default\", v=ALL, inplace=True):\n super(BaseGraphStore, self).apply_nodes(func, v, inplace=True)","def update_filter_limits(self):\n filters = {}\n filters[\"label\"] = \"NanoribbonWorkChain\"\n filters[\"extras.preprocess_version\"] = self.PREPROCESS_VERSION\n filters[\"extras.preprocess_successful\"] = True\n filters[\"extras.obsolete\"] = False\n\n qb = orm.QueryBuilder()\n qb.append(orm.WorkChainNode, filters=filters)\n\n def compare_and_set(val, slider):\n if val < slider.min:\n slider.min = val\n if val > slider.max:\n slider.max = val\n # also reset to min-max\n slider.value = (slider.min, slider.max)\n\n for m in qb.all():\n calc = m[0]\n compare_and_set(calc.get_extra(\"gap\"), self.inp_gap)\n compare_and_set(calc.get_extra(\"homo\"), self.inp_homo)\n compare_and_set(calc.get_extra(\"lumo\"), self.inp_lumo)\n compare_and_set(calc.get_extra(\"fermi_energy\"), self.inp_efermi)\n compare_and_set(\n calc.get_extra(\"total_magnetization_per_angstr\"), self.inp_tmagn\n )\n compare_and_set(\n calc.get_extra(\"absolute_magnetization_per_angstr\"), self.inp_amagn\n )","def input_nodes(self):\n pass","def compute(self, node, input_vals):\r\n #start = time.time()\r\n\r\n #assert len(input_vals) == 1\r\n strides = node.const_attr[1]\r\n ksize = node.const_attr[0]\r\n ish = list(input_vals[0].shape)\r\n input = input_vals[0]\r\n output = np.zeros([ish[0],(ish[1]-ksize[1])//strides[1]+1,(ish[2]-ksize[2])//strides[2]+1,ish[3]])\r\n osh = output.shape\r\n #print(osh)\r\n for i in range(osh[1]):\r\n for j in range(osh[2]):\r\n output[:,i,j,:] = np.amax(input[:,i*strides[1]:(i+1)*strides[1],j*strides[1]:(j+1)*strides[1],:],axis=(1,2))\r\n #end = time.time() \r\n #print(\"max_pool\") \r\n #print(end - start) \r\n return output\r\n \r\n #assert False\r","def optimize(self):\n self.check_is_ready()\n self.check_infeasibility()\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)","def create(self):\n \n \"\"\" A solo prepressing reduction network in the head \"\"\"\n print(\"pre_reduction\")\n with tf.name_scope('pre_reduction'):\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\n \n \"\"\" 1st inception layer group \"\"\"\n print(\"icp1\")\n with tf.name_scope('icp1'):\n # branch 0\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\n # branch 1\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\n # branch 2\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\n # branch 3\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\n # concat\n icp2_in = NW.concat([icp1_out0,\n icp1_out1,\n icp1_out2,\n icp1_out3], 3, 'icp2_in')\n\n \"\"\" 2nd inception layer group \"\"\"\n print(\"icp2\")\n with tf.name_scope('icp2'):\n # branch 0\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\n # branch 1\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\n # branch 2\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\n # branch 3\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\n # concat\n icp2_out = NW.concat([icp2_out0,\n icp2_out1,\n icp2_out2,\n icp2_out3], 3, 'icp2_out')\n \n \"\"\" 3rd inception layer group \"\"\"\n print(\"icp3\")\n with tf.name_scope('icp3'):\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\n # branch 0\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\n # branch 1\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\n # branch 2\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\n # branch 3\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\n # concat\n icp3_out = NW.concat([icp3_out0,\n icp3_out1,\n icp3_out2,\n icp3_out3], 3, 'icp3_out')\n \n \"\"\" 1st classify branch \"\"\"\n with tf.name_scope('cls1'):\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\n self.layers[\"cls1_fc_pose_xy\"] = cls1_fc_pose_xy\n self.layers[\"cls1_fc_pose_ab\"] = cls1_fc_pose_ab\n \n \"\"\" 4st inception layer group \"\"\"\n print(\"icp4\")\n with tf.name_scope('icp4'):\n # branch 0\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\n # branch 1\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\n # branch 2\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\n # branch 3\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\n # concat\n icp4_out = NW.concat([icp4_out0,\n icp4_out1,\n icp4_out2,\n icp4_out3],3, name='icp4_out')\n\n \"\"\" 5st inception layer group \"\"\"\n print(\"icp5\")\n with tf.name_scope('icp5'):\n # branch 0\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\n # branch 1\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\n # branch 2\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\n # branch 3\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\n # concat\n icp5_out = NW.concat([icp5_out0, \n icp5_out1, \n icp5_out2, \n icp5_out3], 3, name='icp5_out')\n \n \"\"\" 6st inception layer group \"\"\"\n print(\"icp6\")\n with tf.name_scope('icp6'):\n # branch 0\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\n # branch 1\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\n # branch 2\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\n # branch 3\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\n # concat\n icp6_out = NW.concat([icp6_out0,\n icp6_out1,\n icp6_out2,\n icp6_out3], 3, name='icp6_out')\n\n \"\"\" 2nd classify branch \"\"\"\n with tf.name_scope('cls2'):\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\n self.layers[\"cls2_fc_pose_xy\"] = cls2_fc_pose_xy\n self.layers[\"cls2_fc_pose_ab\"] = cls2_fc_pose_ab\n\n \"\"\" 7st inception layer group \"\"\"\n print(\"icp7\")\n with tf.name_scope('icp7'):\n # branch 0\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\n # branch 1\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\n # branch 2\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\n # branch 3\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\n # concat\n icp7_out = NW.concat([icp7_out0,\n icp7_out1,\n icp7_out2,\n icp7_out3], 3, name='icp7_out')\n\n \"\"\" 8st inception layer group \"\"\"\n print(\"icp8\")\n with tf.name_scope('icp8'):\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\n # branch 0\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\n # branch 1\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\n # branch 2\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\n # branch 3\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\n # concat\n icp8_out = NW.concat([icp8_out0,\n icp8_out1,\n icp8_out2,\n icp8_out3], 3, name='icp8_out')\n \n \"\"\" 9st inception layer group \"\"\"\n print(\"icp9\")\n with tf.name_scope('icp9'):\n # branch 0\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\n # branch 1\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\n # branch 2\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\n # branch 3\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\n # concat\n icp9_out = NW.concat([icp9_out0,\n icp9_out1,\n icp9_out2,\n icp9_out3], 3, name='icp9_out')\n\n \"\"\" 3rd classify branch \"\"\"\n with tf.name_scope('cls3'):\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\n self.layers[\"cls3_fc_pose_xy\"] = cls3_fc_pose_xy\n self.layers[\"cls3_fc_pose_ab\"] = cls3_fc_pose_ab","def calculateAllSupport(self):\n\n for key, value in self._sets[self._currentSet].items():\n val = self.getSupport(key)\n self._sets[self._currentSet][key] = self.getSupport(key)","def add_max(org, kernels, centres):\n return org","def Allreduce4(net, blobs, reduced_affix, gpu_indices):\n a, b, c, d = blobs\n gpu_a, gpu_b, gpu_c, gpu_d = gpu_indices\n # a_reduced <- a+b, c_reduced <- c + d\n a_reduced = net.Add(\n [a, b],\n str(a) + reduced_affix,\n device_option=OnGPU(gpu_a)\n )\n c_reduced = net.Add(\n [c, d],\n str(c) + reduced_affix,\n device_option=OnGPU(gpu_c)\n )\n # a_reduced <- a_reduced + c_reduced\n a_reduced = a_reduced.Add(c_reduced, a_reduced, device_option=OnGPU(gpu_a))\n # broadcast a_reduced to c_reduced\n c_reduced = a_reduced.Copy([], c_reduced, device_option=OnGPU(gpu_c))\n # broadcast to b and d\n b_reduced = a_reduced.Copy(\n [],\n str(b) + reduced_affix,\n device_option=OnGPU(gpu_b)\n )\n d_reduced = c_reduced.Copy(\n [],\n str(d) + reduced_affix,\n device_option=OnGPU(gpu_d)\n )\n return a_reduced, b_reduced, c_reduced, d_reduced","def evaluator(self, candidates, args):\r\n fitness = []\r\n if self._use_ants:\r\n for candidate in candidates:\r\n total = 0\r\n for c in candidate:\r\n total += c.value\r\n fitness.append(total)\r\n else:\r\n for candidate in candidates:\r\n total_value = 0\r\n total_weight = 0\r\n for c, i in zip(candidate, self.items):\r\n total_weight += c * i[0]\r\n total_value += c * i[1]\r\n if total_weight > self.capacity:\r\n fitness.append(self.capacity - total_weight)\r\n else:\r\n fitness.append(total_value)\r\n return fitness","def reduce(model_results, out, params):\n import numpy as np\n for n, (ps, activation_results) in model_results:\n\n if not activation_results:\n out.add(n, (ps, None))\n else:\n out.add(n, (ps, activation_results))","def generate_mcts(self, graph: Data, n_min: int, nodes_to_keep: List[int],\n exhaustive: bool):\n return self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)","def _reduce(self, x, y):\n ind = self.ind_\n n_samples, n_features = x.shape\n n_features_selected = sum(ind)\n\n for _ in range(self.iters, self.max_iter):\n if np.count_nonzero(ind) == 0:\n warnings.warn(\n \"Sparsity parameter is too big ({}) and eliminated all coeficients\".format(self.threshold)\n )\n coef = np.zeros_like(ind, dtype=float)\n break\n\n coef = self._regress(x[:, ind], y, self.alpha)\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\n\n if sum(ind) == n_features_selected or self._no_change():\n # could not (further) select important features\n break\n else:\n warnings.warn(\n \"STRidge._reduce did not converge after {} iterations.\".format(self.max_iter),\n ConvergenceWarning,\n )\n try:\n coef\n except NameError:\n coef = self.coef_\n warnings.warn(\"STRidge._reduce has no iterations left to determine coef\", ConvergenceWarning)\n self.coef_ = coef\n self.ind_ = ind","def compute(self, inputs, outputs):\n\n # Add new variables to dictionnary\n cpacs = CPACS(Rt.modules[-1].cpacs_out)\n\n update_dict(cpacs.tixi, Rt.optim_var_dict)\n\n # Save the whole aeromap if needed\n if Rt.use_aeromap:\n update_am_dict(cpacs, Rt.aeromap_uid, Rt.am_dict)\n\n for obj in Rt.objective:\n var_list = split(\"[+*/-]\", obj)\n for v in var_list:\n if not v.isdigit() and v != \"\":\n exec('{} = inputs[\"{}\"]'.format(v, v))\n result = eval(obj)\n\n if Rt.minmax == \"min\":\n outputs[\"Objective function \" + obj] = result\n else:\n outputs[\"Objective function \" + obj] = -result","def _query_quantizable_ops(self, matched_nodes, activation_dtype, weight_dtype):\n\n tf_quantizable_op_type = (\"Conv2D\", \"DepthwiseConv2dNative\",\n \"MaxPool\", \"AvgPool\", \"ConcatV2\", \"MatMul\", \"Pad\")\n conv_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax', 'kl'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n },\n 'weight': {\n 'dtype': weight_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_channel', 'per_tensor']\n }\n }\n matmul_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['asym', 'sym'],\n 'granularity': ['per_tensor']\n },\n 'weight': {\n 'dtype': weight_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n }\n }\n other_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n },\n }\n\n self.quantizable_op_details = OrderedDict()\n\n self._init_op_stat = {i: [] for i in tf_quantizable_op_type}\n for details in matched_nodes:\n node_op = details[-1][0]\n node_name = details[0]\n patterns = details[-1]\n pat_length = len(patterns)\n pattern_info = {\n 'sequence': [[','.join(patterns[:pat_length - i]) for i in range(pat_length)][0]],\n 'precision': ['int8']\n }\n if node_op in tf_quantizable_op_type and node_name not in self.exclude_node_names:\n self._init_op_stat[node_op].append(node_name)\n if self.unify_op_type_mapping[node_op].find(\"conv2d\") != -1:\n conv2d_int8_config = copy.deepcopy(conv_config)\n conv2d_int8_config['pattern'] = pattern_info\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = conv2d_int8_config\n elif self.unify_op_type_mapping[node_op].find(\"matmul\") != -1:\n matmul_int8_config = copy.deepcopy(matmul_config)\n matmul_int8_config['pattern'] = pattern_info\n # TODO enable the sym mode once the tf fixed the mkldequantize_op.cc bug.\n # is_positive_input = self.pre_optimizer_handle.has_positive_input(node_name)\n # matmul_scheme = 'sym' if is_positive_input else 'asym'\n matmul_scheme = ['asym']\n matmul_int8_config['activation']['scheme'] = matmul_scheme\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = matmul_int8_config\n else:\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = copy.deepcopy(other_config)\n\n self.quantize_config['op_wise_config'][node_name] = (False, \"minmax\", False)\n return self.quantizable_op_details","def optimize_graph( complete, desired, algo, simi_cutoff ) :\n if (algo == \"trim\") :\n return trim_cluster( desired, desired.nodes(), 2 )","def Q_credit_checkers(s_grid, s_n, g_n, a_m, s_m, s_others, t_obs, v_obs,\n f1=4, k1=[3,5], f2=6, k2=[3,3],\n n_h1_1=128, n_h1_2=32, n_h2=32, stage=2, bias=True):\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\n concated = tf.concat( [conv, s_n, g_n, a_m, conv_o, v_obs], axis=1 )\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\n W_branch1_h2 = get_variable(\"W_branch1_h2\", [n_h1_1, n_h2])\n\n list_mult = []\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\n\n if stage > 1:\n with tf.variable_scope(\"stage-2\"):\n concated2 = tf.concat( [s_m, s_others], axis=1 )\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\n list_mult.append(tf.matmul(others, W_branch2_h2))\n\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\n \n return out","def calc_operand_assignments(self, op_keys, input_chunk_metas=None):\n graph = self._graph\n op_states = self._op_states\n cur_assigns = OrderedDict(self._fixed_assigns)\n expect_workers = dict()\n\n key_to_chunks = defaultdict(list)\n for n in graph:\n key_to_chunks[n.op.key].append(n)\n if n.op.expect_worker is not None:\n expect_workers[n.op.key] = cur_assigns[n.op.key] = n.op.expect_worker\n\n descendant_readies = set()\n op_keys = set(op_keys)\n requested_chunks = [key_to_chunks[k][0] for k in op_keys]\n chunks_to_assign = [c for c in requested_chunks if c.op.expect_worker is None]\n\n if any(graph.count_predecessors(c) for c in chunks_to_assign):\n graph = graph.copy()\n for c in graph:\n if c.op.key not in op_keys:\n continue\n for pred in graph.predecessors(c):\n graph.remove_edge(pred, c)\n\n assigned_counts = defaultdict(lambda: 0)\n worker_op_keys = defaultdict(set)\n if cur_assigns:\n for op_key, state in op_states.items():\n if op_key not in op_keys and state == OperandState.READY \\\n and op_key in cur_assigns:\n descendant_readies.add(op_key)\n assigned_counts[cur_assigns[op_key]] += 1\n\n # calculate the number of nodes to be assigned to every worker\n # given number of workers and existing assignments\n pre_worker_quotas = self._calc_worker_assign_limits(\n len(chunks_to_assign) + len(descendant_readies), assigned_counts)\n\n # pre-assign nodes given pre-determined transfer sizes\n if not input_chunk_metas:\n worker_quotas = pre_worker_quotas\n else:\n for op_key, worker in self._iter_assignments_by_transfer_sizes(\n pre_worker_quotas, input_chunk_metas):\n if op_key in cur_assigns or op_key not in op_keys:\n continue\n assigned_counts[worker] += 1\n cur_assigns[op_key] = worker\n worker_op_keys[worker].add(op_key)\n\n worker_quotas = self._calc_worker_assign_limits(\n len(chunks_to_assign) + len(descendant_readies), assigned_counts)\n\n if cur_assigns:\n # calculate ranges of nodes already assigned\n for op_key, worker in self._iter_successor_assigns(cur_assigns):\n cur_assigns[op_key] = worker\n worker_op_keys[worker].add(op_key)\n\n logger.debug('Worker assign quotas: %r', worker_quotas)\n\n # calculate expected descendant count (spread range) of\n # every worker and subtract assigned number from it\n average_spread_range = len(graph) * 1.0 / len(self._worker_slots)\n spread_ranges = defaultdict(lambda: average_spread_range)\n for worker in cur_assigns.values():\n spread_ranges[worker] -= 1\n\n logger.debug('Scan spread ranges: %r', dict(spread_ranges))\n\n # assign pass 1: assign from fixed groups\n sorted_workers = sorted(worker_op_keys, reverse=True, key=lambda k: len(worker_op_keys[k]))\n for worker in sorted_workers:\n start_chunks = reduce(operator.add, (key_to_chunks[op_key] for op_key in worker_op_keys[worker]))\n self._assign_by_bfs(start_chunks, worker, worker_quotas, spread_ranges,\n op_keys, cur_assigns, graph=graph)\n\n # assign pass 2: assign from other nodes to be assigned\n sorted_candidates = [v for v in chunks_to_assign]\n while max(worker_quotas.values()):\n worker = max(worker_quotas, key=lambda k: worker_quotas[k])\n try:\n cur = sorted_candidates.pop()\n while cur.op.key in cur_assigns:\n cur = sorted_candidates.pop()\n except IndexError: # pragma: no cover\n break\n self._assign_by_bfs(cur, worker, worker_quotas, spread_ranges, op_keys,\n cur_assigns, graph=graph)\n\n keys_to_assign = {n.op.key: n.op for n in requested_chunks}\n assignments = {k: v for k, v in cur_assigns.items() if k in keys_to_assign}\n assignments.update({k: v for k, v in expect_workers.items() if k in keys_to_assign})\n return assignments","def _oim_node2vec_test(\n df,\n df_feats,\n num_inf=10,\n sigma=4,\n c=0.1,\n epsilon=0.4,\n num_repeats=30,\n num_repeats_regret_algo=20,\n num_repeats_regret_true=20,\n num_nodes_tim=-1,\n oracle=tim,\n):\n logger_tlu.debug(\"Started Online Influence Maximization...\")\n logger_tlu.debug(\"Setting parameters\")\n num_feats = df_feats.shape[1]\n num_edges_t = df.shape[0]\n\n # \"True\" probabilities - effectively our test set\n true_weights = df[\"probab\"].copy()\n # Using nodes_t[-1] because TIM wants the max node id\n s_true = sorted(\n oracle(\n df[[\"source\", \"target\", \"probab\"]],\n num_nodes_tim,\n num_edges_t,\n num_inf,\n epsilon,\n )\n )\n # Gathering the stats for the \"true\" seed set\n all_true_nodes = []\n all_true_edges = []\n all_true_obs = []\n for k in range(num_repeats_regret_true):\n true_act_nodes, true_act_edges, true_obs_edges = run_ic_eff(df, s_true)\n all_true_nodes.append(true_act_nodes)\n all_true_edges.append(true_act_edges)\n all_true_obs.append(true_obs_edges)\n\n # Means for nodes and activated edges\n mean_true_nodes = np.mean([len(i) for i in all_true_nodes])\n mean_true_edges = np.mean([len(i) for i in all_true_edges])\n mean_true_obs = np.mean([len(i) for i in all_true_obs])\n\n # b, M_inv - used by IMLinUCB\n b = np.zeros((num_feats, 1))\n m_inv = np.eye(num_feats, num_feats)\n\n # Returning these\n s_best = []\n reward_best = 0\n u_e_best = []\n regrets = []\n regrets_edges = []\n\n for iter_oim in tqdm(\n range(num_repeats),\n desc=f\"OIM iters {num_edges_t} edges\",\n leave=False,\n file=sys.stderr,\n ):\n # ---- Step 1 - Calculating the u_e ----\n theta = (m_inv @ b) / (sigma * sigma)\n # xMx = (df_feats.values @ m_inv @ df_feats.T.values).clip(min=0)\n\n u_e = []\n for i in range(num_edges_t):\n x_e = df_feats.loc[i].values\n xMx = x_e @ m_inv @ x_e.T # .clip(min=0)\n u_e.append(np.clip(x_e @ theta + c * np.sqrt(xMx), 0, 1))\n # u_e.append(expit(x_e @ theta + c * np.sqrt(xMx)))\n\n u_e = np.array(u_e)\n\n # ---- Step 2 - Evaluating the performance ----\n # Loss function\n df[\"probab\"] = u_e\n s_oracle = sorted(\n oracle(\n df[[\"source\", \"target\", \"probab\"]],\n num_nodes_tim,\n num_edges_t,\n num_inf,\n epsilon,\n )\n )\n\n # Observing edge-level feedback\n df[\"probab\"] = true_weights\n\n all_algo_nodes = []\n all_algo_edges = []\n all_algo_obs = []\n for k in range(num_repeats_regret_algo):\n algo_act_nodes, algo_act_edges, algo_obs_edges = run_ic_eff(df, s_oracle)\n all_algo_nodes.append(algo_act_nodes)\n all_algo_edges.append(algo_act_edges)\n all_algo_obs.append(algo_obs_edges)\n\n # Mean node counts\n mean_algo_nodes = np.mean([len(i) for i in all_algo_nodes])\n # Mean activated edge counts\n mean_algo_edges = np.mean([len(i) for i in all_algo_edges])\n mean_algo_obs = np.mean([len(i) for i in all_algo_obs])\n\n # Used for updating M and b later\n all_algo_edges = np.unique(np.concatenate(all_algo_edges))\n all_algo_obs = np.unique(np.concatenate(all_algo_obs))\n\n regrets.append(mean_true_nodes - mean_algo_nodes)\n regrets_edges.append(mean_true_edges - mean_algo_edges)\n\n logger_tlu.debug(f\"True seeds: {s_true}\")\n logger_tlu.debug(f\"Algo seeds: {s_oracle}\")\n logger_tlu.debug(\n \"Diff between true and algo seeds: \"\n f\"{len(np.setdiff1d(s_true, s_oracle))}\"\n )\n logger_tlu.debug(f\"True reward: {mean_true_nodes}\")\n logger_tlu.debug(f\"Algo reward: {mean_algo_nodes}\")\n logger_tlu.debug(f\"Best algo reward: {reward_best}\")\n logger_tlu.debug(f\"Regrets: {regrets}\")\n logger_tlu.debug(f\"Edge regrets: {regrets_edges}\")\n logger_tlu.debug(f\"Observed diff: {mean_true_obs - mean_algo_obs}\")\n logger_tlu.debug(f\"Algo weights {u_e[80:90]}\".replace(\"\\n\", \"\"))\n logger_tlu.debug(f\"Real weights {true_weights[80:90]}\".replace(\"\\n\", \"\"))\n\n if mean_algo_nodes > reward_best:\n reward_best = mean_algo_nodes\n s_best = s_oracle\n u_e_best = u_e\n\n if mean_algo_nodes > mean_true_nodes:\n logger_tlu.debug(\n \"The algorithm has achieved better reward than the true seed node set.\"\n )\n logger_tlu.debug(\"Stopping learning.\")\n logger_tlu.debug(f\"Best algo seed node set: {s_best}\")\n return_dict = {\n \"regrets\": regrets,\n \"regrets_edges\": regrets_edges,\n \"s_true\": s_true,\n \"s_best\": s_best,\n \"u_e_best\": u_e_best,\n \"reward_best\": reward_best,\n }\n logger_tlu.debug(f\"Returning {return_dict}\")\n return return_dict\n\n # ---- Step 3 - Calculating updates ----\n for i in all_algo_obs:\n x_e = np.array([df_feats.loc[i].values])\n m_inv -= (m_inv @ x_e.T @ x_e @ m_inv) / (\n x_e @ m_inv @ x_e.T + sigma * sigma\n )\n b += x_e.T * int(i in all_algo_edges)\n\n return_dict = {\n \"regrets\": regrets,\n \"regrets_edges\": regrets_edges,\n \"s_true\": s_true,\n \"s_best\": s_best,\n \"u_e_best\": u_e_best,\n \"reward_best\": reward_best,\n }\n logger_tlu.debug(\"The algorithm has finished running.\")\n logger_tlu.debug(f\"Returning: {return_dict}\")\n return return_dict","def quantize(self, tune_cfg, model, data_loader, q_func=None):\n assert q_func is None, \"quantization aware training has not been supported on ONNXRUNTIME\"\n model = self.pre_optimized_model if self.pre_optimized_model else model\n ort_version = StrictVersion(ort.__version__)\n if ort_version < ONNXRT152_VERSION: # pragma: no cover\n logger.warning(\"Quantize input needs onnxruntime 1.5.2 or newer.\")\n return model\n if model.model.opset_import[0].version < 11: # pragma: no cover\n logger.warning(\"Quantize input needs model opset 11 or newer.\")\n from neural_compressor.adaptor.ox_utils.onnx_quantizer import ONNXQuantizer\n from onnxruntime.quantization.quant_utils import QuantizationMode\n backend = QuantizationMode.QLinearOps if self.backend == \\\n \"qlinearops\" else QuantizationMode.IntegerOps\n\n self.quantizable_ops = self._query_quantizable_ops(model.model)\n tmp_model = copy.deepcopy(model)\n \n quantize_config = self._cfg_to_quantize_config(tune_cfg)\n iterations = tune_cfg.get('calib_iteration', 1)\n if self.static:\n quantize_params = self._get_quantize_params(tmp_model.model, data_loader, \\\n quantize_config, iterations)\n else:\n quantize_params = None\n self.quantize_params = quantize_params\n quantizer = ONNXQuantizer(tmp_model.model,\n quantize_config,\n backend,\n self.static,\n quantize_params,\n self.quantizable_op_types)\n quantizer.quantize_model()\n tmp_model.q_config = self._generate_qconfig(model.model, tune_cfg, quantize_params)\n tmp_model.model = quantizer.model.model\n self.quantize_config = quantize_config # update so other methods can know current configs\n \n self._dump_model_op_stastics(tmp_model)\n return tmp_model","def _calc_reactions(model, log=False, combo_tags=None):\n\n # Print a status update to the console\n if log: print('- Calculating reactions')\n\n # Identify which load combinations to evaluate\n if combo_tags is None:\n combo_list = model.LoadCombos.values()\n else:\n combo_list = []\n for combo in model.LoadCombos.values():\n if any(tag in combo.combo_tags for tag in combo_tags):\n combo_list.append(combo)\n\n # Calculate the reactions node by node\n for node in model.Nodes.values():\n \n # Step through each load combination\n for combo in combo_list:\n \n # Initialize reactions for this node and load combination\n node.RxnFX[combo.name] = 0.0\n node.RxnFY[combo.name] = 0.0\n node.RxnFZ[combo.name] = 0.0\n node.RxnMX[combo.name] = 0.0\n node.RxnMY[combo.name] = 0.0\n node.RxnMZ[combo.name] = 0.0\n\n # Determine if the node has any supports\n if (node.support_DX or node.support_DY or node.support_DZ \n or node.support_RX or node.support_RY or node.support_RZ):\n\n # Sum the spring end forces at the node\n for spring in model.Springs.values():\n\n if spring.i_node == node and spring.active[combo.name] == True:\n \n # Get the spring's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n spring_F = spring.F(combo.name)\n\n node.RxnFX[combo.name] += spring_F[0, 0]\n node.RxnFY[combo.name] += spring_F[1, 0]\n node.RxnFZ[combo.name] += spring_F[2, 0]\n node.RxnMX[combo.name] += spring_F[3, 0]\n node.RxnMY[combo.name] += spring_F[4, 0]\n node.RxnMZ[combo.name] += spring_F[5, 0]\n\n elif spring.j_node == node and spring.active[combo.name] == True:\n \n # Get the spring's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n spring_F = spring.F(combo.name)\n \n node.RxnFX[combo.name] += spring_F[6, 0]\n node.RxnFY[combo.name] += spring_F[7, 0]\n node.RxnFZ[combo.name] += spring_F[8, 0]\n node.RxnMX[combo.name] += spring_F[9, 0]\n node.RxnMY[combo.name] += spring_F[10, 0]\n node.RxnMZ[combo.name] += spring_F[11, 0]\n\n # Step through each physical member in the model\n for phys_member in model.Members.values():\n\n # Sum the sub-member end forces at the node\n for member in phys_member.sub_members.values():\n \n if member.i_node == node and phys_member.active[combo.name] == True:\n \n # Get the member's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n member_F = member.F(combo.name)\n\n node.RxnFX[combo.name] += member_F[0, 0]\n node.RxnFY[combo.name] += member_F[1, 0]\n node.RxnFZ[combo.name] += member_F[2, 0]\n node.RxnMX[combo.name] += member_F[3, 0]\n node.RxnMY[combo.name] += member_F[4, 0]\n node.RxnMZ[combo.name] += member_F[5, 0]\n\n elif member.j_node == node and phys_member.active[combo.name] == True:\n \n # Get the member's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n member_F = member.F(combo.name)\n \n node.RxnFX[combo.name] += member_F[6, 0]\n node.RxnFY[combo.name] += member_F[7, 0]\n node.RxnFZ[combo.name] += member_F[8, 0]\n node.RxnMX[combo.name] += member_F[9, 0]\n node.RxnMY[combo.name] += member_F[10, 0]\n node.RxnMZ[combo.name] += member_F[11, 0]\n\n # Sum the plate forces at the node\n for plate in model.Plates.values():\n\n if plate.i_node == node:\n\n # Get the plate's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n plate_F = plate.F(combo.name)\n \n node.RxnFX[combo.name] += plate_F[0, 0]\n node.RxnFY[combo.name] += plate_F[1, 0]\n node.RxnFZ[combo.name] += plate_F[2, 0]\n node.RxnMX[combo.name] += plate_F[3, 0]\n node.RxnMY[combo.name] += plate_F[4, 0]\n node.RxnMZ[combo.name] += plate_F[5, 0]\n\n elif plate.j_node == node:\n\n # Get the plate's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n plate_F = plate.F(combo.name)\n \n node.RxnFX[combo.name] += plate_F[6, 0]\n node.RxnFY[combo.name] += plate_F[7, 0]\n node.RxnFZ[combo.name] += plate_F[8, 0]\n node.RxnMX[combo.name] += plate_F[9, 0]\n node.RxnMY[combo.name] += plate_F[10, 0]\n node.RxnMZ[combo.name] += plate_F[11, 0]\n\n elif plate.m_node == node:\n\n # Get the plate's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n plate_F = plate.F(combo.name)\n \n node.RxnFX[combo.name] += plate_F[12, 0]\n node.RxnFY[combo.name] += plate_F[13, 0]\n node.RxnFZ[combo.name] += plate_F[14, 0]\n node.RxnMX[combo.name] += plate_F[15, 0]\n node.RxnMY[combo.name] += plate_F[16, 0]\n node.RxnMZ[combo.name] += plate_F[17, 0]\n\n elif plate.n_node == node:\n\n # Get the plate's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n plate_F = plate.F(combo.name)\n \n node.RxnFX[combo.name] += plate_F[18, 0]\n node.RxnFY[combo.name] += plate_F[19, 0]\n node.RxnFZ[combo.name] += plate_F[20, 0]\n node.RxnMX[combo.name] += plate_F[21, 0]\n node.RxnMY[combo.name] += plate_F[22, 0]\n node.RxnMZ[combo.name] += plate_F[23, 0]\n\n # Sum the quad forces at the node\n for quad in model.Quads.values():\n\n if quad.m_node == node:\n\n # Get the quad's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n quad_F = quad.F(combo.name)\n\n node.RxnFX[combo.name] += quad_F[0, 0]\n node.RxnFY[combo.name] += quad_F[1, 0]\n node.RxnFZ[combo.name] += quad_F[2, 0]\n node.RxnMX[combo.name] += quad_F[3, 0]\n node.RxnMY[combo.name] += quad_F[4, 0]\n node.RxnMZ[combo.name] += quad_F[5, 0]\n\n elif quad.n_node == node:\n\n # Get the quad's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n quad_F = quad.F(combo.name)\n \n node.RxnFX[combo.name] += quad_F[6, 0]\n node.RxnFY[combo.name] += quad_F[7, 0]\n node.RxnFZ[combo.name] += quad_F[8, 0]\n node.RxnMX[combo.name] += quad_F[9, 0]\n node.RxnMY[combo.name] += quad_F[10, 0]\n node.RxnMZ[combo.name] += quad_F[11, 0]\n\n elif quad.i_node == node:\n\n # Get the quad's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n quad_F = quad.F(combo.name)\n \n node.RxnFX[combo.name] += quad_F[12, 0]\n node.RxnFY[combo.name] += quad_F[13, 0]\n node.RxnFZ[combo.name] += quad_F[14, 0]\n node.RxnMX[combo.name] += quad_F[15, 0]\n node.RxnMY[combo.name] += quad_F[16, 0]\n node.RxnMZ[combo.name] += quad_F[17, 0]\n\n elif quad.j_node == node:\n\n # Get the quad's global force matrix\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \n quad_F = quad.F(combo.name)\n \n node.RxnFX[combo.name] += quad_F[18, 0]\n node.RxnFY[combo.name] += quad_F[19, 0]\n node.RxnFZ[combo.name] += quad_F[20, 0]\n node.RxnMX[combo.name] += quad_F[21, 0]\n node.RxnMY[combo.name] += quad_F[22, 0]\n node.RxnMZ[combo.name] += quad_F[23, 0]\n \n # Sum the joint loads applied to the node\n for load in node.NodeLoads:\n\n for case, factor in combo.factors.items():\n \n if load[2] == case:\n\n if load[0] == 'FX':\n node.RxnFX[combo.name] -= load[1]*factor\n elif load[0] == 'FY':\n node.RxnFY[combo.name] -= load[1]*factor\n elif load[0] == 'FZ':\n node.RxnFZ[combo.name] -= load[1]*factor\n elif load[0] == 'MX':\n node.RxnMX[combo.name] -= load[1]*factor\n elif load[0] == 'MY':\n node.RxnMY[combo.name] -= load[1]*factor\n elif load[0] == 'MZ':\n node.RxnMZ[combo.name] -= load[1]*factor\n \n # Calculate reactions due to active spring supports at the node\n elif node.spring_DX[0] != None and node.spring_DX[2] == True:\n sign = node.spring_DX[1]\n k = node.spring_DX[0]\n if sign != None: k = float(sign + str(k))\n DX = node.DX[combo.name]\n node.RxnFX[combo.name] += k*DX\n elif node.spring_DY[0] != None and node.spring_DY[2] == True:\n sign = node.spring_DY[1]\n k = node.spring_DY[0]\n if sign != None: k = float(sign + str(k))\n DY = node.DY[combo.name]\n node.RxnFY[combo.name] += k*DY\n elif node.spring_DZ[0] != None and node.spring_DZ[2] == True:\n sign = node.spring_DZ[1]\n k = node.spring_DZ[0]\n if sign != None: k = float(sign + str(k))\n DZ = node.DZ[combo.name]\n node.RxnFZ[combo.name] += k*DZ\n elif node.spring_RX[0] != None and node.spring_RX[2] == True:\n sign = node.spring_RX[1]\n k = node.spring_RX[0]\n if sign != None: k = float(sign + str(k))\n RX = node.RX[combo.name]\n node.RxnMX[combo.name] += k*RX\n elif node.spring_RY[0] != None and node.spring_RY[2] == True:\n sign = node.spring_RY[1]\n k = node.spring_RY[0]\n if sign != None: k = float(sign + str(k))\n RY = node.RY[combo.name]\n node.RxnMY[combo.name] += k*RY\n elif node.spring_RZ[0] != None and node.spring_RZ[2] == True:\n sign = node.spring_RZ[1]\n k = node.spring_RZ[0]\n if sign != None: k = float(sign + str(k))\n RZ = node.RZ[combo.name]\n node.RxnMZ[combo.name] += k*RZ","def train_models_change_nodes(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, beta, nodes, print_cost = True, is_charge = False):\n \n results = {}\n params = {}\n\n try:\n for n in nodes:\n accs, parameters = model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, n, beta, 1.0, False, True, print_cost, is_charge)\n \n results[n] = accs[3]\n params[n] = parameters\n \n except KeyboardInterrupt: # allow for exiting the for loop in case we want to stop testing all the hyperparameters; to use, press Ctrl+C in terminal\n pass\n \n best = min(results, key=results.get)\n mapes = [results[l] for l in nodes]\n\n if print_cost:\n plt.plot(nodes, mapes)\n plt.ylabel('MAPE')\n plt.xlabel('# of nodes in hidden layer')\n plt.title(\"learning rate = {}, mini-batch = {}, beta = {}\".format(learning_rate, minibatch_size, beta))\n plt.show()\n \n return results, best, params[best]","def run(self, model):\n conv_nodes_list = self.get_conv_nodes(model)\n\n for conv_node in conv_nodes_list:\n weights_node = nu.get_weights_for_node(conv_node)\n weights = nu.get_node_value(weights_node)\n ocs_weights, ocs_channels_idxs = self.split_weights(weights)\n if self.add_input_channels_for_conv_node(conv_node, ocs_channels_idxs):\n nu.set_node_value(weights_node, ocs_weights)\n logger.debug('Node {}: Channels {} were splitted'.\n format(conv_node.fullname, ','.join(str(idx) for idx in ocs_channels_idxs)))\n\n model.clean_up()\n return model","def reconcile(self):\r\n\t\tclass_A = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_G = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_koop = np.empty((self.basis.nK,self.basis.nK),float)\r\n\t\tclass_num = len(self.koop_cluster_list)\r\n\t\tfor i in range(class_num):\r\n\t\t\tclass_mem_num = len(self.koop_cluster_list[i])\r\n\t\t\tclass_counter = 0.0\r\n\t\t\tfor j in range(class_mem_num):\r\n\t\t\t\tclass_A += (self.koop_cluster_list[i][j]._A*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\r\n\t\t\t\tclass_G += (self.koop_cluster_list[i][j]._G*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\r\n\t\t\t\tclass_counter += self.koop_cluster_list[i][j].counter\r\n\t\t\tclass_koop = np.dot(np.linalg.pinv(class_G),class_A)\r\n\t\t\tself.koopman_hybrid_modes.append(KoopmanOperator(self.basis, class_koop, class_A, class_G, class_counter))","def reduce_ops(\n config_path: str,\n build_dir: str,\n enable_type_reduction: bool,\n use_cuda: bool,\n is_extended_minimal_build_or_higher: bool,\n):\n build_dir_path = Path(build_dir).resolve()\n build_dir_path.mkdir(parents=True, exist_ok=True)\n\n required_ops, op_type_impl_filter = parse_config(config_path, enable_type_reduction)\n if is_extended_minimal_build_or_higher:\n required_ops, op_type_impl_filter = _adapt_filters_for_extended_minimal_build(required_ops, op_type_impl_filter)\n\n # delete any existing generated files first\n op_reduction_root = _get_op_reduction_root(build_dir_path)\n if op_reduction_root.is_dir():\n log.info(f\"Deleting existing op reduction file root directory: {op_reduction_root}\")\n shutil.rmtree(op_reduction_root)\n\n _generate_provider_registrations(ORT_ROOT, build_dir_path, use_cuda, required_ops, op_type_impl_filter)\n\n type_control_cpp_code = op_type_impl_filter.get_cpp_entries() if op_type_impl_filter is not None else []\n _generate_type_control_overrides(ORT_ROOT, build_dir_path, type_control_cpp_code)","def compute(self, *args, **kwargs):\n for node in self.evaluation_sequence:\n node.evaluate()","def _parse_requantization_ranges(self):\n res = {}\n\n print_suffix = \"__print__\"\n lines = self._get_valid_log()\n temp_min = {}\n temp_max = {}\n pattern_def = r\"{};{}:\\[\\-?\\d+\\.?\\d*e?-?\\+?\\d*\\]\".format(print_suffix, self.postfix)\n for i in lines:\n if not re.search(pattern_def, i):\n continue\n\n max_line_data = i.split(print_suffix + \";\" + self.postfix)[-1]\n min_value = max_line_data.split('][')[0].split('[')[1]\n max_value = max_line_data.split('][')[1].split(']')[0]\n name = i.split(';')[1].strip()[:-len(print_suffix)]\n if name not in temp_min:\n temp_min[name] = []\n if name not in temp_max:\n temp_max[name] = []\n\n temp_min[name].append(float(min_value))\n temp_max[name].append(float(max_value))\n\n for key in temp_min:\n target_min_index = int(np.ceil(len(temp_min[key]) * (1 - self.threshold)))\n\n if key not in res:\n res[key] = []\n\n if target_min_index > len(temp_min[key]) - 1:\n target_min_index = len(temp_min[key]) - 1\n res[key].append(sorted(temp_min[key])[target_min_index])\n\n for key in temp_max:\n target_max_index = int(np.floor(len(temp_max[key]) * self.threshold)) - 1\n\n if target_max_index > len(temp_max[key]) - 1:\n target_max_index = len(temp_max[key]) - 1\n\n res[key].append(sorted(temp_max[key])[target_max_index])\n\n if self.tensor_data:\n for k, v in self.tensor_data.items():\n if k in res:\n self.logger.debug(\"Update node {} min to {}, max to {}.\".format(k, v[2], v[3]))\n res[k] = [v[2], v[3]]\n return res","def compute_all(self) -> None:\n self.compute_j_matrix()\n self.compute_outter_distribution()\n self.compute_max_prior()\n self.compute_max_poutter()","def res_net_model(features, labels, mode):\n\n # Configurations for each bottleneck group.\n BottleneckGroup = namedtuple('BottleneckGroup',\n ['num_blocks', 'num_filters', 'bottleneck_size'])\n groups = [\n BottleneckGroup(3, 128, 32), BottleneckGroup(3, 256, 64),\n BottleneckGroup(3, 512, 128), BottleneckGroup(3, 1024, 256)\n ]\n\n x = features[X_FEATURE]\n input_shape = x.get_shape().as_list()\n\n # Reshape the input into the right shape if it's 2D tensor\n if len(input_shape) == 2:\n ndim = int(sqrt(input_shape[1]))\n x = tf.reshape(x, [-1, ndim, ndim, 1])\n\n # First convolution expands to 64 channels\n with tf.variable_scope('conv_layer1'):\n net = tf.layers.conv2d(\n x,\n filters=64,\n kernel_size=7,\n activation=tf.nn.relu)\n net = tf.layers.batch_normalization(net)\n\n # Max pool\n net = tf.layers.max_pooling2d(\n net, pool_size=3, strides=2, padding='same')\n\n # First chain of resnets\n with tf.variable_scope('conv_layer2'):\n net = tf.layers.conv2d(\n net,\n filters=groups[0].num_filters,\n kernel_size=1,\n padding='valid')\n\n # Create the bottleneck groups, each of which contains `num_blocks`\n # bottleneck groups.\n for group_i, group in enumerate(groups):\n for block_i in range(group.num_blocks):\n name = 'group_%d/block_%d' % (group_i, block_i)\n\n # 1x1 convolution responsible for reducing dimension\n with tf.variable_scope(name + '/conv_in'):\n conv = tf.layers.conv2d(\n net,\n filters=group.num_filters,\n kernel_size=1,\n padding='valid',\n activation=tf.nn.relu)\n conv = tf.layers.batch_normalization(conv)\n\n with tf.variable_scope(name + '/conv_bottleneck'):\n conv = tf.layers.conv2d(\n conv,\n filters=group.bottleneck_size,\n kernel_size=3,\n padding='same',\n activation=tf.nn.relu)\n conv = tf.layers.batch_normalization(conv)\n\n # 1x1 convolution responsible for restoring dimension\n with tf.variable_scope(name + '/conv_out'):\n input_dim = net.get_shape()[-1].value\n conv = tf.layers.conv2d(\n conv,\n filters=input_dim,\n kernel_size=1,\n padding='valid',\n activation=tf.nn.relu)\n conv = tf.layers.batch_normalization(conv)\n\n # shortcut connections that turn the network into its counterpart\n # residual function (identity shortcut)\n net = conv + net\n\n try:\n # upscale to the next group size\n next_group = groups[group_i + 1]\n with tf.variable_scope('block_%d/conv_upscale' % group_i):\n net = tf.layers.conv2d(\n net,\n filters=next_group.num_filters,\n kernel_size=1,\n padding='same',\n activation=None,\n bias_initializer=None)\n except IndexError:\n pass\n\n net_shape = net.get_shape().as_list()\n net = tf.nn.avg_pool(\n net,\n ksize=[1, net_shape[1], net_shape[2], 1],\n strides=[1, 1, 1, 1],\n padding='VALID')\n\n net_shape = net.get_shape().as_list()\n print(type(net_shape))\n print(\"Length:\", len(net_shape))\n net = tf.reshape(net, [-1, net_shape[1] * net_shape[2] * net_shape[3]])\n print(type(net))\n print(\"Length:\", tf.size(net))\n\n # Compute logits (1 per class) and compute loss.\n logits = tf.layers.dense(net, N_DIGITS, activation=None)\n\n # Compute predictions.\n predicted_classes = tf.argmax(logits, 1)\n if mode == tf.estimator.ModeKeys.PREDICT:\n predictions = {\n 'class': predicted_classes,\n 'prob': tf.nn.softmax(logits)\n }\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\n\n#Loss Function define here -----------------------------------------------------\n # Compute loss.\n onehot_labels = tf.one_hot(tf.cast(labels, tf.int32), N_DIGITS, 1, 0)\n print(\"type(onehot_labels):\", type(onehot_labels))\n print(tf.shape(onehot_labels))\n mynparray = onehot_labels.eval()\n print (\"type(mynparray):\", type(mynparray))\n loss = tf.losses.softmax_cross_entropy(\n onehot_labels=onehot_labels, logits=logits)","def _modify_cpu_questions(self, node, total_cpus, numa_nodes):\n\n print(\n \"\\nYour system has {} core(s) and {} Numa Nodes.\".format(\n total_cpus, len(numa_nodes)\n )\n )\n print(\n \"To begin, we suggest not reserving any cores for \"\n \"VPP or other processes.\"\n )\n print(\n \"Then to improve performance start reserving cores and \"\n \"adding queues as needed.\"\n )\n\n # Leave 1 for the general system\n total_cpus -= 1\n max_vpp_cpus = min(total_cpus, 4)\n total_vpp_cpus = 0\n if max_vpp_cpus > 0:\n question = (\n \"\\nHow many core(s) shall we reserve for \"\n \"VPP [0-{}][0]? \".format(max_vpp_cpus)\n )\n total_vpp_cpus = self._ask_user_range(question, 0, max_vpp_cpus, 0)\n node[\"cpu\"][\"total_vpp_cpus\"] = total_vpp_cpus\n\n total_other_cpus = 0\n max_other_cores = total_cpus - total_vpp_cpus\n if max_other_cores > 0:\n question = (\n \"How many core(s) do you want to reserve for \"\n \"processes other than VPP? [0-{}][0]? \".format(str(max_other_cores))\n )\n total_other_cpus = self._ask_user_range(question, 0, max_other_cores, 0)\n node[\"cpu\"][\"total_other_cpus\"] = total_other_cpus\n\n max_main_cpus = total_cpus - total_vpp_cpus - total_other_cpus\n reserve_vpp_main_core = False\n if max_main_cpus > 0:\n question = \"Should we reserve 1 core for the VPP Main thread? \"\n question += \"[y/N]? \"\n answer = self._ask_user_yn(question, \"n\")\n if answer == \"y\":\n reserve_vpp_main_core = True\n node[\"cpu\"][\"reserve_vpp_main_core\"] = reserve_vpp_main_core\n node[\"cpu\"][\"vpp_main_core\"] = 0\n\n question = (\n \"How many RX queues per port shall we use for \"\n \"VPP [1-4][1]? \".format(max_vpp_cpus)\n )\n total_rx_queues = self._ask_user_range(question, 1, 4, 1)\n node[\"cpu\"][\"total_rx_queues\"] = total_rx_queues","def run_inference(self,isMax = 1,findZ = 0):\r\n# st=time.time()\r\n self.make_connected()\r\n self.nop = 0 # number of operations\r\n T=CliqueTree(self,isMax,findZ)\r\n if isMax == 0:\r\n self.marg_clique_tree = T\r\n elif isMax==1:\r\n self.MAP_clique_tree = T\r\n# print time.time()-st'=\r\n self.nop += T.nop\r\n M=[]\r\n for i in self.g.nodes(): # assuming nodes are labeled 0..N-1\r\n for s,data in T.nodes_iter(data=True):\r\n f = data['fac']\r\n if i in f.var:\r\n if isMax==0:\r\n dummy = f.Marginalize(scipy.setdiff1d(f.var,i))\r\n if findZ == 0:\r\n dummy.val = dummy.val/sum(dummy.val)\r\n else:\r\n dummy = f.MaxMarginalize(scipy.setdiff1d(f.var,i))\r\n self.nop += scipy.prod(f.card)\r\n M.append(dummy)\r\n break\r\n# print time.time()-st\r\n return M","def _update_parallel_coef_constraints(self, x):\n n_features = x.shape[1]\n xi_final = np.zeros((n_features, n_features))\n\n # Todo: parallelize this for loop with Multiprocessing/joblib\n if self.model_subset is None:\n self.model_subset = range(n_features)\n elif np.max(np.abs(self.model_subset)) >= n_features:\n raise ValueError(\n \"A value in model_subset is larger than the number \"\n \"of features in the candidate library\"\n )\n for i in self.model_subset:\n print(\"Model \", i)\n xi = cp.Variable(n_features)\n # Note that norm choice below must be convex,\n # so thresholder must be L1 or L2\n if (self.thresholder).lower() in (\"l1\", \"weighted_l1\"):\n if self.thresholds is None:\n cost = cp.sum_squares(x[:, i] - x @ xi) + self.threshold * cp.norm1(\n xi\n )\n else:\n cost = cp.sum_squares(x[:, i] - x @ xi) + cp.norm1(\n self.thresholds[i, :] @ xi\n )\n if (self.thresholder).lower() in (\"l2\", \"weighted_l2\"):\n if self.thresholds is None:\n cost = (\n cp.sum_squares(x[:, i] - x @ xi)\n + self.threshold * cp.norm2(xi) ** 2\n )\n else:\n cost = (\n cp.sum_squares(x[:, i] - x @ xi)\n + cp.norm2(self.thresholds[i, :] @ xi) ** 2\n )\n prob = cp.Problem(\n cp.Minimize(cost),\n [xi[i] == 0.0],\n )\n try:\n prob.solve(\n max_iter=self.max_iter,\n eps_abs=self.tol,\n eps_rel=self.tol,\n verbose=self.verbose_cvxpy,\n )\n if xi.value is None:\n warnings.warn(\n \"Infeasible solve on iteration \"\n + str(i)\n + \", try changing your library\",\n ConvergenceWarning,\n )\n xi_final[:, i] = xi.value\n # Annoying error coming from L2 norm switching to use the ECOS\n # solver, which uses \"max_iters\" instead of \"max_iter\", and\n # similar semantic changes for the other variables.\n except TypeError:\n prob.solve(\n max_iters=self.max_iter,\n abstol=self.tol,\n reltol=self.tol,\n verbose=self.verbose_cvxpy,\n )\n if xi.value is None:\n warnings.warn(\n \"Infeasible solve on iteration \"\n + str(i)\n + \", try changing your library\",\n ConvergenceWarning,\n )\n xi_final[:, i] = xi.value\n except cp.error.SolverError:\n print(\"Solver failed on model \", str(i), \", setting coefs to zeros\")\n xi_final[:, i] = np.zeros(n_features)\n return xi_final","def maximize(self):\n self.abstract_obj.maximize()","def reduce_possibilities_by_box(self):\n x = self.targetCell.x\n y = self.targetCell.y\n if x < 3 and y < 3: #top left\n self.check_box1()\n if x > 2 and x < 6 and y < 3: #middle left\n self.check_box2()\n if x > 5 and y < 3: #bottom left\n self.check_box3()\n if x < 3 and y > 2 and y < 6: #top middle\n self.check_box4()\n if x > 2 and x < 6 and y > 2 and y < 6: #center\n self.check_box5()\n if x > 5 and y > 2 and y < 6: #bottom middle\n self.check_box6()\n if x < 3 and y > 5: #top right\n self.check_box7()\n if x > 2 and x < 6 and y > 5: #middle right\n self.check_box8()\n if x > 5 and y > 5: #bottom right\n self.check_box9()\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)","def compute(self):\n if self.computed:\n return self.classifications\n\n self.partial_compute()\n\n self.classifications = []\n classify_network = Network([ArgMaxLayer()])\n for pre, post in self.transformed_lines:\n # First, we take each of the linear regions and split them where\n # the ArgMax changes.\n lines = list(zip(post[:-1], post[1:]))\n classify_transformed_lines = classify_network.exactlines(\n lines, compute_preimages=False, include_post=False)\n\n split_pre = []\n split_post = []\n for i, endpoints in enumerate(classify_transformed_lines):\n pre_delta = pre[i + 1] - pre[i]\n post_delta = post[i + 1] - post[i]\n for point_ratio in endpoints:\n point_pre = pre[i] + (point_ratio * pre_delta)\n point_post = post[i] + (point_ratio * post_delta)\n if i == 0 or not point_ratio == 0.0:\n split_pre.append(point_pre)\n split_post.append(point_post)\n\n # Now, in each of the resulting regions, we compute the\n # corresponding label.\n region_labels = []\n for i in range(len(split_pre) - 1):\n mid_post = 0.5 * (split_post[i] + split_post[i + 1])\n region_labels.append(np.argmax(mid_post))\n\n # Finally, we merge segments with the same classification.\n merged_pre = []\n merged_labels = []\n for i, label in enumerate(region_labels):\n if not merged_labels or label != merged_labels[-1]:\n merged_pre.append(split_pre[i])\n merged_labels.append(label)\n merged_pre.append(split_pre[-1])\n regions = list(zip(merged_pre[:-1], merged_pre[1:]))\n self.classifications.append((regions, merged_labels))\n self.computed = True\n return self.classifications","def calculate_ucb_max(self, node):\n pass","def include_compression(nets, compression='none', linear_max=796.87416837456942, input_node_name='cochleagram_no_compression', output_node_name='cochleagram', linear_params=None, rate_level_kwargs={}, custom_compression_op=None):\n # compression of the cochleagram\n if compression=='quarter':\n nets[output_node_name] = tf.sqrt(tf.sqrt(nets[input_node_name], name=output_node_name))\n elif compression=='quarter_plus':\n nets[output_node_name] = tf.sqrt(tf.sqrt(nets[input_node_name]+1e-01, name=output_node_name))\n elif compression=='point3':\n nets[output_node_name] = tf.pow(nets[input_node_name],0.3, name=output_node_name)\n elif compression=='stable_point3':\n nets[output_node_name] = tf.identity(stable_power_compression(nets[input_node_name]*linear_max),name=output_node_name) \n elif compression=='stable_point3_norm_grads':\n nets[output_node_name] = tf.identity(stable_power_compression_norm_grad(nets[input_node_name]*linear_max),name=output_node_name) \n elif compression=='linearbelow1':\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, tf.pow(nets[input_node_name]*linear_max,0.3), name=output_node_name)\n elif compression=='stable_linearbelow1':\n nets['stable_power_compressed_%s'%output_node_name] = tf.identity(stable_power_compression(nets[input_node_name]*linear_max),name='stable_power_compressed_%s'%output_node_name)\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, nets['stable_power_compressed_%s'%output_node_name], name=output_node_name)\n elif compression=='linearbelow1sqrt':\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, tf.sqrt(nets[input_node_name]*linear_max), name=output_node_name)\n elif compression=='quarter_clipped':\n nets[output_node_name] = tf.sqrt(tf.sqrt(tf.maximum(nets[input_node_name],1e-01), name=output_node_name))\n elif compression=='none':\n nets[output_node_name] = nets[input_node_name]\n elif compression=='sqrt':\n nets[output_node_name] = tf.sqrt(nets[input_node_name], name=output_node_name)\n elif compression=='dB': # NOTE: this compression does not work well for the backwards pass, results in nans\n nets[output_node_name + '_noclipped'] = 20 * tflog10(nets[input_node_name])/tf.reduce_max(nets[input_node_name])\n nets[output_node_name] = tf.maximum(nets[output_node_name + '_noclipped'], -60)\n elif compression=='dB_plus': # NOTE: this compression does not work well for the backwards pass, results in nans\n nets[output_node_name + '_noclipped'] = 20 * tflog10(nets[input_node_name]+1)/tf.reduce_max(nets[input_node_name]+1)\n nets[output_node_name] = tf.maximum(nets[output_node_name + '_noclipped'], -60, name=output_node_name)\n elif compression=='linear':\n assert (type(linear_params)==list) and len(linear_params)==2, \"Specifying linear compression but not specifying the compression parameters in linear_params=[m, b]\"\n nets[output_node_name] = linear_params[0]*nets[input_node_name] + linear_params[1]\n elif compression=='rate_level':\n nets[output_node_name] = AN_rate_level_function(nets[input_node_name], name=output_node_name, **rate_level_kwargs)\n elif compression=='custom':\n nets[output_node_name] = custom_compression_op(nets[input_node_name], name=output_node_name)\n\n return nets","def test_multiple_input_model_get_op_product_graph(self):\n\n tf.compat.v1.reset_default_graph()\n _ = multiple_input_model()\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), ['input1', 'input2'], ['multiple_input_model/Softmax'])\n self.assertTrue(validate_branch_ops(conn_graph))\n self.assertTrue(validate_product_tensor_lists(conn_graph))\n self.assertEqual(0, conn_graph.branch_count)\n self.assertEqual(9, len(conn_graph.get_all_ops()))\n self.assertEqual(8 + len(tf.compat.v1.get_default_graph().get_collection('variables')),\n len(conn_graph.get_all_products()))\n self.assertTrue(conn_graph.get_all_ops()['input1'].output.is_model_input)\n self.assertTrue(conn_graph.get_all_ops()['input2'].output.is_model_input)","def _assign_reg_vals(self, sess):\n with self.graph.as_default():\n for nn in range(self.num_networks):\n self.networks[nn].assign_reg_vals(sess)","def train(self):\n max_tuple = self.max_gain()\n # If that gain is 0 then every node should be a pure leaf (hopefully) and you can stop\n while max_tuple.gain != 0:\n max_tuple.node.split(max_tuple.attribute)\n max_tuple = self.max_gain()","def convert_pooling(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n kernel = eval(attrs[\"kernel\"])\n pool_type = attrs[\"pool_type\"] if attrs.get(\"pool_type\") else \"max\"\n stride = eval(attrs[\"stride\"]) if attrs.get(\"stride\") else (1, 1)\n global_pool = get_boolean_attribute_value(attrs, \"global_pool\")\n p_value = attrs.get('p_value', 'None')\n\n pooling_convention = attrs.get('pooling_convention', 'valid')\n ceil_mode = False\n if pooling_convention == 'full':\n if onnx.__version__ < \"1.5.0\":\n pooling_warning = \"Pooling: ONNX lower than 1.5.0 doesn't support pooling_convention. \" \\\n \"This might lead to shape or accuracy issues. \" \\\n \"https://github.com/onnx/onnx/issues/549\"\n ceil_mode = True\n logging.warning(pooling_warning)\n\n pad_dims = list(parse_helper(attrs, \"pad\", [0, 0]))\n pad_dims = pad_dims + pad_dims\n pool_types = {\"max\": \"MaxPool\", \"avg\": \"AveragePool\", \"lp\": \"LpPool\"}\n global_pool_types = {\"max\": \"GlobalMaxPool\", \"avg\": \"GlobalAveragePool\",\n \"lp\": \"GlobalLpPool\"}\n\n if pool_type == 'lp' and p_value == 'None':\n raise AttributeError('ONNX requires a p value for LpPool and GlobalLpPool')\n\n if global_pool:\n if pool_type == 'lp':\n node = onnx.helper.make_node(\n global_pool_types[pool_type],\n input_nodes, # input\n [name],\n p=int(p_value),\n name=name\n )\n else:\n node = onnx.helper.make_node(\n global_pool_types[pool_type],\n input_nodes, # input\n [name],\n name=name\n )\n else:\n if pool_type == 'lp':\n node = onnx.helper.make_node(\n pool_types[pool_type],\n input_nodes, # input\n [name],\n p=int(p_value),\n kernel_shape=kernel,\n pads=pad_dims,\n strides=stride,\n name=name\n )\n else:\n if onnx.__version__ >= \"1.5.0\":\n node = onnx.helper.make_node(\n pool_types[pool_type],\n input_nodes, # input\n [name],\n kernel_shape=kernel,\n pads=pad_dims,\n strides=stride,\n name=name,\n ceil_mode=ceil_mode\n )\n else:\n node = onnx.helper.make_node(\n pool_types[pool_type],\n input_nodes, # input\n [name],\n kernel_shape=kernel,\n pads=pad_dims,\n strides=stride,\n name=name\n )\n\n return [node]","def run1(self, eval_node , feed_dict = {}):\r\n self.eval_node_list = eval_node \r\n for i in feed_dict:\r\n feed_dict[i] = np.array(feed_dict[i]).astype(i.dtype)\r\n #print(self.eval_node_list)\r\n node_to_val_map = dict(feed_dict)\r\n # Traverse graph in topological sort order and compute values for all nodes.\r\n topo_start_node = []\r\n for node in self.eval_node_list:\r\n if isinstance(node,Node):\r\n topo_start_node.append(node)\r\n if topo_start_node==[]:\r\n return eval_node\r\n topo_order = find_topo_sort(topo_start_node)\r\n \r\n \"\"\"TODO: Your code here\"\"\"\r\n for node in topo_order :\r\n if isinstance(node.op, PlaceholderOp):\r\n if not(node in node_to_val_map) and (node in global_variables):\r\n node_to_val_map[node] = global_variables[node]\r\n continue \r\n if not(node in node_to_val_map):\r\n input_vals1=[]\r\n for inp in node.inputs:\r\n input_vals1.append( node_to_val_map[inp] )\r\n #print(input_vals1)\r\n node_to_val_map[node] = node.op.compute(node, input_vals1)\r\n # Collect node values.\r\n node_val_results = []\r\n for node in self.eval_node_list:\r\n if isinstance(node, Node):\r\n node_val_results.append(node_to_val_map[node])\r\n else:\r\n node_val_results.append(node)\r\n #node_val_results = [node_to_val_map[node] for node in self.eval_node_list]\r\n return node_val_results","def experiment1_outliers():\n\tdata_folder = \"ckan_subset/prepared_learnset/\"\n\ttest_folder = 'ckan_subset/testset/xml_csv/'\n\tgm = Graph_Maker()\n\tgm.store()\n\trounds = 5\n\tx = [\"Fingerprint\", \"Syntax Feature Model\", \"Word2Vec Matcher\"]\n\t\n\tnumber_of_classes = 15\n\texamples_per_class = 0\n\taccuracies = []\n\tprecisions = []\n\trecalls = []\n\tfmeasures = []\n\tsf_main = Storage_Files(data_folder, classes)\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\n\tfor i in range(0, rounds):\n\t\tprint(\"Fingerprint\")\n\t\t# --- Fingerprint\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Fingerprint', [sf_main, number_of_classes, examples_per_class, False, False])\n\n\t\tccc.add_matcher('matcher', 'Fingerprint_Matcher', {'feature_main': 'fingerprint'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\t\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\tfor i in range(0, rounds):\n\t\tprint(\"SFM\")\n\t\t# --- Syntax Feature Model\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Syntax_Feature_Model', [sf_main, 1, 0, False, False])\n\n\t\tccc.add_matcher('matcher', 'Syntax_Matcher', {'feature_main': 'syntax'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\n\ttmp_acc = []\n\ttmp_prec = []\n\ttmp_rec = []\n\ttmp_fmeasure = []\n\ttotal_actual = []\n\ttotal_predicted = []\n\tfor i in range(0, rounds):\n\t\tprint(\"W2V\")\n\t\t# --- Word2Vec Matcher\n\t\tccc = Column_Classification_Config()\n\t\tccc.add_feature('feature_main', 'Corpus', [sf_main, number_of_classes, examples_per_class, False, False])\n\n\t\tccc.add_matcher('matcher', 'Word2Vec_Matcher', {'feature_main': 'corpus'}) # main classifier\n\t\tsm = Schema_Matcher(ccc)\n\t\tactual, predicted = execute_test_ckan(sm, test_folder, False)\n\t\ttotal_actual += actual\n\t\ttotal_predicted += predicted\n\t\taccuracy = accuracy_score(actual, predicted)\n\t\ttmp_acc.append(accuracy)\n\t\ttmp_prec.append(precision(actual, predicted))\n\t\ttmp_rec.append(recall(actual, predicted))\n\t\ttmp_fmeasure.append(f_measure(actual, predicted))\n\n\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\n\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\n\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\n\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\n\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\n\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\n\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\n\n\tgm.add_x(x)\n\t# accuracies = [0.4, 0.4, 0.4]\n\t# precisions = [0.5, 0.5, 0.5]\n\t# recalls = [0.62, 0.62, 0.62]\n\t# fmeasures = [0.23, 0.23, 0.28]\n\tgm.append_y(accuracies)\n\tgm.append_y(precisions)\n\tgm.append_y(recalls)\n\tgm.append_y(fmeasures)\n\tgm.store()\n\tsubtitle = \"Scores were averaged over \" + str(rounds) + \" tests with \" + str(len(classes)) + \" classes. \" + \\\n\t\"Number of simulated columns per class: \" + str(number_of_classes)\n\tlabels = [\"Accuracy\", \"Precision\", \"Recall\", \"F-Measure\"]\n\tgm.plot_bar_n(\"Matcher Type\", \"Score\", \"Accuracy of Matchers\", labels, subtitle=subtitle)","def __init__(self, input_shape, action_shape, net_conf, minval=-1, maxval=1, val_buffer=1e-6):\n\n super().__init__()\n\n self.minval = minval\n self.maxval = maxval\n self.replace_min = minval+val_buffer\n\n #initialize weights\n initializer = initializers.RandomUniform(minval=minval, maxval=maxval)\n \n self.action_shape = action_shape\n\n self.add(keras.Input(shape=input_shape))\n for conv in net_conf['conv_layer_params']:\n self.add(layers.Conv2D(\n conv[0],\n conv[1],\n conv[2],\n activation=net_conf['conv_activation'],\n kernel_initializer=initializer,\n bias_initializer=initializer))\n self.add(layers.Flatten())\n for full in net_conf['fc_layer_params']:\n self.add(layers.Dense(\n full,\n activation=net_conf['fc_activation'],\n kernel_initializer=initializer,\n bias_initializer=initializer))\n self.add(layers.Dense(\n action_shape,\n activation=None,\n kernel_initializer=initializer,\n bias_initializer=initializer))\n self.build()","def build_candidates(allowed_nodes=[identity], best_candidates=[], nb_candidates=200):\n new_candidates = []\n length_limit = 4 # Maximal length of a program\n def random_node():\n return random.choice(allowed_nodes)\n\n # Until we have enough new candidates\n while (len(new_candidates) < nb_candidates):\n # Add 10 new programs\n for i in range(5):\n new_candidates += [[random_node()]]\n\n # Create new programs based on each best candidate\n for best_program in best_candidates:\n # Add one op on its right but limit the length of the program\n if len(best_program) < length_limit - 1:\n new_candidates += [[random_node()] + best_program]\n # Add one op on its left but limit the length of the program\n if len(best_program) < length_limit - 1:\n new_candidates += [best_program + [random_node()]]\n # Mutate one instruction of the existing program\n new_candidates += [list(best_program)]\n new_candidates[-1][random.randrange(0, len(best_program))] = random_node()\n\n # Truncate if we have too many candidates\n np.random.shuffle(new_candidates)\n return new_candidates[:nb_candidates]","def Q_global_checkers(s_grid, s_n, g_n, a_n, s_others, a_others, t_obs, v_obs,\n f1=4, k1=[3,5], f2=6, k2=[3,3], n_h1_1=128, n_h1_2=32,\n n_h2=32, n_actions=5, stage=1, bias=True):\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\n concated = tf.concat( [conv, s_n, g_n, a_n, conv_o, v_obs], axis=1 )\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\n W_branch1_h2 = get_variable(\"W_branch1_h2\", [n_h1_1, n_h2])\n\n list_mult = []\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\n\n if stage > 1:\n n_others = a_others.get_shape().as_list()[1]\n a_others_reshaped = tf.reshape(a_others, [-1, n_others*n_actions])\n with tf.variable_scope(\"stage-2\"):\n concated2 = tf.concat( [s_others, a_others_reshaped], axis=1 )\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\n list_mult.append(tf.matmul(others, W_branch2_h2))\n\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\n \n return out","def compute(self, data, input_type='points', output_type='probability'):\n output = []\n\n for vector in data:\n # calculating output for every vector\n for v, node in zip(vector, self.input_nodes):\n node.set_value(v)\n\n result = [node.get_value() for node in self.output_nodes]\n\n result = np.array(result)\n if output_type == 'probability':\n if len(result) > 1:\n # softmax calculation, multi class probability distribution\n x = result\n e_x = np.exp(x - np.max(x))\n\n result = e_x / e_x.sum()\n else:\n # sigmoid calculation, probability\n x = result\n x = np.clip(x, -500, 500)\n result = 1 / (1 + np.exp(-x))\n\n output.append(result)\n\n # reset nodes\n for node in self.nodes:\n node.reset()\n if input_type == 'points':\n node.past_value = 0\n\n return output","def get_optimums(self, model, size, excludes):\n raise NotImplementedError","def run_reduce(self):\n from histogram import add_and_save\n root_file = TFile(self.args.output, \"RECREATE\")\n add_and_save(self.output, root_file)\n root_file.Write()\n root_file.Close()","def compute_model(self, A_on_basis_vec_handles, B_on_standard_basis_handles,\n C_on_basis_vecs):\n self.reduce_A(A_on_basis_vec_handles)\n self.reduce_B(B_on_standard_basis_handles)\n self.reduce_C(C_on_basis_vecs)\n return self.A_reduced, self.B_reduced, self.C_reduced","def _create_reduceOp(cls, op, op_t):\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\n\n node.attribute.extend([\n helper.make_attribute('axes', list(op.axes)),\n helper.make_attribute('keepdims', op.keepdims),\n ])\n return node","def _add_all_odes_to_interface(self):\n comp = self.get_interface_component()\n for var in self.model.find_state_vars():\n if var.component is not comp:\n self.add_input(var, var.get_units())","def build_graph(self):\n n_classes = self.n_classes\n\n (self.feed('data')\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\n .conv(3, 3, 256, 1, 1, name='conv3_1')\n .conv(3, 3, 256, 1, 1, name='conv3_2')\n .conv(3, 3, 256, 1, 1, name='conv3_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\n .conv(3, 3, 512, 1, 1, name='conv4_1')\n .conv(3, 3, 512, 1, 1, name='conv4_2')\n .conv(3, 3, 512, 1, 1, name='conv4_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\n .conv(3, 3, 512, 1, 1, name='conv5_1')\n .conv(3, 3, 512, 1, 1, name='conv5_2')\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\n\n self.compute_rDeRF() # dummy\n\n # Classification\n (self.feed('conv5_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\n .fc(4096, name='fc6')\n .dropout(0.5, name='drop6')\n .fc(4096, name='fc7')\n .dropout(0.5, name='drop7')\n # .make_time(name='drop7_reduced')\n .fc(n_classes, relu=False, name='cls_score')\n .softmax(name='cls_prob'))\n pass","def __init__(self, temperature: float, crops_for_assign: tuple, nmb_crops: tuple, sinkhorn_iterations: int, epsilon: float, gpus: int, num_nodes: int):\n super().__init__()\n self.temperature = temperature\n self.crops_for_assign = crops_for_assign\n self.softmax = nn.Softmax(dim=1)\n self.sinkhorn_iterations = sinkhorn_iterations\n self.epsilon = epsilon\n self.nmb_crops = nmb_crops\n self.gpus = gpus\n self.num_nodes = num_nodes\n if self.gpus * self.num_nodes > 1:\n self.assignment_fn = self.distributed_sinkhorn\n else:\n self.assignment_fn = self.sinkhorn","def Q_credit_sumo(s_n, g_n, a_m, s_m, s_others, g_others,\n n_h1_1=256, n_h1_2=128, n_h2=256,\n activation=tf.nn.relu, stage=2, bias=True):\n concated = tf.concat( [s_n, g_n, a_m], axis=1 )\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=activation, use_bias=bias, name='Q_branch1')\n W_branch1_h2 = get_variable(\"W_branch1_h2\", [n_h1_1, n_h2])\n\n list_mult = []\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\n\n if stage > 1:\n with tf.variable_scope(\"stage-2\"):\n # concated2 = tf.concat( [s_m, s_others, g_others], axis=1 )\n concated2 = tf.concat( [s_m, s_others], axis=1 ) # original\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=activation, use_bias=bias, name='Q_branch2')\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\n list_mult.append(tf.matmul(others, W_branch2_h2))\n\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\n \n return out","def Compute_EdgeBoxesAndCNN_features(demonet='res152',nms_thresh = 0.7,database='IconArt_v1',\n augmentation=False,L2 =False,\n saved='all',verbose=True,filesave='tfrecords',k_regions=300,\n testMode=False,plotProposedBoxes=False):\n\n path_data = '/media/gonthier/HDD/output_exp/ClassifPaintings/'\n path_imgs = path_data + 'EdgeBoxesIllust/'+database +'/'\n \n if plotProposedBoxes:\n print(\"We will only plot the regions of the EdgeBoxes with k_regions = \",k_regions,path_imgs)\n pathlib.Path(path_imgs).mkdir(parents=True, exist_ok=True) \n \n item_name,path_to_img,default_path_imdb,classes,ext,num_classes,str_val,df_label,\\\n path_data,Not_on_NicolasPC = get_database(database)\n \n if augmentation:\n raise NotImplementedError\n N = 50\n else: \n N=1\n if L2:\n raise NotImplementedError\n extL2 = '_L2'\n else:\n extL2 = ''\n if saved=='all':\n savedstr = '_all'\n elif saved=='fc7':\n savedstr = ''\n elif saved=='pool5':\n savedstr = '_pool5'\n \n tf.reset_default_graph() # Needed to use different nets one after the other\n if verbose: print('=== EdgeBoxes net',demonet,'database',database,' ===')\n \n if demonet=='res152':\n weights_path = '/media/gonthier/HDD/models/resnet152_weights_tf.h5'\n model = resnet_152_keras.resnet152_model_2048output(weights_path)\n num_features = 2048\n else:\n raise(NotImplementedError)\n tfconfig = tf.ConfigProto(allow_soft_placement=True)\n tfconfig.gpu_options.allow_growth=True\n # init session\n# sess = tf.Session(config=tfconfig)\n \n features_resnet_dict= {}\n \n sets = ['train','val','trainval','test']\n \n if filesave == 'pkl':\n name_pkl_all_features = path_data+'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+'.pkl'\n pkl = open(name_pkl_all_features, 'wb')\n elif filesave =='tfrecords':\n if k_regions==300:\n k_per_bag_str = ''\n else:\n k_per_bag_str = '_k'+str(k_regions)\n dict_writers = {}\n for set_str in sets:\n name_pkl_all_features = path_data\n if testMode: name_pkl_all_features+= 'TestMode_'\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\n dict_writers[set_str] = tf.python_io.TFRecordWriter(name_pkl_all_features)\n \n model_edgeboxes = 'model/model.yml'\n print('Need of pip install opencv-contrib-python')\n edge_detection = cv2.ximgproc.createStructuredEdgeDetection(model_edgeboxes)\n \n number_of_regions = []\n Itera = 1000\n if testMode:\n Itera = 1\n for i,name_img in enumerate(df_label[item_name]):\n if testMode and i>1:\n break\n if filesave=='pkl':\n if not(k_regions==300):\n raise(NotImplementedError)\n if i%Itera==0:\n if verbose : print(i,name_img)\n if not(i==0):\n pickle.dump(features_resnet_dict,pkl) # Save the data\n features_resnet_dict= {}\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\n 'WikiLabels1000training','CASPApaintings']:\n complet_name = path_to_img + name_img + '.jpg'\n elif database=='PeopleArt':\n complet_name = path_to_img + name_img\n name_sans_ext = os.path.splitext(name_img)[0]\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\n name_sans_ext = os.path.splitext(name_img)[0]\n complet_name = path_to_img +name_sans_ext + '.jpg'\n\n if plotProposedBoxes:\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\n number_of_regions += [len(list_im)]\n fc7 = model.predict(list_im)\n # Need a BGR and between 0 and 255 minus the mean per color \n \n roi_scores = np.ones((len(list_im,)))\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\n if saved=='fc7':\n features_resnet_dict[name_img] = fc7\n# elif saved=='pool5':\n# features_resnet_dict[name_img] = pool5\n elif saved=='all':\n features_resnet_dict[name_img] = rois,roi_scores,fc7\n \n elif filesave=='tfrecords':\n if i%Itera==0:\n if verbose : print(i,name_img)\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings','watercolor'\\\n ,'CASPApaintings','WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training']:\n complet_name = path_to_img + name_img + '.jpg'\n name_sans_ext = name_img\n elif database=='PeopleArt':\n complet_name = path_to_img + name_img\n name_sans_ext = os.path.splitext(name_img)[0]\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\n name_sans_ext = os.path.splitext(name_img)[0]\n complet_name = path_to_img +name_sans_ext + '.jpg'\n\n im = cv2.imread(complet_name)\n \n height = im.shape[0]\n width = im.shape[1]\n\n if plotProposedBoxes:\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\n # Boxes are x, y, w, h\n number_of_regions += [len(list_im)]\n fc7 = model.predict(list_im)\n roi_scores = np.ones((len(list_im,)))\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\n \n if testMode:\n print('Image :',height,width)\n print('Normally ROI (x1,x2,y1,y2) :')\n print(rois)\n \n if(len(fc7) >= k_regions):\n rois = rois[0:k_regions,:]\n roi_scores =roi_scores[0:k_regions,]\n fc7 = fc7[0:k_regions,:]\n else:\n number_repeat = k_regions // len(fc7) +1\n f_repeat = np.repeat(fc7,number_repeat,axis=0)\n roi_scores_repeat = np.repeat(roi_scores,number_repeat,axis=0)\n rois_repeat = np.repeat(rois,number_repeat,axis=0)\n rois = rois_repeat[0:k_regions,:]\n roi_scores =roi_scores_repeat[0:k_regions,]\n fc7 = f_repeat[0:k_regions,:]\n num_regions = fc7.shape[0]\n num_features = fc7.shape[1]\n dim1_rois = rois.shape[1]\n classes_vectors = np.zeros((num_classes,1),dtype=np.float32)\n \n if database=='Paintings':\n for j in range(num_classes):\n if(classes[j] in df_label['classe'][i]):\n classes_vectors[j] = 1\n if database in ['VOC2007','clipart','watercolor','comic','PeopleArt','CASPApaintings']:\n for j in range(num_classes):\n value = int((int(df_label[classes[j]][i])+1.)/2.)\n # En fait ce qui se passe la c'est que tu rescale a la sauvage \n # entre 0 et 1 un truc qui peut etre entre 0 et 1 mais aussi entre -1 et 1\n # C'est chelou\n classes_vectors[j] = value\n if database in ['WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training','IconArt_v1']:\n for j in range(num_classes):\n value = int(df_label[classes[j]][i])\n classes_vectors[j] = value\n \n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\n if saved=='fc7':\n print('It is possible that you need to replace _bytes_feature by _floats_feature in this function')\n print('!!!!!!!!!!!!!!!!!!!!!')\n raise(NotImplementedError)\n # TODO : modifier cela !\n features=tf.train.Features(feature={\n 'height': _int64_feature(height),\n 'width': _int64_feature(width),\n 'num_regions': _int64_feature(num_regions),\n 'num_features': _int64_feature(num_features),\n 'fc7': _bytes_feature(tf.compat.as_bytes(fc7.tostring())),\n 'label' : _bytes_feature(tf.compat.as_bytes(classes_vectors.tostring())),\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))})\n elif saved=='pool5':\n raise(NotImplementedError)\n elif saved=='all':\n feature={\n 'height': _int64_feature(height),\n 'width': _int64_feature(width),\n 'num_regions': _int64_feature(num_regions),\n 'num_features': _int64_feature(num_features),\n 'dim1_rois': _int64_feature(dim1_rois),\n 'rois': _floats_feature(rois),\n 'roi_scores': _floats_feature(roi_scores),\n 'fc7': _floats_feature(fc7),\n 'label' : _floats_feature(classes_vectors),\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))}\n features=tf.train.Features(feature=feature)\n example = tf.train.Example(features=features) \n# print(len(feature['rois']))\n if database=='VOC2007' or database=='PeopleArt':\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\n dict_writers['train'].write(example.SerializeToString())\n dict_writers['trainval'].write(example.SerializeToString())\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='val').any():\n dict_writers['val'].write(example.SerializeToString())\n dict_writers['trainval'].write(example.SerializeToString())\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\n dict_writers['test'].write(example.SerializeToString())\n if (database=='Wikidata_Paintings_miniset') or database=='Paintings':\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\n dict_writers['train'].write(example.SerializeToString())\n dict_writers['trainval'].write(example.SerializeToString())\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='validation').any():\n dict_writers['val'].write(example.SerializeToString())\n dict_writers['trainval'].write(example.SerializeToString())\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\n dict_writers['test'].write(example.SerializeToString())\n if database in ['IconArt_v1','watercolor','clipart','comic','WikiTenLabels',\\\n 'MiniTrain_WikiTenLabels','WikiLabels1000training','CASPApaintings']:\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\n dict_writers['train'].write(example.SerializeToString())\n dict_writers['trainval'].write(example.SerializeToString())\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\n dict_writers['test'].write(example.SerializeToString())\n \n if filesave=='pkl':\n pickle.dump(features_resnet_dict,pkl)\n pkl.close()\n elif filesave=='tfrecords':\n for set_str in sets:\n dict_writers[set_str].close()\n \n print('Mean number of regions per image :',np.mean(number_of_regions),'with k max = ',k_regions)\n \n tf.reset_default_graph()\n \n if testMode:\n sets = ['train','test','trainval','val']\n dim_rois = 4\n for set_str in sets:\n name_pkl_all_features = path_data\n if testMode: name_pkl_all_features+= 'TestMode_'\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\n print(name_pkl_all_features)\n if set_str=='train':\n train_dataset = tf.data.TFRecordDataset(name_pkl_all_features)\n sess = tf.Session()\n train_dataset = train_dataset.map(lambda r: parser_w_rois_all_class(r, \\\n num_classes=num_classes,with_rois_scores=True,num_features=num_features,\n num_rois=k_regions,dim_rois=dim_rois))\n mini_batch_size = 1\n dataset_batch = train_dataset.batch(mini_batch_size)\n dataset_batch.cache()\n iterator = dataset_batch.make_one_shot_iterator()\n next_element = iterator.get_next()\n print(next_element)\n nx = sess.run(next_element)\n print(nx)\n name_img = nx[-1][0].decode('utf8')\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\n 'WikiLabels1000training','CASPApaintings']:\n complet_name = path_to_img + name_img + '.jpg'\n name_sans_ext = name_img\n elif database=='PeopleArt':\n complet_name = path_to_img + name_img\n name_sans_ext = os.path.splitext(name_img)[0]\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\n name_sans_ext = os.path.splitext(name_img)[0]\n complet_name = path_to_img +name_sans_ext + '.jpg'\n \n im = cv2.imread(complet_name)\n \n blobs, im_scales = get_blobs(im)\n dd = nx[1]/ im_scales[0] \n score = nx[2]\n roi = np.hstack((dd[0],score[0].reshape((-1,1))))\n \n \n class_name = ['']\n vis_detections_list(im, class_name, [roi])\n \n os.remove(name_pkl_all_features)","def test_qc_quantize_op_cpu(self):\n graph = tf.Graph()\n config = tf.compat.v1.ConfigProto(log_device_placement=False)\n sess = tf.compat.v1.Session(graph=graph, config=config)\n bitwidth = 8\n use_symm_encoding = True\n\n with graph.as_default():\n # place holder for the input\n with tf.device(\"/device:CPU:0\"):\n inp = tf.compat.v1.placeholder(tf.float32, shape=[10], name='input')\n tensor_quantizer = libpymo.TensorQuantizer(libpymo.QuantizationMode.QUANTIZATION_TF_ENHANCED,\n libpymo.RoundingMode.ROUND_NEAREST)\n tensor_quantizer_val = libpymo.PtrToInt64(tensor_quantizer)\n tensor_quant_ref = tf.Variable(initial_value=tensor_quantizer_val, trainable=False, dtype=tf.int64)\n\n encoding_min = tf.Variable(initial_value=0.0, trainable=True, dtype=tf.double)\n encoding_max = tf.Variable(initial_value=0.0, trainable=True, dtype=tf.double)\n bit_width = tf.Variable(initial_value=bitwidth, trainable=False, dtype=tf.int8)\n use_symmetric_encoding = tf.Variable(initial_value=use_symm_encoding, trainable=False, dtype=tf.bool)\n is_int_data_type = tf.Variable(initial_value=True, trainable=False, dtype=tf.bool)\n\n mode_var = tf.Variable(initial_value=int(libpymo.TensorQuantizerOpMode.updateStats),\n trainable=False, dtype=tf.int32)\n\n sess.run([mode_var.initializer, tensor_quant_ref.initializer, encoding_min.initializer,\n encoding_max.initializer, bit_width.initializer, use_symmetric_encoding.initializer,\n is_int_data_type.initializer])\n\n pass_through_op_output = zero_out_module.qc_quantize(name='quant_op', in_tensor=inp,\n op_mode=mode_var,\n tensor_quantizer_reference=tensor_quant_ref,\n encoding_min=encoding_min,\n encoding_max=encoding_max,\n bit_width=bit_width,\n use_symmetric_encoding=use_symmetric_encoding,\n is_int_data_type=is_int_data_type)\n\n inp_tensor = sess.graph.get_tensor_by_name('input:0')\n inp_data = np.random.rand(10)\n\n # get the output\n print(\"inp_data\", inp_data)\n out_data = sess.run(pass_through_op_output, feed_dict={inp_tensor: inp_data})\n print(\"out_data\", out_data)\n\n # compare qc_quantize op's output with input\n assert np.allclose(out_data, inp_data)\n\n # compute encodings\n assert not tensor_quantizer.isEncodingValid\n encoding = tensor_quantizer.computeEncoding(bitwidth, use_symm_encoding)\n assert tensor_quantizer.isEncodingValid\n print('min=', encoding.min, ', max=', encoding.max)\n\n # get the output\n inp_data = np.random.rand(10) * 2\n print(inp_data)\n mode_var.load(int(libpymo.TensorQuantizerOpMode.quantizeDequantize), sess)\n out_data = sess.run(pass_through_op_output, feed_dict={inp_tensor: inp_data})\n print(out_data)\n\n # compare qc_quantize op's output with input\n assert not np.allclose(out_data, inp_data)\n sess.close()","def ResUNetPlusPlus(input_size: tuple, test_mode=False):\n assert len(input_size) == 3, \"[ERROR]: Expected tuple of length 3 got {0}\".format(len(input_size))\n\n image_width, image_height, n_channels = input_size\n\n inp = tf.keras.layers.Input(shape=(image_width, image_height, n_channels), dtype=\"float32\", name=\"input_layer\")\n\n # starting conv\n x = layers.Conv2DBN(64, 3, padding=\"same\", activation=\"relu\", name=\"conv_start\")(inp)\n\n # Residual block 1\n x = layers.ResidualBlock(64, 3, activation=\"relu\", name=\"rb_1\")(x)\n skip1 = x\n\n x = tf.keras.layers.Conv2D(128,\n kernel_size=(3, 3),\n strides=(2, 2),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.SqueezeExcitationBlock(ratio=1)(x)\n\n # Residual block 2\n x = layers.ResidualBlock(128, 3, activation=\"relu\", name=\"rb_2\")(x)\n skip2 = x\n\n x = tf.keras.layers.Conv2D(256,\n kernel_size=(3, 3),\n strides=(2, 2),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.SqueezeExcitationBlock(ratio=2)(x)\n\n # Residual block 3\n x = layers.ResidualBlock(256, 3, activation=\"relu\", name=\"rb_3\")(x)\n skip3 = x\n\n x = tf.keras.layers.Conv2D(512,\n kernel_size=(3, 3),\n strides=(2, 2),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.SqueezeExcitationBlock(ratio=4)(x)\n\n # Residual block 4\n x = layers.ResidualBlock(512, 3, activation=\"relu\", name=\"rb_4\")(x)\n skip4 = x\n\n x = tf.keras.layers.Conv2D(1024,\n kernel_size=(3, 3),\n strides=(2, 2),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.SqueezeExcitationBlock(ratio=8)(x)\n\n # Bottleneck ASPP\n x = layers.ASPP(256, [4, 8, 12], (256, 256), 16, activation=\"relu\", name=\"aspp_bottleneck\")(x)\n x = layers.Conv2DBN(1024, 1, activation=\"relu\")(x)\n\n # Up-sample L4\n x = layers.GlobalAttentionUpsample(name=\"GAU_4\")([skip4, x])\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip4])\n x = tf.keras.layers.Conv2D(512,\n kernel_size=(3, 3),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.ResidualBlock(512, 3, activation=\"relu\", activate_begin=True, name=\"u_rb_4\")(x)\n\n # Up-sample L3\n x = layers.GlobalAttentionUpsample(name=\"GAU_3\")([skip3, x])\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip3])\n x = tf.keras.layers.Conv2D(256,\n kernel_size=(3, 3),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.ResidualBlock(256, 3, activation=\"relu\", activate_begin=True, name=\"u_rb_3\")(x)\n\n # Up-sample L2\n x = layers.GlobalAttentionUpsample(name=\"GAU_2\")([skip2, x])\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip2])\n x = tf.keras.layers.Conv2D(128,\n kernel_size=(3, 3),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.ResidualBlock(128, 3, activation=\"relu\", activate_begin=True, name=\"u_rb_2\")(x)\n\n # Up-sample L1\n x = layers.GlobalAttentionUpsample(name=\"GAU_1\")([skip1, x])\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip1])\n x = tf.keras.layers.Conv2D(64,\n kernel_size=(3, 3),\n padding=\"same\",\n activation=\"linear\")(x)\n x = layers.ResidualBlock(64, 3, activation=\"relu\", activate_begin=True, name=\"u_rb_1\")(x)\n x = layers.Conv2DBN(1, 1, activation=\"sigmoid\")(x)\n\n return tf.keras.Model(inputs=[inp], outputs=[x])"],"string":"[\n \"def convert_reduce(g, op, block):\\n\\n op_map = {\\n \\\"reduce_all\\\": \\\"all\\\",\\n \\\"reduce_any\\\": \\\"any\\\",\\n \\\"reduce_max\\\": \\\"max\\\",\\n \\\"reduce_min\\\": \\\"min\\\",\\n \\\"reduce_prod\\\": \\\"prod\\\",\\n \\\"reduce_sum\\\": \\\"sum\\\",\\n \\\"reduce_mean\\\": \\\"mean\\\",\\n }\\n op_name = op_map[op.type]\\n input_x = g.get_node(op.input(\\\"X\\\")[0])\\n axis = op.attr(\\\"dim\\\")\\n if op.attr(\\\"reduce_all\\\"):\\n axis = None\\n keepdims = op.attr(\\\"keep_dim\\\")\\n out = get_relay_op(op_name)(input_x, axis=axis, keepdims=keepdims)\\n if not axis and not keepdims:\\n # use `expand_dims` to solve the following situation\\n # for TVM, the shape of `out` will be (, )\\n # for Paddle, the shape of `out` will be [1]\\n out = _op.expand_dims(out, axis=0)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def _collect_ipt_and_opt_nodes(self):\\n for name, node in self._nodes_collection.items():\\n if node.in_degree == 0:\\n # NOTICE: what's usage of `scope`?\\n self._input_nodes.append(name)\\n\\n if node.out_degree == 0:\\n self._output_nodes.append(name)\",\n \"def reduce(self, app, nodes, result):\",\n \"def convert_roipooling(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n pooled_shape = convert_string_to_list(attrs.get('pooled_size'))\\n scale = float(attrs.get(\\\"spatial_scale\\\"))\\n\\n node = onnx.helper.make_node(\\n 'MaxRoiPool',\\n input_nodes,\\n [name],\\n pooled_shape=pooled_shape,\\n spatial_scale=scale,\\n name=name\\n )\\n return [node]\",\n \"def run(self, model):\\n activation_statistics = self._stats_collector.get_statistics_for_algorithm(self.name)\\n\\n act_nodes = mu.get_nodes_by_type(model, self._act_types)\\n for act_node in act_nodes:\\n if act_node.fullname not in activation_statistics:\\n logger.debug('Stats After {} not found!'.format(act_node.fullname))\\n continue\\n min_after_act = np.min(activation_statistics[act_node.fullname]['min_per_tensor'])\\n max_after_act = np.max(activation_statistics[act_node.fullname]['max_per_tensor'])\\n clamp_attrs = {'min': min_after_act, 'max': max_after_act}\\n clamp_name = act_node.name + '/min_max_Clamp'\\n clamp_node = ge.create_node(act_node.graph, clamp_name, 'AttributedClamp', clamp_attrs)\\n clamp_node['fullname'] = nu.reset_node_fullname(act_node.fullname, clamp_name)\\n\\n dest_ports = act_node.out_port(0).get_destinations()\\n act_node.out_port(0).disconnect()\\n clamp_node.in_port(0).connect(act_node.out_port(0))\\n\\n for dest_port in dest_ports:\\n dest_port.connect(clamp_node.out_port(0))\\n return model\",\n \"def common_optimization(m):\\n logger.info(\\\"Doing nodes fusion and replacement... \\\")\\n m = other.polish_model(m)\\n g = m.graph\\n other.transpose_B_in_Gemm(g)\\n fusing.fuse_BN_into_Gemm(g)\\n fusing.fuse_BN_with_Reshape_into_Gemm(g)\\n fusing.fuse_Gemm_into_Gemm(g)\\n fusing.fuse_consecutive_reducemean(g)\\n fusing.fuse_slice_nodes_into_conv(g)\\n fusing.fuse_relu_min_into_clip(g)\\n other.duplicate_shared_Flatten(g)\\n replacing.replace_average_pool_with_GAP(g)\\n\\n m = other.polish_model(m)\\n g = m.graph\\n\\n replacing.replace_Squeeze_with_Reshape(g)\\n replacing.replace_Unsqueeze_with_Reshape(g)\\n replacing.replace_Reshape_with_Flatten(g)\\n replacing.replace_ReduceMean_with_GlobalAveragePool(g)\\n replacing.replace_Sum_with_Adds(g)\\n replacing.replace_constant_input_concat_with_pad(g)\\n other.topological_sort(g)\\n return m\",\n \"def convert_max(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n mx_axis = attrs.get(\\\"axis\\\", None)\\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\\n\\n keepdims = get_boolean_attribute_value(attrs, \\\"keepdims\\\")\\n\\n if axes is not None:\\n node = onnx.helper.make_node(\\n 'ReduceMax',\\n inputs=input_nodes,\\n outputs=[name],\\n axes=axes,\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\\n else:\\n node = onnx.helper.make_node(\\n 'ReduceMax',\\n inputs=input_nodes,\\n outputs=[name],\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\",\n \"def generate_output_graph_ranges(self, max_name_value):\\n for node_name, value in max_name_value.items():\\n if node_name not in self.graph_info:\\n continue\\n\\n min_node = node_def_pb2.NodeDef()\\n min_node.op = \\\"HostConst\\\" if self.device == \\\"gpu\\\" else \\\"Const\\\"\\n min_node_postfix = \\\"/frozen_min\\\"\\n min_node.name = node_name + min_node_postfix\\n min_node.attr[\\\"dtype\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\\n min_node.attr[\\\"value\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(\\n tensor=tensor_util.make_tensor_proto(float(value[0]),\\n dtypes.float32, [])))\\n\\n max_node = node_def_pb2.NodeDef()\\n max_node.op = \\\"HostConst\\\" if self.device == \\\"gpu\\\" else \\\"Const\\\"\\n max_node_postfix = \\\"/frozen_max\\\"\\n max_node.name = node_name + max_node_postfix\\n max_node.attr[\\\"dtype\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\\n max_node.attr[\\\"value\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(\\n tensor=tensor_util.make_tensor_proto(float(value[1]),\\n dtypes.float32, [])))\\n output_node_name = self.graph_info[node_name].outputs[0]\\n self.cur_graph.replace_const_node(min_node,\\n [Helper.node_name_from_input(output_node_name)],\\n node_name + ':0')\\n self.cur_graph.replace_const_node(max_node,\\n [Helper.node_name_from_input(output_node_name)],\\n node_name + ':1')\\n self.cur_graph.remove_node(node_name)\\n\\n self.requant_min_max[node_name] = [\\n tensor_util.MakeNdarray(min_node.attr[\\\"value\\\"].tensor),\\n tensor_util.MakeNdarray(max_node.attr[\\\"value\\\"].tensor)\\n ]\\n\\n self.scale_info[self.postfix] = self.requant_min_max\\n # {\\n # \\\"__requant_min_max\\\":\\n # {requant_range_name:[min,max],}\\n # \\\"__min\\\":\\n # {node_name_min:[min]}\\n # \\\"__max\\\":\\n # {node_name_max:[max]}\\n # }\\n return GraphAnalyzer().dump_graph(), self.scale_info\",\n \"def _reduce(self, x, y):\\n coef = self._update_parallel_coef_constraints(x)\\n self.coef_ = coef.T\",\n \"def enumerate_compatible_opset(model, opset_min=-1, opset_max=-1, # pylint: disable=R0914\\n check_runtime=True, debug=False,\\n runtime='python', dump_folder=None,\\n store_models=False, benchmark=False,\\n assume_finite=True, node_time=False,\\n fLOG=print, filter_exp=None,\\n verbose=0, time_kwargs=None,\\n extended_list=False, dump_all=False,\\n n_features=None, skip_long_test=True,\\n filter_scenario=None, time_kwargs_fact=None,\\n time_limit=4, n_jobs=None):\\n if opset_min == -1:\\n opset_min = __max_supported_opset__ # pragma: no cover\\n if opset_max == -1:\\n opset_max = __max_supported_opset__ # pragma: no cover\\n if verbose > 0 and fLOG is not None:\\n fLOG(\\n f\\\"[enumerate_compatible_opset] opset in [{opset_min}, {opset_max}].\\\")\\n if verbose > 1 and fLOG:\\n fLOG(\\n f\\\"[enumerate_compatible_opset] validate class '{model.__name__}'.\\\")\\n if verbose > 2:\\n fLOG(model)\\n\\n if time_kwargs is None:\\n time_kwargs = default_time_kwargs()\\n problems, extras = _retrieve_problems_extra(\\n model, verbose, fLOG, extended_list)\\n if isinstance(problems, dict):\\n yield problems # pragma: no cover\\n problems = [] # pragma: no cover\\n\\n if opset_max is None:\\n opset_max = __max_supported_opset__ # pragma: no cover\\n opsets = list(range(opset_min, opset_max + 1)) # pragma: no cover\\n opsets.append(None) # pragma: no cover\\n else:\\n opsets = list(range(opset_min, opset_max + 1))\\n\\n if extras is None:\\n problems = []\\n yield {'name': model.__name__, 'skl_version': sklearn_version,\\n '_0problem_exc': 'SKIPPED'}\\n\\n if not isinstance(n_features, list):\\n n_features = [n_features]\\n\\n for prob in problems:\\n if filter_exp is not None and not filter_exp(model, prob):\\n continue\\n for n_feature in n_features:\\n if verbose >= 2 and fLOG is not None:\\n fLOG(\\\"[enumerate_compatible_opset] problem={} n_feature={}\\\".format(\\n prob, n_feature))\\n\\n (X_train, X_test, y_train,\\n y_test, Xort_test,\\n init_types, conv_options, method_name,\\n output_index, dofit, predict_kwargs) = _get_problem_data(prob, n_feature)\\n\\n for scenario_extra in extras:\\n subset_problems = None\\n optimisations = None\\n new_conv_options = None\\n if len(scenario_extra) > 2:\\n options = scenario_extra[2]\\n if isinstance(options, dict):\\n subset_problems = options.get('subset_problems', None)\\n optimisations = options.get('optim', None)\\n new_conv_options = options.get('conv_options', None)\\n else:\\n subset_problems = options\\n\\n if subset_problems and isinstance(subset_problems, (list, set)):\\n if prob not in subset_problems:\\n # Skips unrelated problem for a specific configuration.\\n continue\\n elif subset_problems is not None:\\n raise RuntimeError( # pragma: no cover\\n \\\"subset_problems must be a set or a list not {}.\\\".format(\\n subset_problems))\\n\\n try:\\n scenario, extra = scenario_extra[:2]\\n except TypeError as e: # pragma: no cover\\n raise TypeError(\\n \\\"Unable to interpret 'scenario_extra'\\\\n{}\\\".format(\\n scenario_extra)) from e\\n if optimisations is None:\\n optimisations = [None]\\n if new_conv_options is None:\\n new_conv_options = [{}]\\n\\n if (filter_scenario is not None and\\n not filter_scenario(model, prob, scenario,\\n extra, new_conv_options)):\\n continue\\n\\n if verbose >= 2 and fLOG is not None:\\n fLOG(\\\"[enumerate_compatible_opset] ##############################\\\")\\n fLOG(\\\"[enumerate_compatible_opset] scenario={} optim={} extra={} dofit={} (problem={})\\\".format(\\n scenario, optimisations, extra, dofit, prob))\\n\\n # training\\n obs = {'scenario': scenario, 'name': model.__name__,\\n 'skl_version': sklearn_version, 'problem': prob,\\n 'method_name': method_name, 'output_index': output_index,\\n 'fit': dofit, 'conv_options': conv_options,\\n 'idtype': Xort_test.dtype, 'predict_kwargs': predict_kwargs,\\n 'init_types': init_types, 'inst': extra if extra else None,\\n 'n_features': X_train.shape[1] if len(X_train.shape) == 2 else 1}\\n inst = None\\n extra = set_n_jobs(model, extra, n_jobs=n_jobs)\\n try:\\n inst = model(**extra)\\n except TypeError as e: # pragma: no cover\\n if debug: # pragma: no cover\\n raise\\n if \\\"__init__() missing\\\" not in str(e):\\n raise RuntimeError(\\n \\\"Unable to instantiate model '{}'.\\\\nextra=\\\\n{}\\\".format(\\n model.__name__, pprint.pformat(extra))) from e\\n yield obs.copy()\\n continue\\n\\n if not _dofit_model(dofit, obs, inst, X_train, y_train, X_test, y_test,\\n Xort_test, init_types, store_models,\\n debug, verbose, fLOG):\\n yield obs.copy()\\n continue\\n\\n # statistics about the trained model\\n skl_infos = analyze_model(inst)\\n for k, v in skl_infos.items():\\n obs['fit_' + k] = v\\n\\n # runtime\\n ypred = _run_skl_prediction(\\n obs, check_runtime, assume_finite, inst,\\n method_name, predict_kwargs, X_test,\\n benchmark, debug, verbose, time_kwargs,\\n skip_long_test, time_kwargs_fact, fLOG)\\n if isinstance(ypred, Exception):\\n yield obs.copy()\\n continue\\n\\n for run_obs in _call_conv_runtime_opset(\\n obs=obs.copy(), opsets=opsets, debug=debug,\\n new_conv_options=new_conv_options,\\n model=model, prob=prob, scenario=scenario,\\n extra=extra, extras=extras, conv_options=conv_options,\\n init_types=init_types, inst=inst,\\n optimisations=optimisations, verbose=verbose,\\n benchmark=benchmark, runtime=runtime,\\n filter_scenario=filter_scenario,\\n X_test=X_test, y_test=y_test, ypred=ypred,\\n Xort_test=Xort_test, method_name=method_name,\\n check_runtime=check_runtime,\\n output_index=output_index,\\n kwargs=dict(\\n dump_all=dump_all,\\n dump_folder=dump_folder,\\n node_time=node_time,\\n skip_long_test=skip_long_test,\\n store_models=store_models,\\n time_kwargs=_multiply_time_kwargs(\\n time_kwargs, time_kwargs_fact, inst)\\n ),\\n time_limit=time_limit,\\n fLOG=fLOG):\\n yield run_obs\",\n \"def _legal_operations(self, model, tabu_list=[], max_indegree=None):\\n\\n local_score = self.scoring_method.local_score\\n nodes = model.event_nodes\\n potential_new_edges = (set(permutations(nodes, 2)) -\\n set(model.edges()) -\\n set([(Y, X) for (X, Y) in model.edges()]) -\\n set([X for X, Y in model.relation_map.items() if len(Y) == 0]))\\n\\n for (X, Y) in potential_new_edges: # (1) add single edge\\n if nx.is_directed_acyclic_graph(nx.DiGraph(list(model.edges()) + [(X, Y)])):\\n if self.valid_temporal_relations([(X, Y)], model):\\n operation = ('+', (X, Y))\\n if operation not in tabu_list:\\n old_parents = list(model.get_parents(Y))\\n new_parents = old_parents + [X]\\n if max_indegree is None or len(new_parents) <= max_indegree:\\n temporal_node_parents = [X, Y]\\n temporal_node = ITBN.temporal_node_marker + X + \\\"_\\\" + Y\\n score_delta = (local_score(Y, new_parents) -\\n local_score(Y, old_parents) +\\n local_score(temporal_node, temporal_node_parents))\\n yield(operation, score_delta)\\n\\n for (X, Y) in model.event_edges(): # (2) remove single edge\\n operation = ('-', (X, Y))\\n if operation not in tabu_list:\\n old_parents = list(model.get_parents(Y))\\n new_parents = old_parents[:]\\n new_parents.remove(X)\\n temporal_node_parents = [X, Y]\\n temporal_node = ITBN.temporal_node_marker + X + \\\"_\\\" + Y\\n score_delta = (local_score(Y, new_parents) -\\n local_score(Y, old_parents) -\\n local_score(temporal_node, temporal_node_parents))\\n yield(operation, score_delta)\\n\\n for (X, Y) in model.event_edges(): # (3) flip single edge\\n if len(model.relation_map[(Y, X)]) > 0:\\n new_edges = list(model.edges()) + [(Y, X)]\\n new_edges.remove((X, Y))\\n if nx.is_directed_acyclic_graph(nx.DiGraph(new_edges)):\\n if self.valid_temporal_relations([(X, Y)], model):\\n operation = ('flip', (X, Y))\\n if operation not in tabu_list and ('flip', (Y, X)) not in tabu_list:\\n old_X_parents = list(model.get_parents(X))\\n old_Y_parents = list(model.get_parents(Y))\\n new_X_parents = old_X_parents + [Y]\\n new_Y_parents = old_Y_parents[:]\\n new_Y_parents.remove(X)\\n if max_indegree is None or len(new_X_parents) <= max_indegree:\\n temporal_node_parents = [Y, X]\\n temporal_node = ITBN.temporal_node_marker + Y + \\\"_\\\" + X\\n old_temp_node_parents = [X, Y]\\n old_temp_node = ITBN.temporal_node_marker + X + \\\"_\\\" + Y\\n score_delta = (local_score(X, new_X_parents) +\\n local_score(Y, new_Y_parents) -\\n local_score(X, old_X_parents) -\\n local_score(Y, old_Y_parents) +\\n local_score(temporal_node, temporal_node_parents) -\\n local_score(old_temp_node, old_temp_node_parents))\\n yield(operation, score_delta)\",\n \"def modify_cpu(self, ask_questions=True):\\n\\n # Get the CPU layout\\n CpuUtils.get_cpu_layout_from_all_nodes(self._nodes)\\n\\n for i in self._nodes.items():\\n node = i[1]\\n total_cpus = 0\\n total_cpus_per_slice = 0\\n cpus_per_node = {}\\n numa_nodes = []\\n cores = []\\n cpu_layout = self.get_cpu_layout(node)\\n\\n # Assume the number of cpus per slice is always the same as the\\n # first slice\\n first_node = \\\"0\\\"\\n for cpu in cpu_layout:\\n if cpu[\\\"node\\\"] != first_node:\\n break\\n total_cpus_per_slice += 1\\n\\n # Get the total number of cpus, cores, and numa nodes from the\\n # cpu layout\\n for cpul in cpu_layout:\\n numa_node = cpul[\\\"node\\\"]\\n core = cpul[\\\"core\\\"]\\n cpu = cpul[\\\"cpu\\\"]\\n total_cpus += 1\\n\\n if numa_node not in cpus_per_node:\\n cpus_per_node[numa_node] = []\\n cpuperslice = int(cpu) % total_cpus_per_slice\\n if cpuperslice == 0:\\n cpus_per_node[numa_node].append(\\n (int(cpu), int(cpu) + total_cpus_per_slice - 1)\\n )\\n if numa_node not in numa_nodes:\\n numa_nodes.append(numa_node)\\n if core not in cores:\\n cores.append(core)\\n node[\\\"cpu\\\"][\\\"cpus_per_node\\\"] = cpus_per_node\\n\\n # Ask the user some questions\\n if ask_questions and total_cpus >= 4:\\n self._modify_cpu_questions(node, total_cpus, numa_nodes)\\n\\n # Populate the interfaces with the numa node\\n if \\\"interfaces\\\" in node:\\n ikeys = node[\\\"interfaces\\\"].keys()\\n VPPUtil.get_interfaces_numa_node(node, *tuple(ikeys))\\n\\n # We don't want to write the cpuinfo\\n node[\\\"cpuinfo\\\"] = \\\"\\\"\\n\\n # Write the configs\\n self._update_auto_config()\\n self.updateconfig()\",\n \"def _create_reduceOp(cls, onnx_node, inputs, opset_version):\\n axes = onnx_node.getattr(\\\"axes\\\", None)\\n keepdims = onnx_node.getattr(\\\"keepdims\\\", 1)\\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\\n opset_version)\\n return _, forward(axes, keepdims)\",\n \"def find_quantizer_nodes_to_cut(\\n graph: NNCFGraph,\\n quantizer_node: NNCFNode,\\n quantizer_metatypes: List[OperatorMetatype],\\n const_metatypes: List[OperatorMetatype],\\n quantizable_metatypes: List[OperatorMetatype],\\n quantize_agnostic_metatypes: List[OperatorMetatype],\\n) -> Tuple[List[NNCFNode], List[NNCFNode]]:\\n\\n def _parse_node_relatives(node: NNCFNode, is_parents: bool):\\n if node.metatype in quantizable_metatypes:\\n ops_to_return_in_orig_prec.add(node)\\n\\n relatives = graph.get_previous_nodes(node) if is_parents else graph.get_next_nodes(node)\\n for relative in relatives:\\n if relative.metatype in quantizer_metatypes:\\n if is_parents:\\n if relative in seen_children:\\n continue\\n if relative not in to_cut:\\n to_cut.append(relative)\\n to_see_children.append(relative)\\n else:\\n seen_children.append(relative)\\n elif relative.metatype not in const_metatypes:\\n if relative not in seen_parents:\\n to_see_parents.append(relative)\\n if relative not in seen_children and relative.metatype in quantize_agnostic_metatypes:\\n to_see_children.append(relative)\\n\\n seen_list = seen_parents if is_parents else seen_children\\n seen_list.append(node)\\n\\n seen_children, seen_parents = [], []\\n to_see_children, to_see_parents = [quantizer_node], []\\n to_cut = [quantizer_node]\\n ops_to_return_in_orig_prec = set()\\n\\n while to_see_parents or to_see_children:\\n if to_see_children:\\n _parse_node_relatives(to_see_children.pop(), is_parents=False)\\n if to_see_parents:\\n _parse_node_relatives(to_see_parents.pop(), is_parents=True)\\n\\n return to_cut, list(ops_to_return_in_orig_prec)\",\n \"def optimize(cls, onnx_model):\\n\\n input2node = cls.map_input_and_node(onnx_model)\\n output2node = cls.map_output_and_node(onnx_model)\\n\\n standalone_nodes = cls.find_standalone_nodes(onnx_model, input2node,\\n output2node)\\n for node in standalone_nodes:\\n cls.remove_node_from_onnx(node, onnx_model)\\n print_log(f'Remove node {node.name}')\\n\\n redundant_inits = cls.find_redundant_initializers(\\n onnx_model, input2node)\\n for init in redundant_inits:\\n cls.remove_initializer_from_onnx(init, onnx_model)\\n print_log(f'Remove initializer {init.name}')\\n\\n sorted_onnx_model = cls.topo_sort(onnx_model)\\n\\n return sorted_onnx_model\",\n \"def apply(self, model, layer_quantize_map, quantize_registry, mode):\\n\\n transforms = [\\n vitis_8bit_quantize_transforms.InputLayerQuantize(\\n quantize_registry.get_input_quantizer(), mode),\\n vitis_8bit_quantize_transforms.ConvActivationQuantize(),\\n vitis_8bit_quantize_transforms.AddActivationQuantize(),\\n ]\\n return model_transformer.ModelTransformer(model, transforms,\\n set(layer_quantize_map.keys()),\\n layer_quantize_map).transform()\",\n \"def convert_prod(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n mx_axis = attrs.get(\\\"axis\\\", None)\\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\\n\\n keepdims = get_boolean_attribute_value(attrs, \\\"keepdims\\\")\\n\\n if axes is not None:\\n node = onnx.helper.make_node(\\n 'ReduceProd',\\n inputs=input_nodes,\\n outputs=[name],\\n axes=axes,\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\\n else:\\n node = onnx.helper.make_node(\\n 'ReduceProd',\\n inputs=input_nodes,\\n outputs=[name],\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\",\n \"def __call__(self, graph: Data, n_min: int, nodes_to_keep: List[int] = None, exhaustive: bool = False):\\n nodes_to_keep = nodes_to_keep if nodes_to_keep is not None else []\\n mcts = self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)\\n\\n for iteration in range(self.m):\\n mcts.search_one_iteration()\\n\\n explanation = mcts.best_leaf_node()\\n\\n return explanation.node_set, mcts\",\n \"def get_GNS_cut_reduced(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_2):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n #print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n #print \\\"GNS cut edges:\\\"\\n cut_set_edges = []\\n for u,v in edges:\\n if e[u,v].x != 0:\\n #print (u,v), str(G[u][v]['capacity'])\\n cut_set_edges.append((u,v, G[u][v]['capacity']))\\n return (m.objVal, cut_set_edges)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n return None, None\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def model_with_postprocessing_nodes():\\n\\n inputs = tf.keras.Input(shape=(10, 10, 3,))\\n x = tf.keras.layers.Conv2D(16, (3, 3))(inputs)\\n _ = tf.keras.layers.MaxPool2D()(x)\\n x = tf.keras.layers.Conv2D(8, (2, 2))(x)\\n x = tf.keras.layers.Flatten()(x)\\n x = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\\\"model_with_postprocessing_nodes\\\")(x)\\n\\n labels_placeholder = tf.compat.v1.placeholder_with_default(tf.constant(1, shape=(1, 10)),\\n shape=[None, 10],\\n name='labels')\\n\\n confidences = tf.nn.softmax(x, axis=1, name='confidences')\\n categorical_preds = tf.argmax(confidences, axis=1, name='categorical_preds')\\n categorical_labels = tf.argmax(labels_placeholder, axis=1, name='categorical_labels')\\n correct_predictions = tf.equal(categorical_labels, categorical_preds)\\n _ = tf.reduce_mean(tf.cast(correct_predictions, tf.float32), name='top1-acc')\\n _ = tf.reduce_mean(tf.cast(tf.nn.in_top_k(predictions=confidences,\\n targets=tf.cast(categorical_labels, tf.int32),\\n k=5), tf.float32), name='top5-acc')\",\n \"def generate_output_graph(self, max_name_value):\\n for node_name, value in max_name_value.items():\\n node_name = node_name.replace(\\\":\\\", \\\"__port__\\\").replace(\\\"^\\\", \\\"__hat__\\\")\\n if node_name not in self.graph_info:\\n continue\\n new_node = node_def_pb2.NodeDef()\\n new_node.op = \\\"Const\\\"\\n new_node_postfix = \\\"/frozen_{}_only\\\".format(''.join(\\n [x for x in self.postfix if x.isalpha()]))\\n new_node.name = node_name + new_node_postfix\\n new_node.attr[\\\"dtype\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))\\n new_node.attr[\\\"value\\\"].CopyFrom(\\n attr_value_pb2.AttrValue(\\n tensor=tensor_util.make_tensor_proto(float(value),\\n dtypes.float32, [])))\\n output_node_name = self.graph_info[node_name].outputs[0]\\n self.cur_graph.replace_const_node(new_node,\\n [Helper.node_name_from_input(output_node_name)],\\n node_name)\\n self.cur_graph.remove_node(node_name)\\n\\n self.quantizeV2_min_max[node_name] = tensor_util.MakeNdarray(\\n new_node.attr[\\\"value\\\"].tensor\\n )\\n self.scale_info[self.postfix[:-1]] = self.quantizeV2_min_max\\n\\n return GraphAnalyzer().dump_graph(), self.scale_info\",\n \"def convert_sum(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n mx_axis = attrs.get(\\\"axis\\\", None)\\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\\n\\n keepdims = get_boolean_attribute_value(attrs, \\\"keepdims\\\")\\n\\n if axes:\\n node = onnx.helper.make_node(\\n 'ReduceSum',\\n inputs=input_nodes,\\n outputs=[name],\\n axes=axes,\\n keepdims=keepdims,\\n name=name\\n )\\n else:\\n node = onnx.helper.make_node(\\n 'ReduceSum',\\n inputs=input_nodes,\\n outputs=[name],\\n keepdims=keepdims,\\n name=name\\n )\\n return [node]\",\n \"def convert_min(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n mx_axis = attrs.get(\\\"axis\\\", None)\\n axes = convert_string_to_list(str(mx_axis)) if mx_axis is not None else None\\n\\n keepdims = get_boolean_attribute_value(attrs, \\\"keepdims\\\")\\n\\n if axes is not None:\\n node = onnx.helper.make_node(\\n 'ReduceMin',\\n inputs=input_nodes,\\n outputs=[name],\\n axes=axes,\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\\n else:\\n node = onnx.helper.make_node(\\n 'ReduceMin',\\n inputs=input_nodes,\\n outputs=[name],\\n keepdims=keepdims,\\n name=name\\n )\\n\\n return [node]\",\n \"def quantize(model: nn.Module,\\n precision: str = 'int8',\\n accelerator: str = None,\\n use_ipex: bool = False,\\n calib_dataloader: DataLoader = None,\\n metric: Metric = None,\\n accuracy_criterion: dict = None,\\n approach: str = 'static',\\n method: str = None,\\n conf: str = None,\\n tuning_strategy: str = None,\\n timeout: int = None,\\n max_trials: int = None,\\n input_sample=None,\\n thread_num: int = None,\\n onnxruntime_session_options=None,\\n logging: bool = True,\\n **export_kwargs):\\n return InferenceOptimizer.quantize(model=model,\\n precision=precision,\\n accelerator=accelerator,\\n use_ipex=use_ipex,\\n calib_dataloader=calib_dataloader,\\n metric=metric,\\n accuracy_criterion=accuracy_criterion,\\n approach=approach,\\n method=method,\\n conf=conf,\\n tuning_strategy=tuning_strategy,\\n timeout=timeout,\\n max_trials=max_trials,\\n input_sample=input_sample,\\n thread_num=thread_num,\\n onnxruntime_session_options=onnxruntime_session_options,\\n logging=logging,\\n **export_kwargs)\",\n \"def all_views_max_pool(input_layer, network_type, stride=(2, 2)):\\r\\n if network_type == \\\"CC\\\":\\r\\n\\r\\n\\r\\n input_l_cc, input_r_cc = input_layer\\r\\n\\r\\n output_l_cc = tf.nn.max_pool(input_l_cc, ksize=[1, stride[0], stride[1], 1], strides=[1, stride[0], stride[1], 1],\\r\\n padding='SAME')\\r\\n output_r_cc = tf.nn.max_pool(input_r_cc, ksize=[1, stride[0], stride[1], 1], strides=[1, stride[0], stride[1], 1],\\r\\n padding='SAME')\\r\\n\\r\\n output = (output_l_cc, output_r_cc)\\r\\n\\r\\n return output\\r\\n else:\\r\\n input_l_mlo, input_r_mlo = input_layer\\r\\n\\r\\n output_l_mlo = tf.nn.max_pool(input_l_mlo, ksize=[1, stride[0], stride[1], 1],\\r\\n strides=[1, stride[0], stride[1], 1],\\r\\n padding='SAME')\\r\\n output_r_mlo = tf.nn.max_pool(input_r_mlo, ksize=[1, stride[0], stride[1], 1],\\r\\n strides=[1, stride[0], stride[1], 1],\\r\\n padding='SAME')\\r\\n\\r\\n output = (output_l_mlo, output_r_mlo)\\r\\n\\r\\n return output\",\n \"def reduce_run():\",\n \"def compute(self, node, input_vals):\\r\\n raise NotImplementedError\",\n \"def maximize(self):\\n raise NotImplementedError\",\n \"def quantize_whole_model(net, bits=8):\\n cluster_centers = []\\n assert isinstance(net, nn.Module)\\n layer_ind = 0\\n for n, m in net.named_modules():\\n if isinstance(m, PrunedConv):\\n \\\"\\\"\\\"\\n Apply quantization for the PrunedConv layer.\\n --------------Your Code---------------------\\n \\\"\\\"\\\"\\n\\n # Cluster the Weights\\n num_centroid = pow(2, bits)\\n\\n all_weight = m.conv.weight.data.cpu().detach().numpy()\\n weight_shape = all_weight.shape\\n \\n all_weight = all_weight.reshape(-1,1)\\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\\n\\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\\n\\n # Generate Code Book\\n cluster_center = kmeans.cluster_centers_.flatten()\\n\\n # Quantize\\n indexs = kmeans.predict(all_weight)\\n indexs = indexs.reshape(weight_shape)\\n \\n vmap = np.vectorize(lambda x:cluster_center[x])\\n m.conv.weight.data = torch.from_numpy(vmap(indexs)).to(device)\\n \\n _cluster_center = [ \\\"{0:b}\\\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\\n cluster_centers.append(_cluster_center)\\n\\n layer_ind += 1\\n print(\\\"Complete %d layers quantization...\\\" %layer_ind)\\n \\n elif isinstance(m, PruneLinear):\\n \\\"\\\"\\\"\\n Apply quantization for the PrunedLinear layer.\\n --------------Your Code---------------------\\n \\\"\\\"\\\"\\n \\n # Cluster the Weights\\n num_centroid = pow(2, bits)\\n \\n all_weight = m.linear.weight.data.cpu().detach().numpy()\\n weight_shape = all_weight.shape\\n\\n all_weight = all_weight.reshape(-1,1)\\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\\n \\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\\n \\n # Generate Code Book\\n cluster_center = kmeans.cluster_centers_.flatten()\\n\\n # Quantize\\n indexs = kmeans.predict(all_weight)\\n indexs = indexs.reshape(weight_shape)\\n\\n vmap = np.vectorize(lambda x:cluster_center[x])\\n m.linear.weight.data = torch.from_numpy(vmap(indexs)).to(device)\\n \\n _cluster_center = [ \\\"{0:b}\\\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\\n cluster_centers.append(_cluster_center)\\n \\n layer_ind += 1\\n print(\\\"Complete %d layers quantization...\\\" %layer_ind)\\n \\n return np.array(cluster_centers)\",\n \"def build_resnet152(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 8):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b7_feats = temp\\n \\n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 36):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b35_feats = temp\\n\\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def test_max_expansion(self):\\n\\n circuit, params = self.make_qnode_and_params(\\\"device\\\")\\n\\n assert circuit.max_expansion == 10\\n info = qml.specs(circuit, max_expansion=0)(params)\\n assert circuit.max_expansion == 10\\n\\n assert len(info) == 11\\n\\n gate_sizes = defaultdict(int, {5: 1})\\n gate_types = defaultdict(int, {\\\"BasicEntanglerLayers\\\": 1})\\n expected_resources = qml.resource.Resources(\\n num_wires=5, num_gates=1, gate_types=gate_types, gate_sizes=gate_sizes, depth=1\\n )\\n assert info[\\\"resources\\\"] == expected_resources\\n assert info[\\\"num_observables\\\"] == 1\\n assert info[\\\"num_device_wires\\\"] == 5\\n assert info[\\\"device_name\\\"] == \\\"default.qubit.autograd\\\"\\n assert info[\\\"diff_method\\\"] == \\\"best\\\"\\n assert info[\\\"gradient_fn\\\"] == \\\"backprop\\\"\",\n \"def main(supply):\\n\\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\\n # between each pair. For instance, the arc from node 0 to node 1 has a\\n # capacity of 15 and a unit cost of 4.\\n\\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\\n\\n # Define an array of supplies at each node.\\n supplies = supply\\n\\n\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n\\n # Add each arc.\\n for i in range(0, len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\\n capacities[i], unit_costs[i])\\n\\n # Add node supplies.\\n\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n\\n\\n # Find the minimum cost flow between node 0 and node 4.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n flag = 1\\n optimal_flows = np.zeros(36)\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # save answer to the variable\\n optimal_flows[i] = min_cost_flow.Flow(i)\\n return flag, optimal_flows\\n else:\\n print('There was an issue with the min cost flow input.')\\n flag = 0\\n return flag, 0\",\n \"def local_cut_useless_reduce(node):\\r\\n if isinstance(node.op, T.CAReduce):\\r\\n summed, = node.inputs\\r\\n # if reduce were doing anything, the output ndim would be reduced\\r\\n if summed.type == node.outputs[0].type:\\r\\n return [summed]\",\n \"def fit(self):\\n self._minuit_problem.migrad() # run optimizer\\n self._status = 0 if self._minuit_problem.migrad_ok() else 1\",\n \"def __call__(self, **kwargs):\\n segname = 'block_{}_expand_relu'\\n blocks = [13, 6, 3, 1]\\n skips = [self._backbone.get_layer(segname.format(i)) for i in blocks]\\n backbone_out = self._backbone.get_layer('block_16_project')\\n\\n p5 = self._fpn_block(backbone_out.output, skips[0].output)\\n p4 = self._fpn_block(p5, skips[1].output)\\n p3 = self._fpn_block(p4, skips[2].output)\\n p2 = self._fpn_block(p3, skips[3].output)\\n\\n s5 = self._conv_block(p5, 128)\\n s4 = self._conv_block(p4, 128)\\n s3 = self._conv_block(p3, 128)\\n s2 = self._conv_block(p2, 128)\\n\\n s5 = tf.keras.layers.UpSampling2D(\\n size=(8, 8),\\n interpolation='nearest'\\n )(s5)\\n\\n s4 = tf.keras.layers.UpSampling2D(\\n size=(4, 4),\\n interpolation='nearest'\\n )(s4)\\n\\n s3 = tf.keras.layers.UpSampling2D(\\n size=(2, 2),\\n interpolation='nearest'\\n )(s3)\\n\\n concat = [s5, s4, s3, s2]\\n x = tf.keras.layers.Concatenate()(concat)\\n x = tf.keras.layers.Conv2D(\\n 64,\\n kernel_size=3,\\n padding='same',\\n kernel_initializer='he_uniform'\\n )(x)\\n\\n x = tf.keras.layers.BatchNormalization()(x)\\n x = tf.keras.layers.Activation('relu')(x)\\n x = tf.keras.layers.UpSampling2D((2, 2))(x)\\n\\n x = tf.keras.layers.Conv2D(\\n 1,\\n kernel_size=3,\\n padding='same',\\n kernel_initializer='he_uniform'\\n )(x)\\n\\n out = tf.keras.layers.Activation('sigmoid')(x)\\n model = tf.keras.models.Model(\\n inputs=self._backbone.input,\\n outputs=out\\n )\\n\\n return model\",\n \"def solve(self, **kwargs):\\n\\n sorted_compute_nodes = sorted(\\n self.physical.compute_nodes,\\n key=lambda x: self.physical.cores(x) * 1000 + self.physical.memory(x),\\n reverse=True,\\n )\\n\\n for n_partitions_to_try in range(\\n self.lower_bound(), len(sorted_compute_nodes) + 1\\n ):\\n\\n # partitioning of virtual nodes in n_partitions_to_try partitions\\n k_partition = get_partitions(\\n self.virtual.g, n_partitions=n_partitions_to_try\\n )\\n\\n # subset of hosts of size n_partitions_to_try\\n chosen_physical = sorted_compute_nodes[:n_partitions_to_try]\\n\\n #\\n # check if the partitioning is a feasible solution\\n #\\n try:\\n # virtual nodes to physical nodes assignment\\n res_node_mapping = {}\\n\\n # iterate over each pair (physical_node i, virtual nodes assigned to i)\\n for physical_node, assigned_virtual_nodes in zip(\\n chosen_physical, k_partition\\n ):\\n # keep track of the node physical resources used\\n cores_used = memory_used = 0\\n # check if node resources are not exceeded:\\n for virtual_node in assigned_virtual_nodes:\\n # cpu cores\\n cores_used += self.virtual.req_cores(virtual_node)\\n if self.physical.cores(physical_node) < cores_used:\\n raise NodeResourceError(physical_node, \\\"cpu cores\\\")\\n # memory\\n memory_used += self.virtual.req_memory(virtual_node)\\n if self.physical.memory(physical_node) < memory_used:\\n raise NodeResourceError(physical_node, \\\"memory\\\")\\n # assign the virtual nodes to a physical node\\n res_node_mapping[virtual_node] = physical_node\\n\\n #\\n # virtual links to physical links assignment\\n #\\n res_link_mapping = {}\\n rate_used = defaultdict(int)\\n\\n # iterate over each virtual link between two virtual nodes not mapped on the same physical machine\\n for (u, v) in (\\n (u, v)\\n for (u, v) in self.virtual.sorted_edges()\\n if res_node_mapping[u] != res_node_mapping[v]\\n ):\\n\\n res_link_mapping[(u, v)] = []\\n\\n # physical nodes on which u and v have been placed\\n phy_u, phy_v = res_node_mapping[u], res_node_mapping[v]\\n\\n # for each link in the physical path\\n for (i, j, device_id) in self.physical.find_path(\\n phy_u,\\n phy_v,\\n req_rate=self.virtual.req_rate(u, v),\\n used_rate=rate_used,\\n ):\\n # else update the rate\\n rate_used[(i, j, device_id)] += self.virtual.req_rate(u, v)\\n\\n res_link_mapping[(u, v)].append((i, device_id, j))\\n\\n # build solution from the output\\n self.solution = Solution.build_solution(\\n self.virtual, self.physical, res_node_mapping, res_link_mapping\\n )\\n self.status = Solved\\n return Solved\\n\\n except (NodeResourceError, NoPathFoundError):\\n # unfeasible, increase the number of partitions to be used\\n pass\\n else:\\n self.status = Infeasible\\n return Infeasible\",\n \"def enumerate_validated_operator_opsets(verbose=0, opset_min=-1, opset_max=-1,\\n check_runtime=True, debug=False, runtime='python',\\n models=None, dump_folder=None, store_models=False,\\n benchmark=False, skip_models=None,\\n assume_finite=True, node_time=False,\\n fLOG=print, filter_exp=None,\\n versions=False, extended_list=False,\\n time_kwargs=None, dump_all=False,\\n n_features=None, skip_long_test=True,\\n fail_bad_results=False,\\n filter_scenario=None,\\n time_kwargs_fact=None,\\n time_limit=4, n_jobs=None):\\n register_converters()\\n register_rewritten_operators()\\n register_new_operators()\\n\\n ops = _enumerate_validated_operator_opsets_ops(\\n extended_list, models, skip_models)\\n\\n if verbose > 0:\\n\\n def iterate():\\n for i, row in enumerate(ops): # pragma: no cover\\n fLOG(f\\\"{i + 1}/{len(ops)} - {row}\\\")\\n yield row\\n\\n if verbose >= 11:\\n verbose -= 10 # pragma: no cover\\n loop = iterate() # pragma: no cover\\n else:\\n try:\\n from tqdm import trange\\n\\n def iterate_tqdm():\\n with trange(len(ops)) as t:\\n for i in t:\\n row = ops[i]\\n disp = row['name'] + \\\" \\\" * (28 - len(row['name']))\\n t.set_description(f\\\"{disp}\\\")\\n yield row\\n\\n loop = iterate_tqdm()\\n\\n except ImportError: # pragma: no cover\\n loop = iterate()\\n else:\\n loop = ops\\n\\n if versions:\\n add_versions = _enumerate_validated_operator_opsets_version(runtime)\\n else:\\n add_versions = {}\\n\\n current_opset = __max_supported_opset__\\n if opset_min == -1:\\n opset_min = __max_supported_opset__\\n if opset_max == -1:\\n opset_max = __max_supported_opset__\\n if verbose > 0 and fLOG is not None:\\n fLOG(\\\"[enumerate_validated_operator_opsets] opset in [{}, {}].\\\".format(\\n opset_min, opset_max))\\n for row in loop:\\n\\n model = row['cl']\\n if verbose > 1:\\n fLOG(f\\\"[enumerate_validated_operator_opsets] - model='{model}'\\\")\\n\\n for obs in enumerate_compatible_opset(\\n model, opset_min=opset_min, opset_max=opset_max,\\n check_runtime=check_runtime, runtime=runtime,\\n debug=debug, dump_folder=dump_folder,\\n store_models=store_models, benchmark=benchmark,\\n fLOG=fLOG, filter_exp=filter_exp,\\n assume_finite=assume_finite, node_time=node_time,\\n verbose=verbose, extended_list=extended_list,\\n time_kwargs=time_kwargs, dump_all=dump_all,\\n n_features=n_features, skip_long_test=skip_long_test,\\n filter_scenario=filter_scenario,\\n time_kwargs_fact=time_kwargs_fact,\\n time_limit=time_limit, n_jobs=n_jobs):\\n\\n for mandkey in ('inst', 'method_name', 'problem',\\n 'scenario'):\\n if '_0problem_exc' in obs:\\n continue\\n if mandkey not in obs:\\n raise ValueError(\\\"Missing key '{}' in\\\\n{}\\\".format(\\n mandkey, pprint.pformat(obs))) # pragma: no cover\\n if verbose > 1:\\n fLOG('[enumerate_validated_operator_opsets] - OBS')\\n if verbose > 2:\\n fLOG(\\\" \\\", obs)\\n else:\\n obs_log = {k: v for k,\\n v in obs.items() if 'lambda-' not in k}\\n fLOG(\\\" \\\", obs_log)\\n elif verbose > 0 and \\\"_0problem_exc\\\" in obs:\\n fLOG(\\\" ???\\\", obs) # pragma: no cover\\n\\n diff = obs.get('max_rel_diff_batch', None)\\n batch = 'max_rel_diff_batch' in obs and diff is not None\\n op1 = obs.get('domain_opset_', '')\\n op2 = obs.get('domain_opset_ai.onnx.ml', '')\\n op = f'{op1}/{op2}'\\n\\n obs['available'] = \\\"?\\\"\\n if diff is not None:\\n if diff < 1e-5:\\n obs['available'] = 'OK'\\n elif diff < 0.0001:\\n obs['available'] = 'e<0.0001' # pragma: no cover\\n elif diff < 0.001:\\n obs['available'] = 'e<0.001'\\n elif diff < 0.01:\\n obs['available'] = 'e<0.01' # pragma: no cover\\n elif diff < 0.1:\\n obs['available'] = 'e<0.1'\\n else:\\n obs['available'] = f\\\"ERROR->={diff:1.1f}\\\"\\n obs['available'] += '-' + op\\n if not batch:\\n obs['available'] += \\\"-NOBATCH\\\" # pragma: no cover\\n if fail_bad_results and 'e<' in obs['available']:\\n raise RuntimeBadResultsError(\\n f\\\"Wrong results '{obs['available']}'.\\\", obs) # pragma: no cover\\n\\n excs = []\\n for k, v in sorted(obs.items()):\\n if k.endswith('_exc'):\\n excs.append((k, v))\\n break\\n if 'opset' not in obs:\\n # It fails before the conversion happens.\\n obs['opset'] = current_opset\\n if obs['opset'] == current_opset and len(excs) > 0:\\n k, v = excs[0]\\n obs['available'] = f'ERROR-{k}'\\n obs['available-ERROR'] = v\\n\\n if 'bench-skl' in obs:\\n b1 = obs['bench-skl']\\n if 'bench-batch' in obs:\\n b2 = obs['bench-batch']\\n else:\\n b2 = None\\n if b1 is not None and b2 is not None:\\n for k in b1:\\n if k in b2 and b2[k] is not None and b1[k] is not None:\\n key = 'time-ratio-N=%d' % k\\n obs[key] = b2[k]['average'] / b1[k]['average']\\n key = 'time-ratio-N=%d-min' % k\\n obs[key] = b2[k]['min_exec'] / b1[k]['max_exec']\\n key = 'time-ratio-N=%d-max' % k\\n obs[key] = b2[k]['max_exec'] / b1[k]['min_exec']\\n\\n obs.update(row)\\n obs.update(add_versions)\\n yield obs.copy()\",\n \"def inference(self):\\n logging.info('Mincut inference')\\n\\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\\n # set label\\n [positive_label, _] = self._cut.partition\\n positive_label = set(positive_label) - {self._v_plus}\\n self._graph.delete_vertices([self._v_minus, self._v_plus])\\n y = np.zeros(self._graph.vcount()) # re-construct y\\n y[list(positive_label)] = 1\\n self._graph.vs['label'] = y.astype(int)\",\n \"def apply(self, model, layer_quantize_map, remove_dropout, fold_conv_bn,\\n fold_bn, replace_relu6, include_cle, cle_steps):\\n\\n transforms = []\\n if remove_dropout:\\n transforms.append(vitis_optimize_transforms.RemoveDropout())\\n\\n if fold_conv_bn:\\n transforms.append(vitis_optimize_transforms.Conv2DBatchNormFold())\\n\\n if fold_bn:\\n transforms.append(vitis_optimize_transforms.BatchNormFold())\\n\\n if replace_relu6:\\n transforms.append(vitis_optimize_transforms.ReplaceReLU6WithReLU())\\n\\n transformed_model, layer_quantize_map = model_transformer.ModelTransformer(\\n model, transforms, None, layer_quantize_map).transform()\\n\\n # Cross Layer Equalization\\n if include_cle:\\n cle_transforms = [\\n vitis_optimize_transforms.ConvConvCLE(),\\n vitis_optimize_transforms.ConvActConvCLE(),\\n ]\\n progbar = keras.utils.Progbar(cle_steps)\\n print('[INFO] Start CrossLayerEqualization...')\\n for i in range(cle_steps):\\n progbar.update(i + 1)\\n tmp_model, tmp_layer_quantize_map = transformed_model, layer_quantize_map\\n transformed_model, layer_quantize_map = model_transformer.ModelTransformer(\\n tmp_model, cle_transforms, None,\\n tmp_layer_quantize_map).transform()\\n print('[INFO] CrossLayerEqualization Done.')\\n return transformed_model, layer_quantize_map\",\n \"def maximize(self, budget, optimizer):\\n\\n\\t\\tpass\",\n \"def reduce(nodes):\\r\\n accum = tc.mean(nodes.mailbox['m'], 1).cuda()\\r\\n return {'h': accum}\",\n \"def apply_nodes(self, func=\\\"default\\\", v=ALL, inplace=True):\\n super(BaseGraphStore, self).apply_nodes(func, v, inplace=True)\",\n \"def update_filter_limits(self):\\n filters = {}\\n filters[\\\"label\\\"] = \\\"NanoribbonWorkChain\\\"\\n filters[\\\"extras.preprocess_version\\\"] = self.PREPROCESS_VERSION\\n filters[\\\"extras.preprocess_successful\\\"] = True\\n filters[\\\"extras.obsolete\\\"] = False\\n\\n qb = orm.QueryBuilder()\\n qb.append(orm.WorkChainNode, filters=filters)\\n\\n def compare_and_set(val, slider):\\n if val < slider.min:\\n slider.min = val\\n if val > slider.max:\\n slider.max = val\\n # also reset to min-max\\n slider.value = (slider.min, slider.max)\\n\\n for m in qb.all():\\n calc = m[0]\\n compare_and_set(calc.get_extra(\\\"gap\\\"), self.inp_gap)\\n compare_and_set(calc.get_extra(\\\"homo\\\"), self.inp_homo)\\n compare_and_set(calc.get_extra(\\\"lumo\\\"), self.inp_lumo)\\n compare_and_set(calc.get_extra(\\\"fermi_energy\\\"), self.inp_efermi)\\n compare_and_set(\\n calc.get_extra(\\\"total_magnetization_per_angstr\\\"), self.inp_tmagn\\n )\\n compare_and_set(\\n calc.get_extra(\\\"absolute_magnetization_per_angstr\\\"), self.inp_amagn\\n )\",\n \"def input_nodes(self):\\n pass\",\n \"def compute(self, node, input_vals):\\r\\n #start = time.time()\\r\\n\\r\\n #assert len(input_vals) == 1\\r\\n strides = node.const_attr[1]\\r\\n ksize = node.const_attr[0]\\r\\n ish = list(input_vals[0].shape)\\r\\n input = input_vals[0]\\r\\n output = np.zeros([ish[0],(ish[1]-ksize[1])//strides[1]+1,(ish[2]-ksize[2])//strides[2]+1,ish[3]])\\r\\n osh = output.shape\\r\\n #print(osh)\\r\\n for i in range(osh[1]):\\r\\n for j in range(osh[2]):\\r\\n output[:,i,j,:] = np.amax(input[:,i*strides[1]:(i+1)*strides[1],j*strides[1]:(j+1)*strides[1],:],axis=(1,2))\\r\\n #end = time.time() \\r\\n #print(\\\"max_pool\\\") \\r\\n #print(end - start) \\r\\n return output\\r\\n \\r\\n #assert False\\r\",\n \"def optimize(self):\\n self.check_is_ready()\\n self.check_infeasibility()\\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)\",\n \"def create(self):\\n \\n \\\"\\\"\\\" A solo prepressing reduction network in the head \\\"\\\"\\\"\\n print(\\\"pre_reduction\\\")\\n with tf.name_scope('pre_reduction'):\\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\\n \\n \\\"\\\"\\\" 1st inception layer group \\\"\\\"\\\"\\n print(\\\"icp1\\\")\\n with tf.name_scope('icp1'):\\n # branch 0\\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\\n # branch 1\\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\\n # branch 2\\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\\n # branch 3\\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\\n # concat\\n icp2_in = NW.concat([icp1_out0,\\n icp1_out1,\\n icp1_out2,\\n icp1_out3], 3, 'icp2_in')\\n\\n \\\"\\\"\\\" 2nd inception layer group \\\"\\\"\\\"\\n print(\\\"icp2\\\")\\n with tf.name_scope('icp2'):\\n # branch 0\\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\\n # branch 1\\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\\n # branch 2\\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\\n # branch 3\\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\\n # concat\\n icp2_out = NW.concat([icp2_out0,\\n icp2_out1,\\n icp2_out2,\\n icp2_out3], 3, 'icp2_out')\\n \\n \\\"\\\"\\\" 3rd inception layer group \\\"\\\"\\\"\\n print(\\\"icp3\\\")\\n with tf.name_scope('icp3'):\\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\\n # branch 0\\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\\n # branch 1\\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\\n # branch 2\\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\\n # branch 3\\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\\n # concat\\n icp3_out = NW.concat([icp3_out0,\\n icp3_out1,\\n icp3_out2,\\n icp3_out3], 3, 'icp3_out')\\n \\n \\\"\\\"\\\" 1st classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls1'):\\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\\n self.layers[\\\"cls1_fc_pose_xy\\\"] = cls1_fc_pose_xy\\n self.layers[\\\"cls1_fc_pose_ab\\\"] = cls1_fc_pose_ab\\n \\n \\\"\\\"\\\" 4st inception layer group \\\"\\\"\\\"\\n print(\\\"icp4\\\")\\n with tf.name_scope('icp4'):\\n # branch 0\\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\\n # branch 1\\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\\n # branch 2\\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\\n # branch 3\\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\\n # concat\\n icp4_out = NW.concat([icp4_out0,\\n icp4_out1,\\n icp4_out2,\\n icp4_out3],3, name='icp4_out')\\n\\n \\\"\\\"\\\" 5st inception layer group \\\"\\\"\\\"\\n print(\\\"icp5\\\")\\n with tf.name_scope('icp5'):\\n # branch 0\\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\\n # branch 1\\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\\n # branch 2\\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\\n # branch 3\\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\\n # concat\\n icp5_out = NW.concat([icp5_out0, \\n icp5_out1, \\n icp5_out2, \\n icp5_out3], 3, name='icp5_out')\\n \\n \\\"\\\"\\\" 6st inception layer group \\\"\\\"\\\"\\n print(\\\"icp6\\\")\\n with tf.name_scope('icp6'):\\n # branch 0\\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\\n # branch 1\\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\\n # branch 2\\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\\n # branch 3\\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\\n # concat\\n icp6_out = NW.concat([icp6_out0,\\n icp6_out1,\\n icp6_out2,\\n icp6_out3], 3, name='icp6_out')\\n\\n \\\"\\\"\\\" 2nd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls2'):\\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\\n self.layers[\\\"cls2_fc_pose_xy\\\"] = cls2_fc_pose_xy\\n self.layers[\\\"cls2_fc_pose_ab\\\"] = cls2_fc_pose_ab\\n\\n \\\"\\\"\\\" 7st inception layer group \\\"\\\"\\\"\\n print(\\\"icp7\\\")\\n with tf.name_scope('icp7'):\\n # branch 0\\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\\n # branch 1\\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\\n # branch 2\\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\\n # branch 3\\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\\n # concat\\n icp7_out = NW.concat([icp7_out0,\\n icp7_out1,\\n icp7_out2,\\n icp7_out3], 3, name='icp7_out')\\n\\n \\\"\\\"\\\" 8st inception layer group \\\"\\\"\\\"\\n print(\\\"icp8\\\")\\n with tf.name_scope('icp8'):\\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\\n # branch 0\\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\\n # branch 1\\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\\n # branch 2\\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\\n # branch 3\\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\\n # concat\\n icp8_out = NW.concat([icp8_out0,\\n icp8_out1,\\n icp8_out2,\\n icp8_out3], 3, name='icp8_out')\\n \\n \\\"\\\"\\\" 9st inception layer group \\\"\\\"\\\"\\n print(\\\"icp9\\\")\\n with tf.name_scope('icp9'):\\n # branch 0\\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\\n # branch 1\\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\\n # branch 2\\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\\n # branch 3\\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\\n # concat\\n icp9_out = NW.concat([icp9_out0,\\n icp9_out1,\\n icp9_out2,\\n icp9_out3], 3, name='icp9_out')\\n\\n \\\"\\\"\\\" 3rd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls3'):\\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\\n self.layers[\\\"cls3_fc_pose_xy\\\"] = cls3_fc_pose_xy\\n self.layers[\\\"cls3_fc_pose_ab\\\"] = cls3_fc_pose_ab\",\n \"def calculateAllSupport(self):\\n\\n for key, value in self._sets[self._currentSet].items():\\n val = self.getSupport(key)\\n self._sets[self._currentSet][key] = self.getSupport(key)\",\n \"def add_max(org, kernels, centres):\\n return org\",\n \"def Allreduce4(net, blobs, reduced_affix, gpu_indices):\\n a, b, c, d = blobs\\n gpu_a, gpu_b, gpu_c, gpu_d = gpu_indices\\n # a_reduced <- a+b, c_reduced <- c + d\\n a_reduced = net.Add(\\n [a, b],\\n str(a) + reduced_affix,\\n device_option=OnGPU(gpu_a)\\n )\\n c_reduced = net.Add(\\n [c, d],\\n str(c) + reduced_affix,\\n device_option=OnGPU(gpu_c)\\n )\\n # a_reduced <- a_reduced + c_reduced\\n a_reduced = a_reduced.Add(c_reduced, a_reduced, device_option=OnGPU(gpu_a))\\n # broadcast a_reduced to c_reduced\\n c_reduced = a_reduced.Copy([], c_reduced, device_option=OnGPU(gpu_c))\\n # broadcast to b and d\\n b_reduced = a_reduced.Copy(\\n [],\\n str(b) + reduced_affix,\\n device_option=OnGPU(gpu_b)\\n )\\n d_reduced = c_reduced.Copy(\\n [],\\n str(d) + reduced_affix,\\n device_option=OnGPU(gpu_d)\\n )\\n return a_reduced, b_reduced, c_reduced, d_reduced\",\n \"def evaluator(self, candidates, args):\\r\\n fitness = []\\r\\n if self._use_ants:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for c in candidate:\\r\\n total += c.value\\r\\n fitness.append(total)\\r\\n else:\\r\\n for candidate in candidates:\\r\\n total_value = 0\\r\\n total_weight = 0\\r\\n for c, i in zip(candidate, self.items):\\r\\n total_weight += c * i[0]\\r\\n total_value += c * i[1]\\r\\n if total_weight > self.capacity:\\r\\n fitness.append(self.capacity - total_weight)\\r\\n else:\\r\\n fitness.append(total_value)\\r\\n return fitness\",\n \"def reduce(model_results, out, params):\\n import numpy as np\\n for n, (ps, activation_results) in model_results:\\n\\n if not activation_results:\\n out.add(n, (ps, None))\\n else:\\n out.add(n, (ps, activation_results))\",\n \"def generate_mcts(self, graph: Data, n_min: int, nodes_to_keep: List[int],\\n exhaustive: bool):\\n return self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)\",\n \"def _reduce(self, x, y):\\n ind = self.ind_\\n n_samples, n_features = x.shape\\n n_features_selected = sum(ind)\\n\\n for _ in range(self.iters, self.max_iter):\\n if np.count_nonzero(ind) == 0:\\n warnings.warn(\\n \\\"Sparsity parameter is too big ({}) and eliminated all coeficients\\\".format(self.threshold)\\n )\\n coef = np.zeros_like(ind, dtype=float)\\n break\\n\\n coef = self._regress(x[:, ind], y, self.alpha)\\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\\n\\n if sum(ind) == n_features_selected or self._no_change():\\n # could not (further) select important features\\n break\\n else:\\n warnings.warn(\\n \\\"STRidge._reduce did not converge after {} iterations.\\\".format(self.max_iter),\\n ConvergenceWarning,\\n )\\n try:\\n coef\\n except NameError:\\n coef = self.coef_\\n warnings.warn(\\\"STRidge._reduce has no iterations left to determine coef\\\", ConvergenceWarning)\\n self.coef_ = coef\\n self.ind_ = ind\",\n \"def compute(self, inputs, outputs):\\n\\n # Add new variables to dictionnary\\n cpacs = CPACS(Rt.modules[-1].cpacs_out)\\n\\n update_dict(cpacs.tixi, Rt.optim_var_dict)\\n\\n # Save the whole aeromap if needed\\n if Rt.use_aeromap:\\n update_am_dict(cpacs, Rt.aeromap_uid, Rt.am_dict)\\n\\n for obj in Rt.objective:\\n var_list = split(\\\"[+*/-]\\\", obj)\\n for v in var_list:\\n if not v.isdigit() and v != \\\"\\\":\\n exec('{} = inputs[\\\"{}\\\"]'.format(v, v))\\n result = eval(obj)\\n\\n if Rt.minmax == \\\"min\\\":\\n outputs[\\\"Objective function \\\" + obj] = result\\n else:\\n outputs[\\\"Objective function \\\" + obj] = -result\",\n \"def _query_quantizable_ops(self, matched_nodes, activation_dtype, weight_dtype):\\n\\n tf_quantizable_op_type = (\\\"Conv2D\\\", \\\"DepthwiseConv2dNative\\\",\\n \\\"MaxPool\\\", \\\"AvgPool\\\", \\\"ConcatV2\\\", \\\"MatMul\\\", \\\"Pad\\\")\\n conv_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax', 'kl'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n },\\n 'weight': {\\n 'dtype': weight_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_channel', 'per_tensor']\\n }\\n }\\n matmul_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['asym', 'sym'],\\n 'granularity': ['per_tensor']\\n },\\n 'weight': {\\n 'dtype': weight_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n }\\n }\\n other_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n },\\n }\\n\\n self.quantizable_op_details = OrderedDict()\\n\\n self._init_op_stat = {i: [] for i in tf_quantizable_op_type}\\n for details in matched_nodes:\\n node_op = details[-1][0]\\n node_name = details[0]\\n patterns = details[-1]\\n pat_length = len(patterns)\\n pattern_info = {\\n 'sequence': [[','.join(patterns[:pat_length - i]) for i in range(pat_length)][0]],\\n 'precision': ['int8']\\n }\\n if node_op in tf_quantizable_op_type and node_name not in self.exclude_node_names:\\n self._init_op_stat[node_op].append(node_name)\\n if self.unify_op_type_mapping[node_op].find(\\\"conv2d\\\") != -1:\\n conv2d_int8_config = copy.deepcopy(conv_config)\\n conv2d_int8_config['pattern'] = pattern_info\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = conv2d_int8_config\\n elif self.unify_op_type_mapping[node_op].find(\\\"matmul\\\") != -1:\\n matmul_int8_config = copy.deepcopy(matmul_config)\\n matmul_int8_config['pattern'] = pattern_info\\n # TODO enable the sym mode once the tf fixed the mkldequantize_op.cc bug.\\n # is_positive_input = self.pre_optimizer_handle.has_positive_input(node_name)\\n # matmul_scheme = 'sym' if is_positive_input else 'asym'\\n matmul_scheme = ['asym']\\n matmul_int8_config['activation']['scheme'] = matmul_scheme\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = matmul_int8_config\\n else:\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = copy.deepcopy(other_config)\\n\\n self.quantize_config['op_wise_config'][node_name] = (False, \\\"minmax\\\", False)\\n return self.quantizable_op_details\",\n \"def optimize_graph( complete, desired, algo, simi_cutoff ) :\\n if (algo == \\\"trim\\\") :\\n return trim_cluster( desired, desired.nodes(), 2 )\",\n \"def Q_credit_checkers(s_grid, s_n, g_n, a_m, s_m, s_others, t_obs, v_obs,\\n f1=4, k1=[3,5], f2=6, k2=[3,3],\\n n_h1_1=128, n_h1_2=32, n_h2=32, stage=2, bias=True):\\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\\n concated = tf.concat( [conv, s_n, g_n, a_m, conv_o, v_obs], axis=1 )\\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\\n W_branch1_h2 = get_variable(\\\"W_branch1_h2\\\", [n_h1_1, n_h2])\\n\\n list_mult = []\\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\\n\\n if stage > 1:\\n with tf.variable_scope(\\\"stage-2\\\"):\\n concated2 = tf.concat( [s_m, s_others], axis=1 )\\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\\n list_mult.append(tf.matmul(others, W_branch2_h2))\\n\\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\\n \\n return out\",\n \"def calc_operand_assignments(self, op_keys, input_chunk_metas=None):\\n graph = self._graph\\n op_states = self._op_states\\n cur_assigns = OrderedDict(self._fixed_assigns)\\n expect_workers = dict()\\n\\n key_to_chunks = defaultdict(list)\\n for n in graph:\\n key_to_chunks[n.op.key].append(n)\\n if n.op.expect_worker is not None:\\n expect_workers[n.op.key] = cur_assigns[n.op.key] = n.op.expect_worker\\n\\n descendant_readies = set()\\n op_keys = set(op_keys)\\n requested_chunks = [key_to_chunks[k][0] for k in op_keys]\\n chunks_to_assign = [c for c in requested_chunks if c.op.expect_worker is None]\\n\\n if any(graph.count_predecessors(c) for c in chunks_to_assign):\\n graph = graph.copy()\\n for c in graph:\\n if c.op.key not in op_keys:\\n continue\\n for pred in graph.predecessors(c):\\n graph.remove_edge(pred, c)\\n\\n assigned_counts = defaultdict(lambda: 0)\\n worker_op_keys = defaultdict(set)\\n if cur_assigns:\\n for op_key, state in op_states.items():\\n if op_key not in op_keys and state == OperandState.READY \\\\\\n and op_key in cur_assigns:\\n descendant_readies.add(op_key)\\n assigned_counts[cur_assigns[op_key]] += 1\\n\\n # calculate the number of nodes to be assigned to every worker\\n # given number of workers and existing assignments\\n pre_worker_quotas = self._calc_worker_assign_limits(\\n len(chunks_to_assign) + len(descendant_readies), assigned_counts)\\n\\n # pre-assign nodes given pre-determined transfer sizes\\n if not input_chunk_metas:\\n worker_quotas = pre_worker_quotas\\n else:\\n for op_key, worker in self._iter_assignments_by_transfer_sizes(\\n pre_worker_quotas, input_chunk_metas):\\n if op_key in cur_assigns or op_key not in op_keys:\\n continue\\n assigned_counts[worker] += 1\\n cur_assigns[op_key] = worker\\n worker_op_keys[worker].add(op_key)\\n\\n worker_quotas = self._calc_worker_assign_limits(\\n len(chunks_to_assign) + len(descendant_readies), assigned_counts)\\n\\n if cur_assigns:\\n # calculate ranges of nodes already assigned\\n for op_key, worker in self._iter_successor_assigns(cur_assigns):\\n cur_assigns[op_key] = worker\\n worker_op_keys[worker].add(op_key)\\n\\n logger.debug('Worker assign quotas: %r', worker_quotas)\\n\\n # calculate expected descendant count (spread range) of\\n # every worker and subtract assigned number from it\\n average_spread_range = len(graph) * 1.0 / len(self._worker_slots)\\n spread_ranges = defaultdict(lambda: average_spread_range)\\n for worker in cur_assigns.values():\\n spread_ranges[worker] -= 1\\n\\n logger.debug('Scan spread ranges: %r', dict(spread_ranges))\\n\\n # assign pass 1: assign from fixed groups\\n sorted_workers = sorted(worker_op_keys, reverse=True, key=lambda k: len(worker_op_keys[k]))\\n for worker in sorted_workers:\\n start_chunks = reduce(operator.add, (key_to_chunks[op_key] for op_key in worker_op_keys[worker]))\\n self._assign_by_bfs(start_chunks, worker, worker_quotas, spread_ranges,\\n op_keys, cur_assigns, graph=graph)\\n\\n # assign pass 2: assign from other nodes to be assigned\\n sorted_candidates = [v for v in chunks_to_assign]\\n while max(worker_quotas.values()):\\n worker = max(worker_quotas, key=lambda k: worker_quotas[k])\\n try:\\n cur = sorted_candidates.pop()\\n while cur.op.key in cur_assigns:\\n cur = sorted_candidates.pop()\\n except IndexError: # pragma: no cover\\n break\\n self._assign_by_bfs(cur, worker, worker_quotas, spread_ranges, op_keys,\\n cur_assigns, graph=graph)\\n\\n keys_to_assign = {n.op.key: n.op for n in requested_chunks}\\n assignments = {k: v for k, v in cur_assigns.items() if k in keys_to_assign}\\n assignments.update({k: v for k, v in expect_workers.items() if k in keys_to_assign})\\n return assignments\",\n \"def _oim_node2vec_test(\\n df,\\n df_feats,\\n num_inf=10,\\n sigma=4,\\n c=0.1,\\n epsilon=0.4,\\n num_repeats=30,\\n num_repeats_regret_algo=20,\\n num_repeats_regret_true=20,\\n num_nodes_tim=-1,\\n oracle=tim,\\n):\\n logger_tlu.debug(\\\"Started Online Influence Maximization...\\\")\\n logger_tlu.debug(\\\"Setting parameters\\\")\\n num_feats = df_feats.shape[1]\\n num_edges_t = df.shape[0]\\n\\n # \\\"True\\\" probabilities - effectively our test set\\n true_weights = df[\\\"probab\\\"].copy()\\n # Using nodes_t[-1] because TIM wants the max node id\\n s_true = sorted(\\n oracle(\\n df[[\\\"source\\\", \\\"target\\\", \\\"probab\\\"]],\\n num_nodes_tim,\\n num_edges_t,\\n num_inf,\\n epsilon,\\n )\\n )\\n # Gathering the stats for the \\\"true\\\" seed set\\n all_true_nodes = []\\n all_true_edges = []\\n all_true_obs = []\\n for k in range(num_repeats_regret_true):\\n true_act_nodes, true_act_edges, true_obs_edges = run_ic_eff(df, s_true)\\n all_true_nodes.append(true_act_nodes)\\n all_true_edges.append(true_act_edges)\\n all_true_obs.append(true_obs_edges)\\n\\n # Means for nodes and activated edges\\n mean_true_nodes = np.mean([len(i) for i in all_true_nodes])\\n mean_true_edges = np.mean([len(i) for i in all_true_edges])\\n mean_true_obs = np.mean([len(i) for i in all_true_obs])\\n\\n # b, M_inv - used by IMLinUCB\\n b = np.zeros((num_feats, 1))\\n m_inv = np.eye(num_feats, num_feats)\\n\\n # Returning these\\n s_best = []\\n reward_best = 0\\n u_e_best = []\\n regrets = []\\n regrets_edges = []\\n\\n for iter_oim in tqdm(\\n range(num_repeats),\\n desc=f\\\"OIM iters {num_edges_t} edges\\\",\\n leave=False,\\n file=sys.stderr,\\n ):\\n # ---- Step 1 - Calculating the u_e ----\\n theta = (m_inv @ b) / (sigma * sigma)\\n # xMx = (df_feats.values @ m_inv @ df_feats.T.values).clip(min=0)\\n\\n u_e = []\\n for i in range(num_edges_t):\\n x_e = df_feats.loc[i].values\\n xMx = x_e @ m_inv @ x_e.T # .clip(min=0)\\n u_e.append(np.clip(x_e @ theta + c * np.sqrt(xMx), 0, 1))\\n # u_e.append(expit(x_e @ theta + c * np.sqrt(xMx)))\\n\\n u_e = np.array(u_e)\\n\\n # ---- Step 2 - Evaluating the performance ----\\n # Loss function\\n df[\\\"probab\\\"] = u_e\\n s_oracle = sorted(\\n oracle(\\n df[[\\\"source\\\", \\\"target\\\", \\\"probab\\\"]],\\n num_nodes_tim,\\n num_edges_t,\\n num_inf,\\n epsilon,\\n )\\n )\\n\\n # Observing edge-level feedback\\n df[\\\"probab\\\"] = true_weights\\n\\n all_algo_nodes = []\\n all_algo_edges = []\\n all_algo_obs = []\\n for k in range(num_repeats_regret_algo):\\n algo_act_nodes, algo_act_edges, algo_obs_edges = run_ic_eff(df, s_oracle)\\n all_algo_nodes.append(algo_act_nodes)\\n all_algo_edges.append(algo_act_edges)\\n all_algo_obs.append(algo_obs_edges)\\n\\n # Mean node counts\\n mean_algo_nodes = np.mean([len(i) for i in all_algo_nodes])\\n # Mean activated edge counts\\n mean_algo_edges = np.mean([len(i) for i in all_algo_edges])\\n mean_algo_obs = np.mean([len(i) for i in all_algo_obs])\\n\\n # Used for updating M and b later\\n all_algo_edges = np.unique(np.concatenate(all_algo_edges))\\n all_algo_obs = np.unique(np.concatenate(all_algo_obs))\\n\\n regrets.append(mean_true_nodes - mean_algo_nodes)\\n regrets_edges.append(mean_true_edges - mean_algo_edges)\\n\\n logger_tlu.debug(f\\\"True seeds: {s_true}\\\")\\n logger_tlu.debug(f\\\"Algo seeds: {s_oracle}\\\")\\n logger_tlu.debug(\\n \\\"Diff between true and algo seeds: \\\"\\n f\\\"{len(np.setdiff1d(s_true, s_oracle))}\\\"\\n )\\n logger_tlu.debug(f\\\"True reward: {mean_true_nodes}\\\")\\n logger_tlu.debug(f\\\"Algo reward: {mean_algo_nodes}\\\")\\n logger_tlu.debug(f\\\"Best algo reward: {reward_best}\\\")\\n logger_tlu.debug(f\\\"Regrets: {regrets}\\\")\\n logger_tlu.debug(f\\\"Edge regrets: {regrets_edges}\\\")\\n logger_tlu.debug(f\\\"Observed diff: {mean_true_obs - mean_algo_obs}\\\")\\n logger_tlu.debug(f\\\"Algo weights {u_e[80:90]}\\\".replace(\\\"\\\\n\\\", \\\"\\\"))\\n logger_tlu.debug(f\\\"Real weights {true_weights[80:90]}\\\".replace(\\\"\\\\n\\\", \\\"\\\"))\\n\\n if mean_algo_nodes > reward_best:\\n reward_best = mean_algo_nodes\\n s_best = s_oracle\\n u_e_best = u_e\\n\\n if mean_algo_nodes > mean_true_nodes:\\n logger_tlu.debug(\\n \\\"The algorithm has achieved better reward than the true seed node set.\\\"\\n )\\n logger_tlu.debug(\\\"Stopping learning.\\\")\\n logger_tlu.debug(f\\\"Best algo seed node set: {s_best}\\\")\\n return_dict = {\\n \\\"regrets\\\": regrets,\\n \\\"regrets_edges\\\": regrets_edges,\\n \\\"s_true\\\": s_true,\\n \\\"s_best\\\": s_best,\\n \\\"u_e_best\\\": u_e_best,\\n \\\"reward_best\\\": reward_best,\\n }\\n logger_tlu.debug(f\\\"Returning {return_dict}\\\")\\n return return_dict\\n\\n # ---- Step 3 - Calculating updates ----\\n for i in all_algo_obs:\\n x_e = np.array([df_feats.loc[i].values])\\n m_inv -= (m_inv @ x_e.T @ x_e @ m_inv) / (\\n x_e @ m_inv @ x_e.T + sigma * sigma\\n )\\n b += x_e.T * int(i in all_algo_edges)\\n\\n return_dict = {\\n \\\"regrets\\\": regrets,\\n \\\"regrets_edges\\\": regrets_edges,\\n \\\"s_true\\\": s_true,\\n \\\"s_best\\\": s_best,\\n \\\"u_e_best\\\": u_e_best,\\n \\\"reward_best\\\": reward_best,\\n }\\n logger_tlu.debug(\\\"The algorithm has finished running.\\\")\\n logger_tlu.debug(f\\\"Returning: {return_dict}\\\")\\n return return_dict\",\n \"def quantize(self, tune_cfg, model, data_loader, q_func=None):\\n assert q_func is None, \\\"quantization aware training has not been supported on ONNXRUNTIME\\\"\\n model = self.pre_optimized_model if self.pre_optimized_model else model\\n ort_version = StrictVersion(ort.__version__)\\n if ort_version < ONNXRT152_VERSION: # pragma: no cover\\n logger.warning(\\\"Quantize input needs onnxruntime 1.5.2 or newer.\\\")\\n return model\\n if model.model.opset_import[0].version < 11: # pragma: no cover\\n logger.warning(\\\"Quantize input needs model opset 11 or newer.\\\")\\n from neural_compressor.adaptor.ox_utils.onnx_quantizer import ONNXQuantizer\\n from onnxruntime.quantization.quant_utils import QuantizationMode\\n backend = QuantizationMode.QLinearOps if self.backend == \\\\\\n \\\"qlinearops\\\" else QuantizationMode.IntegerOps\\n\\n self.quantizable_ops = self._query_quantizable_ops(model.model)\\n tmp_model = copy.deepcopy(model)\\n \\n quantize_config = self._cfg_to_quantize_config(tune_cfg)\\n iterations = tune_cfg.get('calib_iteration', 1)\\n if self.static:\\n quantize_params = self._get_quantize_params(tmp_model.model, data_loader, \\\\\\n quantize_config, iterations)\\n else:\\n quantize_params = None\\n self.quantize_params = quantize_params\\n quantizer = ONNXQuantizer(tmp_model.model,\\n quantize_config,\\n backend,\\n self.static,\\n quantize_params,\\n self.quantizable_op_types)\\n quantizer.quantize_model()\\n tmp_model.q_config = self._generate_qconfig(model.model, tune_cfg, quantize_params)\\n tmp_model.model = quantizer.model.model\\n self.quantize_config = quantize_config # update so other methods can know current configs\\n \\n self._dump_model_op_stastics(tmp_model)\\n return tmp_model\",\n \"def _calc_reactions(model, log=False, combo_tags=None):\\n\\n # Print a status update to the console\\n if log: print('- Calculating reactions')\\n\\n # Identify which load combinations to evaluate\\n if combo_tags is None:\\n combo_list = model.LoadCombos.values()\\n else:\\n combo_list = []\\n for combo in model.LoadCombos.values():\\n if any(tag in combo.combo_tags for tag in combo_tags):\\n combo_list.append(combo)\\n\\n # Calculate the reactions node by node\\n for node in model.Nodes.values():\\n \\n # Step through each load combination\\n for combo in combo_list:\\n \\n # Initialize reactions for this node and load combination\\n node.RxnFX[combo.name] = 0.0\\n node.RxnFY[combo.name] = 0.0\\n node.RxnFZ[combo.name] = 0.0\\n node.RxnMX[combo.name] = 0.0\\n node.RxnMY[combo.name] = 0.0\\n node.RxnMZ[combo.name] = 0.0\\n\\n # Determine if the node has any supports\\n if (node.support_DX or node.support_DY or node.support_DZ \\n or node.support_RX or node.support_RY or node.support_RZ):\\n\\n # Sum the spring end forces at the node\\n for spring in model.Springs.values():\\n\\n if spring.i_node == node and spring.active[combo.name] == True:\\n \\n # Get the spring's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n spring_F = spring.F(combo.name)\\n\\n node.RxnFX[combo.name] += spring_F[0, 0]\\n node.RxnFY[combo.name] += spring_F[1, 0]\\n node.RxnFZ[combo.name] += spring_F[2, 0]\\n node.RxnMX[combo.name] += spring_F[3, 0]\\n node.RxnMY[combo.name] += spring_F[4, 0]\\n node.RxnMZ[combo.name] += spring_F[5, 0]\\n\\n elif spring.j_node == node and spring.active[combo.name] == True:\\n \\n # Get the spring's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n spring_F = spring.F(combo.name)\\n \\n node.RxnFX[combo.name] += spring_F[6, 0]\\n node.RxnFY[combo.name] += spring_F[7, 0]\\n node.RxnFZ[combo.name] += spring_F[8, 0]\\n node.RxnMX[combo.name] += spring_F[9, 0]\\n node.RxnMY[combo.name] += spring_F[10, 0]\\n node.RxnMZ[combo.name] += spring_F[11, 0]\\n\\n # Step through each physical member in the model\\n for phys_member in model.Members.values():\\n\\n # Sum the sub-member end forces at the node\\n for member in phys_member.sub_members.values():\\n \\n if member.i_node == node and phys_member.active[combo.name] == True:\\n \\n # Get the member's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n member_F = member.F(combo.name)\\n\\n node.RxnFX[combo.name] += member_F[0, 0]\\n node.RxnFY[combo.name] += member_F[1, 0]\\n node.RxnFZ[combo.name] += member_F[2, 0]\\n node.RxnMX[combo.name] += member_F[3, 0]\\n node.RxnMY[combo.name] += member_F[4, 0]\\n node.RxnMZ[combo.name] += member_F[5, 0]\\n\\n elif member.j_node == node and phys_member.active[combo.name] == True:\\n \\n # Get the member's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n member_F = member.F(combo.name)\\n \\n node.RxnFX[combo.name] += member_F[6, 0]\\n node.RxnFY[combo.name] += member_F[7, 0]\\n node.RxnFZ[combo.name] += member_F[8, 0]\\n node.RxnMX[combo.name] += member_F[9, 0]\\n node.RxnMY[combo.name] += member_F[10, 0]\\n node.RxnMZ[combo.name] += member_F[11, 0]\\n\\n # Sum the plate forces at the node\\n for plate in model.Plates.values():\\n\\n if plate.i_node == node:\\n\\n # Get the plate's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n plate_F = plate.F(combo.name)\\n \\n node.RxnFX[combo.name] += plate_F[0, 0]\\n node.RxnFY[combo.name] += plate_F[1, 0]\\n node.RxnFZ[combo.name] += plate_F[2, 0]\\n node.RxnMX[combo.name] += plate_F[3, 0]\\n node.RxnMY[combo.name] += plate_F[4, 0]\\n node.RxnMZ[combo.name] += plate_F[5, 0]\\n\\n elif plate.j_node == node:\\n\\n # Get the plate's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n plate_F = plate.F(combo.name)\\n \\n node.RxnFX[combo.name] += plate_F[6, 0]\\n node.RxnFY[combo.name] += plate_F[7, 0]\\n node.RxnFZ[combo.name] += plate_F[8, 0]\\n node.RxnMX[combo.name] += plate_F[9, 0]\\n node.RxnMY[combo.name] += plate_F[10, 0]\\n node.RxnMZ[combo.name] += plate_F[11, 0]\\n\\n elif plate.m_node == node:\\n\\n # Get the plate's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n plate_F = plate.F(combo.name)\\n \\n node.RxnFX[combo.name] += plate_F[12, 0]\\n node.RxnFY[combo.name] += plate_F[13, 0]\\n node.RxnFZ[combo.name] += plate_F[14, 0]\\n node.RxnMX[combo.name] += plate_F[15, 0]\\n node.RxnMY[combo.name] += plate_F[16, 0]\\n node.RxnMZ[combo.name] += plate_F[17, 0]\\n\\n elif plate.n_node == node:\\n\\n # Get the plate's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n plate_F = plate.F(combo.name)\\n \\n node.RxnFX[combo.name] += plate_F[18, 0]\\n node.RxnFY[combo.name] += plate_F[19, 0]\\n node.RxnFZ[combo.name] += plate_F[20, 0]\\n node.RxnMX[combo.name] += plate_F[21, 0]\\n node.RxnMY[combo.name] += plate_F[22, 0]\\n node.RxnMZ[combo.name] += plate_F[23, 0]\\n\\n # Sum the quad forces at the node\\n for quad in model.Quads.values():\\n\\n if quad.m_node == node:\\n\\n # Get the quad's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n quad_F = quad.F(combo.name)\\n\\n node.RxnFX[combo.name] += quad_F[0, 0]\\n node.RxnFY[combo.name] += quad_F[1, 0]\\n node.RxnFZ[combo.name] += quad_F[2, 0]\\n node.RxnMX[combo.name] += quad_F[3, 0]\\n node.RxnMY[combo.name] += quad_F[4, 0]\\n node.RxnMZ[combo.name] += quad_F[5, 0]\\n\\n elif quad.n_node == node:\\n\\n # Get the quad's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n quad_F = quad.F(combo.name)\\n \\n node.RxnFX[combo.name] += quad_F[6, 0]\\n node.RxnFY[combo.name] += quad_F[7, 0]\\n node.RxnFZ[combo.name] += quad_F[8, 0]\\n node.RxnMX[combo.name] += quad_F[9, 0]\\n node.RxnMY[combo.name] += quad_F[10, 0]\\n node.RxnMZ[combo.name] += quad_F[11, 0]\\n\\n elif quad.i_node == node:\\n\\n # Get the quad's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n quad_F = quad.F(combo.name)\\n \\n node.RxnFX[combo.name] += quad_F[12, 0]\\n node.RxnFY[combo.name] += quad_F[13, 0]\\n node.RxnFZ[combo.name] += quad_F[14, 0]\\n node.RxnMX[combo.name] += quad_F[15, 0]\\n node.RxnMY[combo.name] += quad_F[16, 0]\\n node.RxnMZ[combo.name] += quad_F[17, 0]\\n\\n elif quad.j_node == node:\\n\\n # Get the quad's global force matrix\\n # Storing it as a local variable eliminates the need to rebuild it every time a term is needed \\n quad_F = quad.F(combo.name)\\n \\n node.RxnFX[combo.name] += quad_F[18, 0]\\n node.RxnFY[combo.name] += quad_F[19, 0]\\n node.RxnFZ[combo.name] += quad_F[20, 0]\\n node.RxnMX[combo.name] += quad_F[21, 0]\\n node.RxnMY[combo.name] += quad_F[22, 0]\\n node.RxnMZ[combo.name] += quad_F[23, 0]\\n \\n # Sum the joint loads applied to the node\\n for load in node.NodeLoads:\\n\\n for case, factor in combo.factors.items():\\n \\n if load[2] == case:\\n\\n if load[0] == 'FX':\\n node.RxnFX[combo.name] -= load[1]*factor\\n elif load[0] == 'FY':\\n node.RxnFY[combo.name] -= load[1]*factor\\n elif load[0] == 'FZ':\\n node.RxnFZ[combo.name] -= load[1]*factor\\n elif load[0] == 'MX':\\n node.RxnMX[combo.name] -= load[1]*factor\\n elif load[0] == 'MY':\\n node.RxnMY[combo.name] -= load[1]*factor\\n elif load[0] == 'MZ':\\n node.RxnMZ[combo.name] -= load[1]*factor\\n \\n # Calculate reactions due to active spring supports at the node\\n elif node.spring_DX[0] != None and node.spring_DX[2] == True:\\n sign = node.spring_DX[1]\\n k = node.spring_DX[0]\\n if sign != None: k = float(sign + str(k))\\n DX = node.DX[combo.name]\\n node.RxnFX[combo.name] += k*DX\\n elif node.spring_DY[0] != None and node.spring_DY[2] == True:\\n sign = node.spring_DY[1]\\n k = node.spring_DY[0]\\n if sign != None: k = float(sign + str(k))\\n DY = node.DY[combo.name]\\n node.RxnFY[combo.name] += k*DY\\n elif node.spring_DZ[0] != None and node.spring_DZ[2] == True:\\n sign = node.spring_DZ[1]\\n k = node.spring_DZ[0]\\n if sign != None: k = float(sign + str(k))\\n DZ = node.DZ[combo.name]\\n node.RxnFZ[combo.name] += k*DZ\\n elif node.spring_RX[0] != None and node.spring_RX[2] == True:\\n sign = node.spring_RX[1]\\n k = node.spring_RX[0]\\n if sign != None: k = float(sign + str(k))\\n RX = node.RX[combo.name]\\n node.RxnMX[combo.name] += k*RX\\n elif node.spring_RY[0] != None and node.spring_RY[2] == True:\\n sign = node.spring_RY[1]\\n k = node.spring_RY[0]\\n if sign != None: k = float(sign + str(k))\\n RY = node.RY[combo.name]\\n node.RxnMY[combo.name] += k*RY\\n elif node.spring_RZ[0] != None and node.spring_RZ[2] == True:\\n sign = node.spring_RZ[1]\\n k = node.spring_RZ[0]\\n if sign != None: k = float(sign + str(k))\\n RZ = node.RZ[combo.name]\\n node.RxnMZ[combo.name] += k*RZ\",\n \"def train_models_change_nodes(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, beta, nodes, print_cost = True, is_charge = False):\\n \\n results = {}\\n params = {}\\n\\n try:\\n for n in nodes:\\n accs, parameters = model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate, iterations, minibatch_size, n, beta, 1.0, False, True, print_cost, is_charge)\\n \\n results[n] = accs[3]\\n params[n] = parameters\\n \\n except KeyboardInterrupt: # allow for exiting the for loop in case we want to stop testing all the hyperparameters; to use, press Ctrl+C in terminal\\n pass\\n \\n best = min(results, key=results.get)\\n mapes = [results[l] for l in nodes]\\n\\n if print_cost:\\n plt.plot(nodes, mapes)\\n plt.ylabel('MAPE')\\n plt.xlabel('# of nodes in hidden layer')\\n plt.title(\\\"learning rate = {}, mini-batch = {}, beta = {}\\\".format(learning_rate, minibatch_size, beta))\\n plt.show()\\n \\n return results, best, params[best]\",\n \"def run(self, model):\\n conv_nodes_list = self.get_conv_nodes(model)\\n\\n for conv_node in conv_nodes_list:\\n weights_node = nu.get_weights_for_node(conv_node)\\n weights = nu.get_node_value(weights_node)\\n ocs_weights, ocs_channels_idxs = self.split_weights(weights)\\n if self.add_input_channels_for_conv_node(conv_node, ocs_channels_idxs):\\n nu.set_node_value(weights_node, ocs_weights)\\n logger.debug('Node {}: Channels {} were splitted'.\\n format(conv_node.fullname, ','.join(str(idx) for idx in ocs_channels_idxs)))\\n\\n model.clean_up()\\n return model\",\n \"def reconcile(self):\\r\\n\\t\\tclass_A = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_G = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_koop = np.empty((self.basis.nK,self.basis.nK),float)\\r\\n\\t\\tclass_num = len(self.koop_cluster_list)\\r\\n\\t\\tfor i in range(class_num):\\r\\n\\t\\t\\tclass_mem_num = len(self.koop_cluster_list[i])\\r\\n\\t\\t\\tclass_counter = 0.0\\r\\n\\t\\t\\tfor j in range(class_mem_num):\\r\\n\\t\\t\\t\\tclass_A += (self.koop_cluster_list[i][j]._A*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\\r\\n\\t\\t\\t\\tclass_G += (self.koop_cluster_list[i][j]._G*self.koop_cluster_memb_prob_list[i][j])/float(class_mem_num)\\r\\n\\t\\t\\t\\tclass_counter += self.koop_cluster_list[i][j].counter\\r\\n\\t\\t\\tclass_koop = np.dot(np.linalg.pinv(class_G),class_A)\\r\\n\\t\\t\\tself.koopman_hybrid_modes.append(KoopmanOperator(self.basis, class_koop, class_A, class_G, class_counter))\",\n \"def reduce_ops(\\n config_path: str,\\n build_dir: str,\\n enable_type_reduction: bool,\\n use_cuda: bool,\\n is_extended_minimal_build_or_higher: bool,\\n):\\n build_dir_path = Path(build_dir).resolve()\\n build_dir_path.mkdir(parents=True, exist_ok=True)\\n\\n required_ops, op_type_impl_filter = parse_config(config_path, enable_type_reduction)\\n if is_extended_minimal_build_or_higher:\\n required_ops, op_type_impl_filter = _adapt_filters_for_extended_minimal_build(required_ops, op_type_impl_filter)\\n\\n # delete any existing generated files first\\n op_reduction_root = _get_op_reduction_root(build_dir_path)\\n if op_reduction_root.is_dir():\\n log.info(f\\\"Deleting existing op reduction file root directory: {op_reduction_root}\\\")\\n shutil.rmtree(op_reduction_root)\\n\\n _generate_provider_registrations(ORT_ROOT, build_dir_path, use_cuda, required_ops, op_type_impl_filter)\\n\\n type_control_cpp_code = op_type_impl_filter.get_cpp_entries() if op_type_impl_filter is not None else []\\n _generate_type_control_overrides(ORT_ROOT, build_dir_path, type_control_cpp_code)\",\n \"def compute(self, *args, **kwargs):\\n for node in self.evaluation_sequence:\\n node.evaluate()\",\n \"def _parse_requantization_ranges(self):\\n res = {}\\n\\n print_suffix = \\\"__print__\\\"\\n lines = self._get_valid_log()\\n temp_min = {}\\n temp_max = {}\\n pattern_def = r\\\"{};{}:\\\\[\\\\-?\\\\d+\\\\.?\\\\d*e?-?\\\\+?\\\\d*\\\\]\\\".format(print_suffix, self.postfix)\\n for i in lines:\\n if not re.search(pattern_def, i):\\n continue\\n\\n max_line_data = i.split(print_suffix + \\\";\\\" + self.postfix)[-1]\\n min_value = max_line_data.split('][')[0].split('[')[1]\\n max_value = max_line_data.split('][')[1].split(']')[0]\\n name = i.split(';')[1].strip()[:-len(print_suffix)]\\n if name not in temp_min:\\n temp_min[name] = []\\n if name not in temp_max:\\n temp_max[name] = []\\n\\n temp_min[name].append(float(min_value))\\n temp_max[name].append(float(max_value))\\n\\n for key in temp_min:\\n target_min_index = int(np.ceil(len(temp_min[key]) * (1 - self.threshold)))\\n\\n if key not in res:\\n res[key] = []\\n\\n if target_min_index > len(temp_min[key]) - 1:\\n target_min_index = len(temp_min[key]) - 1\\n res[key].append(sorted(temp_min[key])[target_min_index])\\n\\n for key in temp_max:\\n target_max_index = int(np.floor(len(temp_max[key]) * self.threshold)) - 1\\n\\n if target_max_index > len(temp_max[key]) - 1:\\n target_max_index = len(temp_max[key]) - 1\\n\\n res[key].append(sorted(temp_max[key])[target_max_index])\\n\\n if self.tensor_data:\\n for k, v in self.tensor_data.items():\\n if k in res:\\n self.logger.debug(\\\"Update node {} min to {}, max to {}.\\\".format(k, v[2], v[3]))\\n res[k] = [v[2], v[3]]\\n return res\",\n \"def compute_all(self) -> None:\\n self.compute_j_matrix()\\n self.compute_outter_distribution()\\n self.compute_max_prior()\\n self.compute_max_poutter()\",\n \"def res_net_model(features, labels, mode):\\n\\n # Configurations for each bottleneck group.\\n BottleneckGroup = namedtuple('BottleneckGroup',\\n ['num_blocks', 'num_filters', 'bottleneck_size'])\\n groups = [\\n BottleneckGroup(3, 128, 32), BottleneckGroup(3, 256, 64),\\n BottleneckGroup(3, 512, 128), BottleneckGroup(3, 1024, 256)\\n ]\\n\\n x = features[X_FEATURE]\\n input_shape = x.get_shape().as_list()\\n\\n # Reshape the input into the right shape if it's 2D tensor\\n if len(input_shape) == 2:\\n ndim = int(sqrt(input_shape[1]))\\n x = tf.reshape(x, [-1, ndim, ndim, 1])\\n\\n # First convolution expands to 64 channels\\n with tf.variable_scope('conv_layer1'):\\n net = tf.layers.conv2d(\\n x,\\n filters=64,\\n kernel_size=7,\\n activation=tf.nn.relu)\\n net = tf.layers.batch_normalization(net)\\n\\n # Max pool\\n net = tf.layers.max_pooling2d(\\n net, pool_size=3, strides=2, padding='same')\\n\\n # First chain of resnets\\n with tf.variable_scope('conv_layer2'):\\n net = tf.layers.conv2d(\\n net,\\n filters=groups[0].num_filters,\\n kernel_size=1,\\n padding='valid')\\n\\n # Create the bottleneck groups, each of which contains `num_blocks`\\n # bottleneck groups.\\n for group_i, group in enumerate(groups):\\n for block_i in range(group.num_blocks):\\n name = 'group_%d/block_%d' % (group_i, block_i)\\n\\n # 1x1 convolution responsible for reducing dimension\\n with tf.variable_scope(name + '/conv_in'):\\n conv = tf.layers.conv2d(\\n net,\\n filters=group.num_filters,\\n kernel_size=1,\\n padding='valid',\\n activation=tf.nn.relu)\\n conv = tf.layers.batch_normalization(conv)\\n\\n with tf.variable_scope(name + '/conv_bottleneck'):\\n conv = tf.layers.conv2d(\\n conv,\\n filters=group.bottleneck_size,\\n kernel_size=3,\\n padding='same',\\n activation=tf.nn.relu)\\n conv = tf.layers.batch_normalization(conv)\\n\\n # 1x1 convolution responsible for restoring dimension\\n with tf.variable_scope(name + '/conv_out'):\\n input_dim = net.get_shape()[-1].value\\n conv = tf.layers.conv2d(\\n conv,\\n filters=input_dim,\\n kernel_size=1,\\n padding='valid',\\n activation=tf.nn.relu)\\n conv = tf.layers.batch_normalization(conv)\\n\\n # shortcut connections that turn the network into its counterpart\\n # residual function (identity shortcut)\\n net = conv + net\\n\\n try:\\n # upscale to the next group size\\n next_group = groups[group_i + 1]\\n with tf.variable_scope('block_%d/conv_upscale' % group_i):\\n net = tf.layers.conv2d(\\n net,\\n filters=next_group.num_filters,\\n kernel_size=1,\\n padding='same',\\n activation=None,\\n bias_initializer=None)\\n except IndexError:\\n pass\\n\\n net_shape = net.get_shape().as_list()\\n net = tf.nn.avg_pool(\\n net,\\n ksize=[1, net_shape[1], net_shape[2], 1],\\n strides=[1, 1, 1, 1],\\n padding='VALID')\\n\\n net_shape = net.get_shape().as_list()\\n print(type(net_shape))\\n print(\\\"Length:\\\", len(net_shape))\\n net = tf.reshape(net, [-1, net_shape[1] * net_shape[2] * net_shape[3]])\\n print(type(net))\\n print(\\\"Length:\\\", tf.size(net))\\n\\n # Compute logits (1 per class) and compute loss.\\n logits = tf.layers.dense(net, N_DIGITS, activation=None)\\n\\n # Compute predictions.\\n predicted_classes = tf.argmax(logits, 1)\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n predictions = {\\n 'class': predicted_classes,\\n 'prob': tf.nn.softmax(logits)\\n }\\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\\n\\n#Loss Function define here -----------------------------------------------------\\n # Compute loss.\\n onehot_labels = tf.one_hot(tf.cast(labels, tf.int32), N_DIGITS, 1, 0)\\n print(\\\"type(onehot_labels):\\\", type(onehot_labels))\\n print(tf.shape(onehot_labels))\\n mynparray = onehot_labels.eval()\\n print (\\\"type(mynparray):\\\", type(mynparray))\\n loss = tf.losses.softmax_cross_entropy(\\n onehot_labels=onehot_labels, logits=logits)\",\n \"def _modify_cpu_questions(self, node, total_cpus, numa_nodes):\\n\\n print(\\n \\\"\\\\nYour system has {} core(s) and {} Numa Nodes.\\\".format(\\n total_cpus, len(numa_nodes)\\n )\\n )\\n print(\\n \\\"To begin, we suggest not reserving any cores for \\\"\\n \\\"VPP or other processes.\\\"\\n )\\n print(\\n \\\"Then to improve performance start reserving cores and \\\"\\n \\\"adding queues as needed.\\\"\\n )\\n\\n # Leave 1 for the general system\\n total_cpus -= 1\\n max_vpp_cpus = min(total_cpus, 4)\\n total_vpp_cpus = 0\\n if max_vpp_cpus > 0:\\n question = (\\n \\\"\\\\nHow many core(s) shall we reserve for \\\"\\n \\\"VPP [0-{}][0]? \\\".format(max_vpp_cpus)\\n )\\n total_vpp_cpus = self._ask_user_range(question, 0, max_vpp_cpus, 0)\\n node[\\\"cpu\\\"][\\\"total_vpp_cpus\\\"] = total_vpp_cpus\\n\\n total_other_cpus = 0\\n max_other_cores = total_cpus - total_vpp_cpus\\n if max_other_cores > 0:\\n question = (\\n \\\"How many core(s) do you want to reserve for \\\"\\n \\\"processes other than VPP? [0-{}][0]? \\\".format(str(max_other_cores))\\n )\\n total_other_cpus = self._ask_user_range(question, 0, max_other_cores, 0)\\n node[\\\"cpu\\\"][\\\"total_other_cpus\\\"] = total_other_cpus\\n\\n max_main_cpus = total_cpus - total_vpp_cpus - total_other_cpus\\n reserve_vpp_main_core = False\\n if max_main_cpus > 0:\\n question = \\\"Should we reserve 1 core for the VPP Main thread? \\\"\\n question += \\\"[y/N]? \\\"\\n answer = self._ask_user_yn(question, \\\"n\\\")\\n if answer == \\\"y\\\":\\n reserve_vpp_main_core = True\\n node[\\\"cpu\\\"][\\\"reserve_vpp_main_core\\\"] = reserve_vpp_main_core\\n node[\\\"cpu\\\"][\\\"vpp_main_core\\\"] = 0\\n\\n question = (\\n \\\"How many RX queues per port shall we use for \\\"\\n \\\"VPP [1-4][1]? \\\".format(max_vpp_cpus)\\n )\\n total_rx_queues = self._ask_user_range(question, 1, 4, 1)\\n node[\\\"cpu\\\"][\\\"total_rx_queues\\\"] = total_rx_queues\",\n \"def run_inference(self,isMax = 1,findZ = 0):\\r\\n# st=time.time()\\r\\n self.make_connected()\\r\\n self.nop = 0 # number of operations\\r\\n T=CliqueTree(self,isMax,findZ)\\r\\n if isMax == 0:\\r\\n self.marg_clique_tree = T\\r\\n elif isMax==1:\\r\\n self.MAP_clique_tree = T\\r\\n# print time.time()-st'=\\r\\n self.nop += T.nop\\r\\n M=[]\\r\\n for i in self.g.nodes(): # assuming nodes are labeled 0..N-1\\r\\n for s,data in T.nodes_iter(data=True):\\r\\n f = data['fac']\\r\\n if i in f.var:\\r\\n if isMax==0:\\r\\n dummy = f.Marginalize(scipy.setdiff1d(f.var,i))\\r\\n if findZ == 0:\\r\\n dummy.val = dummy.val/sum(dummy.val)\\r\\n else:\\r\\n dummy = f.MaxMarginalize(scipy.setdiff1d(f.var,i))\\r\\n self.nop += scipy.prod(f.card)\\r\\n M.append(dummy)\\r\\n break\\r\\n# print time.time()-st\\r\\n return M\",\n \"def _update_parallel_coef_constraints(self, x):\\n n_features = x.shape[1]\\n xi_final = np.zeros((n_features, n_features))\\n\\n # Todo: parallelize this for loop with Multiprocessing/joblib\\n if self.model_subset is None:\\n self.model_subset = range(n_features)\\n elif np.max(np.abs(self.model_subset)) >= n_features:\\n raise ValueError(\\n \\\"A value in model_subset is larger than the number \\\"\\n \\\"of features in the candidate library\\\"\\n )\\n for i in self.model_subset:\\n print(\\\"Model \\\", i)\\n xi = cp.Variable(n_features)\\n # Note that norm choice below must be convex,\\n # so thresholder must be L1 or L2\\n if (self.thresholder).lower() in (\\\"l1\\\", \\\"weighted_l1\\\"):\\n if self.thresholds is None:\\n cost = cp.sum_squares(x[:, i] - x @ xi) + self.threshold * cp.norm1(\\n xi\\n )\\n else:\\n cost = cp.sum_squares(x[:, i] - x @ xi) + cp.norm1(\\n self.thresholds[i, :] @ xi\\n )\\n if (self.thresholder).lower() in (\\\"l2\\\", \\\"weighted_l2\\\"):\\n if self.thresholds is None:\\n cost = (\\n cp.sum_squares(x[:, i] - x @ xi)\\n + self.threshold * cp.norm2(xi) ** 2\\n )\\n else:\\n cost = (\\n cp.sum_squares(x[:, i] - x @ xi)\\n + cp.norm2(self.thresholds[i, :] @ xi) ** 2\\n )\\n prob = cp.Problem(\\n cp.Minimize(cost),\\n [xi[i] == 0.0],\\n )\\n try:\\n prob.solve(\\n max_iter=self.max_iter,\\n eps_abs=self.tol,\\n eps_rel=self.tol,\\n verbose=self.verbose_cvxpy,\\n )\\n if xi.value is None:\\n warnings.warn(\\n \\\"Infeasible solve on iteration \\\"\\n + str(i)\\n + \\\", try changing your library\\\",\\n ConvergenceWarning,\\n )\\n xi_final[:, i] = xi.value\\n # Annoying error coming from L2 norm switching to use the ECOS\\n # solver, which uses \\\"max_iters\\\" instead of \\\"max_iter\\\", and\\n # similar semantic changes for the other variables.\\n except TypeError:\\n prob.solve(\\n max_iters=self.max_iter,\\n abstol=self.tol,\\n reltol=self.tol,\\n verbose=self.verbose_cvxpy,\\n )\\n if xi.value is None:\\n warnings.warn(\\n \\\"Infeasible solve on iteration \\\"\\n + str(i)\\n + \\\", try changing your library\\\",\\n ConvergenceWarning,\\n )\\n xi_final[:, i] = xi.value\\n except cp.error.SolverError:\\n print(\\\"Solver failed on model \\\", str(i), \\\", setting coefs to zeros\\\")\\n xi_final[:, i] = np.zeros(n_features)\\n return xi_final\",\n \"def maximize(self):\\n self.abstract_obj.maximize()\",\n \"def reduce_possibilities_by_box(self):\\n x = self.targetCell.x\\n y = self.targetCell.y\\n if x < 3 and y < 3: #top left\\n self.check_box1()\\n if x > 2 and x < 6 and y < 3: #middle left\\n self.check_box2()\\n if x > 5 and y < 3: #bottom left\\n self.check_box3()\\n if x < 3 and y > 2 and y < 6: #top middle\\n self.check_box4()\\n if x > 2 and x < 6 and y > 2 and y < 6: #center\\n self.check_box5()\\n if x > 5 and y > 2 and y < 6: #bottom middle\\n self.check_box6()\\n if x < 3 and y > 5: #top right\\n self.check_box7()\\n if x > 2 and x < 6 and y > 5: #middle right\\n self.check_box8()\\n if x > 5 and y > 5: #bottom right\\n self.check_box9()\\n self.targetCell.box_neighbour_possibilities = flatten_list(self.targetCell.box_neighbour_possibilities)\",\n \"def compute(self):\\n if self.computed:\\n return self.classifications\\n\\n self.partial_compute()\\n\\n self.classifications = []\\n classify_network = Network([ArgMaxLayer()])\\n for pre, post in self.transformed_lines:\\n # First, we take each of the linear regions and split them where\\n # the ArgMax changes.\\n lines = list(zip(post[:-1], post[1:]))\\n classify_transformed_lines = classify_network.exactlines(\\n lines, compute_preimages=False, include_post=False)\\n\\n split_pre = []\\n split_post = []\\n for i, endpoints in enumerate(classify_transformed_lines):\\n pre_delta = pre[i + 1] - pre[i]\\n post_delta = post[i + 1] - post[i]\\n for point_ratio in endpoints:\\n point_pre = pre[i] + (point_ratio * pre_delta)\\n point_post = post[i] + (point_ratio * post_delta)\\n if i == 0 or not point_ratio == 0.0:\\n split_pre.append(point_pre)\\n split_post.append(point_post)\\n\\n # Now, in each of the resulting regions, we compute the\\n # corresponding label.\\n region_labels = []\\n for i in range(len(split_pre) - 1):\\n mid_post = 0.5 * (split_post[i] + split_post[i + 1])\\n region_labels.append(np.argmax(mid_post))\\n\\n # Finally, we merge segments with the same classification.\\n merged_pre = []\\n merged_labels = []\\n for i, label in enumerate(region_labels):\\n if not merged_labels or label != merged_labels[-1]:\\n merged_pre.append(split_pre[i])\\n merged_labels.append(label)\\n merged_pre.append(split_pre[-1])\\n regions = list(zip(merged_pre[:-1], merged_pre[1:]))\\n self.classifications.append((regions, merged_labels))\\n self.computed = True\\n return self.classifications\",\n \"def calculate_ucb_max(self, node):\\n pass\",\n \"def include_compression(nets, compression='none', linear_max=796.87416837456942, input_node_name='cochleagram_no_compression', output_node_name='cochleagram', linear_params=None, rate_level_kwargs={}, custom_compression_op=None):\\n # compression of the cochleagram\\n if compression=='quarter':\\n nets[output_node_name] = tf.sqrt(tf.sqrt(nets[input_node_name], name=output_node_name))\\n elif compression=='quarter_plus':\\n nets[output_node_name] = tf.sqrt(tf.sqrt(nets[input_node_name]+1e-01, name=output_node_name))\\n elif compression=='point3':\\n nets[output_node_name] = tf.pow(nets[input_node_name],0.3, name=output_node_name)\\n elif compression=='stable_point3':\\n nets[output_node_name] = tf.identity(stable_power_compression(nets[input_node_name]*linear_max),name=output_node_name) \\n elif compression=='stable_point3_norm_grads':\\n nets[output_node_name] = tf.identity(stable_power_compression_norm_grad(nets[input_node_name]*linear_max),name=output_node_name) \\n elif compression=='linearbelow1':\\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, tf.pow(nets[input_node_name]*linear_max,0.3), name=output_node_name)\\n elif compression=='stable_linearbelow1':\\n nets['stable_power_compressed_%s'%output_node_name] = tf.identity(stable_power_compression(nets[input_node_name]*linear_max),name='stable_power_compressed_%s'%output_node_name)\\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, nets['stable_power_compressed_%s'%output_node_name], name=output_node_name)\\n elif compression=='linearbelow1sqrt':\\n nets[output_node_name] = tf.where((nets[input_node_name]*linear_max)<1, nets[input_node_name]*linear_max, tf.sqrt(nets[input_node_name]*linear_max), name=output_node_name)\\n elif compression=='quarter_clipped':\\n nets[output_node_name] = tf.sqrt(tf.sqrt(tf.maximum(nets[input_node_name],1e-01), name=output_node_name))\\n elif compression=='none':\\n nets[output_node_name] = nets[input_node_name]\\n elif compression=='sqrt':\\n nets[output_node_name] = tf.sqrt(nets[input_node_name], name=output_node_name)\\n elif compression=='dB': # NOTE: this compression does not work well for the backwards pass, results in nans\\n nets[output_node_name + '_noclipped'] = 20 * tflog10(nets[input_node_name])/tf.reduce_max(nets[input_node_name])\\n nets[output_node_name] = tf.maximum(nets[output_node_name + '_noclipped'], -60)\\n elif compression=='dB_plus': # NOTE: this compression does not work well for the backwards pass, results in nans\\n nets[output_node_name + '_noclipped'] = 20 * tflog10(nets[input_node_name]+1)/tf.reduce_max(nets[input_node_name]+1)\\n nets[output_node_name] = tf.maximum(nets[output_node_name + '_noclipped'], -60, name=output_node_name)\\n elif compression=='linear':\\n assert (type(linear_params)==list) and len(linear_params)==2, \\\"Specifying linear compression but not specifying the compression parameters in linear_params=[m, b]\\\"\\n nets[output_node_name] = linear_params[0]*nets[input_node_name] + linear_params[1]\\n elif compression=='rate_level':\\n nets[output_node_name] = AN_rate_level_function(nets[input_node_name], name=output_node_name, **rate_level_kwargs)\\n elif compression=='custom':\\n nets[output_node_name] = custom_compression_op(nets[input_node_name], name=output_node_name)\\n\\n return nets\",\n \"def test_multiple_input_model_get_op_product_graph(self):\\n\\n tf.compat.v1.reset_default_graph()\\n _ = multiple_input_model()\\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), ['input1', 'input2'], ['multiple_input_model/Softmax'])\\n self.assertTrue(validate_branch_ops(conn_graph))\\n self.assertTrue(validate_product_tensor_lists(conn_graph))\\n self.assertEqual(0, conn_graph.branch_count)\\n self.assertEqual(9, len(conn_graph.get_all_ops()))\\n self.assertEqual(8 + len(tf.compat.v1.get_default_graph().get_collection('variables')),\\n len(conn_graph.get_all_products()))\\n self.assertTrue(conn_graph.get_all_ops()['input1'].output.is_model_input)\\n self.assertTrue(conn_graph.get_all_ops()['input2'].output.is_model_input)\",\n \"def _assign_reg_vals(self, sess):\\n with self.graph.as_default():\\n for nn in range(self.num_networks):\\n self.networks[nn].assign_reg_vals(sess)\",\n \"def train(self):\\n max_tuple = self.max_gain()\\n # If that gain is 0 then every node should be a pure leaf (hopefully) and you can stop\\n while max_tuple.gain != 0:\\n max_tuple.node.split(max_tuple.attribute)\\n max_tuple = self.max_gain()\",\n \"def convert_pooling(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n kernel = eval(attrs[\\\"kernel\\\"])\\n pool_type = attrs[\\\"pool_type\\\"] if attrs.get(\\\"pool_type\\\") else \\\"max\\\"\\n stride = eval(attrs[\\\"stride\\\"]) if attrs.get(\\\"stride\\\") else (1, 1)\\n global_pool = get_boolean_attribute_value(attrs, \\\"global_pool\\\")\\n p_value = attrs.get('p_value', 'None')\\n\\n pooling_convention = attrs.get('pooling_convention', 'valid')\\n ceil_mode = False\\n if pooling_convention == 'full':\\n if onnx.__version__ < \\\"1.5.0\\\":\\n pooling_warning = \\\"Pooling: ONNX lower than 1.5.0 doesn't support pooling_convention. \\\" \\\\\\n \\\"This might lead to shape or accuracy issues. \\\" \\\\\\n \\\"https://github.com/onnx/onnx/issues/549\\\"\\n ceil_mode = True\\n logging.warning(pooling_warning)\\n\\n pad_dims = list(parse_helper(attrs, \\\"pad\\\", [0, 0]))\\n pad_dims = pad_dims + pad_dims\\n pool_types = {\\\"max\\\": \\\"MaxPool\\\", \\\"avg\\\": \\\"AveragePool\\\", \\\"lp\\\": \\\"LpPool\\\"}\\n global_pool_types = {\\\"max\\\": \\\"GlobalMaxPool\\\", \\\"avg\\\": \\\"GlobalAveragePool\\\",\\n \\\"lp\\\": \\\"GlobalLpPool\\\"}\\n\\n if pool_type == 'lp' and p_value == 'None':\\n raise AttributeError('ONNX requires a p value for LpPool and GlobalLpPool')\\n\\n if global_pool:\\n if pool_type == 'lp':\\n node = onnx.helper.make_node(\\n global_pool_types[pool_type],\\n input_nodes, # input\\n [name],\\n p=int(p_value),\\n name=name\\n )\\n else:\\n node = onnx.helper.make_node(\\n global_pool_types[pool_type],\\n input_nodes, # input\\n [name],\\n name=name\\n )\\n else:\\n if pool_type == 'lp':\\n node = onnx.helper.make_node(\\n pool_types[pool_type],\\n input_nodes, # input\\n [name],\\n p=int(p_value),\\n kernel_shape=kernel,\\n pads=pad_dims,\\n strides=stride,\\n name=name\\n )\\n else:\\n if onnx.__version__ >= \\\"1.5.0\\\":\\n node = onnx.helper.make_node(\\n pool_types[pool_type],\\n input_nodes, # input\\n [name],\\n kernel_shape=kernel,\\n pads=pad_dims,\\n strides=stride,\\n name=name,\\n ceil_mode=ceil_mode\\n )\\n else:\\n node = onnx.helper.make_node(\\n pool_types[pool_type],\\n input_nodes, # input\\n [name],\\n kernel_shape=kernel,\\n pads=pad_dims,\\n strides=stride,\\n name=name\\n )\\n\\n return [node]\",\n \"def run1(self, eval_node , feed_dict = {}):\\r\\n self.eval_node_list = eval_node \\r\\n for i in feed_dict:\\r\\n feed_dict[i] = np.array(feed_dict[i]).astype(i.dtype)\\r\\n #print(self.eval_node_list)\\r\\n node_to_val_map = dict(feed_dict)\\r\\n # Traverse graph in topological sort order and compute values for all nodes.\\r\\n topo_start_node = []\\r\\n for node in self.eval_node_list:\\r\\n if isinstance(node,Node):\\r\\n topo_start_node.append(node)\\r\\n if topo_start_node==[]:\\r\\n return eval_node\\r\\n topo_order = find_topo_sort(topo_start_node)\\r\\n \\r\\n \\\"\\\"\\\"TODO: Your code here\\\"\\\"\\\"\\r\\n for node in topo_order :\\r\\n if isinstance(node.op, PlaceholderOp):\\r\\n if not(node in node_to_val_map) and (node in global_variables):\\r\\n node_to_val_map[node] = global_variables[node]\\r\\n continue \\r\\n if not(node in node_to_val_map):\\r\\n input_vals1=[]\\r\\n for inp in node.inputs:\\r\\n input_vals1.append( node_to_val_map[inp] )\\r\\n #print(input_vals1)\\r\\n node_to_val_map[node] = node.op.compute(node, input_vals1)\\r\\n # Collect node values.\\r\\n node_val_results = []\\r\\n for node in self.eval_node_list:\\r\\n if isinstance(node, Node):\\r\\n node_val_results.append(node_to_val_map[node])\\r\\n else:\\r\\n node_val_results.append(node)\\r\\n #node_val_results = [node_to_val_map[node] for node in self.eval_node_list]\\r\\n return node_val_results\",\n \"def experiment1_outliers():\\n\\tdata_folder = \\\"ckan_subset/prepared_learnset/\\\"\\n\\ttest_folder = 'ckan_subset/testset/xml_csv/'\\n\\tgm = Graph_Maker()\\n\\tgm.store()\\n\\trounds = 5\\n\\tx = [\\\"Fingerprint\\\", \\\"Syntax Feature Model\\\", \\\"Word2Vec Matcher\\\"]\\n\\t\\n\\tnumber_of_classes = 15\\n\\texamples_per_class = 0\\n\\taccuracies = []\\n\\tprecisions = []\\n\\trecalls = []\\n\\tfmeasures = []\\n\\tsf_main = Storage_Files(data_folder, classes)\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"Fingerprint\\\")\\n\\t\\t# --- Fingerprint\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Fingerprint', [sf_main, number_of_classes, examples_per_class, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Fingerprint_Matcher', {'feature_main': 'fingerprint'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\t\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"SFM\\\")\\n\\t\\t# --- Syntax Feature Model\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Syntax_Feature_Model', [sf_main, 1, 0, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Syntax_Matcher', {'feature_main': 'syntax'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\n\\ttmp_acc = []\\n\\ttmp_prec = []\\n\\ttmp_rec = []\\n\\ttmp_fmeasure = []\\n\\ttotal_actual = []\\n\\ttotal_predicted = []\\n\\tfor i in range(0, rounds):\\n\\t\\tprint(\\\"W2V\\\")\\n\\t\\t# --- Word2Vec Matcher\\n\\t\\tccc = Column_Classification_Config()\\n\\t\\tccc.add_feature('feature_main', 'Corpus', [sf_main, number_of_classes, examples_per_class, False, False])\\n\\n\\t\\tccc.add_matcher('matcher', 'Word2Vec_Matcher', {'feature_main': 'corpus'}) # main classifier\\n\\t\\tsm = Schema_Matcher(ccc)\\n\\t\\tactual, predicted = execute_test_ckan(sm, test_folder, False)\\n\\t\\ttotal_actual += actual\\n\\t\\ttotal_predicted += predicted\\n\\t\\taccuracy = accuracy_score(actual, predicted)\\n\\t\\ttmp_acc.append(accuracy)\\n\\t\\ttmp_prec.append(precision(actual, predicted))\\n\\t\\ttmp_rec.append(recall(actual, predicted))\\n\\t\\ttmp_fmeasure.append(f_measure(actual, predicted))\\n\\n\\taccuracies.append( round(sum(tmp_acc) / float(rounds), 2) )\\n\\tprecisions.append( round(sum(tmp_prec) / float(rounds), 2) )\\n\\trecalls.append( round(sum(tmp_rec) / float(rounds), 2) )\\n\\tfmeasures.append(round(sum(tmp_fmeasure) / float(rounds), 2))\\n\\tclassnames = list(set(get_class_names(total_actual) + get_class_names(total_predicted)))\\n\\tcm = confusion_matrix(total_actual, total_predicted, labels=classnames)\\n\\t#gm.plot_confusion_matrix(cm, classnames, normalize=True)\\n\\n\\tgm.add_x(x)\\n\\t# accuracies = [0.4, 0.4, 0.4]\\n\\t# precisions = [0.5, 0.5, 0.5]\\n\\t# recalls = [0.62, 0.62, 0.62]\\n\\t# fmeasures = [0.23, 0.23, 0.28]\\n\\tgm.append_y(accuracies)\\n\\tgm.append_y(precisions)\\n\\tgm.append_y(recalls)\\n\\tgm.append_y(fmeasures)\\n\\tgm.store()\\n\\tsubtitle = \\\"Scores were averaged over \\\" + str(rounds) + \\\" tests with \\\" + str(len(classes)) + \\\" classes. \\\" + \\\\\\n\\t\\\"Number of simulated columns per class: \\\" + str(number_of_classes)\\n\\tlabels = [\\\"Accuracy\\\", \\\"Precision\\\", \\\"Recall\\\", \\\"F-Measure\\\"]\\n\\tgm.plot_bar_n(\\\"Matcher Type\\\", \\\"Score\\\", \\\"Accuracy of Matchers\\\", labels, subtitle=subtitle)\",\n \"def __init__(self, input_shape, action_shape, net_conf, minval=-1, maxval=1, val_buffer=1e-6):\\n\\n super().__init__()\\n\\n self.minval = minval\\n self.maxval = maxval\\n self.replace_min = minval+val_buffer\\n\\n #initialize weights\\n initializer = initializers.RandomUniform(minval=minval, maxval=maxval)\\n \\n self.action_shape = action_shape\\n\\n self.add(keras.Input(shape=input_shape))\\n for conv in net_conf['conv_layer_params']:\\n self.add(layers.Conv2D(\\n conv[0],\\n conv[1],\\n conv[2],\\n activation=net_conf['conv_activation'],\\n kernel_initializer=initializer,\\n bias_initializer=initializer))\\n self.add(layers.Flatten())\\n for full in net_conf['fc_layer_params']:\\n self.add(layers.Dense(\\n full,\\n activation=net_conf['fc_activation'],\\n kernel_initializer=initializer,\\n bias_initializer=initializer))\\n self.add(layers.Dense(\\n action_shape,\\n activation=None,\\n kernel_initializer=initializer,\\n bias_initializer=initializer))\\n self.build()\",\n \"def build_candidates(allowed_nodes=[identity], best_candidates=[], nb_candidates=200):\\n new_candidates = []\\n length_limit = 4 # Maximal length of a program\\n def random_node():\\n return random.choice(allowed_nodes)\\n\\n # Until we have enough new candidates\\n while (len(new_candidates) < nb_candidates):\\n # Add 10 new programs\\n for i in range(5):\\n new_candidates += [[random_node()]]\\n\\n # Create new programs based on each best candidate\\n for best_program in best_candidates:\\n # Add one op on its right but limit the length of the program\\n if len(best_program) < length_limit - 1:\\n new_candidates += [[random_node()] + best_program]\\n # Add one op on its left but limit the length of the program\\n if len(best_program) < length_limit - 1:\\n new_candidates += [best_program + [random_node()]]\\n # Mutate one instruction of the existing program\\n new_candidates += [list(best_program)]\\n new_candidates[-1][random.randrange(0, len(best_program))] = random_node()\\n\\n # Truncate if we have too many candidates\\n np.random.shuffle(new_candidates)\\n return new_candidates[:nb_candidates]\",\n \"def Q_global_checkers(s_grid, s_n, g_n, a_n, s_others, a_others, t_obs, v_obs,\\n f1=4, k1=[3,5], f2=6, k2=[3,3], n_h1_1=128, n_h1_2=32,\\n n_h2=32, n_actions=5, stage=1, bias=True):\\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\\n concated = tf.concat( [conv, s_n, g_n, a_n, conv_o, v_obs], axis=1 )\\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\\n W_branch1_h2 = get_variable(\\\"W_branch1_h2\\\", [n_h1_1, n_h2])\\n\\n list_mult = []\\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\\n\\n if stage > 1:\\n n_others = a_others.get_shape().as_list()[1]\\n a_others_reshaped = tf.reshape(a_others, [-1, n_others*n_actions])\\n with tf.variable_scope(\\\"stage-2\\\"):\\n concated2 = tf.concat( [s_others, a_others_reshaped], axis=1 )\\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\\n list_mult.append(tf.matmul(others, W_branch2_h2))\\n\\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\\n \\n return out\",\n \"def compute(self, data, input_type='points', output_type='probability'):\\n output = []\\n\\n for vector in data:\\n # calculating output for every vector\\n for v, node in zip(vector, self.input_nodes):\\n node.set_value(v)\\n\\n result = [node.get_value() for node in self.output_nodes]\\n\\n result = np.array(result)\\n if output_type == 'probability':\\n if len(result) > 1:\\n # softmax calculation, multi class probability distribution\\n x = result\\n e_x = np.exp(x - np.max(x))\\n\\n result = e_x / e_x.sum()\\n else:\\n # sigmoid calculation, probability\\n x = result\\n x = np.clip(x, -500, 500)\\n result = 1 / (1 + np.exp(-x))\\n\\n output.append(result)\\n\\n # reset nodes\\n for node in self.nodes:\\n node.reset()\\n if input_type == 'points':\\n node.past_value = 0\\n\\n return output\",\n \"def get_optimums(self, model, size, excludes):\\n raise NotImplementedError\",\n \"def run_reduce(self):\\n from histogram import add_and_save\\n root_file = TFile(self.args.output, \\\"RECREATE\\\")\\n add_and_save(self.output, root_file)\\n root_file.Write()\\n root_file.Close()\",\n \"def compute_model(self, A_on_basis_vec_handles, B_on_standard_basis_handles,\\n C_on_basis_vecs):\\n self.reduce_A(A_on_basis_vec_handles)\\n self.reduce_B(B_on_standard_basis_handles)\\n self.reduce_C(C_on_basis_vecs)\\n return self.A_reduced, self.B_reduced, self.C_reduced\",\n \"def _create_reduceOp(cls, op, op_t):\\n node = cls._common_singa_tensor_to_onnx_node(op, op_t)\\n\\n node.attribute.extend([\\n helper.make_attribute('axes', list(op.axes)),\\n helper.make_attribute('keepdims', op.keepdims),\\n ])\\n return node\",\n \"def _add_all_odes_to_interface(self):\\n comp = self.get_interface_component()\\n for var in self.model.find_state_vars():\\n if var.component is not comp:\\n self.add_input(var, var.get_units())\",\n \"def build_graph(self):\\n n_classes = self.n_classes\\n\\n (self.feed('data')\\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\\n .conv(3, 3, 256, 1, 1, name='conv3_1')\\n .conv(3, 3, 256, 1, 1, name='conv3_2')\\n .conv(3, 3, 256, 1, 1, name='conv3_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\\n .conv(3, 3, 512, 1, 1, name='conv4_1')\\n .conv(3, 3, 512, 1, 1, name='conv4_2')\\n .conv(3, 3, 512, 1, 1, name='conv4_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\\n .conv(3, 3, 512, 1, 1, name='conv5_1')\\n .conv(3, 3, 512, 1, 1, name='conv5_2')\\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\\n\\n self.compute_rDeRF() # dummy\\n\\n # Classification\\n (self.feed('conv5_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\\n .fc(4096, name='fc6')\\n .dropout(0.5, name='drop6')\\n .fc(4096, name='fc7')\\n .dropout(0.5, name='drop7')\\n # .make_time(name='drop7_reduced')\\n .fc(n_classes, relu=False, name='cls_score')\\n .softmax(name='cls_prob'))\\n pass\",\n \"def __init__(self, temperature: float, crops_for_assign: tuple, nmb_crops: tuple, sinkhorn_iterations: int, epsilon: float, gpus: int, num_nodes: int):\\n super().__init__()\\n self.temperature = temperature\\n self.crops_for_assign = crops_for_assign\\n self.softmax = nn.Softmax(dim=1)\\n self.sinkhorn_iterations = sinkhorn_iterations\\n self.epsilon = epsilon\\n self.nmb_crops = nmb_crops\\n self.gpus = gpus\\n self.num_nodes = num_nodes\\n if self.gpus * self.num_nodes > 1:\\n self.assignment_fn = self.distributed_sinkhorn\\n else:\\n self.assignment_fn = self.sinkhorn\",\n \"def Q_credit_sumo(s_n, g_n, a_m, s_m, s_others, g_others,\\n n_h1_1=256, n_h1_2=128, n_h2=256,\\n activation=tf.nn.relu, stage=2, bias=True):\\n concated = tf.concat( [s_n, g_n, a_m], axis=1 )\\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=activation, use_bias=bias, name='Q_branch1')\\n W_branch1_h2 = get_variable(\\\"W_branch1_h2\\\", [n_h1_1, n_h2])\\n\\n list_mult = []\\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\\n\\n if stage > 1:\\n with tf.variable_scope(\\\"stage-2\\\"):\\n # concated2 = tf.concat( [s_m, s_others, g_others], axis=1 )\\n concated2 = tf.concat( [s_m, s_others], axis=1 ) # original\\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=activation, use_bias=bias, name='Q_branch2')\\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\\n list_mult.append(tf.matmul(others, W_branch2_h2))\\n\\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\\n \\n return out\",\n \"def Compute_EdgeBoxesAndCNN_features(demonet='res152',nms_thresh = 0.7,database='IconArt_v1',\\n augmentation=False,L2 =False,\\n saved='all',verbose=True,filesave='tfrecords',k_regions=300,\\n testMode=False,plotProposedBoxes=False):\\n\\n path_data = '/media/gonthier/HDD/output_exp/ClassifPaintings/'\\n path_imgs = path_data + 'EdgeBoxesIllust/'+database +'/'\\n \\n if plotProposedBoxes:\\n print(\\\"We will only plot the regions of the EdgeBoxes with k_regions = \\\",k_regions,path_imgs)\\n pathlib.Path(path_imgs).mkdir(parents=True, exist_ok=True) \\n \\n item_name,path_to_img,default_path_imdb,classes,ext,num_classes,str_val,df_label,\\\\\\n path_data,Not_on_NicolasPC = get_database(database)\\n \\n if augmentation:\\n raise NotImplementedError\\n N = 50\\n else: \\n N=1\\n if L2:\\n raise NotImplementedError\\n extL2 = '_L2'\\n else:\\n extL2 = ''\\n if saved=='all':\\n savedstr = '_all'\\n elif saved=='fc7':\\n savedstr = ''\\n elif saved=='pool5':\\n savedstr = '_pool5'\\n \\n tf.reset_default_graph() # Needed to use different nets one after the other\\n if verbose: print('=== EdgeBoxes net',demonet,'database',database,' ===')\\n \\n if demonet=='res152':\\n weights_path = '/media/gonthier/HDD/models/resnet152_weights_tf.h5'\\n model = resnet_152_keras.resnet152_model_2048output(weights_path)\\n num_features = 2048\\n else:\\n raise(NotImplementedError)\\n tfconfig = tf.ConfigProto(allow_soft_placement=True)\\n tfconfig.gpu_options.allow_growth=True\\n # init session\\n# sess = tf.Session(config=tfconfig)\\n \\n features_resnet_dict= {}\\n \\n sets = ['train','val','trainval','test']\\n \\n if filesave == 'pkl':\\n name_pkl_all_features = path_data+'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+'.pkl'\\n pkl = open(name_pkl_all_features, 'wb')\\n elif filesave =='tfrecords':\\n if k_regions==300:\\n k_per_bag_str = ''\\n else:\\n k_per_bag_str = '_k'+str(k_regions)\\n dict_writers = {}\\n for set_str in sets:\\n name_pkl_all_features = path_data\\n if testMode: name_pkl_all_features+= 'TestMode_'\\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\\n dict_writers[set_str] = tf.python_io.TFRecordWriter(name_pkl_all_features)\\n \\n model_edgeboxes = 'model/model.yml'\\n print('Need of pip install opencv-contrib-python')\\n edge_detection = cv2.ximgproc.createStructuredEdgeDetection(model_edgeboxes)\\n \\n number_of_regions = []\\n Itera = 1000\\n if testMode:\\n Itera = 1\\n for i,name_img in enumerate(df_label[item_name]):\\n if testMode and i>1:\\n break\\n if filesave=='pkl':\\n if not(k_regions==300):\\n raise(NotImplementedError)\\n if i%Itera==0:\\n if verbose : print(i,name_img)\\n if not(i==0):\\n pickle.dump(features_resnet_dict,pkl) # Save the data\\n features_resnet_dict= {}\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\\\\n 'WikiLabels1000training','CASPApaintings']:\\n complet_name = path_to_img + name_img + '.jpg'\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n\\n if plotProposedBoxes:\\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\\n number_of_regions += [len(list_im)]\\n fc7 = model.predict(list_im)\\n # Need a BGR and between 0 and 255 minus the mean per color \\n \\n roi_scores = np.ones((len(list_im,)))\\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\\n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\\n if saved=='fc7':\\n features_resnet_dict[name_img] = fc7\\n# elif saved=='pool5':\\n# features_resnet_dict[name_img] = pool5\\n elif saved=='all':\\n features_resnet_dict[name_img] = rois,roi_scores,fc7\\n \\n elif filesave=='tfrecords':\\n if i%Itera==0:\\n if verbose : print(i,name_img)\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings','watercolor'\\\\\\n ,'CASPApaintings','WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training']:\\n complet_name = path_to_img + name_img + '.jpg'\\n name_sans_ext = name_img\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n\\n im = cv2.imread(complet_name)\\n \\n height = im.shape[0]\\n width = im.shape[1]\\n\\n if plotProposedBoxes:\\n plot_im_withBoxes(complet_name,edge_detection,k_regions,path_imgs)\\n list_im, rois = get_crops(complet_name,edge_detection,k_regions,demonet,augmentation=False)\\n # Boxes are x, y, w, h\\n number_of_regions += [len(list_im)]\\n fc7 = model.predict(list_im)\\n roi_scores = np.ones((len(list_im,)))\\n# cls_score, cls_prob, bbox_pred, rois,roi_scores, fc7,pool5 = TL_im_detect(sess, net, im) # Arguments: im (ndarray): a color image in BGR order\\n \\n if testMode:\\n print('Image :',height,width)\\n print('Normally ROI (x1,x2,y1,y2) :')\\n print(rois)\\n \\n if(len(fc7) >= k_regions):\\n rois = rois[0:k_regions,:]\\n roi_scores =roi_scores[0:k_regions,]\\n fc7 = fc7[0:k_regions,:]\\n else:\\n number_repeat = k_regions // len(fc7) +1\\n f_repeat = np.repeat(fc7,number_repeat,axis=0)\\n roi_scores_repeat = np.repeat(roi_scores,number_repeat,axis=0)\\n rois_repeat = np.repeat(rois,number_repeat,axis=0)\\n rois = rois_repeat[0:k_regions,:]\\n roi_scores =roi_scores_repeat[0:k_regions,]\\n fc7 = f_repeat[0:k_regions,:]\\n num_regions = fc7.shape[0]\\n num_features = fc7.shape[1]\\n dim1_rois = rois.shape[1]\\n classes_vectors = np.zeros((num_classes,1),dtype=np.float32)\\n \\n if database=='Paintings':\\n for j in range(num_classes):\\n if(classes[j] in df_label['classe'][i]):\\n classes_vectors[j] = 1\\n if database in ['VOC2007','clipart','watercolor','comic','PeopleArt','CASPApaintings']:\\n for j in range(num_classes):\\n value = int((int(df_label[classes[j]][i])+1.)/2.)\\n # En fait ce qui se passe la c'est que tu rescale a la sauvage \\n # entre 0 et 1 un truc qui peut etre entre 0 et 1 mais aussi entre -1 et 1\\n # C'est chelou\\n classes_vectors[j] = value\\n if database in ['WikiTenLabels','MiniTrain_WikiTenLabels','WikiLabels1000training','IconArt_v1']:\\n for j in range(num_classes):\\n value = int(df_label[classes[j]][i])\\n classes_vectors[j] = value\\n \\n #features_resnet_dict[name_img] = fc7[np.concatenate(([0],np.random.randint(1,len(fc7),29))),:]\\n if saved=='fc7':\\n print('It is possible that you need to replace _bytes_feature by _floats_feature in this function')\\n print('!!!!!!!!!!!!!!!!!!!!!')\\n raise(NotImplementedError)\\n # TODO : modifier cela !\\n features=tf.train.Features(feature={\\n 'height': _int64_feature(height),\\n 'width': _int64_feature(width),\\n 'num_regions': _int64_feature(num_regions),\\n 'num_features': _int64_feature(num_features),\\n 'fc7': _bytes_feature(tf.compat.as_bytes(fc7.tostring())),\\n 'label' : _bytes_feature(tf.compat.as_bytes(classes_vectors.tostring())),\\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))})\\n elif saved=='pool5':\\n raise(NotImplementedError)\\n elif saved=='all':\\n feature={\\n 'height': _int64_feature(height),\\n 'width': _int64_feature(width),\\n 'num_regions': _int64_feature(num_regions),\\n 'num_features': _int64_feature(num_features),\\n 'dim1_rois': _int64_feature(dim1_rois),\\n 'rois': _floats_feature(rois),\\n 'roi_scores': _floats_feature(roi_scores),\\n 'fc7': _floats_feature(fc7),\\n 'label' : _floats_feature(classes_vectors),\\n 'name_img' : _bytes_feature(str.encode(name_sans_ext))}\\n features=tf.train.Features(feature=feature)\\n example = tf.train.Example(features=features) \\n# print(len(feature['rois']))\\n if database=='VOC2007' or database=='PeopleArt':\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='val').any():\\n dict_writers['val'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n if (database=='Wikidata_Paintings_miniset') or database=='Paintings':\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='validation').any():\\n dict_writers['val'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n if database in ['IconArt_v1','watercolor','clipart','comic','WikiTenLabels',\\\\\\n 'MiniTrain_WikiTenLabels','WikiLabels1000training','CASPApaintings']:\\n if (df_label.loc[df_label[item_name]==name_img]['set']=='train').any():\\n dict_writers['train'].write(example.SerializeToString())\\n dict_writers['trainval'].write(example.SerializeToString())\\n elif (df_label.loc[df_label[item_name]==name_img]['set']=='test').any():\\n dict_writers['test'].write(example.SerializeToString())\\n \\n if filesave=='pkl':\\n pickle.dump(features_resnet_dict,pkl)\\n pkl.close()\\n elif filesave=='tfrecords':\\n for set_str in sets:\\n dict_writers[set_str].close()\\n \\n print('Mean number of regions per image :',np.mean(number_of_regions),'with k max = ',k_regions)\\n \\n tf.reset_default_graph()\\n \\n if testMode:\\n sets = ['train','test','trainval','val']\\n dim_rois = 4\\n for set_str in sets:\\n name_pkl_all_features = path_data\\n if testMode: name_pkl_all_features+= 'TestMode_'\\n name_pkl_all_features += 'EdgeBoxes_'+ demonet +'_'+database+'_N'+str(N)+extL2+'_TLforMIL_nms_'+str(nms_thresh)+savedstr+k_per_bag_str+'_'+set_str+'.tfrecords'\\n print(name_pkl_all_features)\\n if set_str=='train':\\n train_dataset = tf.data.TFRecordDataset(name_pkl_all_features)\\n sess = tf.Session()\\n train_dataset = train_dataset.map(lambda r: parser_w_rois_all_class(r, \\\\\\n num_classes=num_classes,with_rois_scores=True,num_features=num_features,\\n num_rois=k_regions,dim_rois=dim_rois))\\n mini_batch_size = 1\\n dataset_batch = train_dataset.batch(mini_batch_size)\\n dataset_batch.cache()\\n iterator = dataset_batch.make_one_shot_iterator()\\n next_element = iterator.get_next()\\n print(next_element)\\n nx = sess.run(next_element)\\n print(nx)\\n name_img = nx[-1][0].decode('utf8')\\n if database in ['IconArt_v1','VOC2007','clipart','comic','Paintings',\\\\\\n 'watercolor','WikiTenLabels','MiniTrain_WikiTenLabels',\\\\\\n 'WikiLabels1000training','CASPApaintings']:\\n complet_name = path_to_img + name_img + '.jpg'\\n name_sans_ext = name_img\\n elif database=='PeopleArt':\\n complet_name = path_to_img + name_img\\n name_sans_ext = os.path.splitext(name_img)[0]\\n elif(database=='Wikidata_Paintings') or (database=='Wikidata_Paintings_miniset_verif'):\\n name_sans_ext = os.path.splitext(name_img)[0]\\n complet_name = path_to_img +name_sans_ext + '.jpg'\\n \\n im = cv2.imread(complet_name)\\n \\n blobs, im_scales = get_blobs(im)\\n dd = nx[1]/ im_scales[0] \\n score = nx[2]\\n roi = np.hstack((dd[0],score[0].reshape((-1,1))))\\n \\n \\n class_name = ['']\\n vis_detections_list(im, class_name, [roi])\\n \\n os.remove(name_pkl_all_features)\",\n \"def test_qc_quantize_op_cpu(self):\\n graph = tf.Graph()\\n config = tf.compat.v1.ConfigProto(log_device_placement=False)\\n sess = tf.compat.v1.Session(graph=graph, config=config)\\n bitwidth = 8\\n use_symm_encoding = True\\n\\n with graph.as_default():\\n # place holder for the input\\n with tf.device(\\\"/device:CPU:0\\\"):\\n inp = tf.compat.v1.placeholder(tf.float32, shape=[10], name='input')\\n tensor_quantizer = libpymo.TensorQuantizer(libpymo.QuantizationMode.QUANTIZATION_TF_ENHANCED,\\n libpymo.RoundingMode.ROUND_NEAREST)\\n tensor_quantizer_val = libpymo.PtrToInt64(tensor_quantizer)\\n tensor_quant_ref = tf.Variable(initial_value=tensor_quantizer_val, trainable=False, dtype=tf.int64)\\n\\n encoding_min = tf.Variable(initial_value=0.0, trainable=True, dtype=tf.double)\\n encoding_max = tf.Variable(initial_value=0.0, trainable=True, dtype=tf.double)\\n bit_width = tf.Variable(initial_value=bitwidth, trainable=False, dtype=tf.int8)\\n use_symmetric_encoding = tf.Variable(initial_value=use_symm_encoding, trainable=False, dtype=tf.bool)\\n is_int_data_type = tf.Variable(initial_value=True, trainable=False, dtype=tf.bool)\\n\\n mode_var = tf.Variable(initial_value=int(libpymo.TensorQuantizerOpMode.updateStats),\\n trainable=False, dtype=tf.int32)\\n\\n sess.run([mode_var.initializer, tensor_quant_ref.initializer, encoding_min.initializer,\\n encoding_max.initializer, bit_width.initializer, use_symmetric_encoding.initializer,\\n is_int_data_type.initializer])\\n\\n pass_through_op_output = zero_out_module.qc_quantize(name='quant_op', in_tensor=inp,\\n op_mode=mode_var,\\n tensor_quantizer_reference=tensor_quant_ref,\\n encoding_min=encoding_min,\\n encoding_max=encoding_max,\\n bit_width=bit_width,\\n use_symmetric_encoding=use_symmetric_encoding,\\n is_int_data_type=is_int_data_type)\\n\\n inp_tensor = sess.graph.get_tensor_by_name('input:0')\\n inp_data = np.random.rand(10)\\n\\n # get the output\\n print(\\\"inp_data\\\", inp_data)\\n out_data = sess.run(pass_through_op_output, feed_dict={inp_tensor: inp_data})\\n print(\\\"out_data\\\", out_data)\\n\\n # compare qc_quantize op's output with input\\n assert np.allclose(out_data, inp_data)\\n\\n # compute encodings\\n assert not tensor_quantizer.isEncodingValid\\n encoding = tensor_quantizer.computeEncoding(bitwidth, use_symm_encoding)\\n assert tensor_quantizer.isEncodingValid\\n print('min=', encoding.min, ', max=', encoding.max)\\n\\n # get the output\\n inp_data = np.random.rand(10) * 2\\n print(inp_data)\\n mode_var.load(int(libpymo.TensorQuantizerOpMode.quantizeDequantize), sess)\\n out_data = sess.run(pass_through_op_output, feed_dict={inp_tensor: inp_data})\\n print(out_data)\\n\\n # compare qc_quantize op's output with input\\n assert not np.allclose(out_data, inp_data)\\n sess.close()\",\n \"def ResUNetPlusPlus(input_size: tuple, test_mode=False):\\n assert len(input_size) == 3, \\\"[ERROR]: Expected tuple of length 3 got {0}\\\".format(len(input_size))\\n\\n image_width, image_height, n_channels = input_size\\n\\n inp = tf.keras.layers.Input(shape=(image_width, image_height, n_channels), dtype=\\\"float32\\\", name=\\\"input_layer\\\")\\n\\n # starting conv\\n x = layers.Conv2DBN(64, 3, padding=\\\"same\\\", activation=\\\"relu\\\", name=\\\"conv_start\\\")(inp)\\n\\n # Residual block 1\\n x = layers.ResidualBlock(64, 3, activation=\\\"relu\\\", name=\\\"rb_1\\\")(x)\\n skip1 = x\\n\\n x = tf.keras.layers.Conv2D(128,\\n kernel_size=(3, 3),\\n strides=(2, 2),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.SqueezeExcitationBlock(ratio=1)(x)\\n\\n # Residual block 2\\n x = layers.ResidualBlock(128, 3, activation=\\\"relu\\\", name=\\\"rb_2\\\")(x)\\n skip2 = x\\n\\n x = tf.keras.layers.Conv2D(256,\\n kernel_size=(3, 3),\\n strides=(2, 2),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.SqueezeExcitationBlock(ratio=2)(x)\\n\\n # Residual block 3\\n x = layers.ResidualBlock(256, 3, activation=\\\"relu\\\", name=\\\"rb_3\\\")(x)\\n skip3 = x\\n\\n x = tf.keras.layers.Conv2D(512,\\n kernel_size=(3, 3),\\n strides=(2, 2),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.SqueezeExcitationBlock(ratio=4)(x)\\n\\n # Residual block 4\\n x = layers.ResidualBlock(512, 3, activation=\\\"relu\\\", name=\\\"rb_4\\\")(x)\\n skip4 = x\\n\\n x = tf.keras.layers.Conv2D(1024,\\n kernel_size=(3, 3),\\n strides=(2, 2),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.SqueezeExcitationBlock(ratio=8)(x)\\n\\n # Bottleneck ASPP\\n x = layers.ASPP(256, [4, 8, 12], (256, 256), 16, activation=\\\"relu\\\", name=\\\"aspp_bottleneck\\\")(x)\\n x = layers.Conv2DBN(1024, 1, activation=\\\"relu\\\")(x)\\n\\n # Up-sample L4\\n x = layers.GlobalAttentionUpsample(name=\\\"GAU_4\\\")([skip4, x])\\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip4])\\n x = tf.keras.layers.Conv2D(512,\\n kernel_size=(3, 3),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.ResidualBlock(512, 3, activation=\\\"relu\\\", activate_begin=True, name=\\\"u_rb_4\\\")(x)\\n\\n # Up-sample L3\\n x = layers.GlobalAttentionUpsample(name=\\\"GAU_3\\\")([skip3, x])\\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip3])\\n x = tf.keras.layers.Conv2D(256,\\n kernel_size=(3, 3),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.ResidualBlock(256, 3, activation=\\\"relu\\\", activate_begin=True, name=\\\"u_rb_3\\\")(x)\\n\\n # Up-sample L2\\n x = layers.GlobalAttentionUpsample(name=\\\"GAU_2\\\")([skip2, x])\\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip2])\\n x = tf.keras.layers.Conv2D(128,\\n kernel_size=(3, 3),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.ResidualBlock(128, 3, activation=\\\"relu\\\", activate_begin=True, name=\\\"u_rb_2\\\")(x)\\n\\n # Up-sample L1\\n x = layers.GlobalAttentionUpsample(name=\\\"GAU_1\\\")([skip1, x])\\n x = tf.keras.layers.Concatenate(axis=-1)([x, skip1])\\n x = tf.keras.layers.Conv2D(64,\\n kernel_size=(3, 3),\\n padding=\\\"same\\\",\\n activation=\\\"linear\\\")(x)\\n x = layers.ResidualBlock(64, 3, activation=\\\"relu\\\", activate_begin=True, name=\\\"u_rb_1\\\")(x)\\n x = layers.Conv2DBN(1, 1, activation=\\\"sigmoid\\\")(x)\\n\\n return tf.keras.Model(inputs=[inp], outputs=[x])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5645855","0.53501433","0.5246339","0.52274525","0.5080488","0.50688004","0.5044712","0.49589333","0.4905664","0.4891885","0.48683834","0.48381573","0.48108053","0.4800535","0.47633642","0.47312012","0.47288904","0.471117","0.47105142","0.4692214","0.46887654","0.46579772","0.46546373","0.4645659","0.46199873","0.46194547","0.4614491","0.46117455","0.46117446","0.4608306","0.46010444","0.45918423","0.45884344","0.45821312","0.45796174","0.45704442","0.45493573","0.4527936","0.45251146","0.45249724","0.4524827","0.45242807","0.45230576","0.45191616","0.45178542","0.4513795","0.45086622","0.4506764","0.45055532","0.449723","0.4495939","0.44951153","0.4495067","0.4488734","0.44879863","0.44824958","0.4470018","0.4469433","0.44683897","0.44644335","0.44623947","0.4461335","0.44593093","0.44576335","0.4457225","0.44466934","0.44445357","0.4443587","0.44429547","0.44375008","0.44368804","0.44328102","0.4432451","0.44315797","0.44307286","0.44296297","0.44281298","0.44142753","0.4413262","0.4412501","0.44107607","0.44075373","0.44061217","0.4403964","0.43969914","0.43941265","0.43936807","0.43902773","0.43852642","0.438382","0.43806744","0.43791276","0.4378908","0.4375693","0.4374692","0.43731156","0.43713135","0.4369138","0.43680578","0.43639725"],"string":"[\n \"0.5645855\",\n \"0.53501433\",\n \"0.5246339\",\n \"0.52274525\",\n \"0.5080488\",\n \"0.50688004\",\n \"0.5044712\",\n \"0.49589333\",\n \"0.4905664\",\n \"0.4891885\",\n \"0.48683834\",\n \"0.48381573\",\n \"0.48108053\",\n \"0.4800535\",\n \"0.47633642\",\n \"0.47312012\",\n \"0.47288904\",\n \"0.471117\",\n \"0.47105142\",\n \"0.4692214\",\n \"0.46887654\",\n \"0.46579772\",\n \"0.46546373\",\n \"0.4645659\",\n \"0.46199873\",\n \"0.46194547\",\n \"0.4614491\",\n \"0.46117455\",\n \"0.46117446\",\n \"0.4608306\",\n \"0.46010444\",\n \"0.45918423\",\n \"0.45884344\",\n \"0.45821312\",\n \"0.45796174\",\n \"0.45704442\",\n \"0.45493573\",\n \"0.4527936\",\n \"0.45251146\",\n \"0.45249724\",\n \"0.4524827\",\n \"0.45242807\",\n \"0.45230576\",\n \"0.45191616\",\n \"0.45178542\",\n \"0.4513795\",\n \"0.45086622\",\n \"0.4506764\",\n \"0.45055532\",\n \"0.449723\",\n \"0.4495939\",\n \"0.44951153\",\n \"0.4495067\",\n \"0.4488734\",\n \"0.44879863\",\n \"0.44824958\",\n \"0.4470018\",\n \"0.4469433\",\n \"0.44683897\",\n \"0.44644335\",\n \"0.44623947\",\n \"0.4461335\",\n \"0.44593093\",\n \"0.44576335\",\n \"0.4457225\",\n \"0.44466934\",\n \"0.44445357\",\n \"0.4443587\",\n \"0.44429547\",\n \"0.44375008\",\n \"0.44368804\",\n \"0.44328102\",\n \"0.4432451\",\n \"0.44315797\",\n \"0.44307286\",\n \"0.44296297\",\n \"0.44281298\",\n \"0.44142753\",\n \"0.4413262\",\n \"0.4412501\",\n \"0.44107607\",\n \"0.44075373\",\n \"0.44061217\",\n \"0.4403964\",\n \"0.43969914\",\n \"0.43941265\",\n \"0.43936807\",\n \"0.43902773\",\n \"0.43852642\",\n \"0.438382\",\n \"0.43806744\",\n \"0.43791276\",\n \"0.4378908\",\n \"0.4375693\",\n \"0.4374692\",\n \"0.43731156\",\n \"0.43713135\",\n \"0.4369138\",\n \"0.43680578\",\n \"0.43639725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56021696"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":83786,"cells":{"query":{"kind":"string","value":"Compute the minmax range of tensor"},"document":{"kind":"string","value":"def compute_data(self) -> TensorsData:\n\n if len(self.intermediate_outputs) == 0:\n return self.calibrate_tensors_range\n\n output_names = [self.infer_session.get_outputs()[i].name for i in range(len(self.intermediate_outputs[0]))]\n output_dicts_list = [\n dict(zip(output_names, intermediate_output)) for intermediate_output in self.intermediate_outputs\n ]\n\n merged_output_dict = {}\n for d in output_dicts_list:\n for k, v in d.items():\n merged_output_dict.setdefault(k, []).append(v)\n added_output_names = output_names[self.num_model_outputs :]\n calibrate_tensor_names = [\n added_output_names[i].rpartition(\"_\")[0] for i in range(0, len(added_output_names), 2)\n ] # output names\n\n merged_added_output_dict = {\n i: merged_output_dict[i] for i in merged_output_dict if i not in self.model_original_outputs\n }\n\n pairs = []\n for i in range(0, len(added_output_names), 2):\n min_value = 0\n max_value = 0\n if self.moving_average:\n min_value_array = np.mean(merged_added_output_dict[added_output_names[i]], axis=0)\n max_value_array = np.mean(merged_added_output_dict[added_output_names[i + 1]], axis=0)\n else:\n min_value_array = min(merged_added_output_dict[added_output_names[i]])\n max_value_array = max(merged_added_output_dict[added_output_names[i + 1]])\n if type(min_value_array) == int or min_value_array.size > 0:\n min_value = float(min_value_array)\n if type(max_value_array) == int or max_value_array.size > 0:\n max_value = float(max_value_array)\n\n if self.symmetric:\n max_absolute_value = max(abs(min_value), abs(max_value))\n pairs.append(tuple([-max_absolute_value, max_absolute_value]))\n else:\n pairs.append(tuple([min_value, max_value]))\n\n new_calibrate_tensors_range = TensorsData(CalibrationMethod.MinMax, dict(zip(calibrate_tensor_names, pairs)))\n if self.calibrate_tensors_range:\n self.calibrate_tensors_range = self.merge_range(self.calibrate_tensors_range, new_calibrate_tensors_range)\n else:\n self.calibrate_tensors_range = new_calibrate_tensors_range\n\n return self.calibrate_tensors_range"},"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_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\n device = tensor.device\n tensor = tensor.detach().cpu()\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\n mn /= numpy.prod(tensor.shape[1:])\n q = alpha * (1 - mn) * 50\n n_samples = tensor.shape[0]\n add_view = [1] * (tensor.ndim - 1)\n low = torch.tensor(\n [numpy.percentile(tensor[i], q[i]) for i in range(n_samples)]).float()\n high = torch.tensor([numpy.percentile(tensor[i], 100 - q[i]) for i in\n range(n_samples)]).float()\n low = low.view(-1, *add_view)\n high = high.view(-1, *add_view)\n return (tensor - low / (high - low)).to(device)","def maxs(self) -> Tensor:\n return self._ranges[:, 1]","def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\n ...","def mins(self) -> Tensor:\n return self._ranges[:, 0]","def min_max_range(s):\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\n sign = np.sign(np.argmax(s) - np.argmin(s))\n if sign == 0:\n return 0.0\n else:\n return sign*(np.max(s) - np.min(s))","def calculate_min_max_tiles(self):","def bounds(self) -> Tensor:\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)","def minmax_norm(X):\n return (X - tf.reduce_min(X))/(tf.reduce_max(X)-tf.reduce_min(X))","def local_max_to_min(node):\r\n if node.op == T.neg and node.inputs[0].owner:\r\n max = node.inputs[0]\r\n if (max.owner and\r\n isinstance(max.owner.op, CAReduce)\r\n and max.owner.op.scalar_op == scal.maximum):\r\n neg = max.owner.inputs[0]\r\n if neg.owner and neg.owner.op == T.neg:\r\n return [CAReduce(scal.minimum,\r\n max.owner.op.axis)(neg.owner.inputs[0])]\r\n\r\n return False","def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\n\n\n dtype = min_broadcast.dtype\n quant_min = 1 if narrow_range else 0\n quant_max = (2 ** num_bits) - 1\n\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\n\n # caculate each channel max and min difference.\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\n # and min_div_scale = min_broadcast / scale\n if product_is_mini():\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\n else:\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\n\n # zero_point_from_min = quant_min_float - min_broadcast / scale\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\n\n # according to above bool param to select effective value\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\n\n # compute which num is not less than quant_min_float and not large than quant_max_float\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\n # add 0.5 to num which min <= num <= max and then floor them.\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\n if product_is_mini():\n between_min_max_round = topi.cast(between_min_max_round, \"float16\")\n\n between_min_max_round = topi.cast(between_min_max_round, \"float32\")\n\n # calculate the maximum and minimum values of the quantization\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\n\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\n nudged_min = topi.multiply(nudged_min_tmp, scale)\n nudged_max = topi.multiply(nudged_max_tmp, scale)\n res = [nudged_min, nudged_max, scale]\n\n return res","def min_max(xs):\n return min(xs), max(xs)","def minmin_maxmax( *args ):\n rmin = min( [ mv.min() for mv in args ] )\n rmax = max( [ mv.max() for mv in args ] )\n rmv = cdms2.createVariable( [rmin,rmax] )\n return rmv","def convert_arg_max_min(g, op, block):\n\n axis = op.attr(\"axis\")\n keepdims = op.attr(\"keepdims\")\n flatten = op.attr(\"flatten\")\n dtype = op.attr(\"dtype\")\n dtype = _convert_dtype_value(dtype)\n\n func = _op.argmax if op.type == \"arg_max\" else _op.argmin\n x = g.get_node(op.input(\"X\")[0])\n if axis is None or flatten:\n x = _op.reshape(x, [-1])\n out = func(x, axis=None, keepdims=True)\n else:\n out = func(x, axis=axis, keepdims=keepdims)\n if dtype != infer_type(out).checked_type.dtype:\n out = _op.cast(out, dtype)\n g.add_node(op.output(\"Out\")[0], out)","def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\n min_max_features = []\n transposed_features = [list(i) for i in zip(*features)]\n for feature in transposed_features:\n min_in_feature = min(feature)\n max_in_feature = max(feature)\n if min_in_feature == max_in_feature:\n min_max_features.append([0 for x in feature])\n else:\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\n return [list(i) for i in zip(*min_max_features)]","def _bound(x, min_value, max_value):\n return np.maximum(min_value, np.minimum(x, max_value))","def abs_max(tensor):\n min_val, max_val = tensor.min(), tensor.max()\n return max(min_val.abs(), max_val.abs())","def minimum_maximum_model():\n inputs = tf.keras.Input(shape=(32, 32, 3,))\n x = tf.keras.layers.Conv2D(32, (3, 3))(inputs)\n x = tf.keras.layers.BatchNormalization(momentum=.3, epsilon=.65)(x, training=False)\n x = tf.minimum(x, .2)\n x = tf.maximum(x, .5)\n x = tf.keras.layers.Conv2D(16, (2, 2), activation=tf.nn.tanh)(x)\n x = tf.keras.layers.Flatten()(x)\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\"minimum_maximum_model\")(x)\n return outputs","def clamp(n, min_, max_):\n return max(min(max_,n),min_)","def saturate_scalar_minmax(value, max_value, min_value):\n mean = (max_value + min_value)/2.0\n half_range = (max_value - min_value)/2.0\n return saturate_vector_dg(value-mean, half_range) + mean","def min_max(tr):\n tr = tr.astype(float)\n mm = tr.min() / tr.max()\n return mm","def min_max_normalization(x, min_x = None, max_x = None):\n if min_x is None:\n min_x = np.min(x, axis=0)\n if max_x is None:\n max_x = np.max(x, axis=0)\n return (x - (min_x)) / (max_x - min_x), min_x, max_x","def minmax(self):\n return self._data_lim[self._n_overlay - 1]","def minmax(self):\r\n vx = [v[0] for v in self.vl]\r\n vy = [v[1] for v in self.vl]\r\n self.xmax, self.xmin = max(vx), min(vx)\r\n self.ymax, self.ymin = max(vy), min(vy)","def get_range(lst):\n return float(max(lst)) - float(min(lst))","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def minMaxFonc(liste):\n\n return min(liste), max(liste)","def min_max(arr, arr_size):\n max_t = arr[0]\n min_t = arr[0]\n for i in range(arr_size):\n if arr[i] > max_t:\n max_t = arr[i]\n if arr[i] < min_t:\n min_t = arr[i]\n return min_t, max_t","def clamp(value, mn, mx):\n\n return max(min(value, mx), mn)","def _normalize_range():\n clipped = tf.clip_by_value(inputs, self.minimum, self.maximum)\n return -1 + 2 * (clipped - self.minimum) / length","def minmax_normalize(X):\n # X -= X.min()\n # X /= X.max()\n # X -= 0.5\n X = (X-X.min()) / (X.max() - X.min())\n return X","def spec_min_max(self):\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\n 2048,2048,2048,2048,2048])\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0])\n return np.vstack((spec_min, spec_max))","def quickMinMax(self, targetSize=1e6):\n data = self.image\n if targetSize < 2: # keep at least two pixels\n targetSize = 2\n while True:\n h, w = data.shape[:2]\n if h * w <= targetSize: break\n if h > w:\n data = data[::2, ::] # downsample first axis\n else:\n data = data[::, ::2] # downsample second axis\n return self._xp.nanmin(data), self._xp.nanmax(data)","def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\n assert \\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\n if dtype is None:\n dtype = images.dtype\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)","def min_max(items):\n return min(items), max(items)","def _min_max_scale(arr, new_range=(0, 255)):\n # get array's current min and max\n mn = arr.min()\n mx = arr.max()\n\n # check if scaling needs to be done to be in new_range\n if mn < new_range[0] or mx > new_range[1]:\n # perform min-max scaling\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\n else:\n # return array if already in range\n scaled = arr\n\n return scaled","def argmin(tensor):\n raise NotImplementedError","def get_max_min(block_size):\r\n return (int(block_size / 2), int((block_size - 1) / 2))","def cpfclamp(f, min_, max_):\n return min(max(f, min_), max_)","def minMax(df):\n max_, min_ = df.max(axis=0), df.min(axis=0)\n midrange = (max_ + min_) / 2\n half_range = (max_ - min_) / 2\n return (df - midrange) / half_range","def data_range(x):\n return max(x)-min(x)","def view_limits(self, dmin, dmax):\n base = self._select_base(dmin, dmax)\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\n vmin = base.le(dmin)\n vmax = base.ge(dmax)\n if vmin == vmax:\n vmin -= 1\n vmax += 1\n else:\n vmin = dmin\n vmax = dmax\n\n return mtransforms.nonsingular(vmin, vmax)","def minMaxLoc(img):\n\tmaskVar = mask(img)\n\tpt = cv2.minMaxLoc(grayscale(img), maskVar)\n\td = {\"minVal\": pt[0], \"maxVal\":pt[1], \"minLoc\":pt[2], \"maxLoc\":pt[3]}\n\treturn d","def get_min_max(ints):\n print(f\"input arr is {ints}\")\n max=0\n min=len(ints)-1\n for i in range(1,len(ints)):\n if ints[i]>ints[max]:\n temp=ints[i]\n ints[i]=ints[max]\n ints[max]=temp\n if ints[i]<ints[min]:\n temp=ints[i]\n ints[i]=ints[min]\n ints[min]=temp\n #print(f\"max value is {ints[max]}\")\n #print(f\"min value is {ints[min]}\")\n return(ints[min],ints[max])","def minmax ( self , nshoots = 100000 ) :\n ## try to get minmax directly from pdf/function \n if self.tricks and hasattr ( self.pdf , 'function' ) :\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \n f = self.pdf.function()\n if hasattr ( f , 'minmax' ) :\n try :\n mn , mx = f.minmax()\n if 0<= mn and mn <= mx and 0 < mx : \n return mn , mx\n except :\n pass\n if hasattr ( f , 'max' ) :\n try :\n mx = f.max()\n if 0 < mx : return 0 , mx\n except :\n pass\n\n ## check RooAbsReal functionality\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\n if 0 < code :\n mx = self.pdf.maxVal ( code )\n if 0 < mx : return 0 , mx\n \n ## not try to use random\n \n mn , mx = -1 , -10\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\n \n if not self.xminmax() : return ()\n if not self.yminmax() : return ()\n \n mn , mx = -1 , -10\n xmn , xmx = self.xminmax()\n ymn , ymx = self.yminmax()\n for i in range ( nshoots ) : \n xx = random.uniform ( xmn , xmx )\n yy = random.uniform ( ymn , ymx )\n with SETVAR ( self.xvar ) :\n with SETVAR ( self.yvar ) :\n self.xvar.setVal ( xx )\n self.yvar.setVal ( yy )\n vv = self.pdf.getVal()\n if mn < 0 or vv < mn : mn = vv\n if mx < 0 or vv > mx : mx = vv\n \n return mn , mx","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def min_max_scale(self, feature_range=(0, 1)):\n\n if len(feature_range) != 2:\n raise AttributeError(\n \"Error: `feature_range` doesn't look like a 2-element tuple?\"\n )\n if feature_range[1] < feature_range[0]:\n raise AttributeError(\"Error: `feature_range` isn't increasing?\")\n\n # use self.__class__ so that child classes can inherit this method\n return self.__class__(\n min_max_scale(self.spectrogram, feature_range=feature_range),\n frequencies=self.frequencies,\n times=self.times,\n decibel_limits=self.decibel_limits,\n )","def min_max(my_list):\n print(\"Min = \",min(my_list,key = abs))\n print(\"Max = \",max(my_list,key = abs))","def normalizeToRange(data,max=255,min=0):\n if min: return (max-min)*normalize(data)+min\n else: return max*normalize2(data) # speeds up operation","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def masked_minimum(data, mask, dim=1):\n axis_maximums = tf.reduce_max(data, dim, keepdims=True)\n masked_minimums = tf.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def x_y_coor_min_max(x_y_coor):\n\tx_range = [np.min(x_y_coor[\"X\"]),np.max(x_y_coor[\"X\"])]\n\ty_range = [np.min(x_y_coor[\"Y\"]),np.max(x_y_coor[\"Y\"])]\n\treturn x_range, y_range","def map_range(x, in_min, in_max, out_min, out_max):\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\n if out_min <= out_max:\n return max(min(mapped, out_max), out_min)\n return min(max(mapped, out_max), out_min)","def find_max_min(self, col):\n self.max = max(col)\n self.min = min(col)","def maxima_in_range(r, g_r, r_min, r_max):\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\n g_r_slice = g_r[idx]\n g_r_max = g_r_slice[g_r_slice.argmax()]\n idx_max, _ = find_nearest(g_r, g_r_max)\n return r[idx_max], g_r[idx_max]","def data_range(xs: List[float]) -> float:\n return max(xs) - min(xs)","def masked_minimum(data, mask, dim=1):\n # sourced from:\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L141-L157\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\n masked_minimums = tf.math.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def clamp(minimum, n, maximum):\n return max(minimum, min(n, maximum))","def min_max(lst):\r\n my_min = None\r\n my_max = None\r\n for num in lst:\r\n if (my_min and my_max) is not None:\r\n # recalculate running min and max:\r\n if num < my_min:\r\n my_min = num\r\n continue\r\n if num > my_max:\r\n my_max = num\r\n else:\r\n my_min = num\r\n my_max = num\r\n ans = (my_min, my_max)\r\n return ans","def vc_clamp(x, lb, ub):\n\n y = min(x, ub)\n y = max(y, lb)\n\n return y","def view_limits(self, vmin, vmax):\n return vmin, vmax\n # return nonsingular(vmin, vmax)","def minima_in_range(r, g_r, r_min, r_max):\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\n g_r_slice = g_r[idx]\n g_r_min = g_r_slice[g_r_slice.argmin()]\n idx_min, _ = find_nearest(g_r, g_r_min)\n return r[idx_min], g_r[idx_min]","def clip(tensor, a_min=None, a_max=None):\n raise NotImplementedError","def clamp(value, min_value, max_value):\n return max(min_value, min(value, max_value))","def getColorRange(self):\n vmax=self.data_matrix.max()\n vmin=self.data_matrix.min()\n\n if vmax * vmin < 0: # ie number range spans +ve and -ve\n vmax = max([vmax, abs(vmin)])\n vmin = -1*vmax\n\n return vmax,vmin","def clamp(n, minn, maxn):\n return max(min(maxn, n), minn)","def minMax2(x):\r\n\r\n iMinMax = [0 for i in range(2)]\r\n num = len(x)[0]\r\n\r\n iMin = 0\r\n iMax = 0\r\n\r\n #// Search for minimum and maximum in row 0 - linear values:\r\n min = x[0][iMin]\r\n max = x[0][iMax]\r\n\r\n for i in range(1, num):\r\n\r\n if (x[0][i] < min): \r\n min = x[0][i]\r\n iMin = i\r\n \r\n\r\n if (x[0][i] > max): \r\n max = x[0][i]\r\n iMax = i\r\n \r\n iMinMax[0] = iMin\r\n iMinMax[1] = iMax\r\n\r\n return iMinMax","def _argmax(self, input_tensor, dimension, c):\n with self.session.graph.as_default():\n min_values = tf.reduce_min(input_tensor, reduction_indices=[dimension,], keep_dims=True)\n not_c = tf.abs(c - 1)\n\n return tf.argmax(input_tensor * c + not_c * min_values, dimension)","def minmaxdenorm(v, minv, maxv):\n v *= maxv - minv\n v += minv\n return v","def _min_in_bounds(self, min):\n if min <= self.valmin:\n if not self.closedmin:\n return self.val[0]\n min = self.valmin\n\n if min > self.val[1]:\n min = self.val[1]\n return self._stepped_value(min)","def clip_range(x, xlim):\n return min([max([x, xlim[0]]), xlim[1]])","def map_to_range(val, old_min, old_max, new_min, new_max):\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)","def minmax(xs):\n min_val = None\n max_val = None\n for x in xs:\n if min_val is None or x < min_val:\n min_val = x\n if max_val is None or x > max_val:\n max_val = x\n return (min_val, max_val)","def masked_maximum(data, mask, dim=1):\n axis_minimums = tf.reduce_min(data, dim, keepdims=True)\n masked_maximums = tf.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim,\n keepdims=True) + axis_minimums\n return masked_maximums","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def xminmax ( self ) :\n return self.xvar.minmax()","def minMax(x):\r\n\r\n iMinMax = [0 for i in range(2)]\r\n\r\n num = len(x)\r\n #//System.out.println(\"MinMax: num: \" + num);\r\n\r\n iMin = 0\r\n iMax = 0\r\n min = x[iMin]\r\n max = x[iMax]\r\n\r\n for i in range(1, num):\r\n\r\n #//System.out.println(\"MinMax: i , current min, x : \" + i + \" \" + min + \" \" + x[i]);\r\n if (x[i] < min): \r\n #//System.out.println(\"MinMax: new min: if branch triggered\" );\r\n min = x[i]\r\n iMin = i\r\n \r\n #//System.out.println(\"MinMax: new min: \" + min);\r\n\r\n if (x[i] > max): \r\n max = x[i]\r\n iMax = i\r\n \r\n\r\n \r\n #//System.out.println(\"MinMax: \" + iMin + \" \" + iMax);\r\n\r\n iMinMax[0] = iMin\r\n iMinMax[1] = iMax\r\n\r\n return iMinMax","def standardize_x(\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\n):\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\n raise ValueError(\n \"Either *both* or *neither* of x_min, x_max need to be supplied!\"\n )\n if x_min is None:\n x_min = torch.min(x, 0)[0]\n x_max = torch.max(x, 0)[0]\n x = (x - x_min) / (x_max - x_min)\n return x, x_min, x_max","def masked_minimum(data, mask, dim=1):\n axis_maximums = math_ops.reduce_max(data, dim, keepdims=True)\n masked_minimums = math_ops.reduce_min(\n math_ops.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def _xywh2min_max(box):\n x, y, w, h = box\n return np.array([x, y, x+w, y+h])","def constrain(n: int, low: int, high: int) -> int:\n return max(min(n, high), low)","def _masked_minimum(data, mask, dim=1):\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\n masked_minimums = (\n tf.math.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim, keepdims=True\n )\n + axis_maximums\n )\n return masked_minimums","def min_max(self, data, era):\n return 0, np.max(data)","def find_max_min(number):\n if max(number) == min(number):\n return [len(number)]\n return [min(number), max(number)]","def clamp(n, minn, maxn):\n return max(min(maxn, n), minn)","def dim_zero_min(x: Tensor) ->Tensor:\n return torch.min(x, dim=0).values","def range(self):\r\n\t\treturn max(self.sample) - min(self.sample)","def min():\n return KeeperOfMinOrMax(int.__gt__)","def convert_clip(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n dtype = infer_type(x).checked_type.dtype\n # if the min/max value is a tensor\n min_max_is_tensor = False\n if op.input(\"Min\"):\n min_value = g.get_node(op.input(\"Min\")[0])\n min_value, infered = try_infer_value(min_value, g.get_params())\n if infered:\n min_value = min_value.tolist()[0]\n if isinstance(min_value, _expr.Expr):\n min_max_is_tensor = True\n else:\n min_value = op.attr(\"min\")\n\n if op.input(\"Max\"):\n max_value = g.get_node(op.input(\"Max\")[0])\n max_value, infered = try_infer_value(max_value, g.get_params())\n if infered:\n max_value = max_value.tolist()[0]\n if isinstance(max_value, _expr.Expr):\n min_max_is_tensor = True\n else:\n max_value = op.attr(\"max\")\n\n if min_max_is_tensor:\n if not isinstance(min_value, _expr.Expr):\n min_value = _op.const(min_value, dtype)\n if not isinstance(max_value, _expr.Expr):\n max_value = _op.const(max_value, dtype)\n out = _op.maximum(x, min_value)\n out = _op.minimum(out, max_value)\n else:\n out = _op.clip(x, min_value, max_value)\n g.add_node(op.output(\"Out\")[0], out)","def masked_maximum(data, mask, dim=1):\n # sourced from:\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L122-L138\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\n masked_maximums = tf.math.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim,\n keepdims=True) + axis_minimums\n return masked_maximums","def normalize_minmax(data):\n _min = np.float(np.min(data))\n _max = np.float(np.max(data))\n if (_max-_min)!=0:\n img = (data - _min) / (_max-_min)\n else:\n img = np.zeros_like(data) \n return img","def print_minmax(arr):\n print(arr.shape)\n for i in range(arr.shape[1]):\n print(transfer[i], arr[:,i].min(), arr[:,i].max())","def _min_or_max_grad(x, axis, out, dout):\n # input_shape = [2, 3] axis = [1]\n input_shape = shape_op(x)\n # output_shape_kept_dims = [2, 1]\n output_shape_kept_dims = reduced_shape(input_shape, axis)\n y = reshape(out, output_shape_kept_dims)\n grad = reshape(dout, output_shape_kept_dims)\n indicators = F.cast(F.equal(y, x), F.dtype(grad))\n min_num = F.cast(F.scalar_to_array(1e-24), F.dtype(grad))\n num_selected = reshape(reduce_sum(indicators, axis), output_shape_kept_dims) + min_num\n return indicators / num_selected * grad","def minmax(value):\n return min(0xff, max(0, value))","def _masked_maximum(data, mask, dim=1):\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\n masked_maximums = (\n tf.math.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim, keepdims=True\n )\n + axis_minimums\n )\n return masked_maximums","def scale_from_minmax(\n col: np.ndarray, minmax: Optional[Tuple[float, float]]\n) -> np.ndarray:\n if minmax is None:\n return np.zeros_like(col)\n else:\n min_, max_ = minmax\n assert max_ - min_ >= FLOAT_TOL\n return 2 * (col - min_) / (max_ - min_) - 1","def atmax(a,upperlimit,dimension=None,inclusive=1):\r\n if inclusive: upperfcn = N.less\r\n else: upperfcn = N.less_equal\r\n if dimension == None:\r\n a = N.ravel(a)\r\n dimension = 0\r\n if upperlimit == None:\r\n upperlimit = N.maximum.reduce(N.ravel(a))+1\r\n smallest = N.minimum.reduce(N.ravel(a))\r\n ta = N.where(upperfcn(a,upperlimit),a,smallest)\r\n return N.maximum.reduce(ta,dimension)","def min_max(arr: StaticArray) -> ():\n minimum = arr.get(0) # sets min to first element\n maximum = arr.get(0) # sets max to first element\n # iterate over the elements in the array to check for < or >\n for index in range(arr.size()):\n if arr[index] < minimum: # if element is less than the current min, min = new element\n minimum = arr[index]\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\n maximum = arr[index]\n return minimum, maximum","def atmin(a,lowerlimit=None,dimension=None,inclusive=1):\r\n if inclusive: lowerfcn = N.greater\r\n else: lowerfcn = N.greater_equal\r\n if dimension == None:\r\n a = N.ravel(a)\r\n dimension = 0\r\n if lowerlimit == None:\r\n lowerlimit = N.minimum.reduce(N.ravel(a))-11\r\n biggest = N.maximum.reduce(N.ravel(a))\r\n ta = N.where(lowerfcn(a,lowerlimit),a,biggest)\r\n return N.minimum.reduce(ta,dimension)","def bounds(x, xMin, xMax):\n if (x < xMin):\n x = xMin\n elif (x > xMax):\n x = xMax\n return(x)","def constrain(small, value, big):\n return min(max(value, small), big)","def clamp(minimum, value, maximum):\n return max(minimum, min(maximum, value))"],"string":"[\n \"def batch_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\\n device = tensor.device\\n tensor = tensor.detach().cpu()\\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\\n mn /= numpy.prod(tensor.shape[1:])\\n q = alpha * (1 - mn) * 50\\n n_samples = tensor.shape[0]\\n add_view = [1] * (tensor.ndim - 1)\\n low = torch.tensor(\\n [numpy.percentile(tensor[i], q[i]) for i in range(n_samples)]).float()\\n high = torch.tensor([numpy.percentile(tensor[i], 100 - q[i]) for i in\\n range(n_samples)]).float()\\n low = low.view(-1, *add_view)\\n high = high.view(-1, *add_view)\\n return (tensor - low / (high - low)).to(device)\",\n \"def maxs(self) -> Tensor:\\n return self._ranges[:, 1]\",\n \"def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\\n ...\",\n \"def mins(self) -> Tensor:\\n return self._ranges[:, 0]\",\n \"def min_max_range(s):\\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\\n sign = np.sign(np.argmax(s) - np.argmin(s))\\n if sign == 0:\\n return 0.0\\n else:\\n return sign*(np.max(s) - np.min(s))\",\n \"def calculate_min_max_tiles(self):\",\n \"def bounds(self) -> Tensor:\\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)\",\n \"def minmax_norm(X):\\n return (X - tf.reduce_min(X))/(tf.reduce_max(X)-tf.reduce_min(X))\",\n \"def local_max_to_min(node):\\r\\n if node.op == T.neg and node.inputs[0].owner:\\r\\n max = node.inputs[0]\\r\\n if (max.owner and\\r\\n isinstance(max.owner.op, CAReduce)\\r\\n and max.owner.op.scalar_op == scal.maximum):\\r\\n neg = max.owner.inputs[0]\\r\\n if neg.owner and neg.owner.op == T.neg:\\r\\n return [CAReduce(scal.minimum,\\r\\n max.owner.op.axis)(neg.owner.inputs[0])]\\r\\n\\r\\n return False\",\n \"def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\\n\\n\\n dtype = min_broadcast.dtype\\n quant_min = 1 if narrow_range else 0\\n quant_max = (2 ** num_bits) - 1\\n\\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\\n\\n # caculate each channel max and min difference.\\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\\n # and min_div_scale = min_broadcast / scale\\n if product_is_mini():\\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\\n else:\\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\\n\\n # zero_point_from_min = quant_min_float - min_broadcast / scale\\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\\n\\n # according to above bool param to select effective value\\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\\n\\n # compute which num is not less than quant_min_float and not large than quant_max_float\\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\\n # add 0.5 to num which min <= num <= max and then floor them.\\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\\n if product_is_mini():\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float16\\\")\\n\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float32\\\")\\n\\n # calculate the maximum and minimum values of the quantization\\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\\n\\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\\n nudged_min = topi.multiply(nudged_min_tmp, scale)\\n nudged_max = topi.multiply(nudged_max_tmp, scale)\\n res = [nudged_min, nudged_max, scale]\\n\\n return res\",\n \"def min_max(xs):\\n return min(xs), max(xs)\",\n \"def minmin_maxmax( *args ):\\n rmin = min( [ mv.min() for mv in args ] )\\n rmax = max( [ mv.max() for mv in args ] )\\n rmv = cdms2.createVariable( [rmin,rmax] )\\n return rmv\",\n \"def convert_arg_max_min(g, op, block):\\n\\n axis = op.attr(\\\"axis\\\")\\n keepdims = op.attr(\\\"keepdims\\\")\\n flatten = op.attr(\\\"flatten\\\")\\n dtype = op.attr(\\\"dtype\\\")\\n dtype = _convert_dtype_value(dtype)\\n\\n func = _op.argmax if op.type == \\\"arg_max\\\" else _op.argmin\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n if axis is None or flatten:\\n x = _op.reshape(x, [-1])\\n out = func(x, axis=None, keepdims=True)\\n else:\\n out = func(x, axis=axis, keepdims=keepdims)\\n if dtype != infer_type(out).checked_type.dtype:\\n out = _op.cast(out, dtype)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\\n min_max_features = []\\n transposed_features = [list(i) for i in zip(*features)]\\n for feature in transposed_features:\\n min_in_feature = min(feature)\\n max_in_feature = max(feature)\\n if min_in_feature == max_in_feature:\\n min_max_features.append([0 for x in feature])\\n else:\\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\\n return [list(i) for i in zip(*min_max_features)]\",\n \"def _bound(x, min_value, max_value):\\n return np.maximum(min_value, np.minimum(x, max_value))\",\n \"def abs_max(tensor):\\n min_val, max_val = tensor.min(), tensor.max()\\n return max(min_val.abs(), max_val.abs())\",\n \"def minimum_maximum_model():\\n inputs = tf.keras.Input(shape=(32, 32, 3,))\\n x = tf.keras.layers.Conv2D(32, (3, 3))(inputs)\\n x = tf.keras.layers.BatchNormalization(momentum=.3, epsilon=.65)(x, training=False)\\n x = tf.minimum(x, .2)\\n x = tf.maximum(x, .5)\\n x = tf.keras.layers.Conv2D(16, (2, 2), activation=tf.nn.tanh)(x)\\n x = tf.keras.layers.Flatten()(x)\\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\\\"minimum_maximum_model\\\")(x)\\n return outputs\",\n \"def clamp(n, min_, max_):\\n return max(min(max_,n),min_)\",\n \"def saturate_scalar_minmax(value, max_value, min_value):\\n mean = (max_value + min_value)/2.0\\n half_range = (max_value - min_value)/2.0\\n return saturate_vector_dg(value-mean, half_range) + mean\",\n \"def min_max(tr):\\n tr = tr.astype(float)\\n mm = tr.min() / tr.max()\\n return mm\",\n \"def min_max_normalization(x, min_x = None, max_x = None):\\n if min_x is None:\\n min_x = np.min(x, axis=0)\\n if max_x is None:\\n max_x = np.max(x, axis=0)\\n return (x - (min_x)) / (max_x - min_x), min_x, max_x\",\n \"def minmax(self):\\n return self._data_lim[self._n_overlay - 1]\",\n \"def minmax(self):\\r\\n vx = [v[0] for v in self.vl]\\r\\n vy = [v[1] for v in self.vl]\\r\\n self.xmax, self.xmin = max(vx), min(vx)\\r\\n self.ymax, self.ymin = max(vy), min(vy)\",\n \"def get_range(lst):\\n return float(max(lst)) - float(min(lst))\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def minMaxFonc(liste):\\n\\n return min(liste), max(liste)\",\n \"def min_max(arr, arr_size):\\n max_t = arr[0]\\n min_t = arr[0]\\n for i in range(arr_size):\\n if arr[i] > max_t:\\n max_t = arr[i]\\n if arr[i] < min_t:\\n min_t = arr[i]\\n return min_t, max_t\",\n \"def clamp(value, mn, mx):\\n\\n return max(min(value, mx), mn)\",\n \"def _normalize_range():\\n clipped = tf.clip_by_value(inputs, self.minimum, self.maximum)\\n return -1 + 2 * (clipped - self.minimum) / length\",\n \"def minmax_normalize(X):\\n # X -= X.min()\\n # X /= X.max()\\n # X -= 0.5\\n X = (X-X.min()) / (X.max() - X.min())\\n return X\",\n \"def spec_min_max(self):\\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\\n 2048,2048,2048,2048,2048])\\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0])\\n return np.vstack((spec_min, spec_max))\",\n \"def quickMinMax(self, targetSize=1e6):\\n data = self.image\\n if targetSize < 2: # keep at least two pixels\\n targetSize = 2\\n while True:\\n h, w = data.shape[:2]\\n if h * w <= targetSize: break\\n if h > w:\\n data = data[::2, ::] # downsample first axis\\n else:\\n data = data[::, ::2] # downsample second axis\\n return self._xp.nanmin(data), self._xp.nanmax(data)\",\n \"def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\\n assert \\\\\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\\\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\\\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\\n if dtype is None:\\n dtype = images.dtype\\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)\",\n \"def min_max(items):\\n return min(items), max(items)\",\n \"def _min_max_scale(arr, new_range=(0, 255)):\\n # get array's current min and max\\n mn = arr.min()\\n mx = arr.max()\\n\\n # check if scaling needs to be done to be in new_range\\n if mn < new_range[0] or mx > new_range[1]:\\n # perform min-max scaling\\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\\n else:\\n # return array if already in range\\n scaled = arr\\n\\n return scaled\",\n \"def argmin(tensor):\\n raise NotImplementedError\",\n \"def get_max_min(block_size):\\r\\n return (int(block_size / 2), int((block_size - 1) / 2))\",\n \"def cpfclamp(f, min_, max_):\\n return min(max(f, min_), max_)\",\n \"def minMax(df):\\n max_, min_ = df.max(axis=0), df.min(axis=0)\\n midrange = (max_ + min_) / 2\\n half_range = (max_ - min_) / 2\\n return (df - midrange) / half_range\",\n \"def data_range(x):\\n return max(x)-min(x)\",\n \"def view_limits(self, dmin, dmax):\\n base = self._select_base(dmin, dmax)\\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\\n vmin = base.le(dmin)\\n vmax = base.ge(dmax)\\n if vmin == vmax:\\n vmin -= 1\\n vmax += 1\\n else:\\n vmin = dmin\\n vmax = dmax\\n\\n return mtransforms.nonsingular(vmin, vmax)\",\n \"def minMaxLoc(img):\\n\\tmaskVar = mask(img)\\n\\tpt = cv2.minMaxLoc(grayscale(img), maskVar)\\n\\td = {\\\"minVal\\\": pt[0], \\\"maxVal\\\":pt[1], \\\"minLoc\\\":pt[2], \\\"maxLoc\\\":pt[3]}\\n\\treturn d\",\n \"def get_min_max(ints):\\n print(f\\\"input arr is {ints}\\\")\\n max=0\\n min=len(ints)-1\\n for i in range(1,len(ints)):\\n if ints[i]>ints[max]:\\n temp=ints[i]\\n ints[i]=ints[max]\\n ints[max]=temp\\n if ints[i]<ints[min]:\\n temp=ints[i]\\n ints[i]=ints[min]\\n ints[min]=temp\\n #print(f\\\"max value is {ints[max]}\\\")\\n #print(f\\\"min value is {ints[min]}\\\")\\n return(ints[min],ints[max])\",\n \"def minmax ( self , nshoots = 100000 ) :\\n ## try to get minmax directly from pdf/function \\n if self.tricks and hasattr ( self.pdf , 'function' ) :\\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \\n f = self.pdf.function()\\n if hasattr ( f , 'minmax' ) :\\n try :\\n mn , mx = f.minmax()\\n if 0<= mn and mn <= mx and 0 < mx : \\n return mn , mx\\n except :\\n pass\\n if hasattr ( f , 'max' ) :\\n try :\\n mx = f.max()\\n if 0 < mx : return 0 , mx\\n except :\\n pass\\n\\n ## check RooAbsReal functionality\\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\\n if 0 < code :\\n mx = self.pdf.maxVal ( code )\\n if 0 < mx : return 0 , mx\\n \\n ## not try to use random\\n \\n mn , mx = -1 , -10\\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\\n \\n if not self.xminmax() : return ()\\n if not self.yminmax() : return ()\\n \\n mn , mx = -1 , -10\\n xmn , xmx = self.xminmax()\\n ymn , ymx = self.yminmax()\\n for i in range ( nshoots ) : \\n xx = random.uniform ( xmn , xmx )\\n yy = random.uniform ( ymn , ymx )\\n with SETVAR ( self.xvar ) :\\n with SETVAR ( self.yvar ) :\\n self.xvar.setVal ( xx )\\n self.yvar.setVal ( yy )\\n vv = self.pdf.getVal()\\n if mn < 0 or vv < mn : mn = vv\\n if mx < 0 or vv > mx : mx = vv\\n \\n return mn , mx\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def min_max_scale(self, feature_range=(0, 1)):\\n\\n if len(feature_range) != 2:\\n raise AttributeError(\\n \\\"Error: `feature_range` doesn't look like a 2-element tuple?\\\"\\n )\\n if feature_range[1] < feature_range[0]:\\n raise AttributeError(\\\"Error: `feature_range` isn't increasing?\\\")\\n\\n # use self.__class__ so that child classes can inherit this method\\n return self.__class__(\\n min_max_scale(self.spectrogram, feature_range=feature_range),\\n frequencies=self.frequencies,\\n times=self.times,\\n decibel_limits=self.decibel_limits,\\n )\",\n \"def min_max(my_list):\\n print(\\\"Min = \\\",min(my_list,key = abs))\\n print(\\\"Max = \\\",max(my_list,key = abs))\",\n \"def normalizeToRange(data,max=255,min=0):\\n if min: return (max-min)*normalize(data)+min\\n else: return max*normalize2(data) # speeds up operation\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def masked_minimum(data, mask, dim=1):\\n axis_maximums = tf.reduce_max(data, dim, keepdims=True)\\n masked_minimums = tf.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def x_y_coor_min_max(x_y_coor):\\n\\tx_range = [np.min(x_y_coor[\\\"X\\\"]),np.max(x_y_coor[\\\"X\\\"])]\\n\\ty_range = [np.min(x_y_coor[\\\"Y\\\"]),np.max(x_y_coor[\\\"Y\\\"])]\\n\\treturn x_range, y_range\",\n \"def map_range(x, in_min, in_max, out_min, out_max):\\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\\n if out_min <= out_max:\\n return max(min(mapped, out_max), out_min)\\n return min(max(mapped, out_max), out_min)\",\n \"def find_max_min(self, col):\\n self.max = max(col)\\n self.min = min(col)\",\n \"def maxima_in_range(r, g_r, r_min, r_max):\\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\\n g_r_slice = g_r[idx]\\n g_r_max = g_r_slice[g_r_slice.argmax()]\\n idx_max, _ = find_nearest(g_r, g_r_max)\\n return r[idx_max], g_r[idx_max]\",\n \"def data_range(xs: List[float]) -> float:\\n return max(xs) - min(xs)\",\n \"def masked_minimum(data, mask, dim=1):\\n # sourced from:\\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L141-L157\\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\\n masked_minimums = tf.math.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def clamp(minimum, n, maximum):\\n return max(minimum, min(n, maximum))\",\n \"def min_max(lst):\\r\\n my_min = None\\r\\n my_max = None\\r\\n for num in lst:\\r\\n if (my_min and my_max) is not None:\\r\\n # recalculate running min and max:\\r\\n if num < my_min:\\r\\n my_min = num\\r\\n continue\\r\\n if num > my_max:\\r\\n my_max = num\\r\\n else:\\r\\n my_min = num\\r\\n my_max = num\\r\\n ans = (my_min, my_max)\\r\\n return ans\",\n \"def vc_clamp(x, lb, ub):\\n\\n y = min(x, ub)\\n y = max(y, lb)\\n\\n return y\",\n \"def view_limits(self, vmin, vmax):\\n return vmin, vmax\\n # return nonsingular(vmin, vmax)\",\n \"def minima_in_range(r, g_r, r_min, r_max):\\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\\n g_r_slice = g_r[idx]\\n g_r_min = g_r_slice[g_r_slice.argmin()]\\n idx_min, _ = find_nearest(g_r, g_r_min)\\n return r[idx_min], g_r[idx_min]\",\n \"def clip(tensor, a_min=None, a_max=None):\\n raise NotImplementedError\",\n \"def clamp(value, min_value, max_value):\\n return max(min_value, min(value, max_value))\",\n \"def getColorRange(self):\\n vmax=self.data_matrix.max()\\n vmin=self.data_matrix.min()\\n\\n if vmax * vmin < 0: # ie number range spans +ve and -ve\\n vmax = max([vmax, abs(vmin)])\\n vmin = -1*vmax\\n\\n return vmax,vmin\",\n \"def clamp(n, minn, maxn):\\n return max(min(maxn, n), minn)\",\n \"def minMax2(x):\\r\\n\\r\\n iMinMax = [0 for i in range(2)]\\r\\n num = len(x)[0]\\r\\n\\r\\n iMin = 0\\r\\n iMax = 0\\r\\n\\r\\n #// Search for minimum and maximum in row 0 - linear values:\\r\\n min = x[0][iMin]\\r\\n max = x[0][iMax]\\r\\n\\r\\n for i in range(1, num):\\r\\n\\r\\n if (x[0][i] < min): \\r\\n min = x[0][i]\\r\\n iMin = i\\r\\n \\r\\n\\r\\n if (x[0][i] > max): \\r\\n max = x[0][i]\\r\\n iMax = i\\r\\n \\r\\n iMinMax[0] = iMin\\r\\n iMinMax[1] = iMax\\r\\n\\r\\n return iMinMax\",\n \"def _argmax(self, input_tensor, dimension, c):\\n with self.session.graph.as_default():\\n min_values = tf.reduce_min(input_tensor, reduction_indices=[dimension,], keep_dims=True)\\n not_c = tf.abs(c - 1)\\n\\n return tf.argmax(input_tensor * c + not_c * min_values, dimension)\",\n \"def minmaxdenorm(v, minv, maxv):\\n v *= maxv - minv\\n v += minv\\n return v\",\n \"def _min_in_bounds(self, min):\\n if min <= self.valmin:\\n if not self.closedmin:\\n return self.val[0]\\n min = self.valmin\\n\\n if min > self.val[1]:\\n min = self.val[1]\\n return self._stepped_value(min)\",\n \"def clip_range(x, xlim):\\n return min([max([x, xlim[0]]), xlim[1]])\",\n \"def map_to_range(val, old_min, old_max, new_min, new_max):\\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)\",\n \"def minmax(xs):\\n min_val = None\\n max_val = None\\n for x in xs:\\n if min_val is None or x < min_val:\\n min_val = x\\n if max_val is None or x > max_val:\\n max_val = x\\n return (min_val, max_val)\",\n \"def masked_maximum(data, mask, dim=1):\\n axis_minimums = tf.reduce_min(data, dim, keepdims=True)\\n masked_maximums = tf.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim,\\n keepdims=True) + axis_minimums\\n return masked_maximums\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def xminmax ( self ) :\\n return self.xvar.minmax()\",\n \"def minMax(x):\\r\\n\\r\\n iMinMax = [0 for i in range(2)]\\r\\n\\r\\n num = len(x)\\r\\n #//System.out.println(\\\"MinMax: num: \\\" + num);\\r\\n\\r\\n iMin = 0\\r\\n iMax = 0\\r\\n min = x[iMin]\\r\\n max = x[iMax]\\r\\n\\r\\n for i in range(1, num):\\r\\n\\r\\n #//System.out.println(\\\"MinMax: i , current min, x : \\\" + i + \\\" \\\" + min + \\\" \\\" + x[i]);\\r\\n if (x[i] < min): \\r\\n #//System.out.println(\\\"MinMax: new min: if branch triggered\\\" );\\r\\n min = x[i]\\r\\n iMin = i\\r\\n \\r\\n #//System.out.println(\\\"MinMax: new min: \\\" + min);\\r\\n\\r\\n if (x[i] > max): \\r\\n max = x[i]\\r\\n iMax = i\\r\\n \\r\\n\\r\\n \\r\\n #//System.out.println(\\\"MinMax: \\\" + iMin + \\\" \\\" + iMax);\\r\\n\\r\\n iMinMax[0] = iMin\\r\\n iMinMax[1] = iMax\\r\\n\\r\\n return iMinMax\",\n \"def standardize_x(\\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\\n):\\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\\n raise ValueError(\\n \\\"Either *both* or *neither* of x_min, x_max need to be supplied!\\\"\\n )\\n if x_min is None:\\n x_min = torch.min(x, 0)[0]\\n x_max = torch.max(x, 0)[0]\\n x = (x - x_min) / (x_max - x_min)\\n return x, x_min, x_max\",\n \"def masked_minimum(data, mask, dim=1):\\n axis_maximums = math_ops.reduce_max(data, dim, keepdims=True)\\n masked_minimums = math_ops.reduce_min(\\n math_ops.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def _xywh2min_max(box):\\n x, y, w, h = box\\n return np.array([x, y, x+w, y+h])\",\n \"def constrain(n: int, low: int, high: int) -> int:\\n return max(min(n, high), low)\",\n \"def _masked_minimum(data, mask, dim=1):\\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\\n masked_minimums = (\\n tf.math.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim, keepdims=True\\n )\\n + axis_maximums\\n )\\n return masked_minimums\",\n \"def min_max(self, data, era):\\n return 0, np.max(data)\",\n \"def find_max_min(number):\\n if max(number) == min(number):\\n return [len(number)]\\n return [min(number), max(number)]\",\n \"def clamp(n, minn, maxn):\\n return max(min(maxn, n), minn)\",\n \"def dim_zero_min(x: Tensor) ->Tensor:\\n return torch.min(x, dim=0).values\",\n \"def range(self):\\r\\n\\t\\treturn max(self.sample) - min(self.sample)\",\n \"def min():\\n return KeeperOfMinOrMax(int.__gt__)\",\n \"def convert_clip(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n dtype = infer_type(x).checked_type.dtype\\n # if the min/max value is a tensor\\n min_max_is_tensor = False\\n if op.input(\\\"Min\\\"):\\n min_value = g.get_node(op.input(\\\"Min\\\")[0])\\n min_value, infered = try_infer_value(min_value, g.get_params())\\n if infered:\\n min_value = min_value.tolist()[0]\\n if isinstance(min_value, _expr.Expr):\\n min_max_is_tensor = True\\n else:\\n min_value = op.attr(\\\"min\\\")\\n\\n if op.input(\\\"Max\\\"):\\n max_value = g.get_node(op.input(\\\"Max\\\")[0])\\n max_value, infered = try_infer_value(max_value, g.get_params())\\n if infered:\\n max_value = max_value.tolist()[0]\\n if isinstance(max_value, _expr.Expr):\\n min_max_is_tensor = True\\n else:\\n max_value = op.attr(\\\"max\\\")\\n\\n if min_max_is_tensor:\\n if not isinstance(min_value, _expr.Expr):\\n min_value = _op.const(min_value, dtype)\\n if not isinstance(max_value, _expr.Expr):\\n max_value = _op.const(max_value, dtype)\\n out = _op.maximum(x, min_value)\\n out = _op.minimum(out, max_value)\\n else:\\n out = _op.clip(x, min_value, max_value)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def masked_maximum(data, mask, dim=1):\\n # sourced from:\\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L122-L138\\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\\n masked_maximums = tf.math.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim,\\n keepdims=True) + axis_minimums\\n return masked_maximums\",\n \"def normalize_minmax(data):\\n _min = np.float(np.min(data))\\n _max = np.float(np.max(data))\\n if (_max-_min)!=0:\\n img = (data - _min) / (_max-_min)\\n else:\\n img = np.zeros_like(data) \\n return img\",\n \"def print_minmax(arr):\\n print(arr.shape)\\n for i in range(arr.shape[1]):\\n print(transfer[i], arr[:,i].min(), arr[:,i].max())\",\n \"def _min_or_max_grad(x, axis, out, dout):\\n # input_shape = [2, 3] axis = [1]\\n input_shape = shape_op(x)\\n # output_shape_kept_dims = [2, 1]\\n output_shape_kept_dims = reduced_shape(input_shape, axis)\\n y = reshape(out, output_shape_kept_dims)\\n grad = reshape(dout, output_shape_kept_dims)\\n indicators = F.cast(F.equal(y, x), F.dtype(grad))\\n min_num = F.cast(F.scalar_to_array(1e-24), F.dtype(grad))\\n num_selected = reshape(reduce_sum(indicators, axis), output_shape_kept_dims) + min_num\\n return indicators / num_selected * grad\",\n \"def minmax(value):\\n return min(0xff, max(0, value))\",\n \"def _masked_maximum(data, mask, dim=1):\\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\\n masked_maximums = (\\n tf.math.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim, keepdims=True\\n )\\n + axis_minimums\\n )\\n return masked_maximums\",\n \"def scale_from_minmax(\\n col: np.ndarray, minmax: Optional[Tuple[float, float]]\\n) -> np.ndarray:\\n if minmax is None:\\n return np.zeros_like(col)\\n else:\\n min_, max_ = minmax\\n assert max_ - min_ >= FLOAT_TOL\\n return 2 * (col - min_) / (max_ - min_) - 1\",\n \"def atmax(a,upperlimit,dimension=None,inclusive=1):\\r\\n if inclusive: upperfcn = N.less\\r\\n else: upperfcn = N.less_equal\\r\\n if dimension == None:\\r\\n a = N.ravel(a)\\r\\n dimension = 0\\r\\n if upperlimit == None:\\r\\n upperlimit = N.maximum.reduce(N.ravel(a))+1\\r\\n smallest = N.minimum.reduce(N.ravel(a))\\r\\n ta = N.where(upperfcn(a,upperlimit),a,smallest)\\r\\n return N.maximum.reduce(ta,dimension)\",\n \"def min_max(arr: StaticArray) -> ():\\n minimum = arr.get(0) # sets min to first element\\n maximum = arr.get(0) # sets max to first element\\n # iterate over the elements in the array to check for < or >\\n for index in range(arr.size()):\\n if arr[index] < minimum: # if element is less than the current min, min = new element\\n minimum = arr[index]\\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\\n maximum = arr[index]\\n return minimum, maximum\",\n \"def atmin(a,lowerlimit=None,dimension=None,inclusive=1):\\r\\n if inclusive: lowerfcn = N.greater\\r\\n else: lowerfcn = N.greater_equal\\r\\n if dimension == None:\\r\\n a = N.ravel(a)\\r\\n dimension = 0\\r\\n if lowerlimit == None:\\r\\n lowerlimit = N.minimum.reduce(N.ravel(a))-11\\r\\n biggest = N.maximum.reduce(N.ravel(a))\\r\\n ta = N.where(lowerfcn(a,lowerlimit),a,biggest)\\r\\n return N.minimum.reduce(ta,dimension)\",\n \"def bounds(x, xMin, xMax):\\n if (x < xMin):\\n x = xMin\\n elif (x > xMax):\\n x = xMax\\n return(x)\",\n \"def constrain(small, value, big):\\n return min(max(value, small), big)\",\n \"def clamp(minimum, value, maximum):\\n return max(minimum, min(maximum, value))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7547379","0.7123834","0.7107737","0.7107506","0.7039821","0.6998676","0.6972081","0.6958474","0.69525874","0.69308096","0.68104637","0.6738522","0.6683714","0.6664642","0.6625571","0.66234326","0.6614864","0.6614411","0.65762603","0.6518506","0.6502009","0.64505905","0.64335","0.6400552","0.63645804","0.6363652","0.63625807","0.63581216","0.63397473","0.63231874","0.6320694","0.6282743","0.62816304","0.62504685","0.6246462","0.6239864","0.6236875","0.62323993","0.6228815","0.6225808","0.6203643","0.61984366","0.6179767","0.6175613","0.6163097","0.6162641","0.6162007","0.61467123","0.6146614","0.61407256","0.6139613","0.61332035","0.61278105","0.61269826","0.6126322","0.611721","0.6116931","0.61143905","0.61111253","0.60827804","0.6082666","0.60818726","0.60813046","0.6075315","0.60743105","0.60729986","0.6072331","0.6058691","0.6058668","0.60573447","0.6055054","0.60512054","0.6037602","0.603136","0.6015259","0.601111","0.60106814","0.60102594","0.59950864","0.597688","0.5973488","0.59589803","0.5958897","0.59546065","0.5952997","0.59528464","0.5948861","0.5948317","0.5947303","0.59440017","0.59395176","0.59359807","0.593572","0.59346414","0.5930939","0.5925969","0.5920001","0.59190047","0.5913487","0.59080267","0.59056157"],"string":"[\n \"0.7547379\",\n \"0.7123834\",\n \"0.7107737\",\n \"0.7107506\",\n \"0.7039821\",\n \"0.6998676\",\n \"0.6972081\",\n \"0.6958474\",\n \"0.69525874\",\n \"0.69308096\",\n \"0.68104637\",\n \"0.6738522\",\n \"0.6683714\",\n \"0.6664642\",\n \"0.6625571\",\n \"0.66234326\",\n \"0.6614864\",\n \"0.6614411\",\n \"0.65762603\",\n \"0.6518506\",\n \"0.6502009\",\n \"0.64505905\",\n \"0.64335\",\n \"0.6400552\",\n \"0.63645804\",\n \"0.6363652\",\n \"0.63625807\",\n \"0.63581216\",\n \"0.63397473\",\n \"0.63231874\",\n \"0.6320694\",\n \"0.6282743\",\n \"0.62816304\",\n \"0.62504685\",\n \"0.6246462\",\n \"0.6239864\",\n \"0.6236875\",\n \"0.62323993\",\n \"0.6228815\",\n \"0.6225808\",\n \"0.6203643\",\n \"0.61984366\",\n \"0.6179767\",\n \"0.6175613\",\n \"0.6163097\",\n \"0.6162641\",\n \"0.6162007\",\n \"0.61467123\",\n \"0.6146614\",\n \"0.61407256\",\n \"0.6139613\",\n \"0.61332035\",\n \"0.61278105\",\n \"0.61269826\",\n \"0.6126322\",\n \"0.611721\",\n \"0.6116931\",\n \"0.61143905\",\n \"0.61111253\",\n \"0.60827804\",\n \"0.6082666\",\n \"0.60818726\",\n \"0.60813046\",\n \"0.6075315\",\n \"0.60743105\",\n \"0.60729986\",\n \"0.6072331\",\n \"0.6058691\",\n \"0.6058668\",\n \"0.60573447\",\n \"0.6055054\",\n \"0.60512054\",\n \"0.6037602\",\n \"0.603136\",\n \"0.6015259\",\n \"0.601111\",\n \"0.60106814\",\n \"0.60102594\",\n \"0.59950864\",\n \"0.597688\",\n \"0.5973488\",\n \"0.59589803\",\n \"0.5958897\",\n \"0.59546065\",\n \"0.5952997\",\n \"0.59528464\",\n \"0.5948861\",\n \"0.5948317\",\n \"0.5947303\",\n \"0.59440017\",\n \"0.59395176\",\n \"0.59359807\",\n \"0.593572\",\n \"0.59346414\",\n \"0.5930939\",\n \"0.5925969\",\n \"0.5920001\",\n \"0.59190047\",\n \"0.5913487\",\n \"0.59080267\",\n \"0.59056157\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83787,"cells":{"query":{"kind":"string","value":"make all quantization_candidates op type nodes as part of the graph output."},"document":{"kind":"string","value":"def augment_graph(self):\n self.tensors_to_calibrate, value_infos = self.select_tensors_to_calibrate(self.model)\n for tensor in self.tensors_to_calibrate:\n if tensor not in self.model_original_outputs:\n self.model.graph.output.append(value_infos[tensor])\n\n onnx.save(\n self.model,\n self.augmented_model_path,\n save_as_external_data=self.use_external_data_format,\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 _collect_ipt_and_opt_nodes(self):\n for name, node in self._nodes_collection.items():\n if node.in_degree == 0:\n # NOTICE: what's usage of `scope`?\n self._input_nodes.append(name)\n\n if node.out_degree == 0:\n self._output_nodes.append(name)","def _query_quantizable_ops(self, matched_nodes, activation_dtype, weight_dtype):\n\n tf_quantizable_op_type = (\"Conv2D\", \"DepthwiseConv2dNative\",\n \"MaxPool\", \"AvgPool\", \"ConcatV2\", \"MatMul\", \"Pad\")\n conv_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax', 'kl'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n },\n 'weight': {\n 'dtype': weight_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_channel', 'per_tensor']\n }\n }\n matmul_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['asym', 'sym'],\n 'granularity': ['per_tensor']\n },\n 'weight': {\n 'dtype': weight_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n }\n }\n other_config = {\n 'activation': {\n 'dtype': activation_dtype,\n 'algorithm': ['minmax'],\n 'scheme': ['sym'],\n 'granularity': ['per_tensor']\n },\n }\n\n self.quantizable_op_details = OrderedDict()\n\n self._init_op_stat = {i: [] for i in tf_quantizable_op_type}\n for details in matched_nodes:\n node_op = details[-1][0]\n node_name = details[0]\n patterns = details[-1]\n pat_length = len(patterns)\n pattern_info = {\n 'sequence': [[','.join(patterns[:pat_length - i]) for i in range(pat_length)][0]],\n 'precision': ['int8']\n }\n if node_op in tf_quantizable_op_type and node_name not in self.exclude_node_names:\n self._init_op_stat[node_op].append(node_name)\n if self.unify_op_type_mapping[node_op].find(\"conv2d\") != -1:\n conv2d_int8_config = copy.deepcopy(conv_config)\n conv2d_int8_config['pattern'] = pattern_info\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = conv2d_int8_config\n elif self.unify_op_type_mapping[node_op].find(\"matmul\") != -1:\n matmul_int8_config = copy.deepcopy(matmul_config)\n matmul_int8_config['pattern'] = pattern_info\n # TODO enable the sym mode once the tf fixed the mkldequantize_op.cc bug.\n # is_positive_input = self.pre_optimizer_handle.has_positive_input(node_name)\n # matmul_scheme = 'sym' if is_positive_input else 'asym'\n matmul_scheme = ['asym']\n matmul_int8_config['activation']['scheme'] = matmul_scheme\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = matmul_int8_config\n else:\n self.quantizable_op_details[(\n node_name, self.unify_op_type_mapping[node_op]\n )] = copy.deepcopy(other_config)\n\n self.quantize_config['op_wise_config'][node_name] = (False, \"minmax\", False)\n return self.quantizable_op_details","def gen_graph(self):","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def _build_computation_graph(self):\n raise NotImplementedError","def build_graph(self):\n n_classes = self.n_classes\n\n (self.feed('data')\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\n .conv(3, 3, 256, 1, 1, name='conv3_1')\n .conv(3, 3, 256, 1, 1, name='conv3_2')\n .conv(3, 3, 256, 1, 1, name='conv3_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\n .conv(3, 3, 512, 1, 1, name='conv4_1')\n .conv(3, 3, 512, 1, 1, name='conv4_2')\n .conv(3, 3, 512, 1, 1, name='conv4_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\n .conv(3, 3, 512, 1, 1, name='conv5_1')\n .conv(3, 3, 512, 1, 1, name='conv5_2')\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\n\n self.compute_rDeRF() # dummy\n\n # Classification\n (self.feed('conv5_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\n .fc(4096, name='fc6')\n .dropout(0.5, name='drop6')\n .fc(4096, name='fc7')\n .dropout(0.5, name='drop7')\n # .make_time(name='drop7_reduced')\n .fc(n_classes, relu=False, name='cls_score')\n .softmax(name='cls_prob'))\n pass","def build_inference_graph(self):\n self.build_train_graph()","def build_graph(self):\n pass","def convert_voting_classifier(\n scope: Scope, operator: Operator, container: ModelComponentContainer\n):\n if scope.get_options(operator.raw_operator, dict(nocl=False))[\"nocl\"]:\n raise RuntimeError(\n \"Option 'nocl' is not implemented for operator '{}'.\".format(\n operator.raw_operator.__class__.__name__\n )\n )\n proto_dtype = guess_proto_type(operator.inputs[0].type)\n if proto_dtype != onnx_proto.TensorProto.DOUBLE:\n proto_dtype = onnx_proto.TensorProto.FLOAT\n op = operator.raw_operator\n n_classes = len(op.classes_)\n\n classes_ind_name = scope.get_unique_variable_name(\"classes_ind\")\n container.add_initializer(\n classes_ind_name,\n onnx_proto.TensorProto.INT64,\n (1, n_classes),\n list(range(n_classes)),\n )\n\n probs_names = []\n one_name = None\n for i, estimator in enumerate(op.estimators_):\n if estimator is None:\n continue\n\n op_type = sklearn_operator_name_map[type(estimator)]\n\n this_operator = scope.declare_local_operator(op_type, estimator)\n this_operator.inputs = operator.inputs\n\n label_name = scope.declare_local_variable(\"label_%d\" % i, Int64TensorType())\n prob_name = scope.declare_local_variable(\n \"voting_proba_%d\" % i, operator.inputs[0].type.__class__()\n )\n this_operator.outputs.append(label_name)\n this_operator.outputs.append(prob_name)\n\n if op.voting == \"hard\":\n if one_name is None:\n shape_name = scope.get_unique_variable_name(\"shape\")\n container.add_node(\n \"Shape\",\n prob_name.onnx_name,\n shape_name,\n name=scope.get_unique_operator_name(\"Shape\"),\n )\n zero_name = scope.get_unique_variable_name(\"zero\")\n container.add_node(\n \"ConstantOfShape\",\n shape_name,\n zero_name,\n name=scope.get_unique_operator_name(\"CoSA\"),\n value=make_tensor(\"value\", proto_dtype, (1,), [0.0]),\n op_version=9,\n )\n one_name = scope.get_unique_variable_name(\"one\")\n container.add_node(\n \"ConstantOfShape\",\n shape_name,\n one_name,\n name=scope.get_unique_operator_name(\"CoSB\"),\n value=make_tensor(\"value\", proto_dtype, (1,), [1.0]),\n op_version=9,\n )\n\n argmax_output_name = scope.get_unique_variable_name(\"argmax_output\")\n container.add_node(\n \"ArgMax\",\n prob_name.onnx_name,\n argmax_output_name,\n name=scope.get_unique_operator_name(\"ArgMax\"),\n axis=1,\n )\n\n equal_name = scope.get_unique_variable_name(\"equal\")\n container.add_node(\n \"Equal\",\n [argmax_output_name, classes_ind_name],\n equal_name,\n name=scope.get_unique_operator_name(\"Equal\"),\n )\n\n max_proba_name = scope.get_unique_variable_name(\"probsmax\")\n container.add_node(\n \"Where\",\n [equal_name, one_name, zero_name],\n max_proba_name,\n name=scope.get_unique_operator_name(\"Where\"),\n )\n prob_name = max_proba_name\n else:\n prob_name = prob_name.onnx_name\n\n if op.weights is not None:\n val = op.weights[i] / op.weights.sum()\n else:\n val = 1.0 / len(op.estimators_)\n\n weights_name = scope.get_unique_variable_name(\"w%d\" % i)\n container.add_initializer(weights_name, proto_dtype, [1], [val])\n wprob_name = scope.get_unique_variable_name(\"wprob_name\")\n apply_mul(scope, [prob_name, weights_name], wprob_name, container, broadcast=1)\n probs_names.append(wprob_name)\n\n if op.flatten_transform in (False, None):\n container.add_node(\n \"Sum\",\n probs_names,\n operator.outputs[1].full_name,\n name=scope.get_unique_operator_name(\"Sum\"),\n )\n else:\n raise NotImplementedError(\n \"flatten_transform==True is not implemented yet. \"\n \"You may raise an issue at \"\n \"https://github.com/onnx/sklearn-onnx/issues.\"\n )\n\n # labels\n label_name = scope.get_unique_variable_name(\"label_name\")\n container.add_node(\n \"ArgMax\",\n operator.outputs[1].full_name,\n label_name,\n name=scope.get_unique_operator_name(\"ArgMax\"),\n axis=1,\n )\n _finalize_converter_classes(\n scope,\n label_name,\n operator.outputs[0].full_name,\n container,\n op.classes_,\n proto_dtype,\n )","def _build_graph(self):\n pass","def _form_computation_graph(self, idx):\n _list, _set = list, set\n if type(idx) is int:\n node_layers = [np.array([idx], dtype=np.int64)]\n elif type(idx) is list:\n node_layers = [np.array(idx, dtype=np.int64)]\n\n for _ in range(self.n_layers):\n prev = node_layers[-1]\n arr = [node for node in prev]\n arr.extend([e[0] for node in arr for e in self.nbrs_t[node]])\n arr = np.array(_list(_set(arr)), dtype=np.int64)\n node_layers.append(arr)\n node_layers.reverse()\n\n mappings = [{j: i for (i, j) in enumerate(arr)} for arr in node_layers]\n\n return node_layers, mappings","def build_graph(self):\n for node in self.graph.nodes():\n self.c2py[node] = PyNode(node)\n for _input in node.inputs():\n if _input not in self.c2py:\n self.c2py[_input] = PyNode(_input, True)\n if _input in self.forward_edge:\n self.forward_edge[_input].append(node)\n else:\n self.forward_edge[_input] = [node]\n for output in node.outputs():\n if output not in self.c2py:\n self.c2py[output] = PyNode(output, True)\n if node in self.forward_edge:\n self.forward_edge[node].append(output)\n else:\n self.forward_edge[node] = [output]","def build_graph(self):\n self.__create_placeholders()\n self.__create_encoder()\n self.__create_latent()\n self.__create_decoder()\n self.__create_loss()\n self.__create_generate()\n self.__create_reconstruct()\n self.__create_optimizer()\n self.__create_summary()","def _select_implementations(self, graph, memory_manager):\n implementations = {}\n for node in graph.nodes:\n choices = []\n for op in OperationRegistry.get_ops(node.op_type):\n candidate = op.create(node, graph, memory_manager)\n if candidate is not None:\n choices.append(candidate)\n\n if len(choices) >= 1:\n implementations[node] = choices[0]\n else:\n implementations[node] = None\n\n return implementations","def create_nodes(self):","def build_graph(self):\n raise NotImplementedError","def convert_type(self):\r\n tree = self.substitute.tree_\r\n classes = self.substitute.classes_\r\n node_list = []\r\n for i in range(tree.capacity):\r\n if tree.feature[i] == -2:\r\n node_list.append(Node(label=classes[np.argmax(tree.value[i, 0, :])]))\r\n else:\r\n node_list.append(Node(tree.feature[i], tree.threshold[i]))\r\n for i in range(tree.capacity):\r\n if tree.children_left[i] != -1:\r\n node_list[i].left = node_list[tree.children_left[i]]\r\n node_list[tree.children_left[i]].parents.append(node_list[i]) if node_list[i] not in node_list[tree.children_left[i]].parents else node_list[tree.children_left[i]].parents\r\n if tree.children_right[i] != -1:\r\n node_list[i].right = node_list[tree.children_right[i]]\r\n node_list[tree.children_right[i]].parents.append(node_list[i]) if node_list[i] not in node_list[tree.children_right[i]].parents else node_list[tree.children_right[i]].parents\r\n return node_list[0]","def buildGraph(self):\r\n\r\n print 'Building graph...'\r\n\r\n self.buildQ()\r\n self.buildP()\r\n self.buildReconstructionTerm()\r\n self.buildConditionalPriorTerm()\r\n self.buildWPriorTerm()\r\n self.buildZPriorTerm()\r\n\r\n self.buildObjective()\r\n self.buildGrad()","def gen_nodes(self):\n self.nodes = []\n for i in range(self.num_nodes):\n self.nodes.append(Node(self.fk))","def build_graph(self):\n self._build_model()\n if self.mode == 'train':\n self._build_train_op()","def _create_graph(self, pools: List[Pool]):\n for pool in pools:\n self._add_nodes(pool.tokens)\n\n for pool in pools: # noqa: WPS440,WPS441\n self._add_edges(pool) # noqa: WPS441","def _build_networks(self):\n self.online_convnet = self._create_network(name='Online')\n self.target_convnet = self._create_network(name='Target')\n\n # Compute the Q-values which are used for action selection in the current\n # state.\n self._net_outputs = self.online_convnet(self.state_ph,\n self.num_quantile_samples)\n # Shape of self._net_outputs.quantile_values:\n # num_quantile_samples x num_actions.\n # e.g. if num_actions is 2, it might look something like this:\n # Vals for Quantile .2 Vals for Quantile .4 Vals for Quantile .6\n # [[0.1, 0.5], [0.15, -0.3], [0.15, -0.2]]\n # Q-values = [(0.1 + 0.15 + 0.15)/3, (0.5 + 0.15 + -0.2)/3].\n self._q_values = tf.reduce_mean(self._net_outputs.quantile_values, axis=0)\n self._q_argmax = tf.argmax(self._q_values, axis=0)\n self._policy_logits = tf.nn.softmax(self._q_values / self.tau, axis=0)\n self._stochastic_action = tf.random.categorical(\n self._policy_logits[None, Ellipsis],\n num_samples=1,\n dtype=tf.int32)[0][0]\n\n self._replay_net_outputs = self.online_convnet(self._replay.states,\n self.num_tau_samples)\n # Shape: (num_tau_samples x batch_size) x num_actions.\n self._replay_net_quantile_values = self._replay_net_outputs.quantile_values\n self._replay_net_quantiles = self._replay_net_outputs.quantiles\n\n # Do the same for next states in the replay buffer.\n self._replay_net_target_outputs = self.target_convnet(\n self._replay.next_states, self.num_tau_prime_samples)\n # Shape: (num_tau_prime_samples x batch_size) x num_actions.\n vals = self._replay_net_target_outputs.quantile_values\n self._replay_net_target_quantile_values = vals\n\n # Compute Q-values which are used for action selection for the states and\n # next states in the replay buffer.\n target_next_action = self.target_convnet(self._replay.next_states,\n self.num_quantile_samples)\n target_action = self.target_convnet(self._replay.states,\n self.num_quantile_samples)\n\n # Shape: (num_quantile_samples x batch_size) x num_actions.\n target_next_quantile_values_action = target_next_action.quantile_values\n # Shape: num_quantile_samples x batch_size x num_actions.\n target_next_quantile_values_action = tf.reshape(\n target_next_quantile_values_action,\n [self.num_quantile_samples, self._replay.batch_size, self.num_actions])\n\n # Shape: (num_quantile_samples x batch_size) x num_actions.\n target_quantile_values_action = target_action.quantile_values\n # Shape: num_quantile_samples x batch_size x num_actions.\n target_quantile_values_action = tf.reshape(target_quantile_values_action,\n [self.num_quantile_samples,\n self._replay.batch_size,\n self.num_actions])\n # Shape: batch_size x num_actions.\n self._replay_next_target_q_values = tf.squeeze(tf.reduce_mean(\n target_next_quantile_values_action, axis=0))\n self._replay_target_q_values = tf.squeeze(tf.reduce_mean(\n target_quantile_values_action, axis=0))\n\n self._replay_next_qt_argmax = tf.argmax(\n self._replay_next_target_q_values, axis=1)","def make_qnode_and_params(self, initial_expansion_strategy):\n n_layers = 2\n n_wires = 5\n\n dev = qml.device(\"default.qubit\", wires=n_wires)\n\n @qml.qnode(dev, expansion_strategy=initial_expansion_strategy)\n def circuit(params):\n qml.BasicEntanglerLayers(params, wires=range(n_wires))\n return qml.expval(qml.PauliZ(0))\n\n params_shape = qml.BasicEntanglerLayers.shape(n_layers=n_layers, n_wires=n_wires)\n rng = np.random.default_rng(seed=10)\n params = rng.standard_normal(params_shape)\n\n return circuit, params","def generate_operations(self):\n combinations = self.COMBINATIONS.items()[:self.limit]\n for (term1, term2), type in combinations:\n yield (term1, term2, type)","def build_graph(self):\n\t\tself._create_placeholders()\n\t\tself._create_embedding()\n\t\tself._create_recurrent_layers()\n\t\tself._create_de_embedding()\n\t\tself._create_loss()\n\t\tself._create_optimizer()\n\t\tself._create_summaries()","def build_node_graph(self):\n G = pgv.AGraph(strict=False, directed=True)\n temp_dict = defaultdict(int) #key - from_to_ip, val - counter\n\n for i, ip in enumerate(self.node_graph_dict.keys()):\n G.add_node(ip, shape='rect', label='%d' % i)\n logger.info(\"All nodes added\")\n\n for ip, droplist in self.node_graph_dict.iteritems():\n for gnid, dropids in droplist:\n for did in dropids:\n tip = self.gnid_ip_dict[self.oid_gnid_dict[did]]\n k = '{0}_{1}'.format(ip, tip)\n temp_dict[k] += 1\n\n for k, v in temp_dict.iteritems():\n ks = k.split('_')\n G.add_edge(ks[0], ks[1], weight=v)\n\n return G","def find_quantizer_nodes_to_cut(\n graph: NNCFGraph,\n quantizer_node: NNCFNode,\n quantizer_metatypes: List[OperatorMetatype],\n const_metatypes: List[OperatorMetatype],\n quantizable_metatypes: List[OperatorMetatype],\n quantize_agnostic_metatypes: List[OperatorMetatype],\n) -> Tuple[List[NNCFNode], List[NNCFNode]]:\n\n def _parse_node_relatives(node: NNCFNode, is_parents: bool):\n if node.metatype in quantizable_metatypes:\n ops_to_return_in_orig_prec.add(node)\n\n relatives = graph.get_previous_nodes(node) if is_parents else graph.get_next_nodes(node)\n for relative in relatives:\n if relative.metatype in quantizer_metatypes:\n if is_parents:\n if relative in seen_children:\n continue\n if relative not in to_cut:\n to_cut.append(relative)\n to_see_children.append(relative)\n else:\n seen_children.append(relative)\n elif relative.metatype not in const_metatypes:\n if relative not in seen_parents:\n to_see_parents.append(relative)\n if relative not in seen_children and relative.metatype in quantize_agnostic_metatypes:\n to_see_children.append(relative)\n\n seen_list = seen_parents if is_parents else seen_children\n seen_list.append(node)\n\n seen_children, seen_parents = [], []\n to_see_children, to_see_parents = [quantizer_node], []\n to_cut = [quantizer_node]\n ops_to_return_in_orig_prec = set()\n\n while to_see_parents or to_see_children:\n if to_see_children:\n _parse_node_relatives(to_see_children.pop(), is_parents=False)\n if to_see_parents:\n _parse_node_relatives(to_see_parents.pop(), is_parents=True)\n\n return to_cut, list(ops_to_return_in_orig_prec)","def _build_networks(self):\n # Calling online_convnet will generate a new graph as defined in\n # self._get_network_template using whatever input is passed, but will always\n # share the same weights.\n self.online_convnet = tf.make_template('Online', self._network_template)\n self.target_convnet = tf.make_template('Target', self._network_template)\n self._net_outputs = self.online_convnet(self.state_ph)\n\n self._replay_net_outputs = self.online_convnet(self._replay.states)\n self._replay_next_target_net_outputs = self.target_convnet(\n self._replay.next_states)\n\n if self.acting_policy == 'hyperbolic':\n self._q_argmax = tf.argmax(self._net_outputs.hyp_q_value, axis=1)[0]\n elif self.acting_policy == 'largest_gamma':\n self._q_argmax = tf.argmax(self._net_outputs.q_values[-1], axis=1)[0]\n else:\n raise NotImplementedError","def build_graph(self):\n\n\n\n self.inputs.append( #uint8\n tf.placeholder(tf.float32, shape=[None, None, None, self.channel],\n name='input/lr')) \n\n self.label.append(\n tf.placeholder(tf.float32, shape=[None, None, None, self.channel],\n name='label/hr'))","def _build_network(self):\n # self._observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.uint8, name=\"observation\")\n # self._observation = tf.to_float(self._observation) / 255.0\n # self._observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.float32, name=\"observation\")\n self._observation = self._obs_fn()\n self._action = tf.placeholder(dtype=tf.int32, shape=[None], name=\"action\")\n self._reward = tf.placeholder(dtype=tf.float32, shape=[None], name=\"reward\")\n self._done = tf.placeholder(dtype=tf.float32, shape=[None], name=\"done\")\n # self._next_observation = tf.placeholder(dtype=tf.uint8, shape=[None, *self._dim_obs], name=\"next_observation\")\n # self._next_observation = tf.to_float(self._next_observation) / 255.0\n # self._next_observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.float32, name=\"next_observation\")\n self._next_observation = self._obs_fn()\n\n with tf.variable_scope(\"main/qnet\"):\n # self._qvals = self._dense(self._observation)\n self._qvals = self._value_fn(self._observation)\n\n self._target_qvals = []\n for i in range(self._n_net):\n with tf.variable_scope(f\"target_{i}/qnet\"):\n self._target_qvals.append(self._value_fn(self._next_observation))","def _build_graph(self,\n question_word,\n question_word_mask,\n question_subword,\n question_subword_mask,\n question_char,\n question_char_mask,\n context_word,\n context_word_mask,\n context_subword,\n context_subword_mask,\n context_char,\n context_char_mask):\n with tf.variable_scope(\"graph\", reuse=tf.AUTO_REUSE):\n \"\"\"build representation layer for qanet model\"\"\"\n (question_feat, question_feat_mask, context_feat,\n context_feat_mask) = self._build_representation_layer(question_word, question_word_mask,\n question_subword, question_subword_mask, question_char, question_char_mask, context_word,\n context_word_mask, context_subword, context_subword_mask, context_char, context_char_mask)\n \n \"\"\"build understanding layer for qanet model\"\"\"\n (question_understanding, context_understanding, question_understanding_mask,\n context_understanding_mask) = self._build_understanding_layer(question_feat,\n context_feat, question_feat_mask, context_feat_mask)\n \n \"\"\"build interaction layer for qanet model\"\"\"\n answer_interaction, answer_interaction_mask = self._build_interaction_layer(question_understanding,\n context_understanding, question_understanding_mask, context_understanding_mask)\n \n \"\"\"build modeling layer for qanet model\"\"\"\n answer_modeling, answer_modeling_mask = self._build_modeling_layer(answer_interaction, answer_interaction_mask)\n \n \"\"\"build output layer for qanet model\"\"\"\n answer_output_list, answer_output_mask_list = self._build_output_layer(answer_modeling, answer_modeling_mask)\n answer_start_output = answer_output_list[0]\n answer_end_output = answer_output_list[1]\n answer_start_output_mask = answer_output_mask_list[0]\n answer_end_output_mask = answer_output_mask_list[1]\n \n return answer_start_output, answer_end_output, answer_start_output_mask, answer_end_output_mask","def QCNN_layer_gen(self):\n pixels = self.filter_size**2\n # filter size: 2^n only for this version!\n if np.log2(pixels) % 1 != 0:\n raise NotImplementedError(\"filter size: 2^n only available\")\n cirq_qubits = cirq.GridQubit.rect(self.filter_size, self.filter_size)\n # mapping input data to circuit\n input_circuit = cirq.Circuit()\n input_params = [sympy.symbols('a%d' %i) for i in range(pixels)]\n for i, qubit in enumerate(cirq_qubits):\n input_circuit.append(cirq.rx(np.pi*input_params[i])(qubit))\n # apply learnable gate set to QCNN circuit\n QCNN_circuit = cirq.Circuit()\n step_size = [2**i for i in range(np.log2(pixels).astype(np.int32))]\n for step in step_size:\n for target in range(0, pixels, 2*step):\n QCNN_circuit.append(self._QConv(step, target, cirq_qubits))\n # merge the circuits\n full_circuit = cirq.Circuit()\n full_circuit.append(input_circuit)\n full_circuit.append(QCNN_circuit)\n self.circuit = full_circuit # save circuit to the QCNN layer obj.\n self.params = input_params + self.learning_params\n self.op = cirq.Z(cirq_qubits[0])","def build_graph(self, name):\n with tf.variable_scope(name, reuse=tf.AUTO_REUSE):\n # change shape of input for when adding score\n self.input_positions = tf.placeholder(tf.float32, shape=(None, 1, 2,6), name='inputs')\n self.target_q = tf.placeholder(shape=[None], dtype=tf.float32, name='target')\n net = self.input_positions\n\n net = tf.layers.conv2d(inputs=net, filters=128, kernel_size=6,\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\n data_format=\"channels_last\", padding='SAME', activation=tf.nn.relu)\n net = tf.layers.conv2d(inputs=net, filters=128, kernel_size=6,\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\n data_format=\"channels_last\", padding='SAME', activation=tf.nn.relu)\n net = tf.layers.conv2d(inputs=net, filters=64, kernel_size=6,\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\n data_format=\"channels_last\", padding='SAME', activation=tf.nn.relu)\n\n net = tf.layers.flatten(net)\n\n net = self.add_dense_layer(net, 12, tf.nn.relu)\n\n self.value = self.add_dense_layer(net, 1, name='state_q_value')\n self.advantage = self.add_dense_layer(net, 12, name='action_advantage')\n\n self.q_values = tf.add(self.value, tf.subtract(self.advantage,\n tf.reduce_mean(self.advantage, axis=1, keepdims=True)),\n name=\"action_q_values\")\n\n self.probabilities = tf.nn.softmax(self.q_values, name='probabilities')\n\n self.actions = tf.placeholder(shape=[None], dtype=tf.int32, name='actions')\n self.actions_onehot = tf.one_hot(self.actions, 12, dtype=tf.float32)\n self.q = tf.reduce_sum(tf.multiply(self.q_values, self.actions_onehot), axis=1, name=\"selected_action_q\")\n\n tf.summary.histogram(\"Action_Q_values\", self.q)\n\n self.td_error = tf.square(self.target_q - self.q)\n self.loss = tf.reduce_mean(self.td_error, name=\"q_loss\")\n\n tf.summary.scalar(\"Q_Loss\", self.loss)\n self.reg_losses = tf.identity(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, scope=name),\n name=\"reg_losses\")\n\n reg_loss = self.beta * tf.reduce_mean(self.reg_losses)\n tf.summary.scalar(\"Regularization_loss\", reg_loss)\n\n self.merge = tf.summary.merge_all()\n\n self.total_loss = tf.add(self.loss, reg_loss, name=\"total_loss\")\n self.train_step = tf.train.GradientDescentOptimizer(learning_rate=self.learningRate). \\\n minimize(self.total_loss, name='train')","def quantify(self, instances):\n ...","def append_available_node_categories(self):\n available_node_types = self.graph.creation_field.available_items\n for types in self.configuration.maya.available_node_categories:\n node_types = pmc.listNodeTypes(types)\n for node_type in node_types:\n if not node_type in available_node_types:\n available_node_types.append(node_type)\n\n self.graph.creation_field.available_items = available_node_types","def __init__(self, data=None, cliques=None, taxons=None, namesMap=None, **attr):\n \n if cliques is not None:\n if namesMap:\n nmap = namesMap.getMap()\n cliques = [ [ nmap[n] for n in nset ] for nset in cliques ]\n \n # prevent self-loops\n cliques = [ list(set(nset)) for nset in cliques ]\n \n # attributes dicts\n hyperb_weight = lambda ts: 1/(ts-1) \n e_attr_hyperbWeight=dict()\n e_attr_taxon=dict()\n e_attr_count=dict()\n \n # build edges from records\n if taxons is None: cliques_taxons = map( lambda c: (c,None), cliques)\n else: cliques_taxons = zip(cliques,taxons)\n for clique,taxon in cliques_taxons:\n teamsize=len(clique)\n edgesFromClique = itertools.combinations(clique,2)\n for e in edgesFromClique:\n e = tuple(sorted(e))\n e_attr_count[e] = e_attr_count.get(e,0)+1\n e_attr_taxon[e] = e_attr_taxon.get(e,[])+[taxon] if taxons is not None else None\n e_attr_hyperbWeight[e] = e_attr_hyperbWeight.get(e,0)+hyperb_weight(teamsize)\n \n edges = e_attr_count.keys()\n data = list(edges)\n \n super().__init__(incoming_graph_data=data,**attr)\n \n # insert nodes and set count attribute\n nodes_counts = Counter( col for clique in cliques for col in clique )\n nodes = nodes_counts.keys()\n \n self.add_nodes_from(nodes)\n networkx.set_node_attributes(self,values=nodes_counts,name='count')\n \n # set edges attributes\n networkx.set_edge_attributes(self,e_attr_count,'count')\n networkx.set_edge_attributes(self,e_attr_taxon,'taxons')\n networkx.set_edge_attributes(self,e_attr_hyperbWeight,'weight_hyperbolic')","def build_graph(self):\n # Print\n if self.verbose:\n print('Building Yolo Graph....')\n # Reset default graph\n tf.reset_default_graph()\n # Input placeholder\n self.x = tf.placeholder('float32', [None, 448, 448, 3])\n # conv1, pool1\n self.conv1 = self.conv_layer(1, self.x, 64, 7, 2)\n self.pool1 = self.maxpool_layer(2, self.conv1, 2, 2)\n # size reduced to 64x112x112\n # conv2, pool2\n self.conv2 = self.conv_layer(3, self.pool1, 192, 3, 1)\n self.pool2 = self.maxpool_layer(4, self.conv2, 2, 2)\n # size reduced to 192x56x56\n # conv3, conv4, conv5, conv6, pool3\n self.conv3 = self.conv_layer(5, self.pool2, 128, 1, 1)\n self.conv4 = self.conv_layer(6, self.conv3, 256, 3, 1)\n self.conv5 = self.conv_layer(7, self.conv4, 256, 1, 1)\n self.conv6 = self.conv_layer(8, self.conv5, 512, 3, 1)\n self.pool3 = self.maxpool_layer(9, self.conv6, 2, 2)\n # size reduced to 512x28x28\n # conv7 - conv16, pool4\n self.conv7 = self.conv_layer(10, self.pool3, 256, 1, 1)\n self.conv8 = self.conv_layer(11, self.conv7, 512, 3, 1)\n self.conv9 = self.conv_layer(12, self.conv8, 256, 1, 1)\n self.conv10 = self.conv_layer(13, self.conv9, 512, 3, 1)\n self.conv11 = self.conv_layer(14, self.conv10, 256, 1, 1)\n self.conv12 = self.conv_layer(15, self.conv11, 512, 3, 1)\n self.conv13 = self.conv_layer(16, self.conv12, 256, 1, 1)\n self.conv14 = self.conv_layer(17, self.conv13, 512, 3, 1)\n self.conv15 = self.conv_layer(18, self.conv14, 512, 1, 1)\n self.conv16 = self.conv_layer(19, self.conv15, 1024, 3, 1)\n self.pool4 = self.maxpool_layer(20, self.conv16, 2, 2)\n # size reduced to 1024x14x14\n # conv17 - conv24\n self.conv17 = self.conv_layer(21, self.pool4, 512, 1, 1)\n self.conv18 = self.conv_layer(22, self.conv17, 1024, 3, 1)\n self.conv19 = self.conv_layer(23, self.conv18, 512, 1, 1)\n self.conv20 = self.conv_layer(24, self.conv19, 1024, 3, 1)\n self.conv21 = self.conv_layer(25, self.conv20, 1024, 3, 1)\n self.conv22 = self.conv_layer(26, self.conv21, 1024, 3, 2)\n self.conv23 = self.conv_layer(27, self.conv22, 1024, 3, 1)\n self.conv24 = self.conv_layer(28, self.conv23, 1024, 3, 1)\n # size reduced to 1024x7x7\n # fc1, fc2, fc3\n self.fc1 = self.fc_layer(29, self.conv24, 512,\n flatten=True, linear=False)\n self.fc2 = self.fc_layer(\n 30, self.fc1, 4096, flatten=False, linear=False)\n self.fc3 = self.fc_layer(\n 31, self.fc2, 1470, flatten=False, linear=True)\n # Run session\n self.sess = tf.Session()\n self.sess.run(tf.global_variables_initializer())\n self.saver = tf.train.Saver()\n self.saver.restore(self.sess, self.weightFile)\n # Print\n print('Graph built.')","def index_rtypes(self):\n metric = self.index_metric\n out = {}\n for fnode in self.nodes.values():\n # only consider outgoing relationships because looping over\n # all object anyways, so will cover everything\n\n for (rtype, dest) in fnode.outgoing_relations:\n dnode = self.nodes[dest]\n\n # merge outgoing and attributes - distinction should not change\n # how vectors are formed\n a1 = fnode.rtypes | fnode.atypes\n b1 = dnode.rtypes | dnode.atypes\n c1 = a1 - b1\n d1 = b1 - a1\n e1 = b1 & a1\n f1 = b1 ^ a1\n g1 = b1 | a1\n\n # merge outgoing and attributes - distinction should not change\n # how vectors are formed\n #a2 = {b for a,b in fnode.outgoing_relations} | {b for a,b in fnode.attributes}\n #b2 = {b for a,b in dnode.outgoing_relations} | {b for a,b in dnode.attributes}\n #c2 = a2 - b2\n #d2 = b2 - a2\n #e2 = b2 & a2\n #f2 = b2 ^ a2\n #g2 = b2 | a2\n\n rval = out.setdefault(rtype, NULL_VEC())\n\n \"\"\"\n TODO: add similarity measure between node and prototype nodes\n\n Idea is to get a ground-truth value for the rtype by measuring\n how src --<rtype>--> dest compares to prototype transformations\n\n \n \n \"\"\"\n\n #types only\n score = np.array([metric(a1, b1),\n metric(a1, c1),#1\n metric(a1, e1),#2\n metric(a1, f1),#3\n metric(a1, g1),#4\n metric(b1, d1),#1\n metric(b1, e1),#2\n metric(b1, f1),#3\n metric(b1, g1),#4\n metric(c1, d1),\n metric(c1, f1),#5\n metric(d1, f1),#5\n metric(f1, g1),\n ],dtype=np.float)\n\n \n #types and objects\n #score = np.array([metric(a1, b1),\n # metric(a1, c1),\n # metric(a1, e1),\n # metric(a1, f1),\n # metric(a1, g1),\n # metric(b1, d1),\n # metric(b1, e1),\n # metric(b1, f1),\n # metric(b1, g1),\n # metric(c1, d1),\n # metric(c1, f1),\n # metric(c1, c2),\n # metric(c1, e2),\n # metric(d1, f1),\n # metric(d1, d2),\n # metric(d1, e2),\n # metric(f1, g1),\n # metric(a2, b2),\n # metric(a2, c2),\n # metric(a2, e2),\n # metric(a2, f2),\n # metric(a2, g2),\n # metric(b2, d2),\n # metric(b2, e2),\n # metric(b2, f2),\n # metric(b2, g2),\n # metric(c2, f2),\n # metric(d2, f2),\n # metric(f2, g2)],dtype=np.float)\n\n out[rtype] = rval + score\n\n #avg = np.mean(list(out.values()),axis=0)\n\n #maxm = np.max(list(out.values()),axis=0)\n\n\n \n #with open(\"rrw.pkl\",\"wb+\") as f:\n # pickle.dump(out, f, -1)\n\n #normalize everything\n for r,v in out.items():\n #out[r] = v / max(v)\n out[r] = v / sqrt(v.dot(v))\n #out[r] = softmax(v/maxm)\n #out[r] = softmax(v/max(v))\n #out[r] = softmax((v-avg)/maxm)\n\n #for debugging purposes\n #np.save(\"utils/vectest.npy\",np.array(list(out.values())))\n \n\n '''\n rcount = self.usage_counts\n vs1 = {}\n for rtype, vec in out.items():\n vs1[rtype] = softmax(vec/rcount[rtype])\n\n data = np.array(list(vs1.values()))\n d2 = data - PCA(data, 1)#eliminate projection onto first principal component\n\n for i,v in enumerate(vs1):#iteration order is preserved\n #rescale output\n out[v] = softmax(d2[i]/rcount[v])\n '''\n return out","def input_nodes(self):\n pass","def output_quantizers(self):\n return self._output_quantizers","def build_tf_graph(self):\n raise NotImplementedError","def _fill_quantizer_maps_for_outputs(self, activations_quantizer_map: Dict[str, StaticGridPerTensorQuantizer],\n io_tensor_map: List[OpToIOTensors]):\n for layer in range(self.module_to_quantize.num_layers):\n outputs = io_tensor_map[layer].outputs\n for index, quantizer_name in enumerate(onnx_outputs_to_quantizers):\n if quantizer_name is None:\n continue\n quantizer_name = quantizer_name.format(layer)\n if quantizer_name in self._output_quantizers:\n quantizer = self._output_quantizers[quantizer_name]\n elif quantizer_name in self._grouped_quantizers:\n quantizer = self._grouped_quantizers[quantizer_name]\n else:\n # Case when rnn and gru does not have c_l{} as an output\n continue\n if quantizer.enabled:\n activations_quantizer_map[outputs[index]] = quantizer","def construct_and_initialize_trainable_quantizers(self, quant_scheme):\n # Copy user settable attributes for outputs\n\n def _create_trainable_quantizer(bw, name, quantizer):\n \"\"\" create trainable quantizer from static grid quantizer. \"\"\"\n # Initialize trainable parameters to None\n self.register_parameter(f'{name}_encoding_min', None)\n self.register_parameter(f'{name}_encoding_max', None)\n # Pass name of tensor quantizer and reference of Wrapper to tensor quantizer\n # Input quantizer\n new_quantizer = tensor_quantizer_factory(bw, self._round_mode,\n quant_scheme,\n self._is_symmetric,\n enabled_by_default=True,\n data_type=self._data_type)\n new_quantizer.name = name\n new_quantizer.wrapper_ref = self\n new_quantizer.device = self.device\n initialize_learned_grid_quantizer_attributes(new_quantizer, quantizer)\n return new_quantizer\n\n new_grouped_quantizers = {name: _create_trainable_quantizer(self._activation_bw, name, quantizer)\n for name, quantizer in self._grouped_quantizers.items()}\n\n def create_trainable_quantizer(bw, name, quantizer):\n \"\"\" create trainable quantizer if not part of a group else reuse the group quantizer. \"\"\"\n if quantizer in self._grouped_quantizers.values():\n group_names = [n for n, q in self._grouped_quantizers.items() if q == quantizer]\n assert len(group_names) == 1\n # creating a param min/max references to the shared group min/max parameters.\n setattr(self, f'{name}_encoding_min', getattr(self, f'{group_names[0]}_encoding_min'))\n setattr(self, f'{name}_encoding_max', getattr(self, f'{group_names[0]}_encoding_max'))\n return new_grouped_quantizers[group_names[0]]\n\n return _create_trainable_quantizer(bw, name, quantizer)\n\n\n self._input_quantizers = {name: create_trainable_quantizer(self._activation_bw, name, quantizer)\n for name, quantizer in self.input_quantizers.items()}\n self._output_quantizers = {name: create_trainable_quantizer(self._activation_bw, name, quantizer)\n for name, quantizer in self.output_quantizers.items()}\n self._param_quantizers = {name: create_trainable_quantizer(self._weight_bw, name, quantizer)\n for name, quantizer in self._param_quantizers.items()}\n\n self._grouped_quantizers = new_grouped_quantizers\n self._mode = QcQuantizeOpMode.LEARN_ENCODINGS","def get_nodes_context(self, node_type_map):\n\n # first let's get the number of nodes of subgraphs rooted at each node, we make use of the special vertex indexing our representation has\n # by traversing in a decreasing order of vertex label, we can compute the number of leaves under each node in one pass\n # this is helpful if we want to compute a special kind of lis\n\n # num_nodes = {} # table of number of nodes of subgraphs rooted at the given node\n # n = self.graph.num_vertices()\n # for v_idx in reversed(range(n)):\n # v = self.graph.vertex(v_idx)\n # if v.out_degree() == 0: # leaf\n # num_nodes[v_idx] = 1\n # else:\n # print(v)\n # num_nodes[v_idx] = 1\n # for u in v.out_neighbors():\n # num_nodes[v_idx] += num_nodes[int(u)]\n\n # print(\"ratios:\")\n # for v in self.graph.vertices():\n # if v == 0: continue\n # print(\"{}:{}\".format(v, num_nodes[v] / (num_nodes[next(v.in_neighbors())] - 1)))\n\n # dump contexts in the form of:\n # [num_children, parent_type, child_1type, child_2type, ..., l_parent, l_child1, l_child2 ...]\n # where l_s are set to 1 for now\n get_type_idx = lambda _: node_type_map[self.graph.vp['type'][_]]\n contexts = []\n for v in self.graph.vertices():\n n = v.out_degree() # number of children\n if n != 0: # not a leaf\n contexts.append([n, get_type_idx(v)])\n for u in v.out_neighbors():\n contexts[-1].append(get_type_idx(u))\n contexts[-1].extend([1] * (n + 1))\n # print(contexts)\n return contexts","def _build(self):\n with tf.variable_scope (self.name + '_architecutre') as scope:\n images_square = unflatten_layer ( self.images )\n visualize_images(images_square)\n\n # Conv Layer 1\n conv1_out, params = conv_2d_layer ( input = images_square,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'enc_conv_1',\n visualize = True )\n process_params(params, name = self.name)\n e1_params = params\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\n\n # Conv Layer 2\n conv2_out, params = conv_2d_layer ( input = pool1_out,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'enc_conv_2' )\n process_params(params, name = self.name)\n e2_params = params\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\n\n flattened = flatten_layer(pool2_out)\n\n # Dropout Layer 1 \n flattened_dropout = dropout_layer ( input = flattened,\n prob = self.dropout_prob,\n name = 'enc_dropout_1') \n\n # Dot Product Layer 1\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\n neurons = HIDDEN_1,\n name = 'enc_dot_1')\n process_params(params, name = self.name)\n e3_params = params \n\n # Dropout Layer 2 \n fc1_out_dropout = dropout_layer ( input = fc1_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_2')\n # Dot Product Layer 2\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \n neurons = HIDDEN_2,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n e4_params = params \n\n # Dropout Layer 3 \n fc2_out_dropout = dropout_layer ( input = fc2_out,\n prob = self.dropout_prob,\n name = 'enc_dropout_3')\n \n # Dot Product Layer 2\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \n neurons = CODEWORD_LENGTH,\n activation = CODE_ACTIVATION,\n name = 'enc_dot_2')\n process_params(params, name = self.name)\n process_codeword_normalization_regularizer(self.codeword, \n coeff = AUTOENCODER_CODEWORD_COEFF,\n name = self.name)\n e5_params = params \n # tf.summary.histogram('codewords', self.codeword)\n # self.hash = threshold_layer ( input = self.codeword,\n # name = 'hash')\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\n # name = self.name)\n\n # Decoder ... \n decoder_1_out, params = dot_product_layer ( input = self.codeword, \n neurons = HIDDEN_2,\n params = [tf.transpose(e5_params[0]), None],\n name = 'decoder_dot_1')\n d1_params = params\n process_params([params[1]], name = self.name)\n \n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_1')\n\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \n neurons = HIDDEN_1,\n params = [tf.transpose(e4_params[0]), None],\n name = 'decoder_dot_2')\n d2_params = params\n process_params([params[1]], name = self.name)\n \n # dropout 2\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\n prob = self.dropout_prob,\n name = 'dec_dropout_2')\n\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \n neurons = 1250,\n params = [tf.transpose(e3_params[0]), None],\n name = 'decoder_dot_3')\n d3_params = params\n process_params([params[1]], name = self.name)\n\n # DeConv Layer 1\n # The output shapes need to be changed according to architecture.\n\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\n\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\n neurons = CONV_1_N,\n filter_size = CONV_2_FILT,\n output_shape = (12,12),\n # n_outs = MINI_BATCH_SIZE,\n stride = (1,1,1,1), \n params = [e2_params[0], None], \n name = 'dec_deconv_1' )\n\n process_params([params[1]], name = self.name)\n d4_params = params\n\n # DeConv Layer 2\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\n neurons = 1,\n filter_size = CONV_1_FILT,\n stride = (1,1,1,1),\n output_shape = (28,28),\n # n_outs = MINI_BATCH_SIZE, \n params = [e1_params[0], None], \n activation = 'tanh', \n name = 'dec_deconv_2' )\n \n process_params([params[1]], name = self.name)\n d5_params = params \n \n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\n visualize_images(decoded_images_square, name = 'decoded')\n # This is because transpose don't initialize.\n self.params = [ [e5_params[0], d1_params[1] ],\n [e4_params[0], d2_params[1] ],\n [e3_params[0], d3_params[1] ],\n [e2_params[0], d4_params[1] ],\n [e1_params[0], d5_params[1] ] ]\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + '_decoder_error') as scope:\n reconstruction_error = rmse(self.images, self.decoded) \n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \n tf.summary.scalar('reconstruction_error', reconstruction_error)\n\n self._cook_optimizer( \n lr = AUTOENCODER_LR, \n optimizer = AUTOENCODER_OPTIMIZER,\n l1_coeff = AUTOENCODER_L1_COEFF,\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)","def connected_component_nodes_with_size(self, size, showRending=False, printResults=False):\n\n graphsOfSize = self.connected_components_with_size(size)\n if showRending:\n ans = [{node:graph.rendering_of_graph_node(node) for node in super(SynonymNetwork, graph).nodes()} for graph in graphsOfSize]\n else:\n ans = [super(SynonymNetwork, graph).nodes() for graph in graphsOfSize]\n\n if printResults:\n for x in ans:\n if showRending:\n for k,v in x.iteritems(): print k + ' (' + v + ')'\n print\n else:\n print x\n else:\n return ans","def _make_circuit_instructions(n_qubits, depth, type_circuit):\n\n if type_circuit in [0, 1, 2]:\n\n # if type_circuit == 1:\n # if depth > 8:\n # raise ValueError(\n # \"For type-1 circuits, only at most depth=8 allowed!\"\n # )\n\n # define rotations for circuit in each layer, 0: identity, 1:X, 2:Y 3:Z\n ini_pauli = np.zeros([depth, n_qubits], dtype=int)\n\n # set first and second layer, rest comes later\n ini_pauli[0, :] = 2 # y rotation\n if depth > 1:\n ini_pauli[1, :] = 3 # z rotation\n\n # construct natural parameterized circuit\n # gives which type of entangling gates at each layer -- first entry is\n # first qubit index, second is second qubit index, third entry is type\n # of entangling gate\n entangling_gate_index_list = [[] for i in range(depth)]\n orderList = []\n for i in range(n_qubits//2):\n if i % 2 == 0:\n orderList.append(i//2)\n else:\n orderList.append((n_qubits-i)//2)\n\n if n_qubits > 1:\n shiftList = [orderList[0]]\n else:\n shiftList = []\n for i in range(1, n_qubits//2):\n shiftList.append(orderList[i])\n shiftList += shiftList[:-1]\n\n # this list gives which entangling gates are applied in which layer\n if type_circuit == 0:\n # deep natural PQC, includes non-nearest neighbor gates\n for j in range(min(len(shiftList), int(np.ceil(depth/2))-1)):\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n elif type_circuit == 1:\n # only do 2 entangling layers at max, and only do gates with\n # nearest neighbor and no ring\n for j in range(min(len(shiftList), 3)):\n if j == 0:\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n elif (j == 1 or j == 2):\n # exclude ring gate and gate 0,1 on third entangling layer\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(1, n_qubits//2)\n ]\n\n elif type_circuit == 2:\n # only do 3 regular entangling layers in a ring topology, then two\n # more phase gates with next-nearst neighbor, which requires one\n # swap. This adds 4 more parameters\n for j in range(min(len(shiftList), 3)):\n entangling_gate_index_list[1+2*j] = [\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\n for i in range(n_qubits//2)\n ]\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\n entangling_gate_index_list[1+2*3] = [\n [n_qubits-1, 1, 0],\n [0, n_qubits-2, 0]\n ]\n\n for i in range(len(entangling_gate_index_list)-1):\n if len(entangling_gate_index_list[i]) > 0:\n for j in range(len(entangling_gate_index_list[i])):\n qubit_index = entangling_gate_index_list[i][j][0]\n ini_pauli[i+1, qubit_index] = 2\n if i+2 < depth:\n ini_pauli[i+2, qubit_index] = 3\n\n elif type_circuit == 3:\n\n ini_pauli = np.ones([depth, n_qubits], dtype=int)*2\n\n for i in range(1, depth, 2):\n ini_pauli[i, :] = 3\n\n if n_qubits % 2 == 0:\n # even qubits ALT circuit needs to get rid of boundary rotations at\n # even entangling layers\n for i in range(4, depth, 4):\n ini_pauli[i, 0] = 0\n ini_pauli[i, -1] = 0\n if i+1 < depth:\n ini_pauli[i+1, 0] = 0\n ini_pauli[i+1, -1] = 0\n else:\n # for odd qubits, get rid of boundary either on top or bottom qubit\n for i in range(2, depth, 4):\n ini_pauli[i, -1] = 0\n if i+1 < depth:\n ini_pauli[i+1, -1] = 0\n for i in range(4, depth, 4):\n ini_pauli[i, 0] = 0\n if i+1 < depth:\n ini_pauli[i+1, 0] = 0\n\n # CNOT entangling gates\n entangling_gate_index_list = [[] for i in range(depth)]\n counter = 0\n # third index indicates type of entangling gate\n for k in range(1, depth-1, 2):\n\n # place entangler every second layer, do not place any at last\n if counter % 2 == 0:\n # even layer\n entangling_gate_index_list[k] = [\n [2*j, 2*j+1, 1] for j in range(n_qubits//2)\n ]\n else:\n # odd layer\n entangling_gate_index_list[k] = [\n [2*j+1, 2*j+2, 1] for j in range((n_qubits-1)//2)\n ]\n counter += 1\n\n else:\n raise ValueError('type_circuit='+f'{type_circuit}'+' not recognised.')\n\n return ini_pauli, entangling_gate_index_list","def create(self):\n \n \"\"\" A solo prepressing reduction network in the head \"\"\"\n print(\"pre_reduction\")\n with tf.name_scope('pre_reduction'):\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\n \n \"\"\" 1st inception layer group \"\"\"\n print(\"icp1\")\n with tf.name_scope('icp1'):\n # branch 0\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\n # branch 1\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\n # branch 2\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\n # branch 3\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\n # concat\n icp2_in = NW.concat([icp1_out0,\n icp1_out1,\n icp1_out2,\n icp1_out3], 3, 'icp2_in')\n\n \"\"\" 2nd inception layer group \"\"\"\n print(\"icp2\")\n with tf.name_scope('icp2'):\n # branch 0\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\n # branch 1\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\n # branch 2\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\n # branch 3\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\n # concat\n icp2_out = NW.concat([icp2_out0,\n icp2_out1,\n icp2_out2,\n icp2_out3], 3, 'icp2_out')\n \n \"\"\" 3rd inception layer group \"\"\"\n print(\"icp3\")\n with tf.name_scope('icp3'):\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\n # branch 0\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\n # branch 1\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\n # branch 2\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\n # branch 3\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\n # concat\n icp3_out = NW.concat([icp3_out0,\n icp3_out1,\n icp3_out2,\n icp3_out3], 3, 'icp3_out')\n \n \"\"\" 1st classify branch \"\"\"\n with tf.name_scope('cls1'):\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\n self.layers[\"cls1_fc_pose_xy\"] = cls1_fc_pose_xy\n self.layers[\"cls1_fc_pose_ab\"] = cls1_fc_pose_ab\n \n \"\"\" 4st inception layer group \"\"\"\n print(\"icp4\")\n with tf.name_scope('icp4'):\n # branch 0\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\n # branch 1\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\n # branch 2\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\n # branch 3\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\n # concat\n icp4_out = NW.concat([icp4_out0,\n icp4_out1,\n icp4_out2,\n icp4_out3],3, name='icp4_out')\n\n \"\"\" 5st inception layer group \"\"\"\n print(\"icp5\")\n with tf.name_scope('icp5'):\n # branch 0\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\n # branch 1\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\n # branch 2\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\n # branch 3\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\n # concat\n icp5_out = NW.concat([icp5_out0, \n icp5_out1, \n icp5_out2, \n icp5_out3], 3, name='icp5_out')\n \n \"\"\" 6st inception layer group \"\"\"\n print(\"icp6\")\n with tf.name_scope('icp6'):\n # branch 0\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\n # branch 1\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\n # branch 2\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\n # branch 3\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\n # concat\n icp6_out = NW.concat([icp6_out0,\n icp6_out1,\n icp6_out2,\n icp6_out3], 3, name='icp6_out')\n\n \"\"\" 2nd classify branch \"\"\"\n with tf.name_scope('cls2'):\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\n self.layers[\"cls2_fc_pose_xy\"] = cls2_fc_pose_xy\n self.layers[\"cls2_fc_pose_ab\"] = cls2_fc_pose_ab\n\n \"\"\" 7st inception layer group \"\"\"\n print(\"icp7\")\n with tf.name_scope('icp7'):\n # branch 0\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\n # branch 1\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\n # branch 2\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\n # branch 3\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\n # concat\n icp7_out = NW.concat([icp7_out0,\n icp7_out1,\n icp7_out2,\n icp7_out3], 3, name='icp7_out')\n\n \"\"\" 8st inception layer group \"\"\"\n print(\"icp8\")\n with tf.name_scope('icp8'):\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\n # branch 0\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\n # branch 1\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\n # branch 2\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\n # branch 3\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\n # concat\n icp8_out = NW.concat([icp8_out0,\n icp8_out1,\n icp8_out2,\n icp8_out3], 3, name='icp8_out')\n \n \"\"\" 9st inception layer group \"\"\"\n print(\"icp9\")\n with tf.name_scope('icp9'):\n # branch 0\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\n # branch 1\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\n # branch 2\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\n # branch 3\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\n # concat\n icp9_out = NW.concat([icp9_out0,\n icp9_out1,\n icp9_out2,\n icp9_out3], 3, name='icp9_out')\n\n \"\"\" 3rd classify branch \"\"\"\n with tf.name_scope('cls3'):\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\n self.layers[\"cls3_fc_pose_xy\"] = cls3_fc_pose_xy\n self.layers[\"cls3_fc_pose_ab\"] = cls3_fc_pose_ab","def upstream_nodes_of_type(self, target_node_name, operation_type):\n assert target_node_name in self.node_map\n nodes = self.nodes_of_type(operation_type)\n nodes = [node for node in nodes if has_path(self.G2, node, target_node_name)]\n return set(nodes)","def _create_param_quantizers(self, weight_bw: int, round_mode: libpymo.RoundingMode,\n quant_scheme: QuantScheme, is_symmetric: bool,\n data_type: QuantizationDataType):\n tensor_grouped_quantizer_map = {}\n for layer in range(self.num_layers):\n for group_name, tensor_names in grouped_quantizer_map.items():\n name = group_name.format(layer)\n if name not in self._grouped_quantizers:\n self._grouped_quantizers[name] = \\\n tensor_quantizer_factory(weight_bw,\n round_mode,\n quant_scheme,\n use_symmetric_encodings=is_symmetric,\n enabled_by_default=False,\n data_type=data_type)\n tensor_names = [tensor_name.format(layer) for tensor_name in tensor_names]\n for tensor_name in tensor_names:\n assert tensor_name not in tensor_grouped_quantizer_map\n tensor_grouped_quantizer_map[tensor_name] = \\\n self._grouped_quantizers[name]\n\n for name, _ in self.module_to_quantize.named_parameters():\n _logger.debug(\"Adding quantizer for parameter: %s\", name)\n if name in tensor_grouped_quantizer_map:\n self._param_quantizers[name] = tensor_grouped_quantizer_map[name]\n self._grouped_param_quantizers.add(self._param_quantizers[name])\n else:\n self._param_quantizers[name] = tensor_quantizer_factory(\n weight_bw,\n round_mode,\n quant_scheme,\n use_symmetric_encodings=is_symmetric,\n enabled_by_default=False,\n data_type=data_type)","def build_graph(self):\n for node in self.nodes:\n self.graph.add_node(node.id, node_obj=node)\n edges = []\n for i in range(0, len(self.nodes)):\n for j in range(i+1, len(self.nodes)):\n if (self.nodes[i].distance(self.nodes[j]) < self.radio_range):\n edges.append((self.nodes[i].id, self.nodes[j].id,1))\n self.graph.add_weighted_edges_from(edges)","def _build_networks(self):\n self.online_convnet = self._create_network(name='Online')\n self.target_convnet = self._create_network(name='Target')\n self._net_outputs = self.online_convnet(self.state_ph, training=True)\n self._q_argmax = tf.argmax(self._net_outputs.q_values, axis=1)[0]\n self._replay_net_outputs = self.online_convnet(self._replay.states,\n training=True)\n self._replay_next_target_net_outputs = self.target_convnet(\n self._replay.next_states)","def __init__(self, **kwargs):\n FeatureDefinition.__init__(self)\n\n nbTypes = self._getTypeNumber(kwargs)\n \n print(\"BETTER FEATURES\")\n \n \n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"xywh\", Pipeline([\n ('selector', NodeTransformerXYWH_v2()),\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"neighbors\", Pipeline([\n ('selector', NodeTransformerNeighbors()),\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"1hot\", Pipeline([\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\n ])\n )\n ])\n grid_line_transformer = GridLine_NodeTransformer_v2()\n \n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \n \n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"1hot\", Pipeline([\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\n ])\n )\n , (\"boolean\", Pipeline([\n ('boolean', EdgeBooleanFeatures_v2())\n ])\n )\n , (\"numerical\", Pipeline([\n ('selector', EdgeNumericalSelector()),\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n ] )\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\n edge_BL_transformer,\n edge_BL_transformer, # useless but required\n edge_LL_transformer \n ])\n \n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer","def build_graph(self):\n # place holders for inputs here \n HIDDEN_LAYER = self.FLAGS.feature_layer_size\n \n self.x_i = tf.placeholder(dtype=tf.float32, shape = (None, self.INPUT_DIM), name=\"x_i\")\n self.a_i = tf.placeholder(dtype=tf.float32, shape = (None, self.ACTION_DIM), name = \"a_i\")\n self.q_opc = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \"q_opc\")\n self.q_ret = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \"q_ret\" )\n self.c = self.FLAGS.c # truncation threshold constant\n \n self.actor_net = PolicyNet(HIDDEN_LAYER, self.ACTION_DIM, name= self.name + \"_actor\", co_var = self.co_var)\n self.critic_net = AdvantageValueNet(HIDDEN_LAYER , name= self.name + \"_critic\")\n \n self.policy_xi_stats, self.policy_xi_dist = self.actor_net(self.x_i)\n \n self.val_xi, self.adv_xi_ai = self.critic_net(self.x_i, self.a_i, self.policy_xi_dist)\n \n #sample a' now\n self.a_i_ = tf.reshape(self.policy_xi_dist.sample(1), shape=[-1,self.ACTION_DIM])\n self.a_i_ = tf.clip_by_value(self.a_i_, self.env.action_space.low[0], self.env.action_space.high[0]) #20190828 add clipping\n \n _, self.adv_xi_ai_ = self.critic_net(self.x_i, self.a_i_, self.policy_xi_dist) # val will be the same for \n \n _, self.average_policy_xi_dist = self.average_actor_net(self.x_i) # can this be done better ?\n \n self.prob_a_i = tf.reshape(self.policy_xi_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\n self.prob_a_i_ = tf.reshape(self.policy_xi_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\n \n self.log_prob_a_i = tf.log(self.prob_a_i)\n self.log_prob_a_i_ = tf.log(self.prob_a_i_)\n \n # for predicting 1-step a_i', p_i, p_i',\n self.u_i = tf.placeholder(dtype=tf.float32, shape = (None, 2*self.ACTION_DIM))\n \n #self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i, \n # scale_diag = tf.ones_like(self.u_i) * self.co_var)\n self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i[:,0], scale_diag=self.u_i[:,1])\n \n self.u_i_prob_a_i = tf.reshape(self.u_i_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\n self.u_i_prob_a_i_ = tf.reshape(self.u_i_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\n \n self.p_i = tf.divide(self.prob_a_i, self.u_i_prob_a_i)\n self.p_i_ = tf.divide(self.prob_a_i_ , self.u_i_prob_a_i_)\n \n\n # take care of NaNs here, for importance sampling weights (might be an extra step)\n self.p_i = tf.where(tf.is_nan(self.p_i), tf.zeros_like(self.p_i), self.p_i)\n self.p_i_ = tf.where(tf.is_nan(self.p_i_), tf.zeros_like(self.p_i_), self.p_i_)\n\n self.c_i = tf.minimum(1. , tf.pow(self.p_i, 1.0/self.ACTION_DIM))\n \n \n # for verification about checking if params are getting synched\n self.local_actor_vars = self.actor_net.local_params()\n self.global_actor_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_actor')\n \n self.local_critic_vars = self.critic_net.local_params()\n self.global_critic_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_critic')\n \n \n # Sync ops from global\n self.sync_local_actor_op = self.actor_net.update_local_params_op('global_actor') # global actor\n self.sync_local_critic_op = self.critic_net.update_local_params_op('global_critic')\n \n # soft update the average network\n self.soft_update_average_actor_op = self.average_actor_net.soft_update_from_target_params('global_actor',\n self.FLAGS.tau)\n \n #Get gradients from local network using local losses\n \n g1 = tf.reshape(tf.gradients((self.log_prob_a_i * (self.q_opc - self.val_xi)),self.policy_xi_stats,\n name=self.name+\"g1_grads\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n g2 = (self.adv_xi_ai_ - self.val_xi) * tf.reshape(tf.gradients((self.log_prob_a_i_), \n self.policy_xi_stats, name=self.name+\"g2_grads\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n \n \n self.g = tf.minimum(self.c, self.p_i) * g1 + tf.nn.relu(1 - tf.divide(self.c , self.p_i_)) * g2\n \n \n self.k = tf.reshape(tf.gradients(tf.contrib.distributions.kl_divergence(self.average_policy_xi_dist, \n self.policy_xi_dist), self.policy_xi_stats, unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n \n \n \n self.kg = tf.reduce_sum( tf.multiply(self.g, self.k), 1, keep_dims=True)\n \n #print \"kg\", self.kg\n \n self.k2 = tf.reduce_sum( tf.multiply(self.k, self.k), 1, keep_dims=True)\n \n self.reg_g = self.g - tf.maximum(tf.zeros_like(self.g), tf.divide((self.kg - self.FLAGS.delta), self.k2) ) * self.k\n \n # take gradients wrt to the local params\n self.actor_grads = tf.gradients(self.policy_xi_stats, self.local_actor_vars, \n grad_ys= -self.reg_g, name=\"actor_grads\", unconnected_gradients='zero')\n \n \n #for ti,tj in zip(self.actor_grads, self.global_actor_vars):\n # print ti, \"\\n\", tj , \"\\n\", \"===========\"\n \n # apply local gradients to the global network\n self.actor_train_op = self.optimizer.apply_gradients(zip(self.actor_grads, self.global_actor_vars),\n global_step=tf.train.get_global_step())\n \n \n # critic loss function and updates\n \n # take gradient wrt to local variables\n self.critic_loss_1 = ((self.q_ret - self.adv_xi_ai) ** 2.0) / 2.0\n \n # for predicting 1-step a_i', p_i, p_i',\n self.v_target = tf.placeholder(dtype=tf.float32, shape = (None, 1))\n \n #self.v_trunc = tf.minimum(self.p_i, 1.0) * (self.q_ret - self.adv_xi_ai) + self.val_xi\n self.critic_loss_2 = ((self.v_target - self.val_xi) ** 2.0) / 2.0\n \n self.critic_loss = self.critic_loss_1 + self.critic_loss_2\n \n #Apply local gradients to global network\n \n self.critic_grads = tf.gradients(self.critic_loss, self.local_critic_vars)\n \n self.critic_train_op = self.optimizer.apply_gradients(zip(self.critic_grads, self.global_critic_vars),\n global_step=tf.train.get_global_step())\n \n # critic_summaries op\n critic_grads_summary = []\n print('-----------------------------------------------------------------')\n print('Create critic_grads_summary histogram ')\n for grad,var in zip(self.critic_grads, self.local_critic_vars):\n print('{} - {}'.format(var.name, grad))\n critic_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\n critic_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\n \n self.critic_summary_op = tf.summary.merge([\n tf.summary.scalar(self.name + \"_critc_mean_loss_Q\", tf.reduce_mean(self.critic_loss_1)),\n tf.summary.scalar(self.name + \"_critc_mean_loss_V\", tf.reduce_mean(self.critic_loss_2)),\n tf.summary.scalar(self.name + \"_critc_sum_loss_Q\", tf.reduce_sum(self.critic_loss_1)),\n tf.summary.scalar(self.name + \"_critc_sum_loss_V\", tf.reduce_sum(self.critic_loss_2)),\n tf.summary.scalar(self.name + \"_critc_mean_loss\", tf.reduce_mean(self.critic_loss)),\n tf.summary.scalar(self.name + \"_critc_sum_loss\", tf.reduce_sum(self.critic_loss)),\n tf.summary.histogram(self.name + \"_val_target\", self.v_target),\n tf.summary.histogram(self.name + \"_val_pred\", self.val_xi),\n tf.summary.histogram(self.name + \"_Q_pred\", self.adv_xi_ai),\n tf.summary.histogram(self.name + \"_Q_ret\", self.q_ret),\n tf.summary.histogram(self.name + \"_Q_opc\", self.q_opc),\n ] + critic_grads_summary)\n \n \n # actor summaries op\n\n actor_grads_summary = []\n print('-----------------------------------------------------------------')\n print('Create actor_grads_summary histogram ')\n for grad,var in zip(self.actor_grads, self.local_actor_vars):\n print('{} - {}'.format(var.name, grad))\n actor_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\n actor_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\n \n\n self.actor_summary_op = tf.summary.merge([\n tf.summary.scalar(self.name + \"_actor_mean_loss_reg_g\", tf.reduce_mean(self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_neg_mean_loss_reg_g\", tf.reduce_mean(-self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_sum_loss_reg_g\", tf.reduce_sum(self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_neg_sum_reg_g\", tf.reduce_sum(-self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_sum_g\", tf.reduce_sum(self.g)),\n tf.summary.scalar(self.name + \"_actor_neg_sum_g\", tf.reduce_sum(-self.g)),\n tf.summary.scalar(self.name + \"_actor_mean_kl\", tf.reduce_mean(self.k)),\n tf.summary.scalar(self.name + \"_actor_sum_kl\", tf.reduce_sum(self.k)),\n tf.summary.histogram(self.name + \"_policy_stats\", self.policy_xi_stats),\n ] + actor_grads_summary )","def build_graph(self):\n self.graph = tf.Graph()\n temp_connections = self.connections\n with self.graph.as_default():\n operations = {}\n\n # create Variables for input vertices\n for neuron_id in self.input_neurons:\n self.inputs[neuron_id] = tf.get_variable(name=str(neuron_id), shape=(),\n initializer=tf.zeros_initializer)\n deletion = []\n while len(temp_connections) > 0:\n for neuron_id in deletion:\n temp_connections.pop(neuron_id, None)\n deletion = []\n keys = list(temp_connections)\n random.shuffle(keys)\n # create input & output vertices\n for neuron_id in temp_connections:\n input_neuron_ids = temp_connections[neuron_id]\n if self.check(input_neuron_ids, operations):\n # weights\n v_weights = tf.constant(self.weights[neuron_id])\n # input vertices\n v_inputs = []\n\n for input_neuron_id in input_neuron_ids:\n if self.is_input_neuron(input_neuron_id):\n vertex = self.inputs[input_neuron_id]\n else:\n vertex = operations[input_neuron_id]\n\n v_inputs.append(vertex)\n\n deletion.append(neuron_id)\n\n # multiply weights and inputs\n mul = tf.multiply(v_inputs, v_weights, str(neuron_id))\n # sum multiplied values\n sum = tf.reduce_sum(mul, name='sum_' + str(neuron_id))\n # apply activation function\n if self.is_output_neuron(neuron_id):\n activation = tf.sigmoid(sum, name=\"output\")\n else:\n activation = tf.nn.leaky_relu(sum, alpha=0.2, name=\"relu_\" + str(neuron_id))\n\n operations[neuron_id] = activation\n if self.is_output_neuron(neuron_id):\n self.output = activation\n return self.graph, self.inputs, self.output","def evaluate_dep_type_sets():\n strategies = {\n 'defensive': ['agent', 'advcl', 'parataxis'],\n 'aggressive': ['agent', 'advcl', 'parataxis', 'dep', 'aux', 'ccomp', 'xcomp', 'dobj', 'pobj', 'nsubj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'preconj', 'advmod', 'neg', 'rcmod', 'tmod', 'poss', 'prepc'],\n 'compromise_1': ['agent', 'advcl', 'parataxis', 'aux', 'xcomp', 'pobj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'neg', 'tmod', 'poss', 'prepc'],\n 'compromise_2': ['agent', 'advcl', 'parataxis', 'aux', 'xcomp', 'pobj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'neg', 'tmod', 'poss', 'prepc', 'attr', 'csubj', 'csubjpass', 'number', 'possessive', 'punct', 'ref']\n }\n results = {'classification':{}, 'retrieval':{}}\n\n print '------ CLASSIFICATION EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/tasa/TASA900_dependencies'\n texts, labels = data.read_files(descriptions_path)\n print '> Creating representations..'\n rep = {}\n for strategy in strategies:\n rep[strategy] = []\n metric = graph.GraphMetrics.CLOSENESS\n for i, text in enumerate(texts):\n if i%10==0: print ' ',str(i)+'/'+str(len(texts))\n for strategy in strategies:\n g = graph_representation.construct_dependency_network(text, exclude=strategies[strategy])\n d = graph_representation.graph_to_dict(g, metric)\n rep[strategy].append(d)\n g = None # just to make sure. I don't trust this damn garbage collector...\n for strategy in strategies:\n rep[strategy] = graph_representation.dicts_to_vectors(rep[strategy])\n print '> Evaluating..'\n for strategy in strategies:\n score = evaluation.evaluate_classification(rep[strategy], labels)\n print ' ', strategy, score\n results['classification'][strategy] = score\n\n data.pickle_to_file(results, 'output/dependencies/types_set_eval_tmp')\n\n print '------ RETRIEVAL EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/air/problem_descriptions_dependencies'\n description_texts, labels = data.read_files(descriptions_path)\n solutions_path = '../data/air/solutions_preprocessed'\n solution_texts, labels = data.read_files(solutions_path)\n solution_vectors = freq_representation.text_to_vector(solution_texts, freq_representation.FrequencyMetrics.TF_IDF)\n print '> Creating representations..'\n rep = {}\n for strategy in strategies:\n rep[strategy] = []\n metric = graph.GraphMetrics.EIGENVECTOR\n for i, text in enumerate(description_texts):\n if i%1==0: print ' ',str(i)+'/'+str(len(description_texts))\n full_graph = graph_representation.construct_dependency_network(text)\n for strategy in strategies:\n g = graph_representation.construct_dependency_network(text, exclude=strategies[strategy])\n d = graph_representation.graph_to_dict(g, metric)\n rep[strategy].append(d)\n g = None # just to make sure..\n full_graph = None\n #~ if i%100==0: data.pickle_to_file(rep, 'output/dependencies/types_eval_rep_'+str(i))\n for strategy in strategies:\n rep[strategy] = graph_representation.dicts_to_vectors(rep[strategy])\n print '> Evaluating..'\n for strategy in strategies:\n score = evaluation.evaluate_retrieval(rep[strategy], solution_vectors)\n print ' ', strategy, score\n results['retrieval'][strategy] = score\n\n pp.pprint(results)\n data.pickle_to_file(results, 'output/dependencies/types_set_eval')\n\n return results","def _make_list_islot_otuples_from_nodelist(self):\n raise NotImplementedError","def build_graph(self):\n\t\tself.n_hidden = 100\n\t\tself.weights_hidden = tf.get_variable(\"weights_hidden\", [self.state_size, self.n_hidden], initializer = tf.random_normal_initializer())\n\t\tself.bias_hidden = tf.get_variable(\"bias_hidden\", [self.n_hidden], initializer = tf.constant_initializer(0.1))\n\n\t\tself.weights_out = tf.get_variable(\"weights_out\", [self.n_hidden, self.action_size], initializer = tf.random_normal_initializer())\n\t\tself.bias_out = tf.get_variable(\"bias_out\", [self.action_size], initializer = tf.constant_initializer(0.1))","def _construct_graph(self):\n raise NotImplementedError","def outputs_for_module_type_operation(self):\n result = []\n module = type(self).__name__\n turbine_rating_MW = self.input_dict['turbine_rating_MW']\n num_turbines = self.input_dict['num_turbines']\n project_size_kw = num_turbines * turbine_rating_MW * 1000\n\n if self.in_distributed_mode:\n result.append({\n 'type_of_cost': 'total_management_cost',\n 'raw_cost': self.output_dict['total_management_cost']\n })\n\n else:\n result.append({\n 'type_of_cost': 'insurance',\n 'raw_cost': self.output_dict['insurance_usd']\n })\n result.append({\n 'type_of_cost': 'Construction Permitting',\n 'raw_cost': self.output_dict['construction_permitting_usd']\n })\n result.append({\n 'type_of_cost': 'Project Management',\n 'raw_cost': self.output_dict['project_management_usd']\n })\n result.append({\n 'type_of_cost': 'Bonding',\n 'raw_cost': self.output_dict['bonding_usd']\n })\n result.append({\n 'type_of_cost': 'Markup Contingency',\n 'raw_cost': self.output_dict['markup_contingency_usd']\n })\n result.append({\n 'type_of_cost': 'Engineering Foundation and Collections System (includes met mast)',\n 'raw_cost': self.output_dict['engineering_usd']\n })\n result.append({\n 'type_of_cost': 'Site Facility',\n 'raw_cost': self.output_dict['site_facility_usd']\n })\n\n for _dict in result:\n _dict['turbine_rating_MW'] = self.input_dict['turbine_rating_MW']\n _dict['num_turbines'] = self.input_dict['num_turbines']\n _dict['rotor_diameter_m'] = self.input_dict['rotor_diameter_m']\n _dict['project_id_with_serial'] = self.project_name\n _dict['operation_id'] = 'Management'\n _dict['module'] = module\n _dict['raw_cost_total_or_per_turbine'] = 'total'\n _dict['cost_per_turbine'] = _dict['raw_cost'] / num_turbines\n _dict['cost_per_project'] = _dict['raw_cost']\n _dict['usd_per_kw_per_project'] = _dict['raw_cost'] / project_size_kw\n\n return result","def _build_graph(self):\n start_t = time.time()\n self._setup_placeholders()\n self._embed()\n self._encode()\n self._match()\n self._fuse()\n self._decode()\n self._passage_rank()\n self._compute_loss()\n self._create_train_op()\n self.logger.info('Time to build graph: {} s'.format(time.time() - start_t))\n param_num = sum([np.prod(self.sess.run(tf.shape(v))) for v in self.all_params])\n self.logger.info('There are {} parameters in the model'.format(param_num))","def build(self):\n # add ops for generator (A->B) to graph\n self.G = Generator(channels=self.opt.channels, ngf=self.opt.ngf, norm_type=self.opt.layer_norm_type,\n init_type=self.opt.weight_init_type, init_gain=self.opt.weight_init_gain,\n training=self.training, name='G')\n\n if self.training:\n # add ops for other generator (B->A) and discriminators to graph\n self.F = Generator(channels=self.opt.channels, ngf=self.opt.ngf,\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\n init_gain=self.opt.weight_init_gain, training=self.training, name='F')\n self.D_A = Discriminator(channels=self.opt.channels, ndf=self.opt.ndf,\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\n init_gain=self.opt.weight_init_gain, training=self.training, name='D_A')\n self.D_B = Discriminator(channels=self.opt.channels, ndf=self.opt.ndf,\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\n init_gain=self.opt.weight_init_gain, training=self.training, name='D_B')\n\n # generate fake images\n fakeB = self.G(self.realA)\n fakeA = self.F(self.realB, self.rand_mask)\n\n # generate reconstructed images\n reconstructedA = self.F(fakeB, self.last_mask)\n reconstructedB = self.G(fakeA)\n\n # generate identity mapping images\n identA = self.G(self.realB)\n identB = self.F(self.realA, self.mask_non_shadow)\n\n tf.summary.image('A/original', batch_convert_2_int(self.realA))\n tf.summary.image('B/original', batch_convert_2_int(self.realB))\n tf.summary.image('A/generated', batch_convert_2_int(fakeA))\n tf.summary.image('B/generated', batch_convert_2_int(fakeB))\n tf.summary.image('A/reconstructed', batch_convert_2_int(reconstructedA))\n tf.summary.image('B/reconstructed', batch_convert_2_int(reconstructedB))\n\n # add loss ops to graph\n Gen_loss, D_A_loss, D_B_loss = self.__loss(fakeA, fakeB, reconstructedA,\n reconstructedB, identA, identB)\n\n # add optimizer ops to graph\n optimizers = self.__optimizers(Gen_loss, D_A_loss, D_B_loss)\n\n return fakeA, fakeB, optimizers, Gen_loss, D_A_loss, D_B_loss\n else: # only need generator from A->B during testing\n fakeB = self.G(self.realA)\n return fakeB","def __initilization(self,node_set):\n \n print \"*********************************\"\n \n for x in node_set:\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\n \n print \"Forward/Backward Algorithm Initialization Done!\"","def build_graph(self, values, values_mask, keys_mask, keys, use_mask=True):\n\n with vs.variable_scope(\"CoAttn\"):\n\n print('value_vec_size is: ', self.value_vec_size)\n print('num_values size is: ', values.shape[1])\n print('num_keys size is: ', keys.shape[1])\n print('value_vec_size is (key):', keys.shape[2])\n # Declare variable \n W = tf.get_variable(\"W\", shape = (self.value_vec_size, self.value_vec_size), \\\n initializer = tf.contrib.layers.xavier_initializer())\n b = tf.get_variable(\"b\", shape = (self.value_vec_size), initializer = tf.constant_initializer(0))\n\n # Compute projected question hidden states\n\n Q = tf.tanh(tf.tensordot(values, W, 1) + tf.reshape(b, [1, 1, self.value_vec_size])) # (batch_size, num_values, value_vec_size)\n\n\n Q = concat_sentinel('question_sentinel', Q, self.value_vec_size) # (batch_size, num_values, value_vec_size)\n # Q = tf.nn.dropout(Q, self.keep_prob)\n print('Q shape is: ', Q.shape)\n # sentinel = tf.get_variable(name='question_sentinel', shape=tf.shape(Q)[2], \\\n # initializer=tf.contrib.layers.xavier_initializer(), dtype = tf.float32)\n # sentinel = tf.tile(sentinel, [tf.shape(original_tensor)[0], 1, 1])\n # concat_tensor = tf.concat([original_tensor, sentinel], 2)\n\n print('Q shape is: ', Q.shape)\n D = keys # (batch_size, num_keys, value_vec_size)\n D = concat_sentinel('document_sentinel', D, self.value_vec_size)\n # D = tf.nn.dropout(D, self.keep_prob)\n\n # key = document, value = question here\n ### End your code here to implement 'Sentinel Vector'\n # Compute affinity matrix L\n L = tf.matmul(D, tf.transpose(Q, perm=[0, 2, 1])) # shape (batch_size, num_keys, num_values)\n\n # Compute Context-to-Question (C2Q) Attention, we obtain C2Q attention outputs\n if use_mask:\n print('tf.shape(values)[0] is: ', tf.shape(values)[0])\n print('tf.ones([tf.shape(values)[0], 1] is ', tf.ones([tf.shape(values)[0], 1], dtype=tf.int32))\n values_mask = tf.expand_dims(tf.concat([values_mask, tf.ones([tf.shape(values)[0], 1], dtype=tf.int32)], axis=1), 1)\n print \"value_mask shape:\", values_mask.shape\n print \"L shape:\", L.shape\n _, A_D = masked_softmax(L, mask=values_mask, dim=2) #(batch_size, num_keys, num_values)\n else:\n A_D = tf.nn.softmax(L, dim=-1)\n\n C2Q_Attn = tf.matmul(A_D, Q) # (batch_size, num_keys, value_vec_size)\n print('C2Q_Attn shapeis ', C2Q_Attn.shape)\n\n # Compute Question-to-Context (Q2C) Attention, we obtain Q2C attention outputs\n if use_mask:\n keys_mask = tf.expand_dims(tf.concat([keys_mask, tf.ones([tf.shape(keys)[0], 1], dtype=tf.int32)], axis=1), 1)\n print \"key_mask shape:\", keys_mask.shape\n print \"L shape:\", L.shape\n _, A_Q = masked_softmax(tf.transpose(L, perm=[0, 2, 1]), mask=keys_mask, dim=-1) # (batch_size, num_values, num_keys)\n else:\n A_Q = tf.nn.softmax(tf.transpose(L, perm=[0, 2, 1]), dim=2)\n\n Q2C_Attn = tf.matmul(A_Q, D) # (batch_size, num_values, key_vec_size)\n print('Q2C_Attn shapeis ', Q2C_Attn.shape)\n\n # Compute second-level attention outputs S\n S = tf.matmul(A_D, Q2C_Attn) # (batch_size, num_keys, value_vec_size)\n print('S size is: ', S.shape)\n\n # Concatenate C2Q_Attn and S:\n C_D = tf.concat([D, C2Q_Attn, S], 2) # (batch_size, num_keys, 3 * value_vec_size)\n # C_D = tf.nn.dropout(C_D, self.keep_prob)\n print('co_context size is: ', C_D.shape)\n\n # co_input = tf.concat([tf.transpose(D, perm = [0, 2, 1]), C_D], 1)\n # print('co_input size is: ', co_input.shape)\n size = int(self.value_vec_size)\n \n if self.device == 'gpu':\n bidirection_rnn = tf.contrib.cudnn_rnn.CudnnLSTM(1, size, 3*size, dropout=0.2, direction=cudnn_rnn_ops.CUDNN_RNN_BIDIRECTION, dtype=tf.float32)\n C_D = tf.transpose(C_D, perm=[1, 0, 2])\n print 'C_D shape', C_D.shape\n input_h = tf.zeros([2, tf.shape(values)[0], size])\n input_c = tf.zeros([2, tf.shape(values)[0], size])\n params = tf.get_variable(\"RNN\", shape=(estimate_cudnn_parameter_size(3*self.value_vec_size, size, 2)),\n initializer=tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\n \n U, _, _ = bidirection_rnn(C_D, input_h, input_c, params)\n#\n print 'U shape:', U.shape\n U = tf.transpose(U, perm=[1, 0, 2])\n\n else:\n (u_fw_out, u_bw_out), _ = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), cell_bw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), \n inputs=C_D, dtype = tf.float32)\n U = tf.concat([u_fw_out, u_bw_out], 2)\n\n U = tf.nn.dropout(U[:,:-1, :], self.keep_prob)\n # U = tf.nn.dropout(U, self.keep_prob)\n print('U shape is: ', U.shape)\n \n return U,A_D,A_Q","def complete_graph(self):\n root_nodes = set()\n\n for name, a_block in self.wf['action'].items():\n\n a_block['name'] = name\n\n for n in a_block.get('needs', []):\n if not self.wf['action'][n].get('next', None):\n self.wf['action'][n]['next'] = set()\n self.wf['action'][n]['next'].add(name)\n\n if not a_block.get('needs', None):\n root_nodes.add(name)\n\n self.wf['root'] = root_nodes","def __init__(self, quantized_edges_in_cfg: int, total_edges_in_cfg: int):\n self.quantized_edges_in_cfg = quantized_edges_in_cfg\n self.total_edges_in_cfg = total_edges_in_cfg","def list_nodes(self, type_):\n raise NotImplementedError()","def get_fused_operator_statistics(self):\n op_count = {}\n ops = [\n \"Attention\",\n \"MultiHeadAttention\",\n \"LayerNormalization\",\n \"SkipLayerNormalization\",\n \"BiasSplitGelu\",\n \"GroupNorm\",\n \"NhwcConv\",\n \"BiasAdd\",\n ]\n for op in ops:\n nodes = self.get_nodes_by_op_type(op)\n op_count[op] = len(nodes)\n\n logger.info(f\"Optimized operators:{op_count}\")\n return op_count","def _process_nodes(self):\n # Sort the nodes by metanode type, then by id\n self.node_df = self.node_df.sort_values(['label', 'id']).reset_index(drop=True)\n # Get all the ids\n self.nodes = self.node_df['id']\n # Get mapping from the index to the node ID (one to many so need different one for each node type)\n self.index_to_nid = dict()\n for group_name, group in self.node_df.groupby('label'):\n self.index_to_nid[group_name] = group['id'].reset_index(drop=True).to_dict()\n # Get the reverse mapping (many to one so don't need to separate based on type).\n self.nid_to_index = dict()\n for mapper in self.index_to_nid.values():\n for index, nid in mapper.items():\n self.nid_to_index[nid] = index\n # Finally, we need a mapper from id to node type\n self.id_to_metanode = self.node_df.set_index('id')['label'].to_dict()\n # And from node type to a list of ids\n self.metanode_to_ids = dict()\n for group_name, group in self.node_df.groupby('label'):\n self.metanode_to_ids[group_name] = group['id'].tolist()\n # One more mapper of id to name\n self.nid_to_name = self.node_df.set_index('id')['name'].to_dict()","def _generate_graph(self) -> None:\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\n p_in=self.community_p_in,\n p_out=self.community_p_out,\n seed=self.seed)\n\n for _, nv in self.g_.nodes.data():\n nv[\"infected\"] = 0\n nv[\"immune\"] = False\n nv[\"alive\"] = True\n nv[\"_edges\"] = []\n nv[\"isolated\"] = False\n nv[\"mask\"] = 0.0","def finalize_graph(self) -> None:\n digraph = nx.MultiDiGraph()\n\n for node in self.graph.iternodes():\n attributes = self.get_attributes(node)\n attributes[\"schema\"] = node.type.name\n if node.caption is not None:\n attributes[\"label\"] = node.caption\n if node.is_entity and node.schema is not None:\n attributes[\"schema\"] = node.schema.name\n digraph.add_node(node.id, **attributes)\n\n for edge in self.graph.iteredges():\n attributes = self.get_attributes(edge)\n attributes[\"schema\"] = edge.type_name\n attributes[\"weight\"] = str(edge.weight)\n digraph.add_edge(edge.source_id, edge.target_id, key=edge.id, **attributes)\n\n for line in generate_gexf(digraph, prettyprint=True):\n self.fh.write(line)\n self.fh.write(\"\\n\")","def make_node_structure() -> Node:\n\n agricult = Node('argicult', os.path.join(os.path.abspath(os.curdir),\n 'finance/agricult/agricult_classifier_RF.sav'),\n os.path.join(os.path.abspath(os.curdir),\n 'finance/agricult/agricult_classifier_CV.sav'),\n {'cattle': Node('cattle'), 'corn': Node('corn'),\n 'soybean': Node('soybean'), 'sugar': Node('sugar')})\n\n crypto = Node('crypto', os.path.join(os.path.abspath(os.curdir),\n 'finance/crypto/crypto_classifier_RF.sav'),\n os.path.join(os.path.abspath(os.curdir),\n 'finance/crypto/crypto_classifier_CV.sav'),\n {'bitcoin': Node('bitcoin'), 'dash': Node('dash'),\n 'ethereum': Node('ethereum'), 'litecoin': Node('litecoin'),\n 'monero': Node('monero'), 'ripple': Node('ripple'), 'zash': Node('zash')}) \n\n energy = Node('energy', os.path.join(os.path.abspath(os.curdir),\n 'finance/energy/energy_classifier_RF.sav'),\n os.path.join(os.path.abspath(os.curdir),\n 'finance/energy/energy_classifier_CV.sav'),\n {'brent crude': Node('brent crude'), 'coal': Node('coal'),\n 'crude oil': Node('crude oil'), 'natural gas': Node('natural gas')})\n\n metals = Node('metals', os.path.join(os.path.abspath(os.curdir),\n 'finance/metals/metals_classifier_RF.sav'),\n os.path.join(os.path.abspath(os.curdir),\n 'finance/metals/metals_classifier_CV.sav'),\n {'gold': Node('gold'), 'iron': Node('iron'),\n 'platinum': Node('platinum'), 'silver': Node('silver')})\n\n finance = Node('finance', os.path.join(os.path.abspath(os.curdir),\n 'finance/finance_classifier_RF.sav'),\n os.path.join(os.path.abspath(os.curdir),\n 'finance/finance_classifier_CV.sav'),\n {'agricult': agricult, 'crypto': crypto,\n 'energy': energy, 'metals': metals})\n\n return finance","def all_conv_ops(self):\n pass","def _first_call_op_prepare_before_hook_create_subgraphs(\n self,\n op: Callable,\n args: Tuple[Any, ...],\n kwargs: Dict[str, Any],\n qtensor_id: List[int],\n fqn: str,\n root_module: torch.nn.Module,\n op_quantizeability_type: OpQuantizeabilityType,\n ) -> Tuple[Tuple[Any, ...], Dict[str, Any]]:\n arg_tensor_infos: List[Optional[QTensorInfo]] = []\n for arg in args:\n if isinstance(arg, (list, tuple)):\n for inner_arg in arg:\n self._first_call_op_prepare_before_hook_create_subgraphs_tensor(\n op, inner_arg, arg_tensor_infos, qtensor_id)\n else:\n self._first_call_op_prepare_before_hook_create_subgraphs_tensor(\n op, arg, arg_tensor_infos, qtensor_id)\n\n if op_quantizeability_type is OpQuantizeabilityType.NOT_QUANTIZEABLE:\n op_type_is_module = isinstance(op, torch.nn.Module)\n op_type : Callable = type(op) if op_type_is_module else op # type: ignore[assignment]\n self.seen_nonq_op_infos.append(SeenNonQOpInfo(\n op_type, arg_tensor_infos, []))\n return args, kwargs\n\n op_packing_only_uses_module_attributes = \\\n get_op_packing_only_uses_module_attributes(op, args, kwargs, root_module)\n\n packable_tensor_idx_to_name = {}\n packable_nontensor_idx_to_arg = {}\n packable_tensor_kwarg_name_to_name = {}\n if op_packing_only_uses_module_attributes:\n packable_tensor_arg_idxs = get_packable_tensor_arg_idxs(op)\n if packable_tensor_arg_idxs is not None:\n for arg_idx in packable_tensor_arg_idxs:\n if arg_idx >= len(args):\n continue\n arg = args[arg_idx]\n param_name = get_param_name(root_module, arg)\n packable_tensor_idx_to_name[arg_idx] = param_name\n\n packable_nontensor_arg_idxs = get_packable_nontensor_arg_idxs(op)\n if packable_nontensor_arg_idxs is not None:\n for arg_idx in packable_nontensor_arg_idxs:\n packable_nontensor_idx_to_arg[arg_idx] = args[arg_idx]\n\n packable_tensor_kwarg_names = \\\n get_packable_tensor_kwarg_names(op)\n if packable_tensor_kwarg_names is not None:\n for kwarg_name in packable_tensor_kwarg_names:\n if kwarg_name not in kwargs:\n continue\n kwarg = kwargs[kwarg_name]\n kwarg_name_on_module = get_param_name(root_module, kwarg)\n packable_tensor_kwarg_name_to_name[kwarg_name] = \\\n kwarg_name_on_module\n\n if self.idx not in self.idx_to_seen_q_op_infos:\n op_type_is_module = isinstance(op, torch.nn.Module)\n op_type = type(op) if op_type_is_module else op # type: ignore[assignment]\n qconfig = get_cur_qconfig(self.qconfig_mapping, fqn, op_type)\n # TODO(future PR): use API flag instead of qconfig for is_reference\n is_reference_op_at_inference = \\\n qconfig is not None and activation_is_int32_quantized(qconfig)\n self.idx_to_seen_q_op_infos[self.idx] = SeenQOpInfo(\n self.idx, op_type, op_type_is_module, fqn, arg_tensor_infos, [],\n packable_tensor_idx_to_name, packable_nontensor_idx_to_arg,\n packable_tensor_kwarg_name_to_name,\n op_packing_only_uses_module_attributes, qconfig, None,\n is_reference_op_at_inference)\n\n return args, kwargs","def quantize_whole_model(net, bits=8):\n cluster_centers = []\n assert isinstance(net, nn.Module)\n layer_ind = 0\n for n, m in net.named_modules():\n if isinstance(m, PrunedConv):\n \"\"\"\n Apply quantization for the PrunedConv layer.\n --------------Your Code---------------------\n \"\"\"\n\n # Cluster the Weights\n num_centroid = pow(2, bits)\n\n all_weight = m.conv.weight.data.cpu().detach().numpy()\n weight_shape = all_weight.shape\n \n all_weight = all_weight.reshape(-1,1)\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\n\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\n\n # Generate Code Book\n cluster_center = kmeans.cluster_centers_.flatten()\n\n # Quantize\n indexs = kmeans.predict(all_weight)\n indexs = indexs.reshape(weight_shape)\n \n vmap = np.vectorize(lambda x:cluster_center[x])\n m.conv.weight.data = torch.from_numpy(vmap(indexs)).to(device)\n \n _cluster_center = [ \"{0:b}\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\n cluster_centers.append(_cluster_center)\n\n layer_ind += 1\n print(\"Complete %d layers quantization...\" %layer_ind)\n \n elif isinstance(m, PruneLinear):\n \"\"\"\n Apply quantization for the PrunedLinear layer.\n --------------Your Code---------------------\n \"\"\"\n \n # Cluster the Weights\n num_centroid = pow(2, bits)\n \n all_weight = m.linear.weight.data.cpu().detach().numpy()\n weight_shape = all_weight.shape\n\n all_weight = all_weight.reshape(-1,1)\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\n \n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\n \n # Generate Code Book\n cluster_center = kmeans.cluster_centers_.flatten()\n\n # Quantize\n indexs = kmeans.predict(all_weight)\n indexs = indexs.reshape(weight_shape)\n\n vmap = np.vectorize(lambda x:cluster_center[x])\n m.linear.weight.data = torch.from_numpy(vmap(indexs)).to(device)\n \n _cluster_center = [ \"{0:b}\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\n cluster_centers.append(_cluster_center)\n \n layer_ind += 1\n print(\"Complete %d layers quantization...\" %layer_ind)\n \n return np.array(cluster_centers)","def _create_activation_quantizers(self, tensor_names: List[str], activation_bw: int,\n round_mode: libpymo.RoundingMode, quant_scheme: QuantScheme,\n is_symmetric: bool, data_type: QuantizationDataType) -> Dict[str, StaticGridPerTensorQuantizer]:\n quantizers = {}\n for layer in range(self.num_layers):\n for name in tensor_names:\n name_in_layer = name.format(layer)\n group_name = QcQuantizeRecurrent._get_group_name(name_in_layer, layer)\n if group_name:\n if group_name not in self._grouped_quantizers:\n self._grouped_quantizers[group_name] = \\\n tensor_quantizer_factory(activation_bw,\n round_mode,\n quant_scheme,\n use_symmetric_encodings=is_symmetric,\n enabled_by_default=False,\n data_type=data_type)\n quantizers[name_in_layer] = self._grouped_quantizers[group_name]\n else:\n quantizers[name_in_layer] = tensor_quantizer_factory(\n activation_bw,\n round_mode,\n quant_scheme,\n use_symmetric_encodings=is_symmetric,\n enabled_by_default=False,\n data_type=data_type)\n return quantizers","def build(self):\n logger.info('Building...')\n self._check_cycles(self.abstract_graph.nx_graph)\n with ctx.inventory('new_nodes'):\n self._build_node(self.abstract_graph.start)\n self._autoplace(new_nodes)\n logger.info('Total number of nodes built: {}'.format(len(new_nodes)))\n return len(new_nodes)","def node_catalogue():\r\n\r\n classes = node_subclasses(Node)\r\n\r\n catalogue = {}\r\n\r\n for node_class in classes:\r\n try:\r\n name = node_class.identifier()\r\n except AttributeError:\r\n # If node does not provide identifier, we consider it to be\r\n # private or abstract class\r\n continue\r\n\r\n # Get copy of node info\r\n info = dict(get_node_info(node_class))\r\n info[\"name\"] = name\r\n info[\"factory\"] = node_class\r\n\r\n # Get node type based on superclass, if not provided\r\n\r\n if \"type\" not in info:\r\n if issubclass(node_class, SourceNode):\r\n info[\"type\"] = \"source\"\r\n elif not issubclass(node_class, SourceNode) \\\r\n and not issubclass(node_class, TargetNode):\r\n info[\"type\"] = \"processing\"\r\n elif issubclass(node_class, TargetNode):\r\n info[\"type\"] = \"target\"\r\n else:\r\n info[\"type\"] = \"unknown\"\r\n\r\n catalogue[name] = info\r\n\r\n return catalogue","def get_output_nodes(self):\n \n\n self.buildings = self.dataset.groups['buildings']\n self.building_nodes = self.buildings.groups['nodes']\n\n eta_output_added = getattr(self.building_nodes,'eta_output_added')\n uv_output_added = getattr(self.building_nodes,'uv_output_added')\n\n eta = []\n uv = []\n nodeIds = []\n time = []\n \n if(eta_output_added or uv_output_added ):\n time = self.building_nodes.variables['time'][:].tolist()\n nodeIds = self.building_nodes.variables['id'][:].tolist()\n if eta_output_added: eta = self.building_nodes.variables['eta'][:].tolist()\n if uv_output_added: uv = self.building_nodes.variables['uv'][:].tolist()\n\n \n return nodeIds,eta, uv, time","def _apply_gating_logic(self):\n if self._mode != QcQuantizeOpMode.LEARN_ENCODINGS:\n return\n\n applied_quantizers = set()\n def apply_logic(name, quantizer):\n if quantizer in self._grouped_quantizers.values():\n if quantizer in applied_quantizers:\n return\n\n name, *_ = [n for n, q in self._grouped_quantizers.items() if q == quantizer]\n\n if quantizer.enabled:\n if quantizer.bitwidth == 32 or quantizer.data_type == QuantizationDataType.float:\n return\n set_encoding_min_max_gating_threshold(\n getattr(self, name + '_encoding_min'),\n getattr(self, name + '_encoding_max'))\n applied_quantizers.add(quantizer)\n\n for name, quantizer in self.input_quantizers.items():\n apply_logic(name, quantizer)\n for name, quantizer in self.output_quantizers.items():\n apply_logic(name, quantizer)\n for name, quantizer in self._param_quantizers.items():\n apply_logic(name, quantizer)","def __calculate_iterations(self):\n iterables = {}\n \n def get_type(type_options):\n key = self._config_dict[type_options].keys()[0]\n data = self._config_dict[type_options][key]\n \n if type(data) == dict:\n iterables[key] = [data]\n else:\n iterables[key] = data\n \n for config_type in self.__iterables:\n get_type(config_type)\n \n self.__iterables = [dict(zip(iterables, v)) for v in product(*iterables.values())] # Calculates the cartesian product of all the lists to iterate to generate permutations.\n self.__iterables_counter = 0","def build_pool(self):\n self._pool = [0] * N\n if isinstance(self._bases, dict):\n for base, num in self._bases.items():\n self._pool[to_code(base)] += num\n elif isinstance(self._bases, list):\n for base in self._bases:\n self._pool[to_code(base)] += 1","def _build_graph(self):\n start_t = time.time()\n self._setup_placeholders()\n self._embed()\n self._encode_back()\n self._encode()\n self._match()\n self._fuse()\n self._decode()\n self._compute_loss()\n self._create_train_op()\n self.logger.info('Time to build graph: {} s'.format(time.time() - start_t))\n param_num = sum([np.prod(self.sess.run(tf.shape(v))) for v in self.all_params])\n self.logger.info('There are {} parameters in the model'.format(param_num))","def build_graph(self):\n with vs.variable_scope(\"context\"):\n context_encoder = RNNEncoder(self.FLAGS.hidden_size, self.keep_prob)\n context_hiddens = context_encoder.build_graph(self.context_embs,\n self.context_mask) # (batch_size, context_len, hidden_size*2)\n\n with vs.variable_scope(\"question\"):\n question_encoder = RNNEncoder(self.FLAGS.hidden_size, self.keep_prob)\n question_hiddens = question_encoder.build_graph(self.qn_embs,\n self.qn_mask) # (batch_size, question_len, hidden_size*2)\n question_last_hidden = tf.reshape(question_hiddens[:, -1, :], (-1, 2 * self.FLAGS.hidden_size))\n question_last_hidden = tf.contrib.layers.fully_connected(question_last_hidden,\n num_outputs=self.FLAGS.hidden_size)\n # Use context hidden states to attend to question hidden states\n\n # attn_output is shape (batch_size, context_len, hidden_size*2)\n # The following is BiDAF attention\n if self.FLAGS.use_bidaf:\n attn_layer = BiDAF(self.keep_prob, self.FLAGS.hidden_size * 2, self.FLAGS.hidden_size * 2)\n attn_output = attn_layer.build_graph(question_hiddens, self.qn_mask, context_hiddens,\n self.context_mask) # (batch_size, context_len, hidden_size * 6)\n else: # otherwise, basic attention\n attn_layer = BasicAttn(self.keep_prob, self.FLAGS.hidden_size * 2, self.FLAGS.hidden_size * 2)\n _, attn_output = attn_layer.build_graph(question_hiddens, self.qn_mask, context_hiddens)\n # Concat attn_output to context_hiddens to get blended_reps\n blended_reps = tf.concat([context_hiddens, attn_output], axis=2) # (batch_size, context_len, hidden_size*4)\n\n blended_reps_final = tf.contrib.layers.fully_connected(blended_reps, num_outputs=self.FLAGS.hidden_size)\n\n decoder = RNNDecoder(self.FLAGS.batch_size, self.FLAGS.hidden_size, self.ans_vocab_size, self.FLAGS.answer_len,\n self.ans_embedding_matrix, self.keep_prob, sampling_prob=self.sampling_prob,\n schedule_embed=self.FLAGS.schedule_embed, pred_method=self.FLAGS.pred_method)\n (self.train_logits, self.train_translations, _), \\\n (self.dev_logits, self.dev_translations, self.attention_results) = decoder.build_graph(blended_reps_final, question_last_hidden,\n self.ans_embs, self.ans_mask, self.ans_ids,\n self.context_mask)","def build_order(self):\n seen = set()\n\n def _already_built(node):\n # visit only once\n if node in seen:\n return True\n seen.add(node)\n\n # prune if the result is already computed\n if node.output_ready:\n return True\n\n return False\n\n for target in self.targets:\n if target in seen:\n continue\n for node in target.postorder(prune_fn=_already_built):\n yield node","def build_graph(self, graph, inst_name, port_nets):\n return","def _build_graph(self):\n with tf.variable_scope(name_or_scope = self.name, reuse = self.reuse):\n if self.strides == 1:\n data_proj, data_path = ly.channel_shuffle(self.input)\n # deal data_path with branch_main\n with tf.variable_scope(name_or_scope = 'branch_main_s1', reuse = self.reuse):\n data_path = ly.conv_bn_activation(data_path, self.mid_channels, 1, self.strides, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\n data_path = ly.depthwise_conv_layer(data_path, self.mid_channels, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\n data_path = ly._bn(data_path, self.data_format, self.is_training)\n data_path = ly.conv_bn_activation(data_path, self.outputs, 1, self.strides, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\n return tf.concat((data_proj, data_path), axis = -1)\n else:\n data_proj = self.input\n data_path = self.input\n with tf.variable_scope(name_or_scope = 'branch_main_s2', reuse = self.reuse):\n data_path = ly.conv_bn_activation(data_path, self.mid_channels, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\n data_path = ly.depthwise_conv_layer(data_path, self.mid_channels, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\n data_path = ly._bn(data_path, self.data_format, self.is_training)\n data_path = ly.conv_bn_activation(data_path, self.outputs, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\n with tf.variable_scope(name_or_scope = 'branch_proj_s2', reuse = self.reuse):\n data_proj = ly.depthwise_conv_layer(data_proj, self.inp, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\n data_proj = ly._bn(data_proj, self.data_format, self.is_training)\n data_proj = ly.conv_bn_activation(data_proj, self.inp, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\n return tf.concat((data_proj, data_path), axis = -1)","def build(self): \n self.computation_graph = tf.Graph()\n with self.computation_graph.as_default():\n\n self.factorization_layer = Factorization(self.args, self.vocab_size)\n self.cluster_layer = Clustering(self.args)\n\n self.gamma = tf.placeholder(\"float\")\n self.loss = self.factorization_layer()+self.gamma*self.cluster_layer(self.factorization_layer)\n\n self.batch = tf.Variable(0)\n self.step = tf.placeholder(\"float\")\n \n self.learning_rate_new = tf.train.polynomial_decay(self.args.initial_learning_rate,\n self.batch,\n self.true_step_size,\n self.args.minimal_learning_rate,\n self.args.annealing_factor)\n \n self.train_op = tf.train.AdamOptimizer(self.learning_rate_new).minimize(self.loss, global_step = self.batch)\n \n self.init = tf.global_variables_initializer()\n\n self.weights = overlap_generator(self.args, self.graph)","def _expand_combinations(kernel: gpflow.kernels.Kernel) -> List[gpflow.kernels.Kernel]:\n if isinstance(kernel, (gpflow.kernels.Sum, gpflow.kernels.Product)):\n return kernel.children.values()\n\n return []","def build_graph(self):\n self._reset_iterator_memory()\n self._construct_graph_handler()\n assert self.graph_handler\n for rxn_id in self.graph_handler.get_valid_reaction_ids():\n rxn = db.Reaction(rxn_id, self._reactions)\n self.graph_handler.add_rxn(rxn)","def build_opt(self):\n student_taken = self.student.student_hist[['FULL','DESCR.y']]\n\n requiments = self.major_map.cleaned_major_data[['REQID','L','MA','CS','HU','SB','SQ','SG','C','G','H','Honor']]\n\n requiments.is_copy = False\n requiments['REQID'] = requiments['REQID'].astype('str')\n\n requirements_to = pd.merge(self.graph, requiments, how='inner', left_on='REQ', right_on='REQID')\n \n # requirements_to = pd.merge(self.graph, requiments, how='left', left_on='REQ', right_on='REQID')\n classes_from = pd.merge(self.graph, student_taken, how='left', left_on='CLS', right_on='FULL')\n\n return classes_from, requirements_to","def build_graph(self, values, values_mask, keys):\n \n \n\n with vs.variable_scope(\"CoAttn\"):\n \n #########################################################################\n # Introduce a non-linear projection layer on top of the question encoding\n # to allow for varation between question and document encoding space\n W_q = tf.get_variable(name=\"W_q\", \\\n shape=[2*self.key_vec_size,2*self.key_vec_size],\\\n initializer=tf.contrib.layers.xavier_initializer(),\\\n dtype=tf.float32)\n\n W_q = tf.expand_dims(tf.ones([tf.shape(values)[0],1]), 1) * W_q\n\n b_q = tf.Variable(tf.constant(0.0,\\\n shape=[2*self.key_vec_size,]),\\\n dtype=tf.float32,\\\n name='b_q')\n \n Q = tf.nn.tanh(tf.matmul(values,W_q)+b_q)\n #########################################################################\n\n #########################################################################\n # Coattention Encoder \n \n # L --> affinity matrix\n l = tf.matmul(keys,tf.transpose(Q,perm=[0,2,1]))\n \n # mask affinity matrix, to not care about padded values\n l_mask = tf.expand_dims(values_mask, 1)\n \n # a_q --> attention weights across document for each word in the question\n _, a_q = masked_softmax(l, l_mask, 2)\n \n # a_d --> attention weights across question for each word in the document\n a_d = tf.nn.softmax(tf.transpose(l,perm=[0, 2, 1]))\n \n # compute attention context of the document in light of each word of the question\n c_q = tf.matmul(tf.transpose(a_q,perm=[0,2,1]),keys)\n \n # parallel computation of q*a_d & c_q*a_q\n c_d = tf.matmul(tf.transpose(a_d,perm=[0,2,1]),tf.concat([Q,c_q],2))\n \n # d_c_d as concatinated d;c_d as inpit for the Bi-LSTM\n d_c_d = tf.concat([keys,c_d],axis=2)\n \n d_c_d_length = tf.cast(\\\n tf.reduce_sum(\\\n tf.sign(\\\n tf.reduce_max(\\\n tf.abs(d_c_d), axis=2)\\\n ),\\\n axis=1), \\\n tf.int32)\n \n with tf.variable_scope('coattentionencoder'):\n u_lstm_forward = tf.contrib.rnn.BasicLSTMCell(self.key_vec_size) \n u_lstm_backward = tf.contrib.rnn.BasicLSTMCell(self.key_vec_size)\n big_u,_ = tf.nn.bidirectional_dynamic_rnn(cell_bw=u_lstm_backward,cell_fw=u_lstm_forward,dtype=tf.float32,inputs=d_c_d,time_major=False,sequence_length=d_c_d_length)\n \n # Dropout on the concatinated big U containing forward and backward pass\n output = tf.nn.dropout(tf.concat(big_u,2), self.keep_prob)\n\n\n return output","def run(self, dag):\n self.property_set[\"commutation_set\"] = defaultdict(list)\n pending_1q = [list() for _ in range(dag.num_qubits())]\n block_id = [-(i + 1) for i in range(dag.num_qubits())]\n current_id = 0\n block_list = list()\n to_qid = dict()\n for i, qubit in enumerate(dag.qubits):\n to_qid[qubit] = i\n for node in dag.topological_op_nodes():\n qids = [to_qid[q] for q in node.qargs]\n if (\n not isinstance(node.op, Gate)\n or len(qids) > 2\n or node.op.condition\n or node.op.is_parameterized()\n ):\n for qid in qids:\n if block_id[qid] > 0:\n block_list[block_id[qid]].extend(pending_1q[qid])\n block_id[qid] = -(qid + 1)\n pending_1q[qid].clear()\n continue\n\n if len(qids) == 1:\n b_id = block_id[qids[0]]\n if b_id < 0:\n pending_1q[qids[0]].append(node)\n else:\n block_list[b_id].append(node)\n elif block_id[qids[0]] == block_id[qids[1]]:\n block_list[block_id[qids[0]]].append(node)\n else:\n block_id[qids[0]] = current_id\n block_id[qids[1]] = current_id\n new_block = list()\n if pending_1q[qids[0]]:\n new_block.extend(pending_1q[qids[0]])\n pending_1q[qids[0]].clear()\n if pending_1q[qids[1]]:\n new_block.extend(pending_1q[qids[1]])\n pending_1q[qids[1]].clear()\n new_block.append(node)\n block_list.append(new_block)\n current_id += 1\n\n self.property_set[\"block_list\"] = [tuple(block) for block in block_list]\n return dag","def graph_implementation(arg_objs, size, data=None):\n t = lu.create_var(size)\n for i, obj in enumerate(arg_objs):\n # Promote obj.\n if obj.size != size:\n arg_objs[i] = lu.promote(obj, size)\n\n return (t, [SOC_Elemwise(t, arg_objs)])","def get_reversed_fusions() -> List[Tuple[NSFusionType, int]]:\n results: List[Tuple[NSFusionType, int]] = []\n\n # Possible syntaxes:\n # * single op: torch.nn.Conv2d\n # * multiple ops: (torch.nn.ReLU, torch.nn.Conv2d)\n # For fusions, we only care about patterns composed of multiple ops.\n # TODO(future PR): allow customizations from default patterns.\n all_quant_patterns = _get_pattern_to_quantize_handlers(get_native_backend_config())\n\n default_base_op_idx = 0\n for quant_pattern in all_quant_patterns.keys():\n # TODO: this is a temporary hack to flatten the patterns from quantization so\n # that it works with the ns matcher function, maybe we should use `_is_match`\n # in torch.ao.quantization.fx.match_utils to match the patterns\n if isinstance(quant_pattern, tuple) and len(quant_pattern) == 2 and \\\n isinstance(quant_pattern[1], tuple) and len(quant_pattern[1]) == 2:\n # flatten the pattern with form (nn.ReLU, (nn.BatchNorm2d, nn.Conv2d))\n quant_pattern = (quant_pattern[0], quant_pattern[1][0], quant_pattern[1][1])\n\n # Only patterns of multiple ops are fusions, ignore\n # patterns which contain a single ops (they get matched\n # without caring about fusions).\n if isinstance(quant_pattern, tuple):\n results.append((quant_pattern, default_base_op_idx)) # type: ignore[arg-type]\n\n # For each pattern, add additional patterns with observers and\n # fake quants at the end.\n # TODO(future PR): if needed, implement matching for a node\n # having multiple output observers.\n for cls in (ObserverBase, FakeQuantizeBase):\n if isinstance(quant_pattern, tuple):\n new_pattern = (cls, *quant_pattern)\n else:\n new_pattern = (cls, quant_pattern)\n results.append((new_pattern, default_base_op_idx)) # type: ignore[arg-type]\n\n\n # After this point, results contains values such as\n # [..., ((torch.nn.Relu, torch.nn.Conv2d), 0), ...]\n\n # Patterns for matching fp16 emulation are not specified in the quantization\n # fusion mappings. For now, define them here.\n fp16_em_base_op_idx = 1\n patterns_to_add = [\n # linear-relu fp16 emulation:\n # fp16_to_fp32 -> linear -> relu -> fp32_to_fp16\n (((\"to\", torch.float16), F.relu, F.linear, \"dequantize\"), fp16_em_base_op_idx,),\n # Conv-BN fusion (this happens outside of quantization patterns,\n # which is why it is defined separately here).\n ((nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),\n ((nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),\n ((nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),\n ((nn.ReLU, nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),\n ((nn.ReLU, nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),\n ((nn.ReLU, nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),\n ]\n for p in patterns_to_add:\n results.append(p) # type: ignore[arg-type]\n results.append(((ObserverBase, *p[0]), p[1])) # type: ignore[arg-type]\n results.append(((FakeQuantizeBase, *p[0]), p[1])) # type: ignore[arg-type]\n\n return results","def _build(self, generation):\n with tf.variable_scope ('discriminator') as scope:\n \n image_unflatten = unflatten_layer ( self.images )\n gen_unflatten = unflatten_layer ( generation )\n\n # Conv Layer 1 - image\n conv1_out_image, params = conv_2d_layer (\n input = image_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'conv_1_img',\n visualize = True ) \n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \n \n # Conv Layer 1 - gen\n conv1_out_gen, params = conv_2d_layer (\n input = gen_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n params = params,\n name = 'conv_1_gen',\n visualize = False )\n\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \n process_params(params, name = self.name)\n c1_params = params\n\n\n\n\n\n # Conv Layer 2 - image\n conv2_out_image, params = conv_2d_layer (\n input = lrn1_out_img,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'conv_2_img' )\n\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \n\n\n # Conv Layer 2 - gen\n conv2_out_gen, params = conv_2d_layer (\n input = lrn1_out_gen,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n params = params,\n name = 'conv_2_gen' )\n\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \n process_params(params, name = self.name)\n c2_params = params\n\n # Dropout Layer\n flat_gen = flatten_layer(lrn2_out_gen)\n flat_img = flatten_layer(lrn2_out_img)\n\n flat_gen_dropout = dropout_layer ( input = flat_gen,\n prob = self.dropout_prob,\n name = 'dropout_1_gen') \n\n flat_img_dropout = dropout_layer ( input = flat_img,\n prob = self.dropout_prob,\n name = 'dropout_1_img') \n\n\n\n # Dot Product Layer 1 -img\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\n neurons = HIDDEN_1,\n name = 'image_disc_dot_1')\n # Dot Product Layer 1 - gen\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_1')\n\n process_params(params, name = self.name)\n d1_params = params\n \n ##\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_2_gen') \n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\n prob = self.dropout_prob,\n name = 'dropout_2_img')\n\n # Dot Product Layer 2 -img\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\n neurons = HIDDEN_2,\n name = 'image_disc_dot_2')\n # Dot Product Layer 2 - gen\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_2')\n process_params(params, name = self.name)\n d2_params = params\n\n ##\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_3_gen') \n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\n prob = self.dropout_prob,\n name = 'dropout_3_img')\n\n # Dot Product Layer 1 -img\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\n neurons = 1,\n activation = 'sigmoid',\n name = 'real')\n # Dot Product Layer 1 -gen\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\n params = params,\n neurons = 1,\n activation = 'sigmoid',\n name = 'fake')\n\n process_params(params, name = self.name)\n d3_params = params\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \n\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\n 0.5 * tf.reduce_mean ((self.fake)**2)\n tf.summary.scalar('discriminator_obj', discriminator_obj)\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \n\n with tf.variable_scope (self.name + '_probabilites') as scope: \n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\n \n self._cook_optimizer( \n lr = DIS_GAN_LR, \n optimizer = DIS_GAN_OPTIMIZER,\n l1_coeff = DIS_GAN_L1_COEFF,\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)","def _QConv(self, step, target, qubits):\n yield cirq.CZPowGate(exponent=self._get_new_param())(qubits[target], qubits[target+step])\n yield cirq.CXPowGate(exponent=self._get_new_param())(qubits[target], qubits[target+step])","def build(self): \n self.computation_graph = tf.Graph()\n with self.computation_graph.as_default():\n\n self.factorization_layer = Factorization(self.args, self.vocab_size)\n self.regularizer_layer = Regularization(self.args)\n\n self.gamma = tf.placeholder(\"float\")\n self.loss = self.factorization_layer()\n\n self.batch = tf.Variable(0)\n self.step = tf.placeholder(\"float\")\n \n self.learning_rate_new = tf.train.polynomial_decay(self.args.initial_learning_rate,\n self.batch,\n self.true_step_size,\n self.args.minimal_learning_rate,\n self.args.annealing_factor)\n \n self.train_op = tf.train.AdamOptimizer(self.learning_rate_new).minimize(self.loss, global_step = self.batch)\n \n self.init = tf.global_variables_initializer()\n\n self.weights = overlap_generator(self.args, self.graph)","def convert_roipooling(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n\n pooled_shape = convert_string_to_list(attrs.get('pooled_size'))\n scale = float(attrs.get(\"spatial_scale\"))\n\n node = onnx.helper.make_node(\n 'MaxRoiPool',\n input_nodes,\n [name],\n pooled_shape=pooled_shape,\n spatial_scale=scale,\n name=name\n )\n return [node]","def build_control_outputs(graph):\n ops = graph.get_operations()\n control_outputs = {}\n for op in ops:\n for cin in op.control_inputs:\n if cin in control_outputs:\n control_outputs[cin] |= {op}\n else:\n control_outputs[cin] = {op}\n return control_outputs","def finalize(self, *args, **kwargs):\n self._add_all_odes_to_interface()\n self._transform_derivatives_on_rhs()\n super(InterfaceGenerator, self).finalize(*args, **kwargs)"],"string":"[\n \"def _collect_ipt_and_opt_nodes(self):\\n for name, node in self._nodes_collection.items():\\n if node.in_degree == 0:\\n # NOTICE: what's usage of `scope`?\\n self._input_nodes.append(name)\\n\\n if node.out_degree == 0:\\n self._output_nodes.append(name)\",\n \"def _query_quantizable_ops(self, matched_nodes, activation_dtype, weight_dtype):\\n\\n tf_quantizable_op_type = (\\\"Conv2D\\\", \\\"DepthwiseConv2dNative\\\",\\n \\\"MaxPool\\\", \\\"AvgPool\\\", \\\"ConcatV2\\\", \\\"MatMul\\\", \\\"Pad\\\")\\n conv_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax', 'kl'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n },\\n 'weight': {\\n 'dtype': weight_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_channel', 'per_tensor']\\n }\\n }\\n matmul_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['asym', 'sym'],\\n 'granularity': ['per_tensor']\\n },\\n 'weight': {\\n 'dtype': weight_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n }\\n }\\n other_config = {\\n 'activation': {\\n 'dtype': activation_dtype,\\n 'algorithm': ['minmax'],\\n 'scheme': ['sym'],\\n 'granularity': ['per_tensor']\\n },\\n }\\n\\n self.quantizable_op_details = OrderedDict()\\n\\n self._init_op_stat = {i: [] for i in tf_quantizable_op_type}\\n for details in matched_nodes:\\n node_op = details[-1][0]\\n node_name = details[0]\\n patterns = details[-1]\\n pat_length = len(patterns)\\n pattern_info = {\\n 'sequence': [[','.join(patterns[:pat_length - i]) for i in range(pat_length)][0]],\\n 'precision': ['int8']\\n }\\n if node_op in tf_quantizable_op_type and node_name not in self.exclude_node_names:\\n self._init_op_stat[node_op].append(node_name)\\n if self.unify_op_type_mapping[node_op].find(\\\"conv2d\\\") != -1:\\n conv2d_int8_config = copy.deepcopy(conv_config)\\n conv2d_int8_config['pattern'] = pattern_info\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = conv2d_int8_config\\n elif self.unify_op_type_mapping[node_op].find(\\\"matmul\\\") != -1:\\n matmul_int8_config = copy.deepcopy(matmul_config)\\n matmul_int8_config['pattern'] = pattern_info\\n # TODO enable the sym mode once the tf fixed the mkldequantize_op.cc bug.\\n # is_positive_input = self.pre_optimizer_handle.has_positive_input(node_name)\\n # matmul_scheme = 'sym' if is_positive_input else 'asym'\\n matmul_scheme = ['asym']\\n matmul_int8_config['activation']['scheme'] = matmul_scheme\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = matmul_int8_config\\n else:\\n self.quantizable_op_details[(\\n node_name, self.unify_op_type_mapping[node_op]\\n )] = copy.deepcopy(other_config)\\n\\n self.quantize_config['op_wise_config'][node_name] = (False, \\\"minmax\\\", False)\\n return self.quantizable_op_details\",\n \"def gen_graph(self):\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def _build_computation_graph(self):\\n raise NotImplementedError\",\n \"def build_graph(self):\\n n_classes = self.n_classes\\n\\n (self.feed('data')\\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\\n .conv(3, 3, 256, 1, 1, name='conv3_1')\\n .conv(3, 3, 256, 1, 1, name='conv3_2')\\n .conv(3, 3, 256, 1, 1, name='conv3_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\\n .conv(3, 3, 512, 1, 1, name='conv4_1')\\n .conv(3, 3, 512, 1, 1, name='conv4_2')\\n .conv(3, 3, 512, 1, 1, name='conv4_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\\n .conv(3, 3, 512, 1, 1, name='conv5_1')\\n .conv(3, 3, 512, 1, 1, name='conv5_2')\\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\\n\\n self.compute_rDeRF() # dummy\\n\\n # Classification\\n (self.feed('conv5_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\\n .fc(4096, name='fc6')\\n .dropout(0.5, name='drop6')\\n .fc(4096, name='fc7')\\n .dropout(0.5, name='drop7')\\n # .make_time(name='drop7_reduced')\\n .fc(n_classes, relu=False, name='cls_score')\\n .softmax(name='cls_prob'))\\n pass\",\n \"def build_inference_graph(self):\\n self.build_train_graph()\",\n \"def build_graph(self):\\n pass\",\n \"def convert_voting_classifier(\\n scope: Scope, operator: Operator, container: ModelComponentContainer\\n):\\n if scope.get_options(operator.raw_operator, dict(nocl=False))[\\\"nocl\\\"]:\\n raise RuntimeError(\\n \\\"Option 'nocl' is not implemented for operator '{}'.\\\".format(\\n operator.raw_operator.__class__.__name__\\n )\\n )\\n proto_dtype = guess_proto_type(operator.inputs[0].type)\\n if proto_dtype != onnx_proto.TensorProto.DOUBLE:\\n proto_dtype = onnx_proto.TensorProto.FLOAT\\n op = operator.raw_operator\\n n_classes = len(op.classes_)\\n\\n classes_ind_name = scope.get_unique_variable_name(\\\"classes_ind\\\")\\n container.add_initializer(\\n classes_ind_name,\\n onnx_proto.TensorProto.INT64,\\n (1, n_classes),\\n list(range(n_classes)),\\n )\\n\\n probs_names = []\\n one_name = None\\n for i, estimator in enumerate(op.estimators_):\\n if estimator is None:\\n continue\\n\\n op_type = sklearn_operator_name_map[type(estimator)]\\n\\n this_operator = scope.declare_local_operator(op_type, estimator)\\n this_operator.inputs = operator.inputs\\n\\n label_name = scope.declare_local_variable(\\\"label_%d\\\" % i, Int64TensorType())\\n prob_name = scope.declare_local_variable(\\n \\\"voting_proba_%d\\\" % i, operator.inputs[0].type.__class__()\\n )\\n this_operator.outputs.append(label_name)\\n this_operator.outputs.append(prob_name)\\n\\n if op.voting == \\\"hard\\\":\\n if one_name is None:\\n shape_name = scope.get_unique_variable_name(\\\"shape\\\")\\n container.add_node(\\n \\\"Shape\\\",\\n prob_name.onnx_name,\\n shape_name,\\n name=scope.get_unique_operator_name(\\\"Shape\\\"),\\n )\\n zero_name = scope.get_unique_variable_name(\\\"zero\\\")\\n container.add_node(\\n \\\"ConstantOfShape\\\",\\n shape_name,\\n zero_name,\\n name=scope.get_unique_operator_name(\\\"CoSA\\\"),\\n value=make_tensor(\\\"value\\\", proto_dtype, (1,), [0.0]),\\n op_version=9,\\n )\\n one_name = scope.get_unique_variable_name(\\\"one\\\")\\n container.add_node(\\n \\\"ConstantOfShape\\\",\\n shape_name,\\n one_name,\\n name=scope.get_unique_operator_name(\\\"CoSB\\\"),\\n value=make_tensor(\\\"value\\\", proto_dtype, (1,), [1.0]),\\n op_version=9,\\n )\\n\\n argmax_output_name = scope.get_unique_variable_name(\\\"argmax_output\\\")\\n container.add_node(\\n \\\"ArgMax\\\",\\n prob_name.onnx_name,\\n argmax_output_name,\\n name=scope.get_unique_operator_name(\\\"ArgMax\\\"),\\n axis=1,\\n )\\n\\n equal_name = scope.get_unique_variable_name(\\\"equal\\\")\\n container.add_node(\\n \\\"Equal\\\",\\n [argmax_output_name, classes_ind_name],\\n equal_name,\\n name=scope.get_unique_operator_name(\\\"Equal\\\"),\\n )\\n\\n max_proba_name = scope.get_unique_variable_name(\\\"probsmax\\\")\\n container.add_node(\\n \\\"Where\\\",\\n [equal_name, one_name, zero_name],\\n max_proba_name,\\n name=scope.get_unique_operator_name(\\\"Where\\\"),\\n )\\n prob_name = max_proba_name\\n else:\\n prob_name = prob_name.onnx_name\\n\\n if op.weights is not None:\\n val = op.weights[i] / op.weights.sum()\\n else:\\n val = 1.0 / len(op.estimators_)\\n\\n weights_name = scope.get_unique_variable_name(\\\"w%d\\\" % i)\\n container.add_initializer(weights_name, proto_dtype, [1], [val])\\n wprob_name = scope.get_unique_variable_name(\\\"wprob_name\\\")\\n apply_mul(scope, [prob_name, weights_name], wprob_name, container, broadcast=1)\\n probs_names.append(wprob_name)\\n\\n if op.flatten_transform in (False, None):\\n container.add_node(\\n \\\"Sum\\\",\\n probs_names,\\n operator.outputs[1].full_name,\\n name=scope.get_unique_operator_name(\\\"Sum\\\"),\\n )\\n else:\\n raise NotImplementedError(\\n \\\"flatten_transform==True is not implemented yet. \\\"\\n \\\"You may raise an issue at \\\"\\n \\\"https://github.com/onnx/sklearn-onnx/issues.\\\"\\n )\\n\\n # labels\\n label_name = scope.get_unique_variable_name(\\\"label_name\\\")\\n container.add_node(\\n \\\"ArgMax\\\",\\n operator.outputs[1].full_name,\\n label_name,\\n name=scope.get_unique_operator_name(\\\"ArgMax\\\"),\\n axis=1,\\n )\\n _finalize_converter_classes(\\n scope,\\n label_name,\\n operator.outputs[0].full_name,\\n container,\\n op.classes_,\\n proto_dtype,\\n )\",\n \"def _build_graph(self):\\n pass\",\n \"def _form_computation_graph(self, idx):\\n _list, _set = list, set\\n if type(idx) is int:\\n node_layers = [np.array([idx], dtype=np.int64)]\\n elif type(idx) is list:\\n node_layers = [np.array(idx, dtype=np.int64)]\\n\\n for _ in range(self.n_layers):\\n prev = node_layers[-1]\\n arr = [node for node in prev]\\n arr.extend([e[0] for node in arr for e in self.nbrs_t[node]])\\n arr = np.array(_list(_set(arr)), dtype=np.int64)\\n node_layers.append(arr)\\n node_layers.reverse()\\n\\n mappings = [{j: i for (i, j) in enumerate(arr)} for arr in node_layers]\\n\\n return node_layers, mappings\",\n \"def build_graph(self):\\n for node in self.graph.nodes():\\n self.c2py[node] = PyNode(node)\\n for _input in node.inputs():\\n if _input not in self.c2py:\\n self.c2py[_input] = PyNode(_input, True)\\n if _input in self.forward_edge:\\n self.forward_edge[_input].append(node)\\n else:\\n self.forward_edge[_input] = [node]\\n for output in node.outputs():\\n if output not in self.c2py:\\n self.c2py[output] = PyNode(output, True)\\n if node in self.forward_edge:\\n self.forward_edge[node].append(output)\\n else:\\n self.forward_edge[node] = [output]\",\n \"def build_graph(self):\\n self.__create_placeholders()\\n self.__create_encoder()\\n self.__create_latent()\\n self.__create_decoder()\\n self.__create_loss()\\n self.__create_generate()\\n self.__create_reconstruct()\\n self.__create_optimizer()\\n self.__create_summary()\",\n \"def _select_implementations(self, graph, memory_manager):\\n implementations = {}\\n for node in graph.nodes:\\n choices = []\\n for op in OperationRegistry.get_ops(node.op_type):\\n candidate = op.create(node, graph, memory_manager)\\n if candidate is not None:\\n choices.append(candidate)\\n\\n if len(choices) >= 1:\\n implementations[node] = choices[0]\\n else:\\n implementations[node] = None\\n\\n return implementations\",\n \"def create_nodes(self):\",\n \"def build_graph(self):\\n raise NotImplementedError\",\n \"def convert_type(self):\\r\\n tree = self.substitute.tree_\\r\\n classes = self.substitute.classes_\\r\\n node_list = []\\r\\n for i in range(tree.capacity):\\r\\n if tree.feature[i] == -2:\\r\\n node_list.append(Node(label=classes[np.argmax(tree.value[i, 0, :])]))\\r\\n else:\\r\\n node_list.append(Node(tree.feature[i], tree.threshold[i]))\\r\\n for i in range(tree.capacity):\\r\\n if tree.children_left[i] != -1:\\r\\n node_list[i].left = node_list[tree.children_left[i]]\\r\\n node_list[tree.children_left[i]].parents.append(node_list[i]) if node_list[i] not in node_list[tree.children_left[i]].parents else node_list[tree.children_left[i]].parents\\r\\n if tree.children_right[i] != -1:\\r\\n node_list[i].right = node_list[tree.children_right[i]]\\r\\n node_list[tree.children_right[i]].parents.append(node_list[i]) if node_list[i] not in node_list[tree.children_right[i]].parents else node_list[tree.children_right[i]].parents\\r\\n return node_list[0]\",\n \"def buildGraph(self):\\r\\n\\r\\n print 'Building graph...'\\r\\n\\r\\n self.buildQ()\\r\\n self.buildP()\\r\\n self.buildReconstructionTerm()\\r\\n self.buildConditionalPriorTerm()\\r\\n self.buildWPriorTerm()\\r\\n self.buildZPriorTerm()\\r\\n\\r\\n self.buildObjective()\\r\\n self.buildGrad()\",\n \"def gen_nodes(self):\\n self.nodes = []\\n for i in range(self.num_nodes):\\n self.nodes.append(Node(self.fk))\",\n \"def build_graph(self):\\n self._build_model()\\n if self.mode == 'train':\\n self._build_train_op()\",\n \"def _create_graph(self, pools: List[Pool]):\\n for pool in pools:\\n self._add_nodes(pool.tokens)\\n\\n for pool in pools: # noqa: WPS440,WPS441\\n self._add_edges(pool) # noqa: WPS441\",\n \"def _build_networks(self):\\n self.online_convnet = self._create_network(name='Online')\\n self.target_convnet = self._create_network(name='Target')\\n\\n # Compute the Q-values which are used for action selection in the current\\n # state.\\n self._net_outputs = self.online_convnet(self.state_ph,\\n self.num_quantile_samples)\\n # Shape of self._net_outputs.quantile_values:\\n # num_quantile_samples x num_actions.\\n # e.g. if num_actions is 2, it might look something like this:\\n # Vals for Quantile .2 Vals for Quantile .4 Vals for Quantile .6\\n # [[0.1, 0.5], [0.15, -0.3], [0.15, -0.2]]\\n # Q-values = [(0.1 + 0.15 + 0.15)/3, (0.5 + 0.15 + -0.2)/3].\\n self._q_values = tf.reduce_mean(self._net_outputs.quantile_values, axis=0)\\n self._q_argmax = tf.argmax(self._q_values, axis=0)\\n self._policy_logits = tf.nn.softmax(self._q_values / self.tau, axis=0)\\n self._stochastic_action = tf.random.categorical(\\n self._policy_logits[None, Ellipsis],\\n num_samples=1,\\n dtype=tf.int32)[0][0]\\n\\n self._replay_net_outputs = self.online_convnet(self._replay.states,\\n self.num_tau_samples)\\n # Shape: (num_tau_samples x batch_size) x num_actions.\\n self._replay_net_quantile_values = self._replay_net_outputs.quantile_values\\n self._replay_net_quantiles = self._replay_net_outputs.quantiles\\n\\n # Do the same for next states in the replay buffer.\\n self._replay_net_target_outputs = self.target_convnet(\\n self._replay.next_states, self.num_tau_prime_samples)\\n # Shape: (num_tau_prime_samples x batch_size) x num_actions.\\n vals = self._replay_net_target_outputs.quantile_values\\n self._replay_net_target_quantile_values = vals\\n\\n # Compute Q-values which are used for action selection for the states and\\n # next states in the replay buffer.\\n target_next_action = self.target_convnet(self._replay.next_states,\\n self.num_quantile_samples)\\n target_action = self.target_convnet(self._replay.states,\\n self.num_quantile_samples)\\n\\n # Shape: (num_quantile_samples x batch_size) x num_actions.\\n target_next_quantile_values_action = target_next_action.quantile_values\\n # Shape: num_quantile_samples x batch_size x num_actions.\\n target_next_quantile_values_action = tf.reshape(\\n target_next_quantile_values_action,\\n [self.num_quantile_samples, self._replay.batch_size, self.num_actions])\\n\\n # Shape: (num_quantile_samples x batch_size) x num_actions.\\n target_quantile_values_action = target_action.quantile_values\\n # Shape: num_quantile_samples x batch_size x num_actions.\\n target_quantile_values_action = tf.reshape(target_quantile_values_action,\\n [self.num_quantile_samples,\\n self._replay.batch_size,\\n self.num_actions])\\n # Shape: batch_size x num_actions.\\n self._replay_next_target_q_values = tf.squeeze(tf.reduce_mean(\\n target_next_quantile_values_action, axis=0))\\n self._replay_target_q_values = tf.squeeze(tf.reduce_mean(\\n target_quantile_values_action, axis=0))\\n\\n self._replay_next_qt_argmax = tf.argmax(\\n self._replay_next_target_q_values, axis=1)\",\n \"def make_qnode_and_params(self, initial_expansion_strategy):\\n n_layers = 2\\n n_wires = 5\\n\\n dev = qml.device(\\\"default.qubit\\\", wires=n_wires)\\n\\n @qml.qnode(dev, expansion_strategy=initial_expansion_strategy)\\n def circuit(params):\\n qml.BasicEntanglerLayers(params, wires=range(n_wires))\\n return qml.expval(qml.PauliZ(0))\\n\\n params_shape = qml.BasicEntanglerLayers.shape(n_layers=n_layers, n_wires=n_wires)\\n rng = np.random.default_rng(seed=10)\\n params = rng.standard_normal(params_shape)\\n\\n return circuit, params\",\n \"def generate_operations(self):\\n combinations = self.COMBINATIONS.items()[:self.limit]\\n for (term1, term2), type in combinations:\\n yield (term1, term2, type)\",\n \"def build_graph(self):\\n\\t\\tself._create_placeholders()\\n\\t\\tself._create_embedding()\\n\\t\\tself._create_recurrent_layers()\\n\\t\\tself._create_de_embedding()\\n\\t\\tself._create_loss()\\n\\t\\tself._create_optimizer()\\n\\t\\tself._create_summaries()\",\n \"def build_node_graph(self):\\n G = pgv.AGraph(strict=False, directed=True)\\n temp_dict = defaultdict(int) #key - from_to_ip, val - counter\\n\\n for i, ip in enumerate(self.node_graph_dict.keys()):\\n G.add_node(ip, shape='rect', label='%d' % i)\\n logger.info(\\\"All nodes added\\\")\\n\\n for ip, droplist in self.node_graph_dict.iteritems():\\n for gnid, dropids in droplist:\\n for did in dropids:\\n tip = self.gnid_ip_dict[self.oid_gnid_dict[did]]\\n k = '{0}_{1}'.format(ip, tip)\\n temp_dict[k] += 1\\n\\n for k, v in temp_dict.iteritems():\\n ks = k.split('_')\\n G.add_edge(ks[0], ks[1], weight=v)\\n\\n return G\",\n \"def find_quantizer_nodes_to_cut(\\n graph: NNCFGraph,\\n quantizer_node: NNCFNode,\\n quantizer_metatypes: List[OperatorMetatype],\\n const_metatypes: List[OperatorMetatype],\\n quantizable_metatypes: List[OperatorMetatype],\\n quantize_agnostic_metatypes: List[OperatorMetatype],\\n) -> Tuple[List[NNCFNode], List[NNCFNode]]:\\n\\n def _parse_node_relatives(node: NNCFNode, is_parents: bool):\\n if node.metatype in quantizable_metatypes:\\n ops_to_return_in_orig_prec.add(node)\\n\\n relatives = graph.get_previous_nodes(node) if is_parents else graph.get_next_nodes(node)\\n for relative in relatives:\\n if relative.metatype in quantizer_metatypes:\\n if is_parents:\\n if relative in seen_children:\\n continue\\n if relative not in to_cut:\\n to_cut.append(relative)\\n to_see_children.append(relative)\\n else:\\n seen_children.append(relative)\\n elif relative.metatype not in const_metatypes:\\n if relative not in seen_parents:\\n to_see_parents.append(relative)\\n if relative not in seen_children and relative.metatype in quantize_agnostic_metatypes:\\n to_see_children.append(relative)\\n\\n seen_list = seen_parents if is_parents else seen_children\\n seen_list.append(node)\\n\\n seen_children, seen_parents = [], []\\n to_see_children, to_see_parents = [quantizer_node], []\\n to_cut = [quantizer_node]\\n ops_to_return_in_orig_prec = set()\\n\\n while to_see_parents or to_see_children:\\n if to_see_children:\\n _parse_node_relatives(to_see_children.pop(), is_parents=False)\\n if to_see_parents:\\n _parse_node_relatives(to_see_parents.pop(), is_parents=True)\\n\\n return to_cut, list(ops_to_return_in_orig_prec)\",\n \"def _build_networks(self):\\n # Calling online_convnet will generate a new graph as defined in\\n # self._get_network_template using whatever input is passed, but will always\\n # share the same weights.\\n self.online_convnet = tf.make_template('Online', self._network_template)\\n self.target_convnet = tf.make_template('Target', self._network_template)\\n self._net_outputs = self.online_convnet(self.state_ph)\\n\\n self._replay_net_outputs = self.online_convnet(self._replay.states)\\n self._replay_next_target_net_outputs = self.target_convnet(\\n self._replay.next_states)\\n\\n if self.acting_policy == 'hyperbolic':\\n self._q_argmax = tf.argmax(self._net_outputs.hyp_q_value, axis=1)[0]\\n elif self.acting_policy == 'largest_gamma':\\n self._q_argmax = tf.argmax(self._net_outputs.q_values[-1], axis=1)[0]\\n else:\\n raise NotImplementedError\",\n \"def build_graph(self):\\n\\n\\n\\n self.inputs.append( #uint8\\n tf.placeholder(tf.float32, shape=[None, None, None, self.channel],\\n name='input/lr')) \\n\\n self.label.append(\\n tf.placeholder(tf.float32, shape=[None, None, None, self.channel],\\n name='label/hr'))\",\n \"def _build_network(self):\\n # self._observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.uint8, name=\\\"observation\\\")\\n # self._observation = tf.to_float(self._observation) / 255.0\\n # self._observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.float32, name=\\\"observation\\\")\\n self._observation = self._obs_fn()\\n self._action = tf.placeholder(dtype=tf.int32, shape=[None], name=\\\"action\\\")\\n self._reward = tf.placeholder(dtype=tf.float32, shape=[None], name=\\\"reward\\\")\\n self._done = tf.placeholder(dtype=tf.float32, shape=[None], name=\\\"done\\\")\\n # self._next_observation = tf.placeholder(dtype=tf.uint8, shape=[None, *self._dim_obs], name=\\\"next_observation\\\")\\n # self._next_observation = tf.to_float(self._next_observation) / 255.0\\n # self._next_observation = tf.placeholder(shape=[None, *self._dim_obs], dtype=tf.float32, name=\\\"next_observation\\\")\\n self._next_observation = self._obs_fn()\\n\\n with tf.variable_scope(\\\"main/qnet\\\"):\\n # self._qvals = self._dense(self._observation)\\n self._qvals = self._value_fn(self._observation)\\n\\n self._target_qvals = []\\n for i in range(self._n_net):\\n with tf.variable_scope(f\\\"target_{i}/qnet\\\"):\\n self._target_qvals.append(self._value_fn(self._next_observation))\",\n \"def _build_graph(self,\\n question_word,\\n question_word_mask,\\n question_subword,\\n question_subword_mask,\\n question_char,\\n question_char_mask,\\n context_word,\\n context_word_mask,\\n context_subword,\\n context_subword_mask,\\n context_char,\\n context_char_mask):\\n with tf.variable_scope(\\\"graph\\\", reuse=tf.AUTO_REUSE):\\n \\\"\\\"\\\"build representation layer for qanet model\\\"\\\"\\\"\\n (question_feat, question_feat_mask, context_feat,\\n context_feat_mask) = self._build_representation_layer(question_word, question_word_mask,\\n question_subword, question_subword_mask, question_char, question_char_mask, context_word,\\n context_word_mask, context_subword, context_subword_mask, context_char, context_char_mask)\\n \\n \\\"\\\"\\\"build understanding layer for qanet model\\\"\\\"\\\"\\n (question_understanding, context_understanding, question_understanding_mask,\\n context_understanding_mask) = self._build_understanding_layer(question_feat,\\n context_feat, question_feat_mask, context_feat_mask)\\n \\n \\\"\\\"\\\"build interaction layer for qanet model\\\"\\\"\\\"\\n answer_interaction, answer_interaction_mask = self._build_interaction_layer(question_understanding,\\n context_understanding, question_understanding_mask, context_understanding_mask)\\n \\n \\\"\\\"\\\"build modeling layer for qanet model\\\"\\\"\\\"\\n answer_modeling, answer_modeling_mask = self._build_modeling_layer(answer_interaction, answer_interaction_mask)\\n \\n \\\"\\\"\\\"build output layer for qanet model\\\"\\\"\\\"\\n answer_output_list, answer_output_mask_list = self._build_output_layer(answer_modeling, answer_modeling_mask)\\n answer_start_output = answer_output_list[0]\\n answer_end_output = answer_output_list[1]\\n answer_start_output_mask = answer_output_mask_list[0]\\n answer_end_output_mask = answer_output_mask_list[1]\\n \\n return answer_start_output, answer_end_output, answer_start_output_mask, answer_end_output_mask\",\n \"def QCNN_layer_gen(self):\\n pixels = self.filter_size**2\\n # filter size: 2^n only for this version!\\n if np.log2(pixels) % 1 != 0:\\n raise NotImplementedError(\\\"filter size: 2^n only available\\\")\\n cirq_qubits = cirq.GridQubit.rect(self.filter_size, self.filter_size)\\n # mapping input data to circuit\\n input_circuit = cirq.Circuit()\\n input_params = [sympy.symbols('a%d' %i) for i in range(pixels)]\\n for i, qubit in enumerate(cirq_qubits):\\n input_circuit.append(cirq.rx(np.pi*input_params[i])(qubit))\\n # apply learnable gate set to QCNN circuit\\n QCNN_circuit = cirq.Circuit()\\n step_size = [2**i for i in range(np.log2(pixels).astype(np.int32))]\\n for step in step_size:\\n for target in range(0, pixels, 2*step):\\n QCNN_circuit.append(self._QConv(step, target, cirq_qubits))\\n # merge the circuits\\n full_circuit = cirq.Circuit()\\n full_circuit.append(input_circuit)\\n full_circuit.append(QCNN_circuit)\\n self.circuit = full_circuit # save circuit to the QCNN layer obj.\\n self.params = input_params + self.learning_params\\n self.op = cirq.Z(cirq_qubits[0])\",\n \"def build_graph(self, name):\\n with tf.variable_scope(name, reuse=tf.AUTO_REUSE):\\n # change shape of input for when adding score\\n self.input_positions = tf.placeholder(tf.float32, shape=(None, 1, 2,6), name='inputs')\\n self.target_q = tf.placeholder(shape=[None], dtype=tf.float32, name='target')\\n net = self.input_positions\\n\\n net = tf.layers.conv2d(inputs=net, filters=128, kernel_size=6,\\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\\n data_format=\\\"channels_last\\\", padding='SAME', activation=tf.nn.relu)\\n net = tf.layers.conv2d(inputs=net, filters=128, kernel_size=6,\\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\\n data_format=\\\"channels_last\\\", padding='SAME', activation=tf.nn.relu)\\n net = tf.layers.conv2d(inputs=net, filters=64, kernel_size=6,\\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\\n data_format=\\\"channels_last\\\", padding='SAME', activation=tf.nn.relu)\\n\\n net = tf.layers.flatten(net)\\n\\n net = self.add_dense_layer(net, 12, tf.nn.relu)\\n\\n self.value = self.add_dense_layer(net, 1, name='state_q_value')\\n self.advantage = self.add_dense_layer(net, 12, name='action_advantage')\\n\\n self.q_values = tf.add(self.value, tf.subtract(self.advantage,\\n tf.reduce_mean(self.advantage, axis=1, keepdims=True)),\\n name=\\\"action_q_values\\\")\\n\\n self.probabilities = tf.nn.softmax(self.q_values, name='probabilities')\\n\\n self.actions = tf.placeholder(shape=[None], dtype=tf.int32, name='actions')\\n self.actions_onehot = tf.one_hot(self.actions, 12, dtype=tf.float32)\\n self.q = tf.reduce_sum(tf.multiply(self.q_values, self.actions_onehot), axis=1, name=\\\"selected_action_q\\\")\\n\\n tf.summary.histogram(\\\"Action_Q_values\\\", self.q)\\n\\n self.td_error = tf.square(self.target_q - self.q)\\n self.loss = tf.reduce_mean(self.td_error, name=\\\"q_loss\\\")\\n\\n tf.summary.scalar(\\\"Q_Loss\\\", self.loss)\\n self.reg_losses = tf.identity(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, scope=name),\\n name=\\\"reg_losses\\\")\\n\\n reg_loss = self.beta * tf.reduce_mean(self.reg_losses)\\n tf.summary.scalar(\\\"Regularization_loss\\\", reg_loss)\\n\\n self.merge = tf.summary.merge_all()\\n\\n self.total_loss = tf.add(self.loss, reg_loss, name=\\\"total_loss\\\")\\n self.train_step = tf.train.GradientDescentOptimizer(learning_rate=self.learningRate). \\\\\\n minimize(self.total_loss, name='train')\",\n \"def quantify(self, instances):\\n ...\",\n \"def append_available_node_categories(self):\\n available_node_types = self.graph.creation_field.available_items\\n for types in self.configuration.maya.available_node_categories:\\n node_types = pmc.listNodeTypes(types)\\n for node_type in node_types:\\n if not node_type in available_node_types:\\n available_node_types.append(node_type)\\n\\n self.graph.creation_field.available_items = available_node_types\",\n \"def __init__(self, data=None, cliques=None, taxons=None, namesMap=None, **attr):\\n \\n if cliques is not None:\\n if namesMap:\\n nmap = namesMap.getMap()\\n cliques = [ [ nmap[n] for n in nset ] for nset in cliques ]\\n \\n # prevent self-loops\\n cliques = [ list(set(nset)) for nset in cliques ]\\n \\n # attributes dicts\\n hyperb_weight = lambda ts: 1/(ts-1) \\n e_attr_hyperbWeight=dict()\\n e_attr_taxon=dict()\\n e_attr_count=dict()\\n \\n # build edges from records\\n if taxons is None: cliques_taxons = map( lambda c: (c,None), cliques)\\n else: cliques_taxons = zip(cliques,taxons)\\n for clique,taxon in cliques_taxons:\\n teamsize=len(clique)\\n edgesFromClique = itertools.combinations(clique,2)\\n for e in edgesFromClique:\\n e = tuple(sorted(e))\\n e_attr_count[e] = e_attr_count.get(e,0)+1\\n e_attr_taxon[e] = e_attr_taxon.get(e,[])+[taxon] if taxons is not None else None\\n e_attr_hyperbWeight[e] = e_attr_hyperbWeight.get(e,0)+hyperb_weight(teamsize)\\n \\n edges = e_attr_count.keys()\\n data = list(edges)\\n \\n super().__init__(incoming_graph_data=data,**attr)\\n \\n # insert nodes and set count attribute\\n nodes_counts = Counter( col for clique in cliques for col in clique )\\n nodes = nodes_counts.keys()\\n \\n self.add_nodes_from(nodes)\\n networkx.set_node_attributes(self,values=nodes_counts,name='count')\\n \\n # set edges attributes\\n networkx.set_edge_attributes(self,e_attr_count,'count')\\n networkx.set_edge_attributes(self,e_attr_taxon,'taxons')\\n networkx.set_edge_attributes(self,e_attr_hyperbWeight,'weight_hyperbolic')\",\n \"def build_graph(self):\\n # Print\\n if self.verbose:\\n print('Building Yolo Graph....')\\n # Reset default graph\\n tf.reset_default_graph()\\n # Input placeholder\\n self.x = tf.placeholder('float32', [None, 448, 448, 3])\\n # conv1, pool1\\n self.conv1 = self.conv_layer(1, self.x, 64, 7, 2)\\n self.pool1 = self.maxpool_layer(2, self.conv1, 2, 2)\\n # size reduced to 64x112x112\\n # conv2, pool2\\n self.conv2 = self.conv_layer(3, self.pool1, 192, 3, 1)\\n self.pool2 = self.maxpool_layer(4, self.conv2, 2, 2)\\n # size reduced to 192x56x56\\n # conv3, conv4, conv5, conv6, pool3\\n self.conv3 = self.conv_layer(5, self.pool2, 128, 1, 1)\\n self.conv4 = self.conv_layer(6, self.conv3, 256, 3, 1)\\n self.conv5 = self.conv_layer(7, self.conv4, 256, 1, 1)\\n self.conv6 = self.conv_layer(8, self.conv5, 512, 3, 1)\\n self.pool3 = self.maxpool_layer(9, self.conv6, 2, 2)\\n # size reduced to 512x28x28\\n # conv7 - conv16, pool4\\n self.conv7 = self.conv_layer(10, self.pool3, 256, 1, 1)\\n self.conv8 = self.conv_layer(11, self.conv7, 512, 3, 1)\\n self.conv9 = self.conv_layer(12, self.conv8, 256, 1, 1)\\n self.conv10 = self.conv_layer(13, self.conv9, 512, 3, 1)\\n self.conv11 = self.conv_layer(14, self.conv10, 256, 1, 1)\\n self.conv12 = self.conv_layer(15, self.conv11, 512, 3, 1)\\n self.conv13 = self.conv_layer(16, self.conv12, 256, 1, 1)\\n self.conv14 = self.conv_layer(17, self.conv13, 512, 3, 1)\\n self.conv15 = self.conv_layer(18, self.conv14, 512, 1, 1)\\n self.conv16 = self.conv_layer(19, self.conv15, 1024, 3, 1)\\n self.pool4 = self.maxpool_layer(20, self.conv16, 2, 2)\\n # size reduced to 1024x14x14\\n # conv17 - conv24\\n self.conv17 = self.conv_layer(21, self.pool4, 512, 1, 1)\\n self.conv18 = self.conv_layer(22, self.conv17, 1024, 3, 1)\\n self.conv19 = self.conv_layer(23, self.conv18, 512, 1, 1)\\n self.conv20 = self.conv_layer(24, self.conv19, 1024, 3, 1)\\n self.conv21 = self.conv_layer(25, self.conv20, 1024, 3, 1)\\n self.conv22 = self.conv_layer(26, self.conv21, 1024, 3, 2)\\n self.conv23 = self.conv_layer(27, self.conv22, 1024, 3, 1)\\n self.conv24 = self.conv_layer(28, self.conv23, 1024, 3, 1)\\n # size reduced to 1024x7x7\\n # fc1, fc2, fc3\\n self.fc1 = self.fc_layer(29, self.conv24, 512,\\n flatten=True, linear=False)\\n self.fc2 = self.fc_layer(\\n 30, self.fc1, 4096, flatten=False, linear=False)\\n self.fc3 = self.fc_layer(\\n 31, self.fc2, 1470, flatten=False, linear=True)\\n # Run session\\n self.sess = tf.Session()\\n self.sess.run(tf.global_variables_initializer())\\n self.saver = tf.train.Saver()\\n self.saver.restore(self.sess, self.weightFile)\\n # Print\\n print('Graph built.')\",\n \"def index_rtypes(self):\\n metric = self.index_metric\\n out = {}\\n for fnode in self.nodes.values():\\n # only consider outgoing relationships because looping over\\n # all object anyways, so will cover everything\\n\\n for (rtype, dest) in fnode.outgoing_relations:\\n dnode = self.nodes[dest]\\n\\n # merge outgoing and attributes - distinction should not change\\n # how vectors are formed\\n a1 = fnode.rtypes | fnode.atypes\\n b1 = dnode.rtypes | dnode.atypes\\n c1 = a1 - b1\\n d1 = b1 - a1\\n e1 = b1 & a1\\n f1 = b1 ^ a1\\n g1 = b1 | a1\\n\\n # merge outgoing and attributes - distinction should not change\\n # how vectors are formed\\n #a2 = {b for a,b in fnode.outgoing_relations} | {b for a,b in fnode.attributes}\\n #b2 = {b for a,b in dnode.outgoing_relations} | {b for a,b in dnode.attributes}\\n #c2 = a2 - b2\\n #d2 = b2 - a2\\n #e2 = b2 & a2\\n #f2 = b2 ^ a2\\n #g2 = b2 | a2\\n\\n rval = out.setdefault(rtype, NULL_VEC())\\n\\n \\\"\\\"\\\"\\n TODO: add similarity measure between node and prototype nodes\\n\\n Idea is to get a ground-truth value for the rtype by measuring\\n how src --<rtype>--> dest compares to prototype transformations\\n\\n \\n \\n \\\"\\\"\\\"\\n\\n #types only\\n score = np.array([metric(a1, b1),\\n metric(a1, c1),#1\\n metric(a1, e1),#2\\n metric(a1, f1),#3\\n metric(a1, g1),#4\\n metric(b1, d1),#1\\n metric(b1, e1),#2\\n metric(b1, f1),#3\\n metric(b1, g1),#4\\n metric(c1, d1),\\n metric(c1, f1),#5\\n metric(d1, f1),#5\\n metric(f1, g1),\\n ],dtype=np.float)\\n\\n \\n #types and objects\\n #score = np.array([metric(a1, b1),\\n # metric(a1, c1),\\n # metric(a1, e1),\\n # metric(a1, f1),\\n # metric(a1, g1),\\n # metric(b1, d1),\\n # metric(b1, e1),\\n # metric(b1, f1),\\n # metric(b1, g1),\\n # metric(c1, d1),\\n # metric(c1, f1),\\n # metric(c1, c2),\\n # metric(c1, e2),\\n # metric(d1, f1),\\n # metric(d1, d2),\\n # metric(d1, e2),\\n # metric(f1, g1),\\n # metric(a2, b2),\\n # metric(a2, c2),\\n # metric(a2, e2),\\n # metric(a2, f2),\\n # metric(a2, g2),\\n # metric(b2, d2),\\n # metric(b2, e2),\\n # metric(b2, f2),\\n # metric(b2, g2),\\n # metric(c2, f2),\\n # metric(d2, f2),\\n # metric(f2, g2)],dtype=np.float)\\n\\n out[rtype] = rval + score\\n\\n #avg = np.mean(list(out.values()),axis=0)\\n\\n #maxm = np.max(list(out.values()),axis=0)\\n\\n\\n \\n #with open(\\\"rrw.pkl\\\",\\\"wb+\\\") as f:\\n # pickle.dump(out, f, -1)\\n\\n #normalize everything\\n for r,v in out.items():\\n #out[r] = v / max(v)\\n out[r] = v / sqrt(v.dot(v))\\n #out[r] = softmax(v/maxm)\\n #out[r] = softmax(v/max(v))\\n #out[r] = softmax((v-avg)/maxm)\\n\\n #for debugging purposes\\n #np.save(\\\"utils/vectest.npy\\\",np.array(list(out.values())))\\n \\n\\n '''\\n rcount = self.usage_counts\\n vs1 = {}\\n for rtype, vec in out.items():\\n vs1[rtype] = softmax(vec/rcount[rtype])\\n\\n data = np.array(list(vs1.values()))\\n d2 = data - PCA(data, 1)#eliminate projection onto first principal component\\n\\n for i,v in enumerate(vs1):#iteration order is preserved\\n #rescale output\\n out[v] = softmax(d2[i]/rcount[v])\\n '''\\n return out\",\n \"def input_nodes(self):\\n pass\",\n \"def output_quantizers(self):\\n return self._output_quantizers\",\n \"def build_tf_graph(self):\\n raise NotImplementedError\",\n \"def _fill_quantizer_maps_for_outputs(self, activations_quantizer_map: Dict[str, StaticGridPerTensorQuantizer],\\n io_tensor_map: List[OpToIOTensors]):\\n for layer in range(self.module_to_quantize.num_layers):\\n outputs = io_tensor_map[layer].outputs\\n for index, quantizer_name in enumerate(onnx_outputs_to_quantizers):\\n if quantizer_name is None:\\n continue\\n quantizer_name = quantizer_name.format(layer)\\n if quantizer_name in self._output_quantizers:\\n quantizer = self._output_quantizers[quantizer_name]\\n elif quantizer_name in self._grouped_quantizers:\\n quantizer = self._grouped_quantizers[quantizer_name]\\n else:\\n # Case when rnn and gru does not have c_l{} as an output\\n continue\\n if quantizer.enabled:\\n activations_quantizer_map[outputs[index]] = quantizer\",\n \"def construct_and_initialize_trainable_quantizers(self, quant_scheme):\\n # Copy user settable attributes for outputs\\n\\n def _create_trainable_quantizer(bw, name, quantizer):\\n \\\"\\\"\\\" create trainable quantizer from static grid quantizer. \\\"\\\"\\\"\\n # Initialize trainable parameters to None\\n self.register_parameter(f'{name}_encoding_min', None)\\n self.register_parameter(f'{name}_encoding_max', None)\\n # Pass name of tensor quantizer and reference of Wrapper to tensor quantizer\\n # Input quantizer\\n new_quantizer = tensor_quantizer_factory(bw, self._round_mode,\\n quant_scheme,\\n self._is_symmetric,\\n enabled_by_default=True,\\n data_type=self._data_type)\\n new_quantizer.name = name\\n new_quantizer.wrapper_ref = self\\n new_quantizer.device = self.device\\n initialize_learned_grid_quantizer_attributes(new_quantizer, quantizer)\\n return new_quantizer\\n\\n new_grouped_quantizers = {name: _create_trainable_quantizer(self._activation_bw, name, quantizer)\\n for name, quantizer in self._grouped_quantizers.items()}\\n\\n def create_trainable_quantizer(bw, name, quantizer):\\n \\\"\\\"\\\" create trainable quantizer if not part of a group else reuse the group quantizer. \\\"\\\"\\\"\\n if quantizer in self._grouped_quantizers.values():\\n group_names = [n for n, q in self._grouped_quantizers.items() if q == quantizer]\\n assert len(group_names) == 1\\n # creating a param min/max references to the shared group min/max parameters.\\n setattr(self, f'{name}_encoding_min', getattr(self, f'{group_names[0]}_encoding_min'))\\n setattr(self, f'{name}_encoding_max', getattr(self, f'{group_names[0]}_encoding_max'))\\n return new_grouped_quantizers[group_names[0]]\\n\\n return _create_trainable_quantizer(bw, name, quantizer)\\n\\n\\n self._input_quantizers = {name: create_trainable_quantizer(self._activation_bw, name, quantizer)\\n for name, quantizer in self.input_quantizers.items()}\\n self._output_quantizers = {name: create_trainable_quantizer(self._activation_bw, name, quantizer)\\n for name, quantizer in self.output_quantizers.items()}\\n self._param_quantizers = {name: create_trainable_quantizer(self._weight_bw, name, quantizer)\\n for name, quantizer in self._param_quantizers.items()}\\n\\n self._grouped_quantizers = new_grouped_quantizers\\n self._mode = QcQuantizeOpMode.LEARN_ENCODINGS\",\n \"def get_nodes_context(self, node_type_map):\\n\\n # first let's get the number of nodes of subgraphs rooted at each node, we make use of the special vertex indexing our representation has\\n # by traversing in a decreasing order of vertex label, we can compute the number of leaves under each node in one pass\\n # this is helpful if we want to compute a special kind of lis\\n\\n # num_nodes = {} # table of number of nodes of subgraphs rooted at the given node\\n # n = self.graph.num_vertices()\\n # for v_idx in reversed(range(n)):\\n # v = self.graph.vertex(v_idx)\\n # if v.out_degree() == 0: # leaf\\n # num_nodes[v_idx] = 1\\n # else:\\n # print(v)\\n # num_nodes[v_idx] = 1\\n # for u in v.out_neighbors():\\n # num_nodes[v_idx] += num_nodes[int(u)]\\n\\n # print(\\\"ratios:\\\")\\n # for v in self.graph.vertices():\\n # if v == 0: continue\\n # print(\\\"{}:{}\\\".format(v, num_nodes[v] / (num_nodes[next(v.in_neighbors())] - 1)))\\n\\n # dump contexts in the form of:\\n # [num_children, parent_type, child_1type, child_2type, ..., l_parent, l_child1, l_child2 ...]\\n # where l_s are set to 1 for now\\n get_type_idx = lambda _: node_type_map[self.graph.vp['type'][_]]\\n contexts = []\\n for v in self.graph.vertices():\\n n = v.out_degree() # number of children\\n if n != 0: # not a leaf\\n contexts.append([n, get_type_idx(v)])\\n for u in v.out_neighbors():\\n contexts[-1].append(get_type_idx(u))\\n contexts[-1].extend([1] * (n + 1))\\n # print(contexts)\\n return contexts\",\n \"def _build(self):\\n with tf.variable_scope (self.name + '_architecutre') as scope:\\n images_square = unflatten_layer ( self.images )\\n visualize_images(images_square)\\n\\n # Conv Layer 1\\n conv1_out, params = conv_2d_layer ( input = images_square,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'enc_conv_1',\\n visualize = True )\\n process_params(params, name = self.name)\\n e1_params = params\\n pool1_out = max_pool_2d_layer ( input = conv1_out, name = 'enc_pool_1')\\n # lrn1_out = local_response_normalization_layer (pool1_out, name = 'lrn_1' )\\n\\n # Conv Layer 2\\n conv2_out, params = conv_2d_layer ( input = pool1_out,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'enc_conv_2' )\\n process_params(params, name = self.name)\\n e2_params = params\\n pool2_out = max_pool_2d_layer ( input = conv2_out, name = 'enc_pool_2')\\n # lrn2_out = local_response_normalization_layer (pool2_out, name = 'lrn_2' )\\n\\n flattened = flatten_layer(pool2_out)\\n\\n # Dropout Layer 1 \\n flattened_dropout = dropout_layer ( input = flattened,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_1') \\n\\n # Dot Product Layer 1\\n fc1_out, params = dot_product_layer ( input = flattened_dropout,\\n neurons = HIDDEN_1,\\n name = 'enc_dot_1')\\n process_params(params, name = self.name)\\n e3_params = params \\n\\n # Dropout Layer 2 \\n fc1_out_dropout = dropout_layer ( input = fc1_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_2')\\n # Dot Product Layer 2\\n fc2_out, params = dot_product_layer ( input = fc1_out_dropout, \\n neurons = HIDDEN_2,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n e4_params = params \\n\\n # Dropout Layer 3 \\n fc2_out_dropout = dropout_layer ( input = fc2_out,\\n prob = self.dropout_prob,\\n name = 'enc_dropout_3')\\n \\n # Dot Product Layer 2\\n self.codeword, params = dot_product_layer ( input = fc2_out_dropout, \\n neurons = CODEWORD_LENGTH,\\n activation = CODE_ACTIVATION,\\n name = 'enc_dot_2')\\n process_params(params, name = self.name)\\n process_codeword_normalization_regularizer(self.codeword, \\n coeff = AUTOENCODER_CODEWORD_COEFF,\\n name = self.name)\\n e5_params = params \\n # tf.summary.histogram('codewords', self.codeword)\\n # self.hash = threshold_layer ( input = self.codeword,\\n # name = 'hash')\\n # process_hash_regularizer(self.codeword, coeff = AUTOENCODER_HASH_COEFF,\\n # name = self.name)\\n\\n # Decoder ... \\n decoder_1_out, params = dot_product_layer ( input = self.codeword, \\n neurons = HIDDEN_2,\\n params = [tf.transpose(e5_params[0]), None],\\n name = 'decoder_dot_1')\\n d1_params = params\\n process_params([params[1]], name = self.name)\\n \\n dec_1_out_dropout = dropout_layer ( input = decoder_1_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_1')\\n\\n decoder_2_out, params = dot_product_layer ( input = dec_1_out_dropout, \\n neurons = HIDDEN_1,\\n params = [tf.transpose(e4_params[0]), None],\\n name = 'decoder_dot_2')\\n d2_params = params\\n process_params([params[1]], name = self.name)\\n \\n # dropout 2\\n dec_2_out_dropout = dropout_layer ( input = decoder_2_out,\\n prob = self.dropout_prob,\\n name = 'dec_dropout_2')\\n\\n decoder_3_out, params = dot_product_layer ( input = dec_2_out_dropout, \\n neurons = 1250,\\n params = [tf.transpose(e3_params[0]), None],\\n name = 'decoder_dot_3')\\n d3_params = params\\n process_params([params[1]], name = self.name)\\n\\n # DeConv Layer 1\\n # The output shapes need to be changed according to architecture.\\n\\n dec_3_square = unflatten_layer ( decoder_3_out, channels = CONV_2_N )\\n upsample_1 = upsampling_layer (dec_3_square, size = (10,10), name = 'dec_upsampling_1')\\n\\n deconv1_out, params = deconv_2d_layer ( input = upsample_1,\\n neurons = CONV_1_N,\\n filter_size = CONV_2_FILT,\\n output_shape = (12,12),\\n # n_outs = MINI_BATCH_SIZE,\\n stride = (1,1,1,1), \\n params = [e2_params[0], None], \\n name = 'dec_deconv_1' )\\n\\n process_params([params[1]], name = self.name)\\n d4_params = params\\n\\n # DeConv Layer 2\\n upsample_2 = upsampling_layer (deconv1_out, size = (24,24), name = 'dec_upsampling_2')\\n decoded_images_square, params = deconv_2d_layer ( input = upsample_2,\\n neurons = 1,\\n filter_size = CONV_1_FILT,\\n stride = (1,1,1,1),\\n output_shape = (28,28),\\n # n_outs = MINI_BATCH_SIZE, \\n params = [e1_params[0], None], \\n activation = 'tanh', \\n name = 'dec_deconv_2' )\\n \\n process_params([params[1]], name = self.name)\\n d5_params = params \\n \\n self.decoded = flatten_layer (decoded_images_square, in_shp = [-1, 28, 28, 1])\\n visualize_images(decoded_images_square, name = 'decoded')\\n # This is because transpose don't initialize.\\n self.params = [ [e5_params[0], d1_params[1] ],\\n [e4_params[0], d2_params[1] ],\\n [e3_params[0], d3_params[1] ],\\n [e2_params[0], d4_params[1] ],\\n [e1_params[0], d5_params[1] ] ]\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + '_decoder_error') as scope:\\n reconstruction_error = rmse(self.images, self.decoded) \\n tf.add_to_collection( self.name + '_objectives', reconstruction_error ) \\n tf.summary.scalar('reconstruction_error', reconstruction_error)\\n\\n self._cook_optimizer( \\n lr = AUTOENCODER_LR, \\n optimizer = AUTOENCODER_OPTIMIZER,\\n l1_coeff = AUTOENCODER_L1_COEFF,\\n l2_coeff = AUTOENCODER_WEIGHT_DECAY_COEFF)\",\n \"def connected_component_nodes_with_size(self, size, showRending=False, printResults=False):\\n\\n graphsOfSize = self.connected_components_with_size(size)\\n if showRending:\\n ans = [{node:graph.rendering_of_graph_node(node) for node in super(SynonymNetwork, graph).nodes()} for graph in graphsOfSize]\\n else:\\n ans = [super(SynonymNetwork, graph).nodes() for graph in graphsOfSize]\\n\\n if printResults:\\n for x in ans:\\n if showRending:\\n for k,v in x.iteritems(): print k + ' (' + v + ')'\\n print\\n else:\\n print x\\n else:\\n return ans\",\n \"def _make_circuit_instructions(n_qubits, depth, type_circuit):\\n\\n if type_circuit in [0, 1, 2]:\\n\\n # if type_circuit == 1:\\n # if depth > 8:\\n # raise ValueError(\\n # \\\"For type-1 circuits, only at most depth=8 allowed!\\\"\\n # )\\n\\n # define rotations for circuit in each layer, 0: identity, 1:X, 2:Y 3:Z\\n ini_pauli = np.zeros([depth, n_qubits], dtype=int)\\n\\n # set first and second layer, rest comes later\\n ini_pauli[0, :] = 2 # y rotation\\n if depth > 1:\\n ini_pauli[1, :] = 3 # z rotation\\n\\n # construct natural parameterized circuit\\n # gives which type of entangling gates at each layer -- first entry is\\n # first qubit index, second is second qubit index, third entry is type\\n # of entangling gate\\n entangling_gate_index_list = [[] for i in range(depth)]\\n orderList = []\\n for i in range(n_qubits//2):\\n if i % 2 == 0:\\n orderList.append(i//2)\\n else:\\n orderList.append((n_qubits-i)//2)\\n\\n if n_qubits > 1:\\n shiftList = [orderList[0]]\\n else:\\n shiftList = []\\n for i in range(1, n_qubits//2):\\n shiftList.append(orderList[i])\\n shiftList += shiftList[:-1]\\n\\n # this list gives which entangling gates are applied in which layer\\n if type_circuit == 0:\\n # deep natural PQC, includes non-nearest neighbor gates\\n for j in range(min(len(shiftList), int(np.ceil(depth/2))-1)):\\n entangling_gate_index_list[1+2*j] = [\\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\\n for i in range(n_qubits//2)\\n ]\\n elif type_circuit == 1:\\n # only do 2 entangling layers at max, and only do gates with\\n # nearest neighbor and no ring\\n for j in range(min(len(shiftList), 3)):\\n if j == 0:\\n entangling_gate_index_list[1+2*j] = [\\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\\n for i in range(n_qubits//2)\\n ]\\n elif (j == 1 or j == 2):\\n # exclude ring gate and gate 0,1 on third entangling layer\\n entangling_gate_index_list[1+2*j] = [\\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\\n for i in range(1, n_qubits//2)\\n ]\\n\\n elif type_circuit == 2:\\n # only do 3 regular entangling layers in a ring topology, then two\\n # more phase gates with next-nearst neighbor, which requires one\\n # swap. This adds 4 more parameters\\n for j in range(min(len(shiftList), 3)):\\n entangling_gate_index_list[1+2*j] = [\\n [2*i, (2*i+1+2*shiftList[j]) % n_qubits, 0]\\n for i in range(n_qubits//2)\\n ]\\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\\n # entangling_gate_index_list[1+2*3]=[[0,n_qubits-1,1],[0,1,0],[n_qubits-1,n_qubits-2,0]]\\n entangling_gate_index_list[1+2*3] = [\\n [n_qubits-1, 1, 0],\\n [0, n_qubits-2, 0]\\n ]\\n\\n for i in range(len(entangling_gate_index_list)-1):\\n if len(entangling_gate_index_list[i]) > 0:\\n for j in range(len(entangling_gate_index_list[i])):\\n qubit_index = entangling_gate_index_list[i][j][0]\\n ini_pauli[i+1, qubit_index] = 2\\n if i+2 < depth:\\n ini_pauli[i+2, qubit_index] = 3\\n\\n elif type_circuit == 3:\\n\\n ini_pauli = np.ones([depth, n_qubits], dtype=int)*2\\n\\n for i in range(1, depth, 2):\\n ini_pauli[i, :] = 3\\n\\n if n_qubits % 2 == 0:\\n # even qubits ALT circuit needs to get rid of boundary rotations at\\n # even entangling layers\\n for i in range(4, depth, 4):\\n ini_pauli[i, 0] = 0\\n ini_pauli[i, -1] = 0\\n if i+1 < depth:\\n ini_pauli[i+1, 0] = 0\\n ini_pauli[i+1, -1] = 0\\n else:\\n # for odd qubits, get rid of boundary either on top or bottom qubit\\n for i in range(2, depth, 4):\\n ini_pauli[i, -1] = 0\\n if i+1 < depth:\\n ini_pauli[i+1, -1] = 0\\n for i in range(4, depth, 4):\\n ini_pauli[i, 0] = 0\\n if i+1 < depth:\\n ini_pauli[i+1, 0] = 0\\n\\n # CNOT entangling gates\\n entangling_gate_index_list = [[] for i in range(depth)]\\n counter = 0\\n # third index indicates type of entangling gate\\n for k in range(1, depth-1, 2):\\n\\n # place entangler every second layer, do not place any at last\\n if counter % 2 == 0:\\n # even layer\\n entangling_gate_index_list[k] = [\\n [2*j, 2*j+1, 1] for j in range(n_qubits//2)\\n ]\\n else:\\n # odd layer\\n entangling_gate_index_list[k] = [\\n [2*j+1, 2*j+2, 1] for j in range((n_qubits-1)//2)\\n ]\\n counter += 1\\n\\n else:\\n raise ValueError('type_circuit='+f'{type_circuit}'+' not recognised.')\\n\\n return ini_pauli, entangling_gate_index_list\",\n \"def create(self):\\n \\n \\\"\\\"\\\" A solo prepressing reduction network in the head \\\"\\\"\\\"\\n print(\\\"pre_reduction\\\")\\n with tf.name_scope('pre_reduction'):\\n conv1 = NW.conv(self.X, 7, 7, 64, 2, 2, name='conv1')\\n pool1 = NW.max_pool(conv1, 3, 3, 2, 2, name='pool1')\\n norm1 = NW.lrn(pool1, 2, 2e-05, 0.75, name='norm1')\\n reduction2 = NW.conv(norm1, 1, 1, 64, 1, 1, name='reduction2')\\n conv2 = NW.conv(reduction2, 3, 3, 192, 1, 1,name='conv2')\\n norm2 = NW.lrn(conv2, 2, 2e-05, 0.75, name='norm2')\\n pool2 = NW.max_pool(norm2, 3, 3, 2, 2, name='pool2')\\n \\n \\\"\\\"\\\" 1st inception layer group \\\"\\\"\\\"\\n print(\\\"icp1\\\")\\n with tf.name_scope('icp1'):\\n # branch 0\\n icp1_out0 = NW.conv(pool2, 1, 1, 64, 1, 1, name='icp1_out0')\\n # branch 1\\n icp1_reduction1 = NW.conv(pool2, 1, 1, 96, 1, 1, name='icp1_reduction1')\\n icp1_out1 = NW.conv(icp1_reduction1, 3, 3, 128, 1, 1, name='icp1_out1')\\n # branch 2\\n icp1_reduction2 = NW.conv(pool2, 1, 1, 16, 1, 1, name='icp1_reduction2')\\n icp1_out2 = NW.conv(icp1_reduction2, 5, 5, 32, 1, 1, name='icp1_out2')\\n # branch 3\\n icp1_pool = NW.max_pool(pool2, 3, 3, 1, 1, name='icp1_pool')\\n icp1_out3 = NW.conv(icp1_pool, 1, 1, 32, 1, 1, name='icp1_out3')\\n # concat\\n icp2_in = NW.concat([icp1_out0,\\n icp1_out1,\\n icp1_out2,\\n icp1_out3], 3, 'icp2_in')\\n\\n \\\"\\\"\\\" 2nd inception layer group \\\"\\\"\\\"\\n print(\\\"icp2\\\")\\n with tf.name_scope('icp2'):\\n # branch 0\\n icp2_out0 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_out0')\\n # branch 1\\n icp2_reduction1 = NW.conv(icp2_in, 1, 1, 128, 1, 1, name='icp2_reduction1')\\n icp2_out1 = NW.conv(icp2_reduction1, 3, 3, 192, 1, 1, name='icp2_out1')\\n # branch 2\\n icp2_reduction2 = NW.conv(icp2_in, 1, 1, 32, 1, 1, name='icp2_reduction2')\\n icp2_out2 = NW.conv(icp2_reduction2, 5, 5, 96, 1, 1, name='icp2_out2')\\n # branch 3\\n icp2_pool = NW.max_pool(icp2_in, 3, 3, 1, 1, name='icp2_pool')\\n icp2_out3 = NW.conv(icp2_pool, 1, 1, 64, 1, 1, name='icp2_out3')\\n # concat\\n icp2_out = NW.concat([icp2_out0,\\n icp2_out1,\\n icp2_out2,\\n icp2_out3], 3, 'icp2_out')\\n \\n \\\"\\\"\\\" 3rd inception layer group \\\"\\\"\\\"\\n print(\\\"icp3\\\")\\n with tf.name_scope('icp3'):\\n icp3_in = NW.max_pool(icp2_out, 3, 3, 2, 2, name='icp3_in')\\n # branch 0\\n icp3_out0 = NW.conv(icp3_in, 1, 1, 192, 1, 1, name='icp3_out0')\\n # branch 1\\n icp3_reduction1 = NW.conv(icp3_in, 1, 1, 96, 1, 1, name='icp3_reduction1')\\n icp3_out1 = NW.conv(icp3_reduction1, 3, 3, 208, 1, 1, name='icp3_out1')\\n # branch 2\\n icp3_reduction2 = NW.conv(icp3_in, 1, 1, 16, 1, 1, name='icp3_reduction2')\\n icp3_out2 = NW.conv(icp3_reduction2, 5, 5, 48, 1, 1, name='icp3_out2')\\n # branch 3\\n icp3_pool = NW.max_pool(icp3_in, 3, 3, 1, 1, name='icp3_pool')\\n icp3_out3 = NW.conv(icp3_pool, 1, 1, 64, 1, 1, name='icp3_out3')\\n # concat\\n icp3_out = NW.concat([icp3_out0,\\n icp3_out1,\\n icp3_out2,\\n icp3_out3], 3, 'icp3_out')\\n \\n \\\"\\\"\\\" 1st classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls1'):\\n cls1_pool = NW.avg_pool(icp3_out, 5, 5, 3, 3, padding='VALID', name='cls1_pool')\\n cls1_reduction_pose = NW.conv(cls1_pool, 1, 1, 128, 1, 1, name='cls1_reduction_pose')\\n cls1_fc1_pose = NW.fc(cls1_reduction_pose, 1024, name='cls1_fc1_pose')\\n cls1_fc_pose_xy = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_xy')\\n cls1_fc_pose_ab = NW.fc(cls1_fc1_pose, 2, relu=False, name='cls1_fc_pose_ab')\\n self.layers[\\\"cls1_fc_pose_xy\\\"] = cls1_fc_pose_xy\\n self.layers[\\\"cls1_fc_pose_ab\\\"] = cls1_fc_pose_ab\\n \\n \\\"\\\"\\\" 4st inception layer group \\\"\\\"\\\"\\n print(\\\"icp4\\\")\\n with tf.name_scope('icp4'):\\n # branch 0\\n icp4_out0 = NW.conv(icp3_out, 1, 1, 160, 1, 1, name='icp4_out0')\\n # branch 1\\n icp4_reduction1 = NW.conv(icp3_out, 1, 1, 112, 1, 1, name='icp4_reduction1')\\n icp4_out1 = NW.conv(icp4_reduction1, 3, 3, 224, 1, 1, name='icp4_out1')\\n # branch 2\\n icp4_reduction2 = NW.conv(icp3_out, 1, 1, 24, 1, 1, name='icp4_reduction2')\\n icp4_out2 = NW.conv(icp4_reduction2, 5, 5, 64, 1, 1, name='icp4_out2')\\n # branch 3\\n icp4_pool = NW.max_pool(icp3_out, 3, 3, 1, 1, name='icp4_pool')\\n icp4_out3 = NW.conv(icp4_pool, 1, 1, 64, 1, 1, name='icp4_out3')\\n # concat\\n icp4_out = NW.concat([icp4_out0,\\n icp4_out1,\\n icp4_out2,\\n icp4_out3],3, name='icp4_out')\\n\\n \\\"\\\"\\\" 5st inception layer group \\\"\\\"\\\"\\n print(\\\"icp5\\\")\\n with tf.name_scope('icp5'):\\n # branch 0\\n icp5_out0 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_out0')\\n # branch 1\\n icp5_reduction1 = NW.conv(icp4_out, 1, 1, 128, 1, 1, name='icp5_reduction1')\\n icp5_out1 = NW.conv(icp5_reduction1, 3, 3, 256, 1, 1, name='icp5_out1')\\n # branch 2\\n icp5_reduction2 = NW.conv(icp4_out,1, 1, 24, 1, 1, name='icp5_reduction2')\\n icp5_out2 = NW.conv(icp5_reduction2, 5, 5, 64, 1, 1, name='icp5_out2')\\n # branch 3\\n icp5_pool = NW.max_pool(icp4_out,3, 3, 1, 1, name='icp5_pool')\\n icp5_out3 = NW.conv(icp5_pool, 1, 1, 64, 1, 1, name='icp5_out3')\\n # concat\\n icp5_out = NW.concat([icp5_out0, \\n icp5_out1, \\n icp5_out2, \\n icp5_out3], 3, name='icp5_out')\\n \\n \\\"\\\"\\\" 6st inception layer group \\\"\\\"\\\"\\n print(\\\"icp6\\\")\\n with tf.name_scope('icp6'):\\n # branch 0\\n icp6_out0 = NW.conv(icp5_out, 1, 1, 112, 1, 1, name='icp6_out0')\\n # branch 1\\n icp6_reduction1 = NW.conv(icp5_out, 1, 1, 144, 1, 1, name='icp6_reduction1')\\n icp6_out1 = NW.conv(icp6_reduction1, 3, 3, 288, 1, 1, name='icp6_out1')\\n # branch 2\\n icp6_reduction2 = NW.conv(icp5_out, 1, 1, 32, 1, 1, name='icp6_reduction2')\\n icp6_out2 = NW.conv(icp6_reduction2, 5, 5, 64, 1, 1, name='icp6_out2')\\n # branch 3\\n icp6_pool = NW.max_pool(icp5_out,3, 3, 1, 1, name='icp6_pool')\\n icp6_out3 = NW.conv(icp6_pool, 1, 1, 64, 1, 1, name='icp6_out3')\\n # concat\\n icp6_out = NW.concat([icp6_out0,\\n icp6_out1,\\n icp6_out2,\\n icp6_out3], 3, name='icp6_out')\\n\\n \\\"\\\"\\\" 2nd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls2'):\\n cls2_pool = NW.avg_pool(icp6_out, 5, 5, 3, 3, padding='VALID', name='cls2_pool')\\n cls2_reduction_pose = NW.conv(cls2_pool, 1, 1, 128, 1, 1, name='cls2_reduction_pose')\\n cls2_fc1 = NW.fc(cls2_reduction_pose, 1024, name='cls2_fc1')\\n cls2_fc_pose_xy = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_xy')\\n cls2_fc_pose_ab = NW.fc(cls2_fc1, 2, relu=False, name='cls2_fc_pose_ab')\\n self.layers[\\\"cls2_fc_pose_xy\\\"] = cls2_fc_pose_xy\\n self.layers[\\\"cls2_fc_pose_ab\\\"] = cls2_fc_pose_ab\\n\\n \\\"\\\"\\\" 7st inception layer group \\\"\\\"\\\"\\n print(\\\"icp7\\\")\\n with tf.name_scope('icp7'):\\n # branch 0\\n icp7_out0 = NW.conv(icp6_out, 1, 1, 256, 1, 1, name='icp7_out0')\\n # branch 1\\n icp7_reduction1 = NW.conv(icp6_out, 1, 1, 160, 1, 1, name='icp7_reduction1')\\n icp7_out1 = NW.conv(icp7_reduction1, 3, 3, 320, 1, 1, name='icp7_out1')\\n # branch 2\\n icp7_reduction2 = NW.conv(icp6_out, 1, 1, 32, 1, 1, name='icp7_reduction2')\\n icp7_out2 = NW.conv(icp7_reduction2, 5, 5, 128, 1, 1, name='icp7_out2')\\n # branch 3\\n icp7_pool = NW.max_pool(icp6_out, 3, 3, 1, 1, name='icp7_pool')\\n icp7_out3 = NW.conv(icp7_pool, 1, 1, 128, 1, 1, name='icp7_out3')\\n # concat\\n icp7_out = NW.concat([icp7_out0,\\n icp7_out1,\\n icp7_out2,\\n icp7_out3], 3, name='icp7_out')\\n\\n \\\"\\\"\\\" 8st inception layer group \\\"\\\"\\\"\\n print(\\\"icp8\\\")\\n with tf.name_scope('icp8'):\\n icp8_in = NW.max_pool(icp7_out, 3, 3, 2, 2, name='icp8_in')\\n # branch 0\\n icp8_out0 = NW.conv(icp8_in, 1, 1, 256, 1, 1, name='icp8_out0')\\n # branch 1\\n icp8_reduction1 = NW.conv(icp8_in, 1, 1, 160, 1, 1, name='icp8_reduction1')\\n icp8_out1 = NW.conv(icp8_reduction1, 3, 3, 320, 1, 1, name='icp8_out1')\\n # branch 2\\n icp8_reduction2 = NW.conv(icp8_in, 1, 1, 32, 1, 1, name='icp8_reduction2')\\n icp8_out2 = NW.conv(icp8_reduction2, 5, 5, 128, 1, 1, name='icp8_out2')\\n # branch 3\\n icp8_pool = NW.max_pool(icp8_in, 3, 3, 1, 1, name='icp8_pool')\\n icp8_out3 = NW.conv(icp8_pool, 1, 1, 128, 1, 1, name='icp8_out3')\\n # concat\\n icp8_out = NW.concat([icp8_out0,\\n icp8_out1,\\n icp8_out2,\\n icp8_out3], 3, name='icp8_out')\\n \\n \\\"\\\"\\\" 9st inception layer group \\\"\\\"\\\"\\n print(\\\"icp9\\\")\\n with tf.name_scope('icp9'):\\n # branch 0\\n icp9_out0 = NW.conv(icp8_out, 1, 1, 384, 1, 1, name='icp9_out0')\\n # branch 1\\n icp9_reduction1 = NW.conv(icp8_out, 1, 1, 192, 1, 1, name='icp9_reduction1')\\n icp9_out1 = NW.conv(icp9_reduction1, 3, 3, 384, 1, 1, name='icp9_out1')\\n # branch 2\\n icp9_reduction2 = NW.conv(icp8_out, 1, 1, 48, 1, 1, name='icp9_reduction2')\\n icp9_out2 = NW.conv(icp9_reduction2, 5, 5, 128, 1, 1, name='icp9_out2')\\n # branch 3\\n icp9_pool = NW.max_pool(icp8_out, 3, 3, 1, 1, name='icp9_pool')\\n icp9_out3 = NW.conv(icp9_pool, 1, 1, 128, 1, 1, name='icp9_out3')\\n # concat\\n icp9_out = NW.concat([icp9_out0,\\n icp9_out1,\\n icp9_out2,\\n icp9_out3], 3, name='icp9_out')\\n\\n \\\"\\\"\\\" 3rd classify branch \\\"\\\"\\\"\\n with tf.name_scope('cls3'):\\n cls3_pool = NW.avg_pool(icp9_out, 7, 7, 1, 1, padding='VALID', name='cls3_pool')\\n cls3_fc1_pose = NW.fc(cls3_pool, 2048, name='cls3_fc1_pose')\\n cls3_fc_pose_xy = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_xy')\\n cls3_fc_pose_ab = NW.fc(cls3_fc1_pose, 2, relu=False, name='cls3_fc_pose_ab')\\n self.layers[\\\"cls3_fc_pose_xy\\\"] = cls3_fc_pose_xy\\n self.layers[\\\"cls3_fc_pose_ab\\\"] = cls3_fc_pose_ab\",\n \"def upstream_nodes_of_type(self, target_node_name, operation_type):\\n assert target_node_name in self.node_map\\n nodes = self.nodes_of_type(operation_type)\\n nodes = [node for node in nodes if has_path(self.G2, node, target_node_name)]\\n return set(nodes)\",\n \"def _create_param_quantizers(self, weight_bw: int, round_mode: libpymo.RoundingMode,\\n quant_scheme: QuantScheme, is_symmetric: bool,\\n data_type: QuantizationDataType):\\n tensor_grouped_quantizer_map = {}\\n for layer in range(self.num_layers):\\n for group_name, tensor_names in grouped_quantizer_map.items():\\n name = group_name.format(layer)\\n if name not in self._grouped_quantizers:\\n self._grouped_quantizers[name] = \\\\\\n tensor_quantizer_factory(weight_bw,\\n round_mode,\\n quant_scheme,\\n use_symmetric_encodings=is_symmetric,\\n enabled_by_default=False,\\n data_type=data_type)\\n tensor_names = [tensor_name.format(layer) for tensor_name in tensor_names]\\n for tensor_name in tensor_names:\\n assert tensor_name not in tensor_grouped_quantizer_map\\n tensor_grouped_quantizer_map[tensor_name] = \\\\\\n self._grouped_quantizers[name]\\n\\n for name, _ in self.module_to_quantize.named_parameters():\\n _logger.debug(\\\"Adding quantizer for parameter: %s\\\", name)\\n if name in tensor_grouped_quantizer_map:\\n self._param_quantizers[name] = tensor_grouped_quantizer_map[name]\\n self._grouped_param_quantizers.add(self._param_quantizers[name])\\n else:\\n self._param_quantizers[name] = tensor_quantizer_factory(\\n weight_bw,\\n round_mode,\\n quant_scheme,\\n use_symmetric_encodings=is_symmetric,\\n enabled_by_default=False,\\n data_type=data_type)\",\n \"def build_graph(self):\\n for node in self.nodes:\\n self.graph.add_node(node.id, node_obj=node)\\n edges = []\\n for i in range(0, len(self.nodes)):\\n for j in range(i+1, len(self.nodes)):\\n if (self.nodes[i].distance(self.nodes[j]) < self.radio_range):\\n edges.append((self.nodes[i].id, self.nodes[j].id,1))\\n self.graph.add_weighted_edges_from(edges)\",\n \"def _build_networks(self):\\n self.online_convnet = self._create_network(name='Online')\\n self.target_convnet = self._create_network(name='Target')\\n self._net_outputs = self.online_convnet(self.state_ph, training=True)\\n self._q_argmax = tf.argmax(self._net_outputs.q_values, axis=1)[0]\\n self._replay_net_outputs = self.online_convnet(self._replay.states,\\n training=True)\\n self._replay_next_target_net_outputs = self.target_convnet(\\n self._replay.next_states)\",\n \"def __init__(self, **kwargs):\\n FeatureDefinition.__init__(self)\\n\\n nbTypes = self._getTypeNumber(kwargs)\\n \\n print(\\\"BETTER FEATURES\\\")\\n \\n \\n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"xywh\\\", Pipeline([\\n ('selector', NodeTransformerXYWH_v2()),\\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"neighbors\\\", Pipeline([\\n ('selector', NodeTransformerNeighbors()),\\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"1hot\\\", Pipeline([\\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\\n ])\\n )\\n ])\\n grid_line_transformer = GridLine_NodeTransformer_v2()\\n \\n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \\n \\n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"1hot\\\", Pipeline([\\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\\n ])\\n )\\n , (\\\"boolean\\\", Pipeline([\\n ('boolean', EdgeBooleanFeatures_v2())\\n ])\\n )\\n , (\\\"numerical\\\", Pipeline([\\n ('selector', EdgeNumericalSelector()),\\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n ] )\\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\\n edge_BL_transformer,\\n edge_BL_transformer, # useless but required\\n edge_LL_transformer \\n ])\\n \\n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer\",\n \"def build_graph(self):\\n # place holders for inputs here \\n HIDDEN_LAYER = self.FLAGS.feature_layer_size\\n \\n self.x_i = tf.placeholder(dtype=tf.float32, shape = (None, self.INPUT_DIM), name=\\\"x_i\\\")\\n self.a_i = tf.placeholder(dtype=tf.float32, shape = (None, self.ACTION_DIM), name = \\\"a_i\\\")\\n self.q_opc = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \\\"q_opc\\\")\\n self.q_ret = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \\\"q_ret\\\" )\\n self.c = self.FLAGS.c # truncation threshold constant\\n \\n self.actor_net = PolicyNet(HIDDEN_LAYER, self.ACTION_DIM, name= self.name + \\\"_actor\\\", co_var = self.co_var)\\n self.critic_net = AdvantageValueNet(HIDDEN_LAYER , name= self.name + \\\"_critic\\\")\\n \\n self.policy_xi_stats, self.policy_xi_dist = self.actor_net(self.x_i)\\n \\n self.val_xi, self.adv_xi_ai = self.critic_net(self.x_i, self.a_i, self.policy_xi_dist)\\n \\n #sample a' now\\n self.a_i_ = tf.reshape(self.policy_xi_dist.sample(1), shape=[-1,self.ACTION_DIM])\\n self.a_i_ = tf.clip_by_value(self.a_i_, self.env.action_space.low[0], self.env.action_space.high[0]) #20190828 add clipping\\n \\n _, self.adv_xi_ai_ = self.critic_net(self.x_i, self.a_i_, self.policy_xi_dist) # val will be the same for \\n \\n _, self.average_policy_xi_dist = self.average_actor_net(self.x_i) # can this be done better ?\\n \\n self.prob_a_i = tf.reshape(self.policy_xi_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\\n self.prob_a_i_ = tf.reshape(self.policy_xi_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\\n \\n self.log_prob_a_i = tf.log(self.prob_a_i)\\n self.log_prob_a_i_ = tf.log(self.prob_a_i_)\\n \\n # for predicting 1-step a_i', p_i, p_i',\\n self.u_i = tf.placeholder(dtype=tf.float32, shape = (None, 2*self.ACTION_DIM))\\n \\n #self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i, \\n # scale_diag = tf.ones_like(self.u_i) * self.co_var)\\n self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i[:,0], scale_diag=self.u_i[:,1])\\n \\n self.u_i_prob_a_i = tf.reshape(self.u_i_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\\n self.u_i_prob_a_i_ = tf.reshape(self.u_i_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\\n \\n self.p_i = tf.divide(self.prob_a_i, self.u_i_prob_a_i)\\n self.p_i_ = tf.divide(self.prob_a_i_ , self.u_i_prob_a_i_)\\n \\n\\n # take care of NaNs here, for importance sampling weights (might be an extra step)\\n self.p_i = tf.where(tf.is_nan(self.p_i), tf.zeros_like(self.p_i), self.p_i)\\n self.p_i_ = tf.where(tf.is_nan(self.p_i_), tf.zeros_like(self.p_i_), self.p_i_)\\n\\n self.c_i = tf.minimum(1. , tf.pow(self.p_i, 1.0/self.ACTION_DIM))\\n \\n \\n # for verification about checking if params are getting synched\\n self.local_actor_vars = self.actor_net.local_params()\\n self.global_actor_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_actor')\\n \\n self.local_critic_vars = self.critic_net.local_params()\\n self.global_critic_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_critic')\\n \\n \\n # Sync ops from global\\n self.sync_local_actor_op = self.actor_net.update_local_params_op('global_actor') # global actor\\n self.sync_local_critic_op = self.critic_net.update_local_params_op('global_critic')\\n \\n # soft update the average network\\n self.soft_update_average_actor_op = self.average_actor_net.soft_update_from_target_params('global_actor',\\n self.FLAGS.tau)\\n \\n #Get gradients from local network using local losses\\n \\n g1 = tf.reshape(tf.gradients((self.log_prob_a_i * (self.q_opc - self.val_xi)),self.policy_xi_stats,\\n name=self.name+\\\"g1_grads\\\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n g2 = (self.adv_xi_ai_ - self.val_xi) * tf.reshape(tf.gradients((self.log_prob_a_i_), \\n self.policy_xi_stats, name=self.name+\\\"g2_grads\\\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n \\n \\n self.g = tf.minimum(self.c, self.p_i) * g1 + tf.nn.relu(1 - tf.divide(self.c , self.p_i_)) * g2\\n \\n \\n self.k = tf.reshape(tf.gradients(tf.contrib.distributions.kl_divergence(self.average_policy_xi_dist, \\n self.policy_xi_dist), self.policy_xi_stats, unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n \\n \\n \\n self.kg = tf.reduce_sum( tf.multiply(self.g, self.k), 1, keep_dims=True)\\n \\n #print \\\"kg\\\", self.kg\\n \\n self.k2 = tf.reduce_sum( tf.multiply(self.k, self.k), 1, keep_dims=True)\\n \\n self.reg_g = self.g - tf.maximum(tf.zeros_like(self.g), tf.divide((self.kg - self.FLAGS.delta), self.k2) ) * self.k\\n \\n # take gradients wrt to the local params\\n self.actor_grads = tf.gradients(self.policy_xi_stats, self.local_actor_vars, \\n grad_ys= -self.reg_g, name=\\\"actor_grads\\\", unconnected_gradients='zero')\\n \\n \\n #for ti,tj in zip(self.actor_grads, self.global_actor_vars):\\n # print ti, \\\"\\\\n\\\", tj , \\\"\\\\n\\\", \\\"===========\\\"\\n \\n # apply local gradients to the global network\\n self.actor_train_op = self.optimizer.apply_gradients(zip(self.actor_grads, self.global_actor_vars),\\n global_step=tf.train.get_global_step())\\n \\n \\n # critic loss function and updates\\n \\n # take gradient wrt to local variables\\n self.critic_loss_1 = ((self.q_ret - self.adv_xi_ai) ** 2.0) / 2.0\\n \\n # for predicting 1-step a_i', p_i, p_i',\\n self.v_target = tf.placeholder(dtype=tf.float32, shape = (None, 1))\\n \\n #self.v_trunc = tf.minimum(self.p_i, 1.0) * (self.q_ret - self.adv_xi_ai) + self.val_xi\\n self.critic_loss_2 = ((self.v_target - self.val_xi) ** 2.0) / 2.0\\n \\n self.critic_loss = self.critic_loss_1 + self.critic_loss_2\\n \\n #Apply local gradients to global network\\n \\n self.critic_grads = tf.gradients(self.critic_loss, self.local_critic_vars)\\n \\n self.critic_train_op = self.optimizer.apply_gradients(zip(self.critic_grads, self.global_critic_vars),\\n global_step=tf.train.get_global_step())\\n \\n # critic_summaries op\\n critic_grads_summary = []\\n print('-----------------------------------------------------------------')\\n print('Create critic_grads_summary histogram ')\\n for grad,var in zip(self.critic_grads, self.local_critic_vars):\\n print('{} - {}'.format(var.name, grad))\\n critic_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\\n critic_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\\n \\n self.critic_summary_op = tf.summary.merge([\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss_Q\\\", tf.reduce_mean(self.critic_loss_1)),\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss_V\\\", tf.reduce_mean(self.critic_loss_2)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss_Q\\\", tf.reduce_sum(self.critic_loss_1)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss_V\\\", tf.reduce_sum(self.critic_loss_2)),\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss\\\", tf.reduce_mean(self.critic_loss)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss\\\", tf.reduce_sum(self.critic_loss)),\\n tf.summary.histogram(self.name + \\\"_val_target\\\", self.v_target),\\n tf.summary.histogram(self.name + \\\"_val_pred\\\", self.val_xi),\\n tf.summary.histogram(self.name + \\\"_Q_pred\\\", self.adv_xi_ai),\\n tf.summary.histogram(self.name + \\\"_Q_ret\\\", self.q_ret),\\n tf.summary.histogram(self.name + \\\"_Q_opc\\\", self.q_opc),\\n ] + critic_grads_summary)\\n \\n \\n # actor summaries op\\n\\n actor_grads_summary = []\\n print('-----------------------------------------------------------------')\\n print('Create actor_grads_summary histogram ')\\n for grad,var in zip(self.actor_grads, self.local_actor_vars):\\n print('{} - {}'.format(var.name, grad))\\n actor_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\\n actor_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\\n \\n\\n self.actor_summary_op = tf.summary.merge([\\n tf.summary.scalar(self.name + \\\"_actor_mean_loss_reg_g\\\", tf.reduce_mean(self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_mean_loss_reg_g\\\", tf.reduce_mean(-self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_loss_reg_g\\\", tf.reduce_sum(self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_sum_reg_g\\\", tf.reduce_sum(-self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_g\\\", tf.reduce_sum(self.g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_sum_g\\\", tf.reduce_sum(-self.g)),\\n tf.summary.scalar(self.name + \\\"_actor_mean_kl\\\", tf.reduce_mean(self.k)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_kl\\\", tf.reduce_sum(self.k)),\\n tf.summary.histogram(self.name + \\\"_policy_stats\\\", self.policy_xi_stats),\\n ] + actor_grads_summary )\",\n \"def build_graph(self):\\n self.graph = tf.Graph()\\n temp_connections = self.connections\\n with self.graph.as_default():\\n operations = {}\\n\\n # create Variables for input vertices\\n for neuron_id in self.input_neurons:\\n self.inputs[neuron_id] = tf.get_variable(name=str(neuron_id), shape=(),\\n initializer=tf.zeros_initializer)\\n deletion = []\\n while len(temp_connections) > 0:\\n for neuron_id in deletion:\\n temp_connections.pop(neuron_id, None)\\n deletion = []\\n keys = list(temp_connections)\\n random.shuffle(keys)\\n # create input & output vertices\\n for neuron_id in temp_connections:\\n input_neuron_ids = temp_connections[neuron_id]\\n if self.check(input_neuron_ids, operations):\\n # weights\\n v_weights = tf.constant(self.weights[neuron_id])\\n # input vertices\\n v_inputs = []\\n\\n for input_neuron_id in input_neuron_ids:\\n if self.is_input_neuron(input_neuron_id):\\n vertex = self.inputs[input_neuron_id]\\n else:\\n vertex = operations[input_neuron_id]\\n\\n v_inputs.append(vertex)\\n\\n deletion.append(neuron_id)\\n\\n # multiply weights and inputs\\n mul = tf.multiply(v_inputs, v_weights, str(neuron_id))\\n # sum multiplied values\\n sum = tf.reduce_sum(mul, name='sum_' + str(neuron_id))\\n # apply activation function\\n if self.is_output_neuron(neuron_id):\\n activation = tf.sigmoid(sum, name=\\\"output\\\")\\n else:\\n activation = tf.nn.leaky_relu(sum, alpha=0.2, name=\\\"relu_\\\" + str(neuron_id))\\n\\n operations[neuron_id] = activation\\n if self.is_output_neuron(neuron_id):\\n self.output = activation\\n return self.graph, self.inputs, self.output\",\n \"def evaluate_dep_type_sets():\\n strategies = {\\n 'defensive': ['agent', 'advcl', 'parataxis'],\\n 'aggressive': ['agent', 'advcl', 'parataxis', 'dep', 'aux', 'ccomp', 'xcomp', 'dobj', 'pobj', 'nsubj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'preconj', 'advmod', 'neg', 'rcmod', 'tmod', 'poss', 'prepc'],\\n 'compromise_1': ['agent', 'advcl', 'parataxis', 'aux', 'xcomp', 'pobj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'neg', 'tmod', 'poss', 'prepc'],\\n 'compromise_2': ['agent', 'advcl', 'parataxis', 'aux', 'xcomp', 'pobj', 'nsubjpass', 'cc', 'abbrev', 'purpcl', 'predet', 'neg', 'tmod', 'poss', 'prepc', 'attr', 'csubj', 'csubjpass', 'number', 'possessive', 'punct', 'ref']\\n }\\n results = {'classification':{}, 'retrieval':{}}\\n\\n print '------ CLASSIFICATION EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/tasa/TASA900_dependencies'\\n texts, labels = data.read_files(descriptions_path)\\n print '> Creating representations..'\\n rep = {}\\n for strategy in strategies:\\n rep[strategy] = []\\n metric = graph.GraphMetrics.CLOSENESS\\n for i, text in enumerate(texts):\\n if i%10==0: print ' ',str(i)+'/'+str(len(texts))\\n for strategy in strategies:\\n g = graph_representation.construct_dependency_network(text, exclude=strategies[strategy])\\n d = graph_representation.graph_to_dict(g, metric)\\n rep[strategy].append(d)\\n g = None # just to make sure. I don't trust this damn garbage collector...\\n for strategy in strategies:\\n rep[strategy] = graph_representation.dicts_to_vectors(rep[strategy])\\n print '> Evaluating..'\\n for strategy in strategies:\\n score = evaluation.evaluate_classification(rep[strategy], labels)\\n print ' ', strategy, score\\n results['classification'][strategy] = score\\n\\n data.pickle_to_file(results, 'output/dependencies/types_set_eval_tmp')\\n\\n print '------ RETRIEVAL EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/air/problem_descriptions_dependencies'\\n description_texts, labels = data.read_files(descriptions_path)\\n solutions_path = '../data/air/solutions_preprocessed'\\n solution_texts, labels = data.read_files(solutions_path)\\n solution_vectors = freq_representation.text_to_vector(solution_texts, freq_representation.FrequencyMetrics.TF_IDF)\\n print '> Creating representations..'\\n rep = {}\\n for strategy in strategies:\\n rep[strategy] = []\\n metric = graph.GraphMetrics.EIGENVECTOR\\n for i, text in enumerate(description_texts):\\n if i%1==0: print ' ',str(i)+'/'+str(len(description_texts))\\n full_graph = graph_representation.construct_dependency_network(text)\\n for strategy in strategies:\\n g = graph_representation.construct_dependency_network(text, exclude=strategies[strategy])\\n d = graph_representation.graph_to_dict(g, metric)\\n rep[strategy].append(d)\\n g = None # just to make sure..\\n full_graph = None\\n #~ if i%100==0: data.pickle_to_file(rep, 'output/dependencies/types_eval_rep_'+str(i))\\n for strategy in strategies:\\n rep[strategy] = graph_representation.dicts_to_vectors(rep[strategy])\\n print '> Evaluating..'\\n for strategy in strategies:\\n score = evaluation.evaluate_retrieval(rep[strategy], solution_vectors)\\n print ' ', strategy, score\\n results['retrieval'][strategy] = score\\n\\n pp.pprint(results)\\n data.pickle_to_file(results, 'output/dependencies/types_set_eval')\\n\\n return results\",\n \"def _make_list_islot_otuples_from_nodelist(self):\\n raise NotImplementedError\",\n \"def build_graph(self):\\n\\t\\tself.n_hidden = 100\\n\\t\\tself.weights_hidden = tf.get_variable(\\\"weights_hidden\\\", [self.state_size, self.n_hidden], initializer = tf.random_normal_initializer())\\n\\t\\tself.bias_hidden = tf.get_variable(\\\"bias_hidden\\\", [self.n_hidden], initializer = tf.constant_initializer(0.1))\\n\\n\\t\\tself.weights_out = tf.get_variable(\\\"weights_out\\\", [self.n_hidden, self.action_size], initializer = tf.random_normal_initializer())\\n\\t\\tself.bias_out = tf.get_variable(\\\"bias_out\\\", [self.action_size], initializer = tf.constant_initializer(0.1))\",\n \"def _construct_graph(self):\\n raise NotImplementedError\",\n \"def outputs_for_module_type_operation(self):\\n result = []\\n module = type(self).__name__\\n turbine_rating_MW = self.input_dict['turbine_rating_MW']\\n num_turbines = self.input_dict['num_turbines']\\n project_size_kw = num_turbines * turbine_rating_MW * 1000\\n\\n if self.in_distributed_mode:\\n result.append({\\n 'type_of_cost': 'total_management_cost',\\n 'raw_cost': self.output_dict['total_management_cost']\\n })\\n\\n else:\\n result.append({\\n 'type_of_cost': 'insurance',\\n 'raw_cost': self.output_dict['insurance_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Construction Permitting',\\n 'raw_cost': self.output_dict['construction_permitting_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Project Management',\\n 'raw_cost': self.output_dict['project_management_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Bonding',\\n 'raw_cost': self.output_dict['bonding_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Markup Contingency',\\n 'raw_cost': self.output_dict['markup_contingency_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Engineering Foundation and Collections System (includes met mast)',\\n 'raw_cost': self.output_dict['engineering_usd']\\n })\\n result.append({\\n 'type_of_cost': 'Site Facility',\\n 'raw_cost': self.output_dict['site_facility_usd']\\n })\\n\\n for _dict in result:\\n _dict['turbine_rating_MW'] = self.input_dict['turbine_rating_MW']\\n _dict['num_turbines'] = self.input_dict['num_turbines']\\n _dict['rotor_diameter_m'] = self.input_dict['rotor_diameter_m']\\n _dict['project_id_with_serial'] = self.project_name\\n _dict['operation_id'] = 'Management'\\n _dict['module'] = module\\n _dict['raw_cost_total_or_per_turbine'] = 'total'\\n _dict['cost_per_turbine'] = _dict['raw_cost'] / num_turbines\\n _dict['cost_per_project'] = _dict['raw_cost']\\n _dict['usd_per_kw_per_project'] = _dict['raw_cost'] / project_size_kw\\n\\n return result\",\n \"def _build_graph(self):\\n start_t = time.time()\\n self._setup_placeholders()\\n self._embed()\\n self._encode()\\n self._match()\\n self._fuse()\\n self._decode()\\n self._passage_rank()\\n self._compute_loss()\\n self._create_train_op()\\n self.logger.info('Time to build graph: {} s'.format(time.time() - start_t))\\n param_num = sum([np.prod(self.sess.run(tf.shape(v))) for v in self.all_params])\\n self.logger.info('There are {} parameters in the model'.format(param_num))\",\n \"def build(self):\\n # add ops for generator (A->B) to graph\\n self.G = Generator(channels=self.opt.channels, ngf=self.opt.ngf, norm_type=self.opt.layer_norm_type,\\n init_type=self.opt.weight_init_type, init_gain=self.opt.weight_init_gain,\\n training=self.training, name='G')\\n\\n if self.training:\\n # add ops for other generator (B->A) and discriminators to graph\\n self.F = Generator(channels=self.opt.channels, ngf=self.opt.ngf,\\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\\n init_gain=self.opt.weight_init_gain, training=self.training, name='F')\\n self.D_A = Discriminator(channels=self.opt.channels, ndf=self.opt.ndf,\\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\\n init_gain=self.opt.weight_init_gain, training=self.training, name='D_A')\\n self.D_B = Discriminator(channels=self.opt.channels, ndf=self.opt.ndf,\\n norm_type=self.opt.layer_norm_type, init_type=self.opt.weight_init_type,\\n init_gain=self.opt.weight_init_gain, training=self.training, name='D_B')\\n\\n # generate fake images\\n fakeB = self.G(self.realA)\\n fakeA = self.F(self.realB, self.rand_mask)\\n\\n # generate reconstructed images\\n reconstructedA = self.F(fakeB, self.last_mask)\\n reconstructedB = self.G(fakeA)\\n\\n # generate identity mapping images\\n identA = self.G(self.realB)\\n identB = self.F(self.realA, self.mask_non_shadow)\\n\\n tf.summary.image('A/original', batch_convert_2_int(self.realA))\\n tf.summary.image('B/original', batch_convert_2_int(self.realB))\\n tf.summary.image('A/generated', batch_convert_2_int(fakeA))\\n tf.summary.image('B/generated', batch_convert_2_int(fakeB))\\n tf.summary.image('A/reconstructed', batch_convert_2_int(reconstructedA))\\n tf.summary.image('B/reconstructed', batch_convert_2_int(reconstructedB))\\n\\n # add loss ops to graph\\n Gen_loss, D_A_loss, D_B_loss = self.__loss(fakeA, fakeB, reconstructedA,\\n reconstructedB, identA, identB)\\n\\n # add optimizer ops to graph\\n optimizers = self.__optimizers(Gen_loss, D_A_loss, D_B_loss)\\n\\n return fakeA, fakeB, optimizers, Gen_loss, D_A_loss, D_B_loss\\n else: # only need generator from A->B during testing\\n fakeB = self.G(self.realA)\\n return fakeB\",\n \"def __initilization(self,node_set):\\n \\n print \\\"*********************************\\\"\\n \\n for x in node_set:\\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\\n \\n print \\\"Forward/Backward Algorithm Initialization Done!\\\"\",\n \"def build_graph(self, values, values_mask, keys_mask, keys, use_mask=True):\\n\\n with vs.variable_scope(\\\"CoAttn\\\"):\\n\\n print('value_vec_size is: ', self.value_vec_size)\\n print('num_values size is: ', values.shape[1])\\n print('num_keys size is: ', keys.shape[1])\\n print('value_vec_size is (key):', keys.shape[2])\\n # Declare variable \\n W = tf.get_variable(\\\"W\\\", shape = (self.value_vec_size, self.value_vec_size), \\\\\\n initializer = tf.contrib.layers.xavier_initializer())\\n b = tf.get_variable(\\\"b\\\", shape = (self.value_vec_size), initializer = tf.constant_initializer(0))\\n\\n # Compute projected question hidden states\\n\\n Q = tf.tanh(tf.tensordot(values, W, 1) + tf.reshape(b, [1, 1, self.value_vec_size])) # (batch_size, num_values, value_vec_size)\\n\\n\\n Q = concat_sentinel('question_sentinel', Q, self.value_vec_size) # (batch_size, num_values, value_vec_size)\\n # Q = tf.nn.dropout(Q, self.keep_prob)\\n print('Q shape is: ', Q.shape)\\n # sentinel = tf.get_variable(name='question_sentinel', shape=tf.shape(Q)[2], \\\\\\n # initializer=tf.contrib.layers.xavier_initializer(), dtype = tf.float32)\\n # sentinel = tf.tile(sentinel, [tf.shape(original_tensor)[0], 1, 1])\\n # concat_tensor = tf.concat([original_tensor, sentinel], 2)\\n\\n print('Q shape is: ', Q.shape)\\n D = keys # (batch_size, num_keys, value_vec_size)\\n D = concat_sentinel('document_sentinel', D, self.value_vec_size)\\n # D = tf.nn.dropout(D, self.keep_prob)\\n\\n # key = document, value = question here\\n ### End your code here to implement 'Sentinel Vector'\\n # Compute affinity matrix L\\n L = tf.matmul(D, tf.transpose(Q, perm=[0, 2, 1])) # shape (batch_size, num_keys, num_values)\\n\\n # Compute Context-to-Question (C2Q) Attention, we obtain C2Q attention outputs\\n if use_mask:\\n print('tf.shape(values)[0] is: ', tf.shape(values)[0])\\n print('tf.ones([tf.shape(values)[0], 1] is ', tf.ones([tf.shape(values)[0], 1], dtype=tf.int32))\\n values_mask = tf.expand_dims(tf.concat([values_mask, tf.ones([tf.shape(values)[0], 1], dtype=tf.int32)], axis=1), 1)\\n print \\\"value_mask shape:\\\", values_mask.shape\\n print \\\"L shape:\\\", L.shape\\n _, A_D = masked_softmax(L, mask=values_mask, dim=2) #(batch_size, num_keys, num_values)\\n else:\\n A_D = tf.nn.softmax(L, dim=-1)\\n\\n C2Q_Attn = tf.matmul(A_D, Q) # (batch_size, num_keys, value_vec_size)\\n print('C2Q_Attn shapeis ', C2Q_Attn.shape)\\n\\n # Compute Question-to-Context (Q2C) Attention, we obtain Q2C attention outputs\\n if use_mask:\\n keys_mask = tf.expand_dims(tf.concat([keys_mask, tf.ones([tf.shape(keys)[0], 1], dtype=tf.int32)], axis=1), 1)\\n print \\\"key_mask shape:\\\", keys_mask.shape\\n print \\\"L shape:\\\", L.shape\\n _, A_Q = masked_softmax(tf.transpose(L, perm=[0, 2, 1]), mask=keys_mask, dim=-1) # (batch_size, num_values, num_keys)\\n else:\\n A_Q = tf.nn.softmax(tf.transpose(L, perm=[0, 2, 1]), dim=2)\\n\\n Q2C_Attn = tf.matmul(A_Q, D) # (batch_size, num_values, key_vec_size)\\n print('Q2C_Attn shapeis ', Q2C_Attn.shape)\\n\\n # Compute second-level attention outputs S\\n S = tf.matmul(A_D, Q2C_Attn) # (batch_size, num_keys, value_vec_size)\\n print('S size is: ', S.shape)\\n\\n # Concatenate C2Q_Attn and S:\\n C_D = tf.concat([D, C2Q_Attn, S], 2) # (batch_size, num_keys, 3 * value_vec_size)\\n # C_D = tf.nn.dropout(C_D, self.keep_prob)\\n print('co_context size is: ', C_D.shape)\\n\\n # co_input = tf.concat([tf.transpose(D, perm = [0, 2, 1]), C_D], 1)\\n # print('co_input size is: ', co_input.shape)\\n size = int(self.value_vec_size)\\n \\n if self.device == 'gpu':\\n bidirection_rnn = tf.contrib.cudnn_rnn.CudnnLSTM(1, size, 3*size, dropout=0.2, direction=cudnn_rnn_ops.CUDNN_RNN_BIDIRECTION, dtype=tf.float32)\\n C_D = tf.transpose(C_D, perm=[1, 0, 2])\\n print 'C_D shape', C_D.shape\\n input_h = tf.zeros([2, tf.shape(values)[0], size])\\n input_c = tf.zeros([2, tf.shape(values)[0], size])\\n params = tf.get_variable(\\\"RNN\\\", shape=(estimate_cudnn_parameter_size(3*self.value_vec_size, size, 2)),\\n initializer=tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\\n \\n U, _, _ = bidirection_rnn(C_D, input_h, input_c, params)\\n#\\n print 'U shape:', U.shape\\n U = tf.transpose(U, perm=[1, 0, 2])\\n\\n else:\\n (u_fw_out, u_bw_out), _ = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), cell_bw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), \\n inputs=C_D, dtype = tf.float32)\\n U = tf.concat([u_fw_out, u_bw_out], 2)\\n\\n U = tf.nn.dropout(U[:,:-1, :], self.keep_prob)\\n # U = tf.nn.dropout(U, self.keep_prob)\\n print('U shape is: ', U.shape)\\n \\n return U,A_D,A_Q\",\n \"def complete_graph(self):\\n root_nodes = set()\\n\\n for name, a_block in self.wf['action'].items():\\n\\n a_block['name'] = name\\n\\n for n in a_block.get('needs', []):\\n if not self.wf['action'][n].get('next', None):\\n self.wf['action'][n]['next'] = set()\\n self.wf['action'][n]['next'].add(name)\\n\\n if not a_block.get('needs', None):\\n root_nodes.add(name)\\n\\n self.wf['root'] = root_nodes\",\n \"def __init__(self, quantized_edges_in_cfg: int, total_edges_in_cfg: int):\\n self.quantized_edges_in_cfg = quantized_edges_in_cfg\\n self.total_edges_in_cfg = total_edges_in_cfg\",\n \"def list_nodes(self, type_):\\n raise NotImplementedError()\",\n \"def get_fused_operator_statistics(self):\\n op_count = {}\\n ops = [\\n \\\"Attention\\\",\\n \\\"MultiHeadAttention\\\",\\n \\\"LayerNormalization\\\",\\n \\\"SkipLayerNormalization\\\",\\n \\\"BiasSplitGelu\\\",\\n \\\"GroupNorm\\\",\\n \\\"NhwcConv\\\",\\n \\\"BiasAdd\\\",\\n ]\\n for op in ops:\\n nodes = self.get_nodes_by_op_type(op)\\n op_count[op] = len(nodes)\\n\\n logger.info(f\\\"Optimized operators:{op_count}\\\")\\n return op_count\",\n \"def _process_nodes(self):\\n # Sort the nodes by metanode type, then by id\\n self.node_df = self.node_df.sort_values(['label', 'id']).reset_index(drop=True)\\n # Get all the ids\\n self.nodes = self.node_df['id']\\n # Get mapping from the index to the node ID (one to many so need different one for each node type)\\n self.index_to_nid = dict()\\n for group_name, group in self.node_df.groupby('label'):\\n self.index_to_nid[group_name] = group['id'].reset_index(drop=True).to_dict()\\n # Get the reverse mapping (many to one so don't need to separate based on type).\\n self.nid_to_index = dict()\\n for mapper in self.index_to_nid.values():\\n for index, nid in mapper.items():\\n self.nid_to_index[nid] = index\\n # Finally, we need a mapper from id to node type\\n self.id_to_metanode = self.node_df.set_index('id')['label'].to_dict()\\n # And from node type to a list of ids\\n self.metanode_to_ids = dict()\\n for group_name, group in self.node_df.groupby('label'):\\n self.metanode_to_ids[group_name] = group['id'].tolist()\\n # One more mapper of id to name\\n self.nid_to_name = self.node_df.set_index('id')['name'].to_dict()\",\n \"def _generate_graph(self) -> None:\\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\\n p_in=self.community_p_in,\\n p_out=self.community_p_out,\\n seed=self.seed)\\n\\n for _, nv in self.g_.nodes.data():\\n nv[\\\"infected\\\"] = 0\\n nv[\\\"immune\\\"] = False\\n nv[\\\"alive\\\"] = True\\n nv[\\\"_edges\\\"] = []\\n nv[\\\"isolated\\\"] = False\\n nv[\\\"mask\\\"] = 0.0\",\n \"def finalize_graph(self) -> None:\\n digraph = nx.MultiDiGraph()\\n\\n for node in self.graph.iternodes():\\n attributes = self.get_attributes(node)\\n attributes[\\\"schema\\\"] = node.type.name\\n if node.caption is not None:\\n attributes[\\\"label\\\"] = node.caption\\n if node.is_entity and node.schema is not None:\\n attributes[\\\"schema\\\"] = node.schema.name\\n digraph.add_node(node.id, **attributes)\\n\\n for edge in self.graph.iteredges():\\n attributes = self.get_attributes(edge)\\n attributes[\\\"schema\\\"] = edge.type_name\\n attributes[\\\"weight\\\"] = str(edge.weight)\\n digraph.add_edge(edge.source_id, edge.target_id, key=edge.id, **attributes)\\n\\n for line in generate_gexf(digraph, prettyprint=True):\\n self.fh.write(line)\\n self.fh.write(\\\"\\\\n\\\")\",\n \"def make_node_structure() -> Node:\\n\\n agricult = Node('argicult', os.path.join(os.path.abspath(os.curdir),\\n 'finance/agricult/agricult_classifier_RF.sav'),\\n os.path.join(os.path.abspath(os.curdir),\\n 'finance/agricult/agricult_classifier_CV.sav'),\\n {'cattle': Node('cattle'), 'corn': Node('corn'),\\n 'soybean': Node('soybean'), 'sugar': Node('sugar')})\\n\\n crypto = Node('crypto', os.path.join(os.path.abspath(os.curdir),\\n 'finance/crypto/crypto_classifier_RF.sav'),\\n os.path.join(os.path.abspath(os.curdir),\\n 'finance/crypto/crypto_classifier_CV.sav'),\\n {'bitcoin': Node('bitcoin'), 'dash': Node('dash'),\\n 'ethereum': Node('ethereum'), 'litecoin': Node('litecoin'),\\n 'monero': Node('monero'), 'ripple': Node('ripple'), 'zash': Node('zash')}) \\n\\n energy = Node('energy', os.path.join(os.path.abspath(os.curdir),\\n 'finance/energy/energy_classifier_RF.sav'),\\n os.path.join(os.path.abspath(os.curdir),\\n 'finance/energy/energy_classifier_CV.sav'),\\n {'brent crude': Node('brent crude'), 'coal': Node('coal'),\\n 'crude oil': Node('crude oil'), 'natural gas': Node('natural gas')})\\n\\n metals = Node('metals', os.path.join(os.path.abspath(os.curdir),\\n 'finance/metals/metals_classifier_RF.sav'),\\n os.path.join(os.path.abspath(os.curdir),\\n 'finance/metals/metals_classifier_CV.sav'),\\n {'gold': Node('gold'), 'iron': Node('iron'),\\n 'platinum': Node('platinum'), 'silver': Node('silver')})\\n\\n finance = Node('finance', os.path.join(os.path.abspath(os.curdir),\\n 'finance/finance_classifier_RF.sav'),\\n os.path.join(os.path.abspath(os.curdir),\\n 'finance/finance_classifier_CV.sav'),\\n {'agricult': agricult, 'crypto': crypto,\\n 'energy': energy, 'metals': metals})\\n\\n return finance\",\n \"def all_conv_ops(self):\\n pass\",\n \"def _first_call_op_prepare_before_hook_create_subgraphs(\\n self,\\n op: Callable,\\n args: Tuple[Any, ...],\\n kwargs: Dict[str, Any],\\n qtensor_id: List[int],\\n fqn: str,\\n root_module: torch.nn.Module,\\n op_quantizeability_type: OpQuantizeabilityType,\\n ) -> Tuple[Tuple[Any, ...], Dict[str, Any]]:\\n arg_tensor_infos: List[Optional[QTensorInfo]] = []\\n for arg in args:\\n if isinstance(arg, (list, tuple)):\\n for inner_arg in arg:\\n self._first_call_op_prepare_before_hook_create_subgraphs_tensor(\\n op, inner_arg, arg_tensor_infos, qtensor_id)\\n else:\\n self._first_call_op_prepare_before_hook_create_subgraphs_tensor(\\n op, arg, arg_tensor_infos, qtensor_id)\\n\\n if op_quantizeability_type is OpQuantizeabilityType.NOT_QUANTIZEABLE:\\n op_type_is_module = isinstance(op, torch.nn.Module)\\n op_type : Callable = type(op) if op_type_is_module else op # type: ignore[assignment]\\n self.seen_nonq_op_infos.append(SeenNonQOpInfo(\\n op_type, arg_tensor_infos, []))\\n return args, kwargs\\n\\n op_packing_only_uses_module_attributes = \\\\\\n get_op_packing_only_uses_module_attributes(op, args, kwargs, root_module)\\n\\n packable_tensor_idx_to_name = {}\\n packable_nontensor_idx_to_arg = {}\\n packable_tensor_kwarg_name_to_name = {}\\n if op_packing_only_uses_module_attributes:\\n packable_tensor_arg_idxs = get_packable_tensor_arg_idxs(op)\\n if packable_tensor_arg_idxs is not None:\\n for arg_idx in packable_tensor_arg_idxs:\\n if arg_idx >= len(args):\\n continue\\n arg = args[arg_idx]\\n param_name = get_param_name(root_module, arg)\\n packable_tensor_idx_to_name[arg_idx] = param_name\\n\\n packable_nontensor_arg_idxs = get_packable_nontensor_arg_idxs(op)\\n if packable_nontensor_arg_idxs is not None:\\n for arg_idx in packable_nontensor_arg_idxs:\\n packable_nontensor_idx_to_arg[arg_idx] = args[arg_idx]\\n\\n packable_tensor_kwarg_names = \\\\\\n get_packable_tensor_kwarg_names(op)\\n if packable_tensor_kwarg_names is not None:\\n for kwarg_name in packable_tensor_kwarg_names:\\n if kwarg_name not in kwargs:\\n continue\\n kwarg = kwargs[kwarg_name]\\n kwarg_name_on_module = get_param_name(root_module, kwarg)\\n packable_tensor_kwarg_name_to_name[kwarg_name] = \\\\\\n kwarg_name_on_module\\n\\n if self.idx not in self.idx_to_seen_q_op_infos:\\n op_type_is_module = isinstance(op, torch.nn.Module)\\n op_type = type(op) if op_type_is_module else op # type: ignore[assignment]\\n qconfig = get_cur_qconfig(self.qconfig_mapping, fqn, op_type)\\n # TODO(future PR): use API flag instead of qconfig for is_reference\\n is_reference_op_at_inference = \\\\\\n qconfig is not None and activation_is_int32_quantized(qconfig)\\n self.idx_to_seen_q_op_infos[self.idx] = SeenQOpInfo(\\n self.idx, op_type, op_type_is_module, fqn, arg_tensor_infos, [],\\n packable_tensor_idx_to_name, packable_nontensor_idx_to_arg,\\n packable_tensor_kwarg_name_to_name,\\n op_packing_only_uses_module_attributes, qconfig, None,\\n is_reference_op_at_inference)\\n\\n return args, kwargs\",\n \"def quantize_whole_model(net, bits=8):\\n cluster_centers = []\\n assert isinstance(net, nn.Module)\\n layer_ind = 0\\n for n, m in net.named_modules():\\n if isinstance(m, PrunedConv):\\n \\\"\\\"\\\"\\n Apply quantization for the PrunedConv layer.\\n --------------Your Code---------------------\\n \\\"\\\"\\\"\\n\\n # Cluster the Weights\\n num_centroid = pow(2, bits)\\n\\n all_weight = m.conv.weight.data.cpu().detach().numpy()\\n weight_shape = all_weight.shape\\n \\n all_weight = all_weight.reshape(-1,1)\\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\\n\\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\\n\\n # Generate Code Book\\n cluster_center = kmeans.cluster_centers_.flatten()\\n\\n # Quantize\\n indexs = kmeans.predict(all_weight)\\n indexs = indexs.reshape(weight_shape)\\n \\n vmap = np.vectorize(lambda x:cluster_center[x])\\n m.conv.weight.data = torch.from_numpy(vmap(indexs)).to(device)\\n \\n _cluster_center = [ \\\"{0:b}\\\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\\n cluster_centers.append(_cluster_center)\\n\\n layer_ind += 1\\n print(\\\"Complete %d layers quantization...\\\" %layer_ind)\\n \\n elif isinstance(m, PruneLinear):\\n \\\"\\\"\\\"\\n Apply quantization for the PrunedLinear layer.\\n --------------Your Code---------------------\\n \\\"\\\"\\\"\\n \\n # Cluster the Weights\\n num_centroid = pow(2, bits)\\n \\n all_weight = m.linear.weight.data.cpu().detach().numpy()\\n weight_shape = all_weight.shape\\n\\n all_weight = all_weight.reshape(-1,1)\\n k_init = np.linspace(all_weight.min(), all_weight.max(), num_centroid)\\n \\n kmeans = KMeans(n_clusters=num_centroid, init=k_init.reshape(-1, 1), n_init=1).fit(all_weight)\\n \\n # Generate Code Book\\n cluster_center = kmeans.cluster_centers_.flatten()\\n\\n # Quantize\\n indexs = kmeans.predict(all_weight)\\n indexs = indexs.reshape(weight_shape)\\n\\n vmap = np.vectorize(lambda x:cluster_center[x])\\n m.linear.weight.data = torch.from_numpy(vmap(indexs)).to(device)\\n \\n _cluster_center = [ \\\"{0:b}\\\".format(x).zfill(bits) for x in range(len(cluster_center)) ]\\n cluster_centers.append(_cluster_center)\\n \\n layer_ind += 1\\n print(\\\"Complete %d layers quantization...\\\" %layer_ind)\\n \\n return np.array(cluster_centers)\",\n \"def _create_activation_quantizers(self, tensor_names: List[str], activation_bw: int,\\n round_mode: libpymo.RoundingMode, quant_scheme: QuantScheme,\\n is_symmetric: bool, data_type: QuantizationDataType) -> Dict[str, StaticGridPerTensorQuantizer]:\\n quantizers = {}\\n for layer in range(self.num_layers):\\n for name in tensor_names:\\n name_in_layer = name.format(layer)\\n group_name = QcQuantizeRecurrent._get_group_name(name_in_layer, layer)\\n if group_name:\\n if group_name not in self._grouped_quantizers:\\n self._grouped_quantizers[group_name] = \\\\\\n tensor_quantizer_factory(activation_bw,\\n round_mode,\\n quant_scheme,\\n use_symmetric_encodings=is_symmetric,\\n enabled_by_default=False,\\n data_type=data_type)\\n quantizers[name_in_layer] = self._grouped_quantizers[group_name]\\n else:\\n quantizers[name_in_layer] = tensor_quantizer_factory(\\n activation_bw,\\n round_mode,\\n quant_scheme,\\n use_symmetric_encodings=is_symmetric,\\n enabled_by_default=False,\\n data_type=data_type)\\n return quantizers\",\n \"def build(self):\\n logger.info('Building...')\\n self._check_cycles(self.abstract_graph.nx_graph)\\n with ctx.inventory('new_nodes'):\\n self._build_node(self.abstract_graph.start)\\n self._autoplace(new_nodes)\\n logger.info('Total number of nodes built: {}'.format(len(new_nodes)))\\n return len(new_nodes)\",\n \"def node_catalogue():\\r\\n\\r\\n classes = node_subclasses(Node)\\r\\n\\r\\n catalogue = {}\\r\\n\\r\\n for node_class in classes:\\r\\n try:\\r\\n name = node_class.identifier()\\r\\n except AttributeError:\\r\\n # If node does not provide identifier, we consider it to be\\r\\n # private or abstract class\\r\\n continue\\r\\n\\r\\n # Get copy of node info\\r\\n info = dict(get_node_info(node_class))\\r\\n info[\\\"name\\\"] = name\\r\\n info[\\\"factory\\\"] = node_class\\r\\n\\r\\n # Get node type based on superclass, if not provided\\r\\n\\r\\n if \\\"type\\\" not in info:\\r\\n if issubclass(node_class, SourceNode):\\r\\n info[\\\"type\\\"] = \\\"source\\\"\\r\\n elif not issubclass(node_class, SourceNode) \\\\\\r\\n and not issubclass(node_class, TargetNode):\\r\\n info[\\\"type\\\"] = \\\"processing\\\"\\r\\n elif issubclass(node_class, TargetNode):\\r\\n info[\\\"type\\\"] = \\\"target\\\"\\r\\n else:\\r\\n info[\\\"type\\\"] = \\\"unknown\\\"\\r\\n\\r\\n catalogue[name] = info\\r\\n\\r\\n return catalogue\",\n \"def get_output_nodes(self):\\n \\n\\n self.buildings = self.dataset.groups['buildings']\\n self.building_nodes = self.buildings.groups['nodes']\\n\\n eta_output_added = getattr(self.building_nodes,'eta_output_added')\\n uv_output_added = getattr(self.building_nodes,'uv_output_added')\\n\\n eta = []\\n uv = []\\n nodeIds = []\\n time = []\\n \\n if(eta_output_added or uv_output_added ):\\n time = self.building_nodes.variables['time'][:].tolist()\\n nodeIds = self.building_nodes.variables['id'][:].tolist()\\n if eta_output_added: eta = self.building_nodes.variables['eta'][:].tolist()\\n if uv_output_added: uv = self.building_nodes.variables['uv'][:].tolist()\\n\\n \\n return nodeIds,eta, uv, time\",\n \"def _apply_gating_logic(self):\\n if self._mode != QcQuantizeOpMode.LEARN_ENCODINGS:\\n return\\n\\n applied_quantizers = set()\\n def apply_logic(name, quantizer):\\n if quantizer in self._grouped_quantizers.values():\\n if quantizer in applied_quantizers:\\n return\\n\\n name, *_ = [n for n, q in self._grouped_quantizers.items() if q == quantizer]\\n\\n if quantizer.enabled:\\n if quantizer.bitwidth == 32 or quantizer.data_type == QuantizationDataType.float:\\n return\\n set_encoding_min_max_gating_threshold(\\n getattr(self, name + '_encoding_min'),\\n getattr(self, name + '_encoding_max'))\\n applied_quantizers.add(quantizer)\\n\\n for name, quantizer in self.input_quantizers.items():\\n apply_logic(name, quantizer)\\n for name, quantizer in self.output_quantizers.items():\\n apply_logic(name, quantizer)\\n for name, quantizer in self._param_quantizers.items():\\n apply_logic(name, quantizer)\",\n \"def __calculate_iterations(self):\\n iterables = {}\\n \\n def get_type(type_options):\\n key = self._config_dict[type_options].keys()[0]\\n data = self._config_dict[type_options][key]\\n \\n if type(data) == dict:\\n iterables[key] = [data]\\n else:\\n iterables[key] = data\\n \\n for config_type in self.__iterables:\\n get_type(config_type)\\n \\n self.__iterables = [dict(zip(iterables, v)) for v in product(*iterables.values())] # Calculates the cartesian product of all the lists to iterate to generate permutations.\\n self.__iterables_counter = 0\",\n \"def build_pool(self):\\n self._pool = [0] * N\\n if isinstance(self._bases, dict):\\n for base, num in self._bases.items():\\n self._pool[to_code(base)] += num\\n elif isinstance(self._bases, list):\\n for base in self._bases:\\n self._pool[to_code(base)] += 1\",\n \"def _build_graph(self):\\n start_t = time.time()\\n self._setup_placeholders()\\n self._embed()\\n self._encode_back()\\n self._encode()\\n self._match()\\n self._fuse()\\n self._decode()\\n self._compute_loss()\\n self._create_train_op()\\n self.logger.info('Time to build graph: {} s'.format(time.time() - start_t))\\n param_num = sum([np.prod(self.sess.run(tf.shape(v))) for v in self.all_params])\\n self.logger.info('There are {} parameters in the model'.format(param_num))\",\n \"def build_graph(self):\\n with vs.variable_scope(\\\"context\\\"):\\n context_encoder = RNNEncoder(self.FLAGS.hidden_size, self.keep_prob)\\n context_hiddens = context_encoder.build_graph(self.context_embs,\\n self.context_mask) # (batch_size, context_len, hidden_size*2)\\n\\n with vs.variable_scope(\\\"question\\\"):\\n question_encoder = RNNEncoder(self.FLAGS.hidden_size, self.keep_prob)\\n question_hiddens = question_encoder.build_graph(self.qn_embs,\\n self.qn_mask) # (batch_size, question_len, hidden_size*2)\\n question_last_hidden = tf.reshape(question_hiddens[:, -1, :], (-1, 2 * self.FLAGS.hidden_size))\\n question_last_hidden = tf.contrib.layers.fully_connected(question_last_hidden,\\n num_outputs=self.FLAGS.hidden_size)\\n # Use context hidden states to attend to question hidden states\\n\\n # attn_output is shape (batch_size, context_len, hidden_size*2)\\n # The following is BiDAF attention\\n if self.FLAGS.use_bidaf:\\n attn_layer = BiDAF(self.keep_prob, self.FLAGS.hidden_size * 2, self.FLAGS.hidden_size * 2)\\n attn_output = attn_layer.build_graph(question_hiddens, self.qn_mask, context_hiddens,\\n self.context_mask) # (batch_size, context_len, hidden_size * 6)\\n else: # otherwise, basic attention\\n attn_layer = BasicAttn(self.keep_prob, self.FLAGS.hidden_size * 2, self.FLAGS.hidden_size * 2)\\n _, attn_output = attn_layer.build_graph(question_hiddens, self.qn_mask, context_hiddens)\\n # Concat attn_output to context_hiddens to get blended_reps\\n blended_reps = tf.concat([context_hiddens, attn_output], axis=2) # (batch_size, context_len, hidden_size*4)\\n\\n blended_reps_final = tf.contrib.layers.fully_connected(blended_reps, num_outputs=self.FLAGS.hidden_size)\\n\\n decoder = RNNDecoder(self.FLAGS.batch_size, self.FLAGS.hidden_size, self.ans_vocab_size, self.FLAGS.answer_len,\\n self.ans_embedding_matrix, self.keep_prob, sampling_prob=self.sampling_prob,\\n schedule_embed=self.FLAGS.schedule_embed, pred_method=self.FLAGS.pred_method)\\n (self.train_logits, self.train_translations, _), \\\\\\n (self.dev_logits, self.dev_translations, self.attention_results) = decoder.build_graph(blended_reps_final, question_last_hidden,\\n self.ans_embs, self.ans_mask, self.ans_ids,\\n self.context_mask)\",\n \"def build_order(self):\\n seen = set()\\n\\n def _already_built(node):\\n # visit only once\\n if node in seen:\\n return True\\n seen.add(node)\\n\\n # prune if the result is already computed\\n if node.output_ready:\\n return True\\n\\n return False\\n\\n for target in self.targets:\\n if target in seen:\\n continue\\n for node in target.postorder(prune_fn=_already_built):\\n yield node\",\n \"def build_graph(self, graph, inst_name, port_nets):\\n return\",\n \"def _build_graph(self):\\n with tf.variable_scope(name_or_scope = self.name, reuse = self.reuse):\\n if self.strides == 1:\\n data_proj, data_path = ly.channel_shuffle(self.input)\\n # deal data_path with branch_main\\n with tf.variable_scope(name_or_scope = 'branch_main_s1', reuse = self.reuse):\\n data_path = ly.conv_bn_activation(data_path, self.mid_channels, 1, self.strides, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\\n data_path = ly.depthwise_conv_layer(data_path, self.mid_channels, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\\n data_path = ly._bn(data_path, self.data_format, self.is_training)\\n data_path = ly.conv_bn_activation(data_path, self.outputs, 1, self.strides, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\\n return tf.concat((data_proj, data_path), axis = -1)\\n else:\\n data_proj = self.input\\n data_path = self.input\\n with tf.variable_scope(name_or_scope = 'branch_main_s2', reuse = self.reuse):\\n data_path = ly.conv_bn_activation(data_path, self.mid_channels, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\\n data_path = ly.depthwise_conv_layer(data_path, self.mid_channels, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\\n data_path = ly._bn(data_path, self.data_format, self.is_training)\\n data_path = ly.conv_bn_activation(data_path, self.outputs, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\\n with tf.variable_scope(name_or_scope = 'branch_proj_s2', reuse = self.reuse):\\n data_proj = ly.depthwise_conv_layer(data_proj, self.inp, self.ksize, [1, self.strides, self.strides, 1], data_format = self.data_format)\\n data_proj = ly._bn(data_proj, self.data_format, self.is_training)\\n data_proj = ly.conv_bn_activation(data_proj, self.inp, 1, 1, data_format = self.data_format, is_training = self.is_training, _use_bias = False)\\n return tf.concat((data_proj, data_path), axis = -1)\",\n \"def build(self): \\n self.computation_graph = tf.Graph()\\n with self.computation_graph.as_default():\\n\\n self.factorization_layer = Factorization(self.args, self.vocab_size)\\n self.cluster_layer = Clustering(self.args)\\n\\n self.gamma = tf.placeholder(\\\"float\\\")\\n self.loss = self.factorization_layer()+self.gamma*self.cluster_layer(self.factorization_layer)\\n\\n self.batch = tf.Variable(0)\\n self.step = tf.placeholder(\\\"float\\\")\\n \\n self.learning_rate_new = tf.train.polynomial_decay(self.args.initial_learning_rate,\\n self.batch,\\n self.true_step_size,\\n self.args.minimal_learning_rate,\\n self.args.annealing_factor)\\n \\n self.train_op = tf.train.AdamOptimizer(self.learning_rate_new).minimize(self.loss, global_step = self.batch)\\n \\n self.init = tf.global_variables_initializer()\\n\\n self.weights = overlap_generator(self.args, self.graph)\",\n \"def _expand_combinations(kernel: gpflow.kernels.Kernel) -> List[gpflow.kernels.Kernel]:\\n if isinstance(kernel, (gpflow.kernels.Sum, gpflow.kernels.Product)):\\n return kernel.children.values()\\n\\n return []\",\n \"def build_graph(self):\\n self._reset_iterator_memory()\\n self._construct_graph_handler()\\n assert self.graph_handler\\n for rxn_id in self.graph_handler.get_valid_reaction_ids():\\n rxn = db.Reaction(rxn_id, self._reactions)\\n self.graph_handler.add_rxn(rxn)\",\n \"def build_opt(self):\\n student_taken = self.student.student_hist[['FULL','DESCR.y']]\\n\\n requiments = self.major_map.cleaned_major_data[['REQID','L','MA','CS','HU','SB','SQ','SG','C','G','H','Honor']]\\n\\n requiments.is_copy = False\\n requiments['REQID'] = requiments['REQID'].astype('str')\\n\\n requirements_to = pd.merge(self.graph, requiments, how='inner', left_on='REQ', right_on='REQID')\\n \\n # requirements_to = pd.merge(self.graph, requiments, how='left', left_on='REQ', right_on='REQID')\\n classes_from = pd.merge(self.graph, student_taken, how='left', left_on='CLS', right_on='FULL')\\n\\n return classes_from, requirements_to\",\n \"def build_graph(self, values, values_mask, keys):\\n \\n \\n\\n with vs.variable_scope(\\\"CoAttn\\\"):\\n \\n #########################################################################\\n # Introduce a non-linear projection layer on top of the question encoding\\n # to allow for varation between question and document encoding space\\n W_q = tf.get_variable(name=\\\"W_q\\\", \\\\\\n shape=[2*self.key_vec_size,2*self.key_vec_size],\\\\\\n initializer=tf.contrib.layers.xavier_initializer(),\\\\\\n dtype=tf.float32)\\n\\n W_q = tf.expand_dims(tf.ones([tf.shape(values)[0],1]), 1) * W_q\\n\\n b_q = tf.Variable(tf.constant(0.0,\\\\\\n shape=[2*self.key_vec_size,]),\\\\\\n dtype=tf.float32,\\\\\\n name='b_q')\\n \\n Q = tf.nn.tanh(tf.matmul(values,W_q)+b_q)\\n #########################################################################\\n\\n #########################################################################\\n # Coattention Encoder \\n \\n # L --> affinity matrix\\n l = tf.matmul(keys,tf.transpose(Q,perm=[0,2,1]))\\n \\n # mask affinity matrix, to not care about padded values\\n l_mask = tf.expand_dims(values_mask, 1)\\n \\n # a_q --> attention weights across document for each word in the question\\n _, a_q = masked_softmax(l, l_mask, 2)\\n \\n # a_d --> attention weights across question for each word in the document\\n a_d = tf.nn.softmax(tf.transpose(l,perm=[0, 2, 1]))\\n \\n # compute attention context of the document in light of each word of the question\\n c_q = tf.matmul(tf.transpose(a_q,perm=[0,2,1]),keys)\\n \\n # parallel computation of q*a_d & c_q*a_q\\n c_d = tf.matmul(tf.transpose(a_d,perm=[0,2,1]),tf.concat([Q,c_q],2))\\n \\n # d_c_d as concatinated d;c_d as inpit for the Bi-LSTM\\n d_c_d = tf.concat([keys,c_d],axis=2)\\n \\n d_c_d_length = tf.cast(\\\\\\n tf.reduce_sum(\\\\\\n tf.sign(\\\\\\n tf.reduce_max(\\\\\\n tf.abs(d_c_d), axis=2)\\\\\\n ),\\\\\\n axis=1), \\\\\\n tf.int32)\\n \\n with tf.variable_scope('coattentionencoder'):\\n u_lstm_forward = tf.contrib.rnn.BasicLSTMCell(self.key_vec_size) \\n u_lstm_backward = tf.contrib.rnn.BasicLSTMCell(self.key_vec_size)\\n big_u,_ = tf.nn.bidirectional_dynamic_rnn(cell_bw=u_lstm_backward,cell_fw=u_lstm_forward,dtype=tf.float32,inputs=d_c_d,time_major=False,sequence_length=d_c_d_length)\\n \\n # Dropout on the concatinated big U containing forward and backward pass\\n output = tf.nn.dropout(tf.concat(big_u,2), self.keep_prob)\\n\\n\\n return output\",\n \"def run(self, dag):\\n self.property_set[\\\"commutation_set\\\"] = defaultdict(list)\\n pending_1q = [list() for _ in range(dag.num_qubits())]\\n block_id = [-(i + 1) for i in range(dag.num_qubits())]\\n current_id = 0\\n block_list = list()\\n to_qid = dict()\\n for i, qubit in enumerate(dag.qubits):\\n to_qid[qubit] = i\\n for node in dag.topological_op_nodes():\\n qids = [to_qid[q] for q in node.qargs]\\n if (\\n not isinstance(node.op, Gate)\\n or len(qids) > 2\\n or node.op.condition\\n or node.op.is_parameterized()\\n ):\\n for qid in qids:\\n if block_id[qid] > 0:\\n block_list[block_id[qid]].extend(pending_1q[qid])\\n block_id[qid] = -(qid + 1)\\n pending_1q[qid].clear()\\n continue\\n\\n if len(qids) == 1:\\n b_id = block_id[qids[0]]\\n if b_id < 0:\\n pending_1q[qids[0]].append(node)\\n else:\\n block_list[b_id].append(node)\\n elif block_id[qids[0]] == block_id[qids[1]]:\\n block_list[block_id[qids[0]]].append(node)\\n else:\\n block_id[qids[0]] = current_id\\n block_id[qids[1]] = current_id\\n new_block = list()\\n if pending_1q[qids[0]]:\\n new_block.extend(pending_1q[qids[0]])\\n pending_1q[qids[0]].clear()\\n if pending_1q[qids[1]]:\\n new_block.extend(pending_1q[qids[1]])\\n pending_1q[qids[1]].clear()\\n new_block.append(node)\\n block_list.append(new_block)\\n current_id += 1\\n\\n self.property_set[\\\"block_list\\\"] = [tuple(block) for block in block_list]\\n return dag\",\n \"def graph_implementation(arg_objs, size, data=None):\\n t = lu.create_var(size)\\n for i, obj in enumerate(arg_objs):\\n # Promote obj.\\n if obj.size != size:\\n arg_objs[i] = lu.promote(obj, size)\\n\\n return (t, [SOC_Elemwise(t, arg_objs)])\",\n \"def get_reversed_fusions() -> List[Tuple[NSFusionType, int]]:\\n results: List[Tuple[NSFusionType, int]] = []\\n\\n # Possible syntaxes:\\n # * single op: torch.nn.Conv2d\\n # * multiple ops: (torch.nn.ReLU, torch.nn.Conv2d)\\n # For fusions, we only care about patterns composed of multiple ops.\\n # TODO(future PR): allow customizations from default patterns.\\n all_quant_patterns = _get_pattern_to_quantize_handlers(get_native_backend_config())\\n\\n default_base_op_idx = 0\\n for quant_pattern in all_quant_patterns.keys():\\n # TODO: this is a temporary hack to flatten the patterns from quantization so\\n # that it works with the ns matcher function, maybe we should use `_is_match`\\n # in torch.ao.quantization.fx.match_utils to match the patterns\\n if isinstance(quant_pattern, tuple) and len(quant_pattern) == 2 and \\\\\\n isinstance(quant_pattern[1], tuple) and len(quant_pattern[1]) == 2:\\n # flatten the pattern with form (nn.ReLU, (nn.BatchNorm2d, nn.Conv2d))\\n quant_pattern = (quant_pattern[0], quant_pattern[1][0], quant_pattern[1][1])\\n\\n # Only patterns of multiple ops are fusions, ignore\\n # patterns which contain a single ops (they get matched\\n # without caring about fusions).\\n if isinstance(quant_pattern, tuple):\\n results.append((quant_pattern, default_base_op_idx)) # type: ignore[arg-type]\\n\\n # For each pattern, add additional patterns with observers and\\n # fake quants at the end.\\n # TODO(future PR): if needed, implement matching for a node\\n # having multiple output observers.\\n for cls in (ObserverBase, FakeQuantizeBase):\\n if isinstance(quant_pattern, tuple):\\n new_pattern = (cls, *quant_pattern)\\n else:\\n new_pattern = (cls, quant_pattern)\\n results.append((new_pattern, default_base_op_idx)) # type: ignore[arg-type]\\n\\n\\n # After this point, results contains values such as\\n # [..., ((torch.nn.Relu, torch.nn.Conv2d), 0), ...]\\n\\n # Patterns for matching fp16 emulation are not specified in the quantization\\n # fusion mappings. For now, define them here.\\n fp16_em_base_op_idx = 1\\n patterns_to_add = [\\n # linear-relu fp16 emulation:\\n # fp16_to_fp32 -> linear -> relu -> fp32_to_fp16\\n (((\\\"to\\\", torch.float16), F.relu, F.linear, \\\"dequantize\\\"), fp16_em_base_op_idx,),\\n # Conv-BN fusion (this happens outside of quantization patterns,\\n # which is why it is defined separately here).\\n ((nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),\\n ((nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),\\n ((nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),\\n ((nn.ReLU, nn.BatchNorm1d, nn.Conv1d), default_base_op_idx),\\n ((nn.ReLU, nn.BatchNorm2d, nn.Conv2d), default_base_op_idx),\\n ((nn.ReLU, nn.BatchNorm3d, nn.Conv3d), default_base_op_idx),\\n ]\\n for p in patterns_to_add:\\n results.append(p) # type: ignore[arg-type]\\n results.append(((ObserverBase, *p[0]), p[1])) # type: ignore[arg-type]\\n results.append(((FakeQuantizeBase, *p[0]), p[1])) # type: ignore[arg-type]\\n\\n return results\",\n \"def _build(self, generation):\\n with tf.variable_scope ('discriminator') as scope:\\n \\n image_unflatten = unflatten_layer ( self.images )\\n gen_unflatten = unflatten_layer ( generation )\\n\\n # Conv Layer 1 - image\\n conv1_out_image, params = conv_2d_layer (\\n input = image_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'conv_1_img',\\n visualize = True ) \\n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \\n \\n # Conv Layer 1 - gen\\n conv1_out_gen, params = conv_2d_layer (\\n input = gen_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n params = params,\\n name = 'conv_1_gen',\\n visualize = False )\\n\\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \\n process_params(params, name = self.name)\\n c1_params = params\\n\\n\\n\\n\\n\\n # Conv Layer 2 - image\\n conv2_out_image, params = conv_2d_layer (\\n input = lrn1_out_img,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'conv_2_img' )\\n\\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \\n\\n\\n # Conv Layer 2 - gen\\n conv2_out_gen, params = conv_2d_layer (\\n input = lrn1_out_gen,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n params = params,\\n name = 'conv_2_gen' )\\n\\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \\n process_params(params, name = self.name)\\n c2_params = params\\n\\n # Dropout Layer\\n flat_gen = flatten_layer(lrn2_out_gen)\\n flat_img = flatten_layer(lrn2_out_img)\\n\\n flat_gen_dropout = dropout_layer ( input = flat_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_1_gen') \\n\\n flat_img_dropout = dropout_layer ( input = flat_img,\\n prob = self.dropout_prob,\\n name = 'dropout_1_img') \\n\\n\\n\\n # Dot Product Layer 1 -img\\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\\n neurons = HIDDEN_1,\\n name = 'image_disc_dot_1')\\n # Dot Product Layer 1 - gen\\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_1')\\n\\n process_params(params, name = self.name)\\n d1_params = params\\n \\n ##\\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_2_gen') \\n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_2_img')\\n\\n # Dot Product Layer 2 -img\\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\\n neurons = HIDDEN_2,\\n name = 'image_disc_dot_2')\\n # Dot Product Layer 2 - gen\\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_2')\\n process_params(params, name = self.name)\\n d2_params = params\\n\\n ##\\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_3_gen') \\n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_3_img')\\n\\n # Dot Product Layer 1 -img\\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'real')\\n # Dot Product Layer 1 -gen\\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\\n params = params,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'fake')\\n\\n process_params(params, name = self.name)\\n d3_params = params\\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \\n\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \\n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\\\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\\\\n 0.5 * tf.reduce_mean ((self.fake)**2)\\n tf.summary.scalar('discriminator_obj', discriminator_obj)\\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \\n\\n with tf.variable_scope (self.name + '_probabilites') as scope: \\n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\\n \\n self._cook_optimizer( \\n lr = DIS_GAN_LR, \\n optimizer = DIS_GAN_OPTIMIZER,\\n l1_coeff = DIS_GAN_L1_COEFF,\\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)\",\n \"def _QConv(self, step, target, qubits):\\n yield cirq.CZPowGate(exponent=self._get_new_param())(qubits[target], qubits[target+step])\\n yield cirq.CXPowGate(exponent=self._get_new_param())(qubits[target], qubits[target+step])\",\n \"def build(self): \\n self.computation_graph = tf.Graph()\\n with self.computation_graph.as_default():\\n\\n self.factorization_layer = Factorization(self.args, self.vocab_size)\\n self.regularizer_layer = Regularization(self.args)\\n\\n self.gamma = tf.placeholder(\\\"float\\\")\\n self.loss = self.factorization_layer()\\n\\n self.batch = tf.Variable(0)\\n self.step = tf.placeholder(\\\"float\\\")\\n \\n self.learning_rate_new = tf.train.polynomial_decay(self.args.initial_learning_rate,\\n self.batch,\\n self.true_step_size,\\n self.args.minimal_learning_rate,\\n self.args.annealing_factor)\\n \\n self.train_op = tf.train.AdamOptimizer(self.learning_rate_new).minimize(self.loss, global_step = self.batch)\\n \\n self.init = tf.global_variables_initializer()\\n\\n self.weights = overlap_generator(self.args, self.graph)\",\n \"def convert_roipooling(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n\\n pooled_shape = convert_string_to_list(attrs.get('pooled_size'))\\n scale = float(attrs.get(\\\"spatial_scale\\\"))\\n\\n node = onnx.helper.make_node(\\n 'MaxRoiPool',\\n input_nodes,\\n [name],\\n pooled_shape=pooled_shape,\\n spatial_scale=scale,\\n name=name\\n )\\n return [node]\",\n \"def build_control_outputs(graph):\\n ops = graph.get_operations()\\n control_outputs = {}\\n for op in ops:\\n for cin in op.control_inputs:\\n if cin in control_outputs:\\n control_outputs[cin] |= {op}\\n else:\\n control_outputs[cin] = {op}\\n return control_outputs\",\n \"def finalize(self, *args, **kwargs):\\n self._add_all_odes_to_interface()\\n self._transform_derivatives_on_rhs()\\n super(InterfaceGenerator, self).finalize(*args, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58436275","0.54256326","0.53823584","0.5308641","0.5279758","0.5254585","0.5193188","0.51130235","0.5092685","0.50865275","0.5085475","0.50561804","0.504065","0.500407","0.4975025","0.49684238","0.49679667","0.49663618","0.49435312","0.49369988","0.49361515","0.49355173","0.49322543","0.49223512","0.49175957","0.49173194","0.491661","0.4903675","0.49003312","0.48992857","0.489426","0.48881122","0.4885929","0.4883598","0.48337263","0.48231208","0.48147625","0.48091993","0.48090434","0.48071307","0.47958457","0.47900188","0.47801125","0.47778293","0.4777765","0.47680247","0.47590056","0.47499958","0.47401226","0.4739164","0.47378477","0.47366646","0.47330853","0.4732535","0.47278565","0.47182605","0.47140598","0.47030312","0.4692147","0.46917754","0.46860197","0.46799773","0.4675562","0.46709022","0.46693265","0.46667838","0.4658569","0.4650889","0.4649713","0.46493277","0.46337464","0.4633453","0.46277365","0.46258596","0.46223855","0.4621401","0.46156836","0.4615563","0.4613193","0.46129128","0.46095183","0.46069726","0.4602695","0.46011046","0.4600963","0.4598581","0.45936102","0.458449","0.458434","0.4582","0.45807135","0.4578621","0.4577753","0.45702136","0.4567712","0.45654798","0.45585412","0.45523262","0.45482188","0.454593","0.45453256"],"string":"[\n \"0.58436275\",\n \"0.54256326\",\n \"0.53823584\",\n \"0.5308641\",\n \"0.5279758\",\n \"0.5254585\",\n \"0.5193188\",\n \"0.51130235\",\n \"0.5092685\",\n \"0.50865275\",\n \"0.5085475\",\n \"0.50561804\",\n \"0.504065\",\n \"0.500407\",\n \"0.4975025\",\n \"0.49684238\",\n \"0.49679667\",\n \"0.49663618\",\n \"0.49435312\",\n \"0.49369988\",\n \"0.49361515\",\n \"0.49355173\",\n \"0.49322543\",\n \"0.49223512\",\n \"0.49175957\",\n \"0.49173194\",\n \"0.491661\",\n \"0.4903675\",\n \"0.49003312\",\n \"0.48992857\",\n \"0.489426\",\n \"0.48881122\",\n \"0.4885929\",\n \"0.4883598\",\n \"0.48337263\",\n \"0.48231208\",\n \"0.48147625\",\n \"0.48091993\",\n \"0.48090434\",\n \"0.48071307\",\n \"0.47958457\",\n \"0.47900188\",\n \"0.47801125\",\n \"0.47778293\",\n \"0.4777765\",\n \"0.47680247\",\n \"0.47590056\",\n \"0.47499958\",\n \"0.47401226\",\n \"0.4739164\",\n \"0.47378477\",\n \"0.47366646\",\n \"0.47330853\",\n \"0.4732535\",\n \"0.47278565\",\n \"0.47182605\",\n \"0.47140598\",\n \"0.47030312\",\n \"0.4692147\",\n \"0.46917754\",\n \"0.46860197\",\n \"0.46799773\",\n \"0.4675562\",\n \"0.46709022\",\n \"0.46693265\",\n \"0.46667838\",\n \"0.4658569\",\n \"0.4650889\",\n \"0.4649713\",\n \"0.46493277\",\n \"0.46337464\",\n \"0.4633453\",\n \"0.46277365\",\n \"0.46258596\",\n \"0.46223855\",\n \"0.4621401\",\n \"0.46156836\",\n \"0.4615563\",\n \"0.4613193\",\n \"0.46129128\",\n \"0.46095183\",\n \"0.46069726\",\n \"0.4602695\",\n \"0.46011046\",\n \"0.4600963\",\n \"0.4598581\",\n \"0.45936102\",\n \"0.458449\",\n \"0.458434\",\n \"0.4582\",\n \"0.45807135\",\n \"0.4578621\",\n \"0.4577753\",\n \"0.45702136\",\n \"0.4567712\",\n \"0.45654798\",\n \"0.45585412\",\n \"0.45523262\",\n \"0.45482188\",\n \"0.454593\",\n \"0.45453256\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83788,"cells":{"query":{"kind":"string","value":"Entropy Calibrator collects operators' tensors as well as generates tensor histogram for each operator."},"document":{"kind":"string","value":"def collect_data(self, data_reader: CalibrationDataReader):\n while True:\n inputs = data_reader.get_next()\n if not inputs:\n break\n self.intermediate_outputs.append(self.infer_session.run(None, inputs))\n\n if len(self.intermediate_outputs) == 0:\n raise ValueError(\"No data is collected.\")\n\n output_names = [self.infer_session.get_outputs()[i].name for i in range(len(self.intermediate_outputs[0]))]\n output_dicts_list = [\n dict(zip(output_names, intermediate_output)) for intermediate_output in self.intermediate_outputs\n ]\n\n merged_dict = {}\n for d in output_dicts_list:\n for k, v in d.items():\n merged_dict.setdefault(k, []).append(v)\n\n clean_merged_dict = {i: merged_dict[i] for i in merged_dict if i in self.tensors_to_calibrate}\n\n if not self.collector:\n self.collector = HistogramCollector(\n method=self.method,\n symmetric=self.symmetric,\n num_bins=self.num_bins,\n num_quantized_bins=self.num_quantized_bins,\n percentile=self.percentile,\n scenario=self.scenario,\n )\n self.collector.collect(clean_merged_dict)\n\n self.clear_collected_data()"},"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 entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def _make_histogram_ops(self, model):\n # only make histogram summary op if it hasn't already been made\n if self.histogram_freq and self.merged is None:\n for weight in self.model.trainable_variables:\n mapped_weight_name = weight.name.replace(\":\", \"_\")\n tf_summary.histogram(mapped_weight_name, weight)\n if self.write_images:\n w_img = array_ops.squeeze(weight)\n shape = K.int_shape(w_img)\n if len(shape) == 2: # dense layer kernel case\n if shape[0] > shape[1]:\n w_img = array_ops.transpose(w_img)\n shape = K.int_shape(w_img)\n w_img = array_ops.reshape(w_img, [1, shape[0], shape[1], 1])\n elif len(shape) == 3: # convnet case\n if K.image_data_format() == \"channels_last\":\n # switch to channels_first to display\n # every kernel as a separate image\n w_img = array_ops.transpose(w_img, perm=[2, 0, 1])\n shape = K.int_shape(w_img)\n w_img = array_ops.reshape(w_img, [shape[0], shape[1], shape[2], 1])\n elif len(shape) == 1: # bias case\n w_img = array_ops.reshape(w_img, [1, shape[0], 1, 1])\n else:\n # not possible to handle 3D convnets etc.\n continue\n\n shape = K.int_shape(w_img)\n assert len(shape) == 4 and shape[-1] in [1, 3, 4]\n tf_summary.image(mapped_weight_name, w_img)\n\n if self.write_grads:\n for weight in model.trainable_weights:\n mapped_weight_name = weight.name.replace(\":\", \"_\")\n grads = model.optimizer.get_gradients(model.total_loss, weight)\n\n def is_indexed_slices(grad):\n return type(grad).__name__ == \"IndexedSlices\"\n\n grads = [grad.values if is_indexed_slices(grad) else grad for grad in grads]\n tf_summary.histogram(\"{}_grad\".format(mapped_weight_name), grads)","def _compute_statistics(self):\n # log to file\n output_dir = self.params['output_dir']\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n output_dir = os.path.join(output_dir, 'statistics.log')\n log = logging.getLogger('tensorflow')\n handle = logging.FileHandler(output_dir)\n log.addHandler(handle)\n\n # FLOPS\n encoder_flops, decoder_flops = 0, 0\n encoder_count, decoder_count = 0, 0\n graph = tf.get_default_graph()\n for operation in graph.get_operations():\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\n 'flops').value\n if flops is None:\n continue\n if operation.name.startswith('model/encoder'):\n # encoder\n encoder_flops += flops\n encoder_count += 1\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\n elif operation.name.startswith('model/decoder'):\n # decoder\n decoder_flops += flops\n decoder_count += 1\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\n else:\n # gradient\n pass\n tf.logging.info('flops of %d encoder tensor: %d',\n encoder_count, encoder_flops)\n tf.logging.info('flops of %d decoder tensor: %d',\n decoder_count, decoder_flops)\n tf.logging.info('flops of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_flops + decoder_flops)\n # parameters\n encoder_parameters, decoder_parameters = 0, 0\n encoder_count, decoder_count = 0, 0\n for var in tf.trainable_variables():\n parameters = np.prod(var.get_shape().as_list())\n if var.name.startswith('model/encoder'):\n # encoder\n encoder_parameters += parameters\n encoder_count += 1\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\n elif var.name.startswith('model/decoder'):\n # decoder\n decoder_parameters += parameters\n decoder_count += 1\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\n\n tf.logging.info('parameters of %d encoder tensor: %d',\n encoder_count, encoder_parameters)\n tf.logging.info('parameters of %d decoder tensor: %d',\n decoder_count, decoder_parameters)\n tf.logging.info('parameters of total %d tensor: %d',\n encoder_count + decoder_count,\n encoder_parameters + decoder_parameters)\n # disable log to file\n log.removeHandler(handle)","def get_fused_operator_statistics(self):\n op_count = {}\n ops = [\n \"Attention\",\n \"MultiHeadAttention\",\n \"LayerNormalization\",\n \"SkipLayerNormalization\",\n \"BiasSplitGelu\",\n \"GroupNorm\",\n \"NhwcConv\",\n \"BiasAdd\",\n ]\n for op in ops:\n nodes = self.get_nodes_by_op_type(op)\n op_count[op] = len(nodes)\n\n logger.info(f\"Optimized operators:{op_count}\")\n return op_count","def __init__(self):\n super(MetricCrossEntropy, self).__init__()","def __call__(self, pred_texture: Image.Image, gt_texture: Image.Image) -> float:\n from plan2scene.evaluation.metric_impl.freq_hist import compute_freq_hist_l1\n return compute_freq_hist_l1(pred=pred_texture, gt=gt_texture)","def compute_entropy(bincounts, include_zeros):\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\n if not include_zeros:\n bincounts = bincounts[1:]\n mask = tf.greater(bincounts, 0)\n nonzero_bincounts = tf.cast(\n tf.boolean_mask(bincounts, mask), tf.float64)\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\n log_nonzero_bincounts)\n entropy = tf.math.reduce_sum(\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\n return entropy * num_nonzero / num_total","def entropy_loss_for_all_arguments(policy_logits, masks):\n\n index_list = ['action_type', 'delay', 'queue', 'units', 'target_unit', 'target_location']\n masks = torch.tensor(masks, device=device)\n\n entropy_list = []\n for x in index_list:\n if x == \"delay\":\n continue\n if x == \"queue\":\n continue\n if x == \"target_unit\":\n continue \n if (not P.use_raw_action) and x == \"units\":\n continue\n\n logits = getattr(policy_logits, x) \n\n print(\"x name:\", x) if debug else None\n print(\"logits.shape:\", logits.shape) if debug else None\n\n if x == \"target_unit\":\n # remove the axis 2\n logits = logits.squeeze(dim=1)\n\n print(\"logits.shape:\", logits.shape) if debug else None\n\n logits = logits.reshape(AHP.batch_size, AHP.sequence_length, *tuple(logits.shape[1:]))\n print(\"logits.shape:\", logits.shape) if debug else None\n logits = logits.transpose(0, 1)\n print(\"logits.shape:\", logits.shape) if debug else None\n\n # shape to be [seq_batch_size, channel_size]\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size, *tuple(logits.shape[2:]))\n print(\"logits.shape:\", logits.shape) if debug else None\n\n if x == \"units\":\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size * AHP.max_selected, AHP.max_entities)\n if x == \"target_location\":\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size, SCHP.world_size * SCHP.world_size)\n print(\"logits.shape:\", logits.shape) if debug else None\n\n i = index_list.index(x)\n\n # shape to be [seq_size, batch_size, 1]\n mask = masks[:, :, i]\n\n # shape to be [seq_batch_size, 1]\n mask = mask.reshape(-1, 1)\n if x == \"units\":\n mask = [mask] * AHP.max_selected\n mask = torch.cat(mask, dim=0)\n print(\"mask.shape:\", mask.shape) if debug else None\n\n entropy_item = entropy(logits, mask)\n\n print(\"entropy_item:\", entropy_item) if debug else None\n\n entropy_list.append(entropy_item)\n\n return torch.mean(torch.cat(entropy_list, axis=0))","def build_summary(self):\n for k, v in self.metrics.items():\n tf.summary.scalar(k, v)\n \n self.summary_op = tf.summary.merge_all()","def log_output_data(self):\r\n with tf.name_scope('model_output'):\r\n for i in range(self.action_handler.get_number_actions()):\r\n variable_name = str(self.action_handler.action_list_names[i])\r\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])","def compute_policy_entropy(available_actions, policy, actions):\n _,arg_ids = actions\n\n fn_pi, arg_pis = policy\n fn_pi = mask_unavailable_actions(available_actions, fn_pi)\n entropy = tf.reduce_mean(compute_entropy(fn_pi))\n tf.summary.scalar('entropy/fn', entropy)\n\n for arg_type in arg_ids.keys():\n arg_id = arg_ids[arg_type]\n arg_pi = arg_pis[arg_type]\n batch_mask = tf.to_float(tf.not_equal(arg_id, -1))\n arg_entropy = safe_div(\n tf.reduce_sum(compute_entropy(arg_pi) * batch_mask),\n tf.reduce_sum(batch_mask))\n entropy += arg_entropy\n tf.summary.scalar('used/arg/%s' % arg_type.name,\n tf.reduce_mean(batch_mask))\n tf.summary.scalar('entropy/arg/%s' % arg_type.name, arg_entropy)\n\n return entropy","def _init_actor_update(self):\n\n actions = self._policy.actions([self._observations_ph])\n log_pis = self._policy.log_pis([self._observations_ph], actions)\n\n assert log_pis.shape.as_list() == [None, 1]\n\n log_alpha = self._log_alpha = tf.get_variable(\n 'log_alpha',\n dtype=tf.float32,\n initializer=0.0)\n alpha = tf.exp(log_alpha)\n\n if isinstance(self._target_entropy, Number):\n alpha_loss = -tf.reduce_mean(\n log_alpha * tf.stop_gradient(log_pis + self._target_entropy))\n\n self._alpha_optimizer = tf.train.AdamOptimizer(\n self._policy_lr, name='alpha_optimizer')\n self._alpha_train_op = self._alpha_optimizer.minimize(\n loss=alpha_loss, var_list=[log_alpha])\n\n self._training_ops.update({\n 'temperature_alpha': self._alpha_train_op\n })\n\n self._alpha = alpha\n\n if self._action_prior == 'normal':\n policy_prior = tf.contrib.distributions.MultivariateNormalDiag(\n loc=tf.zeros(self._action_shape),\n scale_diag=tf.ones(self._action_shape))\n policy_prior_log_probs = policy_prior.log_prob(actions)\n elif self._action_prior == 'uniform':\n policy_prior_log_probs = 0.0\n\n Q_log_targets = tuple(\n Q([self._observations_ph, actions])\n for Q in self._Qs)\n min_Q_log_target = tf.reduce_min(Q_log_targets, axis=0)\n\n if self._reparameterize:\n policy_kl_losses = (\n alpha * log_pis\n - min_Q_log_target\n - policy_prior_log_probs)\n else:\n raise NotImplementedError\n\n assert policy_kl_losses.shape.as_list() == [None, 1]\n\n policy_loss = tf.reduce_mean(policy_kl_losses)\n\n self._policy_optimizer = tf.train.AdamOptimizer(\n learning_rate=self._policy_lr,\n name=\"policy_optimizer\")\n policy_train_op = tf.contrib.layers.optimize_loss(\n policy_loss,\n self.global_step,\n learning_rate=self._policy_lr,\n optimizer=self._policy_optimizer,\n variables=self._policy.trainable_variables,\n increment_global_step=False,\n summaries=(\n \"loss\", \"gradients\", \"gradient_norm\", \"global_gradient_norm\"\n ) if self._tf_summaries else ())\n\n self._training_ops.update({'policy_train_op': policy_train_op})","def get_entropy(distribution, samples):\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\n return entropy","def entropy(data, idxList):\n df = data.loc[idxList]\n counts = df.value_counts().to_numpy()\n counts = counts.reshape(1, -1).astype(np.float32)\n counts /= np.sum(counts)\n log_sum = counts @ np.log2(counts.T)\n return -log_sum[0, 0]","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def entropy(self):\n raise NotImplementedError","def entropy(self):\n\n \"\"\"Gets the first neighbours, which are the first 2*r+1 cells.\"\"\"\n current_neighbours = []\n amount = [0] * self.k ** (2 * self.r + 1)\n for i in range(2 * self.r + 1):\n current_neighbours.append(self.config[self.t, i % self.width])\n\n \"\"\"Calculates the rule and adds one to it's amount. It then removes the\n leftmost cell and adds a cell to the right.\"\"\"\n for i in range(len(self.config[self.t]) - 1):\n rule = 0\n for j in range(len(current_neighbours)):\n rule += int(current_neighbours[j] *\n self.k ** ((2 * self.r + 1) - j - 1))\n amount[len(amount) - 1 - rule] += 1\n current_neighbours.pop(0)\n current_neighbours.append(\n self.config[self.t, (2 * self.r + 1 + i) % self.width])\n\n \"\"\"Calculates the rule for the last neighbourhood.\"\"\"\n rule = 0\n for j in range(len(current_neighbours)):\n rule += int(current_neighbours[j] *\n self.k ** ((2 * self.r + 1) - j - 1))\n amount[len(amount)-1 - rule] += 1\n\n \"\"\"Calculates the Shannon entropy and the the average entropy so far.\"\"\"\n shannon = 0\n for i in range(len(amount)):\n if(amount[i] != 0):\n probability = amount[i] / self.width\n shannon -= probability * np.log2(probability)\n self.average_entropy = (self.average_entropy *\n self.t + shannon) / (self.t + 1)","def _calc_final_dist(_enc_batch_extend_vocab, vocab_dists, attn_dists, p_gens, batch_oov_len, vocab_size, batch_size):\n\n # Multiply vocab dists by p_gen and attention dists by (1-p_gen)\n vocab_dists = [p_gen * dist for (p_gen, dist) in zip(p_gens, vocab_dists)]\n attn_dists = [(1 - p_gen) * dist for (p_gen, dist) in zip(p_gens, attn_dists)]\n\n # Concatenate some zeros to each vocabulary dist, to hold the probabilities for in-article OOV words\n extended_vsize = vocab_size + batch_oov_len # the maximum (over the batch) size of the extended vocabulary\n extra_zeros = tf.zeros((batch_size, batch_oov_len))\n # list length max_dec_steps of shape (batch_size, extended_vsize)\n vocab_dists_extended = [tf.concat(axis=1, values=[dist, extra_zeros]) for dist in vocab_dists]\n\n # Project the values in the attention distributions onto the appropriate entries in the final distributions\n # This means that if a_i = 0.1 and the ith encoder word is w, and w has index 500 in the vocabulary,\n # then we add 0.1 onto the 500th entry of the final distribution\n # This is done for each decoder timestep.\n # This is fiddly; we use tf.scatter_nd to do the projection\n batch_nums = tf.range(0, limit=batch_size) # shape (batch_size)\n batch_nums = tf.expand_dims(batch_nums, 1) # shape (batch_size, 1)\n attn_len = tf.shape(_enc_batch_extend_vocab)[1] # number of states we attend over\n batch_nums = tf.tile(batch_nums, [1, attn_len]) # shape (batch_size, attn_len)\n indices = tf.stack((batch_nums, _enc_batch_extend_vocab), axis=2) # shape (batch_size, enc_t, 2)\n shape = [batch_size, extended_vsize]\n\n # list length max_dec_steps (batch_size, extended_vsize)\n attn_dists_projected = [tf.scatter_nd(indices, copy_dist, shape) for copy_dist in attn_dists]\n\n # Add the vocab distributions and the copy distributions together to get the final distributions\n # final_dists is a list length max_dec_steps; each entry is a tensor shape (batch_size, extended_vsize) giving\n # the final distribution for that decoder timestep\n # Note that for decoder timesteps and examples corresponding to a [PAD] token, this is junk - ignore.\n final_dists = [vocab_dist + copy_dist for (vocab_dist, copy_dist) in\n zip(vocab_dists_extended, attn_dists_projected)]\n\n return final_dists","def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\n confmat = _drop_empty_rows_and_cols(confmat)\n total_occurrences = confmat.sum()\n p_xy_m = confmat / total_occurrences\n p_y = confmat.sum(1) / total_occurrences\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))","def entropy_analysis(data_df):\n seq_list = data_df['sequence'].values.tolist()\n base_set = set([])\n for seq in seq_list:\n base_set.update(set(seq))\n H_list = []\n null_freq_list = []\n STEP = ceil(len(seq_list[0]) / 10)\n for base_idx in range(len(seq_list[0])):\n if base_idx % STEP == 0:\n logging.info('Entropy analysis in progress: {}% completed.'.format(10 * base_idx // STEP))\n H, null_freq = base_entropy_masked(seq_list, base_set, base_idx)\n H_list.append(H,)\n null_freq_list.append(null_freq)\n logging.info('Entropy analysis in progress: DONE.')\n return H_list, null_freq_list","def _Apply(self, c, p):\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\n entropy = tf.reduce_mean(entropy)\n return entropy","def _calc_final_dist(self, vocab_dists, attn_dists):\n\n with tf.variable_scope('final_distribution'):\n vocab_dists = [p_gen * dist for (p_gen,dist) in zip(self.p_gens, vocab_dists)]\n attn_dists = [(1-p_gen) * dist for (p_gen,dist) in zip(self.p_gens, attn_dists)]\n\n # Extend the vocabulary dist with zeros (for OOV words\n extended_vsize = self._vocab.size() + self._max_art_oovs \n extra_zeros = tf.zeros((self._hps.batch_size, self._max_art_oovs))\n # list length max_dec_steps of shape (batch_size, extended_vsize)\n vocab_dists_extended = [tf.concat(axis=1, values=[dist, extra_zeros])\n for dist in vocab_dists]\n\n\n # Project the values in the attention distributions onto the appropriate\n # entries in the final distributions\n batch_nums = tf.range(0, limit=self._hps.batch_size) # shape (batch_size)\n batch_nums = tf.expand_dims(batch_nums, 1) # shape (batch_size, 1)\n\n attn_len = tf.shape(self._enc_batch_extend_vocab)[1] \n batch_nums = tf.tile(batch_nums, [1, attn_len]) # shape (batch_size, attn_len)\n indices = tf.stack( (batch_nums, self._enc_batch_extend_vocab), axis=2) \n shape = [self._hps.batch_size, extended_vsize]\n # indices has shape [batch_size, extended_vsize, 2]\n # sample slice: [[[0, 701], ... ], [[1, 529], ...], [[2, 728], ...]]\n # scatter the distribution among corresponding batches and vocabulary index\n \n\n # list length max_dec_steps (batch_size, extended_vsize)\n attn_dists_projected = [tf.scatter_nd(indices, copy_dist, shape)\n for copy_dist in attn_dists]\n\n # Add a very small epsilon\n def _add_epsilon(dist, epsilon=sys.float_info.epsilon):\n epsilon_mask = tf.ones_like(dist) * epsilon\n return dist + epsilon_mask\n # Add the vocab distributions and the copy distributions together to get\n # the final distributions\n final_dists = [vocab_dist + copy_dist\n for (vocab_dist, copy_dist)\n in zip(vocab_dists_extended, attn_dists_projected)]\n final_dists = [_add_epsilon(dist) for dist in final_dists]\n\n return final_dists","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def collect_powers(operator):\n new_tensors = []\n symbols = {}\n for tensor in operator.tensors:\n if tensor.is_field or tensor.name[0] == \"$\" or tensor.exponent is None:\n new_tensors.append(tensor)\n else:\n # Previusly collected exponent for same base and indices\n prev_exponent = symbols.get((tensor.name, tuple(tensor.indices)), 0)\n \n # The exponents of a product are added\n symbols[(tensor.name, tuple(tensor.indices))] = (\n tensor.exponent + prev_exponent)\n\n # Remove tensors with exponent 0\n new_op = Operator([])\n for (name, inds), exponent in symbols.items():\n if exponent != 0:\n new_op *= power_op(name, exponent, indices=inds)\n \n return new_op * Op(*new_tensors)","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def compute_edge_logits(self):","def entropy(group_counts):\n total = sum(group_counts)\n entro = 0\n for item_count in group_counts:\n entro += item_entropy(item_count, total)\n return entro","def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n logits = args.attribution_model.output2logits(args.forward_output)\n out = torch.distributions.Categorical(logits=logits).entropy()\n if out.ndim > 1:\n out = out.squeeze(-1)\n return out","def get_entropy(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return sum([-(float(label_count[label]) /\n total_count) * np.log2(float(label_count[label]) / total_count)\n for label in label_count.keys()])","def call(self, input):\n for r in range(self.tile_num):\n for c in range(self.tile_num):\n # do frequency conv on each tile\n offset = [[r*self.tile_size+self.tile_size/2, c*self.tile_size+self.tile_size/2] for i in range(BATCHSIZE)]\n input_tile = tf.image.extract_glimpse(input, \n [self.tile_size, self.tile_size],\n offset, centered=False, normalized=False) \n pad_pixels = (self.fft_size - self.tile_size) / 2\n input_tile = tf.image.pad_to_bounding_box(\n input_tile, pad_pixels, pad_pixels, self.fft_size, self.fft_size)\n\n input_tile = tf.transpose(input_tile, perm=[0,3,1,2])\n input_fft = tf.spectral.fft2d(tf.cast(input_tile, tf.complex64))\n output_fft = tf.multiply(self.kernel_freq, input_fft[0,:])\n output_fft_accum = tf.reduce_sum(output_fft, 1)\n output_batch_i = tf.spectral.ifft2d(output_fft_accum)\n bias_expand = tf.expand_dims(tf.expand_dims(self.bias, 1),1)\n output_tile_accum = tf.expand_dims(tf.real(output_batch_i) + bias_expand, 0)\n for b in range(1,BATCHSIZE):\n output_fft = tf.multiply(self.kernel_freq, input_fft[b,:])\n output_fft_accum = tf.reduce_sum(output_fft, 1)\n output_fft_batch_i = tf.spectral.ifft2d(output_fft_accum)\n bias_expand = tf.expand_dims(tf.expand_dims(self.bias, 1),1)\n output_tile_accum = tf.concat([output_tile_accum, \n tf.expand_dims(tf.real(output_fft_batch_i) + bias_expand, 0)],0)\n\n # Concat col tiles\n output_accum_col = output_tile_accum\n if c != 0:\n overlap = output_accum_col[:,:,:,-pad_pixels:] + output_tile_accum[:,:,:,0:pad_pixels]\n output_accum_col = tf.concat([output_accum_col[:,:,:,0:-pad_pixels], \n overlap, \n output_tile_accum[:,:,:,pad_pixels:]], \n 3)\n # Concat tow output tiles\n output_accum = output_accum_col\n if r != 0:\n overlap = output_accum[:,:,-pad_pixels:,:] + output_accum_col[:,:,0:pad_pixels,:]\n output_accum = tf.concat([output_accum[:,:,0:-pad_pixels,:], \n overlap, \n output_accum_col[:,:,pad_pixels:,:]], \n 2)\n\n output_accum = tf.transpose(output_accum, perm=[0,2,3,1])\n return tf.image.crop_to_bounding_box(output_accum, 0, 0, self.img_size, self.img_size)","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def entropy(self, priors=None):\n def entropy_f(x):\n x[x != 0] *= np.log(x[x != 0])\n return -x.sum(axis=0)\n return self.utility(entropy_f, priors)","def entropy(rows, resCol = None):\n from math import log\n if not resCol: #create the dictionary of counts for each class using pure python\n total = len(rows)\n counts = __uniqueCounts(rows)\n else: #Create the dictionary of counts for each class using pandas.\n assert 'index' in dir(rows)\n total = len(rows.index)\n counts = __uniqueCountsPandas(rows, resCol)\n log2 = lambda x:log(x)/log(2) #Create a function to take log-base 2 of a number\n ent = 0 #Initialize the entropy at zero\n #Implement the formula for entropy, using log-base2\n fracs = [float(x)/total for x in counts.values()]\n for x in fracs:\n ent += -x*log2(x)\n return ent","def build_summaries(self):\n\n # Loss summary.\n tf.summary.scalar('loss', self.loss)\n\n merged = tf.summary.merge_all()\n self.summary_op = merged\n tf.logging.info('summary op set')","def build_summaries(self):\n\n # Loss summary.\n tf.summary.scalar('loss', self.loss)\n\n merged = tf.summary.merge_all()\n self.summary_op = merged\n tf.logging.info('summary op set')","def activation_summaries(endpoints):\n sum = []\n with tf.name_scope('summaries'):\n for act in endpoints.values():\n tensor_name = act.op.name\n sum.append(tf.summary.histogram(tensor_name + '/activations', act))\n # sum.append(tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(act)))\n return tf.summary.merge(sum)","def test_entropy_model_learn_normal():\n xs = []\n bs = 128\n bin_ = 0.1\n class CFG:\n pass\n cfg = CFG()\n cfg.MODEL = CFG()\n cfg.MODEL.ENTROPY_MODEL = CFG()\n cfg.MODEL.ENTROPY_MODEL.DIMS = [3,3,3]\n cfg.MODEL.ENTROPY_MODEL.SCALE = 10.\n cfg.MODEL.ENTROPY_MODEL.BIN = bin_\n entropy_model = EntropyModel(in_channels=2, cfg=cfg).cuda()\n entropy_model.train()\n optmizer = torch.optim.AdamW(entropy_model.parameters(), 0.001)\n for _ in tqdm(range(1000)):\n x = torch.cat([torch.randn((bs,1)), torch.randn((bs,1))*5], dim=1)\n xs.append(x.numpy())\n x = x.cuda()\n quantized_x, _, loss = entropy_model(x)\n loss.backward()\n torch.nn.utils.clip_grad_value_(entropy_model.parameters(), 5.)\n optmizer.step()\n optmizer.zero_grad()\n \n xs = np.concatenate(xs).squeeze()\n plt.hist(xs[:,0], bins=100)\n plt.show()\n \n plt.hist(xs[:,1], bins=100)\n plt.show()\n \n with torch.no_grad():\n sample = torch.stack([torch.linspace(-10,10,10001)]*2,dim=1).cuda()\n _, prob, _ = entropy_model(sample)\n plt.plot(sample.cpu().numpy()[:,0], prob.cpu().numpy()[:,0], color=\"r\")\n plt.show()\n plt.plot(sample.cpu().numpy()[:,1], prob.cpu().numpy()[:,1], color=\"g\")\n plt.show()","def entropy(*args):\n\n\n values = []\n leaf = -1\n\n for i, val in enumerate(args):\n if(val != 0):\n values.append(val * math.log(val, len(args)))\n if(val == 1):\n leaf = i\n \n return -sum(values), leaf","def _summary(self):\n trainable_variable = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n for var in trainable_variable:\n tf.summary.histogram(var.op.name, var)\n\n self.merged_summary_op = tf.summary.merge_all()","def _theils_u_compute(confmat: Tensor) ->Tensor:\n confmat = _drop_empty_rows_and_cols(confmat)\n s_xy = _conditional_entropy_compute(confmat)\n total_occurrences = confmat.sum()\n p_x = confmat.sum(0) / total_occurrences\n s_x = -torch.sum(p_x * torch.log(p_x))\n if s_x == 0:\n return torch.tensor(0, device=confmat.device)\n return (s_x - s_xy) / s_x","def BuildSamplerGraph(self):\n # Replace with a Tensor of shape [batch_size, max_time, num_samples = 1]\n self.pred_samples_ = None\n\n #### YOUR CODE HERE ####\n #print(self.logits_.get_shape())\n #print(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]).get_shape())\n #self.pred_samples_ = tf.multinomial(self.logits_, 1, name=\"pred_samples\")\n \n #self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]), \n #1, name=\"pred_samples\")\n #self.pred_samples_ = tf.reshape(self.pred_samples_, [self.batch_size_, self.max_time_, 1])\n \n #self.pred_samples_ = tf.multinomial(self.logits_, self.logits_.get_shape()[-1], name=\"pred_samples\")\n #print(self.pred_samples_.get_shape())\n \n with tf.name_scope(\"sampling_ops\"):\n self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]), \n 1, name=\"pred_samples\")\n self.pred_samples_ = tf.reshape(self.pred_samples_, [self.batch_size_, self.max_time_, 1])\n\n\n\n #### END(YOUR CODE) ####","def entropy_computations(\n self,\n between_labels=True,\n between_images=True,\n between_all_images=False,\n symmetrized=True,\n ):\n jzazbz_dist_dict = self.jzazbz_dist_dict\n\n if between_labels:\n words = self.labels_list\n labels_entropy_dict = {}\n labels_entropy_dict_js = {}\n color_sym_matrix = []\n color_sym_matrix_js = []\n\n for word1 in words:\n row = []\n row_js = []\n for word2 in words:\n entropy_js = js_divergence(\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n np.mean(np.array(jzazbz_dist_dict[word2]), axis=0),\n )\n entropy = kl_divergence(\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\n symmetrized,\n )\n row.append(entropy)\n row_js.append(entropy_js)\n # these lines are for convenience; if strings are correctly synced across all data they are not needed\n if word1 == \"computer science\":\n labels_entropy_dict[\"computer_science\" + \"_\" + word2] = entropy\n labels_entropy_dict_js[\n \"computer_science\" + \"_\" + word2\n ] = entropy_js\n elif word2 == \"computer science\":\n labels_entropy_dict[word1 + \"_\" + \"computer_science\"] = entropy\n labels_entropy_dict_js[\n word1 + \"_\" + \"computer_science\"\n ] = entropy_js\n else:\n labels_entropy_dict[word1 + \"_\" + word2] = entropy\n labels_entropy_dict_js[word1 + \"_\" + word2] = entropy_js\n color_sym_matrix.append(row)\n color_sym_matrix_js.append(row_js)\n\n self.cross_entropy_between_labels_dict = labels_entropy_dict\n self.cross_entropy_between_labels_matrix = color_sym_matrix\n self.cross_entropy_between_labels_dict_js = labels_entropy_dict_js\n self.cross_entropy_between_labels_matrix_js = color_sym_matrix_js\n\n if between_images:\n entropy_dict = {}\n entropy_dict_js = {}\n for key in jzazbz_dist_dict:\n entropy_array = []\n entropy_array_js = []\n for i in range(len(jzazbz_dist_dict[key])):\n for j in range(len(jzazbz_dist_dict[key])):\n entropy_array_js.append(\n js_divergence(\n jzazbz_dist_dict[key][i], jzazbz_dist_dict[key][j]\n )\n )\n entropy_array.append(\n kl_divergence(\n jzazbz_dist_dict[key][i],\n jzazbz_dist_dict[key][j],\n symmetrized,\n )\n )\n entropy_dict[key] = entropy_array\n entropy_dict_js[key] = entropy_array_js\n\n self.cross_entropy_between_images_dict = entropy_dict\n self.cross_entropy_between_images_dict_js = entropy_dict_js\n\n if between_all_images:\n entropy_dict_all = {}\n color_sym_matrix_js_all = []\n\n for word1 in words:\n row_js_all = []\n for word2 in words:\n entropy_js_all = []\n for i in range(len(jzazbz_dist_dict[word1])):\n for j in range(len(jzazbz_dist_dict[word2])):\n try:\n entropy_js_all.append(\n js_divergence(\n jzazbz_dist_dict[word1][i],\n jzazbz_dist_dict[word2][j],\n )\n )\n except Exception as exc:\n self.log.error(exc)\n entropy_js_all.append(np.mean(entropy_js))\n entropy_dict_all[word1 + \"_\" + word2] = entropy_js_all\n row_js_all.append(np.mean(entropy_js_all))\n color_sym_matrix_js_all.append(row_js_all)\n\n self.cross_entropy_between_all_images_dict = entropy_dict_all\n self.cross_entropy_between_all_images_matrix = color_sym_matrix_js_all","def _build_summaries(self):\n max_outputs = 3\n summaries = []\n\n # images\n # ------------------------------------------------\n summary_input_shape = image_utils.get_image_summary_shape(self._input_shape_visualisation)\n\n # input images\n input_summary_reshape = tf.reshape(self._input_values, summary_input_shape, name='input_summary_reshape')\n input_summary_op = tf.summary.image('input_images', input_summary_reshape, max_outputs=max_outputs)\n summaries.append(input_summary_op)\n\n # degraded, target and completed images, and histograms where relevant\n target = self._dual.get_op('target')\n degraded = self._dual.get_op('degraded')\n decoding_op = self.get_decoding_op()\n\n output_hist = tf.summary.histogram(\"output\", decoding_op)\n summaries.append(output_hist)\n\n input_hist = tf.summary.histogram(\"input\", self._input_values)\n summaries.append(input_hist)\n\n # network output when presented with blank\n blank_output_first = self._dual.get_op('blank_output_first')\n blank_first = tf.summary.image('blank_first', tf.reshape(blank_output_first, summary_input_shape))\n summaries.append(blank_first)\n\n blank_output_last = self._dual.get_op('blank_output_last')\n blank_last = tf.summary.image('blank_last', tf.reshape(blank_output_last, summary_input_shape))\n summaries.append(blank_last)\n \n with tf.name_scope('optimize'):\n completed_summary_reshape = tf.reshape(decoding_op, summary_input_shape, 'completed_summary_reshape')\n summaries.append(tf.summary.image('b_completed', completed_summary_reshape))\n\n if self._hparams.bt_degrade:\n degraded_summary_reshape = tf.reshape(degraded, summary_input_shape, 'degraded_summary_reshape')\n summaries.append(tf.summary.image('a_degraded', degraded_summary_reshape))\n\n target_summary_reshape = tf.reshape(target, summary_input_shape, 'target_summary_reshape')\n summaries.append(tf.summary.image('c_target', target_summary_reshape))\n\n # display slow weights as images and distributions\n with tf.name_scope('slow-weights'):\n w = self._dual.get_op('w')\n add_square_as_square(summaries, w, 'w')\n\n w_hist = tf.summary.histogram(\"w\", w)\n summaries.append(w_hist)\n\n alpha = self._dual.get_op('alpha')\n add_square_as_square(summaries, alpha, 'alpha')\n\n alpha_hist = tf.summary.histogram(\"alpha\", alpha)\n summaries.append(alpha_hist)\n\n if self._hparams.bias:\n bias = self._dual.get_op('bias')\n bias_image_shape, _ = image_utils.square_image_shape_from_1d(self._hparams.filters)\n bias_image = tf.reshape(bias, bias_image_shape, name='bias_summary_reshape')\n summaries.append(tf.summary.image('bias', bias_image))\n\n bias_hist = tf.summary.histogram(\"bias\", bias)\n summaries.append(bias_hist)\n\n # eta\n eta_op = self._dual.get_op('eta')\n eta_scalar = tf.reduce_sum(eta_op)\n eta_summary = tf.summary.scalar('eta', eta_scalar)\n summaries.append(eta_summary)\n\n # x_shift\n x_shift_op = self._dual.get_op('x_shift')\n xs_scalar = tf.reduce_sum(x_shift_op)\n xs_summary = tf.summary.scalar('x_shift', xs_scalar)\n summaries.append(xs_summary)\n\n # display fast weights (eta and hebbian), as image, scalars and histogram\n with tf.name_scope('fast-weights'):\n\n # as images\n hebb = self._dual.get_op('hebb')\n add_square_as_square(summaries, hebb, 'hebb')\n\n # as scalars\n hebb_summary = tf_build_stats_summaries_short(hebb, 'hebb')\n summaries.append(hebb_summary)\n\n # as histograms\n hebb_hist = tf.summary.histogram(\"hebb\", hebb)\n summaries.append(hebb_hist)\n\n hebb_per_neuron = tf.reduce_sum(tf.abs(hebb), 0)\n hebb_per_neuron = tf.summary.histogram('hebb_pn', hebb_per_neuron)\n summaries.append(hebb_per_neuron)\n\n # outer products\n outer_first = self._dual.get_op('outer_first')\n outer_last = self._dual.get_op('outer_last')\n add_square_as_square(summaries, outer_first, 'outer_first')\n add_square_as_square(summaries, outer_last, 'outer_last')\n\n # optimization related quantities\n with tf.name_scope('optimize'):\n # loss\n loss_op = self.get_loss_op()\n loss_summary = tf.summary.scalar('loss', loss_op)\n summaries.append(loss_summary)\n\n # losses as an image\n losses = self._dual.get_op(\"losses\")\n shape = losses.get_shape().as_list()\n volume = np.prod(shape[1:])\n losses_image_shape, _ = image_utils.square_image_shape_from_1d(volume)\n losses_image = tf.reshape(losses, losses_image_shape)\n summaries.append(tf.summary.image('losses', losses_image))\n\n input_stats_summary = tf_build_stats_summaries_short(self._input_values, 'input-stats')\n summaries.append(input_stats_summary)\n\n return summaries","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def scalar():\n # setup\n # ---\n print(\"Loading data...\")\n train_y_cpu, train_x_cpu = dataio.bin_to_tensors(constants.TRAIN_BIAS)\n val_y_cpu, val_x_cpu = dataio.bin_to_tensors(constants.VAL_BIAS)\n\n print(\"Moving data to GPU...\")\n train_y = train_y_cpu.type(IntTT)\n train_x = train_x_cpu.type(FloatTT)\n val_y = val_y_cpu.type(IntTT)\n val_x = val_x_cpu.type(FloatTT)\n\n print(\"Starting experiments...\")\n dummy = 0.0\n\n # OLS\n # ---\n\n # OLS analytic solution. uses CPU tensors to go to/from numpy for pseudoinverse.\n w = ols_analytic(train_x_cpu, train_y_cpu)\n loss_ols = ols_loss(w, train_x, train_y.type(FloatTT))\n report(\n \"[scalar] OLS analytic (train)\",\n w,\n train_x,\n train_y,\n dummy,\n scalar_eval,\n ols_loss,\n )\n report(\"[scalar] OLS analytic (val)\", w, val_x, val_y, dummy, scalar_eval, ols_loss)\n\n # plot of ols accuracy\n _, _, ols_acc = accuracy(val_x, val_y, w, scalar_eval)\n viewer.plot_bar(\n torch.FloatTensor([ols_acc, 0.0]),\n [\"OLS\"],\n \"Validation Accuracy\",\n dict(ytickmin=0.0, ytickmax=100.0, xtickvals=[1], xticklabels=[\"OLS\"]),\n )\n return\n\n # OLS gradient descent\n ols_gd_settings: GDSettings = {\"lr\": 0.02, \"epochs\": 1500, \"report_interval\": 10}\n w, record = gradient_descent(\n train_x, train_y, -1, ols_loss, ols_gradient, ols_gd_settings\n )\n report(\"[scalar] OLS GD (train)\", w, train_x, train_y, dummy, scalar_eval, ols_loss)\n report(\"[scalar] OLS GD (val)\", w, val_x, val_y, dummy, scalar_eval, ols_loss)\n\n # plot OLS GD\n xs = torch.FloatTensor(sorted(list(record.keys())))\n viewer.plot_line(\n xs,\n torch.stack(\n [\n torch.FloatTensor(torch.ones(len(xs)) * loss_ols),\n torch.FloatTensor([record[k] for k in sorted(list(record.keys()))]),\n ]\n ),\n [\"Analytic\", \"Gradient descent\"],\n \"OLS Gradient Descent\",\n dict(xlabel=\"GD steps (epochs)\", ylabel=\"Loss\", ytype=\"log\"),\n )\n\n # OLS coordinate descent\n w, record = coordinate_descent(\n train_x,\n train_y,\n dummy,\n ols_cd_weight_update,\n ols_loss,\n {\"epochs\": 150, \"report_interval\": 10},\n )\n report(\n \"[scalar] Coordinate descent (train)\",\n w,\n train_x,\n train_y,\n dummy,\n scalar_eval,\n ols_loss,\n )\n report(\n \"[scalar] Coordinate descent (val)\",\n w,\n val_x,\n val_y,\n dummy,\n scalar_eval,\n ols_loss,\n )\n\n # plot OLS CD\n xs = torch.FloatTensor(sorted(list(record.keys())))\n viewer.plot_line(\n xs,\n torch.stack(\n [\n torch.FloatTensor(torch.ones(len(xs)) * loss_ols),\n torch.FloatTensor([record[k] for k in sorted(list(record.keys()))]),\n ]\n ),\n [\"Analytic\", \"Coordinate descent\"],\n \"OLS Coordinate Descent\",\n dict(xlabel=\"CD epochs\", ylabel=\"Loss\", ytype=\"log\"),\n )\n\n # ridge\n # ---\n\n # ridge analytic solution\n for lmb in [0.2]:\n w = ridge_analytic(train_x, train_y, lmb)\n # code.interact(local=dict(globals(), **locals()))\n report(\n \"[scalar] Ridge analytic (train) lambda={}\".format(lmb),\n w,\n train_x,\n train_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n report(\n \"[scalar] Ridge analytic (val) lambda={}\".format(lmb),\n w,\n val_x,\n val_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n\n # ridge GD\n ridge_gd_settings: GDSettings = {\"lr\": 0.02, \"epochs\": 500, \"report_interval\": 100}\n for lmb in [0.2]:\n w, record = gradient_descent(\n train_x, train_y, lmb, ridge_loss, ridge_gradient, ridge_gd_settings\n )\n report(\n \"[scalar] Ridge GD (train) lambda={}\".format(lmb),\n w,\n train_x,\n train_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n report(\n \"[scalar] Ridge GD (val) lambda={}\".format(lmb),\n w,\n val_x,\n val_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n\n # ridge CD\n ridge_cd_settings: CDSettings = {\"epochs\": 150, \"report_interval\": 10}\n for lmb in [0.2]:\n w, record = coordinate_descent(\n train_x, train_y, lmb, ridge_cd_weight_update, ridge_loss, ridge_cd_settings\n )\n report(\n \"[scalar] Ridge CD (train) lambda={}\".format(lmb),\n w,\n train_x,\n train_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n report(\n \"[scalar] Ridge CD (val) lambda={}\".format(lmb),\n w,\n val_x,\n val_y,\n lmb,\n scalar_eval,\n ridge_loss,\n )\n\n # lasso GD\n lasso_gd_settings: GDSettings = {\"lr\": 0.02, \"epochs\": 1000, \"report_interval\": 100}\n for lmb in [0.2]:\n w, record = gradient_descent(\n train_x, train_y, lmb, lasso_loss, lasso_gradient, lasso_gd_settings\n )\n report(\n \"[scalar] Lasso GD (train) lambda={}\".format(lmb),\n w,\n train_x,\n train_y,\n lmb,\n scalar_eval,\n lasso_loss,\n )\n report(\n \"[scalar] Lasso GD (val) lambda={}\".format(lmb),\n w,\n val_x,\n val_y,\n lmb,\n scalar_eval,\n lasso_loss,\n )\n\n # lasso CD\n lasso_cd_settings: CDSettings = {\"epochs\": 100, \"report_interval\": 10}\n for lmb in [0.2]:\n w, record = coordinate_descent(\n train_x, train_y, lmb, lasso_cd_weight_update, lasso_loss, lasso_cd_settings\n )\n report(\n \"[scalar] Lasso CD (train) lambda={}\".format(lmb),\n w,\n train_x,\n train_y,\n lmb,\n scalar_eval,\n lasso_loss,\n )\n report(\n \"[scalar] Lasso CD (val) lambda={}\".format(lmb),\n w,\n val_x,\n val_y,\n lmb,\n scalar_eval,\n lasso_loss,\n )","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def get_entropy(*labels):\n entropies = [] #list of entropy values from each subset\n total = 0 #total number of datapoints\n for subset in labels:\n n = len(subset)\n total += n\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\n entropies.append((entropy, n))\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])","def entropy(p):\n ent = tf.where(p > np.finfo(np.float32).eps, -p * tf.log(p), tf.zeros_like(p))\n ent = tf.reduce_sum(ent, axis=1)\n return ent","def entropy(data):\n n, m = np.shape(data)\n data = np.tanh(data)\n data = data / np.sum(data, axis=0)\n a = data * 1.0\n a[np.where(data == 0)] = 0.000001\n\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\n w = (1 - e) / np.sum(1 - e)\n return w","def BuildSamplerGraph(self):\n # return a Tensor of shape [batch_size, max_time, 1]\n #self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [1, VOCAB_SIZE]), num_samples=1)\n self.pred_samples_ = tf.argmax(tf.reshape(self.logits_, [VOCAB_SIZE]), tf.constant(0))\n self.pred_samples_ = tf.reshape(self.pred_samples_, [1])","def _activation_summary(x):\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n tf.summary.histogram(tensor_name + '/activations', x)\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))","def _build(self):\n self.autoencoder = autoencoder(\n images = self.images,\n name = 'autoencoder')\n # self.hash = self.autoencoder.hash\n self.z = tf.placeholder(tf.float32, shape = [None, CODEWORD_LENGTH], \n name = 'z-layer') \n with tf.variable_scope('latent_space') as scope:\n for i in range(CODEWORD_LENGTH):\n tf.summary.histogram('z_' + str(i) ,self.z[:,i]) \n tf.summary.histogram('codeword_' + str(i), self.autoencoder.codeword[:,i])\n self.generator = gan_generator( z = self.z,\n input_params = self.autoencoder.params,\n name = 'gan_generator')\n self.discriminator = gan_discriminator ( images = self.images,\n generation = self.generator.generation,\n name = 'gan_discriminator' )\n self.generator.cook(fake = self.discriminator.fake)\n mean_z, var_z = tf.nn.moments(self.z, axes=[0])\n mean_codeword, var_codeword = tf.nn.moments(self.autoencoder.codeword, axes = [0])\n\n with tf.variable_scope ('divergence') as scope:\n tf.summary.scalar( tensor = tf.nn.l2_loss(mean_z-mean_codeword), name = 'mean divergence')\n tf.summary.scalar( tensor = tf.nn.l2_loss(var_z-var_codeword), name = 'variance divergence')\n # divergence = self.hash ","def update_state(self, logits, labels):\n labels = labels.unsqueeze(dim=1) #.cuda() # N,1,H,W\n predictions = logits.max(axis=1)[1].unsqueeze(dim=1) #.cuda() # N,1,H,W\n preds_1hot = torch.zeros_like(logits, dtype=bool).scatter_(1, predictions, True)#.cuda()\n labels_1hot = torch.zeros_like(logits, dtype=bool).scatter_(1, labels, True)#.cuda()\n\n if self.debug:\n if torch.cuda.is_available():\n for t in ['labels','preditions','preds_1hot','labels_1hot']:\n assert t.is_cuda\n assert logits.shape[0] == labels.shape[0]\n assert logits.shape == preds_1hot.shape\n assert logits.shape[1] >= labels.max()\n assert preds_1hot.shape == labels_1hot.shape\n assert preds_1hot.max() == labels_1hot.max() == 1\n assert preds_1hot.min() == labels_1hot.min() == 0\n assert preds_1hot.sum() == labels_1hot.sum() == logits.shape[0]*logits.shape[2]* logits.shape[3]\n\n self.tensors['TP'] += torch.sum(preds_1hot & labels_1hot , dim=(0, 2, 3)).double() # casting to double required for Cuda 10.0, not required for Cuda 10.1\n self.tensors['TN'] += torch.sum(~ preds_1hot & ~ labels_1hot , dim=(0, 2, 3)).double()\n self.tensors['FP'] += torch.sum(preds_1hot & ~ labels_1hot, dim=(0, 2, 3)).double()\n self.tensors['FN'] += torch.sum(~ preds_1hot & labels_1hot, dim=(0, 2, 3)).double()\n self.tensors['PX_CNT'] += torch.sum(labels_1hot , dim=(0, 2, 3)).double()\n self.tensors['samples_evaluated'] += logits.shape[0]\n \n if self.debug:\n if torch.cuda.is_available():\n for t in self.tensors: assert self.tensors[t].is_cuda","def entropycell(self):\n cells = [0] * self.k\n for i in range(self.width):\n cells[int(self.config[self.t, i])] += 1\n\n \"\"\"Calculates the Shannon entropy and the the average entropy so far.\"\"\"\n shannon = 0\n for i in range(self.k):\n if(cells[i] != 0):\n probability = cells[i] / self.width\n shannon -= probability * np.log2(probability)\n self.average_cell = (self.average_cell * self.t + shannon) / (self.t + 1)","def main():\n # lr_decay = 0.5\n # decay_every = 100\n args = get_arguments()\n \n h, w = map(int, args.input_size.split(','))\n input_size = (h, w)\n \n tf.set_random_seed(args.random_seed)\n \n coord = tf.train.Coordinator()\n \n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(\n args.data_list,\n input_size,\n args.random_scale,\n args.random_mirror,\n args.ignore_label,\n IMG_MEAN,\n coord)\n image_batch, label_batch = reader.dequeue(args.batch_size)\n \n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n # config.gpu_options.allow_growth = True\n # config.allow_soft_placement = True\n # config.intra_op_parallelism_threads = 1\n sess = tf.Session(config = config)\n net = unext(image_batch, is_train = True, reuse = False, n_out = NUM_CLASSES)\n \n # Predictions: ignoring all predictions with labels greater or equal than n_classes\n raw_output = net.outputs\n raw_prediction = tf.reshape(raw_output, [-1, args.num_classes])\n label_proc = prepare_label(label_batch, tf.stack(raw_output.get_shape()[1:3]), num_classes=args.num_classes, one_hot=False) # [batch_size, h, w]\n raw_gt = tf.reshape(label_proc, [-1,])\n indices = tf.squeeze(tf.where(tf.less_equal(raw_gt, args.num_classes - 1)), 1)\n gt = tf.cast(tf.gather(raw_gt, indices), dtype = tf.int32)\n prediction = tf.gather(raw_prediction, indices)\n \n main_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = prediction, labels = gt)\n\n t_vars = tf.trainable_variables()\n l2_losses = [args.weight_decay * tf.nn.l2_loss(v) for v in t_vars if 'kernel' in v.name]\n #reduced_loss = 0.5 * tf.reduce_mean(main_loss) + generalised_dice_loss(prediction, gt) + tf.add_n(l2_losses)\n reduced_loss = tf.reduce_mean(main_loss) + tf.add_n(l2_losses)\n\n # Processed predictions: for visualisation.\n raw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\n raw_output_up = tf.argmax(raw_output_up, dimension = 3)\n pred = tf.expand_dims(raw_output_up, dim = 3)\n \n # Image summary.\n images_summary = tf.py_func(inv_preprocess, [image_batch, args.save_num_images, IMG_MEAN], tf.uint8)\n labels_summary = tf.py_func(decode_labels, [label_batch, args.save_num_images, args.num_classes], tf.uint8)\n preds_summary = tf.py_func(decode_labels, [pred, args.save_num_images, args.num_classes], tf.uint8)\n \n total_summary = tf.summary.image('images', \n tf.concat(axis=2, values=[images_summary, labels_summary, preds_summary]), \n max_outputs=args.save_num_images) # Concatenate row-wise.\n loss_summary = tf.summary.scalar('TotalLoss', reduced_loss)\n summary_writer = tf.summary.FileWriter(args.snapshot_dir,\n graph=tf.get_default_graph())\n\n # Using Poly learning rate policy \n base_lr = tf.constant(args.learning_rate)\n step_ph = tf.placeholder(dtype=tf.float32, shape=())\n learning_rate = tf.train.exponential_decay(base_lr, step_ph, args.num_steps, args.power)\n\n lr_summary = tf.summary.scalar('LearningRate', learning_rate)\n #train_op = tf.train.MomentumOptimizer(learning_rate, args.momentum).minimize(reduced_loss, var_list = t_vars)\n train_op = tf.train.AdamOptimizer(learning_rate).minimize(reduced_loss, var_list = t_vars)\n init = tf.global_variables_initializer()\n sess.run(init)\n \n # Saver for storing checkpoints of the model.\n saver = tf.train.Saver(var_list = tf.global_variables(), max_to_keep = 10)\n\n ckpt = tf.train.get_checkpoint_state(SNAPSHOT_DIR)\n if ckpt and ckpt.model_checkpoint_path:\n #restore_vars = list([t for t in tf.global_variables() if not 'uconv1' in t.name])\n loader = tf.train.Saver(var_list = tf.global_variables())\n load_step = int(os.path.basename(ckpt.model_checkpoint_path).split('-')[1])\n load(loader, sess, ckpt.model_checkpoint_path)\n else:\n print('No checkpoint file found.')\n load_step = 0\n\n # Start queue threads.\n threads = tf.train.start_queue_runners(coord = coord, sess = sess)\n\n # Iterate over training steps.\n save_summary_every = 10\n for step in range(args.num_steps):\n start_time = time.time()\n \n feed_dict = {step_ph: step}\n if not step % args.save_pred_every == 0:\n loss_value, _, l_summary, lr_summ = sess.run([reduced_loss, train_op, loss_summary, lr_summary], feed_dict=feed_dict)\n duration = time.time() - start_time\n elif step % args.save_pred_every == 0:\n loss_value, _, summary, l_summary, lr_summ = sess.run([reduced_loss, train_op, total_summary, loss_summary, lr_summary], feed_dict=feed_dict)\n duration = time.time() - start_time\n save(saver, sess, args.snapshot_dir, step)\n summary_writer.add_summary(summary, step)\n\n if step % save_summary_every == 0:\n \n summary_writer.add_summary(l_summary, step)\n summary_writer.add_summary(lr_summ, step)\n \n print('step {:d} \\t loss = {:.3f}, ({:.3f} sec/step)'.format(step, loss_value, duration))\n \n coord.request_stop()\n coord.join(threads)","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def __init__(self, dims, act = 'relu', random_seed = 201809, splitseed = 215, optimizer = Adam(),\n weights_dir = 'CarDEC Count Weights', n_features = 32, mode = 'HVG'):\n \n super(count_model, self).__init__()\n\n tf.keras.backend.clear_session()\n \n self.mode = mode\n self.name_ = mode + \" Count\"\n \n if mode == 'HVG':\n self.embed_name = 'embedding'\n else:\n self.embed_name = 'LVG embedding'\n \n self.weights_dir = weights_dir\n \n self.dims = dims\n n_stacks = len(dims) - 1\n \n self.optimizer = optimizer\n self.random_seed = random_seed\n self.splitseed = splitseed\n \n random.seed(random_seed)\n np.random.seed(random_seed)\n tf.random.set_seed(random_seed)\n \n self.activation = act\n self.MeanAct = lambda x: tf.clip_by_value(tf_exp(x), 1e-5, 1e6)\n self.DispAct = lambda x: tf.clip_by_value(tf.nn.softplus(x), 1e-4, 1e4)\n \n model_layers = []\n for i in range(n_stacks - 1, 0, -1):\n model_layers.append(Dense(dims[i], kernel_initializer = \"glorot_uniform\", activation = self.activation\n , name='base%d' % (i-1)))\n self.base = Sequential(model_layers, name = 'base')\n\n self.mean_layer = Dense(dims[0], activation = self.MeanAct, name='mean')\n self.disp_layer = Dense(dims[0], activation = self.DispAct, name='dispersion')\n\n self.rescale = Lambda(lambda l: tf.matmul(tf.linalg.diag(l[0]), l[1]), name = 'sf scaling')\n \n build_dir(self.weights_dir)\n \n self.construct(n_features, self.name_)","def entropy(probs, name=None):\n with tf.name_scope(name, \"Entropy\", [probs]):\n entropy_matrix = - probs * tf.log(probs)\n entropy_vec = tf.reduce_sum(entropy_matrix, reduction_indices=[1], keep_dims=False)\n return entropy_vec","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def __init__(self, n_actions, hidden=1024, learning_rate=0.00001, \n frame_height=84, frame_width=84, agent_history_length=4):\n self.n_actions = n_actions\n self.hidden = hidden\n self.learning_rate = learning_rate\n self.frame_height = frame_height\n self.frame_width = frame_width\n self.agent_history_length = agent_history_length\n \n self.input = tf.placeholder(shape=[None, self.frame_height, \n self.frame_width, self.agent_history_length], \n dtype=tf.float32)\n # Normalizing the input\n self.input_scaled = self.input/255\n \n # Convolutional layers\n self.conv1 = tf.layers.conv2d(\n inputs=self.input_scaled, filters=32, kernel_size=[8, 8], strides=4,\n kernel_initializer=tf.variance_scaling_initializer(scale=2),\n padding=\"valid\", activation=tf.nn.relu, use_bias=False, name='conv1')\n self.conv2 = tf.layers.conv2d(\n inputs=self.conv1, filters=64, kernel_size=[4, 4], strides=2, \n kernel_initializer=tf.variance_scaling_initializer(scale=2),\n padding=\"valid\", activation=tf.nn.relu, use_bias=False, name='conv2')\n self.conv3 = tf.layers.conv2d(\n inputs=self.conv2, filters=64, kernel_size=[3, 3], strides=1, \n kernel_initializer=tf.variance_scaling_initializer(scale=2),\n padding=\"valid\", activation=tf.nn.relu, use_bias=False, name='conv3')\n self.conv4 = tf.layers.conv2d(\n inputs=self.conv3, filters=hidden, kernel_size=[7, 7], strides=1, \n kernel_initializer=tf.variance_scaling_initializer(scale=2),\n padding=\"valid\", activation=tf.nn.relu, use_bias=False, name='conv4')\n \n # Splitting into value and advantage stream\n self.value_stream, self.advantagestream = tf.split(self.conv4, 2, 3)\n self.value_stream = tf.layers.flatten(self.value_stream)\n self.advantagestream = tf.layers.flatten(self.advantagestream)\n self.advantage = tf.layers.dense(\n inputs=self.advantagestream, units=self.n_actions,\n kernel_initializer=tf.variance_scaling_initializer(scale=2), name=\"advantage\")\n self.value = tf.layers.dense(\n inputs=self.value_stream, units=1, \n kernel_initializer=tf.variance_scaling_initializer(scale=2), name='value')\n \n # Combining value and advantage into Q-values as described above\n self.q_values = self.value + tf.subtract(self.advantage, tf.reduce_mean(self.advantage, axis=1, keepdims=True))\n self.best_action = tf.argmax(self.q_values, 1)\n \n ###################\n # Parameter update.\n ###################\n \n # targetQ according to Bellman equation: \n # Q = r + gamma*max Q', calculated in the function learn()\n self.target_q = tf.placeholder(shape=[None], dtype=tf.float32)\n self.action = tf.placeholder(shape=[None], dtype=tf.int32)\n self.Q = tf.reduce_sum(tf.multiply(self.q_values, tf.one_hot(self.action, self.n_actions, dtype=tf.float32)), axis=1)\n \n # Parameter updates\n # DeepMind uses the quadratic cost function with error clipping (see https://www.nature.com/articles/nature14236/)\n # See https://machinelearningmastery.com/exploding-gradients-in-neural-networks/\n self.loss = tf.reduce_mean(tf.losses.huber_loss(labels=self.target_q, predictions=self.Q))\n \n # Consider using the RMS optimizer: https://arxiv.org/abs/1710.02298 - RMSProp was substituted for Adam with a learning rate of 0.0000625\n self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\n self.update = self.optimizer.minimize(self.loss)","def _special_handle_onehot(cls, op, X, W):\n tensor_list = []\n append_inputs = {\n \"depth\": op.depth,\n \"values\": op.values,\n }\n for tmp_name, append_input in append_inputs.items():\n node_name = op.name + \":\" + tmp_name\n tensor_list.append(\n numpy_helper.from_array(np.array(append_input), node_name))\n return tensor_list","def _activation_summary(x):\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n # session. This helps the clarity of presentation on tensorboard.\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n tf.histogram_summary(tensor_name + '/activations', x)\n tf.scalar_summary(tensor_name + '/sparsity', tf.nn.zero_fraction(x))","def _activation_summary(x):\n\t# Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n\t# session. This helps the clarity of presentation on tensorboard.\n\ttensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n\ttf.summary.histogram(tensor_name + '/activations', x)\n\ttf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))","def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])","def _initalize_state(self):\n\n self.memories.append(tf.tanh(\n tf.random_normal(shape=(self.memory_capacity, self.memory_vector_size), stddev=0.5)))\n self.ww_t.append(tf.nn.softmax(tf.range(self.memory_capacity, 0, -1, dtype=tf.float32)))\n self.rw_t.append(tf.nn.softmax(tf.range(self.memory_capacity, 0, -1, dtype=tf.float32)))\n self.r_t.append(tf.tanh(tf.random_normal(shape=(self.memory_vector_size,), stddev=0.5)))","def get_entropy(self, x_dict={}, sum_features=True, feature_dims=None):\n raise NotImplementedError()","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def compute_logits(self):\n # [num train labels, num classes] where each row is a one-hot-encoded label.\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\n\n # Undocumented in the paper, but *very important*: *only* the support set\n # embeddings is L2-normalized, which means that the distance is not exactly\n # a cosine distance. For comparison we also allow for the actual cosine\n # distance to be computed, which is controlled with the\n # `exact_cosine_distance` instance attribute.\n train_embeddings = tf.nn.l2_normalize(\n self.train_embeddings, 1, epsilon=1e-3)\n test_embeddings = self.test_embeddings\n if self.exact_cosine_distance:\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\n # [num_test_images, num_train_images]\n similarities = tf.matmul(\n test_embeddings, train_embeddings, transpose_b=True)\n attention = tf.nn.softmax(similarities)\n\n # [num_test_images, way]\n probs = tf.matmul(attention, one_hot_train_labels)\n self.test_logits = tf.log(probs)\n return self.test_logits","def compute_loss(\n action_probs: tf.Tensor, values: tf.Tensor, returns: tf.Tensor\n) -> tf.Tensor:\n\n advantage = returns - values\n td = tf.subtract(returns, values)\n\n # actor\n # action_log_probs = tf.math.log(action_probs)\n # actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)\n action_log_probs = tf.math.log(action_probs)\n actor_loss = -tf.math.reduce_mean(action_log_probs * td)\n\n # critic\n # td = tf.subtract(returns, values)\n # critic_loss = tf.reduce_mean(tf.square(td))\n critic_loss = huber_loss(values, returns)\n\n tf.print(\"a_loss:\", actor_loss, \"c_loss:\", critic_loss)\n\n return actor_loss + critic_loss","def _make_summaries(self):\n\n self.summaries['loss'] = tf.summary.scalar('loss', self.loss)\n\n self.summaries['0_inputs_outputs'] = \\\n tf.summary.image('0_inputs_outputs', tf.concat([\n tf.expand_dims(tf.expand_dims(tf.stack(self.inputs, axis=-1), axis=0), axis=-1),\n tf.ones(shape=(1, self.input_vector_size, 1, 1)), # white separator\n tf.expand_dims(tf.expand_dims(tf.stack(self.outputs, axis=-1), axis=0), axis=-1)],\n axis=2))\n\n self.summaries['1_write_and_read_locations'] = \\\n tf.summary.image('1_write_and_read_locations', tf.concat([\n tf.expand_dims(tf.expand_dims(tf.stack(self.ww_t, axis=-1), axis=0), axis=-1),\n tf.ones(shape=(1, self.memory_capacity, 1, 1)), # white separator\n tf.expand_dims(tf.expand_dims(tf.stack(self.rw_t, axis=-1), axis=0), axis=-1)],\n axis=2))\n\n self.summaries['2_memory'] = \\\n tf.summary.image('2_memory', tf.expand_dims(tf.expand_dims(self.memories[-1], axis=0), axis=-1))\n\n self.summaries['3_add_read_vectors'] = \\\n tf.summary.image('3_add_read_vectors', tf.concat([\n tf.expand_dims(tf.expand_dims(tf.stack(self.a_t, axis=-1), axis=0), axis=-1),\n tf.ones(shape=(1, self.memory_vector_size, 1, 1)), # white separator\n tf.expand_dims(tf.expand_dims(tf.stack(self.r_t, axis=-1), axis=0), axis=-1)],\n axis=2))\n\n self.summaries['4_erase_vectors'] = \\\n tf.summary.image('4_erase_vectors',\n tf.expand_dims(tf.expand_dims(tf.stack(self.e_t, axis=-1), axis=0), axis=-1))\n\n self.loss_summarization = tf.summary.merge([self.summaries['loss']])\n self.summarization = tf.summary.merge_all()\n\n logs_dir = join(self.logdir, 'seq_len_{:02d}'.format(self.sequence_length))\n\n # make summary dir\n if not exists(logs_dir):\n os.makedirs(logs_dir)\n self.train_writer = tf.summary.FileWriter(logs_dir, self.sess.graph)","def compute_HOG(self,image_tensor):\n image_idx = image_tensor.size()[0] #size (6, C, H, W)\n hogs = list()\n # iterate through each generated image\n for i in range(image_idx):\n image = image_tensor[i,:,:,:]\n image = image.numpy()\n # revert normalization\n x = np.zeros_like(image)\n x[0, :, :] = image[0, :, :] * STD[0] + MEAN[0]\n x[1, :, :] = image[1, :, :] * STD[1] + MEAN[1]\n x[2, :, :] = image[2, :, :] * STD[2] + MEAN[2]\n x = x*255\n cv_x = x.astype(np.uint8)\n # transpose dimensions since hog implementation requires image to be (M, N[, C]) ndarray\n cv_x = np.transpose(cv_x, (1,2,0))\n\n # 27*27*36\n hist = hog(cv_x, orientations=8, pixels_per_cell=(16, 16),\n cells_per_block=(3, 3), visualize=False, feature_vector=True, multichannel=True)\n hist = torch.from_numpy(hist)\n hogs.append(hist)\n hogs_tensor = torch.stack(hogs, dim=0)\n \n \n return hogs_tensor","def setup_observation_term(background_data_dict,\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\n direct_obs_operator,\n analysis_increment_vector_symbol,\n increment_data=0.001):\n linearized_obs_operator = sympy.Matrix(\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\n background_derived_obs = sympy.Matrix(\n numpy.ones((len(obs_type_vector), 1)))\n\n for i_obs in range(0, len(obs_data_vector)):\n cur_obs_type = str(obs_type_vector[i_obs])\n cur_obs_lat = float(obs_lat_vector[i_obs])\n cur_obs_lon = float(obs_lon_vector[i_obs])\n\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\n \n # 1. calculate h(x):\n bkg_shape = background_data_dict['lat'].shape\n bkg_weight_0 = 0\n bkg_weight_1 = 0\n for ii in range(0, bkg_shape[0]):\n for jj in range(0, bkg_shape[1]):\n cur_bk_lat = background_data_dict['lat'][ii, jj]\n cur_bk_lon = background_data_dict['lon'][ii, jj]\n\n cur_obs_operator_input = {}\n for required_bk_var in required_bk_vars:\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\n\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\n \n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\n final_bkg_weight_1 = bkg_weight_1\n \n # 2. find linearized observation operator\n # n = 0\n for i_bkg in range(0, len(background_type_vector)):\n cur_bk_lat = float(background_lat_vector[i_bkg])\n cur_bk_lon = float(background_lon_vector[i_bkg])\n cur_bk_type = str(background_type_vector[i_bkg])\n \n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\n cur_distance_weight_0 = cur_distance ** 2\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\n \n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\n {cur_bk_type: float(background_data_vector[i_bkg])})\n \n linearized_obs_operator_with_increments = \\\n linearized_obs_operator*analysis_increment_vector_symbol\n \n # get the innovation:\n innovation = obs_data_vector - background_derived_obs - \\\n linearized_obs_operator_with_increments\n return linearized_obs_operator, innovation, background_derived_obs","def calc_entropy(data_set):\n size = len(data_set)\n label_counts = {}\n for feat_vector in data_set:\n label = feat_vector[-1]\n label_counts.setdefault(label, 0)\n label_counts[label] += 1\n\n entropy = 0.0\n for key, count in label_counts.iteritems():\n prob = float(count) / size\n entropy -= prob * log(prob, 2)\n\n return entropy","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def __init__(self):\n self.sum_of_node_inputs = 0\n self.output = 0\n self.delta = 0\n self.dp = 0\n self.onehot_label = 0","def calculate_entropy(dataset) :\n\n num_entries = len(dataset)\n label_counts = {}\n for vector in dataset :\n # the label is at the last index of the data set\n current_label = vector[-1]\n if current_label not in label_counts :\n label_counts[current_label] = 0\n label_counts[current_label] += 1\n # Calculate the entropy\n entropy = 0.0\n for label in label_counts :\n # Calculate probability of each label within the dataset\n prob_of_label = label_counts[label]/num_entries\n # Since the entropy is the negative of the sum of all probability,\n # simply subtract it\n entropy -= prob_of_label * log(prob_of_label, 2)\n return entropy","def entropy_loss(policy_logits):\n\n softmax = nn.Softmax(dim=-1)\n logsoftmax = nn.LogSoftmax(dim=-1)\n\n policy = softmax(policy_logits.action_type)\n log_policy = logsoftmax(policy_logits.action_type)\n\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))","def __init__(self):\n self.counts = [0] * 10\n self.values = [0] * 10\n self.softmaxvalues = [0] * 10\n self.t = 0.3","def _create_counter(self):\n iter_cotrain = tf.get_variable(\n name='iter_cotrain',\n initializer=tf.constant(0, name='iter_cotrain'),\n use_resource=True,\n trainable=False)\n iter_cotrain_update = iter_cotrain.assign_add(1)\n return iter_cotrain, iter_cotrain_update","def compute_metrics(self):\n pass","def _activation_summary(x):\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n # session. This helps the clarity of presentation on tensorboard.\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n tf.summary.histogram(tensor_name + '/activations', x)\n tf.summary.scalar(tensor_name + '/sparsity',\n tf.nn.zero_fraction(x))","def _activation_summary(x):\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n # session. This helps the clarity of presentation on tensorboard.\n tensor_name = x.op.name\n # tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n tf.summary.histogram(tensor_name + '/activations', x)\n\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))","def _activation_summary(x):\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n # session. This helps the clarity of presentation on tensorboard.\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\n tf.summary.histogram(tensor_name + '/activations', x)\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))","def _calculate_probs_and_entropies(self):\n self._calculate_probs_and_entropy_y()\n self._calculate_probs_and_entropy_x(self.cat_cols)","def Entropy(model, pool, addn):\n\n # Get probability distribution over labels\n pool_p = model.predict_proba(pool)\n\n # Calculate entropy and sort for each datapoint in pool\n Entropy = (pool_p * np.log(1/pool_p)).sum(axis = 1)\n Information_gain = np.argsort(Entropy)\n\n # Choose addn datapoints with highest entropy\n x_star = Information_gain[-addn:]\n return x_star","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def _activation_summary(x):\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\n # session. This helps the clarity of presentation on tensorboard.\n tensor_name = re.sub('%s_[0-9]*/' % 'tower', '', x.op.name)\n tf.summary.histogram(tensor_name + '/activations', x)\n tf.summary.scalar(tensor_name + '/sparsity',\n tf.nn.zero_fraction(x))","def entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))","def compute_logits(self):\n # [num test images, 1, embedding size].\n test_embeddings = tf.expand_dims(self.test_embeddings, 1)\n\n # [1, num_clases, embedding_size].\n prototypes = tf.expand_dims(self.prototypes, 0)\n\n # Squared euclidean distances between each test embedding / prototype pair.\n distances = tf.reduce_sum(tf.square(test_embeddings - prototypes), 2)\n self.test_logits = -distances\n return self.test_logits","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def add_op(self, logits, labels):\n\n with tf.name_scope(self.name_scope):\n labels = tf.cast(labels, tf.int64)\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)\n cross_entropy_mean = tf.reduce_mean(cross_entropy, name=self.name_scope)\n\n tf.summary.scalar(self.name_scope, cross_entropy_mean)\n\n return cross_entropy_mean","def _ter_compute(total_num_edits: Tensor, total_tgt_length: Tensor) ->Tensor:\n return _compute_ter_score_from_statistics(total_num_edits, total_tgt_length)","def _activation_summary(x):\n\n tf.summary.histogram(x.op.name + '/activations', x)\n tf.summary.scalar(x.op.name + '/sparsity', tf.nn.zero_fraction(x))","def entropy(self, policy_params):\n return self.head.entropy(policy_params)","def hist_cpu(A):\n C = np.zeros(shape=256, dtype=np.int32)\n shape = A.shape[0]\n for i in range(shape):\n C[A[i]] += 1\n return C","def update(self):\n with torch.no_grad():\n self.preprocess_rollout()\n \n # DEEP-RL TUTORIALS: КОСТЫЛЬ\n #self.advantages = self.returns[:-1] - self.values[:-1]\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\n \n # going through rollout several (config.epochs) times:\n for epoch in range(self.config.epochs):\n # TODO: drop last = False? What if there is 1 sample?\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\n \n for indices in sampler:\n # retrieving new batch as part of rollout\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\n \n # calculating current value, action_log_prob, entropy\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \n self.entropy_b = dist.entropy()#.sum(dim=-1)\n \n # performing step\n self.gradient_ascent_step()","def cal_globalEntropy(self):\n group_score = []\n pop_total = np.sum(self.pop_sum)\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\n\n # loop at sum of each population groups\n for group in prop:\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\n group_score.append(group_idx)\n entropy = np.sum(group_score)\n\n return entropy","def _build_train_op(self):\n\n logits_flatten = tf.reshape(self.logits_up, [-1, self.num_classes])\n pred_flatten = tf.reshape(self.pred, [-1, self.num_classes])\n\n labels_gt = self.labels\n\n if self.ignore_class_bg:\n # ignore background labels: 255\n gt_labels_flatten = tf.reshape(labels_gt, [-1, ])\n indices = tf.squeeze(tf.where(tf.less_equal(gt_labels_flatten, self.num_classes - 1)), 1)\n remain_logits = tf.gather(logits_flatten, indices)\n remain_pred = tf.gather(pred_flatten, indices)\n remain_labels = tf.gather(gt_labels_flatten, indices)\n xent = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=remain_logits, labels=remain_labels)\n else:\n xent = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.logits_up, labels=labels_gt)\n\n self.cls_loss = tf.reduce_mean(xent, name='xent') # xent.shape=[nIgnoredBgPixels]\n self.cost = self.cls_loss + self._decay()\n tf.summary.scalar('cost', self.cost)\n\n self.global_step = tf.Variable(0, name='global_step', trainable=False)\n self.learning_rate = tf.train.polynomial_decay(self.lrn_rate,\n self.global_step,\n self.lr_decay_step,\n end_learning_rate=self.lrn_rate_end,\n power=0.9)\n tf.summary.scalar('learning rate', self.learning_rate)\n\n tvars = tf.trainable_variables()\n\n if self.optimizer == 'sgd':\n optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\n elif self.optimizer == 'mom':\n optimizer = tf.train.MomentumOptimizer(self.learning_rate, 0.9)\n elif self.optimizer == 'adam':\n optimizer = tf.train.AdamOptimizer(self.learning_rate)\n else:\n raise NameError(\"Unknown optimizer type %s!\" % self.optimizer)\n\n grads_and_vars = optimizer.compute_gradients(self.cost, var_list=tvars)\n var_lr_mult = {}\n for var in tvars:\n if var.op.name.find(r'fc_final_sketch46') > 0 and var.op.name.find(r'biases') > 0:\n var_lr_mult[var] = 20.\n elif var.op.name.find(r'fc_final_sketch46') > 0:\n var_lr_mult[var] = 10.\n else:\n var_lr_mult[var] = 1.\n grads_and_vars = [((g if var_lr_mult[v] == 1 else tf.multiply(var_lr_mult[v], g)), v)\n for g, v in grads_and_vars]\n\n ## summary grads\n # for grad, grad_var in grads_and_vars:\n # print('>>>', grad_var.op.name)\n # if grad is None:\n # print('None grad')\n # # if grad is not None:\n # # tf.summary.histogram(grad_var.op.name + \"/gradient\", grad)\n\n apply_op = optimizer.apply_gradients(grads_and_vars,\n global_step=self.global_step, name='train_step')\n\n train_ops = [apply_op] + self._extra_train_ops\n self.train_step = tf.group(*train_ops)","def entropy_root(self):\n\t\tif self.size() == 0:\n\t\t\treturn 0\n\n\t\tcounter = collections.Counter(self.y)\n\t\treturn entropy([x[1] for x in counter.items()], self.size())","def __init__(self, E, U, height, width, filter_hs, conv_non_linear,\n hidden_units, batch_size, non_static, dropout_rates,subspace_size=None,\n activations=[Iden]):\n rng = np.random.RandomState(3435)\n feature_maps = hidden_units[0]\n self.batch_size = batch_size\n\n # define model architecture\n self.index = T.lscalar()\n self.x = T.matrix('x') \n self.y = T.ivector('y') \n self.Words = theano.shared(value=E, name=\"Words\") \n self.Users = None \n self.u = None\n self.subspace_size = subspace_size\n zero_vec_tensor = T.vector()\n self.zero_vec = np.zeros(width)\n # reset Words to 0?\n self.set_zero = theano.function([zero_vec_tensor],\n updates=[(self.Words, T.set_subtensor(self.Words[0,:],zero_vec_tensor))],\n allow_input_downcast=True)\n # inputs to the ConvNet go to all convolutional filters:\n layer0_input = self.Words[T.cast(self.x.flatten(), dtype=\"int32\")].reshape(\n (self.x.shape[0], 1, self.x.shape[1], self.Words.shape[1]))\n self.conv_layers = [] \n \n # outputs of convolutional filters\n layer1_inputs = []\n image_shape = (batch_size, 1, height, width)\n filter_w = width \n for filter_h in filter_hs: \n filter_shape = (feature_maps, 1, filter_h, filter_w)\n pool_size = (height-filter_h+1, width-filter_w+1)\n conv_layer = LeNetConvPoolLayer(rng, input=layer0_input,\n image_shape=image_shape,\n filter_shape=filter_shape,\n poolsize=pool_size,\n non_linear=conv_non_linear)\n layer1_input = conv_layer.output.flatten(2)\n self.conv_layers.append(conv_layer)\n layer1_inputs.append(layer1_input)\n # inputs to the MLP\n layer1_input = T.concatenate(layer1_inputs, 1)\n if U is not None:\n print \"Will use user embeddings\"\n self.u = T.ivector('u')\n self.Users = theano.shared(value=U, name=\"Users\")\n them_users = self.Users[self.u]\n if self.subspace_size:\n print \"and subspace\"\n # set_trace()\n self.subspace = HiddenLayer(rng, them_users, U.shape[1], subspace_size, Sigmoid)\n self.peep = theano.function([self.x, self.u],[self.subspace.output,layer1_input],allow_input_downcast=True)\n\n layer1_input = T.concatenate((layer1_input,T.nnet.sigmoid(self.subspace.output)),1)\n layer_sizes = [feature_maps*len(filter_hs)+subspace_size] \n # layer1_input = T.concatenate((layer1_input,them_users),1)\n # layer_sizes = [feature_maps*len(filter_hs)+U.shape[1]]\n\n else:\n layer1_input = T.concatenate((layer1_input,them_users),1)\n layer_sizes = [feature_maps*len(filter_hs)+U.shape[1]]\n\n else:\n print \"NO user embeddings\"\n layer_sizes = [feature_maps*len(filter_hs)]\n layer_sizes += hidden_units[1:]\n \n super(ConvNet, self).__init__(rng, input=layer1_input,\n layer_sizes=layer_sizes,\n activations=activations,\n dropout_rates=dropout_rates)\n\n # add parameters from convolutional layers\n for conv_layer in self.conv_layers:\n self.params += conv_layer.params\n if non_static:\n # if word vectors are allowed to change, add them as model parameters\n self.params += [self.Words]\n if U is not None:\n # if self.subspace_size is None:\n self.params += [self.Users]"],"string":"[\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def _make_histogram_ops(self, model):\\n # only make histogram summary op if it hasn't already been made\\n if self.histogram_freq and self.merged is None:\\n for weight in self.model.trainable_variables:\\n mapped_weight_name = weight.name.replace(\\\":\\\", \\\"_\\\")\\n tf_summary.histogram(mapped_weight_name, weight)\\n if self.write_images:\\n w_img = array_ops.squeeze(weight)\\n shape = K.int_shape(w_img)\\n if len(shape) == 2: # dense layer kernel case\\n if shape[0] > shape[1]:\\n w_img = array_ops.transpose(w_img)\\n shape = K.int_shape(w_img)\\n w_img = array_ops.reshape(w_img, [1, shape[0], shape[1], 1])\\n elif len(shape) == 3: # convnet case\\n if K.image_data_format() == \\\"channels_last\\\":\\n # switch to channels_first to display\\n # every kernel as a separate image\\n w_img = array_ops.transpose(w_img, perm=[2, 0, 1])\\n shape = K.int_shape(w_img)\\n w_img = array_ops.reshape(w_img, [shape[0], shape[1], shape[2], 1])\\n elif len(shape) == 1: # bias case\\n w_img = array_ops.reshape(w_img, [1, shape[0], 1, 1])\\n else:\\n # not possible to handle 3D convnets etc.\\n continue\\n\\n shape = K.int_shape(w_img)\\n assert len(shape) == 4 and shape[-1] in [1, 3, 4]\\n tf_summary.image(mapped_weight_name, w_img)\\n\\n if self.write_grads:\\n for weight in model.trainable_weights:\\n mapped_weight_name = weight.name.replace(\\\":\\\", \\\"_\\\")\\n grads = model.optimizer.get_gradients(model.total_loss, weight)\\n\\n def is_indexed_slices(grad):\\n return type(grad).__name__ == \\\"IndexedSlices\\\"\\n\\n grads = [grad.values if is_indexed_slices(grad) else grad for grad in grads]\\n tf_summary.histogram(\\\"{}_grad\\\".format(mapped_weight_name), grads)\",\n \"def _compute_statistics(self):\\n # log to file\\n output_dir = self.params['output_dir']\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n output_dir = os.path.join(output_dir, 'statistics.log')\\n log = logging.getLogger('tensorflow')\\n handle = logging.FileHandler(output_dir)\\n log.addHandler(handle)\\n\\n # FLOPS\\n encoder_flops, decoder_flops = 0, 0\\n encoder_count, decoder_count = 0, 0\\n graph = tf.get_default_graph()\\n for operation in graph.get_operations():\\n flops = ops.get_stats_for_node_def(graph, operation.node_def,\\n 'flops').value\\n if flops is None:\\n continue\\n if operation.name.startswith('model/encoder'):\\n # encoder\\n encoder_flops += flops\\n encoder_count += 1\\n tf.logging.info('encoder operation %s : %d', operation.name, flops)\\n elif operation.name.startswith('model/decoder'):\\n # decoder\\n decoder_flops += flops\\n decoder_count += 1\\n tf.logging.info('decoder operation %s : %d', operation.name, flops)\\n else:\\n # gradient\\n pass\\n tf.logging.info('flops of %d encoder tensor: %d',\\n encoder_count, encoder_flops)\\n tf.logging.info('flops of %d decoder tensor: %d',\\n decoder_count, decoder_flops)\\n tf.logging.info('flops of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_flops + decoder_flops)\\n # parameters\\n encoder_parameters, decoder_parameters = 0, 0\\n encoder_count, decoder_count = 0, 0\\n for var in tf.trainable_variables():\\n parameters = np.prod(var.get_shape().as_list())\\n if var.name.startswith('model/encoder'):\\n # encoder\\n encoder_parameters += parameters\\n encoder_count += 1\\n tf.logging.info('encoder variable %s : %d', var.name, parameters)\\n elif var.name.startswith('model/decoder'):\\n # decoder\\n decoder_parameters += parameters\\n decoder_count += 1\\n tf.logging.info('decoder variable %s : %d', var.name, parameters)\\n\\n tf.logging.info('parameters of %d encoder tensor: %d',\\n encoder_count, encoder_parameters)\\n tf.logging.info('parameters of %d decoder tensor: %d',\\n decoder_count, decoder_parameters)\\n tf.logging.info('parameters of total %d tensor: %d',\\n encoder_count + decoder_count,\\n encoder_parameters + decoder_parameters)\\n # disable log to file\\n log.removeHandler(handle)\",\n \"def get_fused_operator_statistics(self):\\n op_count = {}\\n ops = [\\n \\\"Attention\\\",\\n \\\"MultiHeadAttention\\\",\\n \\\"LayerNormalization\\\",\\n \\\"SkipLayerNormalization\\\",\\n \\\"BiasSplitGelu\\\",\\n \\\"GroupNorm\\\",\\n \\\"NhwcConv\\\",\\n \\\"BiasAdd\\\",\\n ]\\n for op in ops:\\n nodes = self.get_nodes_by_op_type(op)\\n op_count[op] = len(nodes)\\n\\n logger.info(f\\\"Optimized operators:{op_count}\\\")\\n return op_count\",\n \"def __init__(self):\\n super(MetricCrossEntropy, self).__init__()\",\n \"def __call__(self, pred_texture: Image.Image, gt_texture: Image.Image) -> float:\\n from plan2scene.evaluation.metric_impl.freq_hist import compute_freq_hist_l1\\n return compute_freq_hist_l1(pred=pred_texture, gt=gt_texture)\",\n \"def compute_entropy(bincounts, include_zeros):\\n num_total = tf.cast(tf.reduce_sum(bincounts), tf.float64)\\n if not include_zeros:\\n bincounts = bincounts[1:]\\n mask = tf.greater(bincounts, 0)\\n nonzero_bincounts = tf.cast(\\n tf.boolean_mask(bincounts, mask), tf.float64)\\n num_nonzero = tf.cast(tf.reduce_sum(nonzero_bincounts), tf.float64)\\n log_nonzero_bincounts = tf.math.log(nonzero_bincounts)\\n log_prob = log_nonzero_bincounts - tf.reduce_logsumexp(\\n log_nonzero_bincounts)\\n entropy = tf.math.reduce_sum(\\n log_prob * tf.exp(log_prob)) / -tf.math.log(tf.cast(2, tf.float64))\\n return entropy * num_nonzero / num_total\",\n \"def entropy_loss_for_all_arguments(policy_logits, masks):\\n\\n index_list = ['action_type', 'delay', 'queue', 'units', 'target_unit', 'target_location']\\n masks = torch.tensor(masks, device=device)\\n\\n entropy_list = []\\n for x in index_list:\\n if x == \\\"delay\\\":\\n continue\\n if x == \\\"queue\\\":\\n continue\\n if x == \\\"target_unit\\\":\\n continue \\n if (not P.use_raw_action) and x == \\\"units\\\":\\n continue\\n\\n logits = getattr(policy_logits, x) \\n\\n print(\\\"x name:\\\", x) if debug else None\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n\\n if x == \\\"target_unit\\\":\\n # remove the axis 2\\n logits = logits.squeeze(dim=1)\\n\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n\\n logits = logits.reshape(AHP.batch_size, AHP.sequence_length, *tuple(logits.shape[1:]))\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n logits = logits.transpose(0, 1)\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n\\n # shape to be [seq_batch_size, channel_size]\\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size, *tuple(logits.shape[2:]))\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n\\n if x == \\\"units\\\":\\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size * AHP.max_selected, AHP.max_entities)\\n if x == \\\"target_location\\\":\\n logits = logits.reshape(AHP.sequence_length * AHP.batch_size, SCHP.world_size * SCHP.world_size)\\n print(\\\"logits.shape:\\\", logits.shape) if debug else None\\n\\n i = index_list.index(x)\\n\\n # shape to be [seq_size, batch_size, 1]\\n mask = masks[:, :, i]\\n\\n # shape to be [seq_batch_size, 1]\\n mask = mask.reshape(-1, 1)\\n if x == \\\"units\\\":\\n mask = [mask] * AHP.max_selected\\n mask = torch.cat(mask, dim=0)\\n print(\\\"mask.shape:\\\", mask.shape) if debug else None\\n\\n entropy_item = entropy(logits, mask)\\n\\n print(\\\"entropy_item:\\\", entropy_item) if debug else None\\n\\n entropy_list.append(entropy_item)\\n\\n return torch.mean(torch.cat(entropy_list, axis=0))\",\n \"def build_summary(self):\\n for k, v in self.metrics.items():\\n tf.summary.scalar(k, v)\\n \\n self.summary_op = tf.summary.merge_all()\",\n \"def log_output_data(self):\\r\\n with tf.name_scope('model_output'):\\r\\n for i in range(self.action_handler.get_number_actions()):\\r\\n variable_name = str(self.action_handler.action_list_names[i])\\r\\n tf.summary.histogram(variable_name + '_output', self.actor_last_row_layer[i])\",\n \"def compute_policy_entropy(available_actions, policy, actions):\\n _,arg_ids = actions\\n\\n fn_pi, arg_pis = policy\\n fn_pi = mask_unavailable_actions(available_actions, fn_pi)\\n entropy = tf.reduce_mean(compute_entropy(fn_pi))\\n tf.summary.scalar('entropy/fn', entropy)\\n\\n for arg_type in arg_ids.keys():\\n arg_id = arg_ids[arg_type]\\n arg_pi = arg_pis[arg_type]\\n batch_mask = tf.to_float(tf.not_equal(arg_id, -1))\\n arg_entropy = safe_div(\\n tf.reduce_sum(compute_entropy(arg_pi) * batch_mask),\\n tf.reduce_sum(batch_mask))\\n entropy += arg_entropy\\n tf.summary.scalar('used/arg/%s' % arg_type.name,\\n tf.reduce_mean(batch_mask))\\n tf.summary.scalar('entropy/arg/%s' % arg_type.name, arg_entropy)\\n\\n return entropy\",\n \"def _init_actor_update(self):\\n\\n actions = self._policy.actions([self._observations_ph])\\n log_pis = self._policy.log_pis([self._observations_ph], actions)\\n\\n assert log_pis.shape.as_list() == [None, 1]\\n\\n log_alpha = self._log_alpha = tf.get_variable(\\n 'log_alpha',\\n dtype=tf.float32,\\n initializer=0.0)\\n alpha = tf.exp(log_alpha)\\n\\n if isinstance(self._target_entropy, Number):\\n alpha_loss = -tf.reduce_mean(\\n log_alpha * tf.stop_gradient(log_pis + self._target_entropy))\\n\\n self._alpha_optimizer = tf.train.AdamOptimizer(\\n self._policy_lr, name='alpha_optimizer')\\n self._alpha_train_op = self._alpha_optimizer.minimize(\\n loss=alpha_loss, var_list=[log_alpha])\\n\\n self._training_ops.update({\\n 'temperature_alpha': self._alpha_train_op\\n })\\n\\n self._alpha = alpha\\n\\n if self._action_prior == 'normal':\\n policy_prior = tf.contrib.distributions.MultivariateNormalDiag(\\n loc=tf.zeros(self._action_shape),\\n scale_diag=tf.ones(self._action_shape))\\n policy_prior_log_probs = policy_prior.log_prob(actions)\\n elif self._action_prior == 'uniform':\\n policy_prior_log_probs = 0.0\\n\\n Q_log_targets = tuple(\\n Q([self._observations_ph, actions])\\n for Q in self._Qs)\\n min_Q_log_target = tf.reduce_min(Q_log_targets, axis=0)\\n\\n if self._reparameterize:\\n policy_kl_losses = (\\n alpha * log_pis\\n - min_Q_log_target\\n - policy_prior_log_probs)\\n else:\\n raise NotImplementedError\\n\\n assert policy_kl_losses.shape.as_list() == [None, 1]\\n\\n policy_loss = tf.reduce_mean(policy_kl_losses)\\n\\n self._policy_optimizer = tf.train.AdamOptimizer(\\n learning_rate=self._policy_lr,\\n name=\\\"policy_optimizer\\\")\\n policy_train_op = tf.contrib.layers.optimize_loss(\\n policy_loss,\\n self.global_step,\\n learning_rate=self._policy_lr,\\n optimizer=self._policy_optimizer,\\n variables=self._policy.trainable_variables,\\n increment_global_step=False,\\n summaries=(\\n \\\"loss\\\", \\\"gradients\\\", \\\"gradient_norm\\\", \\\"global_gradient_norm\\\"\\n ) if self._tf_summaries else ())\\n\\n self._training_ops.update({'policy_train_op': policy_train_op})\",\n \"def get_entropy(distribution, samples):\\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\\n return entropy\",\n \"def entropy(data, idxList):\\n df = data.loc[idxList]\\n counts = df.value_counts().to_numpy()\\n counts = counts.reshape(1, -1).astype(np.float32)\\n counts /= np.sum(counts)\\n log_sum = counts @ np.log2(counts.T)\\n return -log_sum[0, 0]\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def entropy(self):\\n raise NotImplementedError\",\n \"def entropy(self):\\n\\n \\\"\\\"\\\"Gets the first neighbours, which are the first 2*r+1 cells.\\\"\\\"\\\"\\n current_neighbours = []\\n amount = [0] * self.k ** (2 * self.r + 1)\\n for i in range(2 * self.r + 1):\\n current_neighbours.append(self.config[self.t, i % self.width])\\n\\n \\\"\\\"\\\"Calculates the rule and adds one to it's amount. It then removes the\\n leftmost cell and adds a cell to the right.\\\"\\\"\\\"\\n for i in range(len(self.config[self.t]) - 1):\\n rule = 0\\n for j in range(len(current_neighbours)):\\n rule += int(current_neighbours[j] *\\n self.k ** ((2 * self.r + 1) - j - 1))\\n amount[len(amount) - 1 - rule] += 1\\n current_neighbours.pop(0)\\n current_neighbours.append(\\n self.config[self.t, (2 * self.r + 1 + i) % self.width])\\n\\n \\\"\\\"\\\"Calculates the rule for the last neighbourhood.\\\"\\\"\\\"\\n rule = 0\\n for j in range(len(current_neighbours)):\\n rule += int(current_neighbours[j] *\\n self.k ** ((2 * self.r + 1) - j - 1))\\n amount[len(amount)-1 - rule] += 1\\n\\n \\\"\\\"\\\"Calculates the Shannon entropy and the the average entropy so far.\\\"\\\"\\\"\\n shannon = 0\\n for i in range(len(amount)):\\n if(amount[i] != 0):\\n probability = amount[i] / self.width\\n shannon -= probability * np.log2(probability)\\n self.average_entropy = (self.average_entropy *\\n self.t + shannon) / (self.t + 1)\",\n \"def _calc_final_dist(_enc_batch_extend_vocab, vocab_dists, attn_dists, p_gens, batch_oov_len, vocab_size, batch_size):\\n\\n # Multiply vocab dists by p_gen and attention dists by (1-p_gen)\\n vocab_dists = [p_gen * dist for (p_gen, dist) in zip(p_gens, vocab_dists)]\\n attn_dists = [(1 - p_gen) * dist for (p_gen, dist) in zip(p_gens, attn_dists)]\\n\\n # Concatenate some zeros to each vocabulary dist, to hold the probabilities for in-article OOV words\\n extended_vsize = vocab_size + batch_oov_len # the maximum (over the batch) size of the extended vocabulary\\n extra_zeros = tf.zeros((batch_size, batch_oov_len))\\n # list length max_dec_steps of shape (batch_size, extended_vsize)\\n vocab_dists_extended = [tf.concat(axis=1, values=[dist, extra_zeros]) for dist in vocab_dists]\\n\\n # Project the values in the attention distributions onto the appropriate entries in the final distributions\\n # This means that if a_i = 0.1 and the ith encoder word is w, and w has index 500 in the vocabulary,\\n # then we add 0.1 onto the 500th entry of the final distribution\\n # This is done for each decoder timestep.\\n # This is fiddly; we use tf.scatter_nd to do the projection\\n batch_nums = tf.range(0, limit=batch_size) # shape (batch_size)\\n batch_nums = tf.expand_dims(batch_nums, 1) # shape (batch_size, 1)\\n attn_len = tf.shape(_enc_batch_extend_vocab)[1] # number of states we attend over\\n batch_nums = tf.tile(batch_nums, [1, attn_len]) # shape (batch_size, attn_len)\\n indices = tf.stack((batch_nums, _enc_batch_extend_vocab), axis=2) # shape (batch_size, enc_t, 2)\\n shape = [batch_size, extended_vsize]\\n\\n # list length max_dec_steps (batch_size, extended_vsize)\\n attn_dists_projected = [tf.scatter_nd(indices, copy_dist, shape) for copy_dist in attn_dists]\\n\\n # Add the vocab distributions and the copy distributions together to get the final distributions\\n # final_dists is a list length max_dec_steps; each entry is a tensor shape (batch_size, extended_vsize) giving\\n # the final distribution for that decoder timestep\\n # Note that for decoder timesteps and examples corresponding to a [PAD] token, this is junk - ignore.\\n final_dists = [vocab_dist + copy_dist for (vocab_dist, copy_dist) in\\n zip(vocab_dists_extended, attn_dists_projected)]\\n\\n return final_dists\",\n \"def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\\n confmat = _drop_empty_rows_and_cols(confmat)\\n total_occurrences = confmat.sum()\\n p_xy_m = confmat / total_occurrences\\n p_y = confmat.sum(1) / total_occurrences\\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))\",\n \"def entropy_analysis(data_df):\\n seq_list = data_df['sequence'].values.tolist()\\n base_set = set([])\\n for seq in seq_list:\\n base_set.update(set(seq))\\n H_list = []\\n null_freq_list = []\\n STEP = ceil(len(seq_list[0]) / 10)\\n for base_idx in range(len(seq_list[0])):\\n if base_idx % STEP == 0:\\n logging.info('Entropy analysis in progress: {}% completed.'.format(10 * base_idx // STEP))\\n H, null_freq = base_entropy_masked(seq_list, base_set, base_idx)\\n H_list.append(H,)\\n null_freq_list.append(null_freq)\\n logging.info('Entropy analysis in progress: DONE.')\\n return H_list, null_freq_list\",\n \"def _Apply(self, c, p):\\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\\n entropy = tf.reduce_mean(entropy)\\n return entropy\",\n \"def _calc_final_dist(self, vocab_dists, attn_dists):\\n\\n with tf.variable_scope('final_distribution'):\\n vocab_dists = [p_gen * dist for (p_gen,dist) in zip(self.p_gens, vocab_dists)]\\n attn_dists = [(1-p_gen) * dist for (p_gen,dist) in zip(self.p_gens, attn_dists)]\\n\\n # Extend the vocabulary dist with zeros (for OOV words\\n extended_vsize = self._vocab.size() + self._max_art_oovs \\n extra_zeros = tf.zeros((self._hps.batch_size, self._max_art_oovs))\\n # list length max_dec_steps of shape (batch_size, extended_vsize)\\n vocab_dists_extended = [tf.concat(axis=1, values=[dist, extra_zeros])\\n for dist in vocab_dists]\\n\\n\\n # Project the values in the attention distributions onto the appropriate\\n # entries in the final distributions\\n batch_nums = tf.range(0, limit=self._hps.batch_size) # shape (batch_size)\\n batch_nums = tf.expand_dims(batch_nums, 1) # shape (batch_size, 1)\\n\\n attn_len = tf.shape(self._enc_batch_extend_vocab)[1] \\n batch_nums = tf.tile(batch_nums, [1, attn_len]) # shape (batch_size, attn_len)\\n indices = tf.stack( (batch_nums, self._enc_batch_extend_vocab), axis=2) \\n shape = [self._hps.batch_size, extended_vsize]\\n # indices has shape [batch_size, extended_vsize, 2]\\n # sample slice: [[[0, 701], ... ], [[1, 529], ...], [[2, 728], ...]]\\n # scatter the distribution among corresponding batches and vocabulary index\\n \\n\\n # list length max_dec_steps (batch_size, extended_vsize)\\n attn_dists_projected = [tf.scatter_nd(indices, copy_dist, shape)\\n for copy_dist in attn_dists]\\n\\n # Add a very small epsilon\\n def _add_epsilon(dist, epsilon=sys.float_info.epsilon):\\n epsilon_mask = tf.ones_like(dist) * epsilon\\n return dist + epsilon_mask\\n # Add the vocab distributions and the copy distributions together to get\\n # the final distributions\\n final_dists = [vocab_dist + copy_dist\\n for (vocab_dist, copy_dist)\\n in zip(vocab_dists_extended, attn_dists_projected)]\\n final_dists = [_add_epsilon(dist) for dist in final_dists]\\n\\n return final_dists\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def collect_powers(operator):\\n new_tensors = []\\n symbols = {}\\n for tensor in operator.tensors:\\n if tensor.is_field or tensor.name[0] == \\\"$\\\" or tensor.exponent is None:\\n new_tensors.append(tensor)\\n else:\\n # Previusly collected exponent for same base and indices\\n prev_exponent = symbols.get((tensor.name, tuple(tensor.indices)), 0)\\n \\n # The exponents of a product are added\\n symbols[(tensor.name, tuple(tensor.indices))] = (\\n tensor.exponent + prev_exponent)\\n\\n # Remove tensors with exponent 0\\n new_op = Operator([])\\n for (name, inds), exponent in symbols.items():\\n if exponent != 0:\\n new_op *= power_op(name, exponent, indices=inds)\\n \\n return new_op * Op(*new_tensors)\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def compute_edge_logits(self):\",\n \"def entropy(group_counts):\\n total = sum(group_counts)\\n entro = 0\\n for item_count in group_counts:\\n entro += item_entropy(item_count, total)\\n return entro\",\n \"def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n logits = args.attribution_model.output2logits(args.forward_output)\\n out = torch.distributions.Categorical(logits=logits).entropy()\\n if out.ndim > 1:\\n out = out.squeeze(-1)\\n return out\",\n \"def get_entropy(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return sum([-(float(label_count[label]) /\\n total_count) * np.log2(float(label_count[label]) / total_count)\\n for label in label_count.keys()])\",\n \"def call(self, input):\\n for r in range(self.tile_num):\\n for c in range(self.tile_num):\\n # do frequency conv on each tile\\n offset = [[r*self.tile_size+self.tile_size/2, c*self.tile_size+self.tile_size/2] for i in range(BATCHSIZE)]\\n input_tile = tf.image.extract_glimpse(input, \\n [self.tile_size, self.tile_size],\\n offset, centered=False, normalized=False) \\n pad_pixels = (self.fft_size - self.tile_size) / 2\\n input_tile = tf.image.pad_to_bounding_box(\\n input_tile, pad_pixels, pad_pixels, self.fft_size, self.fft_size)\\n\\n input_tile = tf.transpose(input_tile, perm=[0,3,1,2])\\n input_fft = tf.spectral.fft2d(tf.cast(input_tile, tf.complex64))\\n output_fft = tf.multiply(self.kernel_freq, input_fft[0,:])\\n output_fft_accum = tf.reduce_sum(output_fft, 1)\\n output_batch_i = tf.spectral.ifft2d(output_fft_accum)\\n bias_expand = tf.expand_dims(tf.expand_dims(self.bias, 1),1)\\n output_tile_accum = tf.expand_dims(tf.real(output_batch_i) + bias_expand, 0)\\n for b in range(1,BATCHSIZE):\\n output_fft = tf.multiply(self.kernel_freq, input_fft[b,:])\\n output_fft_accum = tf.reduce_sum(output_fft, 1)\\n output_fft_batch_i = tf.spectral.ifft2d(output_fft_accum)\\n bias_expand = tf.expand_dims(tf.expand_dims(self.bias, 1),1)\\n output_tile_accum = tf.concat([output_tile_accum, \\n tf.expand_dims(tf.real(output_fft_batch_i) + bias_expand, 0)],0)\\n\\n # Concat col tiles\\n output_accum_col = output_tile_accum\\n if c != 0:\\n overlap = output_accum_col[:,:,:,-pad_pixels:] + output_tile_accum[:,:,:,0:pad_pixels]\\n output_accum_col = tf.concat([output_accum_col[:,:,:,0:-pad_pixels], \\n overlap, \\n output_tile_accum[:,:,:,pad_pixels:]], \\n 3)\\n # Concat tow output tiles\\n output_accum = output_accum_col\\n if r != 0:\\n overlap = output_accum[:,:,-pad_pixels:,:] + output_accum_col[:,:,0:pad_pixels,:]\\n output_accum = tf.concat([output_accum[:,:,0:-pad_pixels,:], \\n overlap, \\n output_accum_col[:,:,pad_pixels:,:]], \\n 2)\\n\\n output_accum = tf.transpose(output_accum, perm=[0,2,3,1])\\n return tf.image.crop_to_bounding_box(output_accum, 0, 0, self.img_size, self.img_size)\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def entropy(self, priors=None):\\n def entropy_f(x):\\n x[x != 0] *= np.log(x[x != 0])\\n return -x.sum(axis=0)\\n return self.utility(entropy_f, priors)\",\n \"def entropy(rows, resCol = None):\\n from math import log\\n if not resCol: #create the dictionary of counts for each class using pure python\\n total = len(rows)\\n counts = __uniqueCounts(rows)\\n else: #Create the dictionary of counts for each class using pandas.\\n assert 'index' in dir(rows)\\n total = len(rows.index)\\n counts = __uniqueCountsPandas(rows, resCol)\\n log2 = lambda x:log(x)/log(2) #Create a function to take log-base 2 of a number\\n ent = 0 #Initialize the entropy at zero\\n #Implement the formula for entropy, using log-base2\\n fracs = [float(x)/total for x in counts.values()]\\n for x in fracs:\\n ent += -x*log2(x)\\n return ent\",\n \"def build_summaries(self):\\n\\n # Loss summary.\\n tf.summary.scalar('loss', self.loss)\\n\\n merged = tf.summary.merge_all()\\n self.summary_op = merged\\n tf.logging.info('summary op set')\",\n \"def build_summaries(self):\\n\\n # Loss summary.\\n tf.summary.scalar('loss', self.loss)\\n\\n merged = tf.summary.merge_all()\\n self.summary_op = merged\\n tf.logging.info('summary op set')\",\n \"def activation_summaries(endpoints):\\n sum = []\\n with tf.name_scope('summaries'):\\n for act in endpoints.values():\\n tensor_name = act.op.name\\n sum.append(tf.summary.histogram(tensor_name + '/activations', act))\\n # sum.append(tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(act)))\\n return tf.summary.merge(sum)\",\n \"def test_entropy_model_learn_normal():\\n xs = []\\n bs = 128\\n bin_ = 0.1\\n class CFG:\\n pass\\n cfg = CFG()\\n cfg.MODEL = CFG()\\n cfg.MODEL.ENTROPY_MODEL = CFG()\\n cfg.MODEL.ENTROPY_MODEL.DIMS = [3,3,3]\\n cfg.MODEL.ENTROPY_MODEL.SCALE = 10.\\n cfg.MODEL.ENTROPY_MODEL.BIN = bin_\\n entropy_model = EntropyModel(in_channels=2, cfg=cfg).cuda()\\n entropy_model.train()\\n optmizer = torch.optim.AdamW(entropy_model.parameters(), 0.001)\\n for _ in tqdm(range(1000)):\\n x = torch.cat([torch.randn((bs,1)), torch.randn((bs,1))*5], dim=1)\\n xs.append(x.numpy())\\n x = x.cuda()\\n quantized_x, _, loss = entropy_model(x)\\n loss.backward()\\n torch.nn.utils.clip_grad_value_(entropy_model.parameters(), 5.)\\n optmizer.step()\\n optmizer.zero_grad()\\n \\n xs = np.concatenate(xs).squeeze()\\n plt.hist(xs[:,0], bins=100)\\n plt.show()\\n \\n plt.hist(xs[:,1], bins=100)\\n plt.show()\\n \\n with torch.no_grad():\\n sample = torch.stack([torch.linspace(-10,10,10001)]*2,dim=1).cuda()\\n _, prob, _ = entropy_model(sample)\\n plt.plot(sample.cpu().numpy()[:,0], prob.cpu().numpy()[:,0], color=\\\"r\\\")\\n plt.show()\\n plt.plot(sample.cpu().numpy()[:,1], prob.cpu().numpy()[:,1], color=\\\"g\\\")\\n plt.show()\",\n \"def entropy(*args):\\n\\n\\n values = []\\n leaf = -1\\n\\n for i, val in enumerate(args):\\n if(val != 0):\\n values.append(val * math.log(val, len(args)))\\n if(val == 1):\\n leaf = i\\n \\n return -sum(values), leaf\",\n \"def _summary(self):\\n trainable_variable = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n for var in trainable_variable:\\n tf.summary.histogram(var.op.name, var)\\n\\n self.merged_summary_op = tf.summary.merge_all()\",\n \"def _theils_u_compute(confmat: Tensor) ->Tensor:\\n confmat = _drop_empty_rows_and_cols(confmat)\\n s_xy = _conditional_entropy_compute(confmat)\\n total_occurrences = confmat.sum()\\n p_x = confmat.sum(0) / total_occurrences\\n s_x = -torch.sum(p_x * torch.log(p_x))\\n if s_x == 0:\\n return torch.tensor(0, device=confmat.device)\\n return (s_x - s_xy) / s_x\",\n \"def BuildSamplerGraph(self):\\n # Replace with a Tensor of shape [batch_size, max_time, num_samples = 1]\\n self.pred_samples_ = None\\n\\n #### YOUR CODE HERE ####\\n #print(self.logits_.get_shape())\\n #print(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]).get_shape())\\n #self.pred_samples_ = tf.multinomial(self.logits_, 1, name=\\\"pred_samples\\\")\\n \\n #self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]), \\n #1, name=\\\"pred_samples\\\")\\n #self.pred_samples_ = tf.reshape(self.pred_samples_, [self.batch_size_, self.max_time_, 1])\\n \\n #self.pred_samples_ = tf.multinomial(self.logits_, self.logits_.get_shape()[-1], name=\\\"pred_samples\\\")\\n #print(self.pred_samples_.get_shape())\\n \\n with tf.name_scope(\\\"sampling_ops\\\"):\\n self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [-1,self.logits_.get_shape()[-1]]), \\n 1, name=\\\"pred_samples\\\")\\n self.pred_samples_ = tf.reshape(self.pred_samples_, [self.batch_size_, self.max_time_, 1])\\n\\n\\n\\n #### END(YOUR CODE) ####\",\n \"def entropy_computations(\\n self,\\n between_labels=True,\\n between_images=True,\\n between_all_images=False,\\n symmetrized=True,\\n ):\\n jzazbz_dist_dict = self.jzazbz_dist_dict\\n\\n if between_labels:\\n words = self.labels_list\\n labels_entropy_dict = {}\\n labels_entropy_dict_js = {}\\n color_sym_matrix = []\\n color_sym_matrix_js = []\\n\\n for word1 in words:\\n row = []\\n row_js = []\\n for word2 in words:\\n entropy_js = js_divergence(\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n np.mean(np.array(jzazbz_dist_dict[word2]), axis=0),\\n )\\n entropy = kl_divergence(\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n np.mean(np.array(jzazbz_dist_dict[word1]), axis=0),\\n symmetrized,\\n )\\n row.append(entropy)\\n row_js.append(entropy_js)\\n # these lines are for convenience; if strings are correctly synced across all data they are not needed\\n if word1 == \\\"computer science\\\":\\n labels_entropy_dict[\\\"computer_science\\\" + \\\"_\\\" + word2] = entropy\\n labels_entropy_dict_js[\\n \\\"computer_science\\\" + \\\"_\\\" + word2\\n ] = entropy_js\\n elif word2 == \\\"computer science\\\":\\n labels_entropy_dict[word1 + \\\"_\\\" + \\\"computer_science\\\"] = entropy\\n labels_entropy_dict_js[\\n word1 + \\\"_\\\" + \\\"computer_science\\\"\\n ] = entropy_js\\n else:\\n labels_entropy_dict[word1 + \\\"_\\\" + word2] = entropy\\n labels_entropy_dict_js[word1 + \\\"_\\\" + word2] = entropy_js\\n color_sym_matrix.append(row)\\n color_sym_matrix_js.append(row_js)\\n\\n self.cross_entropy_between_labels_dict = labels_entropy_dict\\n self.cross_entropy_between_labels_matrix = color_sym_matrix\\n self.cross_entropy_between_labels_dict_js = labels_entropy_dict_js\\n self.cross_entropy_between_labels_matrix_js = color_sym_matrix_js\\n\\n if between_images:\\n entropy_dict = {}\\n entropy_dict_js = {}\\n for key in jzazbz_dist_dict:\\n entropy_array = []\\n entropy_array_js = []\\n for i in range(len(jzazbz_dist_dict[key])):\\n for j in range(len(jzazbz_dist_dict[key])):\\n entropy_array_js.append(\\n js_divergence(\\n jzazbz_dist_dict[key][i], jzazbz_dist_dict[key][j]\\n )\\n )\\n entropy_array.append(\\n kl_divergence(\\n jzazbz_dist_dict[key][i],\\n jzazbz_dist_dict[key][j],\\n symmetrized,\\n )\\n )\\n entropy_dict[key] = entropy_array\\n entropy_dict_js[key] = entropy_array_js\\n\\n self.cross_entropy_between_images_dict = entropy_dict\\n self.cross_entropy_between_images_dict_js = entropy_dict_js\\n\\n if between_all_images:\\n entropy_dict_all = {}\\n color_sym_matrix_js_all = []\\n\\n for word1 in words:\\n row_js_all = []\\n for word2 in words:\\n entropy_js_all = []\\n for i in range(len(jzazbz_dist_dict[word1])):\\n for j in range(len(jzazbz_dist_dict[word2])):\\n try:\\n entropy_js_all.append(\\n js_divergence(\\n jzazbz_dist_dict[word1][i],\\n jzazbz_dist_dict[word2][j],\\n )\\n )\\n except Exception as exc:\\n self.log.error(exc)\\n entropy_js_all.append(np.mean(entropy_js))\\n entropy_dict_all[word1 + \\\"_\\\" + word2] = entropy_js_all\\n row_js_all.append(np.mean(entropy_js_all))\\n color_sym_matrix_js_all.append(row_js_all)\\n\\n self.cross_entropy_between_all_images_dict = entropy_dict_all\\n self.cross_entropy_between_all_images_matrix = color_sym_matrix_js_all\",\n \"def _build_summaries(self):\\n max_outputs = 3\\n summaries = []\\n\\n # images\\n # ------------------------------------------------\\n summary_input_shape = image_utils.get_image_summary_shape(self._input_shape_visualisation)\\n\\n # input images\\n input_summary_reshape = tf.reshape(self._input_values, summary_input_shape, name='input_summary_reshape')\\n input_summary_op = tf.summary.image('input_images', input_summary_reshape, max_outputs=max_outputs)\\n summaries.append(input_summary_op)\\n\\n # degraded, target and completed images, and histograms where relevant\\n target = self._dual.get_op('target')\\n degraded = self._dual.get_op('degraded')\\n decoding_op = self.get_decoding_op()\\n\\n output_hist = tf.summary.histogram(\\\"output\\\", decoding_op)\\n summaries.append(output_hist)\\n\\n input_hist = tf.summary.histogram(\\\"input\\\", self._input_values)\\n summaries.append(input_hist)\\n\\n # network output when presented with blank\\n blank_output_first = self._dual.get_op('blank_output_first')\\n blank_first = tf.summary.image('blank_first', tf.reshape(blank_output_first, summary_input_shape))\\n summaries.append(blank_first)\\n\\n blank_output_last = self._dual.get_op('blank_output_last')\\n blank_last = tf.summary.image('blank_last', tf.reshape(blank_output_last, summary_input_shape))\\n summaries.append(blank_last)\\n \\n with tf.name_scope('optimize'):\\n completed_summary_reshape = tf.reshape(decoding_op, summary_input_shape, 'completed_summary_reshape')\\n summaries.append(tf.summary.image('b_completed', completed_summary_reshape))\\n\\n if self._hparams.bt_degrade:\\n degraded_summary_reshape = tf.reshape(degraded, summary_input_shape, 'degraded_summary_reshape')\\n summaries.append(tf.summary.image('a_degraded', degraded_summary_reshape))\\n\\n target_summary_reshape = tf.reshape(target, summary_input_shape, 'target_summary_reshape')\\n summaries.append(tf.summary.image('c_target', target_summary_reshape))\\n\\n # display slow weights as images and distributions\\n with tf.name_scope('slow-weights'):\\n w = self._dual.get_op('w')\\n add_square_as_square(summaries, w, 'w')\\n\\n w_hist = tf.summary.histogram(\\\"w\\\", w)\\n summaries.append(w_hist)\\n\\n alpha = self._dual.get_op('alpha')\\n add_square_as_square(summaries, alpha, 'alpha')\\n\\n alpha_hist = tf.summary.histogram(\\\"alpha\\\", alpha)\\n summaries.append(alpha_hist)\\n\\n if self._hparams.bias:\\n bias = self._dual.get_op('bias')\\n bias_image_shape, _ = image_utils.square_image_shape_from_1d(self._hparams.filters)\\n bias_image = tf.reshape(bias, bias_image_shape, name='bias_summary_reshape')\\n summaries.append(tf.summary.image('bias', bias_image))\\n\\n bias_hist = tf.summary.histogram(\\\"bias\\\", bias)\\n summaries.append(bias_hist)\\n\\n # eta\\n eta_op = self._dual.get_op('eta')\\n eta_scalar = tf.reduce_sum(eta_op)\\n eta_summary = tf.summary.scalar('eta', eta_scalar)\\n summaries.append(eta_summary)\\n\\n # x_shift\\n x_shift_op = self._dual.get_op('x_shift')\\n xs_scalar = tf.reduce_sum(x_shift_op)\\n xs_summary = tf.summary.scalar('x_shift', xs_scalar)\\n summaries.append(xs_summary)\\n\\n # display fast weights (eta and hebbian), as image, scalars and histogram\\n with tf.name_scope('fast-weights'):\\n\\n # as images\\n hebb = self._dual.get_op('hebb')\\n add_square_as_square(summaries, hebb, 'hebb')\\n\\n # as scalars\\n hebb_summary = tf_build_stats_summaries_short(hebb, 'hebb')\\n summaries.append(hebb_summary)\\n\\n # as histograms\\n hebb_hist = tf.summary.histogram(\\\"hebb\\\", hebb)\\n summaries.append(hebb_hist)\\n\\n hebb_per_neuron = tf.reduce_sum(tf.abs(hebb), 0)\\n hebb_per_neuron = tf.summary.histogram('hebb_pn', hebb_per_neuron)\\n summaries.append(hebb_per_neuron)\\n\\n # outer products\\n outer_first = self._dual.get_op('outer_first')\\n outer_last = self._dual.get_op('outer_last')\\n add_square_as_square(summaries, outer_first, 'outer_first')\\n add_square_as_square(summaries, outer_last, 'outer_last')\\n\\n # optimization related quantities\\n with tf.name_scope('optimize'):\\n # loss\\n loss_op = self.get_loss_op()\\n loss_summary = tf.summary.scalar('loss', loss_op)\\n summaries.append(loss_summary)\\n\\n # losses as an image\\n losses = self._dual.get_op(\\\"losses\\\")\\n shape = losses.get_shape().as_list()\\n volume = np.prod(shape[1:])\\n losses_image_shape, _ = image_utils.square_image_shape_from_1d(volume)\\n losses_image = tf.reshape(losses, losses_image_shape)\\n summaries.append(tf.summary.image('losses', losses_image))\\n\\n input_stats_summary = tf_build_stats_summaries_short(self._input_values, 'input-stats')\\n summaries.append(input_stats_summary)\\n\\n return summaries\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def scalar():\\n # setup\\n # ---\\n print(\\\"Loading data...\\\")\\n train_y_cpu, train_x_cpu = dataio.bin_to_tensors(constants.TRAIN_BIAS)\\n val_y_cpu, val_x_cpu = dataio.bin_to_tensors(constants.VAL_BIAS)\\n\\n print(\\\"Moving data to GPU...\\\")\\n train_y = train_y_cpu.type(IntTT)\\n train_x = train_x_cpu.type(FloatTT)\\n val_y = val_y_cpu.type(IntTT)\\n val_x = val_x_cpu.type(FloatTT)\\n\\n print(\\\"Starting experiments...\\\")\\n dummy = 0.0\\n\\n # OLS\\n # ---\\n\\n # OLS analytic solution. uses CPU tensors to go to/from numpy for pseudoinverse.\\n w = ols_analytic(train_x_cpu, train_y_cpu)\\n loss_ols = ols_loss(w, train_x, train_y.type(FloatTT))\\n report(\\n \\\"[scalar] OLS analytic (train)\\\",\\n w,\\n train_x,\\n train_y,\\n dummy,\\n scalar_eval,\\n ols_loss,\\n )\\n report(\\\"[scalar] OLS analytic (val)\\\", w, val_x, val_y, dummy, scalar_eval, ols_loss)\\n\\n # plot of ols accuracy\\n _, _, ols_acc = accuracy(val_x, val_y, w, scalar_eval)\\n viewer.plot_bar(\\n torch.FloatTensor([ols_acc, 0.0]),\\n [\\\"OLS\\\"],\\n \\\"Validation Accuracy\\\",\\n dict(ytickmin=0.0, ytickmax=100.0, xtickvals=[1], xticklabels=[\\\"OLS\\\"]),\\n )\\n return\\n\\n # OLS gradient descent\\n ols_gd_settings: GDSettings = {\\\"lr\\\": 0.02, \\\"epochs\\\": 1500, \\\"report_interval\\\": 10}\\n w, record = gradient_descent(\\n train_x, train_y, -1, ols_loss, ols_gradient, ols_gd_settings\\n )\\n report(\\\"[scalar] OLS GD (train)\\\", w, train_x, train_y, dummy, scalar_eval, ols_loss)\\n report(\\\"[scalar] OLS GD (val)\\\", w, val_x, val_y, dummy, scalar_eval, ols_loss)\\n\\n # plot OLS GD\\n xs = torch.FloatTensor(sorted(list(record.keys())))\\n viewer.plot_line(\\n xs,\\n torch.stack(\\n [\\n torch.FloatTensor(torch.ones(len(xs)) * loss_ols),\\n torch.FloatTensor([record[k] for k in sorted(list(record.keys()))]),\\n ]\\n ),\\n [\\\"Analytic\\\", \\\"Gradient descent\\\"],\\n \\\"OLS Gradient Descent\\\",\\n dict(xlabel=\\\"GD steps (epochs)\\\", ylabel=\\\"Loss\\\", ytype=\\\"log\\\"),\\n )\\n\\n # OLS coordinate descent\\n w, record = coordinate_descent(\\n train_x,\\n train_y,\\n dummy,\\n ols_cd_weight_update,\\n ols_loss,\\n {\\\"epochs\\\": 150, \\\"report_interval\\\": 10},\\n )\\n report(\\n \\\"[scalar] Coordinate descent (train)\\\",\\n w,\\n train_x,\\n train_y,\\n dummy,\\n scalar_eval,\\n ols_loss,\\n )\\n report(\\n \\\"[scalar] Coordinate descent (val)\\\",\\n w,\\n val_x,\\n val_y,\\n dummy,\\n scalar_eval,\\n ols_loss,\\n )\\n\\n # plot OLS CD\\n xs = torch.FloatTensor(sorted(list(record.keys())))\\n viewer.plot_line(\\n xs,\\n torch.stack(\\n [\\n torch.FloatTensor(torch.ones(len(xs)) * loss_ols),\\n torch.FloatTensor([record[k] for k in sorted(list(record.keys()))]),\\n ]\\n ),\\n [\\\"Analytic\\\", \\\"Coordinate descent\\\"],\\n \\\"OLS Coordinate Descent\\\",\\n dict(xlabel=\\\"CD epochs\\\", ylabel=\\\"Loss\\\", ytype=\\\"log\\\"),\\n )\\n\\n # ridge\\n # ---\\n\\n # ridge analytic solution\\n for lmb in [0.2]:\\n w = ridge_analytic(train_x, train_y, lmb)\\n # code.interact(local=dict(globals(), **locals()))\\n report(\\n \\\"[scalar] Ridge analytic (train) lambda={}\\\".format(lmb),\\n w,\\n train_x,\\n train_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n report(\\n \\\"[scalar] Ridge analytic (val) lambda={}\\\".format(lmb),\\n w,\\n val_x,\\n val_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n\\n # ridge GD\\n ridge_gd_settings: GDSettings = {\\\"lr\\\": 0.02, \\\"epochs\\\": 500, \\\"report_interval\\\": 100}\\n for lmb in [0.2]:\\n w, record = gradient_descent(\\n train_x, train_y, lmb, ridge_loss, ridge_gradient, ridge_gd_settings\\n )\\n report(\\n \\\"[scalar] Ridge GD (train) lambda={}\\\".format(lmb),\\n w,\\n train_x,\\n train_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n report(\\n \\\"[scalar] Ridge GD (val) lambda={}\\\".format(lmb),\\n w,\\n val_x,\\n val_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n\\n # ridge CD\\n ridge_cd_settings: CDSettings = {\\\"epochs\\\": 150, \\\"report_interval\\\": 10}\\n for lmb in [0.2]:\\n w, record = coordinate_descent(\\n train_x, train_y, lmb, ridge_cd_weight_update, ridge_loss, ridge_cd_settings\\n )\\n report(\\n \\\"[scalar] Ridge CD (train) lambda={}\\\".format(lmb),\\n w,\\n train_x,\\n train_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n report(\\n \\\"[scalar] Ridge CD (val) lambda={}\\\".format(lmb),\\n w,\\n val_x,\\n val_y,\\n lmb,\\n scalar_eval,\\n ridge_loss,\\n )\\n\\n # lasso GD\\n lasso_gd_settings: GDSettings = {\\\"lr\\\": 0.02, \\\"epochs\\\": 1000, \\\"report_interval\\\": 100}\\n for lmb in [0.2]:\\n w, record = gradient_descent(\\n train_x, train_y, lmb, lasso_loss, lasso_gradient, lasso_gd_settings\\n )\\n report(\\n \\\"[scalar] Lasso GD (train) lambda={}\\\".format(lmb),\\n w,\\n train_x,\\n train_y,\\n lmb,\\n scalar_eval,\\n lasso_loss,\\n )\\n report(\\n \\\"[scalar] Lasso GD (val) lambda={}\\\".format(lmb),\\n w,\\n val_x,\\n val_y,\\n lmb,\\n scalar_eval,\\n lasso_loss,\\n )\\n\\n # lasso CD\\n lasso_cd_settings: CDSettings = {\\\"epochs\\\": 100, \\\"report_interval\\\": 10}\\n for lmb in [0.2]:\\n w, record = coordinate_descent(\\n train_x, train_y, lmb, lasso_cd_weight_update, lasso_loss, lasso_cd_settings\\n )\\n report(\\n \\\"[scalar] Lasso CD (train) lambda={}\\\".format(lmb),\\n w,\\n train_x,\\n train_y,\\n lmb,\\n scalar_eval,\\n lasso_loss,\\n )\\n report(\\n \\\"[scalar] Lasso CD (val) lambda={}\\\".format(lmb),\\n w,\\n val_x,\\n val_y,\\n lmb,\\n scalar_eval,\\n lasso_loss,\\n )\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def get_entropy(*labels):\\n entropies = [] #list of entropy values from each subset\\n total = 0 #total number of datapoints\\n for subset in labels:\\n n = len(subset)\\n total += n\\n counts = np.unique(subset, return_counts=True)[1] #frequency of unique values\\n entropy = np.sum([-(i/n) * np.log2(i/n) for i in counts]) #subset entropy calcuation\\n entropies.append((entropy, n))\\n return np.sum([(n/total) * ent for n, ent in iter(entropies)])\",\n \"def entropy(p):\\n ent = tf.where(p > np.finfo(np.float32).eps, -p * tf.log(p), tf.zeros_like(p))\\n ent = tf.reduce_sum(ent, axis=1)\\n return ent\",\n \"def entropy(data):\\n n, m = np.shape(data)\\n data = np.tanh(data)\\n data = data / np.sum(data, axis=0)\\n a = data * 1.0\\n a[np.where(data == 0)] = 0.000001\\n\\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\\n w = (1 - e) / np.sum(1 - e)\\n return w\",\n \"def BuildSamplerGraph(self):\\n # return a Tensor of shape [batch_size, max_time, 1]\\n #self.pred_samples_ = tf.multinomial(tf.reshape(self.logits_, [1, VOCAB_SIZE]), num_samples=1)\\n self.pred_samples_ = tf.argmax(tf.reshape(self.logits_, [VOCAB_SIZE]), tf.constant(0))\\n self.pred_samples_ = tf.reshape(self.pred_samples_, [1])\",\n \"def _activation_summary(x):\\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n tf.summary.histogram(tensor_name + '/activations', x)\\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def _build(self):\\n self.autoencoder = autoencoder(\\n images = self.images,\\n name = 'autoencoder')\\n # self.hash = self.autoencoder.hash\\n self.z = tf.placeholder(tf.float32, shape = [None, CODEWORD_LENGTH], \\n name = 'z-layer') \\n with tf.variable_scope('latent_space') as scope:\\n for i in range(CODEWORD_LENGTH):\\n tf.summary.histogram('z_' + str(i) ,self.z[:,i]) \\n tf.summary.histogram('codeword_' + str(i), self.autoencoder.codeword[:,i])\\n self.generator = gan_generator( z = self.z,\\n input_params = self.autoencoder.params,\\n name = 'gan_generator')\\n self.discriminator = gan_discriminator ( images = self.images,\\n generation = self.generator.generation,\\n name = 'gan_discriminator' )\\n self.generator.cook(fake = self.discriminator.fake)\\n mean_z, var_z = tf.nn.moments(self.z, axes=[0])\\n mean_codeword, var_codeword = tf.nn.moments(self.autoencoder.codeword, axes = [0])\\n\\n with tf.variable_scope ('divergence') as scope:\\n tf.summary.scalar( tensor = tf.nn.l2_loss(mean_z-mean_codeword), name = 'mean divergence')\\n tf.summary.scalar( tensor = tf.nn.l2_loss(var_z-var_codeword), name = 'variance divergence')\\n # divergence = self.hash \",\n \"def update_state(self, logits, labels):\\n labels = labels.unsqueeze(dim=1) #.cuda() # N,1,H,W\\n predictions = logits.max(axis=1)[1].unsqueeze(dim=1) #.cuda() # N,1,H,W\\n preds_1hot = torch.zeros_like(logits, dtype=bool).scatter_(1, predictions, True)#.cuda()\\n labels_1hot = torch.zeros_like(logits, dtype=bool).scatter_(1, labels, True)#.cuda()\\n\\n if self.debug:\\n if torch.cuda.is_available():\\n for t in ['labels','preditions','preds_1hot','labels_1hot']:\\n assert t.is_cuda\\n assert logits.shape[0] == labels.shape[0]\\n assert logits.shape == preds_1hot.shape\\n assert logits.shape[1] >= labels.max()\\n assert preds_1hot.shape == labels_1hot.shape\\n assert preds_1hot.max() == labels_1hot.max() == 1\\n assert preds_1hot.min() == labels_1hot.min() == 0\\n assert preds_1hot.sum() == labels_1hot.sum() == logits.shape[0]*logits.shape[2]* logits.shape[3]\\n\\n self.tensors['TP'] += torch.sum(preds_1hot & labels_1hot , dim=(0, 2, 3)).double() # casting to double required for Cuda 10.0, not required for Cuda 10.1\\n self.tensors['TN'] += torch.sum(~ preds_1hot & ~ labels_1hot , dim=(0, 2, 3)).double()\\n self.tensors['FP'] += torch.sum(preds_1hot & ~ labels_1hot, dim=(0, 2, 3)).double()\\n self.tensors['FN'] += torch.sum(~ preds_1hot & labels_1hot, dim=(0, 2, 3)).double()\\n self.tensors['PX_CNT'] += torch.sum(labels_1hot , dim=(0, 2, 3)).double()\\n self.tensors['samples_evaluated'] += logits.shape[0]\\n \\n if self.debug:\\n if torch.cuda.is_available():\\n for t in self.tensors: assert self.tensors[t].is_cuda\",\n \"def entropycell(self):\\n cells = [0] * self.k\\n for i in range(self.width):\\n cells[int(self.config[self.t, i])] += 1\\n\\n \\\"\\\"\\\"Calculates the Shannon entropy and the the average entropy so far.\\\"\\\"\\\"\\n shannon = 0\\n for i in range(self.k):\\n if(cells[i] != 0):\\n probability = cells[i] / self.width\\n shannon -= probability * np.log2(probability)\\n self.average_cell = (self.average_cell * self.t + shannon) / (self.t + 1)\",\n \"def main():\\n # lr_decay = 0.5\\n # decay_every = 100\\n args = get_arguments()\\n \\n h, w = map(int, args.input_size.split(','))\\n input_size = (h, w)\\n \\n tf.set_random_seed(args.random_seed)\\n \\n coord = tf.train.Coordinator()\\n \\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(\\n args.data_list,\\n input_size,\\n args.random_scale,\\n args.random_mirror,\\n args.ignore_label,\\n IMG_MEAN,\\n coord)\\n image_batch, label_batch = reader.dequeue(args.batch_size)\\n \\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n # config.gpu_options.allow_growth = True\\n # config.allow_soft_placement = True\\n # config.intra_op_parallelism_threads = 1\\n sess = tf.Session(config = config)\\n net = unext(image_batch, is_train = True, reuse = False, n_out = NUM_CLASSES)\\n \\n # Predictions: ignoring all predictions with labels greater or equal than n_classes\\n raw_output = net.outputs\\n raw_prediction = tf.reshape(raw_output, [-1, args.num_classes])\\n label_proc = prepare_label(label_batch, tf.stack(raw_output.get_shape()[1:3]), num_classes=args.num_classes, one_hot=False) # [batch_size, h, w]\\n raw_gt = tf.reshape(label_proc, [-1,])\\n indices = tf.squeeze(tf.where(tf.less_equal(raw_gt, args.num_classes - 1)), 1)\\n gt = tf.cast(tf.gather(raw_gt, indices), dtype = tf.int32)\\n prediction = tf.gather(raw_prediction, indices)\\n \\n main_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = prediction, labels = gt)\\n\\n t_vars = tf.trainable_variables()\\n l2_losses = [args.weight_decay * tf.nn.l2_loss(v) for v in t_vars if 'kernel' in v.name]\\n #reduced_loss = 0.5 * tf.reduce_mean(main_loss) + generalised_dice_loss(prediction, gt) + tf.add_n(l2_losses)\\n reduced_loss = tf.reduce_mean(main_loss) + tf.add_n(l2_losses)\\n\\n # Processed predictions: for visualisation.\\n raw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\\n raw_output_up = tf.argmax(raw_output_up, dimension = 3)\\n pred = tf.expand_dims(raw_output_up, dim = 3)\\n \\n # Image summary.\\n images_summary = tf.py_func(inv_preprocess, [image_batch, args.save_num_images, IMG_MEAN], tf.uint8)\\n labels_summary = tf.py_func(decode_labels, [label_batch, args.save_num_images, args.num_classes], tf.uint8)\\n preds_summary = tf.py_func(decode_labels, [pred, args.save_num_images, args.num_classes], tf.uint8)\\n \\n total_summary = tf.summary.image('images', \\n tf.concat(axis=2, values=[images_summary, labels_summary, preds_summary]), \\n max_outputs=args.save_num_images) # Concatenate row-wise.\\n loss_summary = tf.summary.scalar('TotalLoss', reduced_loss)\\n summary_writer = tf.summary.FileWriter(args.snapshot_dir,\\n graph=tf.get_default_graph())\\n\\n # Using Poly learning rate policy \\n base_lr = tf.constant(args.learning_rate)\\n step_ph = tf.placeholder(dtype=tf.float32, shape=())\\n learning_rate = tf.train.exponential_decay(base_lr, step_ph, args.num_steps, args.power)\\n\\n lr_summary = tf.summary.scalar('LearningRate', learning_rate)\\n #train_op = tf.train.MomentumOptimizer(learning_rate, args.momentum).minimize(reduced_loss, var_list = t_vars)\\n train_op = tf.train.AdamOptimizer(learning_rate).minimize(reduced_loss, var_list = t_vars)\\n init = tf.global_variables_initializer()\\n sess.run(init)\\n \\n # Saver for storing checkpoints of the model.\\n saver = tf.train.Saver(var_list = tf.global_variables(), max_to_keep = 10)\\n\\n ckpt = tf.train.get_checkpoint_state(SNAPSHOT_DIR)\\n if ckpt and ckpt.model_checkpoint_path:\\n #restore_vars = list([t for t in tf.global_variables() if not 'uconv1' in t.name])\\n loader = tf.train.Saver(var_list = tf.global_variables())\\n load_step = int(os.path.basename(ckpt.model_checkpoint_path).split('-')[1])\\n load(loader, sess, ckpt.model_checkpoint_path)\\n else:\\n print('No checkpoint file found.')\\n load_step = 0\\n\\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord = coord, sess = sess)\\n\\n # Iterate over training steps.\\n save_summary_every = 10\\n for step in range(args.num_steps):\\n start_time = time.time()\\n \\n feed_dict = {step_ph: step}\\n if not step % args.save_pred_every == 0:\\n loss_value, _, l_summary, lr_summ = sess.run([reduced_loss, train_op, loss_summary, lr_summary], feed_dict=feed_dict)\\n duration = time.time() - start_time\\n elif step % args.save_pred_every == 0:\\n loss_value, _, summary, l_summary, lr_summ = sess.run([reduced_loss, train_op, total_summary, loss_summary, lr_summary], feed_dict=feed_dict)\\n duration = time.time() - start_time\\n save(saver, sess, args.snapshot_dir, step)\\n summary_writer.add_summary(summary, step)\\n\\n if step % save_summary_every == 0:\\n \\n summary_writer.add_summary(l_summary, step)\\n summary_writer.add_summary(lr_summ, step)\\n \\n print('step {:d} \\\\t loss = {:.3f}, ({:.3f} sec/step)'.format(step, loss_value, duration))\\n \\n coord.request_stop()\\n coord.join(threads)\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def __init__(self, dims, act = 'relu', random_seed = 201809, splitseed = 215, optimizer = Adam(),\\n weights_dir = 'CarDEC Count Weights', n_features = 32, mode = 'HVG'):\\n \\n super(count_model, self).__init__()\\n\\n tf.keras.backend.clear_session()\\n \\n self.mode = mode\\n self.name_ = mode + \\\" Count\\\"\\n \\n if mode == 'HVG':\\n self.embed_name = 'embedding'\\n else:\\n self.embed_name = 'LVG embedding'\\n \\n self.weights_dir = weights_dir\\n \\n self.dims = dims\\n n_stacks = len(dims) - 1\\n \\n self.optimizer = optimizer\\n self.random_seed = random_seed\\n self.splitseed = splitseed\\n \\n random.seed(random_seed)\\n np.random.seed(random_seed)\\n tf.random.set_seed(random_seed)\\n \\n self.activation = act\\n self.MeanAct = lambda x: tf.clip_by_value(tf_exp(x), 1e-5, 1e6)\\n self.DispAct = lambda x: tf.clip_by_value(tf.nn.softplus(x), 1e-4, 1e4)\\n \\n model_layers = []\\n for i in range(n_stacks - 1, 0, -1):\\n model_layers.append(Dense(dims[i], kernel_initializer = \\\"glorot_uniform\\\", activation = self.activation\\n , name='base%d' % (i-1)))\\n self.base = Sequential(model_layers, name = 'base')\\n\\n self.mean_layer = Dense(dims[0], activation = self.MeanAct, name='mean')\\n self.disp_layer = Dense(dims[0], activation = self.DispAct, name='dispersion')\\n\\n self.rescale = Lambda(lambda l: tf.matmul(tf.linalg.diag(l[0]), l[1]), name = 'sf scaling')\\n \\n build_dir(self.weights_dir)\\n \\n self.construct(n_features, self.name_)\",\n \"def entropy(probs, name=None):\\n with tf.name_scope(name, \\\"Entropy\\\", [probs]):\\n entropy_matrix = - probs * tf.log(probs)\\n entropy_vec = tf.reduce_sum(entropy_matrix, reduction_indices=[1], keep_dims=False)\\n return entropy_vec\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def __init__(self, n_actions, hidden=1024, learning_rate=0.00001, \\n frame_height=84, frame_width=84, agent_history_length=4):\\n self.n_actions = n_actions\\n self.hidden = hidden\\n self.learning_rate = learning_rate\\n self.frame_height = frame_height\\n self.frame_width = frame_width\\n self.agent_history_length = agent_history_length\\n \\n self.input = tf.placeholder(shape=[None, self.frame_height, \\n self.frame_width, self.agent_history_length], \\n dtype=tf.float32)\\n # Normalizing the input\\n self.input_scaled = self.input/255\\n \\n # Convolutional layers\\n self.conv1 = tf.layers.conv2d(\\n inputs=self.input_scaled, filters=32, kernel_size=[8, 8], strides=4,\\n kernel_initializer=tf.variance_scaling_initializer(scale=2),\\n padding=\\\"valid\\\", activation=tf.nn.relu, use_bias=False, name='conv1')\\n self.conv2 = tf.layers.conv2d(\\n inputs=self.conv1, filters=64, kernel_size=[4, 4], strides=2, \\n kernel_initializer=tf.variance_scaling_initializer(scale=2),\\n padding=\\\"valid\\\", activation=tf.nn.relu, use_bias=False, name='conv2')\\n self.conv3 = tf.layers.conv2d(\\n inputs=self.conv2, filters=64, kernel_size=[3, 3], strides=1, \\n kernel_initializer=tf.variance_scaling_initializer(scale=2),\\n padding=\\\"valid\\\", activation=tf.nn.relu, use_bias=False, name='conv3')\\n self.conv4 = tf.layers.conv2d(\\n inputs=self.conv3, filters=hidden, kernel_size=[7, 7], strides=1, \\n kernel_initializer=tf.variance_scaling_initializer(scale=2),\\n padding=\\\"valid\\\", activation=tf.nn.relu, use_bias=False, name='conv4')\\n \\n # Splitting into value and advantage stream\\n self.value_stream, self.advantagestream = tf.split(self.conv4, 2, 3)\\n self.value_stream = tf.layers.flatten(self.value_stream)\\n self.advantagestream = tf.layers.flatten(self.advantagestream)\\n self.advantage = tf.layers.dense(\\n inputs=self.advantagestream, units=self.n_actions,\\n kernel_initializer=tf.variance_scaling_initializer(scale=2), name=\\\"advantage\\\")\\n self.value = tf.layers.dense(\\n inputs=self.value_stream, units=1, \\n kernel_initializer=tf.variance_scaling_initializer(scale=2), name='value')\\n \\n # Combining value and advantage into Q-values as described above\\n self.q_values = self.value + tf.subtract(self.advantage, tf.reduce_mean(self.advantage, axis=1, keepdims=True))\\n self.best_action = tf.argmax(self.q_values, 1)\\n \\n ###################\\n # Parameter update.\\n ###################\\n \\n # targetQ according to Bellman equation: \\n # Q = r + gamma*max Q', calculated in the function learn()\\n self.target_q = tf.placeholder(shape=[None], dtype=tf.float32)\\n self.action = tf.placeholder(shape=[None], dtype=tf.int32)\\n self.Q = tf.reduce_sum(tf.multiply(self.q_values, tf.one_hot(self.action, self.n_actions, dtype=tf.float32)), axis=1)\\n \\n # Parameter updates\\n # DeepMind uses the quadratic cost function with error clipping (see https://www.nature.com/articles/nature14236/)\\n # See https://machinelearningmastery.com/exploding-gradients-in-neural-networks/\\n self.loss = tf.reduce_mean(tf.losses.huber_loss(labels=self.target_q, predictions=self.Q))\\n \\n # Consider using the RMS optimizer: https://arxiv.org/abs/1710.02298 - RMSProp was substituted for Adam with a learning rate of 0.0000625\\n self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\\n self.update = self.optimizer.minimize(self.loss)\",\n \"def _special_handle_onehot(cls, op, X, W):\\n tensor_list = []\\n append_inputs = {\\n \\\"depth\\\": op.depth,\\n \\\"values\\\": op.values,\\n }\\n for tmp_name, append_input in append_inputs.items():\\n node_name = op.name + \\\":\\\" + tmp_name\\n tensor_list.append(\\n numpy_helper.from_array(np.array(append_input), node_name))\\n return tensor_list\",\n \"def _activation_summary(x):\\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n # session. This helps the clarity of presentation on tensorboard.\\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n tf.histogram_summary(tensor_name + '/activations', x)\\n tf.scalar_summary(tensor_name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def _activation_summary(x):\\n\\t# Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n\\t# session. This helps the clarity of presentation on tensorboard.\\n\\ttensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n\\ttf.summary.histogram(tensor_name + '/activations', x)\\n\\ttf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def entropy(img):\\n # by calculating\\n histogram = img.histogram()\\n histogram_size = sum(histogram)\\n histogram = [float(h) / histogram_size for h in histogram]\\n\\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])\",\n \"def _initalize_state(self):\\n\\n self.memories.append(tf.tanh(\\n tf.random_normal(shape=(self.memory_capacity, self.memory_vector_size), stddev=0.5)))\\n self.ww_t.append(tf.nn.softmax(tf.range(self.memory_capacity, 0, -1, dtype=tf.float32)))\\n self.rw_t.append(tf.nn.softmax(tf.range(self.memory_capacity, 0, -1, dtype=tf.float32)))\\n self.r_t.append(tf.tanh(tf.random_normal(shape=(self.memory_vector_size,), stddev=0.5)))\",\n \"def get_entropy(self, x_dict={}, sum_features=True, feature_dims=None):\\n raise NotImplementedError()\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def compute_logits(self):\\n # [num train labels, num classes] where each row is a one-hot-encoded label.\\n one_hot_train_labels = tf.one_hot(self.data.train_labels, self.way)\\n\\n # Undocumented in the paper, but *very important*: *only* the support set\\n # embeddings is L2-normalized, which means that the distance is not exactly\\n # a cosine distance. For comparison we also allow for the actual cosine\\n # distance to be computed, which is controlled with the\\n # `exact_cosine_distance` instance attribute.\\n train_embeddings = tf.nn.l2_normalize(\\n self.train_embeddings, 1, epsilon=1e-3)\\n test_embeddings = self.test_embeddings\\n if self.exact_cosine_distance:\\n test_embeddings = tf.nn.l2_normalize(test_embeddings, 1, epsilon=1e-3)\\n # [num_test_images, num_train_images]\\n similarities = tf.matmul(\\n test_embeddings, train_embeddings, transpose_b=True)\\n attention = tf.nn.softmax(similarities)\\n\\n # [num_test_images, way]\\n probs = tf.matmul(attention, one_hot_train_labels)\\n self.test_logits = tf.log(probs)\\n return self.test_logits\",\n \"def compute_loss(\\n action_probs: tf.Tensor, values: tf.Tensor, returns: tf.Tensor\\n) -> tf.Tensor:\\n\\n advantage = returns - values\\n td = tf.subtract(returns, values)\\n\\n # actor\\n # action_log_probs = tf.math.log(action_probs)\\n # actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)\\n action_log_probs = tf.math.log(action_probs)\\n actor_loss = -tf.math.reduce_mean(action_log_probs * td)\\n\\n # critic\\n # td = tf.subtract(returns, values)\\n # critic_loss = tf.reduce_mean(tf.square(td))\\n critic_loss = huber_loss(values, returns)\\n\\n tf.print(\\\"a_loss:\\\", actor_loss, \\\"c_loss:\\\", critic_loss)\\n\\n return actor_loss + critic_loss\",\n \"def _make_summaries(self):\\n\\n self.summaries['loss'] = tf.summary.scalar('loss', self.loss)\\n\\n self.summaries['0_inputs_outputs'] = \\\\\\n tf.summary.image('0_inputs_outputs', tf.concat([\\n tf.expand_dims(tf.expand_dims(tf.stack(self.inputs, axis=-1), axis=0), axis=-1),\\n tf.ones(shape=(1, self.input_vector_size, 1, 1)), # white separator\\n tf.expand_dims(tf.expand_dims(tf.stack(self.outputs, axis=-1), axis=0), axis=-1)],\\n axis=2))\\n\\n self.summaries['1_write_and_read_locations'] = \\\\\\n tf.summary.image('1_write_and_read_locations', tf.concat([\\n tf.expand_dims(tf.expand_dims(tf.stack(self.ww_t, axis=-1), axis=0), axis=-1),\\n tf.ones(shape=(1, self.memory_capacity, 1, 1)), # white separator\\n tf.expand_dims(tf.expand_dims(tf.stack(self.rw_t, axis=-1), axis=0), axis=-1)],\\n axis=2))\\n\\n self.summaries['2_memory'] = \\\\\\n tf.summary.image('2_memory', tf.expand_dims(tf.expand_dims(self.memories[-1], axis=0), axis=-1))\\n\\n self.summaries['3_add_read_vectors'] = \\\\\\n tf.summary.image('3_add_read_vectors', tf.concat([\\n tf.expand_dims(tf.expand_dims(tf.stack(self.a_t, axis=-1), axis=0), axis=-1),\\n tf.ones(shape=(1, self.memory_vector_size, 1, 1)), # white separator\\n tf.expand_dims(tf.expand_dims(tf.stack(self.r_t, axis=-1), axis=0), axis=-1)],\\n axis=2))\\n\\n self.summaries['4_erase_vectors'] = \\\\\\n tf.summary.image('4_erase_vectors',\\n tf.expand_dims(tf.expand_dims(tf.stack(self.e_t, axis=-1), axis=0), axis=-1))\\n\\n self.loss_summarization = tf.summary.merge([self.summaries['loss']])\\n self.summarization = tf.summary.merge_all()\\n\\n logs_dir = join(self.logdir, 'seq_len_{:02d}'.format(self.sequence_length))\\n\\n # make summary dir\\n if not exists(logs_dir):\\n os.makedirs(logs_dir)\\n self.train_writer = tf.summary.FileWriter(logs_dir, self.sess.graph)\",\n \"def compute_HOG(self,image_tensor):\\n image_idx = image_tensor.size()[0] #size (6, C, H, W)\\n hogs = list()\\n # iterate through each generated image\\n for i in range(image_idx):\\n image = image_tensor[i,:,:,:]\\n image = image.numpy()\\n # revert normalization\\n x = np.zeros_like(image)\\n x[0, :, :] = image[0, :, :] * STD[0] + MEAN[0]\\n x[1, :, :] = image[1, :, :] * STD[1] + MEAN[1]\\n x[2, :, :] = image[2, :, :] * STD[2] + MEAN[2]\\n x = x*255\\n cv_x = x.astype(np.uint8)\\n # transpose dimensions since hog implementation requires image to be (M, N[, C]) ndarray\\n cv_x = np.transpose(cv_x, (1,2,0))\\n\\n # 27*27*36\\n hist = hog(cv_x, orientations=8, pixels_per_cell=(16, 16),\\n cells_per_block=(3, 3), visualize=False, feature_vector=True, multichannel=True)\\n hist = torch.from_numpy(hist)\\n hogs.append(hist)\\n hogs_tensor = torch.stack(hogs, dim=0)\\n \\n \\n return hogs_tensor\",\n \"def setup_observation_term(background_data_dict,\\n obs_type_vector, obs_data_vector, obs_lat_vector, obs_lon_vector,\\n background_type_vector, background_data_vector, background_lat_vector, background_lon_vector,\\n direct_obs_operator,\\n analysis_increment_vector_symbol,\\n increment_data=0.001):\\n linearized_obs_operator = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), len(background_type_vector))))\\n background_derived_obs = sympy.Matrix(\\n numpy.ones((len(obs_type_vector), 1)))\\n\\n for i_obs in range(0, len(obs_data_vector)):\\n cur_obs_type = str(obs_type_vector[i_obs])\\n cur_obs_lat = float(obs_lat_vector[i_obs])\\n cur_obs_lon = float(obs_lon_vector[i_obs])\\n\\n cur_bk_derived_obs_operator = direct_obs_operator[cur_obs_type]\\n required_bk_vars = cur_bk_derived_obs_operator.free_symbols\\n \\n # 1. calculate h(x):\\n bkg_shape = background_data_dict['lat'].shape\\n bkg_weight_0 = 0\\n bkg_weight_1 = 0\\n for ii in range(0, bkg_shape[0]):\\n for jj in range(0, bkg_shape[1]):\\n cur_bk_lat = background_data_dict['lat'][ii, jj]\\n cur_bk_lon = background_data_dict['lon'][ii, jj]\\n\\n cur_obs_operator_input = {}\\n for required_bk_var in required_bk_vars:\\n cur_obs_operator_input[str(required_bk_var)] = background_data_dict[str(required_bk_var)][ii, jj]\\n\\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = (direct_obs_operator[cur_obs_type].subs(cur_obs_operator_input))/float(cur_distance**2)\\n cur_distance_weight_1 = 1.0/float(cur_distance**2)\\n bkg_weight_0 = bkg_weight_0 + cur_distance_weight_0\\n bkg_weight_1 = bkg_weight_1 + cur_distance_weight_1\\n \\n background_derived_obs[i_obs, 0] = bkg_weight_0/bkg_weight_1\\n final_bkg_weight_1 = bkg_weight_1\\n \\n # 2. find linearized observation operator\\n # n = 0\\n for i_bkg in range(0, len(background_type_vector)):\\n cur_bk_lat = float(background_lat_vector[i_bkg])\\n cur_bk_lon = float(background_lon_vector[i_bkg])\\n cur_bk_type = str(background_type_vector[i_bkg])\\n \\n cur_distance = math.sqrt((cur_obs_lat - cur_bk_lat)**2 + (cur_obs_lon - cur_bk_lon)**2)\\n cur_distance_weight_0 = cur_distance ** 2\\n distance_term = 1.0/(cur_distance_weight_0 * final_bkg_weight_1)\\n \\n l = sympy.diff(direct_obs_operator[cur_obs_type], cur_bk_type)\\n linearized_obs_operator[i_obs, i_bkg] = distance_term*l.subs(\\n {cur_bk_type: float(background_data_vector[i_bkg])})\\n \\n linearized_obs_operator_with_increments = \\\\\\n linearized_obs_operator*analysis_increment_vector_symbol\\n \\n # get the innovation:\\n innovation = obs_data_vector - background_derived_obs - \\\\\\n linearized_obs_operator_with_increments\\n return linearized_obs_operator, innovation, background_derived_obs\",\n \"def calc_entropy(data_set):\\n size = len(data_set)\\n label_counts = {}\\n for feat_vector in data_set:\\n label = feat_vector[-1]\\n label_counts.setdefault(label, 0)\\n label_counts[label] += 1\\n\\n entropy = 0.0\\n for key, count in label_counts.iteritems():\\n prob = float(count) / size\\n entropy -= prob * log(prob, 2)\\n\\n return entropy\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def __init__(self):\\n self.sum_of_node_inputs = 0\\n self.output = 0\\n self.delta = 0\\n self.dp = 0\\n self.onehot_label = 0\",\n \"def calculate_entropy(dataset) :\\n\\n num_entries = len(dataset)\\n label_counts = {}\\n for vector in dataset :\\n # the label is at the last index of the data set\\n current_label = vector[-1]\\n if current_label not in label_counts :\\n label_counts[current_label] = 0\\n label_counts[current_label] += 1\\n # Calculate the entropy\\n entropy = 0.0\\n for label in label_counts :\\n # Calculate probability of each label within the dataset\\n prob_of_label = label_counts[label]/num_entries\\n # Since the entropy is the negative of the sum of all probability,\\n # simply subtract it\\n entropy -= prob_of_label * log(prob_of_label, 2)\\n return entropy\",\n \"def entropy_loss(policy_logits):\\n\\n softmax = nn.Softmax(dim=-1)\\n logsoftmax = nn.LogSoftmax(dim=-1)\\n\\n policy = softmax(policy_logits.action_type)\\n log_policy = logsoftmax(policy_logits.action_type)\\n\\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [0] * 10\\n self.softmaxvalues = [0] * 10\\n self.t = 0.3\",\n \"def _create_counter(self):\\n iter_cotrain = tf.get_variable(\\n name='iter_cotrain',\\n initializer=tf.constant(0, name='iter_cotrain'),\\n use_resource=True,\\n trainable=False)\\n iter_cotrain_update = iter_cotrain.assign_add(1)\\n return iter_cotrain, iter_cotrain_update\",\n \"def compute_metrics(self):\\n pass\",\n \"def _activation_summary(x):\\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n # session. This helps the clarity of presentation on tensorboard.\\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n tf.summary.histogram(tensor_name + '/activations', x)\\n tf.summary.scalar(tensor_name + '/sparsity',\\n tf.nn.zero_fraction(x))\",\n \"def _activation_summary(x):\\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n # session. This helps the clarity of presentation on tensorboard.\\n tensor_name = x.op.name\\n # tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n tf.summary.histogram(tensor_name + '/activations', x)\\n\\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def _activation_summary(x):\\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n # session. This helps the clarity of presentation on tensorboard.\\n tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)\\n tf.summary.histogram(tensor_name + '/activations', x)\\n tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def _calculate_probs_and_entropies(self):\\n self._calculate_probs_and_entropy_y()\\n self._calculate_probs_and_entropy_x(self.cat_cols)\",\n \"def Entropy(model, pool, addn):\\n\\n # Get probability distribution over labels\\n pool_p = model.predict_proba(pool)\\n\\n # Calculate entropy and sort for each datapoint in pool\\n Entropy = (pool_p * np.log(1/pool_p)).sum(axis = 1)\\n Information_gain = np.argsort(Entropy)\\n\\n # Choose addn datapoints with highest entropy\\n x_star = Information_gain[-addn:]\\n return x_star\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def _activation_summary(x):\\n # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training\\n # session. This helps the clarity of presentation on tensorboard.\\n tensor_name = re.sub('%s_[0-9]*/' % 'tower', '', x.op.name)\\n tf.summary.histogram(tensor_name + '/activations', x)\\n tf.summary.scalar(tensor_name + '/sparsity',\\n tf.nn.zero_fraction(x))\",\n \"def entropy(self):\\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))\",\n \"def compute_logits(self):\\n # [num test images, 1, embedding size].\\n test_embeddings = tf.expand_dims(self.test_embeddings, 1)\\n\\n # [1, num_clases, embedding_size].\\n prototypes = tf.expand_dims(self.prototypes, 0)\\n\\n # Squared euclidean distances between each test embedding / prototype pair.\\n distances = tf.reduce_sum(tf.square(test_embeddings - prototypes), 2)\\n self.test_logits = -distances\\n return self.test_logits\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def add_op(self, logits, labels):\\n\\n with tf.name_scope(self.name_scope):\\n labels = tf.cast(labels, tf.int64)\\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)\\n cross_entropy_mean = tf.reduce_mean(cross_entropy, name=self.name_scope)\\n\\n tf.summary.scalar(self.name_scope, cross_entropy_mean)\\n\\n return cross_entropy_mean\",\n \"def _ter_compute(total_num_edits: Tensor, total_tgt_length: Tensor) ->Tensor:\\n return _compute_ter_score_from_statistics(total_num_edits, total_tgt_length)\",\n \"def _activation_summary(x):\\n\\n tf.summary.histogram(x.op.name + '/activations', x)\\n tf.summary.scalar(x.op.name + '/sparsity', tf.nn.zero_fraction(x))\",\n \"def entropy(self, policy_params):\\n return self.head.entropy(policy_params)\",\n \"def hist_cpu(A):\\n C = np.zeros(shape=256, dtype=np.int32)\\n shape = A.shape[0]\\n for i in range(shape):\\n C[A[i]] += 1\\n return C\",\n \"def update(self):\\n with torch.no_grad():\\n self.preprocess_rollout()\\n \\n # DEEP-RL TUTORIALS: КОСТЫЛЬ\\n #self.advantages = self.returns[:-1] - self.values[:-1]\\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\\n \\n # going through rollout several (config.epochs) times:\\n for epoch in range(self.config.epochs):\\n # TODO: drop last = False? What if there is 1 sample?\\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\\n \\n for indices in sampler:\\n # retrieving new batch as part of rollout\\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\\n \\n # calculating current value, action_log_prob, entropy\\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \\n self.entropy_b = dist.entropy()#.sum(dim=-1)\\n \\n # performing step\\n self.gradient_ascent_step()\",\n \"def cal_globalEntropy(self):\\n group_score = []\\n pop_total = np.sum(self.pop_sum)\\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\\n\\n # loop at sum of each population groups\\n for group in prop:\\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\\n group_score.append(group_idx)\\n entropy = np.sum(group_score)\\n\\n return entropy\",\n \"def _build_train_op(self):\\n\\n logits_flatten = tf.reshape(self.logits_up, [-1, self.num_classes])\\n pred_flatten = tf.reshape(self.pred, [-1, self.num_classes])\\n\\n labels_gt = self.labels\\n\\n if self.ignore_class_bg:\\n # ignore background labels: 255\\n gt_labels_flatten = tf.reshape(labels_gt, [-1, ])\\n indices = tf.squeeze(tf.where(tf.less_equal(gt_labels_flatten, self.num_classes - 1)), 1)\\n remain_logits = tf.gather(logits_flatten, indices)\\n remain_pred = tf.gather(pred_flatten, indices)\\n remain_labels = tf.gather(gt_labels_flatten, indices)\\n xent = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=remain_logits, labels=remain_labels)\\n else:\\n xent = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.logits_up, labels=labels_gt)\\n\\n self.cls_loss = tf.reduce_mean(xent, name='xent') # xent.shape=[nIgnoredBgPixels]\\n self.cost = self.cls_loss + self._decay()\\n tf.summary.scalar('cost', self.cost)\\n\\n self.global_step = tf.Variable(0, name='global_step', trainable=False)\\n self.learning_rate = tf.train.polynomial_decay(self.lrn_rate,\\n self.global_step,\\n self.lr_decay_step,\\n end_learning_rate=self.lrn_rate_end,\\n power=0.9)\\n tf.summary.scalar('learning rate', self.learning_rate)\\n\\n tvars = tf.trainable_variables()\\n\\n if self.optimizer == 'sgd':\\n optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)\\n elif self.optimizer == 'mom':\\n optimizer = tf.train.MomentumOptimizer(self.learning_rate, 0.9)\\n elif self.optimizer == 'adam':\\n optimizer = tf.train.AdamOptimizer(self.learning_rate)\\n else:\\n raise NameError(\\\"Unknown optimizer type %s!\\\" % self.optimizer)\\n\\n grads_and_vars = optimizer.compute_gradients(self.cost, var_list=tvars)\\n var_lr_mult = {}\\n for var in tvars:\\n if var.op.name.find(r'fc_final_sketch46') > 0 and var.op.name.find(r'biases') > 0:\\n var_lr_mult[var] = 20.\\n elif var.op.name.find(r'fc_final_sketch46') > 0:\\n var_lr_mult[var] = 10.\\n else:\\n var_lr_mult[var] = 1.\\n grads_and_vars = [((g if var_lr_mult[v] == 1 else tf.multiply(var_lr_mult[v], g)), v)\\n for g, v in grads_and_vars]\\n\\n ## summary grads\\n # for grad, grad_var in grads_and_vars:\\n # print('>>>', grad_var.op.name)\\n # if grad is None:\\n # print('None grad')\\n # # if grad is not None:\\n # # tf.summary.histogram(grad_var.op.name + \\\"/gradient\\\", grad)\\n\\n apply_op = optimizer.apply_gradients(grads_and_vars,\\n global_step=self.global_step, name='train_step')\\n\\n train_ops = [apply_op] + self._extra_train_ops\\n self.train_step = tf.group(*train_ops)\",\n \"def entropy_root(self):\\n\\t\\tif self.size() == 0:\\n\\t\\t\\treturn 0\\n\\n\\t\\tcounter = collections.Counter(self.y)\\n\\t\\treturn entropy([x[1] for x in counter.items()], self.size())\",\n \"def __init__(self, E, U, height, width, filter_hs, conv_non_linear,\\n hidden_units, batch_size, non_static, dropout_rates,subspace_size=None,\\n activations=[Iden]):\\n rng = np.random.RandomState(3435)\\n feature_maps = hidden_units[0]\\n self.batch_size = batch_size\\n\\n # define model architecture\\n self.index = T.lscalar()\\n self.x = T.matrix('x') \\n self.y = T.ivector('y') \\n self.Words = theano.shared(value=E, name=\\\"Words\\\") \\n self.Users = None \\n self.u = None\\n self.subspace_size = subspace_size\\n zero_vec_tensor = T.vector()\\n self.zero_vec = np.zeros(width)\\n # reset Words to 0?\\n self.set_zero = theano.function([zero_vec_tensor],\\n updates=[(self.Words, T.set_subtensor(self.Words[0,:],zero_vec_tensor))],\\n allow_input_downcast=True)\\n # inputs to the ConvNet go to all convolutional filters:\\n layer0_input = self.Words[T.cast(self.x.flatten(), dtype=\\\"int32\\\")].reshape(\\n (self.x.shape[0], 1, self.x.shape[1], self.Words.shape[1]))\\n self.conv_layers = [] \\n \\n # outputs of convolutional filters\\n layer1_inputs = []\\n image_shape = (batch_size, 1, height, width)\\n filter_w = width \\n for filter_h in filter_hs: \\n filter_shape = (feature_maps, 1, filter_h, filter_w)\\n pool_size = (height-filter_h+1, width-filter_w+1)\\n conv_layer = LeNetConvPoolLayer(rng, input=layer0_input,\\n image_shape=image_shape,\\n filter_shape=filter_shape,\\n poolsize=pool_size,\\n non_linear=conv_non_linear)\\n layer1_input = conv_layer.output.flatten(2)\\n self.conv_layers.append(conv_layer)\\n layer1_inputs.append(layer1_input)\\n # inputs to the MLP\\n layer1_input = T.concatenate(layer1_inputs, 1)\\n if U is not None:\\n print \\\"Will use user embeddings\\\"\\n self.u = T.ivector('u')\\n self.Users = theano.shared(value=U, name=\\\"Users\\\")\\n them_users = self.Users[self.u]\\n if self.subspace_size:\\n print \\\"and subspace\\\"\\n # set_trace()\\n self.subspace = HiddenLayer(rng, them_users, U.shape[1], subspace_size, Sigmoid)\\n self.peep = theano.function([self.x, self.u],[self.subspace.output,layer1_input],allow_input_downcast=True)\\n\\n layer1_input = T.concatenate((layer1_input,T.nnet.sigmoid(self.subspace.output)),1)\\n layer_sizes = [feature_maps*len(filter_hs)+subspace_size] \\n # layer1_input = T.concatenate((layer1_input,them_users),1)\\n # layer_sizes = [feature_maps*len(filter_hs)+U.shape[1]]\\n\\n else:\\n layer1_input = T.concatenate((layer1_input,them_users),1)\\n layer_sizes = [feature_maps*len(filter_hs)+U.shape[1]]\\n\\n else:\\n print \\\"NO user embeddings\\\"\\n layer_sizes = [feature_maps*len(filter_hs)]\\n layer_sizes += hidden_units[1:]\\n \\n super(ConvNet, self).__init__(rng, input=layer1_input,\\n layer_sizes=layer_sizes,\\n activations=activations,\\n dropout_rates=dropout_rates)\\n\\n # add parameters from convolutional layers\\n for conv_layer in self.conv_layers:\\n self.params += conv_layer.params\\n if non_static:\\n # if word vectors are allowed to change, add them as model parameters\\n self.params += [self.Words]\\n if U is not None:\\n # if self.subspace_size is None:\\n self.params += [self.Users]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6375051","0.6375051","0.5747862","0.5734022","0.57108384","0.5705662","0.56487167","0.55760294","0.5560576","0.55325216","0.5517932","0.54343194","0.541528","0.5407086","0.53932786","0.53651863","0.53597933","0.5357408","0.5326563","0.5320264","0.5314028","0.5313147","0.52775466","0.5268302","0.526652","0.5262902","0.52549136","0.524198","0.5241905","0.5238979","0.523601","0.5231344","0.52263117","0.521979","0.52197385","0.52197385","0.52185184","0.52043664","0.5199852","0.51800007","0.51728606","0.51679087","0.5164803","0.5162615","0.5156314","0.51515365","0.51454365","0.514397","0.5142371","0.5141896","0.514039","0.5137679","0.51362157","0.5135741","0.5134172","0.5133435","0.5124783","0.51007855","0.50861126","0.5080621","0.50803185","0.50799394","0.507798","0.5075568","0.5073246","0.5067671","0.50556296","0.50551754","0.50545824","0.50542","0.504759","0.5045519","0.5043619","0.50400907","0.5034407","0.503058","0.5026307","0.5023294","0.502307","0.5019565","0.5017366","0.5013191","0.5012039","0.49997985","0.4996129","0.49920234","0.49893636","0.4980741","0.49773765","0.4972142","0.49717203","0.49656713","0.4963458","0.4961161","0.49551788","0.49501845","0.49486604","0.49427","0.49425265","0.49421096","0.494149"],"string":"[\n \"0.6375051\",\n \"0.6375051\",\n \"0.5747862\",\n \"0.5734022\",\n \"0.57108384\",\n \"0.5705662\",\n \"0.56487167\",\n \"0.55760294\",\n \"0.5560576\",\n \"0.55325216\",\n \"0.5517932\",\n \"0.54343194\",\n \"0.541528\",\n \"0.5407086\",\n \"0.53932786\",\n \"0.53651863\",\n \"0.53597933\",\n \"0.5357408\",\n \"0.5326563\",\n \"0.5320264\",\n \"0.5314028\",\n \"0.5313147\",\n \"0.52775466\",\n \"0.5268302\",\n \"0.526652\",\n \"0.5262902\",\n \"0.52549136\",\n \"0.524198\",\n \"0.5241905\",\n \"0.5238979\",\n \"0.523601\",\n \"0.5231344\",\n \"0.52263117\",\n \"0.521979\",\n \"0.52197385\",\n \"0.52197385\",\n \"0.52185184\",\n \"0.52043664\",\n \"0.5199852\",\n \"0.51800007\",\n \"0.51728606\",\n \"0.51679087\",\n \"0.5164803\",\n \"0.5162615\",\n \"0.5156314\",\n \"0.51515365\",\n \"0.51454365\",\n \"0.514397\",\n \"0.5142371\",\n \"0.5141896\",\n \"0.514039\",\n \"0.5137679\",\n \"0.51362157\",\n \"0.5135741\",\n \"0.5134172\",\n \"0.5133435\",\n \"0.5124783\",\n \"0.51007855\",\n \"0.50861126\",\n \"0.5080621\",\n \"0.50803185\",\n \"0.50799394\",\n \"0.507798\",\n \"0.5075568\",\n \"0.5073246\",\n \"0.5067671\",\n \"0.50556296\",\n \"0.50551754\",\n \"0.50545824\",\n \"0.50542\",\n \"0.504759\",\n \"0.5045519\",\n \"0.5043619\",\n \"0.50400907\",\n \"0.5034407\",\n \"0.503058\",\n \"0.5026307\",\n \"0.5023294\",\n \"0.502307\",\n \"0.5019565\",\n \"0.5017366\",\n \"0.5013191\",\n \"0.5012039\",\n \"0.49997985\",\n \"0.4996129\",\n \"0.49920234\",\n \"0.49893636\",\n \"0.4980741\",\n \"0.49773765\",\n \"0.4972142\",\n \"0.49717203\",\n \"0.49656713\",\n \"0.4963458\",\n \"0.4961161\",\n \"0.49551788\",\n \"0.49501845\",\n \"0.49486604\",\n \"0.49427\",\n \"0.49425265\",\n \"0.49421096\",\n \"0.494149\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83789,"cells":{"query":{"kind":"string","value":"Compute the minmax range of tensor"},"document":{"kind":"string","value":"def compute_data(self) -> TensorsData:\n if not self.collector:\n raise ValueError(\"No collector created and can't generate calibration data.\")\n\n if isinstance(self, EntropyCalibrater):\n cal = CalibrationMethod.Entropy\n elif isinstance(self, PercentileCalibrater):\n cal = CalibrationMethod.Percentile\n elif isinstance(self, DistributionCalibrater):\n cal = CalibrationMethod.Distribution\n else:\n raise TypeError(f\"Unknown calibrater {type(self)}. This method must be overwritten.\")\n return TensorsData(cal, self.collector.compute_collection_result())"},"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_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\n device = tensor.device\n tensor = tensor.detach().cpu()\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\n mn /= numpy.prod(tensor.shape[1:])\n q = alpha * (1 - mn) * 50\n n_samples = tensor.shape[0]\n add_view = [1] * (tensor.ndim - 1)\n low = torch.tensor(\n [numpy.percentile(tensor[i], q[i]) for i in range(n_samples)]).float()\n high = torch.tensor([numpy.percentile(tensor[i], 100 - q[i]) for i in\n range(n_samples)]).float()\n low = low.view(-1, *add_view)\n high = high.view(-1, *add_view)\n return (tensor - low / (high - low)).to(device)","def maxs(self) -> Tensor:\n return self._ranges[:, 1]","def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\n ...","def mins(self) -> Tensor:\n return self._ranges[:, 0]","def min_max_range(s):\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\n sign = np.sign(np.argmax(s) - np.argmin(s))\n if sign == 0:\n return 0.0\n else:\n return sign*(np.max(s) - np.min(s))","def calculate_min_max_tiles(self):","def bounds(self) -> Tensor:\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)","def minmax_norm(X):\n return (X - tf.reduce_min(X))/(tf.reduce_max(X)-tf.reduce_min(X))","def local_max_to_min(node):\r\n if node.op == T.neg and node.inputs[0].owner:\r\n max = node.inputs[0]\r\n if (max.owner and\r\n isinstance(max.owner.op, CAReduce)\r\n and max.owner.op.scalar_op == scal.maximum):\r\n neg = max.owner.inputs[0]\r\n if neg.owner and neg.owner.op == T.neg:\r\n return [CAReduce(scal.minimum,\r\n max.owner.op.axis)(neg.owner.inputs[0])]\r\n\r\n return False","def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\n\n\n dtype = min_broadcast.dtype\n quant_min = 1 if narrow_range else 0\n quant_max = (2 ** num_bits) - 1\n\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\n\n # caculate each channel max and min difference.\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\n # and min_div_scale = min_broadcast / scale\n if product_is_mini():\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\n else:\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\n\n # zero_point_from_min = quant_min_float - min_broadcast / scale\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\n\n # according to above bool param to select effective value\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\n\n # compute which num is not less than quant_min_float and not large than quant_max_float\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\n # add 0.5 to num which min <= num <= max and then floor them.\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\n if product_is_mini():\n between_min_max_round = topi.cast(between_min_max_round, \"float16\")\n\n between_min_max_round = topi.cast(between_min_max_round, \"float32\")\n\n # calculate the maximum and minimum values of the quantization\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\n\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\n nudged_min = topi.multiply(nudged_min_tmp, scale)\n nudged_max = topi.multiply(nudged_max_tmp, scale)\n res = [nudged_min, nudged_max, scale]\n\n return res","def min_max(xs):\n return min(xs), max(xs)","def minmin_maxmax( *args ):\n rmin = min( [ mv.min() for mv in args ] )\n rmax = max( [ mv.max() for mv in args ] )\n rmv = cdms2.createVariable( [rmin,rmax] )\n return rmv","def convert_arg_max_min(g, op, block):\n\n axis = op.attr(\"axis\")\n keepdims = op.attr(\"keepdims\")\n flatten = op.attr(\"flatten\")\n dtype = op.attr(\"dtype\")\n dtype = _convert_dtype_value(dtype)\n\n func = _op.argmax if op.type == \"arg_max\" else _op.argmin\n x = g.get_node(op.input(\"X\")[0])\n if axis is None or flatten:\n x = _op.reshape(x, [-1])\n out = func(x, axis=None, keepdims=True)\n else:\n out = func(x, axis=axis, keepdims=keepdims)\n if dtype != infer_type(out).checked_type.dtype:\n out = _op.cast(out, dtype)\n g.add_node(op.output(\"Out\")[0], out)","def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\n min_max_features = []\n transposed_features = [list(i) for i in zip(*features)]\n for feature in transposed_features:\n min_in_feature = min(feature)\n max_in_feature = max(feature)\n if min_in_feature == max_in_feature:\n min_max_features.append([0 for x in feature])\n else:\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\n return [list(i) for i in zip(*min_max_features)]","def abs_max(tensor):\n min_val, max_val = tensor.min(), tensor.max()\n return max(min_val.abs(), max_val.abs())","def _bound(x, min_value, max_value):\n return np.maximum(min_value, np.minimum(x, max_value))","def clamp(n, min_, max_):\n return max(min(max_,n),min_)","def minimum_maximum_model():\n inputs = tf.keras.Input(shape=(32, 32, 3,))\n x = tf.keras.layers.Conv2D(32, (3, 3))(inputs)\n x = tf.keras.layers.BatchNormalization(momentum=.3, epsilon=.65)(x, training=False)\n x = tf.minimum(x, .2)\n x = tf.maximum(x, .5)\n x = tf.keras.layers.Conv2D(16, (2, 2), activation=tf.nn.tanh)(x)\n x = tf.keras.layers.Flatten()(x)\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\"minimum_maximum_model\")(x)\n return outputs","def saturate_scalar_minmax(value, max_value, min_value):\n mean = (max_value + min_value)/2.0\n half_range = (max_value - min_value)/2.0\n return saturate_vector_dg(value-mean, half_range) + mean","def min_max(tr):\n tr = tr.astype(float)\n mm = tr.min() / tr.max()\n return mm","def min_max_normalization(x, min_x = None, max_x = None):\n if min_x is None:\n min_x = np.min(x, axis=0)\n if max_x is None:\n max_x = np.max(x, axis=0)\n return (x - (min_x)) / (max_x - min_x), min_x, max_x","def minmax(self):\n return self._data_lim[self._n_overlay - 1]","def minmax(self):\r\n vx = [v[0] for v in self.vl]\r\n vy = [v[1] for v in self.vl]\r\n self.xmax, self.xmin = max(vx), min(vx)\r\n self.ymax, self.ymin = max(vy), min(vy)","def get_range(lst):\n return float(max(lst)) - float(min(lst))","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def minMaxFonc(liste):\n\n return min(liste), max(liste)","def min_max(arr, arr_size):\n max_t = arr[0]\n min_t = arr[0]\n for i in range(arr_size):\n if arr[i] > max_t:\n max_t = arr[i]\n if arr[i] < min_t:\n min_t = arr[i]\n return min_t, max_t","def clamp(value, mn, mx):\n\n return max(min(value, mx), mn)","def _normalize_range():\n clipped = tf.clip_by_value(inputs, self.minimum, self.maximum)\n return -1 + 2 * (clipped - self.minimum) / length","def minmax_normalize(X):\n # X -= X.min()\n # X /= X.max()\n # X -= 0.5\n X = (X-X.min()) / (X.max() - X.min())\n return X","def spec_min_max(self):\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\n 2048,2048,2048,2048,2048])\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0])\n return np.vstack((spec_min, spec_max))","def quickMinMax(self, targetSize=1e6):\n data = self.image\n if targetSize < 2: # keep at least two pixels\n targetSize = 2\n while True:\n h, w = data.shape[:2]\n if h * w <= targetSize: break\n if h > w:\n data = data[::2, ::] # downsample first axis\n else:\n data = data[::, ::2] # downsample second axis\n return self._xp.nanmin(data), self._xp.nanmax(data)","def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\n assert \\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\n if dtype is None:\n dtype = images.dtype\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)","def min_max(items):\n return min(items), max(items)","def _min_max_scale(arr, new_range=(0, 255)):\n # get array's current min and max\n mn = arr.min()\n mx = arr.max()\n\n # check if scaling needs to be done to be in new_range\n if mn < new_range[0] or mx > new_range[1]:\n # perform min-max scaling\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\n else:\n # return array if already in range\n scaled = arr\n\n return scaled","def argmin(tensor):\n raise NotImplementedError","def get_max_min(block_size):\r\n return (int(block_size / 2), int((block_size - 1) / 2))","def cpfclamp(f, min_, max_):\n return min(max(f, min_), max_)","def minMax(df):\n max_, min_ = df.max(axis=0), df.min(axis=0)\n midrange = (max_ + min_) / 2\n half_range = (max_ - min_) / 2\n return (df - midrange) / half_range","def data_range(x):\n return max(x)-min(x)","def view_limits(self, dmin, dmax):\n base = self._select_base(dmin, dmax)\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\n vmin = base.le(dmin)\n vmax = base.ge(dmax)\n if vmin == vmax:\n vmin -= 1\n vmax += 1\n else:\n vmin = dmin\n vmax = dmax\n\n return mtransforms.nonsingular(vmin, vmax)","def minMaxLoc(img):\n\tmaskVar = mask(img)\n\tpt = cv2.minMaxLoc(grayscale(img), maskVar)\n\td = {\"minVal\": pt[0], \"maxVal\":pt[1], \"minLoc\":pt[2], \"maxLoc\":pt[3]}\n\treturn d","def get_min_max(ints):\n print(f\"input arr is {ints}\")\n max=0\n min=len(ints)-1\n for i in range(1,len(ints)):\n if ints[i]>ints[max]:\n temp=ints[i]\n ints[i]=ints[max]\n ints[max]=temp\n if ints[i]<ints[min]:\n temp=ints[i]\n ints[i]=ints[min]\n ints[min]=temp\n #print(f\"max value is {ints[max]}\")\n #print(f\"min value is {ints[min]}\")\n return(ints[min],ints[max])","def minmax ( self , nshoots = 100000 ) :\n ## try to get minmax directly from pdf/function \n if self.tricks and hasattr ( self.pdf , 'function' ) :\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \n f = self.pdf.function()\n if hasattr ( f , 'minmax' ) :\n try :\n mn , mx = f.minmax()\n if 0<= mn and mn <= mx and 0 < mx : \n return mn , mx\n except :\n pass\n if hasattr ( f , 'max' ) :\n try :\n mx = f.max()\n if 0 < mx : return 0 , mx\n except :\n pass\n\n ## check RooAbsReal functionality\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\n if 0 < code :\n mx = self.pdf.maxVal ( code )\n if 0 < mx : return 0 , mx\n \n ## not try to use random\n \n mn , mx = -1 , -10\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\n \n if not self.xminmax() : return ()\n if not self.yminmax() : return ()\n \n mn , mx = -1 , -10\n xmn , xmx = self.xminmax()\n ymn , ymx = self.yminmax()\n for i in range ( nshoots ) : \n xx = random.uniform ( xmn , xmx )\n yy = random.uniform ( ymn , ymx )\n with SETVAR ( self.xvar ) :\n with SETVAR ( self.yvar ) :\n self.xvar.setVal ( xx )\n self.yvar.setVal ( yy )\n vv = self.pdf.getVal()\n if mn < 0 or vv < mn : mn = vv\n if mx < 0 or vv > mx : mx = vv\n \n return mn , mx","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def min_max(my_list):\n print(\"Min = \",min(my_list,key = abs))\n print(\"Max = \",max(my_list,key = abs))","def min_max_scale(self, feature_range=(0, 1)):\n\n if len(feature_range) != 2:\n raise AttributeError(\n \"Error: `feature_range` doesn't look like a 2-element tuple?\"\n )\n if feature_range[1] < feature_range[0]:\n raise AttributeError(\"Error: `feature_range` isn't increasing?\")\n\n # use self.__class__ so that child classes can inherit this method\n return self.__class__(\n min_max_scale(self.spectrogram, feature_range=feature_range),\n frequencies=self.frequencies,\n times=self.times,\n decibel_limits=self.decibel_limits,\n )","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def normalizeToRange(data,max=255,min=0):\n if min: return (max-min)*normalize(data)+min\n else: return max*normalize2(data) # speeds up operation","def x_y_coor_min_max(x_y_coor):\n\tx_range = [np.min(x_y_coor[\"X\"]),np.max(x_y_coor[\"X\"])]\n\ty_range = [np.min(x_y_coor[\"Y\"]),np.max(x_y_coor[\"Y\"])]\n\treturn x_range, y_range","def masked_minimum(data, mask, dim=1):\n axis_maximums = tf.reduce_max(data, dim, keepdims=True)\n masked_minimums = tf.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def map_range(x, in_min, in_max, out_min, out_max):\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\n if out_min <= out_max:\n return max(min(mapped, out_max), out_min)\n return min(max(mapped, out_max), out_min)","def maxima_in_range(r, g_r, r_min, r_max):\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\n g_r_slice = g_r[idx]\n g_r_max = g_r_slice[g_r_slice.argmax()]\n idx_max, _ = find_nearest(g_r, g_r_max)\n return r[idx_max], g_r[idx_max]","def find_max_min(self, col):\n self.max = max(col)\n self.min = min(col)","def data_range(xs: List[float]) -> float:\n return max(xs) - min(xs)","def clamp(minimum, n, maximum):\n return max(minimum, min(n, maximum))","def min_max(lst):\r\n my_min = None\r\n my_max = None\r\n for num in lst:\r\n if (my_min and my_max) is not None:\r\n # recalculate running min and max:\r\n if num < my_min:\r\n my_min = num\r\n continue\r\n if num > my_max:\r\n my_max = num\r\n else:\r\n my_min = num\r\n my_max = num\r\n ans = (my_min, my_max)\r\n return ans","def masked_minimum(data, mask, dim=1):\n # sourced from:\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L141-L157\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\n masked_minimums = tf.math.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def vc_clamp(x, lb, ub):\n\n y = min(x, ub)\n y = max(y, lb)\n\n return y","def view_limits(self, vmin, vmax):\n return vmin, vmax\n # return nonsingular(vmin, vmax)","def clamp(value, min_value, max_value):\n return max(min_value, min(value, max_value))","def clip(tensor, a_min=None, a_max=None):\n raise NotImplementedError","def minima_in_range(r, g_r, r_min, r_max):\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\n g_r_slice = g_r[idx]\n g_r_min = g_r_slice[g_r_slice.argmin()]\n idx_min, _ = find_nearest(g_r, g_r_min)\n return r[idx_min], g_r[idx_min]","def getColorRange(self):\n vmax=self.data_matrix.max()\n vmin=self.data_matrix.min()\n\n if vmax * vmin < 0: # ie number range spans +ve and -ve\n vmax = max([vmax, abs(vmin)])\n vmin = -1*vmax\n\n return vmax,vmin","def _argmax(self, input_tensor, dimension, c):\n with self.session.graph.as_default():\n min_values = tf.reduce_min(input_tensor, reduction_indices=[dimension,], keep_dims=True)\n not_c = tf.abs(c - 1)\n\n return tf.argmax(input_tensor * c + not_c * min_values, dimension)","def clamp(n, minn, maxn):\n return max(min(maxn, n), minn)","def minMax2(x):\r\n\r\n iMinMax = [0 for i in range(2)]\r\n num = len(x)[0]\r\n\r\n iMin = 0\r\n iMax = 0\r\n\r\n #// Search for minimum and maximum in row 0 - linear values:\r\n min = x[0][iMin]\r\n max = x[0][iMax]\r\n\r\n for i in range(1, num):\r\n\r\n if (x[0][i] < min): \r\n min = x[0][i]\r\n iMin = i\r\n \r\n\r\n if (x[0][i] > max): \r\n max = x[0][i]\r\n iMax = i\r\n \r\n iMinMax[0] = iMin\r\n iMinMax[1] = iMax\r\n\r\n return iMinMax","def minmaxdenorm(v, minv, maxv):\n v *= maxv - minv\n v += minv\n return v","def clip_range(x, xlim):\n return min([max([x, xlim[0]]), xlim[1]])","def map_to_range(val, old_min, old_max, new_min, new_max):\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)","def _min_in_bounds(self, min):\n if min <= self.valmin:\n if not self.closedmin:\n return self.val[0]\n min = self.valmin\n\n if min > self.val[1]:\n min = self.val[1]\n return self._stepped_value(min)","def minmax(xs):\n min_val = None\n max_val = None\n for x in xs:\n if min_val is None or x < min_val:\n min_val = x\n if max_val is None or x > max_val:\n max_val = x\n return (min_val, max_val)","def masked_maximum(data, mask, dim=1):\n axis_minimums = tf.reduce_min(data, dim, keepdims=True)\n masked_maximums = tf.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim,\n keepdims=True) + axis_minimums\n return masked_maximums","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def xminmax ( self ) :\n return self.xvar.minmax()","def minMax(x):\r\n\r\n iMinMax = [0 for i in range(2)]\r\n\r\n num = len(x)\r\n #//System.out.println(\"MinMax: num: \" + num);\r\n\r\n iMin = 0\r\n iMax = 0\r\n min = x[iMin]\r\n max = x[iMax]\r\n\r\n for i in range(1, num):\r\n\r\n #//System.out.println(\"MinMax: i , current min, x : \" + i + \" \" + min + \" \" + x[i]);\r\n if (x[i] < min): \r\n #//System.out.println(\"MinMax: new min: if branch triggered\" );\r\n min = x[i]\r\n iMin = i\r\n \r\n #//System.out.println(\"MinMax: new min: \" + min);\r\n\r\n if (x[i] > max): \r\n max = x[i]\r\n iMax = i\r\n \r\n\r\n \r\n #//System.out.println(\"MinMax: \" + iMin + \" \" + iMax);\r\n\r\n iMinMax[0] = iMin\r\n iMinMax[1] = iMax\r\n\r\n return iMinMax","def standardize_x(\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\n):\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\n raise ValueError(\n \"Either *both* or *neither* of x_min, x_max need to be supplied!\"\n )\n if x_min is None:\n x_min = torch.min(x, 0)[0]\n x_max = torch.max(x, 0)[0]\n x = (x - x_min) / (x_max - x_min)\n return x, x_min, x_max","def masked_minimum(data, mask, dim=1):\n axis_maximums = math_ops.reduce_max(data, dim, keepdims=True)\n masked_minimums = math_ops.reduce_min(\n math_ops.multiply(data - axis_maximums, mask), dim,\n keepdims=True) + axis_maximums\n return masked_minimums","def _xywh2min_max(box):\n x, y, w, h = box\n return np.array([x, y, x+w, y+h])","def constrain(n: int, low: int, high: int) -> int:\n return max(min(n, high), low)","def _masked_minimum(data, mask, dim=1):\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\n masked_minimums = (\n tf.math.reduce_min(\n tf.math.multiply(data - axis_maximums, mask), dim, keepdims=True\n )\n + axis_maximums\n )\n return masked_minimums","def min_max(self, data, era):\n return 0, np.max(data)","def find_max_min(number):\n if max(number) == min(number):\n return [len(number)]\n return [min(number), max(number)]","def clamp(n, minn, maxn):\n return max(min(maxn, n), minn)","def range(self):\r\n\t\treturn max(self.sample) - min(self.sample)","def masked_maximum(data, mask, dim=1):\n # sourced from:\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L122-L138\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\n masked_maximums = tf.math.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim,\n keepdims=True) + axis_minimums\n return masked_maximums","def dim_zero_min(x: Tensor) ->Tensor:\n return torch.min(x, dim=0).values","def convert_clip(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n dtype = infer_type(x).checked_type.dtype\n # if the min/max value is a tensor\n min_max_is_tensor = False\n if op.input(\"Min\"):\n min_value = g.get_node(op.input(\"Min\")[0])\n min_value, infered = try_infer_value(min_value, g.get_params())\n if infered:\n min_value = min_value.tolist()[0]\n if isinstance(min_value, _expr.Expr):\n min_max_is_tensor = True\n else:\n min_value = op.attr(\"min\")\n\n if op.input(\"Max\"):\n max_value = g.get_node(op.input(\"Max\")[0])\n max_value, infered = try_infer_value(max_value, g.get_params())\n if infered:\n max_value = max_value.tolist()[0]\n if isinstance(max_value, _expr.Expr):\n min_max_is_tensor = True\n else:\n max_value = op.attr(\"max\")\n\n if min_max_is_tensor:\n if not isinstance(min_value, _expr.Expr):\n min_value = _op.const(min_value, dtype)\n if not isinstance(max_value, _expr.Expr):\n max_value = _op.const(max_value, dtype)\n out = _op.maximum(x, min_value)\n out = _op.minimum(out, max_value)\n else:\n out = _op.clip(x, min_value, max_value)\n g.add_node(op.output(\"Out\")[0], out)","def min():\n return KeeperOfMinOrMax(int.__gt__)","def normalize_minmax(data):\n _min = np.float(np.min(data))\n _max = np.float(np.max(data))\n if (_max-_min)!=0:\n img = (data - _min) / (_max-_min)\n else:\n img = np.zeros_like(data) \n return img","def print_minmax(arr):\n print(arr.shape)\n for i in range(arr.shape[1]):\n print(transfer[i], arr[:,i].min(), arr[:,i].max())","def _masked_maximum(data, mask, dim=1):\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\n masked_maximums = (\n tf.math.reduce_max(\n tf.math.multiply(data - axis_minimums, mask), dim, keepdims=True\n )\n + axis_minimums\n )\n return masked_maximums","def _min_or_max_grad(x, axis, out, dout):\n # input_shape = [2, 3] axis = [1]\n input_shape = shape_op(x)\n # output_shape_kept_dims = [2, 1]\n output_shape_kept_dims = reduced_shape(input_shape, axis)\n y = reshape(out, output_shape_kept_dims)\n grad = reshape(dout, output_shape_kept_dims)\n indicators = F.cast(F.equal(y, x), F.dtype(grad))\n min_num = F.cast(F.scalar_to_array(1e-24), F.dtype(grad))\n num_selected = reshape(reduce_sum(indicators, axis), output_shape_kept_dims) + min_num\n return indicators / num_selected * grad","def minmax(value):\n return min(0xff, max(0, value))","def scale_from_minmax(\n col: np.ndarray, minmax: Optional[Tuple[float, float]]\n) -> np.ndarray:\n if minmax is None:\n return np.zeros_like(col)\n else:\n min_, max_ = minmax\n assert max_ - min_ >= FLOAT_TOL\n return 2 * (col - min_) / (max_ - min_) - 1","def atmax(a,upperlimit,dimension=None,inclusive=1):\r\n if inclusive: upperfcn = N.less\r\n else: upperfcn = N.less_equal\r\n if dimension == None:\r\n a = N.ravel(a)\r\n dimension = 0\r\n if upperlimit == None:\r\n upperlimit = N.maximum.reduce(N.ravel(a))+1\r\n smallest = N.minimum.reduce(N.ravel(a))\r\n ta = N.where(upperfcn(a,upperlimit),a,smallest)\r\n return N.maximum.reduce(ta,dimension)","def min_max(arr: StaticArray) -> ():\n minimum = arr.get(0) # sets min to first element\n maximum = arr.get(0) # sets max to first element\n # iterate over the elements in the array to check for < or >\n for index in range(arr.size()):\n if arr[index] < minimum: # if element is less than the current min, min = new element\n minimum = arr[index]\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\n maximum = arr[index]\n return minimum, maximum","def atmin(a,lowerlimit=None,dimension=None,inclusive=1):\r\n if inclusive: lowerfcn = N.greater\r\n else: lowerfcn = N.greater_equal\r\n if dimension == None:\r\n a = N.ravel(a)\r\n dimension = 0\r\n if lowerlimit == None:\r\n lowerlimit = N.minimum.reduce(N.ravel(a))-11\r\n biggest = N.maximum.reduce(N.ravel(a))\r\n ta = N.where(lowerfcn(a,lowerlimit),a,biggest)\r\n return N.minimum.reduce(ta,dimension)","def bounds(x, xMin, xMax):\n if (x < xMin):\n x = xMin\n elif (x > xMax):\n x = xMax\n return(x)","def constrain(small, value, big):\n return min(max(value, small), big)","def clamp(minimum, value, maximum):\n return max(minimum, min(maximum, value))"],"string":"[\n \"def batch_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\\n device = tensor.device\\n tensor = tensor.detach().cpu()\\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\\n mn /= numpy.prod(tensor.shape[1:])\\n q = alpha * (1 - mn) * 50\\n n_samples = tensor.shape[0]\\n add_view = [1] * (tensor.ndim - 1)\\n low = torch.tensor(\\n [numpy.percentile(tensor[i], q[i]) for i in range(n_samples)]).float()\\n high = torch.tensor([numpy.percentile(tensor[i], 100 - q[i]) for i in\\n range(n_samples)]).float()\\n low = low.view(-1, *add_view)\\n high = high.view(-1, *add_view)\\n return (tensor - low / (high - low)).to(device)\",\n \"def maxs(self) -> Tensor:\\n return self._ranges[:, 1]\",\n \"def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\\n ...\",\n \"def mins(self) -> Tensor:\\n return self._ranges[:, 0]\",\n \"def min_max_range(s):\\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\\n sign = np.sign(np.argmax(s) - np.argmin(s))\\n if sign == 0:\\n return 0.0\\n else:\\n return sign*(np.max(s) - np.min(s))\",\n \"def calculate_min_max_tiles(self):\",\n \"def bounds(self) -> Tensor:\\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)\",\n \"def minmax_norm(X):\\n return (X - tf.reduce_min(X))/(tf.reduce_max(X)-tf.reduce_min(X))\",\n \"def local_max_to_min(node):\\r\\n if node.op == T.neg and node.inputs[0].owner:\\r\\n max = node.inputs[0]\\r\\n if (max.owner and\\r\\n isinstance(max.owner.op, CAReduce)\\r\\n and max.owner.op.scalar_op == scal.maximum):\\r\\n neg = max.owner.inputs[0]\\r\\n if neg.owner and neg.owner.op == T.neg:\\r\\n return [CAReduce(scal.minimum,\\r\\n max.owner.op.axis)(neg.owner.inputs[0])]\\r\\n\\r\\n return False\",\n \"def nudged_min_max_compute(min_broadcast, max_broadcast, num_bits, narrow_range):\\n\\n\\n dtype = min_broadcast.dtype\\n quant_min = 1 if narrow_range else 0\\n quant_max = (2 ** num_bits) - 1\\n\\n # because of need compute each channel, so quant_min and quant_max need to broadcast.\\n quant_min_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_min, dtype))\\n quant_max_float = topi.full(min_broadcast.shape, dtype, tvm.const(quant_max, dtype))\\n\\n # caculate each channel max and min difference.\\n max_sub_min = topi.subtract(max_broadcast, min_broadcast)\\n quant_max_sub_quant_min = topi.subtract(quant_max_float, quant_min_float)\\n # compute scale = (max_broadcast - min_broadcast) / (quant_max - quant_min)\\n # and min_div_scale = min_broadcast / scale\\n if product_is_mini():\\n scale = mul(max_sub_min, reciprocal(quant_max_sub_quant_min), target=utils.CCE)\\n min_div_scale = Mul(min_broadcast, reciprocal(scale), target=utils.CCE)\\n else:\\n scale = divide(max_sub_min, quant_max_sub_quant_min, target=utils.CCE)\\n min_div_scale = divide(min_broadcast, scale, target=utils.CCE)\\n\\n # zero_point_from_min = quant_min_float - min_broadcast / scale\\n zero_point_from_min = topi.subtract(quant_min_float, min_div_scale)\\n # if zero_point_from_min < quant_min_float, bool_less_quant_min_float = 1 else 0\\n bool_less_quant_min_float = less_compare_float32(zero_point_from_min, quant_min_float)\\n # if quant_max_float < zero_point_from_min, bool_more_quant_max_float = 1 else 0\\n bool_more_quant_max_float = less_compare_float32(quant_max_float, zero_point_from_min)\\n\\n # according to above bool param to select effective value\\n less_quant_min_float = topi.multiply(quant_min_float, bool_less_quant_min_float)\\n more_quant_max_float = topi.multiply(quant_max_float, bool_more_quant_max_float)\\n\\n # compute which num is not less than quant_min_float and not large than quant_max_float\\n tensor_one = topi.full(min_broadcast.shape, dtype, dc.one_const(dtype))\\n bool_not_less_quant_min_float = topi.subtract(tensor_one, bool_less_quant_min_float)\\n bool_not_more_quant_max_float = topi.subtract(tensor_one, bool_more_quant_max_float)\\n bool_between_min_max = topi.multiply(bool_not_less_quant_min_float, bool_not_more_quant_max_float)\\n between_min_max_float = topi.multiply(zero_point_from_min, bool_between_min_max)\\n # add 0.5 to num which min <= num <= max and then floor them.\\n between_min_max_add_half_one = topi.add(between_min_max_float, dc.half_const(dtype))\\n between_min_max_round = akg.lang.ascend.floor(between_min_max_add_half_one)\\n if product_is_mini():\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float16\\\")\\n\\n between_min_max_round = topi.cast(between_min_max_round, \\\"float32\\\")\\n\\n # calculate the maximum and minimum values of the quantization\\n nudged_zero_point_tmp = topi.add(less_quant_min_float, more_quant_max_float)\\n nudged_zero_point = topi.add(nudged_zero_point_tmp, between_min_max_round)\\n\\n nudged_min_tmp = topi.subtract(quant_min_float, nudged_zero_point)\\n nudged_max_tmp = topi.subtract(quant_max_float, nudged_zero_point)\\n nudged_min = topi.multiply(nudged_min_tmp, scale)\\n nudged_max = topi.multiply(nudged_max_tmp, scale)\\n res = [nudged_min, nudged_max, scale]\\n\\n return res\",\n \"def min_max(xs):\\n return min(xs), max(xs)\",\n \"def minmin_maxmax( *args ):\\n rmin = min( [ mv.min() for mv in args ] )\\n rmax = max( [ mv.max() for mv in args ] )\\n rmv = cdms2.createVariable( [rmin,rmax] )\\n return rmv\",\n \"def convert_arg_max_min(g, op, block):\\n\\n axis = op.attr(\\\"axis\\\")\\n keepdims = op.attr(\\\"keepdims\\\")\\n flatten = op.attr(\\\"flatten\\\")\\n dtype = op.attr(\\\"dtype\\\")\\n dtype = _convert_dtype_value(dtype)\\n\\n func = _op.argmax if op.type == \\\"arg_max\\\" else _op.argmin\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n if axis is None or flatten:\\n x = _op.reshape(x, [-1])\\n out = func(x, axis=None, keepdims=True)\\n else:\\n out = func(x, axis=axis, keepdims=keepdims)\\n if dtype != infer_type(out).checked_type.dtype:\\n out = _op.cast(out, dtype)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def test_min_max_scalar(features: List[List[float]]) -> List[List[float]]:\\n min_max_features = []\\n transposed_features = [list(i) for i in zip(*features)]\\n for feature in transposed_features:\\n min_in_feature = min(feature)\\n max_in_feature = max(feature)\\n if min_in_feature == max_in_feature:\\n min_max_features.append([0 for x in feature])\\n else:\\n min_max_features.append([(x - min_in_feature) / (max_in_feature - min_in_feature) for x in feature])\\n return [list(i) for i in zip(*min_max_features)]\",\n \"def abs_max(tensor):\\n min_val, max_val = tensor.min(), tensor.max()\\n return max(min_val.abs(), max_val.abs())\",\n \"def _bound(x, min_value, max_value):\\n return np.maximum(min_value, np.minimum(x, max_value))\",\n \"def clamp(n, min_, max_):\\n return max(min(max_,n),min_)\",\n \"def minimum_maximum_model():\\n inputs = tf.keras.Input(shape=(32, 32, 3,))\\n x = tf.keras.layers.Conv2D(32, (3, 3))(inputs)\\n x = tf.keras.layers.BatchNormalization(momentum=.3, epsilon=.65)(x, training=False)\\n x = tf.minimum(x, .2)\\n x = tf.maximum(x, .5)\\n x = tf.keras.layers.Conv2D(16, (2, 2), activation=tf.nn.tanh)(x)\\n x = tf.keras.layers.Flatten()(x)\\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\\\"minimum_maximum_model\\\")(x)\\n return outputs\",\n \"def saturate_scalar_minmax(value, max_value, min_value):\\n mean = (max_value + min_value)/2.0\\n half_range = (max_value - min_value)/2.0\\n return saturate_vector_dg(value-mean, half_range) + mean\",\n \"def min_max(tr):\\n tr = tr.astype(float)\\n mm = tr.min() / tr.max()\\n return mm\",\n \"def min_max_normalization(x, min_x = None, max_x = None):\\n if min_x is None:\\n min_x = np.min(x, axis=0)\\n if max_x is None:\\n max_x = np.max(x, axis=0)\\n return (x - (min_x)) / (max_x - min_x), min_x, max_x\",\n \"def minmax(self):\\n return self._data_lim[self._n_overlay - 1]\",\n \"def minmax(self):\\r\\n vx = [v[0] for v in self.vl]\\r\\n vy = [v[1] for v in self.vl]\\r\\n self.xmax, self.xmin = max(vx), min(vx)\\r\\n self.ymax, self.ymin = max(vy), min(vy)\",\n \"def get_range(lst):\\n return float(max(lst)) - float(min(lst))\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def minMaxFonc(liste):\\n\\n return min(liste), max(liste)\",\n \"def min_max(arr, arr_size):\\n max_t = arr[0]\\n min_t = arr[0]\\n for i in range(arr_size):\\n if arr[i] > max_t:\\n max_t = arr[i]\\n if arr[i] < min_t:\\n min_t = arr[i]\\n return min_t, max_t\",\n \"def clamp(value, mn, mx):\\n\\n return max(min(value, mx), mn)\",\n \"def _normalize_range():\\n clipped = tf.clip_by_value(inputs, self.minimum, self.maximum)\\n return -1 + 2 * (clipped - self.minimum) / length\",\n \"def minmax_normalize(X):\\n # X -= X.min()\\n # X /= X.max()\\n # X -= 0.5\\n X = (X-X.min()) / (X.max() - X.min())\\n return X\",\n \"def spec_min_max(self):\\n spec_max = np.asarray([2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,2048,\\n 2048,2048,2048,2048,2048])\\n spec_min = np.asarray([ 500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\\n 0, 0, 0, 0, 0])\\n return np.vstack((spec_min, spec_max))\",\n \"def quickMinMax(self, targetSize=1e6):\\n data = self.image\\n if targetSize < 2: # keep at least two pixels\\n targetSize = 2\\n while True:\\n h, w = data.shape[:2]\\n if h * w <= targetSize: break\\n if h > w:\\n data = data[::2, ::] # downsample first axis\\n else:\\n data = data[::, ::2] # downsample second axis\\n return self._xp.nanmin(data), self._xp.nanmax(data)\",\n \"def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\\n assert \\\\\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\\\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\\\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\\n if dtype is None:\\n dtype = images.dtype\\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)\",\n \"def min_max(items):\\n return min(items), max(items)\",\n \"def _min_max_scale(arr, new_range=(0, 255)):\\n # get array's current min and max\\n mn = arr.min()\\n mx = arr.max()\\n\\n # check if scaling needs to be done to be in new_range\\n if mn < new_range[0] or mx > new_range[1]:\\n # perform min-max scaling\\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\\n else:\\n # return array if already in range\\n scaled = arr\\n\\n return scaled\",\n \"def argmin(tensor):\\n raise NotImplementedError\",\n \"def get_max_min(block_size):\\r\\n return (int(block_size / 2), int((block_size - 1) / 2))\",\n \"def cpfclamp(f, min_, max_):\\n return min(max(f, min_), max_)\",\n \"def minMax(df):\\n max_, min_ = df.max(axis=0), df.min(axis=0)\\n midrange = (max_ + min_) / 2\\n half_range = (max_ - min_) / 2\\n return (df - midrange) / half_range\",\n \"def data_range(x):\\n return max(x)-min(x)\",\n \"def view_limits(self, dmin, dmax):\\n base = self._select_base(dmin, dmax)\\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\\n vmin = base.le(dmin)\\n vmax = base.ge(dmax)\\n if vmin == vmax:\\n vmin -= 1\\n vmax += 1\\n else:\\n vmin = dmin\\n vmax = dmax\\n\\n return mtransforms.nonsingular(vmin, vmax)\",\n \"def minMaxLoc(img):\\n\\tmaskVar = mask(img)\\n\\tpt = cv2.minMaxLoc(grayscale(img), maskVar)\\n\\td = {\\\"minVal\\\": pt[0], \\\"maxVal\\\":pt[1], \\\"minLoc\\\":pt[2], \\\"maxLoc\\\":pt[3]}\\n\\treturn d\",\n \"def get_min_max(ints):\\n print(f\\\"input arr is {ints}\\\")\\n max=0\\n min=len(ints)-1\\n for i in range(1,len(ints)):\\n if ints[i]>ints[max]:\\n temp=ints[i]\\n ints[i]=ints[max]\\n ints[max]=temp\\n if ints[i]<ints[min]:\\n temp=ints[i]\\n ints[i]=ints[min]\\n ints[min]=temp\\n #print(f\\\"max value is {ints[max]}\\\")\\n #print(f\\\"min value is {ints[min]}\\\")\\n return(ints[min],ints[max])\",\n \"def minmax ( self , nshoots = 100000 ) :\\n ## try to get minmax directly from pdf/function \\n if self.tricks and hasattr ( self.pdf , 'function' ) :\\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \\n f = self.pdf.function()\\n if hasattr ( f , 'minmax' ) :\\n try :\\n mn , mx = f.minmax()\\n if 0<= mn and mn <= mx and 0 < mx : \\n return mn , mx\\n except :\\n pass\\n if hasattr ( f , 'max' ) :\\n try :\\n mx = f.max()\\n if 0 < mx : return 0 , mx\\n except :\\n pass\\n\\n ## check RooAbsReal functionality\\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\\n if 0 < code :\\n mx = self.pdf.maxVal ( code )\\n if 0 < mx : return 0 , mx\\n \\n ## not try to use random\\n \\n mn , mx = -1 , -10\\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\\n \\n if not self.xminmax() : return ()\\n if not self.yminmax() : return ()\\n \\n mn , mx = -1 , -10\\n xmn , xmx = self.xminmax()\\n ymn , ymx = self.yminmax()\\n for i in range ( nshoots ) : \\n xx = random.uniform ( xmn , xmx )\\n yy = random.uniform ( ymn , ymx )\\n with SETVAR ( self.xvar ) :\\n with SETVAR ( self.yvar ) :\\n self.xvar.setVal ( xx )\\n self.yvar.setVal ( yy )\\n vv = self.pdf.getVal()\\n if mn < 0 or vv < mn : mn = vv\\n if mx < 0 or vv > mx : mx = vv\\n \\n return mn , mx\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def min_max(my_list):\\n print(\\\"Min = \\\",min(my_list,key = abs))\\n print(\\\"Max = \\\",max(my_list,key = abs))\",\n \"def min_max_scale(self, feature_range=(0, 1)):\\n\\n if len(feature_range) != 2:\\n raise AttributeError(\\n \\\"Error: `feature_range` doesn't look like a 2-element tuple?\\\"\\n )\\n if feature_range[1] < feature_range[0]:\\n raise AttributeError(\\\"Error: `feature_range` isn't increasing?\\\")\\n\\n # use self.__class__ so that child classes can inherit this method\\n return self.__class__(\\n min_max_scale(self.spectrogram, feature_range=feature_range),\\n frequencies=self.frequencies,\\n times=self.times,\\n decibel_limits=self.decibel_limits,\\n )\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def normalizeToRange(data,max=255,min=0):\\n if min: return (max-min)*normalize(data)+min\\n else: return max*normalize2(data) # speeds up operation\",\n \"def x_y_coor_min_max(x_y_coor):\\n\\tx_range = [np.min(x_y_coor[\\\"X\\\"]),np.max(x_y_coor[\\\"X\\\"])]\\n\\ty_range = [np.min(x_y_coor[\\\"Y\\\"]),np.max(x_y_coor[\\\"Y\\\"])]\\n\\treturn x_range, y_range\",\n \"def masked_minimum(data, mask, dim=1):\\n axis_maximums = tf.reduce_max(data, dim, keepdims=True)\\n masked_minimums = tf.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def map_range(x, in_min, in_max, out_min, out_max):\\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\\n if out_min <= out_max:\\n return max(min(mapped, out_max), out_min)\\n return min(max(mapped, out_max), out_min)\",\n \"def maxima_in_range(r, g_r, r_min, r_max):\\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\\n g_r_slice = g_r[idx]\\n g_r_max = g_r_slice[g_r_slice.argmax()]\\n idx_max, _ = find_nearest(g_r, g_r_max)\\n return r[idx_max], g_r[idx_max]\",\n \"def find_max_min(self, col):\\n self.max = max(col)\\n self.min = min(col)\",\n \"def data_range(xs: List[float]) -> float:\\n return max(xs) - min(xs)\",\n \"def clamp(minimum, n, maximum):\\n return max(minimum, min(n, maximum))\",\n \"def min_max(lst):\\r\\n my_min = None\\r\\n my_max = None\\r\\n for num in lst:\\r\\n if (my_min and my_max) is not None:\\r\\n # recalculate running min and max:\\r\\n if num < my_min:\\r\\n my_min = num\\r\\n continue\\r\\n if num > my_max:\\r\\n my_max = num\\r\\n else:\\r\\n my_min = num\\r\\n my_max = num\\r\\n ans = (my_min, my_max)\\r\\n return ans\",\n \"def masked_minimum(data, mask, dim=1):\\n # sourced from:\\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L141-L157\\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\\n masked_minimums = tf.math.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def vc_clamp(x, lb, ub):\\n\\n y = min(x, ub)\\n y = max(y, lb)\\n\\n return y\",\n \"def view_limits(self, vmin, vmax):\\n return vmin, vmax\\n # return nonsingular(vmin, vmax)\",\n \"def clamp(value, min_value, max_value):\\n return max(min_value, min(value, max_value))\",\n \"def clip(tensor, a_min=None, a_max=None):\\n raise NotImplementedError\",\n \"def minima_in_range(r, g_r, r_min, r_max):\\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\\n g_r_slice = g_r[idx]\\n g_r_min = g_r_slice[g_r_slice.argmin()]\\n idx_min, _ = find_nearest(g_r, g_r_min)\\n return r[idx_min], g_r[idx_min]\",\n \"def getColorRange(self):\\n vmax=self.data_matrix.max()\\n vmin=self.data_matrix.min()\\n\\n if vmax * vmin < 0: # ie number range spans +ve and -ve\\n vmax = max([vmax, abs(vmin)])\\n vmin = -1*vmax\\n\\n return vmax,vmin\",\n \"def _argmax(self, input_tensor, dimension, c):\\n with self.session.graph.as_default():\\n min_values = tf.reduce_min(input_tensor, reduction_indices=[dimension,], keep_dims=True)\\n not_c = tf.abs(c - 1)\\n\\n return tf.argmax(input_tensor * c + not_c * min_values, dimension)\",\n \"def clamp(n, minn, maxn):\\n return max(min(maxn, n), minn)\",\n \"def minMax2(x):\\r\\n\\r\\n iMinMax = [0 for i in range(2)]\\r\\n num = len(x)[0]\\r\\n\\r\\n iMin = 0\\r\\n iMax = 0\\r\\n\\r\\n #// Search for minimum and maximum in row 0 - linear values:\\r\\n min = x[0][iMin]\\r\\n max = x[0][iMax]\\r\\n\\r\\n for i in range(1, num):\\r\\n\\r\\n if (x[0][i] < min): \\r\\n min = x[0][i]\\r\\n iMin = i\\r\\n \\r\\n\\r\\n if (x[0][i] > max): \\r\\n max = x[0][i]\\r\\n iMax = i\\r\\n \\r\\n iMinMax[0] = iMin\\r\\n iMinMax[1] = iMax\\r\\n\\r\\n return iMinMax\",\n \"def minmaxdenorm(v, minv, maxv):\\n v *= maxv - minv\\n v += minv\\n return v\",\n \"def clip_range(x, xlim):\\n return min([max([x, xlim[0]]), xlim[1]])\",\n \"def map_to_range(val, old_min, old_max, new_min, new_max):\\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)\",\n \"def _min_in_bounds(self, min):\\n if min <= self.valmin:\\n if not self.closedmin:\\n return self.val[0]\\n min = self.valmin\\n\\n if min > self.val[1]:\\n min = self.val[1]\\n return self._stepped_value(min)\",\n \"def minmax(xs):\\n min_val = None\\n max_val = None\\n for x in xs:\\n if min_val is None or x < min_val:\\n min_val = x\\n if max_val is None or x > max_val:\\n max_val = x\\n return (min_val, max_val)\",\n \"def masked_maximum(data, mask, dim=1):\\n axis_minimums = tf.reduce_min(data, dim, keepdims=True)\\n masked_maximums = tf.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim,\\n keepdims=True) + axis_minimums\\n return masked_maximums\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def xminmax ( self ) :\\n return self.xvar.minmax()\",\n \"def minMax(x):\\r\\n\\r\\n iMinMax = [0 for i in range(2)]\\r\\n\\r\\n num = len(x)\\r\\n #//System.out.println(\\\"MinMax: num: \\\" + num);\\r\\n\\r\\n iMin = 0\\r\\n iMax = 0\\r\\n min = x[iMin]\\r\\n max = x[iMax]\\r\\n\\r\\n for i in range(1, num):\\r\\n\\r\\n #//System.out.println(\\\"MinMax: i , current min, x : \\\" + i + \\\" \\\" + min + \\\" \\\" + x[i]);\\r\\n if (x[i] < min): \\r\\n #//System.out.println(\\\"MinMax: new min: if branch triggered\\\" );\\r\\n min = x[i]\\r\\n iMin = i\\r\\n \\r\\n #//System.out.println(\\\"MinMax: new min: \\\" + min);\\r\\n\\r\\n if (x[i] > max): \\r\\n max = x[i]\\r\\n iMax = i\\r\\n \\r\\n\\r\\n \\r\\n #//System.out.println(\\\"MinMax: \\\" + iMin + \\\" \\\" + iMax);\\r\\n\\r\\n iMinMax[0] = iMin\\r\\n iMinMax[1] = iMax\\r\\n\\r\\n return iMinMax\",\n \"def standardize_x(\\n x: torch.Tensor, x_min: torch.Tensor = None, x_max: torch.Tensor = None\\n):\\n if (x_min is not None and x_max is None) or (x_min is None and x_max is not None):\\n raise ValueError(\\n \\\"Either *both* or *neither* of x_min, x_max need to be supplied!\\\"\\n )\\n if x_min is None:\\n x_min = torch.min(x, 0)[0]\\n x_max = torch.max(x, 0)[0]\\n x = (x - x_min) / (x_max - x_min)\\n return x, x_min, x_max\",\n \"def masked_minimum(data, mask, dim=1):\\n axis_maximums = math_ops.reduce_max(data, dim, keepdims=True)\\n masked_minimums = math_ops.reduce_min(\\n math_ops.multiply(data - axis_maximums, mask), dim,\\n keepdims=True) + axis_maximums\\n return masked_minimums\",\n \"def _xywh2min_max(box):\\n x, y, w, h = box\\n return np.array([x, y, x+w, y+h])\",\n \"def constrain(n: int, low: int, high: int) -> int:\\n return max(min(n, high), low)\",\n \"def _masked_minimum(data, mask, dim=1):\\n axis_maximums = tf.math.reduce_max(data, dim, keepdims=True)\\n masked_minimums = (\\n tf.math.reduce_min(\\n tf.math.multiply(data - axis_maximums, mask), dim, keepdims=True\\n )\\n + axis_maximums\\n )\\n return masked_minimums\",\n \"def min_max(self, data, era):\\n return 0, np.max(data)\",\n \"def find_max_min(number):\\n if max(number) == min(number):\\n return [len(number)]\\n return [min(number), max(number)]\",\n \"def clamp(n, minn, maxn):\\n return max(min(maxn, n), minn)\",\n \"def range(self):\\r\\n\\t\\treturn max(self.sample) - min(self.sample)\",\n \"def masked_maximum(data, mask, dim=1):\\n # sourced from:\\n # https://github.com/tensorflow/tensorflow/blob/r1.14/tensorflow/contrib/losses/python/metric_learning/metric_loss_ops.py#L122-L138\\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\\n masked_maximums = tf.math.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim,\\n keepdims=True) + axis_minimums\\n return masked_maximums\",\n \"def dim_zero_min(x: Tensor) ->Tensor:\\n return torch.min(x, dim=0).values\",\n \"def convert_clip(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n dtype = infer_type(x).checked_type.dtype\\n # if the min/max value is a tensor\\n min_max_is_tensor = False\\n if op.input(\\\"Min\\\"):\\n min_value = g.get_node(op.input(\\\"Min\\\")[0])\\n min_value, infered = try_infer_value(min_value, g.get_params())\\n if infered:\\n min_value = min_value.tolist()[0]\\n if isinstance(min_value, _expr.Expr):\\n min_max_is_tensor = True\\n else:\\n min_value = op.attr(\\\"min\\\")\\n\\n if op.input(\\\"Max\\\"):\\n max_value = g.get_node(op.input(\\\"Max\\\")[0])\\n max_value, infered = try_infer_value(max_value, g.get_params())\\n if infered:\\n max_value = max_value.tolist()[0]\\n if isinstance(max_value, _expr.Expr):\\n min_max_is_tensor = True\\n else:\\n max_value = op.attr(\\\"max\\\")\\n\\n if min_max_is_tensor:\\n if not isinstance(min_value, _expr.Expr):\\n min_value = _op.const(min_value, dtype)\\n if not isinstance(max_value, _expr.Expr):\\n max_value = _op.const(max_value, dtype)\\n out = _op.maximum(x, min_value)\\n out = _op.minimum(out, max_value)\\n else:\\n out = _op.clip(x, min_value, max_value)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def min():\\n return KeeperOfMinOrMax(int.__gt__)\",\n \"def normalize_minmax(data):\\n _min = np.float(np.min(data))\\n _max = np.float(np.max(data))\\n if (_max-_min)!=0:\\n img = (data - _min) / (_max-_min)\\n else:\\n img = np.zeros_like(data) \\n return img\",\n \"def print_minmax(arr):\\n print(arr.shape)\\n for i in range(arr.shape[1]):\\n print(transfer[i], arr[:,i].min(), arr[:,i].max())\",\n \"def _masked_maximum(data, mask, dim=1):\\n axis_minimums = tf.math.reduce_min(data, dim, keepdims=True)\\n masked_maximums = (\\n tf.math.reduce_max(\\n tf.math.multiply(data - axis_minimums, mask), dim, keepdims=True\\n )\\n + axis_minimums\\n )\\n return masked_maximums\",\n \"def _min_or_max_grad(x, axis, out, dout):\\n # input_shape = [2, 3] axis = [1]\\n input_shape = shape_op(x)\\n # output_shape_kept_dims = [2, 1]\\n output_shape_kept_dims = reduced_shape(input_shape, axis)\\n y = reshape(out, output_shape_kept_dims)\\n grad = reshape(dout, output_shape_kept_dims)\\n indicators = F.cast(F.equal(y, x), F.dtype(grad))\\n min_num = F.cast(F.scalar_to_array(1e-24), F.dtype(grad))\\n num_selected = reshape(reduce_sum(indicators, axis), output_shape_kept_dims) + min_num\\n return indicators / num_selected * grad\",\n \"def minmax(value):\\n return min(0xff, max(0, value))\",\n \"def scale_from_minmax(\\n col: np.ndarray, minmax: Optional[Tuple[float, float]]\\n) -> np.ndarray:\\n if minmax is None:\\n return np.zeros_like(col)\\n else:\\n min_, max_ = minmax\\n assert max_ - min_ >= FLOAT_TOL\\n return 2 * (col - min_) / (max_ - min_) - 1\",\n \"def atmax(a,upperlimit,dimension=None,inclusive=1):\\r\\n if inclusive: upperfcn = N.less\\r\\n else: upperfcn = N.less_equal\\r\\n if dimension == None:\\r\\n a = N.ravel(a)\\r\\n dimension = 0\\r\\n if upperlimit == None:\\r\\n upperlimit = N.maximum.reduce(N.ravel(a))+1\\r\\n smallest = N.minimum.reduce(N.ravel(a))\\r\\n ta = N.where(upperfcn(a,upperlimit),a,smallest)\\r\\n return N.maximum.reduce(ta,dimension)\",\n \"def min_max(arr: StaticArray) -> ():\\n minimum = arr.get(0) # sets min to first element\\n maximum = arr.get(0) # sets max to first element\\n # iterate over the elements in the array to check for < or >\\n for index in range(arr.size()):\\n if arr[index] < minimum: # if element is less than the current min, min = new element\\n minimum = arr[index]\\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\\n maximum = arr[index]\\n return minimum, maximum\",\n \"def atmin(a,lowerlimit=None,dimension=None,inclusive=1):\\r\\n if inclusive: lowerfcn = N.greater\\r\\n else: lowerfcn = N.greater_equal\\r\\n if dimension == None:\\r\\n a = N.ravel(a)\\r\\n dimension = 0\\r\\n if lowerlimit == None:\\r\\n lowerlimit = N.minimum.reduce(N.ravel(a))-11\\r\\n biggest = N.maximum.reduce(N.ravel(a))\\r\\n ta = N.where(lowerfcn(a,lowerlimit),a,biggest)\\r\\n return N.minimum.reduce(ta,dimension)\",\n \"def bounds(x, xMin, xMax):\\n if (x < xMin):\\n x = xMin\\n elif (x > xMax):\\n x = xMax\\n return(x)\",\n \"def constrain(small, value, big):\\n return min(max(value, small), big)\",\n \"def clamp(minimum, value, maximum):\\n return max(minimum, min(maximum, value))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75467235","0.7126264","0.7105955","0.7104534","0.70395917","0.6998385","0.69723856","0.69567525","0.6950661","0.6929797","0.6809948","0.6738251","0.66825795","0.66631263","0.6628244","0.6626751","0.6614928","0.66133803","0.6575226","0.65187347","0.65003437","0.64497805","0.64320236","0.6401938","0.6365336","0.6363588","0.636268","0.6358396","0.63390005","0.6321498","0.6317748","0.62817335","0.6280598","0.6249695","0.62460136","0.6237293","0.6236586","0.62325007","0.6229694","0.6226508","0.62035584","0.61972094","0.61788917","0.617552","0.6162019","0.61617637","0.61616486","0.61483824","0.6145617","0.6138636","0.6136428","0.61340386","0.6128687","0.6127425","0.61269087","0.6117599","0.61143017","0.61133873","0.6111438","0.6083003","0.6081341","0.608125","0.6079389","0.607548","0.60753185","0.6075174","0.6073003","0.60593104","0.6056523","0.6056054","0.60550046","0.6050541","0.60406834","0.60341525","0.6014984","0.6010156","0.6009478","0.600627","0.59939826","0.59785545","0.59688646","0.59588176","0.5958337","0.5955367","0.59533954","0.5949759","0.59494215","0.59480673","0.5945206","0.59421986","0.59394336","0.5937541","0.5936399","0.59342414","0.5930668","0.59304607","0.59194493","0.59159684","0.5913923","0.5908068","0.59057945"],"string":"[\n \"0.75467235\",\n \"0.7126264\",\n \"0.7105955\",\n \"0.7104534\",\n \"0.70395917\",\n \"0.6998385\",\n \"0.69723856\",\n \"0.69567525\",\n \"0.6950661\",\n \"0.6929797\",\n \"0.6809948\",\n \"0.6738251\",\n \"0.66825795\",\n \"0.66631263\",\n \"0.6628244\",\n \"0.6626751\",\n \"0.6614928\",\n \"0.66133803\",\n \"0.6575226\",\n \"0.65187347\",\n \"0.65003437\",\n \"0.64497805\",\n \"0.64320236\",\n \"0.6401938\",\n \"0.6365336\",\n \"0.6363588\",\n \"0.636268\",\n \"0.6358396\",\n \"0.63390005\",\n \"0.6321498\",\n \"0.6317748\",\n \"0.62817335\",\n \"0.6280598\",\n \"0.6249695\",\n \"0.62460136\",\n \"0.6237293\",\n \"0.6236586\",\n \"0.62325007\",\n \"0.6229694\",\n \"0.6226508\",\n \"0.62035584\",\n \"0.61972094\",\n \"0.61788917\",\n \"0.617552\",\n \"0.6162019\",\n \"0.61617637\",\n \"0.61616486\",\n \"0.61483824\",\n \"0.6145617\",\n \"0.6138636\",\n \"0.6136428\",\n \"0.61340386\",\n \"0.6128687\",\n \"0.6127425\",\n \"0.61269087\",\n \"0.6117599\",\n \"0.61143017\",\n \"0.61133873\",\n \"0.6111438\",\n \"0.6083003\",\n \"0.6081341\",\n \"0.608125\",\n \"0.6079389\",\n \"0.607548\",\n \"0.60753185\",\n \"0.6075174\",\n \"0.6073003\",\n \"0.60593104\",\n \"0.6056523\",\n \"0.6056054\",\n \"0.60550046\",\n \"0.6050541\",\n \"0.60406834\",\n \"0.60341525\",\n \"0.6014984\",\n \"0.6010156\",\n \"0.6009478\",\n \"0.600627\",\n \"0.59939826\",\n \"0.59785545\",\n \"0.59688646\",\n \"0.59588176\",\n \"0.5958337\",\n \"0.5955367\",\n \"0.59533954\",\n \"0.5949759\",\n \"0.59494215\",\n \"0.59480673\",\n \"0.5945206\",\n \"0.59421986\",\n \"0.59394336\",\n \"0.5937541\",\n \"0.5936399\",\n \"0.59342414\",\n \"0.5930668\",\n \"0.59304607\",\n \"0.59194493\",\n \"0.59159684\",\n \"0.5913923\",\n \"0.5908068\",\n \"0.59057945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83790,"cells":{"query":{"kind":"string","value":"Generate informative data based on given data."},"document":{"kind":"string","value":"def collect(self, name_to_arr):\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 show_data(sim_attr_generator):\n#TODO description\n if Args.data_to_show == 'dprime':\n show_dprime(sim_attr_generator)","def generate_ta(data):\n raise NotImplementedError","def format_data(self, data):","def _construct(self, data):\n logging.info(\"overall constructing (enter)\")\n\n pre_construct_data = self._pre_construct(data)\n # Kickstart the seralizin'.\n\n #if it found no ids, then we can just use the pre construct data\n if any((len(ids) > 0 for label, ids in self.ids.iteritems())):\n self.data = collections.defaultdict(dict)\n\n\n for manip in self.manips:\n manip()\n\n logging.debug(\"constructing (enter)\")\n # extend the output using the collated data we've found\n data = self.construct(data)\n logging.debug(\"constructing (exit)\")\n\n logging.debug(\"overall constructing (exit)\")\n return data\n else:\n logging.debug(\"overall constructing (exit)\")\n return pre_construct_data","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def analyse(self, data=None):\n pass","def generate_extra_data(self):\n self.data[\"male_initial\"], self.data[\"female_initial\"] = \\\n self.get_initial_student_count()\n \n date_line = '<p class=\"report-title\"> %s</p>' \\\n %(self.start_date.strftime(\"%B %Y\"))\n row1 = \"\"\"\n <table>\n <tr class=\"tblRow\"><td>%s</td><td>Enrollment For Year</td>\n <td>Male:</td><td>%d</td><td>Female:</td><td>%d</td>\n <td>Total:</td><td>%d</td></tr>\n \"\"\" %(unicode(self.school), self.data[\"male_initial\"], \n self.data[\"female_initial\"], \n self.data[\"male_initial\"] + self.data[\"female_initial\"])\n row2 = \"\"\"\n <tr class=\"tblOddRow\"><td>%s</td><td>Enrollment For Month</td>\n <td>Male:</td><td>%d</td><td>Female:</td><td>%d</td>\n <td>Total:</td><td>%d</td></tr>\n \"\"\" %(unicode(self.section), self.data[\"male_current\"], \n self.data[\"female_current\"],\n self.data[\"male_current\"] + self.data[\"female_current\"])\n row3 = \"\"\"\n <tr class=\"tblRow\"><td>%s</td><td>Average Attendance</td>\n <td>Male:</td><td>%.1f</td><td>Female:</td><td>%.1f</td>\n <td>Total:</td><td>%.1f</td></tr>\n \"\"\" %(\"Secondary\", self.data[\"aa_male\"], self.data[\"aa_female\"] ,\n self.data[\"aa_combined\"])\n row4 =\"\"\"\n <tr class=\"tblOddRow\"><td>%s</td><td>Percentage of Attendance</td>\n <td>Male:</td><td>%.1f %% </td><td>Female:</td><td>%.1f %% </td>\n <td>Total:</td><td>%.1f %% </td></tr>\n \"\"\" %(unicode(self.school.municipality), self.data[\"pa_male\"], \n self.data[\"pa_female\"], self.data[\"pa_combined\"])\n row5 = \"\"\"\n <tr class=\"tblRow\"><td>School Days: %d</td><td>Percentage of Enrollment</td>\n <td>Male:</td><td>%.1f %% </td><td>Female:</td><td>%.1f %% </td>\n <td>Total:</td><td>%.1f %% </td></tr>\n </table>\n \"\"\" %(self.data[\"num_school_days\"], \n self.data[\"male_current\"] * 100.0 / self.data[\"male_initial\"],\n self.data[\"female_current\"] * 100.0 / \n self.data[\"female_initial\"],\n (self.data[\"male_current\"] + self.data[\"female_current\"]) * \n 100.0 /\n (self.data[\"male_initial\"] + self.data[\"female_initial\"]))\n self.extra_data = date_line + row1 + row2 + row3 + row4 + row5","def generate_synthetic_data(plot_data=False):\n \n # generate 2 non-sensitive features for each data point from Gaussian distributions\n X_non_sensitive, y, pos_dist, neg_dist = generate_non_sensitive_feat()\n \n # generate 1 sensitive feature that is correlated with the non-sensitive features\n sensitive_feat = generate_sensitive_feat(X_non_sensitive, pos_dist, neg_dist)\n sensitive_feat_array = np.array(sensitive_feat)\n \n if plot_data:\n plot_synthetic_data(X_non_sensitive, y, sensitive_feat_array)\n \n # NOTE - This complicates the code somewhat, but lets our classify.py work with multiple sensitive features,\n # which in turn makes the classify code more reusable for students. It's a tradeoff.\n sensitive_feat_dict = {\"s1\": sensitive_feat}\n \n return X_non_sensitive, y, sensitive_feat_dict","def preprocess(data):\n raise NotImplementedError","def generate_statistics(data):\n print(data)\n for key in data:\n print('****\\nSummary data for %s:\\n----' % key)\n for category in data[key]:\n mean = generate_mean(data[key][category])\n print('\\taverage %s: %d' % (category, mean))\n print('\\n\\n')\n return","def treats_data(data, typo='mean'):\n\n nomalized_data = []\n\n if typo == 'mean':\n for i, v in enumerate(data):\n nomalized_data.append( fitness_medio(data[i]) )\n\n if typo == 'gen_mean':\n gens = [0]*len(data[0])\n\n for i, v in enumerate(data):\n for j, v in enumerate(data[i]):\n gens[j] += data[i][j]\n for i,v in enumerate(gens):\n nomalized_data.append( (gens[i])/len(data[0]) )\n\n if typo == 'max':\n for i, v in enumerate(data):\n nomalized_data.append( max(data[i]) )\n\n if typo == 'gen_max':\n gens = [0]*len(data[0])\n\n for i, v in enumerate(data):\n for j, v in enumerate(data[i]):\n if data[i][j] > gens[j]:\n gens[j] = (data[i][j])\n\n for i,v in enumerate(gens):\n nomalized_data.append( (gens[i]) )\n\n return nomalized_data","def print_data_info(my_data, src_field, trg_field):\n train_data = my_data[\"train\"]\n valid_data = my_data[\"val\"]\n test_data = my_data[\"test\"]\n\n print(\"Data set sizes (number of sentence pairs):\")\n print('train', len(train_data))\n print('valid', len(valid_data))\n print('test', len(test_data), \"\\n\")\n\n print(\"First training example:\")\n print(\"src:\", \" \".join(vars(train_data[0])['src']))\n print(\"trg:\", \" \".join(vars(train_data[0])['trg']), \"\\n\")\n\n print(\"Most common words (src):\")\n print(\"\\n\".join([\"%10s %10d\" % x for x in src_field.vocab.freqs.most_common(10)]), \"\\n\")\n print(\"Most common words (trg):\")\n print(\"\\n\".join([\"%10s %10d\" % x for x in trg_field.vocab.freqs.most_common(10)]), \"\\n\")\n\n print(\"First 10 words (src):\")\n print(\"\\n\".join(\n '%02d %s' % (i, t) for i, t in enumerate(src_field.vocab.itos[:10])), \"\\n\")\n print(\"First 10 words (trg):\")\n print(\"\\n\".join(\n '%02d %s' % (i, t) for i, t in enumerate(trg_field.vocab.itos[:10])), \"\\n\")\n\n print(\"Number of NL words (types):\", len(src_field.vocab))\n print(\"Number of AMR words (types):\", len(trg_field.vocab), \"\\n\")","def feature_extraction(_data):\n # Find the digits in the given string Example - data='18-20' digits = '1820'\n digits = str(''.join(c for c in _data if c.isdigit()))\n # calculate the length of the string\n len_digits = len(digits)\n # splitting digits in to values example - digits = '1820' ages = [18, 20]\n ages = [int(digits[i:i + 2]) for i in range(0, len_digits, 2)]\n # checking for special character in the given data\n special_character = '.+-<>?'\n spl_char = ''.join([c for c in list(special_character) if c in _data])\n # handling decimal age data\n if len_digits == 3:\n spl_char = '.'\n age = \"\".join([str(ages[0]), '.', str(ages[1])])\n # normalizing\n age = int(float(age) - 0.5)\n ages = [age]\n # Finding the maximum, minimum, average age values\n max_age = 0\n min_age = 0\n mean_age = 0\n if len(ages):\n max_age = max(ages)\n min_age = min(ages)\n if len(ages) == 2:\n mean_age = int((max_age + min_age) / 2)\n else:\n mean_age = max_age\n # specially added for 18 years cases\n only_18 = 0\n is_y = 0\n if ages == [18]:\n only_18 = 1\n if 'y' in _data or 'Y' in _data:\n is_y = 1\n under_18 = 0\n if 1 < max_age < 18:\n under_18 = 1\n above_65 = 0\n if mean_age >= 65:\n above_65 = 1\n # verifying whether digit is found in the given string or not.\n # Example - data='18-20' digits_found=True data='????' digits_found=False\n digits_found = 1\n if len_digits == 1:\n digits_found = 1\n max_age, min_age, mean_age, only_18, is_y, above_65, under_18 = 0, 0, 0, 0, 0, 0, 0\n elif len_digits == 0:\n digits_found, max_age, min_age, mean_age, only_18, is_y, above_65, under_18 = -1, -1, -1, -1, -1, -1, -1, -1\n \n feature = {\n 'ages': tuple(ages),\n 'len(ages)': len(ages),\n 'spl_chr': spl_char,\n 'is_digit': digits_found,\n 'max_age': max_age,\n 'mean_age': mean_age,\n 'only_18': only_18,\n 'is_y': is_y,\n 'above_65': above_65,\n 'under_18': under_18\n }\n\n return feature","def format(self, data):","def _generate_data(phg: str = None, rng: str = None, dfs: str = None, course: int = None,\n speed: int = None, altitude: int = None, comment: str = None) -> str:\n\n data = \"\"\n if phg:\n data += phg\n elif rng:\n data += rng\n elif dfs:\n data += dfs\n elif course and speed:\n data += \"{}/{}\".format(\n str(course).zfill(3), str(speed).zfill(3)\n )\n\n if altitude:\n data += \"/A={}\".format(\n str(altitude).zfill(6)\n )\n\n if comment:\n data += comment\n\n return data","def generateFeatures(self, data):\n pass","def easydatagen():\n\n # Reading in the training file\n data = pd.read_json('train.json')\n\n # The set of different cuisines\n cuisines = data.cuisine.unique()\n\n # To find the different ingredients, we need to clean them up a little.\n def clean(string) :\n s = string.replace('-',' ') # read low-fat the same as low fat\n s = string.replace('&', 'and') # read & and and as the same\n s = re.sub('\\((.*?)\\)', '', s) # remove everythin g in brackets\n s = re.sub('\\d{1,2}\\%', '', s) # remove things of the form d% or dd%, where d is a digit\n s = ' '.join(s.split()) # remove extra white spaces\n\n return s\n\n ing_list = data.ingredients.values.tolist()\n raw_ingredients = [clean(x) for ing in ing_list for x in ing]\n\n ingredients = sorted(set(raw_ingredients))\n\n # build a dictionary that to each ingredient assigns its index\n ingredient_index = {}\n for i in range(0,len(ingredients)) :\n ingredient_index[ingredients[i]] = i\n\n # the same for cuisines\n cuisine_index = {}\n for i in range(0, len(cuisines)) :\n cuisine_index[cuisines[i]] = i\n\n def ingredients_to_vector(ings) :\n vect = np.zeros(len(ingredients))\n for ing in ings :\n vect[ingredient_index[clean(ing)]] = 1\n\n return vect\n\n def cuisine_to_vector(cus) :\n vect = np.zeros(20)\n vect[cuisine_index[cus]] = 1\n return vect\n\n vect_list = [ingredients_to_vector(ing) for ing in ing_list]\n target_list = [cuisine_to_vector(cus) for cus in data.cuisine.values.tolist()]\n\n # Define training data\n X = np.c_[vect_list]\n Y = np.c_[target_list]\n\n Y_num = np.zeros((Y.shape[0]))\n for i in range(Y.shape[0]):\n Y_num[i] = np.argmax(Y[i])\n\n x_train, x_test, y_train, y_test = train_test_split(X, Y_num, test_size = 0.2)\n\n return x_train, x_test, y_train, y_test","def analyze_data():\n attack_free_1 = load_messages(\"data/csv/Attack_free_dataset.csv\", verbose=True)\n\n impersonation_1 = load_messages(\"data/csv/170907_impersonation.csv\", verbose=True)\n impersonation_2 = load_messages(\"data/csv/170907_impersonation_2.csv\", verbose=True)\n impersonation_3 = load_messages(\"data/csv/Impersonation_attack_dataset.csv\", verbose=True)\n\n information = {\n \"Mean time between normal messages\":\n get_mean_time_between_normal_messages(attack_free_1),\n \"Mean time between split messages\":\n get_mean_time_between_split_messages(attack_free_1),\n \"Sum of removed intervals in '170907_impersonation.csv'\":\n get_sum_of_removed_intervals(impersonation_1, 250),\n \"Sum of removed intervals in '170907_impersonation_2.csv'\":\n get_sum_of_removed_intervals(impersonation_2, 250),\n \"Sum of removed intervals in 'Impersonation_attack_dataset.csv'\":\n get_sum_of_removed_intervals(impersonation_3, 250),\n \"Index of split in '170907_impersonation.csv'\":\n get_index_before_time(impersonation_1, 250 - 23.434627056121826),\n \"Index of split in '170907_impersonation_2.csv'\":\n get_index_before_time(impersonation_2, 250 - 20.980855226516724),\n \"Index of split in 'Impersonation_attack_dataset.csv'\":\n get_index_before_time(impersonation_3, 250 - 2.1056361198425293)\n }\n\n return information","def build_eval_data(self,data, num_classes, clean_string=False):\n revs = []\n num = [-1, 1]\n for line in data:\n line = line.decode('utf-8')\n sent = line\n rev = []\n rev.append(sent.strip())\n\n if clean_string:\n orig_rev = self.dc.clean_str(\" \".join(rev))\n else:\n orig_rev = \" \".join(rev).lower()\n #print orig_rev\n\n datum = {\"y\":num[np.random.randint(0, num_classes)],\n \"text\": orig_rev,\n \"num_words\": len(orig_rev.split()),\n }\n revs.append(datum)\n\n\n return revs","def display_data(data):\n\n index = 0\n for details in data:\n index += 1\n print(\"{5:1}{0}. {1:10} in {2:15} priority {3:>3}\".format(index, *details))","def build_sample(data):\n parsed = {\n 'lims_id': data['Sample Name'],\n 'name': data['External Name'],\n 'project_id': data['Project'],\n 'reference_genome': data['Reference Genome'],\n 'total_reads': data['Total Reads'],\n 'insert_size': data['Median Insert Size'],\n 'duplication_rate': data['Duplication Rate'],\n 'mapped_rate': data['Fraction aligned to Reference'],\n 'coverage_10x': data['Fraction of bases with cov >= 10X'],\n 'coverage_30x': data['Fraction of bases with cov >= 30X'],\n 'coverage_50x': data['Fraction of bases with cov >= 50X'],\n 'coverage_100x': data['Fraction of bases with cov >= 100X']\n }\n return parsed","def test_data():\n return {\"David Andrews\" : [200.50, 400.00, 250.75],\n \"John Goodfellow\" : [25.00, 175.50],\n \"Mary Suzuki\" : [75.00, 125.00, 250.00],\n \"Bonney Lake\" : [500.50, 700.75, 500.25],\n \"DeMarcus Rollins\" : [155.00, 165.00]\n }","def _basic_data_info(X, y):\n num_samples, num_feats = X.shape # start with X properties\n\n # Compute distribution\n classes, counts, percs = _class_distribution(y)\n num_classes = classes.size\n\n # Return data info dictionary\n output_dic = {\n \"Num_samples\": num_samples,\n \"Num_feats\": num_feats,\n \"Num_classes\": num_classes,\n \"classes\": classes,\n \"counts\": counts,\n \"percs\": percs\n }\n\n return output_dic","def generate_data(cls):\n cls.results = {}\n cls.pre_process()\n today = datetime.today()\n skip = None\n values = map(lambda a: a[0], cls.data)\n if len(values) == 0 and 'citation' not in cls.config_data_name:\n skip = True\n weights= map(lambda a: a[1], cls.data)\n if cls.config_data_name == 'reads_histogram':\n bins = range(1996, today.year+2)\n elif cls.min_year:\n bins = range(cls.min_year, today.year+2)\n else:\n try:\n bins = range(min(values),max(values)+2)\n except:\n skip = True\n if not skip:\n refereed_values = map(lambda a: a[0], cls.refereed_data)\n refereed_weights= map(lambda a: a[1], cls.refereed_data)\n # get the regular histogram\n cls.value_histogram = histogram(values,bins=bins)\n cls.refereed_value_histogram = histogram(refereed_values,bins=bins)\n # get the normalized histogram\n cls.normalized_value_histogram = histogram(values,bins=bins,weights=weights)\n cls.refereed_normalized_value_histogram = histogram(refereed_values,bins=bins,weights=refereed_weights)\n else:\n cls.value_histogram = False\n cls.results[str(today.year)] = \"0:0:0:0\"\n cls.post_process()","def _format_ov_ins(data: Dict[str, Any], cfg: Config) -> List[Dict[str, str]]:\n # pylint: disable=line-too-long\n # list of insights\n ins: List[Dict[str, str]] = []\n\n pdup = round((1 - data[\"nrows_wo_dups\"] / data[\"nrows\"]) * 100, 2)\n if pdup > cfg.insight.duplicates__threshold:\n ndup = data[\"nrows\"] - data[\"nrows_wo_dups\"]\n ins.append({\"Duplicates\": f\"Dataset has {ndup} ({pdup}%) duplicate rows\"})\n\n for (*cols, test_result) in data.get(\"ks_tests\", []):\n if test_result > cfg.insight.similar_distribution__threshold:\n msg = f\"/*start*/{cols[0]}/*end*/ and /*start*/{cols[1]}/*end*/ have similar distributions\"\n ins.append({\"Similar Distribution\": msg})\n\n data.pop(\"ks_tests\", None)\n\n return ins","def _setResultInfo(self, data: list):\n repResultInfo = [['機能','端子','状態','判定基準','結果','判定']]\n bufResultInfo = [''] * 6\n _data = [[d[1].split('_')[0],d[1].split('->')[0].split('_')[1],d[1].split('->')[1],d[2],d[3],d[4]] for d in data]\n resultInfo = [[s.replace(',','\\n') for s in ss] for ss in _data]\n for i, item in enumerate(resultInfo):\n if item[2][0:5] == 'LEVEL':\n bufResultInfo = item\n repResultInfo.append(bufResultInfo)\n bufResultInfo = [''] * 6\n elif item[0]=='SQ' or item[0]=='SAT' or item[0]=='LOAD':\n bufResultInfo[0] = item[0]\n bufResultInfo[1] = item[1]\n bufResultInfo[2] = item[2]\n elif item[2] == 'DTCread':\n bufResultInfo[3] = item[3]\n bufResultInfo[4] = item[4]\n bufResultInfo[5] = item[5]\n if bufResultInfo[0] != '':\n repResultInfo.append(bufResultInfo)\n bufResultInfo = [''] * 6\n self._result_info = repResultInfo","def _generate(self, custom_data: typing.Dict) -> typing.Dict:\n info = {}\n for field in self.fields:\n if field.name in custom_data:\n info[field.name] = custom_data[field.name]\n else:\n info[field.name] = field.generate(info)\n\n return info","def prepare_data():\n user_name = os.environ.get('USER')\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\n random.shuffle(traintest_corpus.resumes)\n\n for resume in traintest_corpus.resumes:\n try:\n review_text = pre_processing(resume[0])\n review_text = \" \".join(review_text)\n data_dict['data'].append(review_text)\n data_dict['label'].append(resume[1])\n except:\n pass","def verbose_data_dict(perf_data, epoch_losses, batch_losses):\n data_dict = []\n if epoch_losses is not None and len(epoch_losses['actor_mse']) > 0:\n data_dict.append({'title': \"Actor_MSE_Loss_vs_Epoch\", 'data': epoch_losses['actor_mse'],\n 'y_label': 'Loss' + '( min: ' + str(min(epoch_losses['actor_mse'])) + ' )',\n 'x_label': 'Epoch'})\n if epoch_losses is not None and len(epoch_losses['actor_ce']) > 0:\n data_dict.append({'title': \"Actor_CE_Loss_vs_Epoch\", 'data': epoch_losses['actor_ce'],\n 'y_label': 'Loss' + '( min: ' + str(min(epoch_losses['actor_ce'])) + ' )',\n 'x_label': 'Epoch'})\n if batch_losses is not None and len(batch_losses['actor_mse']) > 0:\n data_dict.append({'title': \"Actor_MSE_Loss_vs_Batches\", 'data': batch_losses['actor_mse'],\n 'y_label': 'Loss' + '( min: ' + str(min(batch_losses['actor_mse'])) + ' )',\n 'x_label': 'Batch'})\n if batch_losses is not None and len(batch_losses['actor_ce']) > 0:\n data_dict.append({'title': \"Actor_CE_Loss_vs_Batches\", 'data': batch_losses['actor_ce'],\n 'y_label': 'Loss' + '( min: ' + str(min(batch_losses['actor_ce'])) + ' )',\n 'x_label': 'Batch'})\n if perf_data is not None and len(perf_data) > 0:\n data_dict.append({'title': \"Test_Performance_vs_Epoch\", 'data': perf_data,\n 'y_label': 'Average Episode Reward' + '( max: ' + str(max(perf_data)) + ' )',\n 'x_label': 'Epoch'})\n return data_dict","def treatment_plugs(data_plugs):\r\n\r\n no_plugs = []\r\n little = []\r\n means = []\r\n great = []\r\n large_enough = []\r\n super_large = []\r\n\r\n\r\n for i in data_plugs:\r\n print(i[0])\r\n if i[1] in ('None', None)\\\r\n or i[0] in ('None', None):\r\n pass\r\n elif i[0] == 'non':\r\n no_plugs.append(int(i[1]))\r\n elif i[0] == 'petit':\r\n little.append(int(i[1]))\r\n elif i[0] == 'moyen':\r\n means.append(int(i[1]))\r\n elif i[0] == 'grand':\r\n great.append(int(i[1]))\r\n elif i[0] == 'assez grand':\r\n large_enough.append(int(i[1]))\r\n elif i[0] == 'tres grand':\r\n super_large.append(int(i[1]))\r\n\r\n\r\n data = len(no_plugs) + len(little) +\\\r\n len(means) + len(great)+\\\r\n len(large_enough)+\\\r\n len(super_large)\r\n\r\n print(data)\r\n\r\n data_no = moyenne(no_plugs)\r\n data_little = moyenne(little)\r\n data_means = moyenne(means)\r\n data_great = moyenne(great)\r\n data_large_enough = moyenne(large_enough)\r\n data_super_large = moyenne(super_large)\r\n\r\n return data_no[0],\\\r\n data_little[0],\\\r\n data_means[0],\\\r\n data_great[0],\\\r\n data_large_enough[0],\\\r\n data_super_large[0],\\\r\n data_no[1],\\\r\n data_little[1],\\\r\n data_means[1],\\\r\n data_great[1],\\\r\n data_large_enough[1],\\\r\n data_super_large[1],\\\r\n data","def define_info_dict():\n\n d = {\n \"PRED\": {\n \"COLUMN\": [\"predicted_class\"],\n \"Number\": \"1\",\n \"Type\": \"String\",\n \"Description\": \"Predicted class: somatic, germline, artifact\",\n },\n \"PROB\": {\n \"COLUMN\": [\"prob_s\", \"prob_g\", \"prob_a\"],\n \"Number\": \"3\",\n \"Type\": \"Float\",\n \"Description\": \"Prediction probability of \"\n \"being somatic, germline, artifact in this order\",\n },\n \"SNP\": {\n \"COLUMN\": [\"is_on_db\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Present on SNP database (modified dbSNP/gnomAD (default) or user-provided database)\",\n },\n \"ANNO\": {\n \"COLUMN\": [\"annotation\"],\n \"Number\": \".\",\n \"Type\": \"String\",\n \"Description\": \"Indel annotation formatted as \"\n \"GeneSymbol|RefSeqAccession|CodonPos|IndelEffect\"\n \"Delimited by comma for multiple isoforms\",\n },\n \"COSMIC_CNT\": {\n \"COLUMN\": [\"cosmic_cnt\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"COSMIC count in v89\",\n },\n \"MAXMAF\": {\n \"COLUMN\": [\"max_maf\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Maximum minor allele frequency (MAF) \"\n \"reported in dbSNP, ClinVar and gnomAD non-cancer population\",\n },\n \"COMMON\": {\n \"COLUMN\": [\"is_common\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Common in dbSNP or MAXMAF > 0.01\",\n },\n \"CLIN\": {\n \"COLUMN\": [\"clin_info\"],\n \"Number\": \"1\",\n \"Type\": \"String\",\n \"Description\": \"ClinVar annotation formatted as ClinicalSignificance|Condition\",\n },\n \"ICP\": {\n \"COLUMN\": [\"indel_complexity\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"Indel complexity: mismatches around the indel measured by edit distance\",\n },\n \"DSM\": {\n \"COLUMN\": [\"dissimilarity\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Dissimilarity: edit distance between indel and flanking sequences\",\n },\n \"ISZ\": {\n \"COLUMN\": [\"indel_size\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"Indel size\",\n },\n \"REP\": {\n \"COLUMN\": [\"repeat\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"Repeat: count of the indel-sequence repeats in flanking region\",\n },\n \"UQM\": {\n \"COLUMN\": [\"is_uniq_mapped\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Supported by uniquely mapped reads\",\n },\n \"NEB\": {\n \"COLUMN\": [\"is_near_boundary\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Near exon boundary\",\n },\n \"EQX\": {\n \"COLUMN\": [\"equivalence_exists\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Equivalent alignments exist for the indel\",\n },\n \"BID\": {\n \"COLUMN\": [\"is_bidirectional\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Supported by forward and reverse reads\",\n },\n \"MTA\": {\n \"COLUMN\": [\"is_multiallelic\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Multialleleic\",\n },\n \"FRM\": {\n \"COLUMN\": [\"is_inframe\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"In-frame indel\",\n },\n \"SPL\": {\n \"COLUMN\": [\"is_splice\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Located in splice region\",\n },\n \"TRN\": {\n \"COLUMN\": [\"is_truncating\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Truncating indel\",\n },\n \"CDD\": {\n \"COLUMN\": [\"is_in_cdd\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Located in conserved domain\",\n },\n \"LOC\": {\n \"COLUMN\": [\"indel_location\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Relative indel location within the transcript coding region\",\n },\n \"NMD\": {\n \"COLUMN\": [\"is_nmd_insensitive\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Insensitive to nonsense mediated decay\",\n },\n \"IPG\": {\n \"COLUMN\": [\"ipg\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Indels per gene\",\n },\n \"LEN\": {\n \"COLUMN\": [\"cds_length\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Coding sequence length. Median value if multiple isoforms exist\",\n },\n \"LC\": {\n \"COLUMN\": [\"lc\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Linguistic complexity: diversity of k-mers in flanking 50-bp region\",\n },\n \"LLC\": {\n \"COLUMN\": [\"local_lc\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Local linguistic complexity: diversity of k-mers in flanking 6-bp region\",\n },\n \"GC\": {\n \"COLUMN\": [\"gc\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"GC-content in flanking 50-bp region\",\n },\n \"LGC\": {\n \"COLUMN\": [\"local_gc\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Local GC-content in flanking 6-bp region\",\n },\n \"SG\": {\n \"COLUMN\": [\"strength\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"DNA bond strength of 2-mers in flanking 50-bp region\",\n },\n \"LSG\": {\n \"COLUMN\": [\"local_strength\"],\n \"Number\": \"1\",\n \"Type\": \"Float\",\n \"Description\": \"Local DNA bond strength of 2-mers in flanking 6-bp region\",\n },\n \"INS\": {\n \"COLUMN\": [\"is_ins\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Insertion\",\n },\n \"ATI\": {\n \"COLUMN\": [\"is_at_ins\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Single insertion of A or T\",\n },\n \"ATD\": {\n \"COLUMN\": [\"is_at_del\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Single deletion of A or T\",\n },\n \"GCI\": {\n \"COLUMN\": [\"is_gc_ins\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Single insertion of G or C\",\n },\n \"GCD\": {\n \"COLUMN\": [\"is_gc_del\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Single deletion of G or C\",\n },\n \"ALTC\": {\n \"COLUMN\": [\"alt_count\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"Alt count: count of unique reads supporting ALT allele\",\n },\n \"REFC\": {\n \"COLUMN\": [\"ref_count\"],\n \"Number\": \"1\",\n \"Type\": \"Integer\",\n \"Description\": \"Ref count: count of unique reads supporting REF allele\",\n },\n \"RCF\": {\n \"COLUMN\": [\"reclassified\"],\n \"Number\": \"0\",\n \"Type\": \"Flag\",\n \"Description\": \"Reclassification applied\",\n },\n \"RQB\": {\n \"COLUMN\": [\"filtered\", \"rescued\"],\n \"Number\": \"1\",\n \"Type\": \"String\",\n \"Description\": \"Indel used to rescue this entry formatted as CHROM:POS:REF:ALT\",\n },\n }\n\n return d","def _make_information_storable( self, data ):\n\t\tpass","def make_code(self, datasetname):\n try:\n if(datasetname):\n for i in range(1, len(self.extract()) + 1):\n self.formated = datasetname + \"%03d\" % (i,)\n yield self.formated \n except:\n raise","def formatdata(data,Params):\n\tmndata = dict()\n\talltrials = np.array([])\n\tfor k in range(len(Params[\"conditions\"])):\n\t\tconditionmean = data[0,k].mean(axis = 0)\n\t\tmndata.update({Params[\"conditions\"][k]: {'data' : data[0,k].mean(axis = 0), 'cmax' : conditionmean.max(), 'cmin' : conditionmean.min()}})\n\treturn mndata","def transform(self, data):","def example_data():\n return [\n {'id': 'text', 'title': {'en': 'Text'}, 'type': 'resourcetypes'},\n {'id': 'data', 'title': {'en': 'Data'}, 'type': 'resourcetypes',\n 'tags': ['recommended']},\n ]","def show_data():","def formulate_data(arrdata):\n\n N, K = arrdata.shape\n\n dfdata = pd.DataFrame({\n 'Id' : np.arange(1,N+1).astype('int32'),\n 'age' : arrdata[:,0].astype('float64'),\n 'work_class' : pd.Categorical(arrdata[:,1]),\n 'education' : pd.Categorical(arrdata[:,2]),\n 'number_of_years_of_education' : arrdata[:,3].astype('float64'),\n 'marital_status' : pd.Categorical(arrdata[:,4]),\n 'occupation' : pd.Categorical(arrdata[:,5]),\n 'relationship' : pd.Categorical(arrdata[:,6]),\n 'race' : pd.Categorical(arrdata[:,7]),\n 'sex' : pd.Categorical(arrdata[:,8]),\n 'income_from_investment_sources': arrdata[:,9].astype('float64'),\n 'losses_from_investment_sources': arrdata[:,10].astype('float64'),\n 'working_hours_per_week' : arrdata[:,11].astype('float64'),\n 'native_country' : pd.Categorical(arrdata[:,12])})\n\n # if earn_over_4k_euros_per_year is available (training set)\n if K == 14:\n dfdata['earn_over_4k_euros_per_year'] = \\\n pd.Series(arrdata[:,13].astype('int32'), index=dfdata.index)\n else:\n dfdata['earn_over_4k_euros_per_year'] = \\\n pd.Series((np.ones(N)*(-1)).astype('int32'), index=dfdata.index)\n\n return dfdata","def generate_data(n, data, labels, param, label):\n\n\tmu = param[0]\n\tsigma = param[1]\n\n\tfor i in range(n):\n\n\t\t# TODO: Recall the notation of x in the exercise sheet.\n\t\t# \t\tGenerate a 2-d Gaussian distributed data point plus an offset value for the bias.\n\t\t# \t\tUse our rand_gaussian method.\n\n\t\tx1 = rand_gaussian(mu[0], sigma[0]) \n\t\tx2 = rand_gaussian(mu[1], sigma[1]) \n\n\t\tdata_point = [1, x1, x2]\n\t\tdata.append(data_point)\n\t\tlabels.append(label)\n\n\treturn data,labels","def simple_generator_function(data):\n if data:\n random.shuffle(data)\n\n for data_row in data:\n print \"\\ngenerating data:\"\n guess_data = [data_row[0], data_row[1], data_row[2], data_row[3]]\n iris = copy.deepcopy(DATA_SKELETON)\n iris['data_vector'] = guess_data\n iris['class'] = data_row[4]\n iris['_id'] = str(uuid.uuid4())\n # iris[0]['created'] = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')\n yield iris","def analysisData(train_data, test_data, users_data, products_data):\n\n #\n\n # how many data are\n dataShape(train_data)\n dataShape(test_data)\n dataShape(users_data)\n dataShape(products_data)\n\n \"\"\" CSV shape \n Train: 416147\n Test: 46239\n Usuario: 68819\n Producto: 309961\n \"\"\"\n\n # Users, products and tag are unique:\n removeDuplicated(train_data) # obtenemos: tag_id column of your data is not duplicated\n removeDuplicated(users_data) # obtenemos: user_id column of your data is not duplicated\n removeDuplicated(products_data) #\n\n # Null values\n checkNulls(train_data, remove= False) # No null values\n checkNulls(users_data, remove= False) # No null values\n checkNulls(products_data, remove= False) # product_info: 443 null values and description: 81381 null values\n\n\n # cluck count description\n dataDescription(train_data, 'click_count')\n\n # click count distribution\n countClickIntervals(train_data) # Most of tag id have only 1 click, then 0 clicks\n # It is not possible detecting outliers by the moment\n\n # analize the data tange in users and train\n dateAnalyzing(users_data, train_data)\n\n \"\"\"\n USERS: maxim date:, 2016-01-21 minim date: 2017-06-30 unique dates 522\n TRAIN: maxim date:, 2017-04-23 minim date:: 2017-06-19 unique dates 58\n \n Number of users increases with the time. las few dates i where the number of new users is widely higher \n \"\"\"\n\n # Sample distribution\n g = visualization.plotSns(train_data[['tag_id', 'post_id', 'product_id', 'user_id', 'click_count']], diag_kind=\"kde\", markers='+')\n\n # How many unique users are in the training subset?\n print('The number of unique users are:', len(train_data['user_id'].unique()))\n\n return train_data, test_data, users_data, products_data","def read_item(data: DataModel) -> Dict:\n convertor = Convertor(data)\n return {'output': convertor.get_humanized_data()}","def _format_data(self, data: np.ndarray) -> np.ndarray:\n self._n_circs = 0\n self._n_shots = 0\n self._n_slots = 0\n self._n_iq = 0\n\n # identify shape\n try:\n # level1 single-shot data\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\n except ValueError:\n try:\n # level1 data averaged over shots\n self._n_circs, self._n_slots, self._n_iq = data.shape\n except ValueError as ex:\n raise DataProcessorError(\n f\"Data given to {self.__class__.__name__} is not likely level1 data.\"\n ) from ex\n\n if self._validate:\n if self._n_iq != 2:\n raise DataProcessorError(\n f\"IQ data given to {self.__class__.__name__} does not have two-dimensions \"\n f\"(I and Q). Instead, {self._n_iq} dimensions were found.\"\n )\n\n return data","def gen_analysis_text(num_data, usage_flag, labelled_landmark, landmark_name, error_summary):\n analysis_text = r'<p style=\"color:red;\">Basic information:</p>'\n analysis_text += '<p style=\"color:black;\">Landmark name: {0}.</p>'.format(landmark_name)\n analysis_text += '<p style=\"color:black;\"># cases in total: {0}.</p>'.format(num_data)\n labelled_landmarks_stat = get_landmarks_stat(labelled_landmark)\n \n analysis_text += r'<p style=\"color:black;\"># cases having this landmark (Pos. cases): {0}.</p>'.format(\n len(labelled_landmarks_stat[landmark_name]['pos']))\n analysis_text += r'<p style=\"color:black;\"># cases missing this landmark (Neg. cases): {}.</p>'.format(\n len(labelled_landmarks_stat[landmark_name]['neg']))\n if len(labelled_landmarks_stat[landmark_name]['neg']) > 0:\n missing_cases = copy.deepcopy(labelled_landmarks_stat[landmark_name]['neg'])\n missing_cases.sort()\n analysis_text += r'{}'.format(missing_cases)\n\n if usage_flag == 2:\n tp_cases = error_summary.tp_cases[landmark_name]\n tn_cases = error_summary.tn_cases[landmark_name]\n fp_cases = error_summary.fp_cases[landmark_name]\n fn_cases = error_summary.fn_cases[landmark_name]\n num_pos_cases = len(tp_cases) + len(fn_cases)\n num_neg_cases = len(tn_cases) + len(fp_cases)\n # compute TPR, TNR, FPR, FNR\n TPR = len(tp_cases) / max(1, num_pos_cases) * 100 \\\n if len(tp_cases) != 0 or num_pos_cases != 0 else 100\n TNR = len(tn_cases) / max(1, num_neg_cases) * 100 \\\n if len(tn_cases) != 0 or num_neg_cases != 0 else 100\n FPR = 100 - TNR\n FNR = 100 - TPR\n mean_error = error_summary.mean_error_tp[landmark_name]\n std_error = error_summary.std_error_tp[landmark_name]\n median_error = error_summary.median_error_tp[landmark_name]\n max_error = error_summary.max_error_tp[landmark_name]\n analysis_text += r'<p style=\"color:red;\"> Landmark classification error: </p>'\n analysis_text += r'<p style=\"color:black;\">TP (TPR): {0} ({1:.2f}%)</p>'.format(\n len(tp_cases), TPR)\n analysis_text += r'<p style=\"color:black;\">TN (TNR): {0} ({1:.2f}%)</p>'.format(\n len(tn_cases), TNR)\n analysis_text += r'<p style=\"color:black;\">FP (FPR): {0} ({1:.2f}%)</p>'.format(\n len(fp_cases), FPR)\n analysis_text += r'<p style=\"color:black;\">FN (FNR): {0} ({1:.2f}%)</p>'.format(\n len(fn_cases), FNR)\n analysis_text += r'<p style=\"color:red;\"> Landmark distance error for the {} TP cases (unit: mm): </p>'.format(\n len(tp_cases))\n analysis_text += r'<p style=\"color:black;\">mean (std): {0:.2f} ({1:.2f})</p>'.format(\n mean_error, std_error)\n analysis_text += r'<p style=\"color:black;\">median: {0:.2f}</p>'.format(median_error)\n analysis_text += r'<p style=\"color:black;\">max: {0:.2f}</p>'.format(max_error)\n\n return analysis_text","def preprocess_data(extracted_data: List[Tuple[str, str]]) -> List[str]:\n return [f'__label__{data[0]} {clean_formatting(data[1])}' for data in extracted_data]","def mk_data(self):\n self.data = self.DEFAULTS.copy()\n\n for template in self.raw_data.get('extends', []):\n template_data = self.load_template(template)\n self.data.update(template_data)\n\n self.data.update(self.raw_data)\n\n str_replace(self.data)\n\n if self.data.get('redirect_stderr'):\n self.data.pop('stderr')","def _pack_data( self, data ) : \r\n \r\n # hints = self._translation_table.get( type(data), None )\r\n hints = self._get_hints( data ) \r\n \r\n if hints is None : \r\n \r\n ## #debug: \r\n ## print \"_pack_data(): no hints for data type %s (data repr: %s)\" % (type(data), repr(data))\r\n \r\n # \"one-level recursion\" : \r\n # return self._pack_data( repr(data) )\r\n return self._pack_data( str(data) )\r\n \r\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \r\n ## if data is None: data = 0\r\n \r\n # else ... \r\n \r\n # 'DescType' + 'length' + 'data'\r\n desctype = hints[0]\r\n if desctype == 'TEXT' : \r\n length = len(data)\r\n data_str = data \r\n else :\r\n length = struct.calcsize( hints[1] )\r\n data_str = struct.pack( hints[1], data )\r\n \r\n length_str = struct.pack('=H', length)\r\n \r\n \r\n return _cat(desctype, length_str, data_str)","def __profile_to_table(data):\n output = [[\"condition\", \"mean\", \"min\", \"max\"]]\n order = data[\"order\"]\n\n for o in order:\n try:\n values = data[\"data\"][o]\n output.append(\n [o, str(mean(values)), str(min(values)), str(max(values))]\n )\n except Exception as e:\n print(e)\n\n return \"\\n\".join([\"\\t\".join(l) for l in output])","def _create_Data(classname, typename):\n attributes = {\"typename\": typename}\n if \"complex\" in typename:\n def format_sampler(self, val):\n \"\"\"Format surrounded by [] for the sampler.\n\n 2x space (for real and complex parts).\n \"\"\"\n if isinstance(val, int):\n return \"[%s]\" % (2 * val)\n return val\n attributes[\"format_sampler\"] = format_sampler\n globals()[classname] = type(classname, (Data,), attributes)","def print_data(**kwargs):\n return f'Имя: {kwargs.get(\"name\")}, Фамилия: {kwargs.get(\"surname\")}, Год рождения: {kwargs.get(\"birth_year\")},' \\\n f' Город проживания: {kwargs.get(\"city\")}, Адрес эл. почты: {kwargs.get(\"email\")},' \\\n f' Номер телефона: {kwargs.get(\"phone\")}.'","def _fillData(self, extras):\n e = {k : (\" \".join(v[\"words\"])\n if type(v) == dict and \"words\" in v else v) for k, v in extras.items()}\n return self.data % e","def show_data(self, ):\r\n return print('society_name : {}\\n'\r\n 'flat : {}\\n'\r\n 'house_no : {}\\n'\r\n 'no_of_members : {}\\n'\r\n 'income : {}\\n '\r\n .format(self.society_name, self.flat, self.house_no, self.no_of_members, self.income))","def generate_data(input_file):\n \n mol_mass_list = []\n inchi_list = []\n SMILES_list = []\n identifier_list = []\n inchi_key1_list = [] \n inchi_key2_list = [] \n mol_formula_list = []\n NA_list = []\n \n pre_SMILES_list = []\n identifier_list = []\n all_lines = input_file.split('\\n')\n if all_lines[-1] == '':\n all_lines = all_lines[:-1]\n for line in all_lines:\n line = line.split('\\t')\n\n #Convert to mol and remove invalid structures \n smile_string = ''\n id_string = ''\n m = line[0]\n id_name = line[1]\n mol = Chem.MolFromSmiles(m)\n if mol != None:\n smile_string += m\n id_string += id_name\n pre_SMILES_list += [smile_string]\n \n #Source identifiers\n identifier_list += [id_string]\n \n pre_inchi_list = []\n for smile in pre_SMILES_list:\n #Generate mol\n m = Chem.MolFromSmiles(smile)\n #SMILES, canonical\n sm = Chem.MolToSmiles(m)\n SMILES_list += [sm]\n #Monoisotopic mass\n mol_weigth = Descriptors.ExactMolWt(m)\n mol_mass_list += [mol_weigth]\n #Mol Forumula\n mol_formula = rdMolDescriptors.CalcMolFormula(m)\n mol_formula_list += [mol_formula]\n # InChI \n inchi = rdinchi.MolToInchi(m)\n pre_inchi_list += [inchi[0]] \n \n \n # InChIKey1 and InChIKey2\n for inchi in pre_inchi_list:\n if not str(inchi).startswith('InCh'):\n inchi = 'NA'\n inchi_list += [inchi]\n \n pre_inchi_key_list =[]\n for inchi2 in inchi_list: \n if inchi2 == 'NA':\n inchi_key = \"NA-NA\"\n pre_inchi_key_list += [inchi_key]\n if inchi2 != 'NA':\n inchi_key = rdinchi.InchiToInchiKey(inchi2)\n pre_inchi_key_list += [inchi_key]\n \n for inchi_key in pre_inchi_key_list:\n inchi_key = inchi_key.split('-')\n inchi_key2 = inchi_key[1]\n inchi_key2_list += [inchi_key2]\n inchi_key1 = inchi_key[0]\n inchi_key1_list += [inchi_key1]\n\n # NA list \n nr_of_structures = len(SMILES_list)\n NA_list += ['NA'] * nr_of_structures\n\n overall_list = [mol_mass_list]+[inchi_list]+[SMILES_list]+\\\n [identifier_list]+[inchi_key2_list]+[inchi_key1_list]+[mol_formula_list]+\\\n [NA_list]+[NA_list]+[NA_list]+[NA_list]\n \n return overall_list","def debug_data(\n # fmt: off\n lang: (\"Model language\", \"positional\", None, str),\n train_path: (\"Location of JSON-formatted training data\", \"positional\", None, Path),\n dev_path: (\"Location of JSON-formatted development data\", \"positional\", None, Path),\n tag_map_path: (\"Location of JSON-formatted tag map\", \"option\", \"tm\", Path) = None,\n base_model: (\"Name of model to update (optional)\", \"option\", \"b\", str) = None,\n pipeline: (\"Comma-separated names of pipeline components to train\", \"option\", \"p\", str) = \"tagger,parser,ner\",\n ignore_warnings: (\"Ignore warnings, only show stats and errors\", \"flag\", \"IW\", bool) = False,\n verbose: (\"Print additional information and explanations\", \"flag\", \"V\", bool) = False,\n no_format: (\"Don't pretty-print the results\", \"flag\", \"NF\", bool) = False,\n # fmt: on\n):\n msg = Printer(pretty=not no_format, ignore_warnings=ignore_warnings)\n\n # Make sure all files and paths exists if they are needed\n if not train_path.exists():\n msg.fail(\"Training data not found\", train_path, exits=1)\n if not dev_path.exists():\n msg.fail(\"Development data not found\", dev_path, exits=1)\n\n tag_map = {}\n if tag_map_path is not None:\n tag_map = srsly.read_json(tag_map_path)\n\n # Initialize the model and pipeline\n pipeline = [p.strip() for p in pipeline.split(\",\")]\n if base_model:\n nlp = load_model(base_model)\n else:\n lang_cls = get_lang_class(lang)\n nlp = lang_cls()\n # Update tag map with provided mapping\n nlp.vocab.morphology.tag_map.update(tag_map)\n\n msg.divider(\"Data format validation\")\n\n # TODO: Validate data format using the JSON schema\n # TODO: update once the new format is ready\n # TODO: move validation to GoldCorpus in order to be able to load from dir\n\n # Create the gold corpus to be able to better analyze data\n loading_train_error_message = \"\"\n loading_dev_error_message = \"\"\n with msg.loading(\"Loading corpus...\"):\n corpus = GoldCorpus(train_path, dev_path)\n try:\n train_dataset = list(corpus.train_dataset(nlp))\n train_dataset_unpreprocessed = list(\n corpus.train_dataset_without_preprocessing(nlp)\n )\n except ValueError as e:\n loading_train_error_message = f\"Training data cannot be loaded: {e}\"\n try:\n dev_dataset = list(corpus.dev_dataset(nlp))\n except ValueError as e:\n loading_dev_error_message = f\"Development data cannot be loaded: {e}\"\n if loading_train_error_message or loading_dev_error_message:\n if loading_train_error_message:\n msg.fail(loading_train_error_message)\n if loading_dev_error_message:\n msg.fail(loading_dev_error_message)\n sys.exit(1)\n msg.good(\"Corpus is loadable\")\n\n # Create all gold data here to avoid iterating over the train_dataset constantly\n gold_train_data = _compile_gold(train_dataset, pipeline)\n gold_train_unpreprocessed_data = _compile_gold(\n train_dataset_unpreprocessed, pipeline\n )\n gold_dev_data = _compile_gold(dev_dataset, pipeline)\n\n train_texts = gold_train_data[\"texts\"]\n dev_texts = gold_dev_data[\"texts\"]\n\n msg.divider(\"Training stats\")\n msg.text(f\"Training pipeline: {', '.join(pipeline)}\")\n for pipe in [p for p in pipeline if p not in nlp.factories]:\n msg.fail(f\"Pipeline component '{pipe}' not available in factories\")\n if base_model:\n msg.text(f\"Starting with base model '{base_model}'\")\n else:\n msg.text(f\"Starting with blank model '{lang}'\")\n msg.text(f\"{len(train_dataset)} training docs\")\n msg.text(f\"{len(dev_dataset)} evaluation docs\")\n\n if not len(gold_dev_data):\n msg.fail(\"No evaluation docs\")\n overlap = len(train_texts.intersection(dev_texts))\n if overlap:\n msg.warn(f\"{overlap} training examples also in evaluation data\")\n else:\n msg.good(\"No overlap between training and evaluation data\")\n if not base_model and len(train_dataset) < BLANK_MODEL_THRESHOLD:\n text = (\n f\"Low number of examples to train from a blank model ({len(train_dataset)})\"\n )\n if len(train_dataset) < BLANK_MODEL_MIN_THRESHOLD:\n msg.fail(text)\n else:\n msg.warn(text)\n msg.text(\n f\"It's recommended to use at least {BLANK_MODEL_THRESHOLD} examples \"\n f\"(minimum {BLANK_MODEL_MIN_THRESHOLD})\",\n show=verbose,\n )\n\n msg.divider(\"Vocab & Vectors\")\n n_words = gold_train_data[\"n_words\"]\n msg.info(\n f\"{n_words} total word(s) in the data ({len(gold_train_data['words'])} unique)\"\n )\n if gold_train_data[\"n_misaligned_words\"] > 0:\n n_misaligned = gold_train_data[\"n_misaligned_words\"]\n msg.warn(f\"{n_misaligned} misaligned tokens in the training data\")\n if gold_dev_data[\"n_misaligned_words\"] > 0:\n n_misaligned = gold_dev_data[\"n_misaligned_words\"]\n msg.warn(f\"{n_misaligned} misaligned tokens in the dev data\")\n most_common_words = gold_train_data[\"words\"].most_common(10)\n msg.text(\n f\"10 most common words: {_format_labels(most_common_words, counts=True)}\",\n show=verbose,\n )\n if len(nlp.vocab.vectors):\n msg.info(\n f\"{len(nlp.vocab.vectors)} vectors ({nlp.vocab.vectors.n_keys} \"\n f\"unique keys, {nlp.vocab.vectors_length} dimensions)\"\n )\n else:\n msg.info(\"No word vectors present in the model\")\n\n if \"ner\" in pipeline:\n # Get all unique NER labels present in the data\n labels = set(\n label for label in gold_train_data[\"ner\"] if label not in (\"O\", \"-\", None)\n )\n label_counts = gold_train_data[\"ner\"]\n model_labels = _get_labels_from_model(nlp, \"ner\")\n new_labels = [l for l in labels if l not in model_labels]\n existing_labels = [l for l in labels if l in model_labels]\n has_low_data_warning = False\n has_no_neg_warning = False\n has_ws_ents_error = False\n has_punct_ents_warning = False\n\n msg.divider(\"Named Entity Recognition\")\n msg.info(\n f\"{len(new_labels)} new label(s), {len(existing_labels)} existing label(s)\"\n )\n missing_values = label_counts[\"-\"]\n msg.text(f\"{missing_values} missing value(s) (tokens with '-' label)\")\n for label in new_labels:\n if len(label) == 0:\n msg.fail(\"Empty label found in new labels\")\n if new_labels:\n labels_with_counts = [\n (label, count)\n for label, count in label_counts.most_common()\n if label != \"-\"\n ]\n labels_with_counts = _format_labels(labels_with_counts, counts=True)\n msg.text(f\"New: {labels_with_counts}\", show=verbose)\n if existing_labels:\n msg.text(f\"Existing: {_format_labels(existing_labels)}\", show=verbose)\n if gold_train_data[\"ws_ents\"]:\n msg.fail(f\"{gold_train_data['ws_ents']} invalid whitespace entity spans\")\n has_ws_ents_error = True\n\n if gold_train_data[\"punct_ents\"]:\n msg.warn(f\"{gold_train_data['punct_ents']} entity span(s) with punctuation\")\n has_punct_ents_warning = True\n\n for label in new_labels:\n if label_counts[label] <= NEW_LABEL_THRESHOLD:\n msg.warn(\n f\"Low number of examples for new label '{label}' ({label_counts[label]})\"\n )\n has_low_data_warning = True\n\n with msg.loading(\"Analyzing label distribution...\"):\n neg_docs = _get_examples_without_label(train_dataset, label)\n if neg_docs == 0:\n msg.warn(f\"No examples for texts WITHOUT new label '{label}'\")\n has_no_neg_warning = True\n\n if not has_low_data_warning:\n msg.good(\"Good amount of examples for all labels\")\n if not has_no_neg_warning:\n msg.good(\"Examples without occurrences available for all labels\")\n if not has_ws_ents_error:\n msg.good(\"No entities consisting of or starting/ending with whitespace\")\n if not has_punct_ents_warning:\n msg.good(\"No entities consisting of or starting/ending with punctuation\")\n\n if has_low_data_warning:\n msg.text(\n f\"To train a new entity type, your data should include at \"\n f\"least {NEW_LABEL_THRESHOLD} instances of the new label\",\n show=verbose,\n )\n if has_no_neg_warning:\n msg.text(\n \"Training data should always include examples of entities \"\n \"in context, as well as examples without a given entity \"\n \"type.\",\n show=verbose,\n )\n if has_ws_ents_error:\n msg.text(\n \"As of spaCy v2.1.0, entity spans consisting of or starting/ending \"\n \"with whitespace characters are considered invalid.\"\n )\n\n if has_punct_ents_warning:\n msg.text(\n \"Entity spans consisting of or starting/ending \"\n \"with punctuation can not be trained with a noise level > 0.\"\n )\n\n if \"textcat\" in pipeline:\n msg.divider(\"Text Classification\")\n labels = [label for label in gold_train_data[\"cats\"]]\n model_labels = _get_labels_from_model(nlp, \"textcat\")\n new_labels = [l for l in labels if l not in model_labels]\n existing_labels = [l for l in labels if l in model_labels]\n msg.info(\n f\"Text Classification: {len(new_labels)} new label(s), \"\n f\"{len(existing_labels)} existing label(s)\"\n )\n if new_labels:\n labels_with_counts = _format_labels(\n gold_train_data[\"cats\"].most_common(), counts=True\n )\n msg.text(f\"New: {labels_with_counts}\", show=verbose)\n if existing_labels:\n msg.text(f\"Existing: {_format_labels(existing_labels)}\", show=verbose)\n if set(gold_train_data[\"cats\"]) != set(gold_dev_data[\"cats\"]):\n msg.fail(\n f\"The train and dev labels are not the same. \"\n f\"Train labels: {_format_labels(gold_train_data['cats'])}. \"\n f\"Dev labels: {_format_labels(gold_dev_data['cats'])}.\"\n )\n if gold_train_data[\"n_cats_multilabel\"] > 0:\n msg.info(\n \"The train data contains instances without \"\n \"mutually-exclusive classes. Use '--textcat-multilabel' \"\n \"when training.\"\n )\n if gold_dev_data[\"n_cats_multilabel\"] == 0:\n msg.warn(\n \"Potential train/dev mismatch: the train data contains \"\n \"instances without mutually-exclusive classes while the \"\n \"dev data does not.\"\n )\n else:\n msg.info(\n \"The train data contains only instances with \"\n \"mutually-exclusive classes.\"\n )\n if gold_dev_data[\"n_cats_multilabel\"] > 0:\n msg.fail(\n \"Train/dev mismatch: the dev data contains instances \"\n \"without mutually-exclusive classes while the train data \"\n \"contains only instances with mutually-exclusive classes.\"\n )\n\n if \"tagger\" in pipeline:\n msg.divider(\"Part-of-speech Tagging\")\n labels = [label for label in gold_train_data[\"tags\"]]\n tag_map = nlp.vocab.morphology.tag_map\n msg.info(f\"{len(labels)} label(s) in data ({len(tag_map)} label(s) in tag map)\")\n labels_with_counts = _format_labels(\n gold_train_data[\"tags\"].most_common(), counts=True\n )\n msg.text(labels_with_counts, show=verbose)\n non_tagmap = [l for l in labels if l not in tag_map]\n if not non_tagmap:\n msg.good(f\"All labels present in tag map for language '{nlp.lang}'\")\n for label in non_tagmap:\n msg.fail(f\"Label '{label}' not found in tag map for language '{nlp.lang}'\")\n\n if \"parser\" in pipeline:\n has_low_data_warning = False\n msg.divider(\"Dependency Parsing\")\n\n # profile sentence length\n msg.info(\n f\"Found {gold_train_data['n_sents']} sentence(s) with an average \"\n f\"length of {gold_train_data['n_words'] / gold_train_data['n_sents']:.1f} words.\"\n )\n\n # check for documents with multiple sentences\n sents_per_doc = gold_train_data[\"n_sents\"] / len(gold_train_data[\"texts\"])\n if sents_per_doc < 1.1:\n msg.warn(\n f\"The training data contains {sents_per_doc:.2f} sentences per \"\n f\"document. When there are very few documents containing more \"\n f\"than one sentence, the parser will not learn how to segment \"\n f\"longer texts into sentences.\"\n )\n\n # profile labels\n labels_train = [label for label in gold_train_data[\"deps\"]]\n labels_train_unpreprocessed = [\n label for label in gold_train_unpreprocessed_data[\"deps\"]\n ]\n labels_dev = [label for label in gold_dev_data[\"deps\"]]\n\n if gold_train_unpreprocessed_data[\"n_nonproj\"] > 0:\n n_nonproj = gold_train_unpreprocessed_data[\"n_nonproj\"]\n msg.info(f\"Found {n_nonproj} nonprojective train sentence(s)\")\n if gold_dev_data[\"n_nonproj\"] > 0:\n n_nonproj = gold_dev_data[\"n_nonproj\"]\n msg.info(f\"Found {n_nonproj} nonprojective dev sentence(s)\")\n msg.info(f\"{labels_train_unpreprocessed} label(s) in train data\")\n msg.info(f\"{len(labels_train)} label(s) in projectivized train data\")\n labels_with_counts = _format_labels(\n gold_train_unpreprocessed_data[\"deps\"].most_common(), counts=True\n )\n msg.text(labels_with_counts, show=verbose)\n\n # rare labels in train\n for label in gold_train_unpreprocessed_data[\"deps\"]:\n if gold_train_unpreprocessed_data[\"deps\"][label] <= DEP_LABEL_THRESHOLD:\n msg.warn(\n f\"Low number of examples for label '{label}' \"\n f\"({gold_train_unpreprocessed_data['deps'][label]})\"\n )\n has_low_data_warning = True\n\n # rare labels in projectivized train\n rare_projectivized_labels = []\n for label in gold_train_data[\"deps\"]:\n if gold_train_data[\"deps\"][label] <= DEP_LABEL_THRESHOLD and \"||\" in label:\n rare_projectivized_labels.append(\n f\"{label}: {gold_train_data['deps'][label]}\"\n )\n\n if len(rare_projectivized_labels) > 0:\n msg.warn(\n f\"Low number of examples for {len(rare_projectivized_labels)} \"\n \"label(s) in the projectivized dependency trees used for \"\n \"training. You may want to projectivize labels such as punct \"\n \"before training in order to improve parser performance.\"\n )\n msg.warn(\n f\"Projectivized labels with low numbers of examples: \",\n \", \".join(rare_projectivized_labels),\n show=verbose,\n )\n has_low_data_warning = True\n\n # labels only in train\n if set(labels_train) - set(labels_dev):\n msg.warn(\n \"The following labels were found only in the train data:\",\n \", \".join(set(labels_train) - set(labels_dev)),\n show=verbose,\n )\n\n # labels only in dev\n if set(labels_dev) - set(labels_train):\n msg.warn(\n \"The following labels were found only in the dev data:\",\n \", \".join(set(labels_dev) - set(labels_train)),\n show=verbose,\n )\n\n if has_low_data_warning:\n msg.text(\n f\"To train a parser, your data should include at \"\n f\"least {DEP_LABEL_THRESHOLD} instances of each label.\",\n show=verbose,\n )\n\n # multiple root labels\n if len(gold_train_unpreprocessed_data[\"roots\"]) > 1:\n msg.warn(\n f\"Multiple root labels \"\n f\"({', '.join(gold_train_unpreprocessed_data['roots'])}) \"\n f\"found in training data. spaCy's parser uses a single root \"\n f\"label ROOT so this distinction will not be available.\"\n )\n\n # these should not happen, but just in case\n if gold_train_data[\"n_nonproj\"] > 0:\n msg.fail(\n f\"Found {gold_train_data['n_nonproj']} nonprojective \"\n f\"projectivized train sentence(s)\"\n )\n if gold_train_data[\"n_cycles\"] > 0:\n msg.fail(\n f\"Found {gold_train_data['n_cycles']} projectivized train sentence(s) with cycles\"\n )\n\n msg.divider(\"Summary\")\n good_counts = msg.counts[MESSAGES.GOOD]\n warn_counts = msg.counts[MESSAGES.WARN]\n fail_counts = msg.counts[MESSAGES.FAIL]\n if good_counts:\n msg.good(f\"{good_counts} {'check' if good_counts == 1 else 'checks'} passed\")\n if warn_counts:\n msg.warn(f\"{warn_counts} {'warning' if warn_counts == 1 else 'warnings'}\")\n if fail_counts:\n msg.fail(f\"{fail_counts} {'error' if fail_counts == 1 else 'errors'}\")\n sys.exit(1)","def featurize(\n self, data: List[Dict[str, Any]]\n ) -> Generator[Dict[str, Any], None, None]:\n raise NotImplementedError","def data(self):\n # Regenerate the extra data\n if self._req_update_fill:\n self._generate_fill()\n if self._req_update_variation:\n self._generate_variations()\n\n output = self._data_words\n\n # Add variations\n where = np.where(output == '')\n output[where] = self._data_variations[where]\n\n # Add fill\n where = np.where(output == '')\n output[where] = self._data_fill.reshape(self.shape)[where]\n\n return output","def preprocess_data(data):\n def deal_line(line):\n pos, rating = line.split(',')\n row, col = pos.split(\"_\")\n row = row.replace(\"r\", \"\")\n col = col.replace(\"c\", \"\")\n return int(row), int(col), float(rating)\n\n def statistics(data):\n row = set([line[0] for line in data])\n col = set([line[1] for line in data])\n return min(row), max(row), min(col), max(col)\n\n # parse each line\n data = [deal_line(line) for line in data]\n\n # do statistics on the dataset.\n min_row, max_row, min_col, max_col = statistics(data)\n print(\"number of items: {}, number of users: {}\".format(max_row, max_col))\n\n # build rating matrix.\n ratings = sp.lil_matrix((max_row, max_col))\n for row, col, rating in data:\n ratings[row - 1, col - 1] = rating\n return ratings","def inf(self, data):\n self.set_data(data)\n self.infer_post_and_update_samples()","def understand_the_data(self,dataset):\n shape = dataset.shape\n description = dataset.describe\n print(shape)\n print(description)","def create_data(self) -> str:\r\n s = self.scale\r\n mini, maxi = self.get_min_max()\r\n diff = maxi - mini\r\n\r\n output = \"const data = {\\n\"\r\n\r\n # Create the data for the scatters\r\n # TODO: If it's not interactive, labels shouldn't be exported.\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n colormaps = self.scatters[name][\"colormap\"]\r\n cmaps = [None] * len(colormaps)\r\n\r\n for i, colormap in enumerate(colormaps):\r\n if isinstance(colormap, str):\r\n cmaps[i] = plt.cm.get_cmap(colormap)\r\n else:\r\n cmaps[i] = colormap\r\n\r\n output += name + \": {\\n\"\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\"x\"]]]\r\n output += \"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\"y\"]]]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\"z\"]]]\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n\r\n if mapping[\"labels\"] in data:\r\n fmt_labels = [\"'{0}'\".format(s) for s in data[mapping[\"labels\"]]]\r\n output += \"labels: [\" + \",\".join(fmt_labels) + \"],\\n\"\r\n\r\n if mapping[\"s\"] in data:\r\n output += \"s: [\"\r\n\r\n for series in range(len(data[mapping[\"s\"]])):\r\n output += (\r\n \"[\"\r\n + \",\".join(map(str, np.round(data[mapping[\"s\"]][series], 3)))\r\n + \"],\\n\"\r\n )\r\n\r\n output += \"],\\n\"\r\n\r\n output += \"colors: [\\n\"\r\n for series in range(len(data[mapping[\"c\"]])):\r\n output += \"{\\n\"\r\n if mapping[\"cs\"] in data:\r\n colors = np.array(\r\n [cmaps[series](x) for x in data[mapping[\"c\"]][series]]\r\n )\r\n\r\n for i, c in enumerate(colors):\r\n hsl = np.array(colour.rgb2hsl(c[:3]))\r\n hsl[1] = hsl[1] - hsl[1] * data[mapping[\"cs\"]][series][i]\r\n colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)\r\n\r\n colors = np.round(colors * 255.0)\r\n\r\n output += (\r\n \"r: [\" + \",\".join(map(str, map(int, colors[:, 0]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"g: [\" + \",\".join(map(str, map(int, colors[:, 1]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"b: [\" + \",\".join(map(str, map(int, colors[:, 2]))) + \"],\\n\"\r\n )\r\n elif mapping[\"c\"] in data:\r\n colors = np.array(\r\n [cmaps[series](x) for x in data[mapping[\"c\"]][series]]\r\n )\r\n colors = np.round(colors * 255.0)\r\n output += (\r\n \"r: [\" + \",\".join(map(str, map(int, colors[:, 0]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"g: [\" + \",\".join(map(str, map(int, colors[:, 1]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"b: [\" + \",\".join(map(str, map(int, colors[:, 2]))) + \"],\\n\"\r\n )\r\n output += \"},\\n\"\r\n\r\n output += \"]\"\r\n output += \"},\\n\"\r\n\r\n for name, data in self.trees_data.items():\r\n mapping = self.trees[name][\"mapping\"]\r\n point_helper = self.trees[name][\"point_helper\"]\r\n\r\n output += name + \": {\\n\"\r\n\r\n if point_helper is not None and point_helper in self.scatters_data:\r\n scatter = self.scatters_data[point_helper]\r\n scatter_mapping = self.scatters[point_helper][\"mapping\"]\r\n\r\n x_t = []\r\n y_t = []\r\n z_t = []\r\n\r\n for i in range(len(data[mapping[\"from\"]])):\r\n x_t.append(scatter[scatter_mapping[\"x\"]][data[mapping[\"from\"]][i]])\r\n x_t.append(scatter[scatter_mapping[\"x\"]][data[mapping[\"to\"]][i]])\r\n y_t.append(scatter[scatter_mapping[\"y\"]][data[mapping[\"from\"]][i]])\r\n y_t.append(scatter[scatter_mapping[\"y\"]][data[mapping[\"to\"]][i]])\r\n z_t.append(scatter[scatter_mapping[\"z\"]][data[mapping[\"from\"]][i]])\r\n z_t.append(scatter[scatter_mapping[\"z\"]][data[mapping[\"to\"]][i]])\r\n\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in x_t]\r\n output += f\"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in y_t]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in z_t]\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n else:\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\"x\"]]]\r\n output += \"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\"y\"]]]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\"z\"]]]\r\n\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n\r\n if mapping[\"c\"] in data:\r\n colormap = self.trees[name][\"colormap\"]\r\n cmap = None\r\n if isinstance(colormap, str):\r\n cmap = plt.cm.get_cmap(colormap)\r\n else:\r\n cmap = colormap\r\n\r\n colors = np.array([cmap(x) for x in data[mapping[\"c\"]]])\r\n colors = np.round(colors * 255.0)\r\n output += \"r: [\" + \",\".join(map(str, colors[:, 0])) + \"],\\n\"\r\n output += \"g: [\" + \",\".join(map(str, colors[:, 1])) + \"],\\n\"\r\n output += \"b: [\" + \",\".join(map(str, colors[:, 2])) + \"],\\n\"\r\n\r\n output += \"},\\n\"\r\n\r\n output += \"};\\n\"\r\n\r\n return output","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","def build_data(self):\n from desiutil.io import combine_dicts\n # Loop on exposures\n odict = {}\n for qanight in self.qa_nights:\n for qaexp in qanight.qa_exps:\n # Get the exposure dict\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\n odict = combine_dicts(odict, idict)\n # Finish\n self.data = odict","def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\n data.gatherData(neat.pop, neat.species)\n\n if savePop is True: # Get a sample pop to play with in notebooks\n global fileName\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\n import pickle\n with open(pref+'.obj', 'wb') as fp:\n pickle.dump(neat.pop,fp)\n\n return data","def make_multi_output_data(self, data):\n confirmed, deceased, recovered = [], [], []\n for sample in data:\n confirmed.append(sample[:,0])\n deceased.append(sample[:,1])\n recovered.append(sample[:,2])\n confirmed = np.stack(confirmed)\n deceased = np.stack(deceased)\n recovered = np.stack(recovered)\n return np.stack([confirmed, deceased, recovered])","def get_info(data_list):\n info = [{TEST_SAMPLE: data_elem[TEST_SAMPLE], CONTROL_SAMPLE: data_elem[CONTROL_SAMPLE],\n N_UP: len(data_elem[REG_UP].index), N_DOWN: len(data_elem[REG_DOWN].index)} for data_elem in data_list]","def verbose_data(which_set, data, label):\n text = ['{} size: {}'.format(which_set, data.shape[0])]\n for i in range(label.max() + 1):\n text.append('class{}-{}'.format(i, len(np.where(label == i)[0])))\n text.append('\\n')\n text = ' '.join(text)\n tf.logging.info(text)","def __generate_input_data(self):\n if not len(self.input_data) == 0:\n return\n\n try:\n self.input_data = s.load(open('output/input_data.p', 'rb'))\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n except:\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\n if not self.classes_to_visualise == None:\n self.__filter_input_data(self.classes_to_visualise)\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\n\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))","def _gather_data(self):\n for data in self._collection:\n label = data.label\n label = disambiguate(label, self._data)\n self._data[label] = data","def get_data(self, data):\n self.data = {}\n self.data[ATTR_PM1] = data['current']['values'][0]['value']\n self.data[ATTR_PM25] = data['current']['values'][1]['value']\n self.data[ATTR_PM25_LIMIT] = data['current']['standards'][0]['limit']\n self.data[ATTR_PM25_PERCENT] = (data['current']['standards'][0]\n ['percent'])\n self.data[ATTR_PM10] = data['current']['values'][2]['value']\n self.data[ATTR_PM10_LIMIT] = data['current']['standards'][1]['limit']\n self.data[ATTR_PM10_PERCENT] = (data['current']['standards'][1]\n ['percent'])\n self.data[ATTR_PRESSURE] = data['current']['values'][3]['value']\n self.data[ATTR_HUMIDITY] = data['current']['values'][4]['value']\n self.data[ATTR_TEMPERATURE] = data['current']['values'][5]['value']\n self.data[ATTR_CAQI] = data['current']['indexes'][0]['value']\n self.data[ATTR_CAQI_LEVEL] = (data['current']['indexes'][0]\n ['level'].lower().replace('_', ' '))","def build(self, data: dict):","def pack(data):\r\n data['length'] = [len(text) for text in data['text']] \r\n data['longest_word_len'] = [longest_word_len(text) for text in data['text']] \r\n data['mean_word_len'] = [mean_word_len(text) for text in data['text']] \r\n data['subject_len'] = [len(subject) for subject in data['subject']]\r\n data['stop_words_num'] = [stop_words_count(text) for text in data['text']]\r\n data['pounctuation_num'] = [punctuation_count(text) for text in data['text']]\r\n data['text'] = [clean_text(text) for text in data['text']]","def test_data_preprocessing(raw_data): \r\n\r\n # get data output\r\n data_output = raw_data[['Submitby Date Time', 'Challenge Manager', 'Challenge Copilot', 'Posting Date Date', 'Track',\r\n 'Technology List', 'First Place Prize', 'Num Registrations', 'Total Prize']]\r\n with open('cache/extended_columns.pkl', 'rb') as f:\r\n extended_columns = pickle.load(f)\r\n with open('cache/num_date_columns.pkl', 'rb') as f:\r\n max_date_columns = pickle.load(f)\r\n \r\n data_output = class_binaryzation_for_test(data_output, extended_columns)\r\n try:\r\n data_output = date_separation1(data_output, max_num_columns=NUM_DATE_COLUMNS)\r\n except:\r\n data_output = date_separation2(data_output)\r\n data_output = money_digitalization(data_output)\r\n data_output = get_date_in_days(data_output)\r\n data_output['Days from Posting to Submit'] = data_output['Submitby Date Time Days from 2016'] \\\r\n - data_output['Posting Date Date Days from 2016'] \r\n\r\n return data_output","def data_details_return(data, data_set):\r\n data.update(data_resources[data_set])\r\n return data","def format(self, data):\r\n for name, value in sorted(data.items()):\r\n line = '{name} = {value}\\n'.format(\r\n name=name,\r\n value=value,\r\n )\r\n yield line","def _format_data(self) -> None:\n for row in self._db_data:\n if row['age_start'] is None:\n continue\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\n elif row['age_start'] == 95:\n entry = {'x': f\"{int(row['age_start'])}+\", 'y': int(row['count'])}\n else:\n entry = {'x': f\"{int(row['age_start'])}-{int(row['age_start'])+4}\", 'y': int(row['count'])}\n self.return_data['data'].append(entry)","def featurize(data):\n features = {}\n missing_weight = False\n for fieldname in STATIC_FIELDS:\n # Static fields use -1 to denote that the value was not measured.\n if data[fieldname][0][1] == -1:\n features[fieldname] = NAN_REPLACE\n else:\n features[fieldname] = float(data[fieldname][0][1])\n for fieldname in FIELDS:\n # Time-series fields may or may not be measured, but if they are present\n # in the dataset, then the value will be valid (i.e. nonnegative).\n if fieldname in data:\n values = [float(d[1]) for d in data[fieldname]]\n if -1 in values and fieldname == 'Weight':\n # Record that weight was missing for this record id.\n missing_weight = True\n field_features = set_features_to_nan(fieldname)\n else:\n field_features = {}\n field_features['{}_min'.format(fieldname)] = min(values)\n field_features['{}_max'.format(fieldname)] = max(values)\n field_features['{}_mean'.format(fieldname)] = np.mean(values)\n field_features['{}_first'.format(fieldname)] = values[0]\n field_features['{}_last'.format(fieldname)] = values[-1]\n field_features['{}_diff'.format(fieldname)] = values[-1] - values[0]\n else:\n field_features = set_features_to_nan(fieldname)\n features.update(field_features)\n return features, missing_weight","def test_data():\n return [Donor(\"David Andrews\", [200.50, 400.00, 250.75]),\n Donor(\"John Goodfellow\", [25.00, 175.50]),\n Donor(\"Mary Suzuki\", [75.00, 125.00, 250.00]),\n Donor(\"Bonney Lake\", [500.50, 700.75, 500.25]),\n Donor(\"DeMarcus Rollins\", [155.00, 165.00])\n ]","def package_data(self, data):\n pass","def genbasictestdata():\n\t# These are the different test values we will combine in various ways.\n\tarraycode = [('typecode', x) for x in ('bytes', 'bytearray')]\n\thassimd = (('simdpresent', 'with'), ('simdpresent', 'without'))\n\tarraylen = (('arrayevenodd', 'even'), ('arrayevenodd', 'odd'))\n\ttestdata = (('testdataset', 0), ('testdataset', 1), ('testdataset', 2))\n\n\t# The product function produces all possible combinations.\n\tcombos = list(itertools.product(arraycode, hassimd, arraylen, testdata))\n\n\n\t# Convert the data into a list of dictionaries.\n\ttestdata = [dict(x) for x in combos]\n\n\tnosimd = {'with' : '', 'without' : ', nosimd=True'}\n\n\t# Now go through the list and add data which goes with the ones we have already defined.\n\tfor x in testdata:\n\t\tx['typelabel'] = x['typecode']\n\t\tx['nosimd'] = nosimd[x['simdpresent']]\n\n\t\tx['tval1'] = testdatasets[x['testdataset']][0]\n\t\tx['tval2'] = testdatasets[x['testdataset']][1]\n\t\tx['tval3'] = testdatasets[x['testdataset']][2]\n\t\tx['tval4'] = testdatasets[x['testdataset']][3]\n\n\treturn testdata","def __init__(self, data_array, cui2name):\n\t\tassert isinstance(data_array, xr.DataArray), 'Constructor requires xr.DataArray.'\n\n\t\tself.data_array = data_array\n\t\tself.data = self.data_array.values\n\t\tself.sources = self.data_array.source.values\n\t\tself.targets = self.data_array.target.values\n\t\tself.metrics = self.data_array.metric.values\n\t\tself.metapaths = self.data_array.metapath.values\n\n\t\t# Fetch the verbose names\n\t\t#int_rf_df = pd.read_csv('data/impd_cogn_sources.tsv', delimiter='\\t')\n\t\t#cui2name = {cui:name for cui, name in zip(int_rf_df.identifier, int_rf_df.name)} \n\t\tself.source_names = np.array([cui2name[source] for source in self.sources])","def __str__(self):\r\n return f\"OPA of {self.data}\"","def create_data_bunch(data, test=False):\r\n examples = [t[0] for t in data if t[0]]\r\n target = np.zeros((len(data),), dtype=np.int64)\r\n if not test:\r\n for i, tweet in enumerate(data):\r\n if tweet[1] == 'OFF':\r\n target[i] = 1\r\n elif tweet[1] == 'NOT':\r\n target[i] = 0\r\n dataset = Bunch(data=examples, target=target, target_names=['NOT', 'OFF'])\r\n return dataset","def print_data(self):\n for chain, gen in self.generations.items():\n print('Generations for chain %s: %d' % (chain, gen))\n print('Log likelihood effective size: %d' % self.loglik_effsize)\n print('Log likelihood relative difference: %f' % self.loglik_rel_diff)\n print('Max diff: %f' % self.max_diff)","def overview(data):\n\n printer.table(['Name', 'El', 'Invariom name', 'Model compound'], head=True)\n for atom in data.iter_atoms(True):\n printer.table([atom.name, atom.element, atom.invariom_name, atom.invariom.molecule.name])\n printer.table(done=True)","def format_data(arr, dimen, data_type):\n\tif type(dimen) != tuple:\n\t\tprint(\"Error: expected tuple type.\")\n\t\treturn None\n\tfactor = int(dimen[1] / dimen[0])\n\treturn {\n\t\t\"train\": [np.reshape(row, dimen) for row in arr],\n\t\t\"test\": [np.hsplit(row, factor) for row in arr]\n\t}.get(data_type)","def gen_data(self):\n\n # 1，read the source text\n inputs, labels = self.read_data()\n print(\"read finished\")\n\n # 2. word label index\n word_to_index, label_to_index = self.gen_word_label_index()\n # print(\"word_to_index\",word_to_index)\n # print(\"label_to_index\",label_to_index)\n print(\"vocab process finished\")\n #\n # 3，input to index\n inputs_idx = self.trans_to_index(inputs, word_to_index)\n # print((inputs_idx))\n print(\"index transform finished\")\n #\n # 4, padding\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\n # print(inputs_idx)\n print(\"padding finished\")\n\n # 6，label to index\n labels_idx = self.trans_label_to_index(labels, label_to_index)\n print(\"label index transform finished\")\n\n return np.array(inputs_idx), np.array(labels_idx)","def olympic_sprints(data_set='rogers_girolami_data'):\r\n X = np.zeros((0, 2))\r\n Y = np.zeros((0, 1))\r\n for i, dataset in enumerate([olympic_100m_men,\r\n olympic_100m_women,\r\n olympic_200m_men,\r\n olympic_200m_women,\r\n olympic_400m_men,\r\n olympic_400m_women]):\r\n data = dataset()\r\n year = data['X']\r\n time = data['Y']\r\n X = np.vstack((X, np.hstack((year, np.ones_like(year)*i))))\r\n Y = np.vstack((Y, time))\r\n data['X'] = X\r\n data['Y'] = Y\r\n data['info'] = \"Olympics sprint event winning for men and women to 2008. Data is from Rogers and Girolami's First Course in Machine Learning.\"\r\n return data_details_return({\r\n 'X': X,\r\n 'Y': Y,\r\n 'info': \"Olympics sprint event winning for men and women to 2008. Data is from Rogers and Girolami's First Course in Machine Learning.\",\r\n 'output_info': {\r\n 0:'100m Men',\r\n 1:'100m Women',\r\n 2:'200m Men',\r\n 3:'200m Women',\r\n 4:'400m Men',\r\n 5:'400m Women'}\r\n }, data_set)","def build_data(self):\n return self.mean, self.sigma","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def test_dataset_autogen(autogen_dataset):\n train_dummy = \"eget, venenatis a, magna. Lorem ipsum dolor sit amet, consectetuer\"\n val_dummy = \"leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis,\"\n test_dummy = \"turpis egestas. Aliquam fringilla cursus purus. Nullam scelerisque neque sed\"\n\n assert autogen_dataset.train[0][0] == train_dummy\n assert autogen_dataset.train[0][1] == '8'\n assert len(autogen_dataset.train) == 64\n\n assert autogen_dataset.val[0][0] == val_dummy\n assert autogen_dataset.val[0][1] == '1'\n assert len(autogen_dataset.val) == 16\n\n assert autogen_dataset.test[0][0] == test_dummy\n assert autogen_dataset.test[0][1] == '6'\n assert len(autogen_dataset.test) == 20","def gendata(varname, vardict, avardict, alldatastatements):\n \n # parameters: varnamein, varnameout, unitcategory, source\n datatemplate = \"\"\"DATA: %(varnameout)s = col(source(%(source)s), name(\"%(varnamein)s\") %(unitcategory)s)\"\"\"\n \n if not varname:\n return \"\"\n varnamelc = varname.lower()\n if varnamelc in alldatastatements:\n return \"\"\n alldatastatements.add(varnamelc)\n \n if vardict[varname].VariableLevel in ['nominal','ordinal']:\n unitcategory = iscat\n else:\n unitcategory = \"\"\n varnameout = avardict.getAName(varname)\n dtc = []\n dtc.append(datatemplate % {'varnamein': varname, \"varnameout\": varname, \n \"unitcategory\": unitcategory, \"source\" : \"s\"})\n dtc.append(datatemplate % {'varnamein': varname, \"varnameout\": varnameout, \n \"unitcategory\": unitcategory, \"source\" : \"t\"})\n return dtc","def generate_synthetic_matrix_factorization_data(xdim=6, ydim=10, nsamples=1000, A_condition_number=1e-10):\n Atrue = np.linspace(1, A_condition_number, ydim\n ).reshape(-1, 1) * np.random.rand(ydim, xdim)\n # the inputs\n X = np.random.randn(xdim, nsamples)\n # the y's to fit\n Ytrue = Atrue.dot(X)\n data = (X.T, Ytrue.T)\n\n return data","def dataConversion(data, I, attr, Na, noise, alpha, R=True):\n n = data.shape[0]\n m = data.shape[1]\n\n data_dict = {}\n structure = []\n # Transform the data to a dictionary and get the data structure\n for j in range(m):\n temp_data = data[:, j].reshape(-1, 1)\n enc = preprocessing.OneHotEncoder(categories='auto')\n enc.fit(temp_data)\n data_dict[j] = enc.transform(temp_data).toarray()\n structure.append(len(set(data[:, j])))\n\n x = np.rint(I * n).astype(int)\n # The indices of the records to which noise will be added\n row_inds = np.random.choice(range(n), x, replace=False)\n # For each corrupted observation:\n for i in row_inds:\n if R:\n attr_inds = np.random.choice(m, size=Na, replace=False)\n else:\n # Specify the attributes to which noise will be added\n attr_inds = attr\n # For each specified attribute\n for j in attr_inds:\n # Divide 'noise' over all the columns belonging to that attribute\n noise_individuals = np.random.dirichlet(np.ones(structure[j] - 1) * alpha, size=1) * noise\n t = 0\n for k in range(structure[j]):\n if data_dict[j][i, k] == 0 and t < noise_individuals.shape[1]:\n data_dict[j][i, k] = noise_individuals[0][t]\n t += 1\n elif data_dict[j][i, k] == 1:\n data_dict[j][i, k] -= noise\n new_data = np.concatenate([data_dict[k] for k in data_dict.keys()], axis=1)\n\n # One-hot encoding GT:\n enc = OneHotEncoder(categories='auto')\n enc.fit(data)\n GT = enc.transform(data).toarray()\n\n return GT, new_data, structure, row_inds","def generate_basic_report(self, from_time, to_time, raw_data):\n\n\t\t# Transform the raw data into something more reporting friendly\n\t\tstructured_data = self.build_data_structure(from_time, to_time, raw_data)\n\n\t\t# Now build the report from the structured data.\n\t\treport = []\n\t\tfor key, value in structured_data.items():\n\t\t\treport.append([key, len(value), len(set(value))])\n\n\t\t# Return the actual report data for further processing.\n\t\treturn report","def __init__(self, data):\n\n self.produce_csv = data['produce_csv']\n self.produce_graphics = data['produce_graphics']\n self.report_name = data['report_name']\n self.file_name = self.report_name + '.csv'\n self.annual_file_name = self.report_name + '_annual.csv'\n self.csv_dir = ''\n self.diagnostic_dir = ''\n\n self.daily_variables = {\n 'year': ['time.cal_year', '', []],\n 'j_day': ['time.day', '', []]\n }\n\n self.annual_variables = {\n 'year': ['time.cal_year', '', 0]\n }","def process_data(self, data):\n\n for feat, vals in zip(data.names, data.feats):\n for val in vals:\n self.fvals[feat][val][1] = Literal(feature=feat, value=val)","def _format_nom_ins(col: str, data: Dict[str, Any], nrows: int, cfg: Config) -> Any:\n # list of insights\n ins: List[Dict[str, str]] = []\n\n if data[\"chisq\"][1] > cfg.insight.uniform__threshold:\n ins.append({\"Uniform\": f\"/*start*/{col}/*end*/ is uniformly distributed\"})\n\n pmiss = round((1 - (data[\"npres\"] / nrows)) * 100, 2)\n if pmiss > cfg.insight.missing__threshold:\n nmiss = nrows - data[\"npres\"]\n ins.append({\"Missing\": f\"/*start*/{col}/*end*/ has {nmiss} ({pmiss}%) missing values\"})\n\n if data[\"nuniq\"] > cfg.insight.high_cardinality__threshold:\n uniq = data[\"nuniq\"]\n msg = f\"/*start*/{col}/*end*/ has a high cardinality: {uniq} distinct values\"\n ins.append({\"High Cardinality\": msg})\n\n if data[\"nuniq\"] == cfg.insight.constant__threshold:\n val = data[\"bar\"].index[0]\n ins.append({\"Constant\": f'/*start*/{col}/*end*/ has constant value \"{val}\"'})\n\n if data[\"min_len\"] == data[\"max_len\"]:\n length = data[\"min_len\"]\n ins.append({\"Constant Length\": f\"/*start*/{col}/*end*/ has constant length {length}\"})\n\n if data[\"nuniq\"] == data[\"npres\"]:\n ins.append({\"Unique\": f\"/*start*/{col}/*end*/ has all distinct values\"})\n\n # list of insight messages\n ins_msg_list = [list(ins.values())[0] for ins in ins]\n\n return ins_msg_list, ins","def print_data(data):\n print(str(data))\n return data","def setSampleInfo(self, data: list):\n repSampleInfo = [\n ['イベント', data[0]],\n ['シリアル', data[1]],\n ]\n self._sample_info = repSampleInfo","def extract(self, data):","def format_input_data(positive_data: List[str], negative_data: list) -> Tuple[List[Tuple[str, int]],\n List[Tuple[str, int]]]:\n # 1 = positive, 0 = negative\n positive_input_data = []\n negative_input_data = []\n\n for sentence_data in positive_data:\n positive_input_data.append((sentence_data, 1))\n\n for sentence_data in negative_data:\n negative_input_data.append((sentence_data, 0))\n\n return positive_input_data, negative_input_data"],"string":"[\n \"def show_data(sim_attr_generator):\\n#TODO description\\n if Args.data_to_show == 'dprime':\\n show_dprime(sim_attr_generator)\",\n \"def generate_ta(data):\\n raise NotImplementedError\",\n \"def format_data(self, data):\",\n \"def _construct(self, data):\\n logging.info(\\\"overall constructing (enter)\\\")\\n\\n pre_construct_data = self._pre_construct(data)\\n # Kickstart the seralizin'.\\n\\n #if it found no ids, then we can just use the pre construct data\\n if any((len(ids) > 0 for label, ids in self.ids.iteritems())):\\n self.data = collections.defaultdict(dict)\\n\\n\\n for manip in self.manips:\\n manip()\\n\\n logging.debug(\\\"constructing (enter)\\\")\\n # extend the output using the collated data we've found\\n data = self.construct(data)\\n logging.debug(\\\"constructing (exit)\\\")\\n\\n logging.debug(\\\"overall constructing (exit)\\\")\\n return data\\n else:\\n logging.debug(\\\"overall constructing (exit)\\\")\\n return pre_construct_data\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def analyse(self, data=None):\\n pass\",\n \"def generate_extra_data(self):\\n self.data[\\\"male_initial\\\"], self.data[\\\"female_initial\\\"] = \\\\\\n self.get_initial_student_count()\\n \\n date_line = '<p class=\\\"report-title\\\"> %s</p>' \\\\\\n %(self.start_date.strftime(\\\"%B %Y\\\"))\\n row1 = \\\"\\\"\\\"\\n <table>\\n <tr class=\\\"tblRow\\\"><td>%s</td><td>Enrollment For Year</td>\\n <td>Male:</td><td>%d</td><td>Female:</td><td>%d</td>\\n <td>Total:</td><td>%d</td></tr>\\n \\\"\\\"\\\" %(unicode(self.school), self.data[\\\"male_initial\\\"], \\n self.data[\\\"female_initial\\\"], \\n self.data[\\\"male_initial\\\"] + self.data[\\\"female_initial\\\"])\\n row2 = \\\"\\\"\\\"\\n <tr class=\\\"tblOddRow\\\"><td>%s</td><td>Enrollment For Month</td>\\n <td>Male:</td><td>%d</td><td>Female:</td><td>%d</td>\\n <td>Total:</td><td>%d</td></tr>\\n \\\"\\\"\\\" %(unicode(self.section), self.data[\\\"male_current\\\"], \\n self.data[\\\"female_current\\\"],\\n self.data[\\\"male_current\\\"] + self.data[\\\"female_current\\\"])\\n row3 = \\\"\\\"\\\"\\n <tr class=\\\"tblRow\\\"><td>%s</td><td>Average Attendance</td>\\n <td>Male:</td><td>%.1f</td><td>Female:</td><td>%.1f</td>\\n <td>Total:</td><td>%.1f</td></tr>\\n \\\"\\\"\\\" %(\\\"Secondary\\\", self.data[\\\"aa_male\\\"], self.data[\\\"aa_female\\\"] ,\\n self.data[\\\"aa_combined\\\"])\\n row4 =\\\"\\\"\\\"\\n <tr class=\\\"tblOddRow\\\"><td>%s</td><td>Percentage of Attendance</td>\\n <td>Male:</td><td>%.1f %% </td><td>Female:</td><td>%.1f %% </td>\\n <td>Total:</td><td>%.1f %% </td></tr>\\n \\\"\\\"\\\" %(unicode(self.school.municipality), self.data[\\\"pa_male\\\"], \\n self.data[\\\"pa_female\\\"], self.data[\\\"pa_combined\\\"])\\n row5 = \\\"\\\"\\\"\\n <tr class=\\\"tblRow\\\"><td>School Days: %d</td><td>Percentage of Enrollment</td>\\n <td>Male:</td><td>%.1f %% </td><td>Female:</td><td>%.1f %% </td>\\n <td>Total:</td><td>%.1f %% </td></tr>\\n </table>\\n \\\"\\\"\\\" %(self.data[\\\"num_school_days\\\"], \\n self.data[\\\"male_current\\\"] * 100.0 / self.data[\\\"male_initial\\\"],\\n self.data[\\\"female_current\\\"] * 100.0 / \\n self.data[\\\"female_initial\\\"],\\n (self.data[\\\"male_current\\\"] + self.data[\\\"female_current\\\"]) * \\n 100.0 /\\n (self.data[\\\"male_initial\\\"] + self.data[\\\"female_initial\\\"]))\\n self.extra_data = date_line + row1 + row2 + row3 + row4 + row5\",\n \"def generate_synthetic_data(plot_data=False):\\n \\n # generate 2 non-sensitive features for each data point from Gaussian distributions\\n X_non_sensitive, y, pos_dist, neg_dist = generate_non_sensitive_feat()\\n \\n # generate 1 sensitive feature that is correlated with the non-sensitive features\\n sensitive_feat = generate_sensitive_feat(X_non_sensitive, pos_dist, neg_dist)\\n sensitive_feat_array = np.array(sensitive_feat)\\n \\n if plot_data:\\n plot_synthetic_data(X_non_sensitive, y, sensitive_feat_array)\\n \\n # NOTE - This complicates the code somewhat, but lets our classify.py work with multiple sensitive features,\\n # which in turn makes the classify code more reusable for students. It's a tradeoff.\\n sensitive_feat_dict = {\\\"s1\\\": sensitive_feat}\\n \\n return X_non_sensitive, y, sensitive_feat_dict\",\n \"def preprocess(data):\\n raise NotImplementedError\",\n \"def generate_statistics(data):\\n print(data)\\n for key in data:\\n print('****\\\\nSummary data for %s:\\\\n----' % key)\\n for category in data[key]:\\n mean = generate_mean(data[key][category])\\n print('\\\\taverage %s: %d' % (category, mean))\\n print('\\\\n\\\\n')\\n return\",\n \"def treats_data(data, typo='mean'):\\n\\n nomalized_data = []\\n\\n if typo == 'mean':\\n for i, v in enumerate(data):\\n nomalized_data.append( fitness_medio(data[i]) )\\n\\n if typo == 'gen_mean':\\n gens = [0]*len(data[0])\\n\\n for i, v in enumerate(data):\\n for j, v in enumerate(data[i]):\\n gens[j] += data[i][j]\\n for i,v in enumerate(gens):\\n nomalized_data.append( (gens[i])/len(data[0]) )\\n\\n if typo == 'max':\\n for i, v in enumerate(data):\\n nomalized_data.append( max(data[i]) )\\n\\n if typo == 'gen_max':\\n gens = [0]*len(data[0])\\n\\n for i, v in enumerate(data):\\n for j, v in enumerate(data[i]):\\n if data[i][j] > gens[j]:\\n gens[j] = (data[i][j])\\n\\n for i,v in enumerate(gens):\\n nomalized_data.append( (gens[i]) )\\n\\n return nomalized_data\",\n \"def print_data_info(my_data, src_field, trg_field):\\n train_data = my_data[\\\"train\\\"]\\n valid_data = my_data[\\\"val\\\"]\\n test_data = my_data[\\\"test\\\"]\\n\\n print(\\\"Data set sizes (number of sentence pairs):\\\")\\n print('train', len(train_data))\\n print('valid', len(valid_data))\\n print('test', len(test_data), \\\"\\\\n\\\")\\n\\n print(\\\"First training example:\\\")\\n print(\\\"src:\\\", \\\" \\\".join(vars(train_data[0])['src']))\\n print(\\\"trg:\\\", \\\" \\\".join(vars(train_data[0])['trg']), \\\"\\\\n\\\")\\n\\n print(\\\"Most common words (src):\\\")\\n print(\\\"\\\\n\\\".join([\\\"%10s %10d\\\" % x for x in src_field.vocab.freqs.most_common(10)]), \\\"\\\\n\\\")\\n print(\\\"Most common words (trg):\\\")\\n print(\\\"\\\\n\\\".join([\\\"%10s %10d\\\" % x for x in trg_field.vocab.freqs.most_common(10)]), \\\"\\\\n\\\")\\n\\n print(\\\"First 10 words (src):\\\")\\n print(\\\"\\\\n\\\".join(\\n '%02d %s' % (i, t) for i, t in enumerate(src_field.vocab.itos[:10])), \\\"\\\\n\\\")\\n print(\\\"First 10 words (trg):\\\")\\n print(\\\"\\\\n\\\".join(\\n '%02d %s' % (i, t) for i, t in enumerate(trg_field.vocab.itos[:10])), \\\"\\\\n\\\")\\n\\n print(\\\"Number of NL words (types):\\\", len(src_field.vocab))\\n print(\\\"Number of AMR words (types):\\\", len(trg_field.vocab), \\\"\\\\n\\\")\",\n \"def feature_extraction(_data):\\n # Find the digits in the given string Example - data='18-20' digits = '1820'\\n digits = str(''.join(c for c in _data if c.isdigit()))\\n # calculate the length of the string\\n len_digits = len(digits)\\n # splitting digits in to values example - digits = '1820' ages = [18, 20]\\n ages = [int(digits[i:i + 2]) for i in range(0, len_digits, 2)]\\n # checking for special character in the given data\\n special_character = '.+-<>?'\\n spl_char = ''.join([c for c in list(special_character) if c in _data])\\n # handling decimal age data\\n if len_digits == 3:\\n spl_char = '.'\\n age = \\\"\\\".join([str(ages[0]), '.', str(ages[1])])\\n # normalizing\\n age = int(float(age) - 0.5)\\n ages = [age]\\n # Finding the maximum, minimum, average age values\\n max_age = 0\\n min_age = 0\\n mean_age = 0\\n if len(ages):\\n max_age = max(ages)\\n min_age = min(ages)\\n if len(ages) == 2:\\n mean_age = int((max_age + min_age) / 2)\\n else:\\n mean_age = max_age\\n # specially added for 18 years cases\\n only_18 = 0\\n is_y = 0\\n if ages == [18]:\\n only_18 = 1\\n if 'y' in _data or 'Y' in _data:\\n is_y = 1\\n under_18 = 0\\n if 1 < max_age < 18:\\n under_18 = 1\\n above_65 = 0\\n if mean_age >= 65:\\n above_65 = 1\\n # verifying whether digit is found in the given string or not.\\n # Example - data='18-20' digits_found=True data='????' digits_found=False\\n digits_found = 1\\n if len_digits == 1:\\n digits_found = 1\\n max_age, min_age, mean_age, only_18, is_y, above_65, under_18 = 0, 0, 0, 0, 0, 0, 0\\n elif len_digits == 0:\\n digits_found, max_age, min_age, mean_age, only_18, is_y, above_65, under_18 = -1, -1, -1, -1, -1, -1, -1, -1\\n \\n feature = {\\n 'ages': tuple(ages),\\n 'len(ages)': len(ages),\\n 'spl_chr': spl_char,\\n 'is_digit': digits_found,\\n 'max_age': max_age,\\n 'mean_age': mean_age,\\n 'only_18': only_18,\\n 'is_y': is_y,\\n 'above_65': above_65,\\n 'under_18': under_18\\n }\\n\\n return feature\",\n \"def format(self, data):\",\n \"def _generate_data(phg: str = None, rng: str = None, dfs: str = None, course: int = None,\\n speed: int = None, altitude: int = None, comment: str = None) -> str:\\n\\n data = \\\"\\\"\\n if phg:\\n data += phg\\n elif rng:\\n data += rng\\n elif dfs:\\n data += dfs\\n elif course and speed:\\n data += \\\"{}/{}\\\".format(\\n str(course).zfill(3), str(speed).zfill(3)\\n )\\n\\n if altitude:\\n data += \\\"/A={}\\\".format(\\n str(altitude).zfill(6)\\n )\\n\\n if comment:\\n data += comment\\n\\n return data\",\n \"def generateFeatures(self, data):\\n pass\",\n \"def easydatagen():\\n\\n # Reading in the training file\\n data = pd.read_json('train.json')\\n\\n # The set of different cuisines\\n cuisines = data.cuisine.unique()\\n\\n # To find the different ingredients, we need to clean them up a little.\\n def clean(string) :\\n s = string.replace('-',' ') # read low-fat the same as low fat\\n s = string.replace('&', 'and') # read & and and as the same\\n s = re.sub('\\\\((.*?)\\\\)', '', s) # remove everythin g in brackets\\n s = re.sub('\\\\d{1,2}\\\\%', '', s) # remove things of the form d% or dd%, where d is a digit\\n s = ' '.join(s.split()) # remove extra white spaces\\n\\n return s\\n\\n ing_list = data.ingredients.values.tolist()\\n raw_ingredients = [clean(x) for ing in ing_list for x in ing]\\n\\n ingredients = sorted(set(raw_ingredients))\\n\\n # build a dictionary that to each ingredient assigns its index\\n ingredient_index = {}\\n for i in range(0,len(ingredients)) :\\n ingredient_index[ingredients[i]] = i\\n\\n # the same for cuisines\\n cuisine_index = {}\\n for i in range(0, len(cuisines)) :\\n cuisine_index[cuisines[i]] = i\\n\\n def ingredients_to_vector(ings) :\\n vect = np.zeros(len(ingredients))\\n for ing in ings :\\n vect[ingredient_index[clean(ing)]] = 1\\n\\n return vect\\n\\n def cuisine_to_vector(cus) :\\n vect = np.zeros(20)\\n vect[cuisine_index[cus]] = 1\\n return vect\\n\\n vect_list = [ingredients_to_vector(ing) for ing in ing_list]\\n target_list = [cuisine_to_vector(cus) for cus in data.cuisine.values.tolist()]\\n\\n # Define training data\\n X = np.c_[vect_list]\\n Y = np.c_[target_list]\\n\\n Y_num = np.zeros((Y.shape[0]))\\n for i in range(Y.shape[0]):\\n Y_num[i] = np.argmax(Y[i])\\n\\n x_train, x_test, y_train, y_test = train_test_split(X, Y_num, test_size = 0.2)\\n\\n return x_train, x_test, y_train, y_test\",\n \"def analyze_data():\\n attack_free_1 = load_messages(\\\"data/csv/Attack_free_dataset.csv\\\", verbose=True)\\n\\n impersonation_1 = load_messages(\\\"data/csv/170907_impersonation.csv\\\", verbose=True)\\n impersonation_2 = load_messages(\\\"data/csv/170907_impersonation_2.csv\\\", verbose=True)\\n impersonation_3 = load_messages(\\\"data/csv/Impersonation_attack_dataset.csv\\\", verbose=True)\\n\\n information = {\\n \\\"Mean time between normal messages\\\":\\n get_mean_time_between_normal_messages(attack_free_1),\\n \\\"Mean time between split messages\\\":\\n get_mean_time_between_split_messages(attack_free_1),\\n \\\"Sum of removed intervals in '170907_impersonation.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_1, 250),\\n \\\"Sum of removed intervals in '170907_impersonation_2.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_2, 250),\\n \\\"Sum of removed intervals in 'Impersonation_attack_dataset.csv'\\\":\\n get_sum_of_removed_intervals(impersonation_3, 250),\\n \\\"Index of split in '170907_impersonation.csv'\\\":\\n get_index_before_time(impersonation_1, 250 - 23.434627056121826),\\n \\\"Index of split in '170907_impersonation_2.csv'\\\":\\n get_index_before_time(impersonation_2, 250 - 20.980855226516724),\\n \\\"Index of split in 'Impersonation_attack_dataset.csv'\\\":\\n get_index_before_time(impersonation_3, 250 - 2.1056361198425293)\\n }\\n\\n return information\",\n \"def build_eval_data(self,data, num_classes, clean_string=False):\\n revs = []\\n num = [-1, 1]\\n for line in data:\\n line = line.decode('utf-8')\\n sent = line\\n rev = []\\n rev.append(sent.strip())\\n\\n if clean_string:\\n orig_rev = self.dc.clean_str(\\\" \\\".join(rev))\\n else:\\n orig_rev = \\\" \\\".join(rev).lower()\\n #print orig_rev\\n\\n datum = {\\\"y\\\":num[np.random.randint(0, num_classes)],\\n \\\"text\\\": orig_rev,\\n \\\"num_words\\\": len(orig_rev.split()),\\n }\\n revs.append(datum)\\n\\n\\n return revs\",\n \"def display_data(data):\\n\\n index = 0\\n for details in data:\\n index += 1\\n print(\\\"{5:1}{0}. {1:10} in {2:15} priority {3:>3}\\\".format(index, *details))\",\n \"def build_sample(data):\\n parsed = {\\n 'lims_id': data['Sample Name'],\\n 'name': data['External Name'],\\n 'project_id': data['Project'],\\n 'reference_genome': data['Reference Genome'],\\n 'total_reads': data['Total Reads'],\\n 'insert_size': data['Median Insert Size'],\\n 'duplication_rate': data['Duplication Rate'],\\n 'mapped_rate': data['Fraction aligned to Reference'],\\n 'coverage_10x': data['Fraction of bases with cov >= 10X'],\\n 'coverage_30x': data['Fraction of bases with cov >= 30X'],\\n 'coverage_50x': data['Fraction of bases with cov >= 50X'],\\n 'coverage_100x': data['Fraction of bases with cov >= 100X']\\n }\\n return parsed\",\n \"def test_data():\\n return {\\\"David Andrews\\\" : [200.50, 400.00, 250.75],\\n \\\"John Goodfellow\\\" : [25.00, 175.50],\\n \\\"Mary Suzuki\\\" : [75.00, 125.00, 250.00],\\n \\\"Bonney Lake\\\" : [500.50, 700.75, 500.25],\\n \\\"DeMarcus Rollins\\\" : [155.00, 165.00]\\n }\",\n \"def _basic_data_info(X, y):\\n num_samples, num_feats = X.shape # start with X properties\\n\\n # Compute distribution\\n classes, counts, percs = _class_distribution(y)\\n num_classes = classes.size\\n\\n # Return data info dictionary\\n output_dic = {\\n \\\"Num_samples\\\": num_samples,\\n \\\"Num_feats\\\": num_feats,\\n \\\"Num_classes\\\": num_classes,\\n \\\"classes\\\": classes,\\n \\\"counts\\\": counts,\\n \\\"percs\\\": percs\\n }\\n\\n return output_dic\",\n \"def generate_data(cls):\\n cls.results = {}\\n cls.pre_process()\\n today = datetime.today()\\n skip = None\\n values = map(lambda a: a[0], cls.data)\\n if len(values) == 0 and 'citation' not in cls.config_data_name:\\n skip = True\\n weights= map(lambda a: a[1], cls.data)\\n if cls.config_data_name == 'reads_histogram':\\n bins = range(1996, today.year+2)\\n elif cls.min_year:\\n bins = range(cls.min_year, today.year+2)\\n else:\\n try:\\n bins = range(min(values),max(values)+2)\\n except:\\n skip = True\\n if not skip:\\n refereed_values = map(lambda a: a[0], cls.refereed_data)\\n refereed_weights= map(lambda a: a[1], cls.refereed_data)\\n # get the regular histogram\\n cls.value_histogram = histogram(values,bins=bins)\\n cls.refereed_value_histogram = histogram(refereed_values,bins=bins)\\n # get the normalized histogram\\n cls.normalized_value_histogram = histogram(values,bins=bins,weights=weights)\\n cls.refereed_normalized_value_histogram = histogram(refereed_values,bins=bins,weights=refereed_weights)\\n else:\\n cls.value_histogram = False\\n cls.results[str(today.year)] = \\\"0:0:0:0\\\"\\n cls.post_process()\",\n \"def _format_ov_ins(data: Dict[str, Any], cfg: Config) -> List[Dict[str, str]]:\\n # pylint: disable=line-too-long\\n # list of insights\\n ins: List[Dict[str, str]] = []\\n\\n pdup = round((1 - data[\\\"nrows_wo_dups\\\"] / data[\\\"nrows\\\"]) * 100, 2)\\n if pdup > cfg.insight.duplicates__threshold:\\n ndup = data[\\\"nrows\\\"] - data[\\\"nrows_wo_dups\\\"]\\n ins.append({\\\"Duplicates\\\": f\\\"Dataset has {ndup} ({pdup}%) duplicate rows\\\"})\\n\\n for (*cols, test_result) in data.get(\\\"ks_tests\\\", []):\\n if test_result > cfg.insight.similar_distribution__threshold:\\n msg = f\\\"/*start*/{cols[0]}/*end*/ and /*start*/{cols[1]}/*end*/ have similar distributions\\\"\\n ins.append({\\\"Similar Distribution\\\": msg})\\n\\n data.pop(\\\"ks_tests\\\", None)\\n\\n return ins\",\n \"def _setResultInfo(self, data: list):\\n repResultInfo = [['機能','端子','状態','判定基準','結果','判定']]\\n bufResultInfo = [''] * 6\\n _data = [[d[1].split('_')[0],d[1].split('->')[0].split('_')[1],d[1].split('->')[1],d[2],d[3],d[4]] for d in data]\\n resultInfo = [[s.replace(',','\\\\n') for s in ss] for ss in _data]\\n for i, item in enumerate(resultInfo):\\n if item[2][0:5] == 'LEVEL':\\n bufResultInfo = item\\n repResultInfo.append(bufResultInfo)\\n bufResultInfo = [''] * 6\\n elif item[0]=='SQ' or item[0]=='SAT' or item[0]=='LOAD':\\n bufResultInfo[0] = item[0]\\n bufResultInfo[1] = item[1]\\n bufResultInfo[2] = item[2]\\n elif item[2] == 'DTCread':\\n bufResultInfo[3] = item[3]\\n bufResultInfo[4] = item[4]\\n bufResultInfo[5] = item[5]\\n if bufResultInfo[0] != '':\\n repResultInfo.append(bufResultInfo)\\n bufResultInfo = [''] * 6\\n self._result_info = repResultInfo\",\n \"def _generate(self, custom_data: typing.Dict) -> typing.Dict:\\n info = {}\\n for field in self.fields:\\n if field.name in custom_data:\\n info[field.name] = custom_data[field.name]\\n else:\\n info[field.name] = field.generate(info)\\n\\n return info\",\n \"def prepare_data():\\n user_name = os.environ.get('USER')\\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\\n random.shuffle(traintest_corpus.resumes)\\n\\n for resume in traintest_corpus.resumes:\\n try:\\n review_text = pre_processing(resume[0])\\n review_text = \\\" \\\".join(review_text)\\n data_dict['data'].append(review_text)\\n data_dict['label'].append(resume[1])\\n except:\\n pass\",\n \"def verbose_data_dict(perf_data, epoch_losses, batch_losses):\\n data_dict = []\\n if epoch_losses is not None and len(epoch_losses['actor_mse']) > 0:\\n data_dict.append({'title': \\\"Actor_MSE_Loss_vs_Epoch\\\", 'data': epoch_losses['actor_mse'],\\n 'y_label': 'Loss' + '( min: ' + str(min(epoch_losses['actor_mse'])) + ' )',\\n 'x_label': 'Epoch'})\\n if epoch_losses is not None and len(epoch_losses['actor_ce']) > 0:\\n data_dict.append({'title': \\\"Actor_CE_Loss_vs_Epoch\\\", 'data': epoch_losses['actor_ce'],\\n 'y_label': 'Loss' + '( min: ' + str(min(epoch_losses['actor_ce'])) + ' )',\\n 'x_label': 'Epoch'})\\n if batch_losses is not None and len(batch_losses['actor_mse']) > 0:\\n data_dict.append({'title': \\\"Actor_MSE_Loss_vs_Batches\\\", 'data': batch_losses['actor_mse'],\\n 'y_label': 'Loss' + '( min: ' + str(min(batch_losses['actor_mse'])) + ' )',\\n 'x_label': 'Batch'})\\n if batch_losses is not None and len(batch_losses['actor_ce']) > 0:\\n data_dict.append({'title': \\\"Actor_CE_Loss_vs_Batches\\\", 'data': batch_losses['actor_ce'],\\n 'y_label': 'Loss' + '( min: ' + str(min(batch_losses['actor_ce'])) + ' )',\\n 'x_label': 'Batch'})\\n if perf_data is not None and len(perf_data) > 0:\\n data_dict.append({'title': \\\"Test_Performance_vs_Epoch\\\", 'data': perf_data,\\n 'y_label': 'Average Episode Reward' + '( max: ' + str(max(perf_data)) + ' )',\\n 'x_label': 'Epoch'})\\n return data_dict\",\n \"def treatment_plugs(data_plugs):\\r\\n\\r\\n no_plugs = []\\r\\n little = []\\r\\n means = []\\r\\n great = []\\r\\n large_enough = []\\r\\n super_large = []\\r\\n\\r\\n\\r\\n for i in data_plugs:\\r\\n print(i[0])\\r\\n if i[1] in ('None', None)\\\\\\r\\n or i[0] in ('None', None):\\r\\n pass\\r\\n elif i[0] == 'non':\\r\\n no_plugs.append(int(i[1]))\\r\\n elif i[0] == 'petit':\\r\\n little.append(int(i[1]))\\r\\n elif i[0] == 'moyen':\\r\\n means.append(int(i[1]))\\r\\n elif i[0] == 'grand':\\r\\n great.append(int(i[1]))\\r\\n elif i[0] == 'assez grand':\\r\\n large_enough.append(int(i[1]))\\r\\n elif i[0] == 'tres grand':\\r\\n super_large.append(int(i[1]))\\r\\n\\r\\n\\r\\n data = len(no_plugs) + len(little) +\\\\\\r\\n len(means) + len(great)+\\\\\\r\\n len(large_enough)+\\\\\\r\\n len(super_large)\\r\\n\\r\\n print(data)\\r\\n\\r\\n data_no = moyenne(no_plugs)\\r\\n data_little = moyenne(little)\\r\\n data_means = moyenne(means)\\r\\n data_great = moyenne(great)\\r\\n data_large_enough = moyenne(large_enough)\\r\\n data_super_large = moyenne(super_large)\\r\\n\\r\\n return data_no[0],\\\\\\r\\n data_little[0],\\\\\\r\\n data_means[0],\\\\\\r\\n data_great[0],\\\\\\r\\n data_large_enough[0],\\\\\\r\\n data_super_large[0],\\\\\\r\\n data_no[1],\\\\\\r\\n data_little[1],\\\\\\r\\n data_means[1],\\\\\\r\\n data_great[1],\\\\\\r\\n data_large_enough[1],\\\\\\r\\n data_super_large[1],\\\\\\r\\n data\",\n \"def define_info_dict():\\n\\n d = {\\n \\\"PRED\\\": {\\n \\\"COLUMN\\\": [\\\"predicted_class\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"String\\\",\\n \\\"Description\\\": \\\"Predicted class: somatic, germline, artifact\\\",\\n },\\n \\\"PROB\\\": {\\n \\\"COLUMN\\\": [\\\"prob_s\\\", \\\"prob_g\\\", \\\"prob_a\\\"],\\n \\\"Number\\\": \\\"3\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Prediction probability of \\\"\\n \\\"being somatic, germline, artifact in this order\\\",\\n },\\n \\\"SNP\\\": {\\n \\\"COLUMN\\\": [\\\"is_on_db\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Present on SNP database (modified dbSNP/gnomAD (default) or user-provided database)\\\",\\n },\\n \\\"ANNO\\\": {\\n \\\"COLUMN\\\": [\\\"annotation\\\"],\\n \\\"Number\\\": \\\".\\\",\\n \\\"Type\\\": \\\"String\\\",\\n \\\"Description\\\": \\\"Indel annotation formatted as \\\"\\n \\\"GeneSymbol|RefSeqAccession|CodonPos|IndelEffect\\\"\\n \\\"Delimited by comma for multiple isoforms\\\",\\n },\\n \\\"COSMIC_CNT\\\": {\\n \\\"COLUMN\\\": [\\\"cosmic_cnt\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"COSMIC count in v89\\\",\\n },\\n \\\"MAXMAF\\\": {\\n \\\"COLUMN\\\": [\\\"max_maf\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Maximum minor allele frequency (MAF) \\\"\\n \\\"reported in dbSNP, ClinVar and gnomAD non-cancer population\\\",\\n },\\n \\\"COMMON\\\": {\\n \\\"COLUMN\\\": [\\\"is_common\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Common in dbSNP or MAXMAF > 0.01\\\",\\n },\\n \\\"CLIN\\\": {\\n \\\"COLUMN\\\": [\\\"clin_info\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"String\\\",\\n \\\"Description\\\": \\\"ClinVar annotation formatted as ClinicalSignificance|Condition\\\",\\n },\\n \\\"ICP\\\": {\\n \\\"COLUMN\\\": [\\\"indel_complexity\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"Indel complexity: mismatches around the indel measured by edit distance\\\",\\n },\\n \\\"DSM\\\": {\\n \\\"COLUMN\\\": [\\\"dissimilarity\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Dissimilarity: edit distance between indel and flanking sequences\\\",\\n },\\n \\\"ISZ\\\": {\\n \\\"COLUMN\\\": [\\\"indel_size\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"Indel size\\\",\\n },\\n \\\"REP\\\": {\\n \\\"COLUMN\\\": [\\\"repeat\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"Repeat: count of the indel-sequence repeats in flanking region\\\",\\n },\\n \\\"UQM\\\": {\\n \\\"COLUMN\\\": [\\\"is_uniq_mapped\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Supported by uniquely mapped reads\\\",\\n },\\n \\\"NEB\\\": {\\n \\\"COLUMN\\\": [\\\"is_near_boundary\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Near exon boundary\\\",\\n },\\n \\\"EQX\\\": {\\n \\\"COLUMN\\\": [\\\"equivalence_exists\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Equivalent alignments exist for the indel\\\",\\n },\\n \\\"BID\\\": {\\n \\\"COLUMN\\\": [\\\"is_bidirectional\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Supported by forward and reverse reads\\\",\\n },\\n \\\"MTA\\\": {\\n \\\"COLUMN\\\": [\\\"is_multiallelic\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Multialleleic\\\",\\n },\\n \\\"FRM\\\": {\\n \\\"COLUMN\\\": [\\\"is_inframe\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"In-frame indel\\\",\\n },\\n \\\"SPL\\\": {\\n \\\"COLUMN\\\": [\\\"is_splice\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Located in splice region\\\",\\n },\\n \\\"TRN\\\": {\\n \\\"COLUMN\\\": [\\\"is_truncating\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Truncating indel\\\",\\n },\\n \\\"CDD\\\": {\\n \\\"COLUMN\\\": [\\\"is_in_cdd\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Located in conserved domain\\\",\\n },\\n \\\"LOC\\\": {\\n \\\"COLUMN\\\": [\\\"indel_location\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Relative indel location within the transcript coding region\\\",\\n },\\n \\\"NMD\\\": {\\n \\\"COLUMN\\\": [\\\"is_nmd_insensitive\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Insensitive to nonsense mediated decay\\\",\\n },\\n \\\"IPG\\\": {\\n \\\"COLUMN\\\": [\\\"ipg\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Indels per gene\\\",\\n },\\n \\\"LEN\\\": {\\n \\\"COLUMN\\\": [\\\"cds_length\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Coding sequence length. Median value if multiple isoforms exist\\\",\\n },\\n \\\"LC\\\": {\\n \\\"COLUMN\\\": [\\\"lc\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Linguistic complexity: diversity of k-mers in flanking 50-bp region\\\",\\n },\\n \\\"LLC\\\": {\\n \\\"COLUMN\\\": [\\\"local_lc\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Local linguistic complexity: diversity of k-mers in flanking 6-bp region\\\",\\n },\\n \\\"GC\\\": {\\n \\\"COLUMN\\\": [\\\"gc\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"GC-content in flanking 50-bp region\\\",\\n },\\n \\\"LGC\\\": {\\n \\\"COLUMN\\\": [\\\"local_gc\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Local GC-content in flanking 6-bp region\\\",\\n },\\n \\\"SG\\\": {\\n \\\"COLUMN\\\": [\\\"strength\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"DNA bond strength of 2-mers in flanking 50-bp region\\\",\\n },\\n \\\"LSG\\\": {\\n \\\"COLUMN\\\": [\\\"local_strength\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Float\\\",\\n \\\"Description\\\": \\\"Local DNA bond strength of 2-mers in flanking 6-bp region\\\",\\n },\\n \\\"INS\\\": {\\n \\\"COLUMN\\\": [\\\"is_ins\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Insertion\\\",\\n },\\n \\\"ATI\\\": {\\n \\\"COLUMN\\\": [\\\"is_at_ins\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Single insertion of A or T\\\",\\n },\\n \\\"ATD\\\": {\\n \\\"COLUMN\\\": [\\\"is_at_del\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Single deletion of A or T\\\",\\n },\\n \\\"GCI\\\": {\\n \\\"COLUMN\\\": [\\\"is_gc_ins\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Single insertion of G or C\\\",\\n },\\n \\\"GCD\\\": {\\n \\\"COLUMN\\\": [\\\"is_gc_del\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Single deletion of G or C\\\",\\n },\\n \\\"ALTC\\\": {\\n \\\"COLUMN\\\": [\\\"alt_count\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"Alt count: count of unique reads supporting ALT allele\\\",\\n },\\n \\\"REFC\\\": {\\n \\\"COLUMN\\\": [\\\"ref_count\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"Integer\\\",\\n \\\"Description\\\": \\\"Ref count: count of unique reads supporting REF allele\\\",\\n },\\n \\\"RCF\\\": {\\n \\\"COLUMN\\\": [\\\"reclassified\\\"],\\n \\\"Number\\\": \\\"0\\\",\\n \\\"Type\\\": \\\"Flag\\\",\\n \\\"Description\\\": \\\"Reclassification applied\\\",\\n },\\n \\\"RQB\\\": {\\n \\\"COLUMN\\\": [\\\"filtered\\\", \\\"rescued\\\"],\\n \\\"Number\\\": \\\"1\\\",\\n \\\"Type\\\": \\\"String\\\",\\n \\\"Description\\\": \\\"Indel used to rescue this entry formatted as CHROM:POS:REF:ALT\\\",\\n },\\n }\\n\\n return d\",\n \"def _make_information_storable( self, data ):\\n\\t\\tpass\",\n \"def make_code(self, datasetname):\\n try:\\n if(datasetname):\\n for i in range(1, len(self.extract()) + 1):\\n self.formated = datasetname + \\\"%03d\\\" % (i,)\\n yield self.formated \\n except:\\n raise\",\n \"def formatdata(data,Params):\\n\\tmndata = dict()\\n\\talltrials = np.array([])\\n\\tfor k in range(len(Params[\\\"conditions\\\"])):\\n\\t\\tconditionmean = data[0,k].mean(axis = 0)\\n\\t\\tmndata.update({Params[\\\"conditions\\\"][k]: {'data' : data[0,k].mean(axis = 0), 'cmax' : conditionmean.max(), 'cmin' : conditionmean.min()}})\\n\\treturn mndata\",\n \"def transform(self, data):\",\n \"def example_data():\\n return [\\n {'id': 'text', 'title': {'en': 'Text'}, 'type': 'resourcetypes'},\\n {'id': 'data', 'title': {'en': 'Data'}, 'type': 'resourcetypes',\\n 'tags': ['recommended']},\\n ]\",\n \"def show_data():\",\n \"def formulate_data(arrdata):\\n\\n N, K = arrdata.shape\\n\\n dfdata = pd.DataFrame({\\n 'Id' : np.arange(1,N+1).astype('int32'),\\n 'age' : arrdata[:,0].astype('float64'),\\n 'work_class' : pd.Categorical(arrdata[:,1]),\\n 'education' : pd.Categorical(arrdata[:,2]),\\n 'number_of_years_of_education' : arrdata[:,3].astype('float64'),\\n 'marital_status' : pd.Categorical(arrdata[:,4]),\\n 'occupation' : pd.Categorical(arrdata[:,5]),\\n 'relationship' : pd.Categorical(arrdata[:,6]),\\n 'race' : pd.Categorical(arrdata[:,7]),\\n 'sex' : pd.Categorical(arrdata[:,8]),\\n 'income_from_investment_sources': arrdata[:,9].astype('float64'),\\n 'losses_from_investment_sources': arrdata[:,10].astype('float64'),\\n 'working_hours_per_week' : arrdata[:,11].astype('float64'),\\n 'native_country' : pd.Categorical(arrdata[:,12])})\\n\\n # if earn_over_4k_euros_per_year is available (training set)\\n if K == 14:\\n dfdata['earn_over_4k_euros_per_year'] = \\\\\\n pd.Series(arrdata[:,13].astype('int32'), index=dfdata.index)\\n else:\\n dfdata['earn_over_4k_euros_per_year'] = \\\\\\n pd.Series((np.ones(N)*(-1)).astype('int32'), index=dfdata.index)\\n\\n return dfdata\",\n \"def generate_data(n, data, labels, param, label):\\n\\n\\tmu = param[0]\\n\\tsigma = param[1]\\n\\n\\tfor i in range(n):\\n\\n\\t\\t# TODO: Recall the notation of x in the exercise sheet.\\n\\t\\t# \\t\\tGenerate a 2-d Gaussian distributed data point plus an offset value for the bias.\\n\\t\\t# \\t\\tUse our rand_gaussian method.\\n\\n\\t\\tx1 = rand_gaussian(mu[0], sigma[0]) \\n\\t\\tx2 = rand_gaussian(mu[1], sigma[1]) \\n\\n\\t\\tdata_point = [1, x1, x2]\\n\\t\\tdata.append(data_point)\\n\\t\\tlabels.append(label)\\n\\n\\treturn data,labels\",\n \"def simple_generator_function(data):\\n if data:\\n random.shuffle(data)\\n\\n for data_row in data:\\n print \\\"\\\\ngenerating data:\\\"\\n guess_data = [data_row[0], data_row[1], data_row[2], data_row[3]]\\n iris = copy.deepcopy(DATA_SKELETON)\\n iris['data_vector'] = guess_data\\n iris['class'] = data_row[4]\\n iris['_id'] = str(uuid.uuid4())\\n # iris[0]['created'] = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')\\n yield iris\",\n \"def analysisData(train_data, test_data, users_data, products_data):\\n\\n #\\n\\n # how many data are\\n dataShape(train_data)\\n dataShape(test_data)\\n dataShape(users_data)\\n dataShape(products_data)\\n\\n \\\"\\\"\\\" CSV shape \\n Train: 416147\\n Test: 46239\\n Usuario: 68819\\n Producto: 309961\\n \\\"\\\"\\\"\\n\\n # Users, products and tag are unique:\\n removeDuplicated(train_data) # obtenemos: tag_id column of your data is not duplicated\\n removeDuplicated(users_data) # obtenemos: user_id column of your data is not duplicated\\n removeDuplicated(products_data) #\\n\\n # Null values\\n checkNulls(train_data, remove= False) # No null values\\n checkNulls(users_data, remove= False) # No null values\\n checkNulls(products_data, remove= False) # product_info: 443 null values and description: 81381 null values\\n\\n\\n # cluck count description\\n dataDescription(train_data, 'click_count')\\n\\n # click count distribution\\n countClickIntervals(train_data) # Most of tag id have only 1 click, then 0 clicks\\n # It is not possible detecting outliers by the moment\\n\\n # analize the data tange in users and train\\n dateAnalyzing(users_data, train_data)\\n\\n \\\"\\\"\\\"\\n USERS: maxim date:, 2016-01-21 minim date: 2017-06-30 unique dates 522\\n TRAIN: maxim date:, 2017-04-23 minim date:: 2017-06-19 unique dates 58\\n \\n Number of users increases with the time. las few dates i where the number of new users is widely higher \\n \\\"\\\"\\\"\\n\\n # Sample distribution\\n g = visualization.plotSns(train_data[['tag_id', 'post_id', 'product_id', 'user_id', 'click_count']], diag_kind=\\\"kde\\\", markers='+')\\n\\n # How many unique users are in the training subset?\\n print('The number of unique users are:', len(train_data['user_id'].unique()))\\n\\n return train_data, test_data, users_data, products_data\",\n \"def read_item(data: DataModel) -> Dict:\\n convertor = Convertor(data)\\n return {'output': convertor.get_humanized_data()}\",\n \"def _format_data(self, data: np.ndarray) -> np.ndarray:\\n self._n_circs = 0\\n self._n_shots = 0\\n self._n_slots = 0\\n self._n_iq = 0\\n\\n # identify shape\\n try:\\n # level1 single-shot data\\n self._n_circs, self._n_shots, self._n_slots, self._n_iq = data.shape\\n except ValueError:\\n try:\\n # level1 data averaged over shots\\n self._n_circs, self._n_slots, self._n_iq = data.shape\\n except ValueError as ex:\\n raise DataProcessorError(\\n f\\\"Data given to {self.__class__.__name__} is not likely level1 data.\\\"\\n ) from ex\\n\\n if self._validate:\\n if self._n_iq != 2:\\n raise DataProcessorError(\\n f\\\"IQ data given to {self.__class__.__name__} does not have two-dimensions \\\"\\n f\\\"(I and Q). Instead, {self._n_iq} dimensions were found.\\\"\\n )\\n\\n return data\",\n \"def gen_analysis_text(num_data, usage_flag, labelled_landmark, landmark_name, error_summary):\\n analysis_text = r'<p style=\\\"color:red;\\\">Basic information:</p>'\\n analysis_text += '<p style=\\\"color:black;\\\">Landmark name: {0}.</p>'.format(landmark_name)\\n analysis_text += '<p style=\\\"color:black;\\\"># cases in total: {0}.</p>'.format(num_data)\\n labelled_landmarks_stat = get_landmarks_stat(labelled_landmark)\\n \\n analysis_text += r'<p style=\\\"color:black;\\\"># cases having this landmark (Pos. cases): {0}.</p>'.format(\\n len(labelled_landmarks_stat[landmark_name]['pos']))\\n analysis_text += r'<p style=\\\"color:black;\\\"># cases missing this landmark (Neg. cases): {}.</p>'.format(\\n len(labelled_landmarks_stat[landmark_name]['neg']))\\n if len(labelled_landmarks_stat[landmark_name]['neg']) > 0:\\n missing_cases = copy.deepcopy(labelled_landmarks_stat[landmark_name]['neg'])\\n missing_cases.sort()\\n analysis_text += r'{}'.format(missing_cases)\\n\\n if usage_flag == 2:\\n tp_cases = error_summary.tp_cases[landmark_name]\\n tn_cases = error_summary.tn_cases[landmark_name]\\n fp_cases = error_summary.fp_cases[landmark_name]\\n fn_cases = error_summary.fn_cases[landmark_name]\\n num_pos_cases = len(tp_cases) + len(fn_cases)\\n num_neg_cases = len(tn_cases) + len(fp_cases)\\n # compute TPR, TNR, FPR, FNR\\n TPR = len(tp_cases) / max(1, num_pos_cases) * 100 \\\\\\n if len(tp_cases) != 0 or num_pos_cases != 0 else 100\\n TNR = len(tn_cases) / max(1, num_neg_cases) * 100 \\\\\\n if len(tn_cases) != 0 or num_neg_cases != 0 else 100\\n FPR = 100 - TNR\\n FNR = 100 - TPR\\n mean_error = error_summary.mean_error_tp[landmark_name]\\n std_error = error_summary.std_error_tp[landmark_name]\\n median_error = error_summary.median_error_tp[landmark_name]\\n max_error = error_summary.max_error_tp[landmark_name]\\n analysis_text += r'<p style=\\\"color:red;\\\"> Landmark classification error: </p>'\\n analysis_text += r'<p style=\\\"color:black;\\\">TP (TPR): {0} ({1:.2f}%)</p>'.format(\\n len(tp_cases), TPR)\\n analysis_text += r'<p style=\\\"color:black;\\\">TN (TNR): {0} ({1:.2f}%)</p>'.format(\\n len(tn_cases), TNR)\\n analysis_text += r'<p style=\\\"color:black;\\\">FP (FPR): {0} ({1:.2f}%)</p>'.format(\\n len(fp_cases), FPR)\\n analysis_text += r'<p style=\\\"color:black;\\\">FN (FNR): {0} ({1:.2f}%)</p>'.format(\\n len(fn_cases), FNR)\\n analysis_text += r'<p style=\\\"color:red;\\\"> Landmark distance error for the {} TP cases (unit: mm): </p>'.format(\\n len(tp_cases))\\n analysis_text += r'<p style=\\\"color:black;\\\">mean (std): {0:.2f} ({1:.2f})</p>'.format(\\n mean_error, std_error)\\n analysis_text += r'<p style=\\\"color:black;\\\">median: {0:.2f}</p>'.format(median_error)\\n analysis_text += r'<p style=\\\"color:black;\\\">max: {0:.2f}</p>'.format(max_error)\\n\\n return analysis_text\",\n \"def preprocess_data(extracted_data: List[Tuple[str, str]]) -> List[str]:\\n return [f'__label__{data[0]} {clean_formatting(data[1])}' for data in extracted_data]\",\n \"def mk_data(self):\\n self.data = self.DEFAULTS.copy()\\n\\n for template in self.raw_data.get('extends', []):\\n template_data = self.load_template(template)\\n self.data.update(template_data)\\n\\n self.data.update(self.raw_data)\\n\\n str_replace(self.data)\\n\\n if self.data.get('redirect_stderr'):\\n self.data.pop('stderr')\",\n \"def _pack_data( self, data ) : \\r\\n \\r\\n # hints = self._translation_table.get( type(data), None )\\r\\n hints = self._get_hints( data ) \\r\\n \\r\\n if hints is None : \\r\\n \\r\\n ## #debug: \\r\\n ## print \\\"_pack_data(): no hints for data type %s (data repr: %s)\\\" % (type(data), repr(data))\\r\\n \\r\\n # \\\"one-level recursion\\\" : \\r\\n # return self._pack_data( repr(data) )\\r\\n return self._pack_data( str(data) )\\r\\n \\r\\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \\r\\n ## if data is None: data = 0\\r\\n \\r\\n # else ... \\r\\n \\r\\n # 'DescType' + 'length' + 'data'\\r\\n desctype = hints[0]\\r\\n if desctype == 'TEXT' : \\r\\n length = len(data)\\r\\n data_str = data \\r\\n else :\\r\\n length = struct.calcsize( hints[1] )\\r\\n data_str = struct.pack( hints[1], data )\\r\\n \\r\\n length_str = struct.pack('=H', length)\\r\\n \\r\\n \\r\\n return _cat(desctype, length_str, data_str)\",\n \"def __profile_to_table(data):\\n output = [[\\\"condition\\\", \\\"mean\\\", \\\"min\\\", \\\"max\\\"]]\\n order = data[\\\"order\\\"]\\n\\n for o in order:\\n try:\\n values = data[\\\"data\\\"][o]\\n output.append(\\n [o, str(mean(values)), str(min(values)), str(max(values))]\\n )\\n except Exception as e:\\n print(e)\\n\\n return \\\"\\\\n\\\".join([\\\"\\\\t\\\".join(l) for l in output])\",\n \"def _create_Data(classname, typename):\\n attributes = {\\\"typename\\\": typename}\\n if \\\"complex\\\" in typename:\\n def format_sampler(self, val):\\n \\\"\\\"\\\"Format surrounded by [] for the sampler.\\n\\n 2x space (for real and complex parts).\\n \\\"\\\"\\\"\\n if isinstance(val, int):\\n return \\\"[%s]\\\" % (2 * val)\\n return val\\n attributes[\\\"format_sampler\\\"] = format_sampler\\n globals()[classname] = type(classname, (Data,), attributes)\",\n \"def print_data(**kwargs):\\n return f'Имя: {kwargs.get(\\\"name\\\")}, Фамилия: {kwargs.get(\\\"surname\\\")}, Год рождения: {kwargs.get(\\\"birth_year\\\")},' \\\\\\n f' Город проживания: {kwargs.get(\\\"city\\\")}, Адрес эл. почты: {kwargs.get(\\\"email\\\")},' \\\\\\n f' Номер телефона: {kwargs.get(\\\"phone\\\")}.'\",\n \"def _fillData(self, extras):\\n e = {k : (\\\" \\\".join(v[\\\"words\\\"])\\n if type(v) == dict and \\\"words\\\" in v else v) for k, v in extras.items()}\\n return self.data % e\",\n \"def show_data(self, ):\\r\\n return print('society_name : {}\\\\n'\\r\\n 'flat : {}\\\\n'\\r\\n 'house_no : {}\\\\n'\\r\\n 'no_of_members : {}\\\\n'\\r\\n 'income : {}\\\\n '\\r\\n .format(self.society_name, self.flat, self.house_no, self.no_of_members, self.income))\",\n \"def generate_data(input_file):\\n \\n mol_mass_list = []\\n inchi_list = []\\n SMILES_list = []\\n identifier_list = []\\n inchi_key1_list = [] \\n inchi_key2_list = [] \\n mol_formula_list = []\\n NA_list = []\\n \\n pre_SMILES_list = []\\n identifier_list = []\\n all_lines = input_file.split('\\\\n')\\n if all_lines[-1] == '':\\n all_lines = all_lines[:-1]\\n for line in all_lines:\\n line = line.split('\\\\t')\\n\\n #Convert to mol and remove invalid structures \\n smile_string = ''\\n id_string = ''\\n m = line[0]\\n id_name = line[1]\\n mol = Chem.MolFromSmiles(m)\\n if mol != None:\\n smile_string += m\\n id_string += id_name\\n pre_SMILES_list += [smile_string]\\n \\n #Source identifiers\\n identifier_list += [id_string]\\n \\n pre_inchi_list = []\\n for smile in pre_SMILES_list:\\n #Generate mol\\n m = Chem.MolFromSmiles(smile)\\n #SMILES, canonical\\n sm = Chem.MolToSmiles(m)\\n SMILES_list += [sm]\\n #Monoisotopic mass\\n mol_weigth = Descriptors.ExactMolWt(m)\\n mol_mass_list += [mol_weigth]\\n #Mol Forumula\\n mol_formula = rdMolDescriptors.CalcMolFormula(m)\\n mol_formula_list += [mol_formula]\\n # InChI \\n inchi = rdinchi.MolToInchi(m)\\n pre_inchi_list += [inchi[0]] \\n \\n \\n # InChIKey1 and InChIKey2\\n for inchi in pre_inchi_list:\\n if not str(inchi).startswith('InCh'):\\n inchi = 'NA'\\n inchi_list += [inchi]\\n \\n pre_inchi_key_list =[]\\n for inchi2 in inchi_list: \\n if inchi2 == 'NA':\\n inchi_key = \\\"NA-NA\\\"\\n pre_inchi_key_list += [inchi_key]\\n if inchi2 != 'NA':\\n inchi_key = rdinchi.InchiToInchiKey(inchi2)\\n pre_inchi_key_list += [inchi_key]\\n \\n for inchi_key in pre_inchi_key_list:\\n inchi_key = inchi_key.split('-')\\n inchi_key2 = inchi_key[1]\\n inchi_key2_list += [inchi_key2]\\n inchi_key1 = inchi_key[0]\\n inchi_key1_list += [inchi_key1]\\n\\n # NA list \\n nr_of_structures = len(SMILES_list)\\n NA_list += ['NA'] * nr_of_structures\\n\\n overall_list = [mol_mass_list]+[inchi_list]+[SMILES_list]+\\\\\\n [identifier_list]+[inchi_key2_list]+[inchi_key1_list]+[mol_formula_list]+\\\\\\n [NA_list]+[NA_list]+[NA_list]+[NA_list]\\n \\n return overall_list\",\n \"def debug_data(\\n # fmt: off\\n lang: (\\\"Model language\\\", \\\"positional\\\", None, str),\\n train_path: (\\\"Location of JSON-formatted training data\\\", \\\"positional\\\", None, Path),\\n dev_path: (\\\"Location of JSON-formatted development data\\\", \\\"positional\\\", None, Path),\\n tag_map_path: (\\\"Location of JSON-formatted tag map\\\", \\\"option\\\", \\\"tm\\\", Path) = None,\\n base_model: (\\\"Name of model to update (optional)\\\", \\\"option\\\", \\\"b\\\", str) = None,\\n pipeline: (\\\"Comma-separated names of pipeline components to train\\\", \\\"option\\\", \\\"p\\\", str) = \\\"tagger,parser,ner\\\",\\n ignore_warnings: (\\\"Ignore warnings, only show stats and errors\\\", \\\"flag\\\", \\\"IW\\\", bool) = False,\\n verbose: (\\\"Print additional information and explanations\\\", \\\"flag\\\", \\\"V\\\", bool) = False,\\n no_format: (\\\"Don't pretty-print the results\\\", \\\"flag\\\", \\\"NF\\\", bool) = False,\\n # fmt: on\\n):\\n msg = Printer(pretty=not no_format, ignore_warnings=ignore_warnings)\\n\\n # Make sure all files and paths exists if they are needed\\n if not train_path.exists():\\n msg.fail(\\\"Training data not found\\\", train_path, exits=1)\\n if not dev_path.exists():\\n msg.fail(\\\"Development data not found\\\", dev_path, exits=1)\\n\\n tag_map = {}\\n if tag_map_path is not None:\\n tag_map = srsly.read_json(tag_map_path)\\n\\n # Initialize the model and pipeline\\n pipeline = [p.strip() for p in pipeline.split(\\\",\\\")]\\n if base_model:\\n nlp = load_model(base_model)\\n else:\\n lang_cls = get_lang_class(lang)\\n nlp = lang_cls()\\n # Update tag map with provided mapping\\n nlp.vocab.morphology.tag_map.update(tag_map)\\n\\n msg.divider(\\\"Data format validation\\\")\\n\\n # TODO: Validate data format using the JSON schema\\n # TODO: update once the new format is ready\\n # TODO: move validation to GoldCorpus in order to be able to load from dir\\n\\n # Create the gold corpus to be able to better analyze data\\n loading_train_error_message = \\\"\\\"\\n loading_dev_error_message = \\\"\\\"\\n with msg.loading(\\\"Loading corpus...\\\"):\\n corpus = GoldCorpus(train_path, dev_path)\\n try:\\n train_dataset = list(corpus.train_dataset(nlp))\\n train_dataset_unpreprocessed = list(\\n corpus.train_dataset_without_preprocessing(nlp)\\n )\\n except ValueError as e:\\n loading_train_error_message = f\\\"Training data cannot be loaded: {e}\\\"\\n try:\\n dev_dataset = list(corpus.dev_dataset(nlp))\\n except ValueError as e:\\n loading_dev_error_message = f\\\"Development data cannot be loaded: {e}\\\"\\n if loading_train_error_message or loading_dev_error_message:\\n if loading_train_error_message:\\n msg.fail(loading_train_error_message)\\n if loading_dev_error_message:\\n msg.fail(loading_dev_error_message)\\n sys.exit(1)\\n msg.good(\\\"Corpus is loadable\\\")\\n\\n # Create all gold data here to avoid iterating over the train_dataset constantly\\n gold_train_data = _compile_gold(train_dataset, pipeline)\\n gold_train_unpreprocessed_data = _compile_gold(\\n train_dataset_unpreprocessed, pipeline\\n )\\n gold_dev_data = _compile_gold(dev_dataset, pipeline)\\n\\n train_texts = gold_train_data[\\\"texts\\\"]\\n dev_texts = gold_dev_data[\\\"texts\\\"]\\n\\n msg.divider(\\\"Training stats\\\")\\n msg.text(f\\\"Training pipeline: {', '.join(pipeline)}\\\")\\n for pipe in [p for p in pipeline if p not in nlp.factories]:\\n msg.fail(f\\\"Pipeline component '{pipe}' not available in factories\\\")\\n if base_model:\\n msg.text(f\\\"Starting with base model '{base_model}'\\\")\\n else:\\n msg.text(f\\\"Starting with blank model '{lang}'\\\")\\n msg.text(f\\\"{len(train_dataset)} training docs\\\")\\n msg.text(f\\\"{len(dev_dataset)} evaluation docs\\\")\\n\\n if not len(gold_dev_data):\\n msg.fail(\\\"No evaluation docs\\\")\\n overlap = len(train_texts.intersection(dev_texts))\\n if overlap:\\n msg.warn(f\\\"{overlap} training examples also in evaluation data\\\")\\n else:\\n msg.good(\\\"No overlap between training and evaluation data\\\")\\n if not base_model and len(train_dataset) < BLANK_MODEL_THRESHOLD:\\n text = (\\n f\\\"Low number of examples to train from a blank model ({len(train_dataset)})\\\"\\n )\\n if len(train_dataset) < BLANK_MODEL_MIN_THRESHOLD:\\n msg.fail(text)\\n else:\\n msg.warn(text)\\n msg.text(\\n f\\\"It's recommended to use at least {BLANK_MODEL_THRESHOLD} examples \\\"\\n f\\\"(minimum {BLANK_MODEL_MIN_THRESHOLD})\\\",\\n show=verbose,\\n )\\n\\n msg.divider(\\\"Vocab & Vectors\\\")\\n n_words = gold_train_data[\\\"n_words\\\"]\\n msg.info(\\n f\\\"{n_words} total word(s) in the data ({len(gold_train_data['words'])} unique)\\\"\\n )\\n if gold_train_data[\\\"n_misaligned_words\\\"] > 0:\\n n_misaligned = gold_train_data[\\\"n_misaligned_words\\\"]\\n msg.warn(f\\\"{n_misaligned} misaligned tokens in the training data\\\")\\n if gold_dev_data[\\\"n_misaligned_words\\\"] > 0:\\n n_misaligned = gold_dev_data[\\\"n_misaligned_words\\\"]\\n msg.warn(f\\\"{n_misaligned} misaligned tokens in the dev data\\\")\\n most_common_words = gold_train_data[\\\"words\\\"].most_common(10)\\n msg.text(\\n f\\\"10 most common words: {_format_labels(most_common_words, counts=True)}\\\",\\n show=verbose,\\n )\\n if len(nlp.vocab.vectors):\\n msg.info(\\n f\\\"{len(nlp.vocab.vectors)} vectors ({nlp.vocab.vectors.n_keys} \\\"\\n f\\\"unique keys, {nlp.vocab.vectors_length} dimensions)\\\"\\n )\\n else:\\n msg.info(\\\"No word vectors present in the model\\\")\\n\\n if \\\"ner\\\" in pipeline:\\n # Get all unique NER labels present in the data\\n labels = set(\\n label for label in gold_train_data[\\\"ner\\\"] if label not in (\\\"O\\\", \\\"-\\\", None)\\n )\\n label_counts = gold_train_data[\\\"ner\\\"]\\n model_labels = _get_labels_from_model(nlp, \\\"ner\\\")\\n new_labels = [l for l in labels if l not in model_labels]\\n existing_labels = [l for l in labels if l in model_labels]\\n has_low_data_warning = False\\n has_no_neg_warning = False\\n has_ws_ents_error = False\\n has_punct_ents_warning = False\\n\\n msg.divider(\\\"Named Entity Recognition\\\")\\n msg.info(\\n f\\\"{len(new_labels)} new label(s), {len(existing_labels)} existing label(s)\\\"\\n )\\n missing_values = label_counts[\\\"-\\\"]\\n msg.text(f\\\"{missing_values} missing value(s) (tokens with '-' label)\\\")\\n for label in new_labels:\\n if len(label) == 0:\\n msg.fail(\\\"Empty label found in new labels\\\")\\n if new_labels:\\n labels_with_counts = [\\n (label, count)\\n for label, count in label_counts.most_common()\\n if label != \\\"-\\\"\\n ]\\n labels_with_counts = _format_labels(labels_with_counts, counts=True)\\n msg.text(f\\\"New: {labels_with_counts}\\\", show=verbose)\\n if existing_labels:\\n msg.text(f\\\"Existing: {_format_labels(existing_labels)}\\\", show=verbose)\\n if gold_train_data[\\\"ws_ents\\\"]:\\n msg.fail(f\\\"{gold_train_data['ws_ents']} invalid whitespace entity spans\\\")\\n has_ws_ents_error = True\\n\\n if gold_train_data[\\\"punct_ents\\\"]:\\n msg.warn(f\\\"{gold_train_data['punct_ents']} entity span(s) with punctuation\\\")\\n has_punct_ents_warning = True\\n\\n for label in new_labels:\\n if label_counts[label] <= NEW_LABEL_THRESHOLD:\\n msg.warn(\\n f\\\"Low number of examples for new label '{label}' ({label_counts[label]})\\\"\\n )\\n has_low_data_warning = True\\n\\n with msg.loading(\\\"Analyzing label distribution...\\\"):\\n neg_docs = _get_examples_without_label(train_dataset, label)\\n if neg_docs == 0:\\n msg.warn(f\\\"No examples for texts WITHOUT new label '{label}'\\\")\\n has_no_neg_warning = True\\n\\n if not has_low_data_warning:\\n msg.good(\\\"Good amount of examples for all labels\\\")\\n if not has_no_neg_warning:\\n msg.good(\\\"Examples without occurrences available for all labels\\\")\\n if not has_ws_ents_error:\\n msg.good(\\\"No entities consisting of or starting/ending with whitespace\\\")\\n if not has_punct_ents_warning:\\n msg.good(\\\"No entities consisting of or starting/ending with punctuation\\\")\\n\\n if has_low_data_warning:\\n msg.text(\\n f\\\"To train a new entity type, your data should include at \\\"\\n f\\\"least {NEW_LABEL_THRESHOLD} instances of the new label\\\",\\n show=verbose,\\n )\\n if has_no_neg_warning:\\n msg.text(\\n \\\"Training data should always include examples of entities \\\"\\n \\\"in context, as well as examples without a given entity \\\"\\n \\\"type.\\\",\\n show=verbose,\\n )\\n if has_ws_ents_error:\\n msg.text(\\n \\\"As of spaCy v2.1.0, entity spans consisting of or starting/ending \\\"\\n \\\"with whitespace characters are considered invalid.\\\"\\n )\\n\\n if has_punct_ents_warning:\\n msg.text(\\n \\\"Entity spans consisting of or starting/ending \\\"\\n \\\"with punctuation can not be trained with a noise level > 0.\\\"\\n )\\n\\n if \\\"textcat\\\" in pipeline:\\n msg.divider(\\\"Text Classification\\\")\\n labels = [label for label in gold_train_data[\\\"cats\\\"]]\\n model_labels = _get_labels_from_model(nlp, \\\"textcat\\\")\\n new_labels = [l for l in labels if l not in model_labels]\\n existing_labels = [l for l in labels if l in model_labels]\\n msg.info(\\n f\\\"Text Classification: {len(new_labels)} new label(s), \\\"\\n f\\\"{len(existing_labels)} existing label(s)\\\"\\n )\\n if new_labels:\\n labels_with_counts = _format_labels(\\n gold_train_data[\\\"cats\\\"].most_common(), counts=True\\n )\\n msg.text(f\\\"New: {labels_with_counts}\\\", show=verbose)\\n if existing_labels:\\n msg.text(f\\\"Existing: {_format_labels(existing_labels)}\\\", show=verbose)\\n if set(gold_train_data[\\\"cats\\\"]) != set(gold_dev_data[\\\"cats\\\"]):\\n msg.fail(\\n f\\\"The train and dev labels are not the same. \\\"\\n f\\\"Train labels: {_format_labels(gold_train_data['cats'])}. \\\"\\n f\\\"Dev labels: {_format_labels(gold_dev_data['cats'])}.\\\"\\n )\\n if gold_train_data[\\\"n_cats_multilabel\\\"] > 0:\\n msg.info(\\n \\\"The train data contains instances without \\\"\\n \\\"mutually-exclusive classes. Use '--textcat-multilabel' \\\"\\n \\\"when training.\\\"\\n )\\n if gold_dev_data[\\\"n_cats_multilabel\\\"] == 0:\\n msg.warn(\\n \\\"Potential train/dev mismatch: the train data contains \\\"\\n \\\"instances without mutually-exclusive classes while the \\\"\\n \\\"dev data does not.\\\"\\n )\\n else:\\n msg.info(\\n \\\"The train data contains only instances with \\\"\\n \\\"mutually-exclusive classes.\\\"\\n )\\n if gold_dev_data[\\\"n_cats_multilabel\\\"] > 0:\\n msg.fail(\\n \\\"Train/dev mismatch: the dev data contains instances \\\"\\n \\\"without mutually-exclusive classes while the train data \\\"\\n \\\"contains only instances with mutually-exclusive classes.\\\"\\n )\\n\\n if \\\"tagger\\\" in pipeline:\\n msg.divider(\\\"Part-of-speech Tagging\\\")\\n labels = [label for label in gold_train_data[\\\"tags\\\"]]\\n tag_map = nlp.vocab.morphology.tag_map\\n msg.info(f\\\"{len(labels)} label(s) in data ({len(tag_map)} label(s) in tag map)\\\")\\n labels_with_counts = _format_labels(\\n gold_train_data[\\\"tags\\\"].most_common(), counts=True\\n )\\n msg.text(labels_with_counts, show=verbose)\\n non_tagmap = [l for l in labels if l not in tag_map]\\n if not non_tagmap:\\n msg.good(f\\\"All labels present in tag map for language '{nlp.lang}'\\\")\\n for label in non_tagmap:\\n msg.fail(f\\\"Label '{label}' not found in tag map for language '{nlp.lang}'\\\")\\n\\n if \\\"parser\\\" in pipeline:\\n has_low_data_warning = False\\n msg.divider(\\\"Dependency Parsing\\\")\\n\\n # profile sentence length\\n msg.info(\\n f\\\"Found {gold_train_data['n_sents']} sentence(s) with an average \\\"\\n f\\\"length of {gold_train_data['n_words'] / gold_train_data['n_sents']:.1f} words.\\\"\\n )\\n\\n # check for documents with multiple sentences\\n sents_per_doc = gold_train_data[\\\"n_sents\\\"] / len(gold_train_data[\\\"texts\\\"])\\n if sents_per_doc < 1.1:\\n msg.warn(\\n f\\\"The training data contains {sents_per_doc:.2f} sentences per \\\"\\n f\\\"document. When there are very few documents containing more \\\"\\n f\\\"than one sentence, the parser will not learn how to segment \\\"\\n f\\\"longer texts into sentences.\\\"\\n )\\n\\n # profile labels\\n labels_train = [label for label in gold_train_data[\\\"deps\\\"]]\\n labels_train_unpreprocessed = [\\n label for label in gold_train_unpreprocessed_data[\\\"deps\\\"]\\n ]\\n labels_dev = [label for label in gold_dev_data[\\\"deps\\\"]]\\n\\n if gold_train_unpreprocessed_data[\\\"n_nonproj\\\"] > 0:\\n n_nonproj = gold_train_unpreprocessed_data[\\\"n_nonproj\\\"]\\n msg.info(f\\\"Found {n_nonproj} nonprojective train sentence(s)\\\")\\n if gold_dev_data[\\\"n_nonproj\\\"] > 0:\\n n_nonproj = gold_dev_data[\\\"n_nonproj\\\"]\\n msg.info(f\\\"Found {n_nonproj} nonprojective dev sentence(s)\\\")\\n msg.info(f\\\"{labels_train_unpreprocessed} label(s) in train data\\\")\\n msg.info(f\\\"{len(labels_train)} label(s) in projectivized train data\\\")\\n labels_with_counts = _format_labels(\\n gold_train_unpreprocessed_data[\\\"deps\\\"].most_common(), counts=True\\n )\\n msg.text(labels_with_counts, show=verbose)\\n\\n # rare labels in train\\n for label in gold_train_unpreprocessed_data[\\\"deps\\\"]:\\n if gold_train_unpreprocessed_data[\\\"deps\\\"][label] <= DEP_LABEL_THRESHOLD:\\n msg.warn(\\n f\\\"Low number of examples for label '{label}' \\\"\\n f\\\"({gold_train_unpreprocessed_data['deps'][label]})\\\"\\n )\\n has_low_data_warning = True\\n\\n # rare labels in projectivized train\\n rare_projectivized_labels = []\\n for label in gold_train_data[\\\"deps\\\"]:\\n if gold_train_data[\\\"deps\\\"][label] <= DEP_LABEL_THRESHOLD and \\\"||\\\" in label:\\n rare_projectivized_labels.append(\\n f\\\"{label}: {gold_train_data['deps'][label]}\\\"\\n )\\n\\n if len(rare_projectivized_labels) > 0:\\n msg.warn(\\n f\\\"Low number of examples for {len(rare_projectivized_labels)} \\\"\\n \\\"label(s) in the projectivized dependency trees used for \\\"\\n \\\"training. You may want to projectivize labels such as punct \\\"\\n \\\"before training in order to improve parser performance.\\\"\\n )\\n msg.warn(\\n f\\\"Projectivized labels with low numbers of examples: \\\",\\n \\\", \\\".join(rare_projectivized_labels),\\n show=verbose,\\n )\\n has_low_data_warning = True\\n\\n # labels only in train\\n if set(labels_train) - set(labels_dev):\\n msg.warn(\\n \\\"The following labels were found only in the train data:\\\",\\n \\\", \\\".join(set(labels_train) - set(labels_dev)),\\n show=verbose,\\n )\\n\\n # labels only in dev\\n if set(labels_dev) - set(labels_train):\\n msg.warn(\\n \\\"The following labels were found only in the dev data:\\\",\\n \\\", \\\".join(set(labels_dev) - set(labels_train)),\\n show=verbose,\\n )\\n\\n if has_low_data_warning:\\n msg.text(\\n f\\\"To train a parser, your data should include at \\\"\\n f\\\"least {DEP_LABEL_THRESHOLD} instances of each label.\\\",\\n show=verbose,\\n )\\n\\n # multiple root labels\\n if len(gold_train_unpreprocessed_data[\\\"roots\\\"]) > 1:\\n msg.warn(\\n f\\\"Multiple root labels \\\"\\n f\\\"({', '.join(gold_train_unpreprocessed_data['roots'])}) \\\"\\n f\\\"found in training data. spaCy's parser uses a single root \\\"\\n f\\\"label ROOT so this distinction will not be available.\\\"\\n )\\n\\n # these should not happen, but just in case\\n if gold_train_data[\\\"n_nonproj\\\"] > 0:\\n msg.fail(\\n f\\\"Found {gold_train_data['n_nonproj']} nonprojective \\\"\\n f\\\"projectivized train sentence(s)\\\"\\n )\\n if gold_train_data[\\\"n_cycles\\\"] > 0:\\n msg.fail(\\n f\\\"Found {gold_train_data['n_cycles']} projectivized train sentence(s) with cycles\\\"\\n )\\n\\n msg.divider(\\\"Summary\\\")\\n good_counts = msg.counts[MESSAGES.GOOD]\\n warn_counts = msg.counts[MESSAGES.WARN]\\n fail_counts = msg.counts[MESSAGES.FAIL]\\n if good_counts:\\n msg.good(f\\\"{good_counts} {'check' if good_counts == 1 else 'checks'} passed\\\")\\n if warn_counts:\\n msg.warn(f\\\"{warn_counts} {'warning' if warn_counts == 1 else 'warnings'}\\\")\\n if fail_counts:\\n msg.fail(f\\\"{fail_counts} {'error' if fail_counts == 1 else 'errors'}\\\")\\n sys.exit(1)\",\n \"def featurize(\\n self, data: List[Dict[str, Any]]\\n ) -> Generator[Dict[str, Any], None, None]:\\n raise NotImplementedError\",\n \"def data(self):\\n # Regenerate the extra data\\n if self._req_update_fill:\\n self._generate_fill()\\n if self._req_update_variation:\\n self._generate_variations()\\n\\n output = self._data_words\\n\\n # Add variations\\n where = np.where(output == '')\\n output[where] = self._data_variations[where]\\n\\n # Add fill\\n where = np.where(output == '')\\n output[where] = self._data_fill.reshape(self.shape)[where]\\n\\n return output\",\n \"def preprocess_data(data):\\n def deal_line(line):\\n pos, rating = line.split(',')\\n row, col = pos.split(\\\"_\\\")\\n row = row.replace(\\\"r\\\", \\\"\\\")\\n col = col.replace(\\\"c\\\", \\\"\\\")\\n return int(row), int(col), float(rating)\\n\\n def statistics(data):\\n row = set([line[0] for line in data])\\n col = set([line[1] for line in data])\\n return min(row), max(row), min(col), max(col)\\n\\n # parse each line\\n data = [deal_line(line) for line in data]\\n\\n # do statistics on the dataset.\\n min_row, max_row, min_col, max_col = statistics(data)\\n print(\\\"number of items: {}, number of users: {}\\\".format(max_row, max_col))\\n\\n # build rating matrix.\\n ratings = sp.lil_matrix((max_row, max_col))\\n for row, col, rating in data:\\n ratings[row - 1, col - 1] = rating\\n return ratings\",\n \"def inf(self, data):\\n self.set_data(data)\\n self.infer_post_and_update_samples()\",\n \"def understand_the_data(self,dataset):\\n shape = dataset.shape\\n description = dataset.describe\\n print(shape)\\n print(description)\",\n \"def create_data(self) -> str:\\r\\n s = self.scale\\r\\n mini, maxi = self.get_min_max()\\r\\n diff = maxi - mini\\r\\n\\r\\n output = \\\"const data = {\\\\n\\\"\\r\\n\\r\\n # Create the data for the scatters\\r\\n # TODO: If it's not interactive, labels shouldn't be exported.\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n colormaps = self.scatters[name][\\\"colormap\\\"]\\r\\n cmaps = [None] * len(colormaps)\\r\\n\\r\\n for i, colormap in enumerate(colormaps):\\r\\n if isinstance(colormap, str):\\r\\n cmaps[i] = plt.cm.get_cmap(colormap)\\r\\n else:\\r\\n cmaps[i] = colormap\\r\\n\\r\\n output += name + \\\": {\\\\n\\\"\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\\\"x\\\"]]]\\r\\n output += \\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\\\"y\\\"]]]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\\\"z\\\"]]]\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"labels\\\"] in data:\\r\\n fmt_labels = [\\\"'{0}'\\\".format(s) for s in data[mapping[\\\"labels\\\"]]]\\r\\n output += \\\"labels: [\\\" + \\\",\\\".join(fmt_labels) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"s\\\"] in data:\\r\\n output += \\\"s: [\\\"\\r\\n\\r\\n for series in range(len(data[mapping[\\\"s\\\"]])):\\r\\n output += (\\r\\n \\\"[\\\"\\r\\n + \\\",\\\".join(map(str, np.round(data[mapping[\\\"s\\\"]][series], 3)))\\r\\n + \\\"],\\\\n\\\"\\r\\n )\\r\\n\\r\\n output += \\\"],\\\\n\\\"\\r\\n\\r\\n output += \\\"colors: [\\\\n\\\"\\r\\n for series in range(len(data[mapping[\\\"c\\\"]])):\\r\\n output += \\\"{\\\\n\\\"\\r\\n if mapping[\\\"cs\\\"] in data:\\r\\n colors = np.array(\\r\\n [cmaps[series](x) for x in data[mapping[\\\"c\\\"]][series]]\\r\\n )\\r\\n\\r\\n for i, c in enumerate(colors):\\r\\n hsl = np.array(colour.rgb2hsl(c[:3]))\\r\\n hsl[1] = hsl[1] - hsl[1] * data[mapping[\\\"cs\\\"]][series][i]\\r\\n colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)\\r\\n\\r\\n colors = np.round(colors * 255.0)\\r\\n\\r\\n output += (\\r\\n \\\"r: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 0]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"g: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 1]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"b: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 2]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n elif mapping[\\\"c\\\"] in data:\\r\\n colors = np.array(\\r\\n [cmaps[series](x) for x in data[mapping[\\\"c\\\"]][series]]\\r\\n )\\r\\n colors = np.round(colors * 255.0)\\r\\n output += (\\r\\n \\\"r: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 0]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"g: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 1]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"b: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 2]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n output += \\\"]\\\"\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n point_helper = self.trees[name][\\\"point_helper\\\"]\\r\\n\\r\\n output += name + \\\": {\\\\n\\\"\\r\\n\\r\\n if point_helper is not None and point_helper in self.scatters_data:\\r\\n scatter = self.scatters_data[point_helper]\\r\\n scatter_mapping = self.scatters[point_helper][\\\"mapping\\\"]\\r\\n\\r\\n x_t = []\\r\\n y_t = []\\r\\n z_t = []\\r\\n\\r\\n for i in range(len(data[mapping[\\\"from\\\"]])):\\r\\n x_t.append(scatter[scatter_mapping[\\\"x\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n x_t.append(scatter[scatter_mapping[\\\"x\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n y_t.append(scatter[scatter_mapping[\\\"y\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n y_t.append(scatter[scatter_mapping[\\\"y\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n z_t.append(scatter[scatter_mapping[\\\"z\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n z_t.append(scatter[scatter_mapping[\\\"z\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in x_t]\\r\\n output += f\\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in y_t]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in z_t]\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n else:\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\\\"x\\\"]]]\\r\\n output += \\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\\\"y\\\"]]]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\\\"z\\\"]]]\\r\\n\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"c\\\"] in data:\\r\\n colormap = self.trees[name][\\\"colormap\\\"]\\r\\n cmap = None\\r\\n if isinstance(colormap, str):\\r\\n cmap = plt.cm.get_cmap(colormap)\\r\\n else:\\r\\n cmap = colormap\\r\\n\\r\\n colors = np.array([cmap(x) for x in data[mapping[\\\"c\\\"]]])\\r\\n colors = np.round(colors * 255.0)\\r\\n output += \\\"r: [\\\" + \\\",\\\".join(map(str, colors[:, 0])) + \\\"],\\\\n\\\"\\r\\n output += \\\"g: [\\\" + \\\",\\\".join(map(str, colors[:, 1])) + \\\"],\\\\n\\\"\\r\\n output += \\\"b: [\\\" + \\\",\\\".join(map(str, colors[:, 2])) + \\\"],\\\\n\\\"\\r\\n\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n output += \\\"};\\\\n\\\"\\r\\n\\r\\n return output\",\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 build_data(self):\\n from desiutil.io import combine_dicts\\n # Loop on exposures\\n odict = {}\\n for qanight in self.qa_nights:\\n for qaexp in qanight.qa_exps:\\n # Get the exposure dict\\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\\n odict = combine_dicts(odict, idict)\\n # Finish\\n self.data = odict\",\n \"def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\\n data.gatherData(neat.pop, neat.species)\\n\\n if savePop is True: # Get a sample pop to play with in notebooks\\n global fileName\\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\\n import pickle\\n with open(pref+'.obj', 'wb') as fp:\\n pickle.dump(neat.pop,fp)\\n\\n return data\",\n \"def make_multi_output_data(self, data):\\n confirmed, deceased, recovered = [], [], []\\n for sample in data:\\n confirmed.append(sample[:,0])\\n deceased.append(sample[:,1])\\n recovered.append(sample[:,2])\\n confirmed = np.stack(confirmed)\\n deceased = np.stack(deceased)\\n recovered = np.stack(recovered)\\n return np.stack([confirmed, deceased, recovered])\",\n \"def get_info(data_list):\\n info = [{TEST_SAMPLE: data_elem[TEST_SAMPLE], CONTROL_SAMPLE: data_elem[CONTROL_SAMPLE],\\n N_UP: len(data_elem[REG_UP].index), N_DOWN: len(data_elem[REG_DOWN].index)} for data_elem in data_list]\",\n \"def verbose_data(which_set, data, label):\\n text = ['{} size: {}'.format(which_set, data.shape[0])]\\n for i in range(label.max() + 1):\\n text.append('class{}-{}'.format(i, len(np.where(label == i)[0])))\\n text.append('\\\\n')\\n text = ' '.join(text)\\n tf.logging.info(text)\",\n \"def __generate_input_data(self):\\n if not len(self.input_data) == 0:\\n return\\n\\n try:\\n self.input_data = s.load(open('output/input_data.p', 'rb'))\\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n except:\\n self.input_data = generate_input_data_list(training=False) if self.testing else generate_input_data_list()\\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\\n if not self.classes_to_visualise == None:\\n self.__filter_input_data(self.classes_to_visualise)\\n s.dump([input.tolist() for input in self.input_data], open('output/input_data.p', 'wb'))\\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\\n\\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))\",\n \"def _gather_data(self):\\n for data in self._collection:\\n label = data.label\\n label = disambiguate(label, self._data)\\n self._data[label] = data\",\n \"def get_data(self, data):\\n self.data = {}\\n self.data[ATTR_PM1] = data['current']['values'][0]['value']\\n self.data[ATTR_PM25] = data['current']['values'][1]['value']\\n self.data[ATTR_PM25_LIMIT] = data['current']['standards'][0]['limit']\\n self.data[ATTR_PM25_PERCENT] = (data['current']['standards'][0]\\n ['percent'])\\n self.data[ATTR_PM10] = data['current']['values'][2]['value']\\n self.data[ATTR_PM10_LIMIT] = data['current']['standards'][1]['limit']\\n self.data[ATTR_PM10_PERCENT] = (data['current']['standards'][1]\\n ['percent'])\\n self.data[ATTR_PRESSURE] = data['current']['values'][3]['value']\\n self.data[ATTR_HUMIDITY] = data['current']['values'][4]['value']\\n self.data[ATTR_TEMPERATURE] = data['current']['values'][5]['value']\\n self.data[ATTR_CAQI] = data['current']['indexes'][0]['value']\\n self.data[ATTR_CAQI_LEVEL] = (data['current']['indexes'][0]\\n ['level'].lower().replace('_', ' '))\",\n \"def build(self, data: dict):\",\n \"def pack(data):\\r\\n data['length'] = [len(text) for text in data['text']] \\r\\n data['longest_word_len'] = [longest_word_len(text) for text in data['text']] \\r\\n data['mean_word_len'] = [mean_word_len(text) for text in data['text']] \\r\\n data['subject_len'] = [len(subject) for subject in data['subject']]\\r\\n data['stop_words_num'] = [stop_words_count(text) for text in data['text']]\\r\\n data['pounctuation_num'] = [punctuation_count(text) for text in data['text']]\\r\\n data['text'] = [clean_text(text) for text in data['text']]\",\n \"def test_data_preprocessing(raw_data): \\r\\n\\r\\n # get data output\\r\\n data_output = raw_data[['Submitby Date Time', 'Challenge Manager', 'Challenge Copilot', 'Posting Date Date', 'Track',\\r\\n 'Technology List', 'First Place Prize', 'Num Registrations', 'Total Prize']]\\r\\n with open('cache/extended_columns.pkl', 'rb') as f:\\r\\n extended_columns = pickle.load(f)\\r\\n with open('cache/num_date_columns.pkl', 'rb') as f:\\r\\n max_date_columns = pickle.load(f)\\r\\n \\r\\n data_output = class_binaryzation_for_test(data_output, extended_columns)\\r\\n try:\\r\\n data_output = date_separation1(data_output, max_num_columns=NUM_DATE_COLUMNS)\\r\\n except:\\r\\n data_output = date_separation2(data_output)\\r\\n data_output = money_digitalization(data_output)\\r\\n data_output = get_date_in_days(data_output)\\r\\n data_output['Days from Posting to Submit'] = data_output['Submitby Date Time Days from 2016'] \\\\\\r\\n - data_output['Posting Date Date Days from 2016'] \\r\\n\\r\\n return data_output\",\n \"def data_details_return(data, data_set):\\r\\n data.update(data_resources[data_set])\\r\\n return data\",\n \"def format(self, data):\\r\\n for name, value in sorted(data.items()):\\r\\n line = '{name} = {value}\\\\n'.format(\\r\\n name=name,\\r\\n value=value,\\r\\n )\\r\\n yield line\",\n \"def _format_data(self) -> None:\\n for row in self._db_data:\\n if row['age_start'] is None:\\n continue\\n # entry = {'x': 'Celkem', 'y': int(row['count'])}\\n elif row['age_start'] == 95:\\n entry = {'x': f\\\"{int(row['age_start'])}+\\\", 'y': int(row['count'])}\\n else:\\n entry = {'x': f\\\"{int(row['age_start'])}-{int(row['age_start'])+4}\\\", 'y': int(row['count'])}\\n self.return_data['data'].append(entry)\",\n \"def featurize(data):\\n features = {}\\n missing_weight = False\\n for fieldname in STATIC_FIELDS:\\n # Static fields use -1 to denote that the value was not measured.\\n if data[fieldname][0][1] == -1:\\n features[fieldname] = NAN_REPLACE\\n else:\\n features[fieldname] = float(data[fieldname][0][1])\\n for fieldname in FIELDS:\\n # Time-series fields may or may not be measured, but if they are present\\n # in the dataset, then the value will be valid (i.e. nonnegative).\\n if fieldname in data:\\n values = [float(d[1]) for d in data[fieldname]]\\n if -1 in values and fieldname == 'Weight':\\n # Record that weight was missing for this record id.\\n missing_weight = True\\n field_features = set_features_to_nan(fieldname)\\n else:\\n field_features = {}\\n field_features['{}_min'.format(fieldname)] = min(values)\\n field_features['{}_max'.format(fieldname)] = max(values)\\n field_features['{}_mean'.format(fieldname)] = np.mean(values)\\n field_features['{}_first'.format(fieldname)] = values[0]\\n field_features['{}_last'.format(fieldname)] = values[-1]\\n field_features['{}_diff'.format(fieldname)] = values[-1] - values[0]\\n else:\\n field_features = set_features_to_nan(fieldname)\\n features.update(field_features)\\n return features, missing_weight\",\n \"def test_data():\\n return [Donor(\\\"David Andrews\\\", [200.50, 400.00, 250.75]),\\n Donor(\\\"John Goodfellow\\\", [25.00, 175.50]),\\n Donor(\\\"Mary Suzuki\\\", [75.00, 125.00, 250.00]),\\n Donor(\\\"Bonney Lake\\\", [500.50, 700.75, 500.25]),\\n Donor(\\\"DeMarcus Rollins\\\", [155.00, 165.00])\\n ]\",\n \"def package_data(self, data):\\n pass\",\n \"def genbasictestdata():\\n\\t# These are the different test values we will combine in various ways.\\n\\tarraycode = [('typecode', x) for x in ('bytes', 'bytearray')]\\n\\thassimd = (('simdpresent', 'with'), ('simdpresent', 'without'))\\n\\tarraylen = (('arrayevenodd', 'even'), ('arrayevenodd', 'odd'))\\n\\ttestdata = (('testdataset', 0), ('testdataset', 1), ('testdataset', 2))\\n\\n\\t# The product function produces all possible combinations.\\n\\tcombos = list(itertools.product(arraycode, hassimd, arraylen, testdata))\\n\\n\\n\\t# Convert the data into a list of dictionaries.\\n\\ttestdata = [dict(x) for x in combos]\\n\\n\\tnosimd = {'with' : '', 'without' : ', nosimd=True'}\\n\\n\\t# Now go through the list and add data which goes with the ones we have already defined.\\n\\tfor x in testdata:\\n\\t\\tx['typelabel'] = x['typecode']\\n\\t\\tx['nosimd'] = nosimd[x['simdpresent']]\\n\\n\\t\\tx['tval1'] = testdatasets[x['testdataset']][0]\\n\\t\\tx['tval2'] = testdatasets[x['testdataset']][1]\\n\\t\\tx['tval3'] = testdatasets[x['testdataset']][2]\\n\\t\\tx['tval4'] = testdatasets[x['testdataset']][3]\\n\\n\\treturn testdata\",\n \"def __init__(self, data_array, cui2name):\\n\\t\\tassert isinstance(data_array, xr.DataArray), 'Constructor requires xr.DataArray.'\\n\\n\\t\\tself.data_array = data_array\\n\\t\\tself.data = self.data_array.values\\n\\t\\tself.sources = self.data_array.source.values\\n\\t\\tself.targets = self.data_array.target.values\\n\\t\\tself.metrics = self.data_array.metric.values\\n\\t\\tself.metapaths = self.data_array.metapath.values\\n\\n\\t\\t# Fetch the verbose names\\n\\t\\t#int_rf_df = pd.read_csv('data/impd_cogn_sources.tsv', delimiter='\\\\t')\\n\\t\\t#cui2name = {cui:name for cui, name in zip(int_rf_df.identifier, int_rf_df.name)} \\n\\t\\tself.source_names = np.array([cui2name[source] for source in self.sources])\",\n \"def __str__(self):\\r\\n return f\\\"OPA of {self.data}\\\"\",\n \"def create_data_bunch(data, test=False):\\r\\n examples = [t[0] for t in data if t[0]]\\r\\n target = np.zeros((len(data),), dtype=np.int64)\\r\\n if not test:\\r\\n for i, tweet in enumerate(data):\\r\\n if tweet[1] == 'OFF':\\r\\n target[i] = 1\\r\\n elif tweet[1] == 'NOT':\\r\\n target[i] = 0\\r\\n dataset = Bunch(data=examples, target=target, target_names=['NOT', 'OFF'])\\r\\n return dataset\",\n \"def print_data(self):\\n for chain, gen in self.generations.items():\\n print('Generations for chain %s: %d' % (chain, gen))\\n print('Log likelihood effective size: %d' % self.loglik_effsize)\\n print('Log likelihood relative difference: %f' % self.loglik_rel_diff)\\n print('Max diff: %f' % self.max_diff)\",\n \"def overview(data):\\n\\n printer.table(['Name', 'El', 'Invariom name', 'Model compound'], head=True)\\n for atom in data.iter_atoms(True):\\n printer.table([atom.name, atom.element, atom.invariom_name, atom.invariom.molecule.name])\\n printer.table(done=True)\",\n \"def format_data(arr, dimen, data_type):\\n\\tif type(dimen) != tuple:\\n\\t\\tprint(\\\"Error: expected tuple type.\\\")\\n\\t\\treturn None\\n\\tfactor = int(dimen[1] / dimen[0])\\n\\treturn {\\n\\t\\t\\\"train\\\": [np.reshape(row, dimen) for row in arr],\\n\\t\\t\\\"test\\\": [np.hsplit(row, factor) for row in arr]\\n\\t}.get(data_type)\",\n \"def gen_data(self):\\n\\n # 1，read the source text\\n inputs, labels = self.read_data()\\n print(\\\"read finished\\\")\\n\\n # 2. word label index\\n word_to_index, label_to_index = self.gen_word_label_index()\\n # print(\\\"word_to_index\\\",word_to_index)\\n # print(\\\"label_to_index\\\",label_to_index)\\n print(\\\"vocab process finished\\\")\\n #\\n # 3，input to index\\n inputs_idx = self.trans_to_index(inputs, word_to_index)\\n # print((inputs_idx))\\n print(\\\"index transform finished\\\")\\n #\\n # 4, padding\\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\\n # print(inputs_idx)\\n print(\\\"padding finished\\\")\\n\\n # 6，label to index\\n labels_idx = self.trans_label_to_index(labels, label_to_index)\\n print(\\\"label index transform finished\\\")\\n\\n return np.array(inputs_idx), np.array(labels_idx)\",\n \"def olympic_sprints(data_set='rogers_girolami_data'):\\r\\n X = np.zeros((0, 2))\\r\\n Y = np.zeros((0, 1))\\r\\n for i, dataset in enumerate([olympic_100m_men,\\r\\n olympic_100m_women,\\r\\n olympic_200m_men,\\r\\n olympic_200m_women,\\r\\n olympic_400m_men,\\r\\n olympic_400m_women]):\\r\\n data = dataset()\\r\\n year = data['X']\\r\\n time = data['Y']\\r\\n X = np.vstack((X, np.hstack((year, np.ones_like(year)*i))))\\r\\n Y = np.vstack((Y, time))\\r\\n data['X'] = X\\r\\n data['Y'] = Y\\r\\n data['info'] = \\\"Olympics sprint event winning for men and women to 2008. Data is from Rogers and Girolami's First Course in Machine Learning.\\\"\\r\\n return data_details_return({\\r\\n 'X': X,\\r\\n 'Y': Y,\\r\\n 'info': \\\"Olympics sprint event winning for men and women to 2008. Data is from Rogers and Girolami's First Course in Machine Learning.\\\",\\r\\n 'output_info': {\\r\\n 0:'100m Men',\\r\\n 1:'100m Women',\\r\\n 2:'200m Men',\\r\\n 3:'200m Women',\\r\\n 4:'400m Men',\\r\\n 5:'400m Women'}\\r\\n }, data_set)\",\n \"def build_data(self):\\n return self.mean, self.sigma\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def test_dataset_autogen(autogen_dataset):\\n train_dummy = \\\"eget, venenatis a, magna. Lorem ipsum dolor sit amet, consectetuer\\\"\\n val_dummy = \\\"leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis,\\\"\\n test_dummy = \\\"turpis egestas. Aliquam fringilla cursus purus. Nullam scelerisque neque sed\\\"\\n\\n assert autogen_dataset.train[0][0] == train_dummy\\n assert autogen_dataset.train[0][1] == '8'\\n assert len(autogen_dataset.train) == 64\\n\\n assert autogen_dataset.val[0][0] == val_dummy\\n assert autogen_dataset.val[0][1] == '1'\\n assert len(autogen_dataset.val) == 16\\n\\n assert autogen_dataset.test[0][0] == test_dummy\\n assert autogen_dataset.test[0][1] == '6'\\n assert len(autogen_dataset.test) == 20\",\n \"def gendata(varname, vardict, avardict, alldatastatements):\\n \\n # parameters: varnamein, varnameout, unitcategory, source\\n datatemplate = \\\"\\\"\\\"DATA: %(varnameout)s = col(source(%(source)s), name(\\\"%(varnamein)s\\\") %(unitcategory)s)\\\"\\\"\\\"\\n \\n if not varname:\\n return \\\"\\\"\\n varnamelc = varname.lower()\\n if varnamelc in alldatastatements:\\n return \\\"\\\"\\n alldatastatements.add(varnamelc)\\n \\n if vardict[varname].VariableLevel in ['nominal','ordinal']:\\n unitcategory = iscat\\n else:\\n unitcategory = \\\"\\\"\\n varnameout = avardict.getAName(varname)\\n dtc = []\\n dtc.append(datatemplate % {'varnamein': varname, \\\"varnameout\\\": varname, \\n \\\"unitcategory\\\": unitcategory, \\\"source\\\" : \\\"s\\\"})\\n dtc.append(datatemplate % {'varnamein': varname, \\\"varnameout\\\": varnameout, \\n \\\"unitcategory\\\": unitcategory, \\\"source\\\" : \\\"t\\\"})\\n return dtc\",\n \"def generate_synthetic_matrix_factorization_data(xdim=6, ydim=10, nsamples=1000, A_condition_number=1e-10):\\n Atrue = np.linspace(1, A_condition_number, ydim\\n ).reshape(-1, 1) * np.random.rand(ydim, xdim)\\n # the inputs\\n X = np.random.randn(xdim, nsamples)\\n # the y's to fit\\n Ytrue = Atrue.dot(X)\\n data = (X.T, Ytrue.T)\\n\\n return data\",\n \"def dataConversion(data, I, attr, Na, noise, alpha, R=True):\\n n = data.shape[0]\\n m = data.shape[1]\\n\\n data_dict = {}\\n structure = []\\n # Transform the data to a dictionary and get the data structure\\n for j in range(m):\\n temp_data = data[:, j].reshape(-1, 1)\\n enc = preprocessing.OneHotEncoder(categories='auto')\\n enc.fit(temp_data)\\n data_dict[j] = enc.transform(temp_data).toarray()\\n structure.append(len(set(data[:, j])))\\n\\n x = np.rint(I * n).astype(int)\\n # The indices of the records to which noise will be added\\n row_inds = np.random.choice(range(n), x, replace=False)\\n # For each corrupted observation:\\n for i in row_inds:\\n if R:\\n attr_inds = np.random.choice(m, size=Na, replace=False)\\n else:\\n # Specify the attributes to which noise will be added\\n attr_inds = attr\\n # For each specified attribute\\n for j in attr_inds:\\n # Divide 'noise' over all the columns belonging to that attribute\\n noise_individuals = np.random.dirichlet(np.ones(structure[j] - 1) * alpha, size=1) * noise\\n t = 0\\n for k in range(structure[j]):\\n if data_dict[j][i, k] == 0 and t < noise_individuals.shape[1]:\\n data_dict[j][i, k] = noise_individuals[0][t]\\n t += 1\\n elif data_dict[j][i, k] == 1:\\n data_dict[j][i, k] -= noise\\n new_data = np.concatenate([data_dict[k] for k in data_dict.keys()], axis=1)\\n\\n # One-hot encoding GT:\\n enc = OneHotEncoder(categories='auto')\\n enc.fit(data)\\n GT = enc.transform(data).toarray()\\n\\n return GT, new_data, structure, row_inds\",\n \"def generate_basic_report(self, from_time, to_time, raw_data):\\n\\n\\t\\t# Transform the raw data into something more reporting friendly\\n\\t\\tstructured_data = self.build_data_structure(from_time, to_time, raw_data)\\n\\n\\t\\t# Now build the report from the structured data.\\n\\t\\treport = []\\n\\t\\tfor key, value in structured_data.items():\\n\\t\\t\\treport.append([key, len(value), len(set(value))])\\n\\n\\t\\t# Return the actual report data for further processing.\\n\\t\\treturn report\",\n \"def __init__(self, data):\\n\\n self.produce_csv = data['produce_csv']\\n self.produce_graphics = data['produce_graphics']\\n self.report_name = data['report_name']\\n self.file_name = self.report_name + '.csv'\\n self.annual_file_name = self.report_name + '_annual.csv'\\n self.csv_dir = ''\\n self.diagnostic_dir = ''\\n\\n self.daily_variables = {\\n 'year': ['time.cal_year', '', []],\\n 'j_day': ['time.day', '', []]\\n }\\n\\n self.annual_variables = {\\n 'year': ['time.cal_year', '', 0]\\n }\",\n \"def process_data(self, data):\\n\\n for feat, vals in zip(data.names, data.feats):\\n for val in vals:\\n self.fvals[feat][val][1] = Literal(feature=feat, value=val)\",\n \"def _format_nom_ins(col: str, data: Dict[str, Any], nrows: int, cfg: Config) -> Any:\\n # list of insights\\n ins: List[Dict[str, str]] = []\\n\\n if data[\\\"chisq\\\"][1] > cfg.insight.uniform__threshold:\\n ins.append({\\\"Uniform\\\": f\\\"/*start*/{col}/*end*/ is uniformly distributed\\\"})\\n\\n pmiss = round((1 - (data[\\\"npres\\\"] / nrows)) * 100, 2)\\n if pmiss > cfg.insight.missing__threshold:\\n nmiss = nrows - data[\\\"npres\\\"]\\n ins.append({\\\"Missing\\\": f\\\"/*start*/{col}/*end*/ has {nmiss} ({pmiss}%) missing values\\\"})\\n\\n if data[\\\"nuniq\\\"] > cfg.insight.high_cardinality__threshold:\\n uniq = data[\\\"nuniq\\\"]\\n msg = f\\\"/*start*/{col}/*end*/ has a high cardinality: {uniq} distinct values\\\"\\n ins.append({\\\"High Cardinality\\\": msg})\\n\\n if data[\\\"nuniq\\\"] == cfg.insight.constant__threshold:\\n val = data[\\\"bar\\\"].index[0]\\n ins.append({\\\"Constant\\\": f'/*start*/{col}/*end*/ has constant value \\\"{val}\\\"'})\\n\\n if data[\\\"min_len\\\"] == data[\\\"max_len\\\"]:\\n length = data[\\\"min_len\\\"]\\n ins.append({\\\"Constant Length\\\": f\\\"/*start*/{col}/*end*/ has constant length {length}\\\"})\\n\\n if data[\\\"nuniq\\\"] == data[\\\"npres\\\"]:\\n ins.append({\\\"Unique\\\": f\\\"/*start*/{col}/*end*/ has all distinct values\\\"})\\n\\n # list of insight messages\\n ins_msg_list = [list(ins.values())[0] for ins in ins]\\n\\n return ins_msg_list, ins\",\n \"def print_data(data):\\n print(str(data))\\n return data\",\n \"def setSampleInfo(self, data: list):\\n repSampleInfo = [\\n ['イベント', data[0]],\\n ['シリアル', data[1]],\\n ]\\n self._sample_info = repSampleInfo\",\n \"def extract(self, data):\",\n \"def format_input_data(positive_data: List[str], negative_data: list) -> Tuple[List[Tuple[str, int]],\\n List[Tuple[str, int]]]:\\n # 1 = positive, 0 = negative\\n positive_input_data = []\\n negative_input_data = []\\n\\n for sentence_data in positive_data:\\n positive_input_data.append((sentence_data, 1))\\n\\n for sentence_data in negative_data:\\n negative_input_data.append((sentence_data, 0))\\n\\n return positive_input_data, negative_input_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6068046","0.5998432","0.5993212","0.5823532","0.58189803","0.5803318","0.568087","0.5674967","0.56731486","0.5647276","0.5622952","0.56198436","0.5607101","0.55947775","0.55919886","0.5589899","0.5589657","0.5586132","0.55597925","0.5534209","0.5532182","0.55299217","0.5525494","0.552317","0.54645014","0.54607356","0.5451283","0.54425436","0.540897","0.54079956","0.5405895","0.53932387","0.5390159","0.5386525","0.5384352","0.5374616","0.53682107","0.5362242","0.5360603","0.53556985","0.5331638","0.53291094","0.5325626","0.53228575","0.5314144","0.5311082","0.5303118","0.52964056","0.52961904","0.52768385","0.5267393","0.5265845","0.52625114","0.52621937","0.52594125","0.52589697","0.5258202","0.52558434","0.52496713","0.52319413","0.5219518","0.52187514","0.5217144","0.52093905","0.5208471","0.5208265","0.5202975","0.5202922","0.5199384","0.519814","0.5192356","0.51887685","0.518754","0.51774544","0.5173983","0.5167499","0.5162231","0.5153056","0.51515925","0.5142068","0.5139194","0.5136554","0.5131052","0.5130875","0.5128698","0.5126321","0.51227623","0.51209825","0.51201564","0.5117376","0.5115467","0.5111615","0.5111042","0.5109577","0.51062137","0.51038265","0.51036185","0.51035756","0.5092603","0.5091074","0.50896716"],"string":"[\n \"0.6068046\",\n \"0.5998432\",\n \"0.5993212\",\n \"0.5823532\",\n \"0.58189803\",\n \"0.5803318\",\n \"0.568087\",\n \"0.5674967\",\n \"0.56731486\",\n \"0.5647276\",\n \"0.5622952\",\n \"0.56198436\",\n \"0.5607101\",\n \"0.55947775\",\n \"0.55919886\",\n \"0.5589899\",\n \"0.5589657\",\n \"0.5586132\",\n \"0.55597925\",\n \"0.5534209\",\n \"0.5532182\",\n \"0.55299217\",\n \"0.5525494\",\n \"0.552317\",\n \"0.54645014\",\n \"0.54607356\",\n \"0.5451283\",\n \"0.54425436\",\n \"0.540897\",\n \"0.54079956\",\n \"0.5405895\",\n \"0.53932387\",\n \"0.5390159\",\n \"0.5386525\",\n \"0.5384352\",\n \"0.5374616\",\n \"0.53682107\",\n \"0.5362242\",\n \"0.5360603\",\n \"0.53556985\",\n \"0.5331638\",\n \"0.53291094\",\n \"0.5325626\",\n \"0.53228575\",\n \"0.5314144\",\n \"0.5311082\",\n \"0.5303118\",\n \"0.52964056\",\n \"0.52961904\",\n \"0.52768385\",\n \"0.5267393\",\n \"0.5265845\",\n \"0.52625114\",\n \"0.52621937\",\n \"0.52594125\",\n \"0.52589697\",\n \"0.5258202\",\n \"0.52558434\",\n \"0.52496713\",\n \"0.52319413\",\n \"0.5219518\",\n \"0.52187514\",\n \"0.5217144\",\n \"0.52093905\",\n \"0.5208471\",\n \"0.5208265\",\n \"0.5202975\",\n \"0.5202922\",\n \"0.5199384\",\n \"0.519814\",\n \"0.5192356\",\n \"0.51887685\",\n \"0.518754\",\n \"0.51774544\",\n \"0.5173983\",\n \"0.5167499\",\n \"0.5162231\",\n \"0.5153056\",\n \"0.51515925\",\n \"0.5142068\",\n \"0.5139194\",\n \"0.5136554\",\n \"0.5131052\",\n \"0.5130875\",\n \"0.5128698\",\n \"0.5126321\",\n \"0.51227623\",\n \"0.51209825\",\n \"0.51201564\",\n \"0.5117376\",\n \"0.5115467\",\n \"0.5111615\",\n \"0.5111042\",\n \"0.5109577\",\n \"0.51062137\",\n \"0.51038265\",\n \"0.51036185\",\n \"0.51035756\",\n \"0.5092603\",\n \"0.5091074\",\n \"0.50896716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83791,"cells":{"query":{"kind":"string","value":"Get the optimal result among collection data."},"document":{"kind":"string","value":"def compute_collection_result(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 GetPts(self):\n return self.best","def getResults():","def _compute_best_value(self):\n reduced_cs = []\n concerned_vars = set()\n\n for c in self.utilities:\n asgt = filter_assignment_dict(self._neighbors_values, c.dimensions)\n reduced_cs.append(c.slice(asgt))\n concerned_vars.update(c.dimensions)\n var_val, rel_val = find_arg_optimal(\n self.variable,\n lambda x: functools.reduce(operator.add, [f(x) for f in reduced_cs]),\n self._mode,\n )\n # Add the cost for each variable value if any\n for var in concerned_vars:\n if var.name == self.name:\n rel_val += var.cost_for_val(self.current_value)\n else:\n rel_val += var.cost_for_val(self._neighbors_values[var.name])\n\n return var_val, rel_val","def _compute_results(self):\n self.Y_best = best_value(self.Y)\n self.x_opt = self.X[np.argmin(self.Y),:]\n self.fx_opt = np.min(self.Y)\n self.distance = self._compute_distance_betw_consecutive_x()","def optimal(count):\n\n return _optimal(start, count)[0]","def get_n_best(self):\n pass","def best_value(self):\r\n return self._best_value","def compute(self, result_file_dict):\r\n for part in self.parts:\r\n #=====================Need to change, temporal=========================\r\n if part == 'train':\r\n continue # because the train not have the label\r\n #=======================================================================\r\n gt = self.gt_dict[part]\r\n result_file = result_file_dict[part]\r\n # import ipdb; ipdb.set_trace()\r\n for key, item in result_file.items():\r\n self._result_name = item\r\n # score_records, num_videos = self.load_results(result_file)\r\n score_records, num_videos = self.load_results(item)\r\n logger.info(f'Compute Metric of {item}')\r\n assert num_videos == len(gt), f'the number of saved videos does not match the ground truth, {num_videos} != {len(gt)}'\r\n temp_result = self.eval_method(score_records, gt, str(key))\r\n if temp_result > self.optimal_resulst:\r\n self.optimal_resulst = temp_result\r\n \r\n return self.optimal_resulst","def _SD_optimal(t):","def get_best(self):\n scores, ids = self.sort_best()\n return scores[1], ids[1]","def best_metric(\n self, return_step: bool = False\n ) -> Union[\n None,\n float,\n Tuple[float, int],\n Tuple[None, None],\n Dict[str, Union[float, None]],\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\n ]:\n res = self.compute_all()\n if isinstance(res, list):\n rank_zero_warn(\n \"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\"\n \" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\"\n \"Returning `None` instead. Please consider \"\n )\n if return_step:\n return None, None\n return None\n\n if isinstance(self._base_metric, Metric):\n fn = torch.max if self.maximize else torch.min\n try:\n value, idx = fn(res, 0)\n if return_step:\n return value.item(), idx.item()\n return value.item()\n except (ValueError, RuntimeError) as error:\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric: {error}\"\n \"this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n if return_step:\n return None, None\n return None\n\n else: # this is a metric collection\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\n value, idx = {}, {}\n for i, (k, v) in enumerate(res.items()):\n try:\n fn = torch.max if maximize[i] else torch.min\n out = fn(v, 0)\n value[k], idx[k] = out[0].item(), out[1].item()\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric for metric {k}:\"\n f\"{error} this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n value[k], idx[k] = None, None\n\n if return_step:\n return value, idx\n return value","def calculateOptimal(self) -> (list, int):\n\t\tcombinations = list(itertools.product(*self.clusters))\n\t\tmin_dist = 1000000\n\t\tmin_combination = None\n\t\tfor combination in combinations:\n\t\t\tdist = super().step(combination)\n\t\t\tif(dist < min_dist):\n\t\t\t\tmin_dist = dist\n\t\t\t\tmin_combination = combination\n\t\treturn (min_combination, min_dist)","def _compute_best_value(self):\n asgt = self._neighbors_values.copy()\n best_cost, best_val = None, []\n\n for v in self._variable.domain:\n asgt[self.variable.name] = v\n c = self._compute_cost(**asgt)\n if (\n best_cost is None\n or (best_cost > c and self._mode == \"min\")\n or (best_cost < c and self._mode == \"max\")\n ):\n best_cost = c\n best_val = [v]\n elif best_cost == c:\n best_val.append(v)\n\n return best_val, best_cost","def get_bests(self):\n set_names = [\"training\", \"hp_selection\", \"validation\"]\n run_tec_conf_set = recursivedict()\n validation = self._campaign_configuration['General']['validation']\n hp_selection = self._campaign_configuration['General']['hp_selection']\n if (validation, hp_selection) in {(\"All\", \"All\"), (\"Extrapolation\", \"All\"), (\"All\", \"HoldOut\"), (\"HoldOut\", \"All\"), (\"HoldOut\", \"HoldOut\"), (\"Extrapolation\", \"HoldOut\")}:\n # For each run, for each technique the best configuration\n run_tec_best_conf = recursivedict()\n\n # Hyperparameter search\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n technique = conf.technique\n run_tec_conf_set[run][technique][str(conf.get_signature()[4:])] = conf.mapes\n # First experiment for this technique or better than the current best\n if technique not in run_tec_best_conf[run] or conf.mapes[\"hp_selection\"] < run_tec_best_conf[run][technique].mapes[\"hp_selection\"]:\n run_tec_best_conf[run][technique] = conf\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"-->Printing results for run %s\", str(run))\n overall_run_best = None\n # Print data of single techniques\n for technique in run_tec_best_conf[run]:\n temp = run_tec_best_conf[run][technique]\n self._logger.info(\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, temp.get_signature()[4:], temp.mapes[\"training\"], temp.mapes[\"hp_selection\"], temp.mapes[\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or temp.mapes[\"hp_selection\"] < overall_run_best.mapes[\"hp_selection\"]:\n overall_run_best = temp\n best_model_description = overall_run_best.print_model()\n self._logger.info(\"<--Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best.get_signature()[3:], \"(\" + best_model_description + \")\" if best_model_description else \"\", overall_run_best.mapes[\"training\"], overall_run_best.mapes[\"hp_selection\"], overall_run_best.mapes[\"validation\"])\n\n elif (validation, hp_selection) in {(\"KFold\", \"All\"), (\"KFold\", \"HoldOut\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each fold, for each technique, the best configuration\n run_fold_tec_best_conf = recursivedict()\n\n # Hyperparameter search inside each fold\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n fold = int(conf.get_signature()[1].replace(\"f\", \"\"))\n technique = conf.technique\n if \"hp_selection\" not in run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] + conf.mapes[set_name] / folds\n # First experiment for this fold+technique or better than the current best\n if technique not in run_fold_tec_best_conf[run][fold] or conf.mapes[\"hp_selection\"] < run_fold_tec_best_conf[run][fold][technique].mapes[\"hp_selection\"]:\n run_fold_tec_best_conf[run][fold][technique] = conf\n\n # Aggregate different folds (only the value of the mapes)\n run_tec_set = recursivedict()\n for run in run_fold_tec_best_conf:\n for fold in run_fold_tec_best_conf[run]:\n for tec in run_fold_tec_best_conf[run][fold]:\n if \"hp_selection\" not in run_tec_set[run][technique]:\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = 0\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = run_fold_tec_best_conf[run][fold][tec].mapes[set_name]\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", str(run))\n overall_run_best = ()\n # Print data of single techniques\n for technique in run_tec_set[run]:\n self._logger.info(\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, run_tec_set[run][technique][\"training\"], run_tec_set[run][technique][\"hp_selection\"], run_tec_set[run][technique][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or run_tec_set[run][technique][\"hp_selection\"] < overall_run_best[1][\"hp_selection\"]:\n overall_run_best = (technique, run_tec_set[run][technique])\n\n self._logger.info(\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1][\"training\"], overall_run_best[1][\"hp_selection\"], overall_run_best[1][\"validation\"])\n\n # Overall best will contain as first argument the technique with the best (across runs) average (across folds) mape on validation; now we consider on all the runs and on all the folds the configuraiton of this technique with best validation mape\n\n elif (validation, hp_selection) in {(\"All\", \"KFold\"), (\"HoldOut\", \"KFold\"), (\"Extrapolation\", \"KFold\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each technique, for each configuration, the aggregated mape\n run_tec_conf_set = recursivedict()\n\n # Hyperparameter search aggregating over folders\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n fold = int(conf.get_signature()[2].replace(\"f\", \"\"))\n technique = conf.technique\n configuration = str(conf.get_signature()[4:])\n if \"hp_selection\" not in run_tec_conf_set[run][technique][configuration]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + conf.mapes[set_name] / folds\n\n # Select the best configuration for each technique across different folders\n run_tec_best_conf = recursivedict()\n for run in run_tec_conf_set:\n for tec in run_tec_conf_set[run]:\n for conf in run_tec_conf_set[run][tec]:\n if tec not in run_tec_best_conf[run] or run_tec_conf_set[run][tec][conf][\"hp_selection\"] < run_tec_best_conf[run][tec][1][\"hp_selection\"]:\n run_tec_best_conf[run][tec] = (conf, run_tec_conf_set[run][tec][conf])\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", run)\n overall_run_best = () # (technique, configuration, mapes)\n # Print data of single techniques\n for technique in run_tec_best_conf[run]:\n temp = run_tec_best_conf[run][technique]\n self._logger.info(\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, temp[0], temp[1][\"training\"], temp[1][\"hp_selection\"], temp[1][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or temp[1][\"hp_selection\"] < overall_run_best[2][\"hp_selection\"]:\n overall_run_best = (technique, temp[0], temp[1])\n\n self._logger.info(\"---Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1], overall_run_best[2][\"training\"], overall_run_best[2][\"hp_selection\"], overall_run_best[2][\"validation\"])\n\n elif (validation, hp_selection) in {(\"KFold\", \"KFold\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each external fold, for each technique, the aggregated mape\n run_efold_tec_conf_set = recursivedict()\n\n # Hyperparameter search aggregating over internal folders\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n ext_fold = int(conf.get_signature()[2].replace(\"f\", \"\"))\n technique = conf.technique\n configuration = str(conf.get_signature()[4:])\n if \"hp_selection\" not in run_tec_conf_set[run][technique][configuration]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\n if configuration not in run_efold_tec_conf_set[run][ext_fold][technique]:\n for set_name in set_names:\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\n\n # Select the best configuration for each technique in each external fold across different internal folders\n run_efold_tec_best_conf = recursivedict()\n for run in run_efold_tec_conf_set:\n for efold in run_efold_tec_conf_set[run]:\n for tec in run_efold_tec_conf_set[run][efold]:\n for conf in run_efold_tec_conf_set[run][efold][tec]:\n if conf not in run_efold_tec_best_conf[run][efold][tec] or run_efold_tec_conf_set[run][efold][tec][conf][\"hp_selection\"] < run_efold_tec_best_conf[run][efold][tec][1][\"hp_selection\"]:\n run_efold_tec_best_conf[run][efold][tec] = (conf, run_efold_tec_conf_set[run][efold][tec][conf], run_efold_tec_conf_set[run][efold][tec][conf])\n\n # Aggregate on external folds\n run_tec_set = recursivedict()\n for run in run_efold_tec_best_conf:\n for efold in run_efold_tec_best_conf[run]:\n for tec in run_efold_tec_best_conf[run][efold]:\n if \"hp_selection\" not in run_tec_set[run][tec]:\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = 0\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = run_tec_set[run][tec][set_name] + run_efold_tec_best_conf[run][efold][tec][1][set_name]\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", run)\n overall_run_best = ()\n # Print data of single techniques\n for technique in run_tec_set[run]:\n self._logger.info(\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, run_tec_set[run][technique][\"training\"], run_tec_set[run][technique][\"hp_selection\"], run_tec_set[run][technique][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or run_tec_set[run][technique][\"hp_selection\"] < overall_run_best[1][\"hp_selection\"]:\n overall_run_best = (technique, run_tec_set[run][technique])\n\n self._logger.info(\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1][\"training\"], overall_run_best[1][\"hp_selection\"], overall_run_best[1][\"validation\"])\n\n else:\n self._logger.error(\"Unexpected combination: %s\", str((validation, hp_selection)))\n sys.exit(1)\n best_confs = {}\n best_technique = None\n for conf in self._exp_confs:\n technique = conf.technique\n if technique not in best_confs or conf.mapes[\"validation\"] < best_confs[technique].mapes[\"validation\"]:\n best_confs[technique] = conf\n for technique in best_confs:\n if not best_technique or best_confs[technique].mapes[\"validation\"] < best_confs[best_technique].mapes[\"validation\"]:\n best_technique = technique\n if bool(self._campaign_configuration['General']['details']):\n for run in run_tec_conf_set:\n for tec in run_tec_conf_set[run]:\n for conf in run_tec_conf_set[run][tec]:\n assert \"hp_selection\" in run_tec_conf_set[run][tec][conf]\n assert \"validation\" in run_tec_conf_set[run][tec][conf], \"training MAPE not found for \" + str(run) + str(tec) + str(conf)\n self._logger.info(\"Run %s - Technique %s - Conf %s - Training MAPE %f - Test MAPE %f\", str(run), ec.enum_to_configuration_label[tec], str(conf), run_tec_conf_set[run][tec][conf][\"hp_selection\"], run_tec_conf_set[run][tec][conf][\"validation\"])\n return best_confs, best_technique","def save_cma_optimization_results(self, es):\n # code extra verbose to understand what is going on\n generation = es.result.iterations\n evals = es.result.evaluations # number of evals at start of each gen\n xfavorite = es.result.xfavorite # center of distribution, best est\n stds = es.result.stds # stds of distribution, stds of xfavorite\n fbest = es.result.fbest # best ever measured\n xbest = es.result.xbest # coordinates of best ever measured\n evals_best = es.result.evals_best # index of best measurement\n\n if not self.minimize_optimization:\n fbest = -fbest\n\n results_array = np.concatenate([[generation, evals],\n xfavorite, stds,\n [fbest], xbest, [evals_best]])\n if (not 'optimization_result'\n in self.data_object[EXPERIMENTAL_DATA_GROUP_NAME].keys()):\n opt_res_grp = self.data_object[EXPERIMENTAL_DATA_GROUP_NAME]\n self.opt_res_dset = opt_res_grp.create_dataset(\n 'optimization_result', (0, len(results_array)),\n maxshape=(None, len(results_array)),\n dtype='float64')\n\n # FIXME: Jan 2018, add the names of the parameters to column names\n self.opt_res_dset.attrs['column_names'] = h5d.encode_to_utf8(\n 'generation, ' + 'evaluations, ' +\n 'xfavorite, ' * len(xfavorite) +\n 'stds, '*len(stds) +\n 'fbest, ' + 'xbest, '*len(xbest) +\n 'best evaluation,')\n\n old_shape = self.opt_res_dset.shape\n new_shape = (old_shape[0]+1, old_shape[1])\n self.opt_res_dset.resize(new_shape)\n self.opt_res_dset[-1, :] = results_array","def compute_cost_clarans(data, _cur_choice):\n # modified from that of CLARA\n total_cost = 0.0\n medoids = {}\n for idx in _cur_choice:\n medoids[idx] = []\n\n for i in list(data.index):\n choice = -1\n min_cost = np.inf\n for m in medoids:\n # fast_euclidean from CLARA\n tmp = np.linalg.norm(data.loc[m] - data.loc[i])\n if tmp < min_cost:\n choice = m\n min_cost = tmp\n\n medoids[choice].append(i)\n total_cost += min_cost\n # print(\"total_cost: \", total_cost)\n return total_cost, medoids","def get_result(self, collector_set):\n\t\traise NotImplementedError","def get_winners(self):\n\n if self.optimal is not None:\n return self.optimal\n clean_proposals = self.cleaner.create_scenarios(self.proposals)\n self.optimal = self.optimizer.optimize(clean_proposals)\n return self.optimal","def ml_result(self, var, e):\n\t\tdist = self.enumerate_ask(var, e)\n\t\treturn max(dist.items(), key=lambda x:x[1])[0]","def _get_best(self, populations, func):\n best = None\n for population in populations:\n for item in population:\n if not best:\n best = item\n elif func.fit(*item) > func.fit(*best):\n best = item\n return best","def _get_lip_best(self) -> float:\n pass","def get_best_result(self) -> Optional[Tuple[int, Module, Dict[str, Dict[str, Tensor]], float, List[Dict]]]:\n if self._best_task_id is not None:\n compact_model = torch.load(Path(self._log_dir_root, 'best_result', 'model.pth'))\n compact_model_masks = torch.load(Path(self._log_dir_root, 'best_result', 'masks.pth'))\n with Path(self._log_dir_root, 'best_result', 'config_list.json').open('r') as f:\n config_list = json_tricks.load(f)\n return self._best_task_id, compact_model, compact_model_masks, self._best_score, config_list\n return None","def compute_statistics(self):","def _choose_best_option(self):","def result(self):\n return min(self.population, key=lambda individual: individual.get_fitness())","def get_best_individual(self):\n return self._best_indv","def get_so_results(self, save=False):\n #Read through output files\n parameters=self.get_optimization_parameters(friendly=True)\n parameterRange = range(len(parameters))\n\n results = []\n\n for i in parameterRange:\n result = {\n 'name': parameters[i][0],\n 'max_result': '?',\n 'max_evals' : '?',\n 'max_cpu' : '?',\n 'min_result' : '?',\n 'min_evals' : '?',\n 'min_cpu' : '?',\n }\n #Read min and max files\n for max in [0, 1]:\n iterator = 0\n \n try:\n file = open(os.path.join(self.path, 'output_1.%d.txt' % (2*i + max)),'r')\n output=[None for r in range(4)]\n for f in file.readlines():\n value = f.rstrip('\\n') #Read the file line by line.\n #Line 0: seperator. Line 1: Evals. Line 2: Time. Line 3: result\n index=parameterRange.index(i)\n output[iterator] = value\n iterator = (iterator + 1)%4\n file.close()\n evals = output[1].split(' ')[2]\n cpu_time = output[2].split(' ')[2]\n sens_result = output[3]\n \n if max == 0:\n max_str = 'max'\n else:\n max_str = 'min'\n result[max_str + '_result'] = sens_result\n result[max_str + '_cpu'] = cpu_time\n result[max_str + '_evals'] = evals\n \n except:\n raise\n \n results.append(result)\n \n #Finally, if save==True, write these results to file results.txt\n if save:\n if not os.path.isfile(os.path.join(self.path, 'results.txt')):\n results_file = open(os.path.join(self.path, 'results.txt'), 'w')\n header_line = 'Parameter name\\tMin result\\tMax result\\tMin CPU time\\tMin Evals\\tMax CPU time\\tMax Evals\\n'\n results_file.write(header_line)\n for result in results:\n result_line = result['name'] + '\\t' + result['min_result'] + '\\t' + result['max_result'] + '\\t' + result['min_cpu'] + '\\t' + result['min_evals'] + '\\t' + result['max_cpu'] + '\\t' + result['max_evals'] + '\\n'\n results_file.write(result_line)\n results_file.close()\n return results","def getBestOption(self):\n if len(self.Data) < 1:\n return None\n else:\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\n return bestR[1]","def get_results(self):\n return self.result","def _find_solution(self, population, num_of_best_chromosomes):\n data = self._Individuals()\n for x in population:\n curr_fit = self._fitness(x)\n data.append_object(self._Individual(curr_fit, x))\n return data.sort_objects()[:num_of_best_chromosomes]","def _extract_results(self) -> None:\n metric_name = self.metric.name\n for inference_name in ['train', 'test', 'opt']:\n # TODO: Extract information from self.search_results\n data = getattr(self.search_results, f'{inference_name}_metric_dict')[metric_name]\n if all([d is None for d in data]):\n if inference_name not in OPTIONAL_INFERENCE_CHOICES:\n raise ValueError(f\"Expected {metric_name} score for {inference_name} set\"\n f\" to not be None, but got {data}\")\n else:\n continue\n self.data[f'single::{inference_name}::{metric_name}'] = np.array(data)\n\n if self.ensemble_results.empty() or inference_name == 'opt':\n continue\n\n data = getattr(self.ensemble_results, f'{inference_name}_scores')\n if all([d is None for d in data]):\n if inference_name not in OPTIONAL_INFERENCE_CHOICES:\n raise ValueError(f\"Expected {metric_name} score for {inference_name} set\"\n f\" to not be None, but got {data}\")\n else:\n continue\n self.data[f'ensemble::{inference_name}::{metric_name}'] = np.array(data)","def getOptimalSolution(self):\n max_index = np.argmax(self.Ws)\n self.Wmax = self.Ws[max_index]\n self.Emax = self.subsets[max_index]\n return (self.Wmax, self.Emax)","def best(self):\n if len(self) == 0:\n return None\n return max_elems(self, key=attr.getter(\"value\"), gt=self.solver.sense.is_better)[0]","def find_best_solution_and_score(self):\r\n best_score = MAXSIZE\r\n best_solution = self.simulation.solutions[0]\r\n for solution in self.simulation.solutions:\r\n score = self.simulation.fitting_function.fit_score(solution)\r\n if score < best_score:\r\n best_score = score\r\n best_solution = solution\r\n return best_solution, best_score","def _evaluate(self):\n if not self._evaluated:\n query = { 'query' : self._query.serialize() }\n if self._min_score is not None:\n query['min_score'] = self._min_score\n if self._highlight is not None:\n query['highlight'] = self._highlight\n if self._order is not None:\n query['sort'] = self._order\n\n params = {}\n if self._offset is not None:\n params['from'] = int(self._offset)\n if self._limit is not None:\n params['size'] = int(self._limit)\n if self._only_fields:\n params['fields'] = \",\".join(self._only_fields)\n\n self._results = self._document._meta.search_engine.search(\n query,\n **params\n )\n self._evaluated = True\n\n return self._results","def ordered_result(self):\n cc = Counter(self._counter)\n return cc.most_common(self._qtd) #qtd is a cli arg used on --top-ips <number>","def find_bestParameter(self,currentEnergy):\n if currentEnergy==5.89:\n currentEnergy=6.4\n print(\"WARNING !!!!!!!! E=5.89 KeV ==>> uso best value trovato a 6.4 KeV !!!!!\")\n \n \n index_summary=1e6\n try:\n index_summary=np.where( np.logical_and ( self.energy<(float(currentEnergy)+0.05), self.energy >(float(currentEnergy)-0.05) ) )[0][0]\n print (\"readSummaryData: energia trovata! index = \",index_summary)\n except:\n print (\"readSummaryData: energia *NON* trovata nello scan ploarizzato\")\n\n \n bestPar=1e6 \n if ( index_summary<1000):\n bestPar=self.best_val[index_summary]\n \n return bestPar","def find_bestParameter(self,currentEnergy):\n if currentEnergy==5.89:\n currentEnergy=6.4\n print(\"WARNING !!!!!!!! E=5.89 KeV ==>> uso best value trovato a 6.4 KeV !!!!!\")\n \n \n index_summary=1e6\n try:\n index_summary=np.where( np.logical_and ( self.energy<(float(currentEnergy)+0.05), self.energy >(float(currentEnergy)-0.05) ) )[0][0]\n print (\"readSummaryData: energia trovata! index = \",index_summary)\n except:\n print (\"readSummaryData: energia *NON* trovata nello scan ploarizzato\")\n\n \n bestPar=1e6 \n if ( index_summary<1000):\n bestPar=self.best_val[index_summary]\n \n return bestPar","def get_expected_cost(self):","def result(self):\r\n # TODO: how about xcurrent?\r\n return self.best.get() + (\r\n self.countevals, self.countiter, self.gp.pheno(self.mean), self.gp.scales * self.sigma * self.sigma_vec * self.dC**0.5)","def getAlgoResult(self):\n return _SALOMERuntime.OptimizerAlgASync_getAlgoResult(self)","def get_best_value(self):\n # Todo: implement\n best_value_global = -inf\n for particle in self.particles:\n if particle.best_value >= best_value_global:\n best_value_global = particle.best_value\n return best_value_global # Remove this line","def results(self):\n pass","def get_best_worst():\n return make_response(jsonify(storage.ranking), 200)","def results(self):\r\n pass","def getAlgoResult(self):\n return _SALOMERuntime.OptimizerAlgSync_getAlgoResult(self)","def get_best_match(self, list):\n raise NotImplementedError","def populate_pool_results(self, miner, worker, pool, algo, algo_idx, coin_idx, coin_cost,\n profitability, speed_accepted, speed_reported, speed_suffix):\n\n # Determine how much COIN is being generated per minute for the\n # accepted hashrate (stats are usually collected once each minute)\n # multiply the number of units of speed (speed accepted) by the profitability,\n # divided by 1440 minutes per day\n\n coin_generated_per_minute = (profitability * speed_accepted) / (60 * 24)\n\n # compute amount of power used and the cost of that power, per minute\n power_used, power_used_cost = get_power_usage_info_per_algo_per_minute(self, miner, algo)\n\n # must always set worker, algo, pool\n self.set_result(miner, 'worker', worker)\n self.set_result(miner, 'algo', algo_idx)\n self.set_result(miner, 'pool', pool)\n\n # set the algo stats - for hashrate calculations later\n\n self.set_result(miner, 'hashrates_by_algo',\n {algo: {'accepted': speed_accepted,\n 'reported': speed_reported,\n 'speed_suffix': speed_suffix}})\n\n # derived stats\n self.set_result(miner, 'power_used', power_used)\n self.set_result(miner, 'power_used_cost', power_used_cost)\n self.set_result(miner, 'coin', coin_idx)\n self.set_result(miner, 'coin_cost', coin_cost)\n self.set_result(miner, 'coin_mined', coin_generated_per_minute)\n\n # save the current coin index in the miner\n miner.coin_idx = coin_idx\n\n # how much would it cost to purchase this much generated coin, instead?\n coin_purchase_cost = (coin_cost * coin_generated_per_minute)\n self.set_result(miner, 'coin_purchase_cost', coin_purchase_cost)\n\n # did we get power used cost so we can determine Profitability?\n if power_used_cost is not None and power_used_cost != 0:\n\n # PROFITABILITY - (cost to buy) / (cost to mine) >1 is profitable\n self.set_result(miner, 'profitability', (coin_purchase_cost / power_used_cost))\n\n # BOOLEAN is it profitable\n self.set_result(miner, 'profitable', (coin_purchase_cost > power_used_cost))","def get_best_solution(self):\n if not self.tours:\n raise Exception('No solution has been computed yet')\n scores = {s:get_cost(self.tours[s],self) for s in self.tours}\n best = min(scores,key=scores.get)\n print('The best solution is given by {} with score {}'.format(best,scores[best]))\n return self.tours[best]","def __call__(self, **kwds):\n best = kwds['best']\n print(best.pbestval)\n sys.stdout.flush()","def get_personal_best(self):\n return self._personal_best","def fetch(\n self,\n search_method: str,\n objective_function: str,\n weight: int,\n ):\n if os.path.isfile(self.filename):\n with open(self.filename, 'r+') as f:\n table = pandas.io.json.read_json(f)\n try:\n table = table[(table[\"objective\"] == objective_function)\n & (table[\"weight\"] == weight)\n & (table[\"search\"] == search_method)]\n best = table.loc[table['cost'].idxmax()]\n self.best_cost = best[\"cost\"]\n return best[\"code\"], best[\"cost\"], best[\"progress\"]\n except (ValueError, KeyError):\n pass\n return None, -np.inf, 0","def __evaluateLocal__(self,featureVals):\n returnEvaluation = {self.pivotParameterID:self.pivotValues}\n for target in list(set(self.target) - set([self.pivotParameterID])):\n reconstructData = self._reconstructData(target).real\n # find the nearest data and compute weights\n if len(reconstructData) > 1:\n weights, indexes = self.KDTreeFinder.query(featureVals, k=min(2**len(self.features),len(reconstructData)))\n # if 0 (perfect match), assign minimum possible distance\n weights[weights == 0] = sys.float_info.min\n weights =1./weights\n # normalize to 1\n weights = weights/weights.sum()\n for point in range(len(weights)):\n returnEvaluation[target] = np.sum ((weights[point,:]*reconstructData[indexes[point,:]].T) , axis=1)\n else:\n returnEvaluation[target] = reconstructData[0]\n\n return returnEvaluation","def find_best(self):\n best_st = 0\n best_bt = 0\n best_perf = -1.1\n for bt in self.btl:\n for st in self.stl:\n if self.total[bt, st, \"perf\"] > best_perf:\n best_perf = self.total[bt, st, \"perf\"]\n best_st = st\n best_bt = bt\n return (best_perf, self.total[best_bt, best_st, \"count\"], best_bt, best_st)","def get_results(self):\n return self.results","def get_results(self):\n return self.results","def get_best_vector(results, f_x, target):\n index_min = -1\n cur_min = 10**10\n\n with Session() as sess:\n for index, individual in enumerate(results):\n f_x_res = sess.run(f_x, feed_dict={\n target: individual\n })\n if f_x_res < cur_min:\n cur_min = f_x_res\n index_min = index\n\n best = results[index_min]\n\n return best","def best(self, side):\n return Library.functions.best(self._book, side)","def strategy_best(cookies, cps, time_left, build_info):\n items = build_info.build_items()\n result = None\n cost = 0\n overall = cookies + time_left * cps\n for item in items:\n temp_cost = build_info.get_cps(item) / build_info.get_cost(item)\n if temp_cost <= overall and cost < temp_cost:\n result = item\n cost = temp_cost\n return result","def _optimise(self):\n pass","def run(self):\n best_score = float('inf')\n best_route = None\n best_nr_iterations = None\n best_tabu_list_size = None\n for i in range(self.range_iterations_start, self.range_iterations_end, 10):\n for j in range(self.range_tabu_list_start, self.range_tabu_list_end):\n print('testing for nr_iterations', i, ' and tabu list size', j)\n self.hc.generate_initial_solution(use_seed=True)\n score, route, iteration = self.hc.solve(tabu=self.tabu, with_time_windows=self.with_time_windows,\n nr_iterations=i, tabu_size=j,\n allow_infeasibilites=self.allow_infeasibilites)\n\n if score < best_score:\n best_score = score\n best_route = route\n best_nr_iterations = i\n best_tabu_list_size = j\n\n print('best results with sore', best_score, best_nr_iterations, best_tabu_list_size )\n return best_score, best_route, best_tabu_list_size","def Results(self):\n return self.data","def Results(self):\n return self.data","def getResults(solver, minBit, maxBit, saveFile, noResults):\n\n for k in range(minBit, maxBit + 1, 2):\n for i in range(noResults):\n\n keys = generate_RSA.KeyGen(k) # initialise keys\n keys.generateKeys() # generate keys\n\n solver.setN(keys.n) # setup solver\n solver.setE(keys.e)\n\n solver.solve() # solve problem\n\n if solver.d == keys.d: # if we got it right\n resTime = resTime_C # update correct dictionaries\n resCount = resCount_C\n resSpace = resSpace_C\n else:\n resTime = resTime_W # else update wrong dictionaries\n resCount = resCount_W\n resSpace = resSpace_W\n\n if k not in resTime: # if we've not yet had a result for k\n resTime[k] = [solver.time, 1] # then set\n resSpace[k] = [solver.space, 1] # then set\n resCount[k] = [solver.count, 1]\n else:\n oldT, oldC = resTime[k] # keeps a running average\n newC = oldC + 1 # increment count\n newT = ((oldT * oldC) + solver.time) / newC # get new averagae\n resTime[k] = [newT, newC] # without storing all variables\n\n oldS, oldC = resSpace[k] # keeps a running average\n newS = ((oldS * oldC) + solver.space) / newC\n resSpace[k] = [newS, newC] # without storing all variables\n\n oldCount, oldC = resCount[k] # keeps a running average\n newCount = ((oldCount * oldC) + solver.count) / newC\n resCount[k] = [newCount, newC] # without storing all variables\n\n if i % 10 == 0:\n saveResults(saveFile) # every ten results save again","def __call__(self, num_perms=999):\r\n res = super(Best, self).__call__()\r\n cats = self.Categories\r\n dm = self.DistanceMatrices[0]\r\n dm_flat = dm.condensed_form()\r\n\r\n row_count = dm.shape[0]\r\n col_count = len(cats)\r\n sum = 0\r\n stats = [(-777777777, '') for c in range(col_count + 1)]\r\n for i in range(1, col_count + 1):\r\n combo = combinations([j for j in range(1, col_count + 1)], i)\r\n\r\n for element in combo:\r\n cat_mat = self._make_cat_mat(cats, element)\r\n cat_dm = self._derive_euclidean_dm(cat_mat, row_count)\r\n cat_dm_flat = cat_dm.condensed_form()\r\n r = spearman(dm_flat, cat_dm_flat)\r\n if r > stats[i - 1][0]:\r\n stats[i - 1] = (r, ','.join(str(s) for s in element))\r\n\r\n res['method_name'] = 'BEST'\r\n res['num_vars'] = col_count\r\n res['vars'] = ['%s = %d' % (name, val + 1)\r\n for val, name in enumerate(cats)]\r\n res['rho_vals'] = stats[:-1]\r\n\r\n return res","def hardest_read(self, it):\n workers = multiprocessing.cpu_count()\n # highest_avg=0\n texts = []\n while True:\n try:\n texts.append(it.__next__())\n except StopIteration:\n break\n\n with ProcessPoolExecutor(workers) as ex:\n res = ex.map(self.avg_vowels, texts)\n result = dict(zip([filename for filename in self.filenames], [avg for avg in list(res)]))\n maxi = max(result, key=result.get) # finding key with max value\n return maxi","def localResultSet(options=None):\n options = {} if options is None else options\n results = {}\n for problem in generateProblem(options):\n _, solutions = solver.numberOfSolutions(\n problem, returnWays=True)\n results[tuple(problem)] = difficulty(solutions)\n\n # sort from easiest to hardest\n results = sorted(list(results.iteritems()), key=lambda x: x[1])\n return results","def greedy(items, maxCost, keyFunction):\n result = []\n itemsCopy = sorted(items, key=keyFunction, reverse=True)\n totalValue , totalCalories = 0.0, 0.0\n for i in range(len(itemsCopy)):\n item = itemsCopy[i]\n if (totalCalories + item.getCalories()) <= maxCost:\n result.append(item)\n totalCalories += item.getCalories()\n totalValue += item.getValue()\n return result, totalValue","def get_best_candidate(self):\n if not self.scores:\n return None\n return self.te_list[self.scores.index(max(self.scores))]","def process_or_results(self, filenames):\n \n #Check if we're maximising or minimising\n optTask = self._getTask('optimization')\n problem = optTask.find(xmlns + 'Problem')\n for parameter in problem:\n if parameter.attrib['name']=='Maximize':\n max_param = parameter.attrib['value']\n if max_param == '0':\n maximize = False\n else:\n maximize = True\n \n output_file = open(os.path.join(self.path, 'raw_results.txt'), 'w')\n \n\n #Match a string of the format ( 0.0995749 0.101685 0.108192 0.091224 ) 0.091224 0 \n #Contains parameter values, the best optimization value, the cpu time, and some other values.\n output_string = r'\\(\\s(?P<params>.+)\\s\\)\\s+(?P<best_value>\\S+)\\s+(?P<cpu_time>\\S+)\\.*'\n output_re = re.compile(output_string)\n \n best_value = None\n best_line = None\n \n #Copy the contents of the first file to results.txt\n for line in open(os.path.join(self.path, filenames[0]), 'r'):\n output_file.write(line)\n if line != '\\n':\n if output_re.match(line):\n value = float(output_re.match(line).groupdict()['best_value'])\n if best_value != None and maximize:\n if value > best_value:\n best_value = value\n best_line = line\n elif best_value != None and not maximize:\n if value < best_value:\n best_value = value\n best_line = line\n elif best_value == None:\n best_value = value\n best_line = line\n else:\n pass\n \n #And for all other files, copy everything but the last line\n for filename in filenames[1:]:\n firstLine = True\n for line in open(os.path.join(self.path,filename), 'r'):\n if not firstLine:\n output_file.write(line)\n if line != '\\n':\n if output_re.match(line):\n value = float(output_re.match(line).groupdict()['best_value'])\n if maximize:\n if value > best_value:\n best_value = value\n best_line = line\n elif not maximize:\n if value < best_value:\n best_value = value\n best_line = line\n else:\n pass\n firstLine = False\n \n \n output_file.close()\n \n #Write the best value to results.txt\n output_file = open(os.path.join(self.path, 'results.txt'), 'w')\n \n output_file.write('Best value\\t')\n \n for parameter in self.get_optimization_parameters():\n\n output_file.write(parameter[0].encode('utf8'))\n output_file.write('\\t')\n output_file.write('\\n')\n\n best_line_dict = output_re.match(best_line).groupdict()\n\n output_file.write(best_line_dict['best_value'])\n output_file.write('\\t')\n \n for parameter in best_line_dict['params'].split('\\t'):\n output_file.write(parameter)\n output_file.write('\\t')\n output_file.close()","def get_best(self, population):\n best = min(population, key=self.cost_function)\n return best, self.cost_function(best)","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def _find_best_offer(\n self, all_offers: List[Tuple[str, Dict]]\n ) -> Tuple[List, float]:\n bests, best_gain = [], 0\n\n for partner, offers in all_offers:\n partial_asgt = self._neighbors_values.copy()\n current_partner = self._neighbor_var(partner)\n\n # Filter out the constraints linking those two variables to avoid\n # counting their cost twice.\n shared = find_dependent_relations(current_partner, self._constraints)\n concerned = [rel for rel in self._constraints if rel not in shared]\n\n for (val_p, my_offer_val), partner_local_gain in offers.items():\n partial_asgt.update({partner: val_p, self.variable.name: my_offer_val})\n\n # Then we evaluate the agent constraint's for the offer\n # and add the partner's local gain.\n cost = assignment_cost(partial_asgt, concerned)\n global_gain = self.current_cost - cost + partner_local_gain\n\n if (global_gain > best_gain and self._mode == \"min\") or (\n global_gain < best_gain and self._mode == \"max\"\n ):\n bests = [(val_p, my_offer_val, partner)]\n best_gain = global_gain\n elif global_gain == best_gain:\n bests.append((val_p, my_offer_val, partner))\n\n return bests, best_gain","def strategy_best(cookies, cps, time_left, build_info):\n return_item = None\n highest_icr = float('-inf')\n item_list = build_info.build_items()\n cookies_potential = cookies + time_left * cps\n for item in item_list:\n cost = build_info.get_cost(item)\n curr_icr = build_info.get_cps(item) / cost \n if cookies_potential >= cost and curr_icr > highest_icr:\n return_item = item\n highest_icr = curr_icr\n return return_item","def compute(self) -> Any:\n self._check_for_increment(\"compute\")\n return self[-1].compute()","def get_optimums(self, model, size, excludes):\n raise NotImplementedError","def getOptimalParams(self):\n\t\t# Load calibration chain and find optimal for like1\n\t\tcal_data = pd.read_csv(self.database_path, sep=',')\n\t\tparams = cal_data.ix[cal_data['like1'].idxmax()].to_dict()\n\t\tcost = params['like1']\n\t\t# reformat parameters to match original naming\n\t\tparams_reformatted = {}\n\t\tfor k, p in self.cal_params.items():\n\t\t\tparams_reformatted[k] = params['par'+k]\n\n\t\treturn params_reformatted, cost","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n aStarSearch(problem)","def get_sol(self):","def Collection_return_selected(C:list) -> list:\r\n p = int(input(\"Please enter the maximum average price: \"))\r\n c = input(\"Please enter preferred cuisine: \")\r\n cheap = Collection_select_cheap(C, p)\r\n cuisine = Collection_select_cuisine(C, c)\r\n result = []\r\n for r in cheap:\r\n for rc in cuisine:\r\n if r == rc:\r\n result.append(r)\r\n return result","def _get_aggregated_results(self):\n gradients = self.gradients\n client_traj_infos = flatten_lists(self.client_traj_infos)\n client_opt_infos = self._combine_client_opt_infos(self.client_opt_infos)\n \n self.gradients = []\n self.client_traj_infos = []\n self.client_opt_infos = []\n\n return gradients, client_traj_infos, client_opt_infos","def compute_objective(Instance: dict):\r\n\r\n print(\"Computing objectives values...\")\r\n # Retrieve usefull infos\r\n T_max = Instance[T_STR]\r\n scenario_numbers = Instance[SCENARIO_NUMBER]\r\n Interventions = Instance[INTERVENTIONS_STR]\r\n quantile = Instance[QUANTILE_STR]\r\n # Retrieve risk final distribution\r\n risk = compute_risk_distribution(Interventions, T_max, scenario_numbers)\r\n # Compute mean risk\r\n mean_risk = compute_mean_risk(risk, T_max, scenario_numbers)\r\n # Compute quantile\r\n q = compute_quantile(risk, T_max, scenario_numbers, quantile)\r\n print(\"Done\")\r\n\r\n return mean_risk, q","def queryresults(templateList, res, epsilon, weight_for_hori):\r\n\t# get Results column#\r\n\tcoor_result = None\r\n\tall_results = {}\r\n\ttemp_all_results = {}\r\n\tcoor_results = []\r\n\tall_items = res.items()\r\n\ttemp = deepcopy(res)\r\n\tfor k, v in all_items:\r\n\t\tif k.count('结果'):\r\n\t\t\ttemp.pop(k)\r\n\t\t\tcoor_result = v\r\n\t\t\tcoor_results.append(coor_result)#multiple same results, typically 2 results\r\n\r\n\tres = deepcopy(temp)\r\n\tdel temp\r\n\r\n\tif coor_result is None:\r\n\t\traise Exception('No 结果 detected!')\r\n\r\n\tx, y = coor_results[0][0], coor_results[0][1]\r\n\tres_range1 = (x - epsilon, x + epsilon)#vertical 1\r\n\tif len(coor_results) > 1:\r\n\t\tx, y = coor_results[1][0], coor_results[1][1]\r\n\t\tres_range2 = (x - epsilon, x + epsilon)#vertical 2\r\n\r\n\telse:\r\n\t\tres_range2 = res_range1\r\n\r\n\tfor item in templateList:#for each item, we iterate through the whole dictionary to find corresponding value\r\n\t\tcoor_result = None\r\n\t\tfor k, v in res.items():\r\n\t\t\tif get_equal_rate(k, item) > 0.8:#string match\r\n\t\t\t\tres.pop(k)\r\n\t\t\t\tcoor_result = v\r\n\t\t\t\tbreak\r\n\r\n\t\tif coor_result is None:\r\n\t\t\tall_results[item] = 'NOT DETECTED'\r\n\r\n\t\telse:\r\n\t\t\tx, y = coor_result[0], coor_result[1]\r\n\t\t\t#x_range = (x - epsilon, x + epsilon)\r\n\t\t\ty_range = (y - epsilon, y + epsilon)#横坐标\r\n\r\n\t\t\tfor k, v in res.items():\r\n\t\t\t\t#First, filter all results in the range of [x - epsilon, x + epsilon] and [y - epsilon, y + epsilon]\r\n\t\t\t\tif ((y_range[0] <= v[1] <= y_range[1]) and (res_range1[0] <= v[0] <= res_range1[1])) \\\r\n\t\t\t\t\tor ((y_range[0] <= v[1] <= y_range[1]) and (res_range2[0] <= v[0] <= res_range2[1])):\r\n\t\t\t\t\t#Then, we filter closer results in the same range, if we get two columns, v[0] - x makes sure\r\n\t\t\t\t\t#we can find closer one, if we get multiple rows abs(v[1] - y) makes sure we can find nearest one\r\n\t\t\t\t\tnow_residual = (v[0] - x) * weight_for_hori + abs(v[1] - y) * (1 - weight_for_hori)#weighted to say vertical line is more important\r\n\t\t\t\t\t\r\n\t\t\t\t\tif (v[0] - x) >= 0:\r\n\t\t\t\t\t\tif item not in temp_all_results:\r\n\t\t\t\t\t\t\ttemp_all_results[item] = now_residual\r\n\t\t\t\t\t\t\tall_results[item] = k\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\tresidual = temp_all_results[item]\r\n\t\t\t\t\t\t\tif residual > now_residual:\r\n\t\t\t\t\t\t\t\ttemp_all_results[item] = now_residual#compare residual, if old one is larger than the new one, then this key must be better\r\n\t\t\t\t\t\t\t\tall_results[item] = k\r\n\r\n\t\t\t\t\t\t\t# res.pop(k)\r\n\t\t\t\t\t\t\t# break\r\n\r\n\treturn all_results","def results(algo = 0, minBit = 10, maxBit = 44, saveFile = \"results\", noResults = 100):\n\n solver = None\n if algo == 0:\n solver = brute_force.BFSolver(verbose = False)\n elif algo == 1:\n solver = fermats.FFSolver(verbose = False)\n elif algo == 2:\n solver = pollard_rho.RhoSolver(verbose = False)\n elif algo == 3:\n solver = knj_factorisation.KNJSolver(verbose = False)\n elif algo == 4:\n solver = pollard_p_minus_1.PSolver(verbose = False)\n elif algo == 5:\n solver = quadratic_sieve.QSolver(verbose = False)\n\n getResults(solver, minBit, maxBit, saveFile, noResults)","def _evaluate_performance__static_winners(self):\n # | - _evaluate_performance__\n\n # | - class attributes #################################################\n AL = self\n al_gen = self.al_gen\n verbose = self.verbose\n seed_ids = self.seed_ids\n acquisition_bin = self.acquisition_bin\n completed_ids = self.completed_ids\n CandidateSpace = self.CandidateSpace\n RegressionModel = self.RegressionModel\n DuplicateFinder = self.DuplicateFinder\n al_gen_dict = self.al_gen_dict\n\n stop_mode = self.stop_mode\n stop_num_generations = self.stop_num_generations\n\n index_acq_gen_dict = self.index_acq_gen_dict\n #__| #################################################################\n\n # #####################################################################\n mode = \"lowest_N\" # 'lowest_N' or 'lowest_perc'\n\n N_ids = 10\n lowest_perc = 5\n\n # Number of consecutive generations that the Nth best systems must\n # remain static\n M_gens = 3\n # #####################################################################\n\n if mode == \"lowest_perc\":\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\n N_ids = int(num_candidates * (lowest_perc * 0.01))\n\n gen_keys = list(AL.al_gen_dict.keys())\n\n if len(gen_keys) > M_gens:\n latest_M_keys = gen_keys[-(M_gens + 1):]\n last_gen_key = gen_keys[-1]\n\n al_gen_dict_subset_i = dict(zip(\n latest_M_keys,\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\n\n indices_list = []\n iterator = enumerate(al_gen_dict_subset_i.items())\n for i_cnt, (gen_i, AL_i) in iterator:\n model_i = AL_i.model\n\n model_i = AL.add_main_Y_to_model(\n model_i, plot_dft_instead_of_pred=True)\n model_i = model_i[(model_i[\"duplicate\"] == False)]\n model_i = model_i.sort_values(\"Y_main\")\n\n indices_i = model_i.index.tolist()\n\n indices_list.append(indices_i)\n\n if i_cnt >= M_gens:\n indices_i = indices_list[i_cnt][0:N_ids]\n ids_static_list = []\n for j in range(M_gens):\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\n ids_static = indices_j == indices_i\n ids_static_list.append(ids_static)\n\n ids_are_static = all(ids_static_list)\n\n self.performance__static_winners[last_gen_key] = ids_are_static\n #__|","def test_best_hits_unique(self):\n records = [h for _, h in self.result.best_hits_by_query(n=5)][0]\n self.assertEqual(len(records), 3)\n values = {tuple(h.values()) for h in records}\n self.assertEqual(len(values), 3)","def __next__(self):\n self.rebuild_all()\n\n if not hasattr(self, \"demand_array\"):\n self.build_demand_array()\n\n self.lci_calculation()\n if self.lcia:\n self.lcia_calculation()\n if self.weighting:\n self.weighting_calculation()\n return self.score\n else:\n return self.supply_array","def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\n partial_asgt = self._neighbors_values.copy()\n offers = dict()\n\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\n partial_asgt.update(limited_asgt)\n cost = self._compute_cost(**partial_asgt)\n if self.logger.isEnabledFor(logging.DEBUG):\n self.logger.debug(\n f\"looking for offer : {partial_asgt} - cost {cost}\"\n f\" current {self.current_cost} {self._mode}\"\n )\n\n if (self.current_cost > cost and self._mode == \"min\") or (\n self.current_cost < cost and self._mode == \"max\"\n ):\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\n self.current_cost - cost\n )\n return offers","def stats(self):\n return self._solution","def stats(self):\n return self._solution","def stats(self):\n return self._solution","def main():\n # Retrieve csv_file name an max_investment from argument passed in console:\n arg_csv_file, arg_max_investment = set_arg()\n if arg_csv_file:\n csv_file = arg_csv_file\n else:\n csv_file = 'dataset1_Python+P7.csv'\n if arg_max_investment:\n max_investment = float(arg_max_investment)\n else:\n max_investment = 500.00\n\n # Retrieve dataset:\n base_dataset = open_convert_and_clean_csv(csv_file)\n\n # Retrieve solution:\n start = time.perf_counter()\n print()\n print(f\"Processing with file '{csv_file}' containing {len(base_dataset)} shares...\")\n print(f\"Maximum investment: {max_investment}€\")\n print(\"Please wait...\")\n computable_dataset = add_roi_to_dataset(convert_dataset_to_cents(base_dataset))\n best_roi, combination = best_combination_dynamic(computable_dataset, max_investment)\n\n # Formatting results:\n combination.sort(key=lambda x: x[2], reverse=True)\n combination_in_euros = convert_dataset_to_euros(combination)\n best_roi /= 100\n # Following calculus is done on cent prices (combination) to avoid approximations with floats\n shares_cost = calculate_shares_cost_sum(combination) / 100\n\n # Printing results:\n print()\n print(f\"Length of dataset: {len(computable_dataset)}\")\n print(f\"Duration of Analysis: {elapsed_time_formatted(start)}\")\n print()\n print(f\"Best Return on investment after 2 years: {round(best_roi, 2)}€\")\n print(f\"Number of shares to buy : {len(combination_in_euros)}\")\n print(f\"Total cost: {round(shares_cost, 2)}€\")\n print()\n print(f\"Best combination of shares ordered by performance: \")\n for share in combination_in_euros:\n print(f\"{share[0]} | Price: {share[1]}€ | profit: {share[2]}%\")\n print()","def train(self): \n start_time = time()\n\n # reset previous results\n self.best_result = pd.DataFrame()\n self.result = pd.DataFrame()\n\n # Generate dictionaries of all posible parameter permutations\n keys, values = zip(*self.params.items())\n self.permutations_dict = [dict(zip(keys, v)) for v in itertools.product(*values)] \n\n # Run through all models in parallel threads\n with Pool(self.thread_cnt) as p:\n result = p.map(self.analyze_model, self.permutations_dict)\n\n\n # wrap up results\n if self.classes_names: # acts as trigger for computation of cms\n for i, dic in enumerate(result):\n dic[\"id\"] = i\n self.cms = [(dic[\"id\"] ,dic.pop(\"cm\")) for dic in result]\n\n self.result = pd.DataFrame(result)\n self.best_result = self.result.iloc[self.result[\"score\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"f1_score\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"recall\"].argmax()] # store row with the best score\n self.best_result = self.result.iloc[self.result[\"precision\"].argmax()] # store row with the best score\n end_time = time()\n print(\"Finished evaluation\")\n print(\"Best parameteters found with:\", self.best_parameter_set())\n print(\"score=\", self.best_score())\n #print(\"f1_score=\", self.best_f1_score())\n #print(\"recall_score=\", self.best_recall_score())\n #print(\"precision_score=\", self.best_precision_score())\n print(\"Total evaluation time = {:.2f}s\".format(end_time-start_time))\n\n return self.best_parameter_set(), self.best_score()","def _estimate_elasticsearch_requirement(\n instance: Instance,\n desires: CapacityDesires,\n working_set: float,\n reads_per_second: float,\n max_rps_to_disk: int,\n zones_per_region: int = 3,\n copies_per_region: int = 3,\n) -> CapacityRequirement:\n # Keep half of the cores free for background work (merging mostly)\n needed_cores = math.ceil(sqrt_staffed_cores(desires) * 1.5)\n # Keep half of the bandwidth available for backup\n needed_network_mbps = simple_network_mbps(desires) * 2\n\n needed_disk = math.ceil(\n (1.0 / desires.data_shape.estimated_compression_ratio.mid)\n * desires.data_shape.estimated_state_size_gib.mid\n * copies_per_region,\n )\n\n # Rough estimate of how many instances we would need just for the the CPU\n # Note that this is a lower bound, we might end up with more.\n needed_cores = math.ceil(\n max(1, needed_cores // (instance.cpu_ghz / desires.core_reference_ghz))\n )\n rough_count = math.ceil(needed_cores / instance.cpu)\n\n # Generally speaking we want fewer than some number of reads per second\n # hitting disk per instance. If we don't have many reads we don't need to\n # hold much data in memory.\n instance_rps = max(1, reads_per_second // rough_count)\n disk_rps = instance_rps * _es_io_per_read(max(1, needed_disk // rough_count))\n rps_working_set = min(1.0, disk_rps / max_rps_to_disk)\n\n # If disk RPS will be smaller than our target because there are no\n # reads, we don't need to hold as much data in memory\n needed_memory = min(working_set, rps_working_set) * needed_disk\n\n # Now convert to per zone\n needed_cores = needed_cores // zones_per_region\n needed_disk = needed_disk // zones_per_region\n needed_memory = int(needed_memory // zones_per_region)\n logger.debug(\n \"Need (cpu, mem, disk, working) = (%s, %s, %s, %f)\",\n needed_cores,\n needed_memory,\n needed_disk,\n working_set,\n )\n\n return CapacityRequirement(\n requirement_type=\"elasticsearch-data-zonal\",\n core_reference_ghz=desires.core_reference_ghz,\n cpu_cores=certain_int(needed_cores),\n mem_gib=certain_float(needed_memory),\n disk_gib=certain_float(needed_disk),\n network_mbps=certain_float(needed_network_mbps),\n context={\n \"working_set\": min(working_set, rps_working_set),\n \"rps_working_set\": rps_working_set,\n \"disk_slo_working_set\": working_set,\n \"replication_factor\": copies_per_region,\n \"compression_ratio\": round(\n 1.0 / desires.data_shape.estimated_compression_ratio.mid, 2\n ),\n \"read_per_second\": reads_per_second,\n },\n )","def __call__(self, ret):\n \n ce = None\n for reli in itertools.product([False, True], repeat = len(ret)):\n\n mean, var = self.learner.updated_prediction({ i : 1 if r else -1 for i, r in zip(ret, reli) }, self.learner.candidates, cov_mode = 'diag')\n \n prob_irrel = scipy.stats.norm.cdf(0, mean, np.sqrt(var))\n prob_rel = 1. - prob_irrel\n cur_ce = np.sum(prob_irrel * np.log(prob_irrel + self.eps) + prob_rel * np.log(prob_rel + self.eps))\n \n if (ce is None) or (cur_ce < ce):\n ce = cur_ce\n \n return ce","def personal_best(scores):\n return max(scores)","def evaluate_score(self,word_id):\r\n total_best = 0\r\n assigned_to_return = {}\r\n for possible_word in self.satisfiers[word_id].keys():\r\n words_to_iterate = []\r\n iterated_word_ids = []\r\n # print()\r\n for connected_word_id in self.satisfiers[word_id][possible_word].keys():\r\n words_to_iterate.append(self.satisfiers[word_id][possible_word][connected_word_id])\r\n # print(\"word_id: {}, possible_word: {}, connected_id: {}, words: {}\".format(word_id,possible_word, connected_word_id,self.satisfiers[word_id][possible_word][connected_word_id]))\r\n iterated_word_ids.append(connected_word_id)\r\n \r\n # print(possible_word)\r\n # print(\"\\nPossible word:\",possible_word)\r\n for comb in itertools.product(*words_to_iterate):\r\n assigned_words = {}\r\n assigned_words[word_id] = possible_word\r\n for i in range(len(iterated_word_ids)):\r\n assigned_words[iterated_word_ids[i]] = comb[i]\r\n # print(\"word_id: {} comb: {}\".format(word_id,comb))\r\n # print(\"\\nword_id: {}, assigned words: {}\".format(word_id,assigned_words))\r\n new_assigned, current_max = self.get_max_score(word_id,assigned_words)\r\n # print(\"new_assigned: {}, current_max: {}\".format(new_assigned, current_max))\r\n if current_max > total_best:\r\n total_best = current_max\r\n assigned_to_return = {}\r\n assigned_to_return = new_assigned\r\n return assigned_to_return, total_best","def display_results(_results, model):\n print(\"Optimal solution:\\n\")\n for website in sorted(model.Websites):\n for item in sorted(model.Items):\n if model.Quantity[website, item].value > 0:\n print(\"Buy {q} item(s) of {i} from {w}\".format(q=int(model.Quantity[website, item].value),\n i=item,\n w=website,))\n\n print('')\n print(\"Shipping Cost = {}\".format(model.Cost['Shipping'].value))\n print(\"Product Cost = {}\".format(model.Cost['Item'].value))\n print('')\n\n for i in _results['Solution']:\n print(\"Total Cost = {}\".format(i['Objective']['Objective']['Value']))"],"string":"[\n \"def GetPts(self):\\n return self.best\",\n \"def getResults():\",\n \"def _compute_best_value(self):\\n reduced_cs = []\\n concerned_vars = set()\\n\\n for c in self.utilities:\\n asgt = filter_assignment_dict(self._neighbors_values, c.dimensions)\\n reduced_cs.append(c.slice(asgt))\\n concerned_vars.update(c.dimensions)\\n var_val, rel_val = find_arg_optimal(\\n self.variable,\\n lambda x: functools.reduce(operator.add, [f(x) for f in reduced_cs]),\\n self._mode,\\n )\\n # Add the cost for each variable value if any\\n for var in concerned_vars:\\n if var.name == self.name:\\n rel_val += var.cost_for_val(self.current_value)\\n else:\\n rel_val += var.cost_for_val(self._neighbors_values[var.name])\\n\\n return var_val, rel_val\",\n \"def _compute_results(self):\\n self.Y_best = best_value(self.Y)\\n self.x_opt = self.X[np.argmin(self.Y),:]\\n self.fx_opt = np.min(self.Y)\\n self.distance = self._compute_distance_betw_consecutive_x()\",\n \"def optimal(count):\\n\\n return _optimal(start, count)[0]\",\n \"def get_n_best(self):\\n pass\",\n \"def best_value(self):\\r\\n return self._best_value\",\n \"def compute(self, result_file_dict):\\r\\n for part in self.parts:\\r\\n #=====================Need to change, temporal=========================\\r\\n if part == 'train':\\r\\n continue # because the train not have the label\\r\\n #=======================================================================\\r\\n gt = self.gt_dict[part]\\r\\n result_file = result_file_dict[part]\\r\\n # import ipdb; ipdb.set_trace()\\r\\n for key, item in result_file.items():\\r\\n self._result_name = item\\r\\n # score_records, num_videos = self.load_results(result_file)\\r\\n score_records, num_videos = self.load_results(item)\\r\\n logger.info(f'Compute Metric of {item}')\\r\\n assert num_videos == len(gt), f'the number of saved videos does not match the ground truth, {num_videos} != {len(gt)}'\\r\\n temp_result = self.eval_method(score_records, gt, str(key))\\r\\n if temp_result > self.optimal_resulst:\\r\\n self.optimal_resulst = temp_result\\r\\n \\r\\n return self.optimal_resulst\",\n \"def _SD_optimal(t):\",\n \"def get_best(self):\\n scores, ids = self.sort_best()\\n return scores[1], ids[1]\",\n \"def best_metric(\\n self, return_step: bool = False\\n ) -> Union[\\n None,\\n float,\\n Tuple[float, int],\\n Tuple[None, None],\\n Dict[str, Union[float, None]],\\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\\n ]:\\n res = self.compute_all()\\n if isinstance(res, list):\\n rank_zero_warn(\\n \\\"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\\\"\\n \\\" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\\\"\\n \\\"Returning `None` instead. Please consider \\\"\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n if isinstance(self._base_metric, Metric):\\n fn = torch.max if self.maximize else torch.min\\n try:\\n value, idx = fn(res, 0)\\n if return_step:\\n return value.item(), idx.item()\\n return value.item()\\n except (ValueError, RuntimeError) as error:\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric: {error}\\\"\\n \\\"this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n else: # this is a metric collection\\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\\n value, idx = {}, {}\\n for i, (k, v) in enumerate(res.items()):\\n try:\\n fn = torch.max if maximize[i] else torch.min\\n out = fn(v, 0)\\n value[k], idx[k] = out[0].item(), out[1].item()\\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric for metric {k}:\\\"\\n f\\\"{error} this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n value[k], idx[k] = None, None\\n\\n if return_step:\\n return value, idx\\n return value\",\n \"def calculateOptimal(self) -> (list, int):\\n\\t\\tcombinations = list(itertools.product(*self.clusters))\\n\\t\\tmin_dist = 1000000\\n\\t\\tmin_combination = None\\n\\t\\tfor combination in combinations:\\n\\t\\t\\tdist = super().step(combination)\\n\\t\\t\\tif(dist < min_dist):\\n\\t\\t\\t\\tmin_dist = dist\\n\\t\\t\\t\\tmin_combination = combination\\n\\t\\treturn (min_combination, min_dist)\",\n \"def _compute_best_value(self):\\n asgt = self._neighbors_values.copy()\\n best_cost, best_val = None, []\\n\\n for v in self._variable.domain:\\n asgt[self.variable.name] = v\\n c = self._compute_cost(**asgt)\\n if (\\n best_cost is None\\n or (best_cost > c and self._mode == \\\"min\\\")\\n or (best_cost < c and self._mode == \\\"max\\\")\\n ):\\n best_cost = c\\n best_val = [v]\\n elif best_cost == c:\\n best_val.append(v)\\n\\n return best_val, best_cost\",\n \"def get_bests(self):\\n set_names = [\\\"training\\\", \\\"hp_selection\\\", \\\"validation\\\"]\\n run_tec_conf_set = recursivedict()\\n validation = self._campaign_configuration['General']['validation']\\n hp_selection = self._campaign_configuration['General']['hp_selection']\\n if (validation, hp_selection) in {(\\\"All\\\", \\\"All\\\"), (\\\"Extrapolation\\\", \\\"All\\\"), (\\\"All\\\", \\\"HoldOut\\\"), (\\\"HoldOut\\\", \\\"All\\\"), (\\\"HoldOut\\\", \\\"HoldOut\\\"), (\\\"Extrapolation\\\", \\\"HoldOut\\\")}:\\n # For each run, for each technique the best configuration\\n run_tec_best_conf = recursivedict()\\n\\n # Hyperparameter search\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n technique = conf.technique\\n run_tec_conf_set[run][technique][str(conf.get_signature()[4:])] = conf.mapes\\n # First experiment for this technique or better than the current best\\n if technique not in run_tec_best_conf[run] or conf.mapes[\\\"hp_selection\\\"] < run_tec_best_conf[run][technique].mapes[\\\"hp_selection\\\"]:\\n run_tec_best_conf[run][technique] = conf\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"-->Printing results for run %s\\\", str(run))\\n overall_run_best = None\\n # Print data of single techniques\\n for technique in run_tec_best_conf[run]:\\n temp = run_tec_best_conf[run][technique]\\n self._logger.info(\\\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, temp.get_signature()[4:], temp.mapes[\\\"training\\\"], temp.mapes[\\\"hp_selection\\\"], temp.mapes[\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or temp.mapes[\\\"hp_selection\\\"] < overall_run_best.mapes[\\\"hp_selection\\\"]:\\n overall_run_best = temp\\n best_model_description = overall_run_best.print_model()\\n self._logger.info(\\\"<--Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best.get_signature()[3:], \\\"(\\\" + best_model_description + \\\")\\\" if best_model_description else \\\"\\\", overall_run_best.mapes[\\\"training\\\"], overall_run_best.mapes[\\\"hp_selection\\\"], overall_run_best.mapes[\\\"validation\\\"])\\n\\n elif (validation, hp_selection) in {(\\\"KFold\\\", \\\"All\\\"), (\\\"KFold\\\", \\\"HoldOut\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each fold, for each technique, the best configuration\\n run_fold_tec_best_conf = recursivedict()\\n\\n # Hyperparameter search inside each fold\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n fold = int(conf.get_signature()[1].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] + conf.mapes[set_name] / folds\\n # First experiment for this fold+technique or better than the current best\\n if technique not in run_fold_tec_best_conf[run][fold] or conf.mapes[\\\"hp_selection\\\"] < run_fold_tec_best_conf[run][fold][technique].mapes[\\\"hp_selection\\\"]:\\n run_fold_tec_best_conf[run][fold][technique] = conf\\n\\n # Aggregate different folds (only the value of the mapes)\\n run_tec_set = recursivedict()\\n for run in run_fold_tec_best_conf:\\n for fold in run_fold_tec_best_conf[run]:\\n for tec in run_fold_tec_best_conf[run][fold]:\\n if \\\"hp_selection\\\" not in run_tec_set[run][technique]:\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = 0\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = run_fold_tec_best_conf[run][fold][tec].mapes[set_name]\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", str(run))\\n overall_run_best = ()\\n # Print data of single techniques\\n for technique in run_tec_set[run]:\\n self._logger.info(\\\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, run_tec_set[run][technique][\\\"training\\\"], run_tec_set[run][technique][\\\"hp_selection\\\"], run_tec_set[run][technique][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or run_tec_set[run][technique][\\\"hp_selection\\\"] < overall_run_best[1][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, run_tec_set[run][technique])\\n\\n self._logger.info(\\\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1][\\\"training\\\"], overall_run_best[1][\\\"hp_selection\\\"], overall_run_best[1][\\\"validation\\\"])\\n\\n # Overall best will contain as first argument the technique with the best (across runs) average (across folds) mape on validation; now we consider on all the runs and on all the folds the configuraiton of this technique with best validation mape\\n\\n elif (validation, hp_selection) in {(\\\"All\\\", \\\"KFold\\\"), (\\\"HoldOut\\\", \\\"KFold\\\"), (\\\"Extrapolation\\\", \\\"KFold\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each technique, for each configuration, the aggregated mape\\n run_tec_conf_set = recursivedict()\\n\\n # Hyperparameter search aggregating over folders\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n fold = int(conf.get_signature()[2].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n configuration = str(conf.get_signature()[4:])\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][configuration]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + conf.mapes[set_name] / folds\\n\\n # Select the best configuration for each technique across different folders\\n run_tec_best_conf = recursivedict()\\n for run in run_tec_conf_set:\\n for tec in run_tec_conf_set[run]:\\n for conf in run_tec_conf_set[run][tec]:\\n if tec not in run_tec_best_conf[run] or run_tec_conf_set[run][tec][conf][\\\"hp_selection\\\"] < run_tec_best_conf[run][tec][1][\\\"hp_selection\\\"]:\\n run_tec_best_conf[run][tec] = (conf, run_tec_conf_set[run][tec][conf])\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", run)\\n overall_run_best = () # (technique, configuration, mapes)\\n # Print data of single techniques\\n for technique in run_tec_best_conf[run]:\\n temp = run_tec_best_conf[run][technique]\\n self._logger.info(\\\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, temp[0], temp[1][\\\"training\\\"], temp[1][\\\"hp_selection\\\"], temp[1][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or temp[1][\\\"hp_selection\\\"] < overall_run_best[2][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, temp[0], temp[1])\\n\\n self._logger.info(\\\"---Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1], overall_run_best[2][\\\"training\\\"], overall_run_best[2][\\\"hp_selection\\\"], overall_run_best[2][\\\"validation\\\"])\\n\\n elif (validation, hp_selection) in {(\\\"KFold\\\", \\\"KFold\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each external fold, for each technique, the aggregated mape\\n run_efold_tec_conf_set = recursivedict()\\n\\n # Hyperparameter search aggregating over internal folders\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n ext_fold = int(conf.get_signature()[2].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n configuration = str(conf.get_signature()[4:])\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][configuration]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\\n if configuration not in run_efold_tec_conf_set[run][ext_fold][technique]:\\n for set_name in set_names:\\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\\n\\n # Select the best configuration for each technique in each external fold across different internal folders\\n run_efold_tec_best_conf = recursivedict()\\n for run in run_efold_tec_conf_set:\\n for efold in run_efold_tec_conf_set[run]:\\n for tec in run_efold_tec_conf_set[run][efold]:\\n for conf in run_efold_tec_conf_set[run][efold][tec]:\\n if conf not in run_efold_tec_best_conf[run][efold][tec] or run_efold_tec_conf_set[run][efold][tec][conf][\\\"hp_selection\\\"] < run_efold_tec_best_conf[run][efold][tec][1][\\\"hp_selection\\\"]:\\n run_efold_tec_best_conf[run][efold][tec] = (conf, run_efold_tec_conf_set[run][efold][tec][conf], run_efold_tec_conf_set[run][efold][tec][conf])\\n\\n # Aggregate on external folds\\n run_tec_set = recursivedict()\\n for run in run_efold_tec_best_conf:\\n for efold in run_efold_tec_best_conf[run]:\\n for tec in run_efold_tec_best_conf[run][efold]:\\n if \\\"hp_selection\\\" not in run_tec_set[run][tec]:\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = 0\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = run_tec_set[run][tec][set_name] + run_efold_tec_best_conf[run][efold][tec][1][set_name]\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", run)\\n overall_run_best = ()\\n # Print data of single techniques\\n for technique in run_tec_set[run]:\\n self._logger.info(\\\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, run_tec_set[run][technique][\\\"training\\\"], run_tec_set[run][technique][\\\"hp_selection\\\"], run_tec_set[run][technique][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or run_tec_set[run][technique][\\\"hp_selection\\\"] < overall_run_best[1][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, run_tec_set[run][technique])\\n\\n self._logger.info(\\\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1][\\\"training\\\"], overall_run_best[1][\\\"hp_selection\\\"], overall_run_best[1][\\\"validation\\\"])\\n\\n else:\\n self._logger.error(\\\"Unexpected combination: %s\\\", str((validation, hp_selection)))\\n sys.exit(1)\\n best_confs = {}\\n best_technique = None\\n for conf in self._exp_confs:\\n technique = conf.technique\\n if technique not in best_confs or conf.mapes[\\\"validation\\\"] < best_confs[technique].mapes[\\\"validation\\\"]:\\n best_confs[technique] = conf\\n for technique in best_confs:\\n if not best_technique or best_confs[technique].mapes[\\\"validation\\\"] < best_confs[best_technique].mapes[\\\"validation\\\"]:\\n best_technique = technique\\n if bool(self._campaign_configuration['General']['details']):\\n for run in run_tec_conf_set:\\n for tec in run_tec_conf_set[run]:\\n for conf in run_tec_conf_set[run][tec]:\\n assert \\\"hp_selection\\\" in run_tec_conf_set[run][tec][conf]\\n assert \\\"validation\\\" in run_tec_conf_set[run][tec][conf], \\\"training MAPE not found for \\\" + str(run) + str(tec) + str(conf)\\n self._logger.info(\\\"Run %s - Technique %s - Conf %s - Training MAPE %f - Test MAPE %f\\\", str(run), ec.enum_to_configuration_label[tec], str(conf), run_tec_conf_set[run][tec][conf][\\\"hp_selection\\\"], run_tec_conf_set[run][tec][conf][\\\"validation\\\"])\\n return best_confs, best_technique\",\n \"def save_cma_optimization_results(self, es):\\n # code extra verbose to understand what is going on\\n generation = es.result.iterations\\n evals = es.result.evaluations # number of evals at start of each gen\\n xfavorite = es.result.xfavorite # center of distribution, best est\\n stds = es.result.stds # stds of distribution, stds of xfavorite\\n fbest = es.result.fbest # best ever measured\\n xbest = es.result.xbest # coordinates of best ever measured\\n evals_best = es.result.evals_best # index of best measurement\\n\\n if not self.minimize_optimization:\\n fbest = -fbest\\n\\n results_array = np.concatenate([[generation, evals],\\n xfavorite, stds,\\n [fbest], xbest, [evals_best]])\\n if (not 'optimization_result'\\n in self.data_object[EXPERIMENTAL_DATA_GROUP_NAME].keys()):\\n opt_res_grp = self.data_object[EXPERIMENTAL_DATA_GROUP_NAME]\\n self.opt_res_dset = opt_res_grp.create_dataset(\\n 'optimization_result', (0, len(results_array)),\\n maxshape=(None, len(results_array)),\\n dtype='float64')\\n\\n # FIXME: Jan 2018, add the names of the parameters to column names\\n self.opt_res_dset.attrs['column_names'] = h5d.encode_to_utf8(\\n 'generation, ' + 'evaluations, ' +\\n 'xfavorite, ' * len(xfavorite) +\\n 'stds, '*len(stds) +\\n 'fbest, ' + 'xbest, '*len(xbest) +\\n 'best evaluation,')\\n\\n old_shape = self.opt_res_dset.shape\\n new_shape = (old_shape[0]+1, old_shape[1])\\n self.opt_res_dset.resize(new_shape)\\n self.opt_res_dset[-1, :] = results_array\",\n \"def compute_cost_clarans(data, _cur_choice):\\n # modified from that of CLARA\\n total_cost = 0.0\\n medoids = {}\\n for idx in _cur_choice:\\n medoids[idx] = []\\n\\n for i in list(data.index):\\n choice = -1\\n min_cost = np.inf\\n for m in medoids:\\n # fast_euclidean from CLARA\\n tmp = np.linalg.norm(data.loc[m] - data.loc[i])\\n if tmp < min_cost:\\n choice = m\\n min_cost = tmp\\n\\n medoids[choice].append(i)\\n total_cost += min_cost\\n # print(\\\"total_cost: \\\", total_cost)\\n return total_cost, medoids\",\n \"def get_result(self, collector_set):\\n\\t\\traise NotImplementedError\",\n \"def get_winners(self):\\n\\n if self.optimal is not None:\\n return self.optimal\\n clean_proposals = self.cleaner.create_scenarios(self.proposals)\\n self.optimal = self.optimizer.optimize(clean_proposals)\\n return self.optimal\",\n \"def ml_result(self, var, e):\\n\\t\\tdist = self.enumerate_ask(var, e)\\n\\t\\treturn max(dist.items(), key=lambda x:x[1])[0]\",\n \"def _get_best(self, populations, func):\\n best = None\\n for population in populations:\\n for item in population:\\n if not best:\\n best = item\\n elif func.fit(*item) > func.fit(*best):\\n best = item\\n return best\",\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def get_best_result(self) -> Optional[Tuple[int, Module, Dict[str, Dict[str, Tensor]], float, List[Dict]]]:\\n if self._best_task_id is not None:\\n compact_model = torch.load(Path(self._log_dir_root, 'best_result', 'model.pth'))\\n compact_model_masks = torch.load(Path(self._log_dir_root, 'best_result', 'masks.pth'))\\n with Path(self._log_dir_root, 'best_result', 'config_list.json').open('r') as f:\\n config_list = json_tricks.load(f)\\n return self._best_task_id, compact_model, compact_model_masks, self._best_score, config_list\\n return None\",\n \"def compute_statistics(self):\",\n \"def _choose_best_option(self):\",\n \"def result(self):\\n return min(self.population, key=lambda individual: individual.get_fitness())\",\n \"def get_best_individual(self):\\n return self._best_indv\",\n \"def get_so_results(self, save=False):\\n #Read through output files\\n parameters=self.get_optimization_parameters(friendly=True)\\n parameterRange = range(len(parameters))\\n\\n results = []\\n\\n for i in parameterRange:\\n result = {\\n 'name': parameters[i][0],\\n 'max_result': '?',\\n 'max_evals' : '?',\\n 'max_cpu' : '?',\\n 'min_result' : '?',\\n 'min_evals' : '?',\\n 'min_cpu' : '?',\\n }\\n #Read min and max files\\n for max in [0, 1]:\\n iterator = 0\\n \\n try:\\n file = open(os.path.join(self.path, 'output_1.%d.txt' % (2*i + max)),'r')\\n output=[None for r in range(4)]\\n for f in file.readlines():\\n value = f.rstrip('\\\\n') #Read the file line by line.\\n #Line 0: seperator. Line 1: Evals. Line 2: Time. Line 3: result\\n index=parameterRange.index(i)\\n output[iterator] = value\\n iterator = (iterator + 1)%4\\n file.close()\\n evals = output[1].split(' ')[2]\\n cpu_time = output[2].split(' ')[2]\\n sens_result = output[3]\\n \\n if max == 0:\\n max_str = 'max'\\n else:\\n max_str = 'min'\\n result[max_str + '_result'] = sens_result\\n result[max_str + '_cpu'] = cpu_time\\n result[max_str + '_evals'] = evals\\n \\n except:\\n raise\\n \\n results.append(result)\\n \\n #Finally, if save==True, write these results to file results.txt\\n if save:\\n if not os.path.isfile(os.path.join(self.path, 'results.txt')):\\n results_file = open(os.path.join(self.path, 'results.txt'), 'w')\\n header_line = 'Parameter name\\\\tMin result\\\\tMax result\\\\tMin CPU time\\\\tMin Evals\\\\tMax CPU time\\\\tMax Evals\\\\n'\\n results_file.write(header_line)\\n for result in results:\\n result_line = result['name'] + '\\\\t' + result['min_result'] + '\\\\t' + result['max_result'] + '\\\\t' + result['min_cpu'] + '\\\\t' + result['min_evals'] + '\\\\t' + result['max_cpu'] + '\\\\t' + result['max_evals'] + '\\\\n'\\n results_file.write(result_line)\\n results_file.close()\\n return results\",\n \"def getBestOption(self):\\n if len(self.Data) < 1:\\n return None\\n else:\\n bestR = max(self.Data.items(), key=lambda x: x[1]['SPat'].I)\\n return bestR[1]\",\n \"def get_results(self):\\n return self.result\",\n \"def _find_solution(self, population, num_of_best_chromosomes):\\n data = self._Individuals()\\n for x in population:\\n curr_fit = self._fitness(x)\\n data.append_object(self._Individual(curr_fit, x))\\n return data.sort_objects()[:num_of_best_chromosomes]\",\n \"def _extract_results(self) -> None:\\n metric_name = self.metric.name\\n for inference_name in ['train', 'test', 'opt']:\\n # TODO: Extract information from self.search_results\\n data = getattr(self.search_results, f'{inference_name}_metric_dict')[metric_name]\\n if all([d is None for d in data]):\\n if inference_name not in OPTIONAL_INFERENCE_CHOICES:\\n raise ValueError(f\\\"Expected {metric_name} score for {inference_name} set\\\"\\n f\\\" to not be None, but got {data}\\\")\\n else:\\n continue\\n self.data[f'single::{inference_name}::{metric_name}'] = np.array(data)\\n\\n if self.ensemble_results.empty() or inference_name == 'opt':\\n continue\\n\\n data = getattr(self.ensemble_results, f'{inference_name}_scores')\\n if all([d is None for d in data]):\\n if inference_name not in OPTIONAL_INFERENCE_CHOICES:\\n raise ValueError(f\\\"Expected {metric_name} score for {inference_name} set\\\"\\n f\\\" to not be None, but got {data}\\\")\\n else:\\n continue\\n self.data[f'ensemble::{inference_name}::{metric_name}'] = np.array(data)\",\n \"def getOptimalSolution(self):\\n max_index = np.argmax(self.Ws)\\n self.Wmax = self.Ws[max_index]\\n self.Emax = self.subsets[max_index]\\n return (self.Wmax, self.Emax)\",\n \"def best(self):\\n if len(self) == 0:\\n return None\\n return max_elems(self, key=attr.getter(\\\"value\\\"), gt=self.solver.sense.is_better)[0]\",\n \"def find_best_solution_and_score(self):\\r\\n best_score = MAXSIZE\\r\\n best_solution = self.simulation.solutions[0]\\r\\n for solution in self.simulation.solutions:\\r\\n score = self.simulation.fitting_function.fit_score(solution)\\r\\n if score < best_score:\\r\\n best_score = score\\r\\n best_solution = solution\\r\\n return best_solution, best_score\",\n \"def _evaluate(self):\\n if not self._evaluated:\\n query = { 'query' : self._query.serialize() }\\n if self._min_score is not None:\\n query['min_score'] = self._min_score\\n if self._highlight is not None:\\n query['highlight'] = self._highlight\\n if self._order is not None:\\n query['sort'] = self._order\\n\\n params = {}\\n if self._offset is not None:\\n params['from'] = int(self._offset)\\n if self._limit is not None:\\n params['size'] = int(self._limit)\\n if self._only_fields:\\n params['fields'] = \\\",\\\".join(self._only_fields)\\n\\n self._results = self._document._meta.search_engine.search(\\n query,\\n **params\\n )\\n self._evaluated = True\\n\\n return self._results\",\n \"def ordered_result(self):\\n cc = Counter(self._counter)\\n return cc.most_common(self._qtd) #qtd is a cli arg used on --top-ips <number>\",\n \"def find_bestParameter(self,currentEnergy):\\n if currentEnergy==5.89:\\n currentEnergy=6.4\\n print(\\\"WARNING !!!!!!!! E=5.89 KeV ==>> uso best value trovato a 6.4 KeV !!!!!\\\")\\n \\n \\n index_summary=1e6\\n try:\\n index_summary=np.where( np.logical_and ( self.energy<(float(currentEnergy)+0.05), self.energy >(float(currentEnergy)-0.05) ) )[0][0]\\n print (\\\"readSummaryData: energia trovata! index = \\\",index_summary)\\n except:\\n print (\\\"readSummaryData: energia *NON* trovata nello scan ploarizzato\\\")\\n\\n \\n bestPar=1e6 \\n if ( index_summary<1000):\\n bestPar=self.best_val[index_summary]\\n \\n return bestPar\",\n \"def find_bestParameter(self,currentEnergy):\\n if currentEnergy==5.89:\\n currentEnergy=6.4\\n print(\\\"WARNING !!!!!!!! E=5.89 KeV ==>> uso best value trovato a 6.4 KeV !!!!!\\\")\\n \\n \\n index_summary=1e6\\n try:\\n index_summary=np.where( np.logical_and ( self.energy<(float(currentEnergy)+0.05), self.energy >(float(currentEnergy)-0.05) ) )[0][0]\\n print (\\\"readSummaryData: energia trovata! index = \\\",index_summary)\\n except:\\n print (\\\"readSummaryData: energia *NON* trovata nello scan ploarizzato\\\")\\n\\n \\n bestPar=1e6 \\n if ( index_summary<1000):\\n bestPar=self.best_val[index_summary]\\n \\n return bestPar\",\n \"def get_expected_cost(self):\",\n \"def result(self):\\r\\n # TODO: how about xcurrent?\\r\\n return self.best.get() + (\\r\\n self.countevals, self.countiter, self.gp.pheno(self.mean), self.gp.scales * self.sigma * self.sigma_vec * self.dC**0.5)\",\n \"def getAlgoResult(self):\\n return _SALOMERuntime.OptimizerAlgASync_getAlgoResult(self)\",\n \"def get_best_value(self):\\n # Todo: implement\\n best_value_global = -inf\\n for particle in self.particles:\\n if particle.best_value >= best_value_global:\\n best_value_global = particle.best_value\\n return best_value_global # Remove this line\",\n \"def results(self):\\n pass\",\n \"def get_best_worst():\\n return make_response(jsonify(storage.ranking), 200)\",\n \"def results(self):\\r\\n pass\",\n \"def getAlgoResult(self):\\n return _SALOMERuntime.OptimizerAlgSync_getAlgoResult(self)\",\n \"def get_best_match(self, list):\\n raise NotImplementedError\",\n \"def populate_pool_results(self, miner, worker, pool, algo, algo_idx, coin_idx, coin_cost,\\n profitability, speed_accepted, speed_reported, speed_suffix):\\n\\n # Determine how much COIN is being generated per minute for the\\n # accepted hashrate (stats are usually collected once each minute)\\n # multiply the number of units of speed (speed accepted) by the profitability,\\n # divided by 1440 minutes per day\\n\\n coin_generated_per_minute = (profitability * speed_accepted) / (60 * 24)\\n\\n # compute amount of power used and the cost of that power, per minute\\n power_used, power_used_cost = get_power_usage_info_per_algo_per_minute(self, miner, algo)\\n\\n # must always set worker, algo, pool\\n self.set_result(miner, 'worker', worker)\\n self.set_result(miner, 'algo', algo_idx)\\n self.set_result(miner, 'pool', pool)\\n\\n # set the algo stats - for hashrate calculations later\\n\\n self.set_result(miner, 'hashrates_by_algo',\\n {algo: {'accepted': speed_accepted,\\n 'reported': speed_reported,\\n 'speed_suffix': speed_suffix}})\\n\\n # derived stats\\n self.set_result(miner, 'power_used', power_used)\\n self.set_result(miner, 'power_used_cost', power_used_cost)\\n self.set_result(miner, 'coin', coin_idx)\\n self.set_result(miner, 'coin_cost', coin_cost)\\n self.set_result(miner, 'coin_mined', coin_generated_per_minute)\\n\\n # save the current coin index in the miner\\n miner.coin_idx = coin_idx\\n\\n # how much would it cost to purchase this much generated coin, instead?\\n coin_purchase_cost = (coin_cost * coin_generated_per_minute)\\n self.set_result(miner, 'coin_purchase_cost', coin_purchase_cost)\\n\\n # did we get power used cost so we can determine Profitability?\\n if power_used_cost is not None and power_used_cost != 0:\\n\\n # PROFITABILITY - (cost to buy) / (cost to mine) >1 is profitable\\n self.set_result(miner, 'profitability', (coin_purchase_cost / power_used_cost))\\n\\n # BOOLEAN is it profitable\\n self.set_result(miner, 'profitable', (coin_purchase_cost > power_used_cost))\",\n \"def get_best_solution(self):\\n if not self.tours:\\n raise Exception('No solution has been computed yet')\\n scores = {s:get_cost(self.tours[s],self) for s in self.tours}\\n best = min(scores,key=scores.get)\\n print('The best solution is given by {} with score {}'.format(best,scores[best]))\\n return self.tours[best]\",\n \"def __call__(self, **kwds):\\n best = kwds['best']\\n print(best.pbestval)\\n sys.stdout.flush()\",\n \"def get_personal_best(self):\\n return self._personal_best\",\n \"def fetch(\\n self,\\n search_method: str,\\n objective_function: str,\\n weight: int,\\n ):\\n if os.path.isfile(self.filename):\\n with open(self.filename, 'r+') as f:\\n table = pandas.io.json.read_json(f)\\n try:\\n table = table[(table[\\\"objective\\\"] == objective_function)\\n & (table[\\\"weight\\\"] == weight)\\n & (table[\\\"search\\\"] == search_method)]\\n best = table.loc[table['cost'].idxmax()]\\n self.best_cost = best[\\\"cost\\\"]\\n return best[\\\"code\\\"], best[\\\"cost\\\"], best[\\\"progress\\\"]\\n except (ValueError, KeyError):\\n pass\\n return None, -np.inf, 0\",\n \"def __evaluateLocal__(self,featureVals):\\n returnEvaluation = {self.pivotParameterID:self.pivotValues}\\n for target in list(set(self.target) - set([self.pivotParameterID])):\\n reconstructData = self._reconstructData(target).real\\n # find the nearest data and compute weights\\n if len(reconstructData) > 1:\\n weights, indexes = self.KDTreeFinder.query(featureVals, k=min(2**len(self.features),len(reconstructData)))\\n # if 0 (perfect match), assign minimum possible distance\\n weights[weights == 0] = sys.float_info.min\\n weights =1./weights\\n # normalize to 1\\n weights = weights/weights.sum()\\n for point in range(len(weights)):\\n returnEvaluation[target] = np.sum ((weights[point,:]*reconstructData[indexes[point,:]].T) , axis=1)\\n else:\\n returnEvaluation[target] = reconstructData[0]\\n\\n return returnEvaluation\",\n \"def find_best(self):\\n best_st = 0\\n best_bt = 0\\n best_perf = -1.1\\n for bt in self.btl:\\n for st in self.stl:\\n if self.total[bt, st, \\\"perf\\\"] > best_perf:\\n best_perf = self.total[bt, st, \\\"perf\\\"]\\n best_st = st\\n best_bt = bt\\n return (best_perf, self.total[best_bt, best_st, \\\"count\\\"], best_bt, best_st)\",\n \"def get_results(self):\\n return self.results\",\n \"def get_results(self):\\n return self.results\",\n \"def get_best_vector(results, f_x, target):\\n index_min = -1\\n cur_min = 10**10\\n\\n with Session() as sess:\\n for index, individual in enumerate(results):\\n f_x_res = sess.run(f_x, feed_dict={\\n target: individual\\n })\\n if f_x_res < cur_min:\\n cur_min = f_x_res\\n index_min = index\\n\\n best = results[index_min]\\n\\n return best\",\n \"def best(self, side):\\n return Library.functions.best(self._book, side)\",\n \"def strategy_best(cookies, cps, time_left, build_info):\\n items = build_info.build_items()\\n result = None\\n cost = 0\\n overall = cookies + time_left * cps\\n for item in items:\\n temp_cost = build_info.get_cps(item) / build_info.get_cost(item)\\n if temp_cost <= overall and cost < temp_cost:\\n result = item\\n cost = temp_cost\\n return result\",\n \"def _optimise(self):\\n pass\",\n \"def run(self):\\n best_score = float('inf')\\n best_route = None\\n best_nr_iterations = None\\n best_tabu_list_size = None\\n for i in range(self.range_iterations_start, self.range_iterations_end, 10):\\n for j in range(self.range_tabu_list_start, self.range_tabu_list_end):\\n print('testing for nr_iterations', i, ' and tabu list size', j)\\n self.hc.generate_initial_solution(use_seed=True)\\n score, route, iteration = self.hc.solve(tabu=self.tabu, with_time_windows=self.with_time_windows,\\n nr_iterations=i, tabu_size=j,\\n allow_infeasibilites=self.allow_infeasibilites)\\n\\n if score < best_score:\\n best_score = score\\n best_route = route\\n best_nr_iterations = i\\n best_tabu_list_size = j\\n\\n print('best results with sore', best_score, best_nr_iterations, best_tabu_list_size )\\n return best_score, best_route, best_tabu_list_size\",\n \"def Results(self):\\n return self.data\",\n \"def Results(self):\\n return self.data\",\n \"def getResults(solver, minBit, maxBit, saveFile, noResults):\\n\\n for k in range(minBit, maxBit + 1, 2):\\n for i in range(noResults):\\n\\n keys = generate_RSA.KeyGen(k) # initialise keys\\n keys.generateKeys() # generate keys\\n\\n solver.setN(keys.n) # setup solver\\n solver.setE(keys.e)\\n\\n solver.solve() # solve problem\\n\\n if solver.d == keys.d: # if we got it right\\n resTime = resTime_C # update correct dictionaries\\n resCount = resCount_C\\n resSpace = resSpace_C\\n else:\\n resTime = resTime_W # else update wrong dictionaries\\n resCount = resCount_W\\n resSpace = resSpace_W\\n\\n if k not in resTime: # if we've not yet had a result for k\\n resTime[k] = [solver.time, 1] # then set\\n resSpace[k] = [solver.space, 1] # then set\\n resCount[k] = [solver.count, 1]\\n else:\\n oldT, oldC = resTime[k] # keeps a running average\\n newC = oldC + 1 # increment count\\n newT = ((oldT * oldC) + solver.time) / newC # get new averagae\\n resTime[k] = [newT, newC] # without storing all variables\\n\\n oldS, oldC = resSpace[k] # keeps a running average\\n newS = ((oldS * oldC) + solver.space) / newC\\n resSpace[k] = [newS, newC] # without storing all variables\\n\\n oldCount, oldC = resCount[k] # keeps a running average\\n newCount = ((oldCount * oldC) + solver.count) / newC\\n resCount[k] = [newCount, newC] # without storing all variables\\n\\n if i % 10 == 0:\\n saveResults(saveFile) # every ten results save again\",\n \"def __call__(self, num_perms=999):\\r\\n res = super(Best, self).__call__()\\r\\n cats = self.Categories\\r\\n dm = self.DistanceMatrices[0]\\r\\n dm_flat = dm.condensed_form()\\r\\n\\r\\n row_count = dm.shape[0]\\r\\n col_count = len(cats)\\r\\n sum = 0\\r\\n stats = [(-777777777, '') for c in range(col_count + 1)]\\r\\n for i in range(1, col_count + 1):\\r\\n combo = combinations([j for j in range(1, col_count + 1)], i)\\r\\n\\r\\n for element in combo:\\r\\n cat_mat = self._make_cat_mat(cats, element)\\r\\n cat_dm = self._derive_euclidean_dm(cat_mat, row_count)\\r\\n cat_dm_flat = cat_dm.condensed_form()\\r\\n r = spearman(dm_flat, cat_dm_flat)\\r\\n if r > stats[i - 1][0]:\\r\\n stats[i - 1] = (r, ','.join(str(s) for s in element))\\r\\n\\r\\n res['method_name'] = 'BEST'\\r\\n res['num_vars'] = col_count\\r\\n res['vars'] = ['%s = %d' % (name, val + 1)\\r\\n for val, name in enumerate(cats)]\\r\\n res['rho_vals'] = stats[:-1]\\r\\n\\r\\n return res\",\n \"def hardest_read(self, it):\\n workers = multiprocessing.cpu_count()\\n # highest_avg=0\\n texts = []\\n while True:\\n try:\\n texts.append(it.__next__())\\n except StopIteration:\\n break\\n\\n with ProcessPoolExecutor(workers) as ex:\\n res = ex.map(self.avg_vowels, texts)\\n result = dict(zip([filename for filename in self.filenames], [avg for avg in list(res)]))\\n maxi = max(result, key=result.get) # finding key with max value\\n return maxi\",\n \"def localResultSet(options=None):\\n options = {} if options is None else options\\n results = {}\\n for problem in generateProblem(options):\\n _, solutions = solver.numberOfSolutions(\\n problem, returnWays=True)\\n results[tuple(problem)] = difficulty(solutions)\\n\\n # sort from easiest to hardest\\n results = sorted(list(results.iteritems()), key=lambda x: x[1])\\n return results\",\n \"def greedy(items, maxCost, keyFunction):\\n result = []\\n itemsCopy = sorted(items, key=keyFunction, reverse=True)\\n totalValue , totalCalories = 0.0, 0.0\\n for i in range(len(itemsCopy)):\\n item = itemsCopy[i]\\n if (totalCalories + item.getCalories()) <= maxCost:\\n result.append(item)\\n totalCalories += item.getCalories()\\n totalValue += item.getValue()\\n return result, totalValue\",\n \"def get_best_candidate(self):\\n if not self.scores:\\n return None\\n return self.te_list[self.scores.index(max(self.scores))]\",\n \"def process_or_results(self, filenames):\\n \\n #Check if we're maximising or minimising\\n optTask = self._getTask('optimization')\\n problem = optTask.find(xmlns + 'Problem')\\n for parameter in problem:\\n if parameter.attrib['name']=='Maximize':\\n max_param = parameter.attrib['value']\\n if max_param == '0':\\n maximize = False\\n else:\\n maximize = True\\n \\n output_file = open(os.path.join(self.path, 'raw_results.txt'), 'w')\\n \\n\\n #Match a string of the format ( 0.0995749 0.101685 0.108192 0.091224 ) 0.091224 0 \\n #Contains parameter values, the best optimization value, the cpu time, and some other values.\\n output_string = r'\\\\(\\\\s(?P<params>.+)\\\\s\\\\)\\\\s+(?P<best_value>\\\\S+)\\\\s+(?P<cpu_time>\\\\S+)\\\\.*'\\n output_re = re.compile(output_string)\\n \\n best_value = None\\n best_line = None\\n \\n #Copy the contents of the first file to results.txt\\n for line in open(os.path.join(self.path, filenames[0]), 'r'):\\n output_file.write(line)\\n if line != '\\\\n':\\n if output_re.match(line):\\n value = float(output_re.match(line).groupdict()['best_value'])\\n if best_value != None and maximize:\\n if value > best_value:\\n best_value = value\\n best_line = line\\n elif best_value != None and not maximize:\\n if value < best_value:\\n best_value = value\\n best_line = line\\n elif best_value == None:\\n best_value = value\\n best_line = line\\n else:\\n pass\\n \\n #And for all other files, copy everything but the last line\\n for filename in filenames[1:]:\\n firstLine = True\\n for line in open(os.path.join(self.path,filename), 'r'):\\n if not firstLine:\\n output_file.write(line)\\n if line != '\\\\n':\\n if output_re.match(line):\\n value = float(output_re.match(line).groupdict()['best_value'])\\n if maximize:\\n if value > best_value:\\n best_value = value\\n best_line = line\\n elif not maximize:\\n if value < best_value:\\n best_value = value\\n best_line = line\\n else:\\n pass\\n firstLine = False\\n \\n \\n output_file.close()\\n \\n #Write the best value to results.txt\\n output_file = open(os.path.join(self.path, 'results.txt'), 'w')\\n \\n output_file.write('Best value\\\\t')\\n \\n for parameter in self.get_optimization_parameters():\\n\\n output_file.write(parameter[0].encode('utf8'))\\n output_file.write('\\\\t')\\n output_file.write('\\\\n')\\n\\n best_line_dict = output_re.match(best_line).groupdict()\\n\\n output_file.write(best_line_dict['best_value'])\\n output_file.write('\\\\t')\\n \\n for parameter in best_line_dict['params'].split('\\\\t'):\\n output_file.write(parameter)\\n output_file.write('\\\\t')\\n output_file.close()\",\n \"def get_best(self, population):\\n best = min(population, key=self.cost_function)\\n return best, self.cost_function(best)\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def _find_best_offer(\\n self, all_offers: List[Tuple[str, Dict]]\\n ) -> Tuple[List, float]:\\n bests, best_gain = [], 0\\n\\n for partner, offers in all_offers:\\n partial_asgt = self._neighbors_values.copy()\\n current_partner = self._neighbor_var(partner)\\n\\n # Filter out the constraints linking those two variables to avoid\\n # counting their cost twice.\\n shared = find_dependent_relations(current_partner, self._constraints)\\n concerned = [rel for rel in self._constraints if rel not in shared]\\n\\n for (val_p, my_offer_val), partner_local_gain in offers.items():\\n partial_asgt.update({partner: val_p, self.variable.name: my_offer_val})\\n\\n # Then we evaluate the agent constraint's for the offer\\n # and add the partner's local gain.\\n cost = assignment_cost(partial_asgt, concerned)\\n global_gain = self.current_cost - cost + partner_local_gain\\n\\n if (global_gain > best_gain and self._mode == \\\"min\\\") or (\\n global_gain < best_gain and self._mode == \\\"max\\\"\\n ):\\n bests = [(val_p, my_offer_val, partner)]\\n best_gain = global_gain\\n elif global_gain == best_gain:\\n bests.append((val_p, my_offer_val, partner))\\n\\n return bests, best_gain\",\n \"def strategy_best(cookies, cps, time_left, build_info):\\n return_item = None\\n highest_icr = float('-inf')\\n item_list = build_info.build_items()\\n cookies_potential = cookies + time_left * cps\\n for item in item_list:\\n cost = build_info.get_cost(item)\\n curr_icr = build_info.get_cps(item) / cost \\n if cookies_potential >= cost and curr_icr > highest_icr:\\n return_item = item\\n highest_icr = curr_icr\\n return return_item\",\n \"def compute(self) -> Any:\\n self._check_for_increment(\\\"compute\\\")\\n return self[-1].compute()\",\n \"def get_optimums(self, model, size, excludes):\\n raise NotImplementedError\",\n \"def getOptimalParams(self):\\n\\t\\t# Load calibration chain and find optimal for like1\\n\\t\\tcal_data = pd.read_csv(self.database_path, sep=',')\\n\\t\\tparams = cal_data.ix[cal_data['like1'].idxmax()].to_dict()\\n\\t\\tcost = params['like1']\\n\\t\\t# reformat parameters to match original naming\\n\\t\\tparams_reformatted = {}\\n\\t\\tfor k, p in self.cal_params.items():\\n\\t\\t\\tparams_reformatted[k] = params['par'+k]\\n\\n\\t\\treturn params_reformatted, cost\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n aStarSearch(problem)\",\n \"def get_sol(self):\",\n \"def Collection_return_selected(C:list) -> list:\\r\\n p = int(input(\\\"Please enter the maximum average price: \\\"))\\r\\n c = input(\\\"Please enter preferred cuisine: \\\")\\r\\n cheap = Collection_select_cheap(C, p)\\r\\n cuisine = Collection_select_cuisine(C, c)\\r\\n result = []\\r\\n for r in cheap:\\r\\n for rc in cuisine:\\r\\n if r == rc:\\r\\n result.append(r)\\r\\n return result\",\n \"def _get_aggregated_results(self):\\n gradients = self.gradients\\n client_traj_infos = flatten_lists(self.client_traj_infos)\\n client_opt_infos = self._combine_client_opt_infos(self.client_opt_infos)\\n \\n self.gradients = []\\n self.client_traj_infos = []\\n self.client_opt_infos = []\\n\\n return gradients, client_traj_infos, client_opt_infos\",\n \"def compute_objective(Instance: dict):\\r\\n\\r\\n print(\\\"Computing objectives values...\\\")\\r\\n # Retrieve usefull infos\\r\\n T_max = Instance[T_STR]\\r\\n scenario_numbers = Instance[SCENARIO_NUMBER]\\r\\n Interventions = Instance[INTERVENTIONS_STR]\\r\\n quantile = Instance[QUANTILE_STR]\\r\\n # Retrieve risk final distribution\\r\\n risk = compute_risk_distribution(Interventions, T_max, scenario_numbers)\\r\\n # Compute mean risk\\r\\n mean_risk = compute_mean_risk(risk, T_max, scenario_numbers)\\r\\n # Compute quantile\\r\\n q = compute_quantile(risk, T_max, scenario_numbers, quantile)\\r\\n print(\\\"Done\\\")\\r\\n\\r\\n return mean_risk, q\",\n \"def queryresults(templateList, res, epsilon, weight_for_hori):\\r\\n\\t# get Results column#\\r\\n\\tcoor_result = None\\r\\n\\tall_results = {}\\r\\n\\ttemp_all_results = {}\\r\\n\\tcoor_results = []\\r\\n\\tall_items = res.items()\\r\\n\\ttemp = deepcopy(res)\\r\\n\\tfor k, v in all_items:\\r\\n\\t\\tif k.count('结果'):\\r\\n\\t\\t\\ttemp.pop(k)\\r\\n\\t\\t\\tcoor_result = v\\r\\n\\t\\t\\tcoor_results.append(coor_result)#multiple same results, typically 2 results\\r\\n\\r\\n\\tres = deepcopy(temp)\\r\\n\\tdel temp\\r\\n\\r\\n\\tif coor_result is None:\\r\\n\\t\\traise Exception('No 结果 detected!')\\r\\n\\r\\n\\tx, y = coor_results[0][0], coor_results[0][1]\\r\\n\\tres_range1 = (x - epsilon, x + epsilon)#vertical 1\\r\\n\\tif len(coor_results) > 1:\\r\\n\\t\\tx, y = coor_results[1][0], coor_results[1][1]\\r\\n\\t\\tres_range2 = (x - epsilon, x + epsilon)#vertical 2\\r\\n\\r\\n\\telse:\\r\\n\\t\\tres_range2 = res_range1\\r\\n\\r\\n\\tfor item in templateList:#for each item, we iterate through the whole dictionary to find corresponding value\\r\\n\\t\\tcoor_result = None\\r\\n\\t\\tfor k, v in res.items():\\r\\n\\t\\t\\tif get_equal_rate(k, item) > 0.8:#string match\\r\\n\\t\\t\\t\\tres.pop(k)\\r\\n\\t\\t\\t\\tcoor_result = v\\r\\n\\t\\t\\t\\tbreak\\r\\n\\r\\n\\t\\tif coor_result is None:\\r\\n\\t\\t\\tall_results[item] = 'NOT DETECTED'\\r\\n\\r\\n\\t\\telse:\\r\\n\\t\\t\\tx, y = coor_result[0], coor_result[1]\\r\\n\\t\\t\\t#x_range = (x - epsilon, x + epsilon)\\r\\n\\t\\t\\ty_range = (y - epsilon, y + epsilon)#横坐标\\r\\n\\r\\n\\t\\t\\tfor k, v in res.items():\\r\\n\\t\\t\\t\\t#First, filter all results in the range of [x - epsilon, x + epsilon] and [y - epsilon, y + epsilon]\\r\\n\\t\\t\\t\\tif ((y_range[0] <= v[1] <= y_range[1]) and (res_range1[0] <= v[0] <= res_range1[1])) \\\\\\r\\n\\t\\t\\t\\t\\tor ((y_range[0] <= v[1] <= y_range[1]) and (res_range2[0] <= v[0] <= res_range2[1])):\\r\\n\\t\\t\\t\\t\\t#Then, we filter closer results in the same range, if we get two columns, v[0] - x makes sure\\r\\n\\t\\t\\t\\t\\t#we can find closer one, if we get multiple rows abs(v[1] - y) makes sure we can find nearest one\\r\\n\\t\\t\\t\\t\\tnow_residual = (v[0] - x) * weight_for_hori + abs(v[1] - y) * (1 - weight_for_hori)#weighted to say vertical line is more important\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tif (v[0] - x) >= 0:\\r\\n\\t\\t\\t\\t\\t\\tif item not in temp_all_results:\\r\\n\\t\\t\\t\\t\\t\\t\\ttemp_all_results[item] = now_residual\\r\\n\\t\\t\\t\\t\\t\\t\\tall_results[item] = k\\r\\n\\t\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\t\\tresidual = temp_all_results[item]\\r\\n\\t\\t\\t\\t\\t\\t\\tif residual > now_residual:\\r\\n\\t\\t\\t\\t\\t\\t\\t\\ttemp_all_results[item] = now_residual#compare residual, if old one is larger than the new one, then this key must be better\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tall_results[item] = k\\r\\n\\r\\n\\t\\t\\t\\t\\t\\t\\t# res.pop(k)\\r\\n\\t\\t\\t\\t\\t\\t\\t# break\\r\\n\\r\\n\\treturn all_results\",\n \"def results(algo = 0, minBit = 10, maxBit = 44, saveFile = \\\"results\\\", noResults = 100):\\n\\n solver = None\\n if algo == 0:\\n solver = brute_force.BFSolver(verbose = False)\\n elif algo == 1:\\n solver = fermats.FFSolver(verbose = False)\\n elif algo == 2:\\n solver = pollard_rho.RhoSolver(verbose = False)\\n elif algo == 3:\\n solver = knj_factorisation.KNJSolver(verbose = False)\\n elif algo == 4:\\n solver = pollard_p_minus_1.PSolver(verbose = False)\\n elif algo == 5:\\n solver = quadratic_sieve.QSolver(verbose = False)\\n\\n getResults(solver, minBit, maxBit, saveFile, noResults)\",\n \"def _evaluate_performance__static_winners(self):\\n # | - _evaluate_performance__\\n\\n # | - class attributes #################################################\\n AL = self\\n al_gen = self.al_gen\\n verbose = self.verbose\\n seed_ids = self.seed_ids\\n acquisition_bin = self.acquisition_bin\\n completed_ids = self.completed_ids\\n CandidateSpace = self.CandidateSpace\\n RegressionModel = self.RegressionModel\\n DuplicateFinder = self.DuplicateFinder\\n al_gen_dict = self.al_gen_dict\\n\\n stop_mode = self.stop_mode\\n stop_num_generations = self.stop_num_generations\\n\\n index_acq_gen_dict = self.index_acq_gen_dict\\n #__| #################################################################\\n\\n # #####################################################################\\n mode = \\\"lowest_N\\\" # 'lowest_N' or 'lowest_perc'\\n\\n N_ids = 10\\n lowest_perc = 5\\n\\n # Number of consecutive generations that the Nth best systems must\\n # remain static\\n M_gens = 3\\n # #####################################################################\\n\\n if mode == \\\"lowest_perc\\\":\\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\\n N_ids = int(num_candidates * (lowest_perc * 0.01))\\n\\n gen_keys = list(AL.al_gen_dict.keys())\\n\\n if len(gen_keys) > M_gens:\\n latest_M_keys = gen_keys[-(M_gens + 1):]\\n last_gen_key = gen_keys[-1]\\n\\n al_gen_dict_subset_i = dict(zip(\\n latest_M_keys,\\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\\n\\n indices_list = []\\n iterator = enumerate(al_gen_dict_subset_i.items())\\n for i_cnt, (gen_i, AL_i) in iterator:\\n model_i = AL_i.model\\n\\n model_i = AL.add_main_Y_to_model(\\n model_i, plot_dft_instead_of_pred=True)\\n model_i = model_i[(model_i[\\\"duplicate\\\"] == False)]\\n model_i = model_i.sort_values(\\\"Y_main\\\")\\n\\n indices_i = model_i.index.tolist()\\n\\n indices_list.append(indices_i)\\n\\n if i_cnt >= M_gens:\\n indices_i = indices_list[i_cnt][0:N_ids]\\n ids_static_list = []\\n for j in range(M_gens):\\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\\n ids_static = indices_j == indices_i\\n ids_static_list.append(ids_static)\\n\\n ids_are_static = all(ids_static_list)\\n\\n self.performance__static_winners[last_gen_key] = ids_are_static\\n #__|\",\n \"def test_best_hits_unique(self):\\n records = [h for _, h in self.result.best_hits_by_query(n=5)][0]\\n self.assertEqual(len(records), 3)\\n values = {tuple(h.values()) for h in records}\\n self.assertEqual(len(values), 3)\",\n \"def __next__(self):\\n self.rebuild_all()\\n\\n if not hasattr(self, \\\"demand_array\\\"):\\n self.build_demand_array()\\n\\n self.lci_calculation()\\n if self.lcia:\\n self.lcia_calculation()\\n if self.weighting:\\n self.weighting_calculation()\\n return self.score\\n else:\\n return self.supply_array\",\n \"def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\\n partial_asgt = self._neighbors_values.copy()\\n offers = dict()\\n\\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\\n partial_asgt.update(limited_asgt)\\n cost = self._compute_cost(**partial_asgt)\\n if self.logger.isEnabledFor(logging.DEBUG):\\n self.logger.debug(\\n f\\\"looking for offer : {partial_asgt} - cost {cost}\\\"\\n f\\\" current {self.current_cost} {self._mode}\\\"\\n )\\n\\n if (self.current_cost > cost and self._mode == \\\"min\\\") or (\\n self.current_cost < cost and self._mode == \\\"max\\\"\\n ):\\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\\n self.current_cost - cost\\n )\\n return offers\",\n \"def stats(self):\\n return self._solution\",\n \"def stats(self):\\n return self._solution\",\n \"def stats(self):\\n return self._solution\",\n \"def main():\\n # Retrieve csv_file name an max_investment from argument passed in console:\\n arg_csv_file, arg_max_investment = set_arg()\\n if arg_csv_file:\\n csv_file = arg_csv_file\\n else:\\n csv_file = 'dataset1_Python+P7.csv'\\n if arg_max_investment:\\n max_investment = float(arg_max_investment)\\n else:\\n max_investment = 500.00\\n\\n # Retrieve dataset:\\n base_dataset = open_convert_and_clean_csv(csv_file)\\n\\n # Retrieve solution:\\n start = time.perf_counter()\\n print()\\n print(f\\\"Processing with file '{csv_file}' containing {len(base_dataset)} shares...\\\")\\n print(f\\\"Maximum investment: {max_investment}€\\\")\\n print(\\\"Please wait...\\\")\\n computable_dataset = add_roi_to_dataset(convert_dataset_to_cents(base_dataset))\\n best_roi, combination = best_combination_dynamic(computable_dataset, max_investment)\\n\\n # Formatting results:\\n combination.sort(key=lambda x: x[2], reverse=True)\\n combination_in_euros = convert_dataset_to_euros(combination)\\n best_roi /= 100\\n # Following calculus is done on cent prices (combination) to avoid approximations with floats\\n shares_cost = calculate_shares_cost_sum(combination) / 100\\n\\n # Printing results:\\n print()\\n print(f\\\"Length of dataset: {len(computable_dataset)}\\\")\\n print(f\\\"Duration of Analysis: {elapsed_time_formatted(start)}\\\")\\n print()\\n print(f\\\"Best Return on investment after 2 years: {round(best_roi, 2)}€\\\")\\n print(f\\\"Number of shares to buy : {len(combination_in_euros)}\\\")\\n print(f\\\"Total cost: {round(shares_cost, 2)}€\\\")\\n print()\\n print(f\\\"Best combination of shares ordered by performance: \\\")\\n for share in combination_in_euros:\\n print(f\\\"{share[0]} | Price: {share[1]}€ | profit: {share[2]}%\\\")\\n print()\",\n \"def train(self): \\n start_time = time()\\n\\n # reset previous results\\n self.best_result = pd.DataFrame()\\n self.result = pd.DataFrame()\\n\\n # Generate dictionaries of all posible parameter permutations\\n keys, values = zip(*self.params.items())\\n self.permutations_dict = [dict(zip(keys, v)) for v in itertools.product(*values)] \\n\\n # Run through all models in parallel threads\\n with Pool(self.thread_cnt) as p:\\n result = p.map(self.analyze_model, self.permutations_dict)\\n\\n\\n # wrap up results\\n if self.classes_names: # acts as trigger for computation of cms\\n for i, dic in enumerate(result):\\n dic[\\\"id\\\"] = i\\n self.cms = [(dic[\\\"id\\\"] ,dic.pop(\\\"cm\\\")) for dic in result]\\n\\n self.result = pd.DataFrame(result)\\n self.best_result = self.result.iloc[self.result[\\\"score\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"f1_score\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"recall\\\"].argmax()] # store row with the best score\\n self.best_result = self.result.iloc[self.result[\\\"precision\\\"].argmax()] # store row with the best score\\n end_time = time()\\n print(\\\"Finished evaluation\\\")\\n print(\\\"Best parameteters found with:\\\", self.best_parameter_set())\\n print(\\\"score=\\\", self.best_score())\\n #print(\\\"f1_score=\\\", self.best_f1_score())\\n #print(\\\"recall_score=\\\", self.best_recall_score())\\n #print(\\\"precision_score=\\\", self.best_precision_score())\\n print(\\\"Total evaluation time = {:.2f}s\\\".format(end_time-start_time))\\n\\n return self.best_parameter_set(), self.best_score()\",\n \"def _estimate_elasticsearch_requirement(\\n instance: Instance,\\n desires: CapacityDesires,\\n working_set: float,\\n reads_per_second: float,\\n max_rps_to_disk: int,\\n zones_per_region: int = 3,\\n copies_per_region: int = 3,\\n) -> CapacityRequirement:\\n # Keep half of the cores free for background work (merging mostly)\\n needed_cores = math.ceil(sqrt_staffed_cores(desires) * 1.5)\\n # Keep half of the bandwidth available for backup\\n needed_network_mbps = simple_network_mbps(desires) * 2\\n\\n needed_disk = math.ceil(\\n (1.0 / desires.data_shape.estimated_compression_ratio.mid)\\n * desires.data_shape.estimated_state_size_gib.mid\\n * copies_per_region,\\n )\\n\\n # Rough estimate of how many instances we would need just for the the CPU\\n # Note that this is a lower bound, we might end up with more.\\n needed_cores = math.ceil(\\n max(1, needed_cores // (instance.cpu_ghz / desires.core_reference_ghz))\\n )\\n rough_count = math.ceil(needed_cores / instance.cpu)\\n\\n # Generally speaking we want fewer than some number of reads per second\\n # hitting disk per instance. If we don't have many reads we don't need to\\n # hold much data in memory.\\n instance_rps = max(1, reads_per_second // rough_count)\\n disk_rps = instance_rps * _es_io_per_read(max(1, needed_disk // rough_count))\\n rps_working_set = min(1.0, disk_rps / max_rps_to_disk)\\n\\n # If disk RPS will be smaller than our target because there are no\\n # reads, we don't need to hold as much data in memory\\n needed_memory = min(working_set, rps_working_set) * needed_disk\\n\\n # Now convert to per zone\\n needed_cores = needed_cores // zones_per_region\\n needed_disk = needed_disk // zones_per_region\\n needed_memory = int(needed_memory // zones_per_region)\\n logger.debug(\\n \\\"Need (cpu, mem, disk, working) = (%s, %s, %s, %f)\\\",\\n needed_cores,\\n needed_memory,\\n needed_disk,\\n working_set,\\n )\\n\\n return CapacityRequirement(\\n requirement_type=\\\"elasticsearch-data-zonal\\\",\\n core_reference_ghz=desires.core_reference_ghz,\\n cpu_cores=certain_int(needed_cores),\\n mem_gib=certain_float(needed_memory),\\n disk_gib=certain_float(needed_disk),\\n network_mbps=certain_float(needed_network_mbps),\\n context={\\n \\\"working_set\\\": min(working_set, rps_working_set),\\n \\\"rps_working_set\\\": rps_working_set,\\n \\\"disk_slo_working_set\\\": working_set,\\n \\\"replication_factor\\\": copies_per_region,\\n \\\"compression_ratio\\\": round(\\n 1.0 / desires.data_shape.estimated_compression_ratio.mid, 2\\n ),\\n \\\"read_per_second\\\": reads_per_second,\\n },\\n )\",\n \"def __call__(self, ret):\\n \\n ce = None\\n for reli in itertools.product([False, True], repeat = len(ret)):\\n\\n mean, var = self.learner.updated_prediction({ i : 1 if r else -1 for i, r in zip(ret, reli) }, self.learner.candidates, cov_mode = 'diag')\\n \\n prob_irrel = scipy.stats.norm.cdf(0, mean, np.sqrt(var))\\n prob_rel = 1. - prob_irrel\\n cur_ce = np.sum(prob_irrel * np.log(prob_irrel + self.eps) + prob_rel * np.log(prob_rel + self.eps))\\n \\n if (ce is None) or (cur_ce < ce):\\n ce = cur_ce\\n \\n return ce\",\n \"def personal_best(scores):\\n return max(scores)\",\n \"def evaluate_score(self,word_id):\\r\\n total_best = 0\\r\\n assigned_to_return = {}\\r\\n for possible_word in self.satisfiers[word_id].keys():\\r\\n words_to_iterate = []\\r\\n iterated_word_ids = []\\r\\n # print()\\r\\n for connected_word_id in self.satisfiers[word_id][possible_word].keys():\\r\\n words_to_iterate.append(self.satisfiers[word_id][possible_word][connected_word_id])\\r\\n # print(\\\"word_id: {}, possible_word: {}, connected_id: {}, words: {}\\\".format(word_id,possible_word, connected_word_id,self.satisfiers[word_id][possible_word][connected_word_id]))\\r\\n iterated_word_ids.append(connected_word_id)\\r\\n \\r\\n # print(possible_word)\\r\\n # print(\\\"\\\\nPossible word:\\\",possible_word)\\r\\n for comb in itertools.product(*words_to_iterate):\\r\\n assigned_words = {}\\r\\n assigned_words[word_id] = possible_word\\r\\n for i in range(len(iterated_word_ids)):\\r\\n assigned_words[iterated_word_ids[i]] = comb[i]\\r\\n # print(\\\"word_id: {} comb: {}\\\".format(word_id,comb))\\r\\n # print(\\\"\\\\nword_id: {}, assigned words: {}\\\".format(word_id,assigned_words))\\r\\n new_assigned, current_max = self.get_max_score(word_id,assigned_words)\\r\\n # print(\\\"new_assigned: {}, current_max: {}\\\".format(new_assigned, current_max))\\r\\n if current_max > total_best:\\r\\n total_best = current_max\\r\\n assigned_to_return = {}\\r\\n assigned_to_return = new_assigned\\r\\n return assigned_to_return, total_best\",\n \"def display_results(_results, model):\\n print(\\\"Optimal solution:\\\\n\\\")\\n for website in sorted(model.Websites):\\n for item in sorted(model.Items):\\n if model.Quantity[website, item].value > 0:\\n print(\\\"Buy {q} item(s) of {i} from {w}\\\".format(q=int(model.Quantity[website, item].value),\\n i=item,\\n w=website,))\\n\\n print('')\\n print(\\\"Shipping Cost = {}\\\".format(model.Cost['Shipping'].value))\\n print(\\\"Product Cost = {}\\\".format(model.Cost['Item'].value))\\n print('')\\n\\n for i in _results['Solution']:\\n print(\\\"Total Cost = {}\\\".format(i['Objective']['Objective']['Value']))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6284819","0.62337065","0.61745787","0.61052895","0.60609734","0.60476875","0.6004349","0.59691477","0.5940262","0.59164304","0.5862893","0.5773496","0.57638365","0.5753932","0.574135","0.57389337","0.5737159","0.57235175","0.5709042","0.56935674","0.5674875","0.56637883","0.56564367","0.5654699","0.56170446","0.5607826","0.56023216","0.5582764","0.5578994","0.55683744","0.5553584","0.55460393","0.554341","0.5534818","0.5518387","0.55154437","0.55141485","0.55141485","0.5505685","0.5503306","0.55032724","0.5497449","0.54745597","0.54690534","0.5462859","0.54613143","0.5458828","0.5449752","0.54299635","0.5428909","0.5427429","0.5422756","0.5419842","0.54114795","0.5403481","0.5403481","0.54034454","0.54017544","0.53906804","0.5383695","0.5382585","0.5382229","0.5382229","0.53684044","0.5367361","0.5361794","0.535875","0.53579783","0.5357777","0.5355423","0.5354318","0.5353883","0.5353883","0.5353883","0.53497607","0.53497475","0.5348282","0.5346826","0.53449994","0.5341655","0.53373677","0.53258663","0.53219837","0.5320652","0.53157985","0.53154325","0.5314634","0.5308904","0.53075874","0.5306803","0.5303235","0.5303235","0.5303235","0.53019625","0.53008217","0.52971625","0.5295324","0.5292361","0.52912146","0.52898586"],"string":"[\n \"0.6284819\",\n \"0.62337065\",\n \"0.61745787\",\n \"0.61052895\",\n \"0.60609734\",\n \"0.60476875\",\n \"0.6004349\",\n \"0.59691477\",\n \"0.5940262\",\n \"0.59164304\",\n \"0.5862893\",\n \"0.5773496\",\n \"0.57638365\",\n \"0.5753932\",\n \"0.574135\",\n \"0.57389337\",\n \"0.5737159\",\n \"0.57235175\",\n \"0.5709042\",\n \"0.56935674\",\n \"0.5674875\",\n \"0.56637883\",\n \"0.56564367\",\n \"0.5654699\",\n \"0.56170446\",\n \"0.5607826\",\n \"0.56023216\",\n \"0.5582764\",\n \"0.5578994\",\n \"0.55683744\",\n \"0.5553584\",\n \"0.55460393\",\n \"0.554341\",\n \"0.5534818\",\n \"0.5518387\",\n \"0.55154437\",\n \"0.55141485\",\n \"0.55141485\",\n \"0.5505685\",\n \"0.5503306\",\n \"0.55032724\",\n \"0.5497449\",\n \"0.54745597\",\n \"0.54690534\",\n \"0.5462859\",\n \"0.54613143\",\n \"0.5458828\",\n \"0.5449752\",\n \"0.54299635\",\n \"0.5428909\",\n \"0.5427429\",\n \"0.5422756\",\n \"0.5419842\",\n \"0.54114795\",\n \"0.5403481\",\n \"0.5403481\",\n \"0.54034454\",\n \"0.54017544\",\n \"0.53906804\",\n \"0.5383695\",\n \"0.5382585\",\n \"0.5382229\",\n \"0.5382229\",\n \"0.53684044\",\n \"0.5367361\",\n \"0.5361794\",\n \"0.535875\",\n \"0.53579783\",\n \"0.5357777\",\n \"0.5355423\",\n \"0.5354318\",\n \"0.5353883\",\n \"0.5353883\",\n \"0.5353883\",\n \"0.53497607\",\n \"0.53497475\",\n \"0.5348282\",\n \"0.5346826\",\n \"0.53449994\",\n \"0.5341655\",\n \"0.53373677\",\n \"0.53258663\",\n \"0.53219837\",\n \"0.5320652\",\n \"0.53157985\",\n \"0.53154325\",\n \"0.5314634\",\n \"0.5308904\",\n \"0.53075874\",\n \"0.5306803\",\n \"0.5303235\",\n \"0.5303235\",\n \"0.5303235\",\n \"0.53019625\",\n \"0.53008217\",\n \"0.52971625\",\n \"0.5295324\",\n \"0.5292361\",\n \"0.52912146\",\n \"0.52898586\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6996528"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83792,"cells":{"query":{"kind":"string","value":"Collect histogram on absolute value"},"document":{"kind":"string","value":"def collect_absolute_value(self, name_to_arr):\n for tensor, data_arr in name_to_arr.items():\n data_arr = np.asarray(data_arr) # noqa: PLW2901\n data_arr = data_arr.flatten() # noqa: PLW2901\n if data_arr.size > 0:\n min_value = np.min(data_arr)\n max_value = np.max(data_arr)\n else:\n min_value = 0\n max_value = 0\n\n data_arr = np.absolute(data_arr) # only consider absolute value # noqa: PLW2901\n\n if tensor not in self.histogram_dict:\n # first time it uses num_bins to compute histogram.\n hist, hist_edges = np.histogram(data_arr, bins=self.num_bins)\n self.histogram_dict[tensor] = (hist, hist_edges, min_value, max_value)\n else:\n old_histogram = self.histogram_dict[tensor]\n old_min = old_histogram[2]\n old_max = old_histogram[3]\n old_hist = old_histogram[0]\n old_hist_edges = old_histogram[1]\n temp_amax = np.max(data_arr)\n if temp_amax > old_hist_edges[-1]:\n # increase the number of bins\n width = old_hist_edges[1] - old_hist_edges[0]\n # NOTE: np.arange may create an extra bin after the one containing temp_amax\n new_bin_edges = np.arange(old_hist_edges[-1] + width, temp_amax + width, width)\n old_hist_edges = np.hstack((old_hist_edges, new_bin_edges))\n hist, hist_edges = np.histogram(data_arr, bins=old_hist_edges)\n hist[: len(old_hist)] += old_hist\n self.histogram_dict[tensor] = (hist, hist_edges, min(old_min, min_value), max(old_max, max_value))"},"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_histogram(self):\n\n for bin in range(self.bins.size):\n bin_inf = self.bins[bin]\n try: bin_sup = self.bins[bin + 1]\n except IndexError: bin_sup = self.vmax\n self.hist[bin] = np.sum(\n (self.values >= bin_inf)*(self.values < bin_sup))\n\n binned_values = np.sum(self.hist)\n if binned_values == 0: return self.hist # no binned value\n else: self.hist /= np.sum(self.hist)\n return self.hist","def frecuencia_abs(seq) -> dict:\n hist = {}\n for i in seq:\n hist[i] = hist.get(i, 0) + 1\n return hist","def get_histogram(self):\n\n values_array = np.array(self.values)\n for bin0 in range(self.bins[0].size):\n bin_inf0 = self.bins[0][bin0]\n try: bin_sup0 = self.bins[0][bin0 + 1]\n except IndexError: bin_sup0 = self.vmax[0]\n values = values_array[\n (values_array[:, 0] >= bin_inf0)\n *(values_array[:, 0] < bin_sup0)][:, 1]\n for bin1 in range(self.bins[1].size):\n bin_inf1 = self.bins[1][bin1]\n try: bin_sup1 = self.bins[1][bin1 + 1]\n except IndexError: bin_sup1 = self.vmax[1]\n self.hist[bin0*self.Nbins[1] + bin1, 2] = (\n np.sum((values >= bin_inf1)*(values < bin_sup1)))\n\n if np.sum(self.hist[:, 2]) > 0: # there are binned values\n self.hist[:, 2] /= np.sum(self.hist[:, 2])\n return self.hist","def just_histogram(*args, **kwargs):\n return np.histogram(*args, **kwargs)[0].astype(float)","def compute_histogram(self):\n # compute distance between points \n distmatrix = np.sqrt(pdist(self.points))\n if not self.mean_dist:\n self.mean_dist = np.mean(distmatrix)\n distmatrix = distmatrix/self.mean_dist\n distmatrix = squareform(distmatrix)\n #compute angles between points\n angles = compute_angles(self.points)\n #quantize angles to a bin\n tbins = np.floor(angles / (2 * pi / self.nbins_theta))\n lg = np.logspace(self.r1, self.r2, num=5)\n #quantize radious to bins\n rbins = np.ones(angles.shape) * -1\n for r in lg:\n counts = (distmatrix < r) \n rbins = rbins + counts.astype(int) \n return rbins, tbins","def histogram(self, mask=None, extrema=None):\r\n uni, counts = self._getcolors()\r\n return [l for l in counts]","def create_fixed_hist(self):\n hist = cv2.calcHist([self.obj], [0, 1, 2], None, [32, 8, 8],\n [0, 256, 0, 256, 0, 256])\n self.hist = cv2.normalize(hist).flatten()\n print self.hist","def histo ( self ,\n xbins = 20 , xmin = None , xmax = None ,\n ybins = 20 , ymin = None , ymax = None ,\n hpars = () , \n histo = None ,\n integral = False ,\n errors = False , \n density = False ) :\n \n \n histos = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\n ybins = ybins , ymin = ymin , ymax = ymax ,\n hpars = hpars ,\n histo = histo )\n\n # loop over the historgam bins \n for ix,iy,x,y,z in histo.items() :\n\n xv , xe = x.value() , x.error()\n yv , ye = y.value() , y.error()\n \n # value at the bin center \n c = self ( xv , yv , error = errors ) \n\n if not integral : \n histo[ix,iy] = c\n continue\n\n # integral over the bin \n v = self.integral( xv - xe , xv + xe , yv - ye , yv + ye )\n \n if errors :\n if 0 == c.cov2 () : pass\n elif 0 != c.value() and 0 != v : \n v = c * ( v / c.value() )\n \n histo[ix,iy] = v \n\n ## coovert to density historgam, if requested \n if density : histo = histo.density()\n \n return histo","def makeHistogram(values, numBins, xLabel, yLabel, title=None):","def anticum_hist(data, bins=None, toadd=0, zero=False, zerox=False):\n\n from numpy import histogram, unique, append, cumsum, zeros, array\n data = array(data)\n\n if bins is None:\n temp, bins = histogram(data, unique(data))\n hist = append(cumsum(temp[::-1])[::-1], 1)\n else:\n if len(data) == 0:\n return zeros(len(bins)), bins\n # if max(data) > max(bins):\n # print \"Must have the largest bin be bigger than the largest data point.\"\n # print max(bins)\n # print max(data)\n # import sys\n # sys.exit(1337)\n temp, bins = histogram(data, bins=bins)\n numbig = data[data > bins.max()].shape[0]\n # add on the objects that are above the last bin to the last count, so that they're included in the cumulative sum\n temp[-1] += numbig\n hist = append(cumsum(temp[::-1])[::-1], numbig)\n\n hist = hist + toadd # add some number to all the values\n\n if zero:\n hist = append(hist, 1e-10)\n bins = append(bins, bins[-1])\n if zerox:\n hist = append(hist[0], hist)\n bins = append(1e-10, bins)\n\n return hist, bins","def test_get_histogram_stat_by(self):\n pass","def hist(a,bins):\n n=searchsorted(sort(a),bins)\n n=concatenate([n,[len(a)]])\n n=array(list(map(float,n)))\n# n=array(n)\n return n[1:]-n[:-1]","def histogram(self):\n return self._hist","def add_histogram(self, tag, values, global_step=None, bins='tensorflow'):\n values = make_np(values)\n self.vis.histogram(make_np(values), opts={'title': tag})","def distribution_magnitude_histogram(cur, var, table, label):\n x = select(cur,var, table)\n print(\"Number of entries: \", len(x))\n print(\"Maximum: \", max(x))\n print(\"Minimum: \", min(x))\n \n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.set_xlabel(\"Sentiment Magnitude\")\n ax.set_ylabel(\"Number of Sentences\")\n fig.suptitle(label)\n ax.hist(x, bins = 20)\n plt.show()","def histogram(self):\n if np.size(self.stats['Counts']): # don't do anything to an empty list\n if np.size(self.bins) and not self.redo:\n return self.bins, self.occs, self.thresh\n elif np.size(self.bin_array) > 0: \n self.occs, self.bins = np.histogram(self.stats['Counts'], self.bin_array) # fixed bins. \n else:\n try:\n lo, hi = min(self.stats['Counts'])*0.97, max(self.stats['Counts'])*1.02\n # scale number of bins with number of files in histogram and with separation of peaks\n num_bins = int(15 + self.ind//100 + (abs(hi - abs(lo))/hi)**2*15) \n self.occs, self.bins = np.histogram(self.stats['Counts'], bins=np.linspace(lo, hi, num_bins+1)) # no bins provided by user\n except: \n self.occs, self.bins = np.histogram(self.stats['Counts'])\n else: self.occs, self.bins = np.zeros(10), np.arange(0,1.1,0.1)\n return self.bins, self.occs, self.thresh","def _compute_histogram(self, x, momentum):\n num_bins = self.histogram.size(0)\n x_detached = x.detach()\n self.bin_width = (self._max_val - self._min_val) / (num_bins - 1)\n lo = torch.floor((x_detached - self._min_val) / self.bin_width).long()\n hi = (lo + 1).clamp(min=0, max=num_bins - 1)\n hist = x.new_zeros(num_bins)\n alpha = (\n 1.0\n - (x_detached - self._min_val - lo.float() * self.bin_width)\n / self.bin_width\n )\n hist.index_add_(0, lo, alpha)\n hist.index_add_(0, hi, 1.0 - alpha)\n hist = hist / (hist.sum() + 1e-6)\n self.histogram = (1.0 - momentum) * self.histogram + momentum * hist","def test_get_histogram_stat_by_breakout(self):\n pass","def f_hist(datos, lims, devolver_frecuencia=False):\n #incializacion\n n_bins = lims.size - 1\n frec_abs = np.zeros(n_bins)\n #conteo frecuencia absoluta\n for i in range(n_bins):\n frec_abs[i] = np.sum( (lims[i] <= datos) * (datos < lims[i+1]) )\n #calculo de funcion histograma\n hist = frec_abs / (n_sim * (lims[1:] - lims[:-1]))\n #salida de resultados\n if devolver_frecuencia:\n return frec_abs, hist\n else:\n return hist","def create_general_hist(self, obj):\n hist = cv2.calcHist([obj], [0, 1, 2], None, [32, 8, 8],\n [0, 256, 0, 256, 0, 256])\n print cv2.normalize(hist).flatten()\n return cv2.normalize(hist).flatten()","def ascii_hist(x):\n fAbs = frecuencia_abs(x)\n for k in sorted(fAbs):\n print(\"{0:5d} {1}\".format(k, \"+\"*fAbs[k]))","def getHistogram( self, img):\n bins = 256\n range_scale = [0,254]\n nivel_transparencia = 0.5\n plt.hist(img.ravel(),bins,range_scale, label=\"histogram\", alpha=nivel_transparencia);\n plt.legend(loc='upper right')\n plt.show()","def _histogram_with_spread(self):\n complexity_hist = np.bincount(\n self.epoch.array_annotations['complexity'])\n num_bins = (self.t_stop - self.t_start).rescale(\n self.bin_size.units).item() / self.bin_size.item()\n num_bins = round_binning_errors(num_bins, tolerance=self.tolerance)\n time_hist = np.zeros(num_bins, dtype=int)\n\n start_bins = (self.epoch.times - self.t_start).rescale(\n self.bin_size.units).magnitude / self.bin_size.item()\n stop_bins = (self.epoch.times + self.epoch.durations - self.t_start\n ).rescale(self.bin_size.units\n ).magnitude / self.bin_size.item()\n\n if self.sampling_rate is not None:\n shift = (.5 / self.sampling_rate / self.bin_size).simplified.item()\n # account for the first bin not being shifted in the epoch creation\n # if the shift would move it past t_start\n if self.epoch.times[0] == self.t_start:\n start_bins[1:] += shift\n else:\n start_bins += shift\n stop_bins += shift\n\n start_bins = round_binning_errors(start_bins, tolerance=self.tolerance)\n stop_bins = round_binning_errors(stop_bins, tolerance=self.tolerance)\n\n for idx, (start, stop) in enumerate(zip(start_bins, stop_bins)):\n time_hist[start:stop] = \\\n self.epoch.array_annotations['complexity'][idx]\n\n time_hist = neo.AnalogSignal(\n signal=np.expand_dims(time_hist, axis=1),\n sampling_period=self.bin_size, units=pq.dimensionless,\n t_start=self.t_start)\n\n empty_bins = (self.t_stop - self.t_start - self.epoch.durations.sum())\n empty_bins = empty_bins.rescale(self.bin_size.units\n ).magnitude / self.bin_size.item()\n empty_bins = round_binning_errors(empty_bins, tolerance=self.tolerance)\n complexity_hist[0] = empty_bins\n\n return time_hist, complexity_hist","def histogram_function(r_min, a, N, nbins):\n r_min_no_selfdistance = r_min - np.identity(len(r_min)) #remove identitity matrix so own distance will be treated as 0\n histarray = np.array(r_min_no_selfdistance).flatten()\n histogram = np.histogram(histarray,bins=np.linspace(0,a,nbins))\n histogram[0][0] = histogram[0][0] - N # remove N from the first bin to prevent it counting particle distance to itself\n return histogram[0]","def _determine_histogram_bins(self, ma_maps):\n if isinstance(ma_maps, list):\n ma_values = self.masker.transform(ma_maps)\n elif isinstance(ma_maps, np.ndarray):\n ma_values = ma_maps.copy()\n else:\n raise ValueError(f\"Unsupported data type '{type(ma_maps)}'\")\n\n # Determine bins for null distribution histogram\n # Remember that numpy histogram bins are bin edges, not centers\n # Assuming values of 0, .001, .002, etc., bins are -.0005-.0005, .0005-.0015, etc.\n INV_STEP_SIZE = 100000\n step_size = 1 / INV_STEP_SIZE\n max_ma_values = np.max(ma_values, axis=1)\n # round up based on resolution\n max_ma_values = np.ceil(max_ma_values * INV_STEP_SIZE) / INV_STEP_SIZE\n max_poss_ale = self.compute_summarystat(max_ma_values)\n # create bin centers\n hist_bins = np.round(np.arange(0, max_poss_ale + (1.5 * step_size), step_size), 5)\n self.null_distributions_[\"histogram_bins\"] = hist_bins","def hist_and_thresh(self):\n bins, occ, _ = self.histogram()\n self.thresh = np.mean(bins) # initial guess\n self.peaks_and_thresh() # in case peak calculation fails\n # if np.size(self.peak_indexes) == 2: # est_param will only find one peak if the number of bins is small\n # # set the threshold where the fidelity is max\n # self.search_fidelity(self.peak_centre[0], self.peak_widths[0] ,self.peak_centre[1])\n try: \n thresh = threshold_minimum(np.array(self.stats['Counts']), len(bins))\n int(np.log(thresh)) # if thresh <= 0 this gives ValueError\n self.thresh = thresh\n except (ValueError, RuntimeError, OverflowError): pass\n try:\n # atom is present if the counts are above threshold\n self.stats['Atom detected'] = [x // self.thresh for x in self.stats['Counts']]\n # self.fidelity, self. err_fidelity = np.around(self.get_fidelity(), 4) # this is a relatively slow operation\n except (ValueError, OverflowError): pass\n return bins, occ, self.thresh","def update_histo_frame():\n min_histo.text = str(MIN_RANGE_F) # Display the legend\n max_histo.text = str(MAX_RANGE_F)\n\n histogram = np.zeros(GRID_AXIS) # Clear histogram accumulation array\n # Collect camera data and calculate the histogram\n for _row in range(0, GRID_AXIS):\n for _col in range(0, GRID_AXIS):\n histo_index = int(map_range(GRID_DATA[_col, _row], 0, 1, 0, GRID_AXIS - 1))\n histogram[histo_index] = histogram[histo_index] + 1\n\n histo_scale = np.max(histogram) / (GRID_AXIS - 1)\n if histo_scale <= 0:\n histo_scale = 1\n\n # Display the histogram\n for _col in range(0, GRID_AXIS):\n for _row in range(0, GRID_AXIS):\n if histogram[_col] / histo_scale > GRID_AXIS - 1 - _row:\n image_group[((_row * GRID_AXIS) + _col)].fill = index_to_rgb(\n round((_col / GRID_AXIS), 3)\n )\n else:\n image_group[((_row * GRID_AXIS) + _col)].fill = BLACK","def sum_hist(self, label=None):\n values = [h.values for h in self.hists]\n errors = [h.yerr for h in self.hists]\n hist = deepcopy(self.hists[0])\n hist.values = sum(values)\n hist.yerr = np.sqrt(sum([error*error for error in errors]))\n hist.label = label\n hist.color = style.def_grey\n return hist","def _histogram_no_spread(self):\n # Computing the population histogram with parameter binary=True to\n # clip the spike trains before summing\n time_hist = time_histogram(self.input_spiketrains,\n self.bin_size,\n binary=self.binary)\n\n time_hist_magnitude = time_hist.magnitude.flatten()\n\n # Computing the histogram of the entries of pophist\n complexity_hist = np.bincount(time_hist_magnitude)\n\n return time_hist, complexity_hist","def getPeaksFromHist(orig_hist, width_thres=0, height_thres=0):\n if len(orig_hist) < 10:\n return []\n if width_thres == 0:\n width_thres = 5\n if height_thres == 0:\n height_thres = np.mean(orig_hist)\n\n hist = smooth(np.array(orig_hist), 20)\n hist[hist < height_thres] = height_thres\n hist = hist - min(hist)\n\n peak_hist1 = np.zeros((len(hist), 1))\n peak_list = []\n for i in range(4, len(hist) - 4):\n peak_hist1[i] = hist[i + 1] - hist[i - 1]\n\n for i in range(width_thres, len(peak_hist1) - width_thres):\n\n\n if all(peak_hist1[i - width_thres:i] > 0) and all(peak_hist1[i + 1:i + width_thres] < 0):\n peak_list.append(i)\n\n if len(peak_list) != 0:\n new_list = []\n derivate = np.zeros((len(peak_list), 1))\n for i in range(1, len(peak_list)):\n derivate[i] = peak_list[i] - peak_list[i - 1]\n i = 0\n while i < len(derivate) - 1:\n s = peak_list[i]\n c = 0\n if derivate[i + 1] == 1 and not i + 1 == len(derivate) - 1:\n j = i + 1\n while j <= len(derivate):\n if derivate[j] == 1 and not j + 1 == len(derivate):\n s += peak_list[j]\n c += 1\n j += 1\n else:\n s /= (c + 1)\n i = j\n break\n else:\n i += 1\n new_list.append(s)\n if i != len(derivate) - 1:\n new_list.append(peak_list[i])\n peak_list = new_list\n\n peak_list.sort()\n return peak_list","def norm_hist(self, hist_lower, hist_upper, lower, upper, value) :\n norm = 1.\n if upper>lower :\n norm = hist_lower.Integral()+(hist_upper.Integral()-hist_lower.Integral())/abs(upper-lower)*(value-lower)\n return norm","def getHistogram(self, var, idx = None, translation = None, other = None,\\\n verbose = 1, ab = [], bins = 100, minmax = None):\n \n if idx is None: idx = np.arange(self.atoms.shape[0])\n if translation is None: translation = [0]\n if isinstance(translation, (int, np.integer)): translation = [translation]\n\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\n verbose = verbose, ab = ab, other = other)\n x = []\n y = []\n for i, item in enumerate(data):\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\n x.append((bin[:-1] + bin[1:]) / 2)\n y.append(cnt)\n\n return x, y, lbl, leg","def hist(img):\n bottom_half = img[img.shape[0]//2:,:] # 0:img.shape[0]//2 is the top half\n histogram = bottom_half.sum(axis=0) \n \n return histogram","def calcHistogram(Tech_res):\n A_Hist = np.histogram(Tech_res.A_mean, Tech_res.hist_bins)\n top, bin_list, x_steps = list(A_Hist[0]), list(A_Hist[1]), []\n for n in range(np.shape(bin_list)[0]-1):\n x_steps.append((bin_list[n+1] + bin_list[n]) / 2)\n Tech_res.update_tech_meas(Hist_tops=top, Hist_steps=x_steps)\n return","def build_hist(concept_values: np.ndarray, num_bins: int = 100) -> np.ndarray:\n hist, _ = np.histogram(concept_values, bins=num_bins, range=(0., 1.), density=True)\n return hist","def make_sorted_frequencies(counts, absolute=False):\r\n\r\n c = sort(counts)\r\n c = c[c.nonzero()]\r\n c = c[::-1]\r\n if absolute:\r\n return c\r\n else:\r\n f = c / float(c.sum())\r\n return f","def hist_zero(df, *args, **kwargs):\n # TODO: should this set values to 0?\n df = df.copy()\n return df","def calculateHistogram(self):\n \n # Define color map\n colors = [ (255,0,0),(0,255,0),(0,0,255) ]\n # Define empty image to plot histogram in\n plot_to_fill = np.zeros((280,400,3))\n # Define bins of the histogram\n bins = np.arange(256).reshape(256,1)\n \n # Boucle sur les canaux\n for channel, color in enumerate(colors):\n # Calcul de l'histogramme\n hist_item = cv2.calcHist(self.frame,[channel],None,[256],[0,256])\n # Normalisation\n cv2.normalize(hist_item,hist_item,0,255,cv2.NORM_MINMAX)\n # Conversion\n hist = np.int32(np.around(hist_item))\n pts = np.int32(np.column_stack((bins, hist)))\n cv2.polylines(plot_to_fill, [pts], False, color)\n # Mettre dans le bon sens\n histplot = np.flipud(plot_to_fill)\n histplot = np.uint8(histplot)\n \n # Conversion en objet QPixelMap\n self.histplot_qpix = self.convertToQPixelmap(histplot)","def histogram_plot(val_addr):\n pos = np.zeros((val_addr.shape[0],2))\n for i in range(val_addr.shape[0]):\n if i%1e6==0:\n print(i)\n temp=val_addr[i]\n if temp<25:\n if temp<=4:\n pos[i,0]=np.sqrt(3)\n pos[i,1] = temp-2.\n elif temp<=8:\n pos[i,0]=np.sqrt(3)/2.\n pos[i,1] = temp-6.5 \n elif temp<=13:\n pos[i,0]=0\n pos[i,1] = temp-11. \n elif temp<=17:\n pos[i,0]=-np.sqrt(3)/2.\n pos[i,1] = temp-15.5 \n elif temp<=23:\n pos[i,0]=-np.sqrt(3)\n pos[i,1] = temp-20.\n plt.hexbin(pos[:,1],pos[:,0],gridsize=(4,2))\n plt.colorbar()\n plt.show()\n return(pos)","def ahistogram (inarray,numbins=10,defaultlimits=None,printextras=1):\r\n inarray = N.ravel(inarray) # flatten any >1D arrays\r\n if (defaultlimits <> None):\r\n lowerreallimit = defaultlimits[0]\r\n upperreallimit = defaultlimits[1]\r\n binsize = (upperreallimit-lowerreallimit) / float(numbins)\r\n else:\r\n Min = N.minimum.reduce(inarray)\r\n Max = N.maximum.reduce(inarray)\r\n estbinwidth = float(Max - Min)/float(numbins) + 1e-6\r\n binsize = (Max-Min+estbinwidth)/float(numbins)\r\n lowerreallimit = Min - binsize/2.0 #lower real limit,1st bin\r\n bins = N.zeros(numbins)\r\n extrapoints = 0\r\n for num in inarray:\r\n try:\r\n if (num-lowerreallimit) < 0:\r\n extrapoints = extrapoints + 1\r\n else:\r\n bintoincrement = int((num-lowerreallimit) / float(binsize))\r\n bins[bintoincrement] = bins[bintoincrement] + 1\r\n except: # point outside lower/upper limits\r\n extrapoints = extrapoints + 1\r\n if (extrapoints > 0 and printextras == 1):\r\n print '\\nPoints outside given histogram range =',extrapoints\r\n return (bins, lowerreallimit, binsize, extrapoints)","def _make_histogram(values, bins):\n values = values.reshape(-1)\n counts, limits = np.histogram(values, bins=bins)\n limits = limits[1:]\n\n sum_sq = values.dot(values)\n return HistogramProto(min=values.min(),\n max=values.max(),\n num=len(values),\n sum=values.sum(),\n sum_squares=sum_sq,\n bucket_limit=limits,\n bucket=counts)","def color_hist_block(aois):\n hist = cv2.calcHist([aois[0]], [0], None, [30], [0, 256])\n contrasts = []\n for aoi in aois[1:]:\n hist = hist + cv2.calcHist([aoi], [0], None, [30], [0, 256])\n contrasts.append(compute_contrast(aoi))\n hist = cv2.normalize(hist, hist).flatten()\n # print hist,contrasts\n return hist","def create_hist(pVals,bins=1000,log=False,max_val=False):\n\t# gets an array of pValues and returns an array of bins with counts\n\thist_count = np.zeros(bins)\n\tif (log):\n\t\tnlp = -1.0*np.log10(pVals)\n\t\tif (max_val):\n\t\t\tnlp_max=max_val\n\t\telse:\n\t\t\tnlp_max = nlp.max()\n\t\tpVals = pVals/nlp_max\n\tfor i in pVals:\n\t\tj=int(bins*i)\n\t\tif j == bins:\n\t\t\tj -= 1\n\t\thist_count[j] += 1\n\treturn hist_count","def _printHist(self):\n bins = [0] * self.displayBins\n binSize = self.maxValue / self.displayBins\n displaySamps = self.samples[:]\n displaySamps.sort()\n currLimit = binSize\n binIndex = 0\n partIndex = 0\n while partIndex < self.numParticles:\n part = displaySamps[partIndex]\n if binIndex >= self.displayBins:\n # if value beyond max value, add to last bin and go on to next particle\n bins[19] += 1\n partIndex += 1\n elif part < currLimit:\n # count particle in current bin, go on to next particle\n bins[binIndex] += 1\n partIndex += 1\n else:\n # go on to next bin, don't go on to next particle\n binIndex += 1\n currLimit += binSize\n self.printMapPattern(binSize)\n histStr = \"{0:3d} \"\n printStr = \"\"\n for b in bins:\n printStr += histStr.format(b)\n print(printStr)","def normalize_hist(hist) -> [float]:\n hsum = np.sum(hist)\n newhist = []\n for hi in hist:\n newhist.append(hi/hsum)\n\n return newhist","def histograms(probs, actual, bins=100):\n actual = actual.astype(np.bool)\n edges, step = np.linspace(0., 1., bins, retstep=True, endpoint=False)\n idx = np.digitize(probs, edges) - 1\n top = np.bincount(idx, weights=actual, minlength=bins)\n bot = np.bincount(idx, weights=(~actual), minlength=bins)\n return top, bot, edges, step","def test_get_result_histogram_stat(self):\n pass","def OF1_CalculateRawHistogram(image):\n h = np.zeros(256, np.float_)\n for i in np.nditer(image):\n h[i - 1] = h[i - 1] + 1\n\n return h","def histogram(f, option=\"uint16\"):\n from numpy import searchsorted, sort, ravel, concatenate, product\n\n n = searchsorted(sort(ravel(f)), range(f.max()+1))\n n = concatenate([n, [product(f.shape)]])\n h = n[1:]-n[:-1]\n return h","def normalized(self):\n total = self.total()\n result = Histogram()\n for value, count in self.items():\n try:\n result[value] = count / float(total)\n except UnorderableElements:\n result = Histogram.from_dict(dict(result), key=hash)\n result[value] = count / float(total)\n return result","def OF1_CalculateNormalizedHistogram(image):\n\n raw = OF1_CalculateRawHistogram(image)\n norm = np.zeros(256, np.float_)\n\n for i in range(256):\n norm[i] = raw[i] / image.size\n\n return norm","def gc_percent_hist(data):\n result = [0] * 101 # 0-100\n for s in data:\n percent = _gc_percent(s)\n result[percent] += 1\n return result","def avghist(data, weights, bins=None):\n if bins is not None:\n sums = np.histogram(data, weights=weights, bins=bins)[0]\n (counts, buckets) = np.histogram(data, bins=bins)\n buckets=bins\n else:\n sums = np.histogram(data, weights=weights)[0]\n (counts, buckets) = np.histogram(data)\n\n #elements with zero count will by definition have zero sum, ignore div by zero\n counts[counts == 0] = 1\n\n bin_means = np.divide(sums, counts)\n return (bin_means, buckets)","def hist_of_numeric(X):\n figsize(10,3)\n for col in get_numeric(X):\n print(col)\n X[col].hist(bins=50)\n show()","def create_af_histo(snp_dict,perc):\n for i in snp_dict.keys():\n hist=np.histogram(snp_dict[i]['afs'], bins=np.ceil(100.0/perc), range=(0.0,1.0))\n # get rid of bins with afs == 0 in the spectrum\n vals=[]\n bins=[]\n for j,x in enumerate(hist[0]):\n if x > 0:\n if len(vals) == 0:\n bins.append(hist[1][j])\n elif (bins[-1] != hist[1][j] ):\n vals.append(0)\n bins.append(hist[1][j])\n vals.append(x)\n bins.append(hist[1][j+1])\n snp_dict[i]['afs_hist'] = { 'counts':np.array(vals),'bins':np.array(bins) }\n return True","def histogram_creation(val_addr,val_time,time_range):\n a=val_time.shape[0]\n hist = np.zeros((23,23,2*time_range+1))\n for i in range(a-1):\n b=1 \n diff = val_time[i+b]-val_time[i]\n\n while diff<=time_range and diff>=0:\n if val_addr[i]<25 and val_addr[i+b]<25:\n hist[val_addr[i],val_addr[i+b],time_range+diff]+=1\n hist[val_addr[i+b],val_addr[i],time_range-diff]+=1\n b+=1\n try:\n diff = val_time[i+b]-val_time[i]\n except:\n break\n return(hist)","def compute_hist(query_loc, radius, qtree):\r\n hist_result = []\r\n for r in radius:\r\n nearby_point = qtree.query_ball_point(query_loc, r)\r\n hist_result.append(float(len(nearby_point)))\r\n\r\n index = len(hist_result) - 1\r\n while index != 1:\r\n hist_result[index] -= hist_result[index-1]\r\n index -= 1\r\n \r\n total_point = sum(hist_result)\r\n if total_point != 0:\r\n for index in range(0, len(hist_result)):\r\n hist_result[index] /= total_point\r\n return hist_result","def get_hist(self):\n return self.hist","def fullhistogram(img):\n maxt = img.max()\n if maxt == 0:\n return np.array([img.size])\n return nhistogram(img, np.arange(maxt+2))[0]","def correlation_bins(shred):\n return 0","def histograma(frame):\n #Imagen mejorada por Equalizacion de Histogramas.\n histograma = cv2.equalizeHist(frame)\n return histograma","def produceHist(self, start=None, end=None, period=24 * 3600):\n self.sort()\n if len(self) == 0:\n return\n if start is None:\n start = UTC(self[0].datetime.date)\n if end is None:\n end = UTC(self[-1].datetime)\n entries = int((end - start) / period) + 1\n hist_list = np.zeros(entries)\n mag_list = np.zeros(entries)\n for event in self:\n #date = UTC(event.datetime.date)\n entry = int((event.datetime - start) / period)\n print entry\n try:\n hist_list[entry] += 1\n mag_list[entry] = max(event.magnitude, mag_list[entry])\n except IndexError:\n pass\n return hist_list, mag_list","def histmake(self, n, minfreq, maxfreq, bins_, lat1, lat0, abs = False, norm = True,\\\n pole = \"north\"):\n\n assert self.shifted, \"Data has not been index-shifted\"\n\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n self.inds = inds\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n timesA, fftA = self.fft_time_holes_integral(signal = NeA,\\\n seconds = secondsA, n = n, fs = self.fs, minfreq\\\n = minfreq, maxfreq = maxfreq)\n\n timesB, fftB = self.fft_time_holes_integral(signal = NeB,\\\n seconds = secondsB, n = n, fs = self.fs, minfreq\\\n = minfreq, maxfreq = maxfreq)\n\n timesC, fftC = self.fft_time_holes_integral(signal = NeC,\\\n seconds = secondsC, n = n, fs = self.fs, minfreq\\\n = minfreq, maxfreq = maxfreq)\n\n\n BAdiff = self.relative_diff(fftB, fftA, norm = norm, abs = abs)\n BCdiff = self.relative_diff(fftB, fftC, norm = norm, abs = abs)\n ACdiff = self.relative_diff(fftA, fftC, norm = norm, abs = abs)\n\n BAhist, bins = np.histogram(BAdiff, bins = bins_)\n BChist, bins = np.histogram(BCdiff, bins = bins_)\n AChist, bins = np.histogram(ACdiff, bins = bins_)\n\n bins = (bins[1:] + bins[:-1])/2\n hists = [BAhist, BChist, AChist]\n\n return(hists, bins)","def histogram_equalize(im_orig):\n\n color_flag = False\n image = im_orig\n\n\n if len(im_orig.shape) == 3: #RGB image\n color_flag = True\n y_im = rgb2yiq(im_orig)\n image = y_im[:, :, 0]\n\n image *= NORMALIZE\n hist_orig, bins = np.histogram(image, range(BINS))\n hist_cum = np.cumsum(hist_orig) #cumulative distribution function\n\n cum = ((hist_cum - hist_cum.min()) / ( hist_cum.max() - hist_cum.min())) * NORMALIZE\n\n im_eq = cum[image.astype(np.uint8)]\n\n hist_eq, bins = np.histogram(im_eq, range(BINS)) #before getting back to float64 does the histogram)\n\n im_eq /= NORMALIZE\n im_eq = im_eq.astype(np.float64)\n\n\n if color_flag:\n y_im[:, :, 0] = im_eq\n im_eq = yiq2rgb(y_im)\n\n im_eq = im_eq.clip(0,1)\n return [im_eq, hist_orig, hist_eq]","def color_hist_single(aoi):\n hist = cv2.calcHist([aoi], [0], None, [30], [0, 256])\n return cv2.normalize(hist, hist).flatten()","def get_histogram(folder_name, image_name, save_location):\n print(\"Getting histogram for:\" + str(folder_name) + '/' + str(image_name))\n image = cv2.imread(folder_name + '/' + image_name, cv2.IMREAD_ANYDEPTH)\n plt.hist(image.ravel(), 256, [0, 65535])\n plt.xlabel('Pixel Intensity')\n plt.ylabel('Number of pixels')\n plt.title('Histogram of normalised reference image. Overnight2')\n plt.savefig(save_location + 'histogram.png')\n plt.savefig(save_location + 'histogram.eps', format='eps')\n # plt.show()","def test_get_result_histogram(self):\n pass","def compute_histogram(self, image):\n\n hist = [0] * 256\n x, y = image.shape[:2]\n #print(image.shape)\n for i in range(x):\n for j in range(y):\n hist[image[i, j]] += 1\n\n return hist","def calculate_histogram(self, abstract_features_1, abstract_features_2):\n scores = torch.mm(abstract_features_1, abstract_features_2).detach()\n scores = scores.view(-1, 1)\n hist = torch.histc(scores, bins=self.args.bins)\n hist = hist/torch.sum(hist)\n hist = hist.view(1, -1)\n return hist","def histogram_summary(self, tag, values, step, bins=1000):\n self.writer.add_histogram(tag, values, step, bins='auto')","def equalize_hist(input):\n return np.float32(skimage.exposure.equalize_hist(input.numpy()))","def readsHistogram(sortedList):\n M = sortedList[0].getSamples()\n for item in sortedList:\n if max(item.getSamples()) < 5000:\n M = np.vstack((M, item.getSamples()))\n m = int(np.max(M))\n M = np.ndarray.flatten(M)\n # M = M[np.nonzero(M)] #considering zeros or not?\n hist = np.histogram(M, bins= m)\n # plt.xlabel(\"peak size(reads)\")\n # plt.ylabel(\"number of peaks\")\n # plt.title(\"Histogram of peaks sizes\")\n # plt.bar(np.arange(50), hist[0][:50])\n # plt.show()\n cumulative = np.cumsum(hist[0])\n mc = np.max(cumulative)\n treshold = 0\n indexesTreshold = np.where(cumulative <= mc * (1 - PERCENT_OF_READS_HIST))\n if indexesTreshold[0].size > 0:\n treshold = np.max(indexesTreshold)\n return treshold","def calc_stat_values(self):","def equalise_hist(image, bin_count=256):\n # TODO: your histogram equalization code\n #define arrays\n image = img_as_ubyte(image)\n row,col = image.shape\n new_image = np.zeros((row,col),dtype='uint8') \n\n # compute the value of each grayscale,and save in image_hist \n image_hist = np.bincount(image.flatten(), minlength=(bin_count))\n\n # normalise n[]\n norm_arr = (np.cumsum(image_hist)/(image.size))*(bin_count-1)\n norm_arr = norm_arr.astype('uint8')\n \n #Compute a normalized cumulative histogram\n for x in range(row):\n for y in range(col):\n new_image[x,y] = norm_arr[image[x,y]]\n \n return new_image","def test_hist_w_unc_zero_case(self):\n bins, hist, unc, band = hist_w_unc(\n arr=[],\n bins=[],\n )\n\n np.testing.assert_almost_equal(bins, [])\n np.testing.assert_almost_equal(hist, [])\n np.testing.assert_almost_equal(unc, [])\n np.testing.assert_almost_equal(band, [])","def _hist(xs, bins=100, range=None, stats=('entries', 'mean', 'rms'),\n xylabels = (), stats_xypos=(0.1, 0.7),\n *args, **kargs):\n if (range==None):\n range = (np.min(xs), np.max(xs))\n cc = hst.hist(xs, bins=bins, range=range, *args, **kargs);\n if (not stats):\n return cc\n ys, xedges = np.histogram(xs, bins, range=range)\n ns = len(xs)\n sel = np.logical_and(xs >= range[0], xs <= range[1])\n nos, mean, rms = len(xs[sel]), np.mean(xs[sel]), np.std(xs[sel])\n epsilon = (1.*nos)/(1.*ns)\n ss = ''\n if ('total entries') in stats:\n ss += 'total entries {0:d} \\n'.format(ns)\n if ('entries') in stats:\n ss += 'entries {0:d} \\n'.format(nos)\n if ('mean') in stats:\n ss += 'mean {0:.3f} \\n'.format(mean)\n if ('rms') in stats:\n ss += 'rms {0:.3f} \\n'.format(rms)\n xp, yp = _xypos(xedges, ys, xf=stats_xypos[0], yf=stats_xypos[1])\n ##plt.set_label(ss)\n # plt.gca().set_label(ss)\n # plt.legend()\n plt.text(xp, yp, ss)\n return cc","def find_histogram(vol, hist, mini, maxi, mask, use_mask):\n validsize = 0\n hist = np.zeros(hist.size, dtype=int)\n if mini == maxi:\n return -1\n\n fA = float(hist.size)/(maxi-mini)\n fB = (float(hist.size)*float(-mini)) / (maxi-mini)\n\n if use_mask:\n a = vol[mask > 0.5].flatten()\n else:\n a = vol.flatten()\n\n a = (a*fA + fB).astype(int)\n h = hist.size - 1\n\n for i in np.arange(a.size):\n hist[max(0, min(a[i], h))] += 1\n validsize += 1\n\n return hist, validsize","def rythm_hist(duration_ohe):\n assert duration_ohe.ndim == 2\n return duration_ohe.sum(axis=0) / duration_ohe.sum()","def histograma(p):\n img = read_img(p)\n show_histograma(img.reshape((-1)))","def hist(data):\n\n fig = plt.figure()\n ax1 = fig.add_subplot(111)\n plt.hold(True)\n for x in xrange(len(data[:,0,0])):\n counts, edges = np.histogram(data[x,:,:],bins=100)\n centers = [(edges[i]+edges[i+1])/2.0 for i,v in enumerate(edges[:-1])]\n ax1.plot(centers,counts)\n plt.hold(False)\n\n plt.show(block=False)\n\n # return fig","def _histogram(image,\n min,\n max,\n bins):\n\n return numpy.histogram(image, bins, (min, max))[0]","def histeq( im, nbr_bins = 256):\n\t# get image histogram \n\timhist, bins = histogram( im.flatten(), nbr_bins, normed = True) \n\tcdf = imhist.cumsum() \n\t# cumulative distribution function cdf = 255 * cdf / cdf[-1] \n\t# normalize \n\t# use linear interpolation of cdf to find new pixel values \n\tim2 = interp( im.flatten(), bins[:-1], cdf) \n\treturn im2.reshape( im.shape), cdf","def test_uniform(self):\r\n\r\n s = np.random.uniform(-1.35, 0.5, 5000)\r\n plt.hist(s, 30, density=False)\r\n plt.xlabel('Interlayer point energy [eV]')\r\n plt.ylabel('Frequency')\r\n plt.show()","def normalize(histogram):\n nbins = histogram.GetNbinsX()\n integral = histogram.Integral(1,nbins)\n newhist = histogram.Clone()\n newhist.Reset()\n for bin in range(1,nbins+1):\n ibinY = histogram.GetBinContent(bin)\n newhist.SetBinContent(bin,ibinY/integral)\n return newhist","def createHistogram(data,cumulative=False,**kargs):\n y,x = histogram(data,**kargs)\n if cumulative:\n y = y.cumsum()\n return y,x","def hist(self, bins=\"unit\", closed=\"left\", stat=\"sum\"):\n return self.dist.hist(bins=bins, closed=closed, stat=stat)","def plot_histogram(self,**kwargs):\n axes = []\n for i in range(self.score_length):\n fig = plt.figure()\n scores = np.array([s[i] for s in self.scores_list])\n probs,bins,patches = plt.hist(scores,label=\"Sample {}\".format(self.labels[i]), **kwargs)\n plt.vlines(self.xhat,fig.get_axes().get_ylim(),label='Mean',color='r')\n plt.legend()\n axes.append(fig.get_axes())\n return axes","def normalise_histogram(histogram):\n total_sum = np.sum(histogram)\n for i in range(len(histogram)):\n histogram[i] /= total_sum\n\n return histogram","def color_histogram_hsv(im, nbin=10, xmin=0, xmax=255, normalized=True):\n ndim = im.ndim\n bins = np.linspace(xmin, xmax, nbin + 1)\n hsv = matplotlib.colors.rgb_to_hsv(im / xmax) * xmax\n imhist, bin_edges = np.histogram(hsv[:, :, 0],\n bins=bins,\n density=normalized)\n imhist = imhist * np.diff(bin_edges)\n\n return imhist","def setup_hist(self):\n self.x_min = {}\n self.x_max = {}\n self.x_max_minus_min = {}\n self.dx = {}\n self.n_bins = {}\n\n self.histogram_edges = {}\n self.histogram_values = {}\n self.histogram_cdf = {}","def _compute_null_approximate(self, ma_maps):\n if isinstance(ma_maps, list):\n ma_values = self.masker.transform(ma_maps)\n elif isinstance(ma_maps, np.ndarray):\n ma_values = ma_maps.copy()\n else:\n raise ValueError(f\"Unsupported data type '{type(ma_maps)}'\")\n\n assert \"histogram_bins\" in self.null_distributions_.keys()\n\n def just_histogram(*args, **kwargs):\n \"\"\"Collect the first output (weights) from numpy histogram.\"\"\"\n return np.histogram(*args, **kwargs)[0].astype(float)\n\n # Derive bin edges from histogram bin centers for numpy histogram function\n bin_centers = self.null_distributions_[\"histogram_bins\"]\n step_size = bin_centers[1] - bin_centers[0]\n inv_step_size = 1 / step_size\n bin_edges = bin_centers - (step_size / 2)\n bin_edges = np.append(bin_centers, bin_centers[-1] + step_size)\n\n ma_hists = np.apply_along_axis(just_histogram, 1, ma_values, bins=bin_edges, density=False)\n\n # Normalize MA histograms to get probabilities\n ma_hists /= ma_hists.sum(1)[:, None]\n\n ale_hist = ma_hists[0, :].copy()\n\n for i_exp in range(1, ma_hists.shape[0]):\n\n exp_hist = ma_hists[i_exp, :]\n\n # Find histogram bins with nonzero values for each histogram.\n ale_idx = np.where(ale_hist > 0)[0]\n exp_idx = np.where(exp_hist > 0)[0]\n\n # Compute output MA values, ale_hist indices, and probabilities\n ale_scores = (\n 1 - np.outer((1 - bin_centers[exp_idx]), (1 - bin_centers[ale_idx])).ravel()\n )\n score_idx = np.floor(ale_scores * inv_step_size).astype(int)\n probabilities = np.outer(exp_hist[exp_idx], ale_hist[ale_idx]).ravel()\n\n # Reset histogram and set probabilities.\n # Use at() instead of setting values directly (ale_hist[score_idx] = probabilities)\n # because there can be redundant values in score_idx.\n ale_hist = np.zeros(ale_hist.shape)\n np.add.at(ale_hist, score_idx, probabilities)\n\n self.null_distributions_[\"histweights_corr-none_method-approximate\"] = ale_hist","def arelfreq(a,numbins=10,defaultreallimits=None):\r\n h,l,b,e = histogram(a,numbins,defaultreallimits)\r\n h = N.array(h/float(a.shape[0]))\r\n return h,l,b,e","def makeHist(data, bins, wgt=None, factor=1.0, pdf=False):\n n_arr, bins = np.histogram(data, bins, weights=wgt)\n ctr_bins = centerOfBins(bins)\n \n if pdf == True:\n n_arr = asFloat(n_arr) / (float(sum(n_arr)) * (bins[1:] - bins[:-1]))\n else:\n n_arr = asFloat(n_arr) * factor\n \n return n_arr, ctr_bins","def hist_pvalue(perms, ax, name):\n # Re-weight to obtain distribution\n pval = np.sum(perms >= perms[0]) / perms.shape[0]\n weights = np.ones(perms.shape[0]) / perms.shape[0]\n ax.hist([perms[perms >= perms[0]], perms], histtype='stepfilled',\n bins=100, label=\"p-val<%.3f\" % pval,\n weights=[weights[perms >= perms[0]], weights])\n ax.axvline(x=perms[0], color=\"k\", linewidth=2)#, label=\"observed statistic\")\n ax.set_ylabel(name)\n ax.legend()\n return ax","def hist(self):\r\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\r\n plt.title(self.column_name)\r\n plt.savefig(self.column_name + \".svg\")\r\n plt.close()","def efficient_Make_Binned_ROC_histograms(title, data, bins, PU_range='full'):\n diff_ran = (-25,25)\n diff_bins = diff_ran[1]-diff_ran[0]\n ratio_ran = (0,10)\n ratio_bins = 60\n\n Diff_hist_list = []\n Ratio_hist_list = []\n CSV_hist_list = []\n ZeroDiv_list = []\n for bin_ in range(len(bins)-1):\n Diff_hist_list.append(rt.TH1D(\"L4-L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"L4-L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),diff_bins,diff_ran[0],diff_ran[1]))\n Ratio_hist_list.append(rt.TH1D(\"L4_L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"L4_L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),ratio_bins,ratio_ran[0],ratio_ran[1]))\n CSV_hist_list.append(rt.TH1D(\"CSV_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"CSV_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),ratio_bins,0,1))\n ZeroDiv_list.append(0)\n\n for particle in data:\n if PU_range != 'full':\n if particle[-1]<PU_range[0] or particle[-1]>PU_range[1]: continue\n bin_number = FCM.bin_selection(particle,bins)\n if bin_number == -100: continue\n\n Diff_hist_list[bin_number].Fill(particle[8]-particle[5])\n CSV_hist_list[bin_number].Fill(particle[1])\n if particle[17] != 0:\n L4_L1 = particle[20]/particle[17]\n Ratio_hist_list[bin_number].Fill(L4_L1)\n else:\n ZeroDiv_list[bin_number] += 1\n\n tfile = rt.TFile(\"Thesis_Plots/root_files/{}_histograms.root\".format(title),\"recreate\")\n for hist in Diff_hist_list:\n hist.Write()\n for hist in Ratio_hist_list:\n hist.Write()\n for hist in CSV_hist_list:\n hist.Write()\n print \"saved histograms in Thesis_Plots/root_files/{}_histograms.root\".format(title)\n\n csv_file = open(\"Thesis_Plots/root_files/{}_ZeroDiv.csv\".format(title),\"wb\")\n writer = csv.writer(csv_file)\n writer.writerow(ZeroDiv_list)\n csv_file.close()\n print \"saved zero division occurences in Thesis_Plots/root_files/{}_ZeroDiv.csv\".format(title)","def test_under_overflow_values(self):\n values_with_inf = np.array([-1, 1, 2, 100, np.inf])\n\n with self.subTest(\"Under/overflow values without under/overflow bins.\"):\n bins, hist, _, _ = hist_w_unc(values_with_inf, bins=5, bins_range=(0, 5))\n np.testing.assert_almost_equal(bins, np.linspace(0, 5, 6))\n # in this case only 40% of the values are shown in the plot\n np.testing.assert_almost_equal(hist, np.array([0, 0.2, 0.2, 0, 0]))\n\n with self.subTest(\"Under/overflow values with under/overflow bins.\"):\n bins, hist, _, _ = hist_w_unc(\n values_with_inf, bins=5, bins_range=(0, 5), underoverflow=True\n )\n np.testing.assert_almost_equal(bins, np.linspace(0, 5, 6))\n np.testing.assert_almost_equal(hist, np.array([0.2, 0.2, 0.2, 0, 0.4]))","def histogramintegrals(self):\n return {}","def Test_Histogram(Graph_MD):\n \n Edges = NX.edges(Graph_MD)\n KnotenNamen = NX.nodes(Graph_MD)\n \n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\n NumKnotenListe = len(KnotenNamenListe)\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\n \n count = 0\n for Knoten in KnotenLeitung:\n KnotenLeitung[count] = 0\n count = count + 1\n \n \n for ii in list(range(NumKnotenListe)):\n KnotenName = KnotenNamenListe[ii]\n for edge in Edges:\n posS = edge[0] == KnotenName\n posE = edge[1] == KnotenName\n \n if posS :\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n if posE:\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n \n MaxKnotenLeitung = max(KnotenLeitung)\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\n \n for ii in list(range(0, MaxKnotenLeitung + 1)):\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\n\n\n return HistSegmKnoten","def import_histo(w,hz,xmin,xmax):\n print 'Loading histogram with',hz.GetEntries(),'entries'\n data = RooDataHist('data','Zmumu MC',RooArgList(w.var('x')),hz)\n return data"],"string":"[\n \"def get_histogram(self):\\n\\n for bin in range(self.bins.size):\\n bin_inf = self.bins[bin]\\n try: bin_sup = self.bins[bin + 1]\\n except IndexError: bin_sup = self.vmax\\n self.hist[bin] = np.sum(\\n (self.values >= bin_inf)*(self.values < bin_sup))\\n\\n binned_values = np.sum(self.hist)\\n if binned_values == 0: return self.hist # no binned value\\n else: self.hist /= np.sum(self.hist)\\n return self.hist\",\n \"def frecuencia_abs(seq) -> dict:\\n hist = {}\\n for i in seq:\\n hist[i] = hist.get(i, 0) + 1\\n return hist\",\n \"def get_histogram(self):\\n\\n values_array = np.array(self.values)\\n for bin0 in range(self.bins[0].size):\\n bin_inf0 = self.bins[0][bin0]\\n try: bin_sup0 = self.bins[0][bin0 + 1]\\n except IndexError: bin_sup0 = self.vmax[0]\\n values = values_array[\\n (values_array[:, 0] >= bin_inf0)\\n *(values_array[:, 0] < bin_sup0)][:, 1]\\n for bin1 in range(self.bins[1].size):\\n bin_inf1 = self.bins[1][bin1]\\n try: bin_sup1 = self.bins[1][bin1 + 1]\\n except IndexError: bin_sup1 = self.vmax[1]\\n self.hist[bin0*self.Nbins[1] + bin1, 2] = (\\n np.sum((values >= bin_inf1)*(values < bin_sup1)))\\n\\n if np.sum(self.hist[:, 2]) > 0: # there are binned values\\n self.hist[:, 2] /= np.sum(self.hist[:, 2])\\n return self.hist\",\n \"def just_histogram(*args, **kwargs):\\n return np.histogram(*args, **kwargs)[0].astype(float)\",\n \"def compute_histogram(self):\\n # compute distance between points \\n distmatrix = np.sqrt(pdist(self.points))\\n if not self.mean_dist:\\n self.mean_dist = np.mean(distmatrix)\\n distmatrix = distmatrix/self.mean_dist\\n distmatrix = squareform(distmatrix)\\n #compute angles between points\\n angles = compute_angles(self.points)\\n #quantize angles to a bin\\n tbins = np.floor(angles / (2 * pi / self.nbins_theta))\\n lg = np.logspace(self.r1, self.r2, num=5)\\n #quantize radious to bins\\n rbins = np.ones(angles.shape) * -1\\n for r in lg:\\n counts = (distmatrix < r) \\n rbins = rbins + counts.astype(int) \\n return rbins, tbins\",\n \"def histogram(self, mask=None, extrema=None):\\r\\n uni, counts = self._getcolors()\\r\\n return [l for l in counts]\",\n \"def create_fixed_hist(self):\\n hist = cv2.calcHist([self.obj], [0, 1, 2], None, [32, 8, 8],\\n [0, 256, 0, 256, 0, 256])\\n self.hist = cv2.normalize(hist).flatten()\\n print self.hist\",\n \"def histo ( self ,\\n xbins = 20 , xmin = None , xmax = None ,\\n ybins = 20 , ymin = None , ymax = None ,\\n hpars = () , \\n histo = None ,\\n integral = False ,\\n errors = False , \\n density = False ) :\\n \\n \\n histos = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\\n ybins = ybins , ymin = ymin , ymax = ymax ,\\n hpars = hpars ,\\n histo = histo )\\n\\n # loop over the historgam bins \\n for ix,iy,x,y,z in histo.items() :\\n\\n xv , xe = x.value() , x.error()\\n yv , ye = y.value() , y.error()\\n \\n # value at the bin center \\n c = self ( xv , yv , error = errors ) \\n\\n if not integral : \\n histo[ix,iy] = c\\n continue\\n\\n # integral over the bin \\n v = self.integral( xv - xe , xv + xe , yv - ye , yv + ye )\\n \\n if errors :\\n if 0 == c.cov2 () : pass\\n elif 0 != c.value() and 0 != v : \\n v = c * ( v / c.value() )\\n \\n histo[ix,iy] = v \\n\\n ## coovert to density historgam, if requested \\n if density : histo = histo.density()\\n \\n return histo\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\",\n \"def anticum_hist(data, bins=None, toadd=0, zero=False, zerox=False):\\n\\n from numpy import histogram, unique, append, cumsum, zeros, array\\n data = array(data)\\n\\n if bins is None:\\n temp, bins = histogram(data, unique(data))\\n hist = append(cumsum(temp[::-1])[::-1], 1)\\n else:\\n if len(data) == 0:\\n return zeros(len(bins)), bins\\n # if max(data) > max(bins):\\n # print \\\"Must have the largest bin be bigger than the largest data point.\\\"\\n # print max(bins)\\n # print max(data)\\n # import sys\\n # sys.exit(1337)\\n temp, bins = histogram(data, bins=bins)\\n numbig = data[data > bins.max()].shape[0]\\n # add on the objects that are above the last bin to the last count, so that they're included in the cumulative sum\\n temp[-1] += numbig\\n hist = append(cumsum(temp[::-1])[::-1], numbig)\\n\\n hist = hist + toadd # add some number to all the values\\n\\n if zero:\\n hist = append(hist, 1e-10)\\n bins = append(bins, bins[-1])\\n if zerox:\\n hist = append(hist[0], hist)\\n bins = append(1e-10, bins)\\n\\n return hist, bins\",\n \"def test_get_histogram_stat_by(self):\\n pass\",\n \"def hist(a,bins):\\n n=searchsorted(sort(a),bins)\\n n=concatenate([n,[len(a)]])\\n n=array(list(map(float,n)))\\n# n=array(n)\\n return n[1:]-n[:-1]\",\n \"def histogram(self):\\n return self._hist\",\n \"def add_histogram(self, tag, values, global_step=None, bins='tensorflow'):\\n values = make_np(values)\\n self.vis.histogram(make_np(values), opts={'title': tag})\",\n \"def distribution_magnitude_histogram(cur, var, table, label):\\n x = select(cur,var, table)\\n print(\\\"Number of entries: \\\", len(x))\\n print(\\\"Maximum: \\\", max(x))\\n print(\\\"Minimum: \\\", min(x))\\n \\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.set_xlabel(\\\"Sentiment Magnitude\\\")\\n ax.set_ylabel(\\\"Number of Sentences\\\")\\n fig.suptitle(label)\\n ax.hist(x, bins = 20)\\n plt.show()\",\n \"def histogram(self):\\n if np.size(self.stats['Counts']): # don't do anything to an empty list\\n if np.size(self.bins) and not self.redo:\\n return self.bins, self.occs, self.thresh\\n elif np.size(self.bin_array) > 0: \\n self.occs, self.bins = np.histogram(self.stats['Counts'], self.bin_array) # fixed bins. \\n else:\\n try:\\n lo, hi = min(self.stats['Counts'])*0.97, max(self.stats['Counts'])*1.02\\n # scale number of bins with number of files in histogram and with separation of peaks\\n num_bins = int(15 + self.ind//100 + (abs(hi - abs(lo))/hi)**2*15) \\n self.occs, self.bins = np.histogram(self.stats['Counts'], bins=np.linspace(lo, hi, num_bins+1)) # no bins provided by user\\n except: \\n self.occs, self.bins = np.histogram(self.stats['Counts'])\\n else: self.occs, self.bins = np.zeros(10), np.arange(0,1.1,0.1)\\n return self.bins, self.occs, self.thresh\",\n \"def _compute_histogram(self, x, momentum):\\n num_bins = self.histogram.size(0)\\n x_detached = x.detach()\\n self.bin_width = (self._max_val - self._min_val) / (num_bins - 1)\\n lo = torch.floor((x_detached - self._min_val) / self.bin_width).long()\\n hi = (lo + 1).clamp(min=0, max=num_bins - 1)\\n hist = x.new_zeros(num_bins)\\n alpha = (\\n 1.0\\n - (x_detached - self._min_val - lo.float() * self.bin_width)\\n / self.bin_width\\n )\\n hist.index_add_(0, lo, alpha)\\n hist.index_add_(0, hi, 1.0 - alpha)\\n hist = hist / (hist.sum() + 1e-6)\\n self.histogram = (1.0 - momentum) * self.histogram + momentum * hist\",\n \"def test_get_histogram_stat_by_breakout(self):\\n pass\",\n \"def f_hist(datos, lims, devolver_frecuencia=False):\\n #incializacion\\n n_bins = lims.size - 1\\n frec_abs = np.zeros(n_bins)\\n #conteo frecuencia absoluta\\n for i in range(n_bins):\\n frec_abs[i] = np.sum( (lims[i] <= datos) * (datos < lims[i+1]) )\\n #calculo de funcion histograma\\n hist = frec_abs / (n_sim * (lims[1:] - lims[:-1]))\\n #salida de resultados\\n if devolver_frecuencia:\\n return frec_abs, hist\\n else:\\n return hist\",\n \"def create_general_hist(self, obj):\\n hist = cv2.calcHist([obj], [0, 1, 2], None, [32, 8, 8],\\n [0, 256, 0, 256, 0, 256])\\n print cv2.normalize(hist).flatten()\\n return cv2.normalize(hist).flatten()\",\n \"def ascii_hist(x):\\n fAbs = frecuencia_abs(x)\\n for k in sorted(fAbs):\\n print(\\\"{0:5d} {1}\\\".format(k, \\\"+\\\"*fAbs[k]))\",\n \"def getHistogram( self, img):\\n bins = 256\\n range_scale = [0,254]\\n nivel_transparencia = 0.5\\n plt.hist(img.ravel(),bins,range_scale, label=\\\"histogram\\\", alpha=nivel_transparencia);\\n plt.legend(loc='upper right')\\n plt.show()\",\n \"def _histogram_with_spread(self):\\n complexity_hist = np.bincount(\\n self.epoch.array_annotations['complexity'])\\n num_bins = (self.t_stop - self.t_start).rescale(\\n self.bin_size.units).item() / self.bin_size.item()\\n num_bins = round_binning_errors(num_bins, tolerance=self.tolerance)\\n time_hist = np.zeros(num_bins, dtype=int)\\n\\n start_bins = (self.epoch.times - self.t_start).rescale(\\n self.bin_size.units).magnitude / self.bin_size.item()\\n stop_bins = (self.epoch.times + self.epoch.durations - self.t_start\\n ).rescale(self.bin_size.units\\n ).magnitude / self.bin_size.item()\\n\\n if self.sampling_rate is not None:\\n shift = (.5 / self.sampling_rate / self.bin_size).simplified.item()\\n # account for the first bin not being shifted in the epoch creation\\n # if the shift would move it past t_start\\n if self.epoch.times[0] == self.t_start:\\n start_bins[1:] += shift\\n else:\\n start_bins += shift\\n stop_bins += shift\\n\\n start_bins = round_binning_errors(start_bins, tolerance=self.tolerance)\\n stop_bins = round_binning_errors(stop_bins, tolerance=self.tolerance)\\n\\n for idx, (start, stop) in enumerate(zip(start_bins, stop_bins)):\\n time_hist[start:stop] = \\\\\\n self.epoch.array_annotations['complexity'][idx]\\n\\n time_hist = neo.AnalogSignal(\\n signal=np.expand_dims(time_hist, axis=1),\\n sampling_period=self.bin_size, units=pq.dimensionless,\\n t_start=self.t_start)\\n\\n empty_bins = (self.t_stop - self.t_start - self.epoch.durations.sum())\\n empty_bins = empty_bins.rescale(self.bin_size.units\\n ).magnitude / self.bin_size.item()\\n empty_bins = round_binning_errors(empty_bins, tolerance=self.tolerance)\\n complexity_hist[0] = empty_bins\\n\\n return time_hist, complexity_hist\",\n \"def histogram_function(r_min, a, N, nbins):\\n r_min_no_selfdistance = r_min - np.identity(len(r_min)) #remove identitity matrix so own distance will be treated as 0\\n histarray = np.array(r_min_no_selfdistance).flatten()\\n histogram = np.histogram(histarray,bins=np.linspace(0,a,nbins))\\n histogram[0][0] = histogram[0][0] - N # remove N from the first bin to prevent it counting particle distance to itself\\n return histogram[0]\",\n \"def _determine_histogram_bins(self, ma_maps):\\n if isinstance(ma_maps, list):\\n ma_values = self.masker.transform(ma_maps)\\n elif isinstance(ma_maps, np.ndarray):\\n ma_values = ma_maps.copy()\\n else:\\n raise ValueError(f\\\"Unsupported data type '{type(ma_maps)}'\\\")\\n\\n # Determine bins for null distribution histogram\\n # Remember that numpy histogram bins are bin edges, not centers\\n # Assuming values of 0, .001, .002, etc., bins are -.0005-.0005, .0005-.0015, etc.\\n INV_STEP_SIZE = 100000\\n step_size = 1 / INV_STEP_SIZE\\n max_ma_values = np.max(ma_values, axis=1)\\n # round up based on resolution\\n max_ma_values = np.ceil(max_ma_values * INV_STEP_SIZE) / INV_STEP_SIZE\\n max_poss_ale = self.compute_summarystat(max_ma_values)\\n # create bin centers\\n hist_bins = np.round(np.arange(0, max_poss_ale + (1.5 * step_size), step_size), 5)\\n self.null_distributions_[\\\"histogram_bins\\\"] = hist_bins\",\n \"def hist_and_thresh(self):\\n bins, occ, _ = self.histogram()\\n self.thresh = np.mean(bins) # initial guess\\n self.peaks_and_thresh() # in case peak calculation fails\\n # if np.size(self.peak_indexes) == 2: # est_param will only find one peak if the number of bins is small\\n # # set the threshold where the fidelity is max\\n # self.search_fidelity(self.peak_centre[0], self.peak_widths[0] ,self.peak_centre[1])\\n try: \\n thresh = threshold_minimum(np.array(self.stats['Counts']), len(bins))\\n int(np.log(thresh)) # if thresh <= 0 this gives ValueError\\n self.thresh = thresh\\n except (ValueError, RuntimeError, OverflowError): pass\\n try:\\n # atom is present if the counts are above threshold\\n self.stats['Atom detected'] = [x // self.thresh for x in self.stats['Counts']]\\n # self.fidelity, self. err_fidelity = np.around(self.get_fidelity(), 4) # this is a relatively slow operation\\n except (ValueError, OverflowError): pass\\n return bins, occ, self.thresh\",\n \"def update_histo_frame():\\n min_histo.text = str(MIN_RANGE_F) # Display the legend\\n max_histo.text = str(MAX_RANGE_F)\\n\\n histogram = np.zeros(GRID_AXIS) # Clear histogram accumulation array\\n # Collect camera data and calculate the histogram\\n for _row in range(0, GRID_AXIS):\\n for _col in range(0, GRID_AXIS):\\n histo_index = int(map_range(GRID_DATA[_col, _row], 0, 1, 0, GRID_AXIS - 1))\\n histogram[histo_index] = histogram[histo_index] + 1\\n\\n histo_scale = np.max(histogram) / (GRID_AXIS - 1)\\n if histo_scale <= 0:\\n histo_scale = 1\\n\\n # Display the histogram\\n for _col in range(0, GRID_AXIS):\\n for _row in range(0, GRID_AXIS):\\n if histogram[_col] / histo_scale > GRID_AXIS - 1 - _row:\\n image_group[((_row * GRID_AXIS) + _col)].fill = index_to_rgb(\\n round((_col / GRID_AXIS), 3)\\n )\\n else:\\n image_group[((_row * GRID_AXIS) + _col)].fill = BLACK\",\n \"def sum_hist(self, label=None):\\n values = [h.values for h in self.hists]\\n errors = [h.yerr for h in self.hists]\\n hist = deepcopy(self.hists[0])\\n hist.values = sum(values)\\n hist.yerr = np.sqrt(sum([error*error for error in errors]))\\n hist.label = label\\n hist.color = style.def_grey\\n return hist\",\n \"def _histogram_no_spread(self):\\n # Computing the population histogram with parameter binary=True to\\n # clip the spike trains before summing\\n time_hist = time_histogram(self.input_spiketrains,\\n self.bin_size,\\n binary=self.binary)\\n\\n time_hist_magnitude = time_hist.magnitude.flatten()\\n\\n # Computing the histogram of the entries of pophist\\n complexity_hist = np.bincount(time_hist_magnitude)\\n\\n return time_hist, complexity_hist\",\n \"def getPeaksFromHist(orig_hist, width_thres=0, height_thres=0):\\n if len(orig_hist) < 10:\\n return []\\n if width_thres == 0:\\n width_thres = 5\\n if height_thres == 0:\\n height_thres = np.mean(orig_hist)\\n\\n hist = smooth(np.array(orig_hist), 20)\\n hist[hist < height_thres] = height_thres\\n hist = hist - min(hist)\\n\\n peak_hist1 = np.zeros((len(hist), 1))\\n peak_list = []\\n for i in range(4, len(hist) - 4):\\n peak_hist1[i] = hist[i + 1] - hist[i - 1]\\n\\n for i in range(width_thres, len(peak_hist1) - width_thres):\\n\\n\\n if all(peak_hist1[i - width_thres:i] > 0) and all(peak_hist1[i + 1:i + width_thres] < 0):\\n peak_list.append(i)\\n\\n if len(peak_list) != 0:\\n new_list = []\\n derivate = np.zeros((len(peak_list), 1))\\n for i in range(1, len(peak_list)):\\n derivate[i] = peak_list[i] - peak_list[i - 1]\\n i = 0\\n while i < len(derivate) - 1:\\n s = peak_list[i]\\n c = 0\\n if derivate[i + 1] == 1 and not i + 1 == len(derivate) - 1:\\n j = i + 1\\n while j <= len(derivate):\\n if derivate[j] == 1 and not j + 1 == len(derivate):\\n s += peak_list[j]\\n c += 1\\n j += 1\\n else:\\n s /= (c + 1)\\n i = j\\n break\\n else:\\n i += 1\\n new_list.append(s)\\n if i != len(derivate) - 1:\\n new_list.append(peak_list[i])\\n peak_list = new_list\\n\\n peak_list.sort()\\n return peak_list\",\n \"def norm_hist(self, hist_lower, hist_upper, lower, upper, value) :\\n norm = 1.\\n if upper>lower :\\n norm = hist_lower.Integral()+(hist_upper.Integral()-hist_lower.Integral())/abs(upper-lower)*(value-lower)\\n return norm\",\n \"def getHistogram(self, var, idx = None, translation = None, other = None,\\\\\\n verbose = 1, ab = [], bins = 100, minmax = None):\\n \\n if idx is None: idx = np.arange(self.atoms.shape[0])\\n if translation is None: translation = [0]\\n if isinstance(translation, (int, np.integer)): translation = [translation]\\n\\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\\\\n verbose = verbose, ab = ab, other = other)\\n x = []\\n y = []\\n for i, item in enumerate(data):\\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\\n x.append((bin[:-1] + bin[1:]) / 2)\\n y.append(cnt)\\n\\n return x, y, lbl, leg\",\n \"def hist(img):\\n bottom_half = img[img.shape[0]//2:,:] # 0:img.shape[0]//2 is the top half\\n histogram = bottom_half.sum(axis=0) \\n \\n return histogram\",\n \"def calcHistogram(Tech_res):\\n A_Hist = np.histogram(Tech_res.A_mean, Tech_res.hist_bins)\\n top, bin_list, x_steps = list(A_Hist[0]), list(A_Hist[1]), []\\n for n in range(np.shape(bin_list)[0]-1):\\n x_steps.append((bin_list[n+1] + bin_list[n]) / 2)\\n Tech_res.update_tech_meas(Hist_tops=top, Hist_steps=x_steps)\\n return\",\n \"def build_hist(concept_values: np.ndarray, num_bins: int = 100) -> np.ndarray:\\n hist, _ = np.histogram(concept_values, bins=num_bins, range=(0., 1.), density=True)\\n return hist\",\n \"def make_sorted_frequencies(counts, absolute=False):\\r\\n\\r\\n c = sort(counts)\\r\\n c = c[c.nonzero()]\\r\\n c = c[::-1]\\r\\n if absolute:\\r\\n return c\\r\\n else:\\r\\n f = c / float(c.sum())\\r\\n return f\",\n \"def hist_zero(df, *args, **kwargs):\\n # TODO: should this set values to 0?\\n df = df.copy()\\n return df\",\n \"def calculateHistogram(self):\\n \\n # Define color map\\n colors = [ (255,0,0),(0,255,0),(0,0,255) ]\\n # Define empty image to plot histogram in\\n plot_to_fill = np.zeros((280,400,3))\\n # Define bins of the histogram\\n bins = np.arange(256).reshape(256,1)\\n \\n # Boucle sur les canaux\\n for channel, color in enumerate(colors):\\n # Calcul de l'histogramme\\n hist_item = cv2.calcHist(self.frame,[channel],None,[256],[0,256])\\n # Normalisation\\n cv2.normalize(hist_item,hist_item,0,255,cv2.NORM_MINMAX)\\n # Conversion\\n hist = np.int32(np.around(hist_item))\\n pts = np.int32(np.column_stack((bins, hist)))\\n cv2.polylines(plot_to_fill, [pts], False, color)\\n # Mettre dans le bon sens\\n histplot = np.flipud(plot_to_fill)\\n histplot = np.uint8(histplot)\\n \\n # Conversion en objet QPixelMap\\n self.histplot_qpix = self.convertToQPixelmap(histplot)\",\n \"def histogram_plot(val_addr):\\n pos = np.zeros((val_addr.shape[0],2))\\n for i in range(val_addr.shape[0]):\\n if i%1e6==0:\\n print(i)\\n temp=val_addr[i]\\n if temp<25:\\n if temp<=4:\\n pos[i,0]=np.sqrt(3)\\n pos[i,1] = temp-2.\\n elif temp<=8:\\n pos[i,0]=np.sqrt(3)/2.\\n pos[i,1] = temp-6.5 \\n elif temp<=13:\\n pos[i,0]=0\\n pos[i,1] = temp-11. \\n elif temp<=17:\\n pos[i,0]=-np.sqrt(3)/2.\\n pos[i,1] = temp-15.5 \\n elif temp<=23:\\n pos[i,0]=-np.sqrt(3)\\n pos[i,1] = temp-20.\\n plt.hexbin(pos[:,1],pos[:,0],gridsize=(4,2))\\n plt.colorbar()\\n plt.show()\\n return(pos)\",\n \"def ahistogram (inarray,numbins=10,defaultlimits=None,printextras=1):\\r\\n inarray = N.ravel(inarray) # flatten any >1D arrays\\r\\n if (defaultlimits <> None):\\r\\n lowerreallimit = defaultlimits[0]\\r\\n upperreallimit = defaultlimits[1]\\r\\n binsize = (upperreallimit-lowerreallimit) / float(numbins)\\r\\n else:\\r\\n Min = N.minimum.reduce(inarray)\\r\\n Max = N.maximum.reduce(inarray)\\r\\n estbinwidth = float(Max - Min)/float(numbins) + 1e-6\\r\\n binsize = (Max-Min+estbinwidth)/float(numbins)\\r\\n lowerreallimit = Min - binsize/2.0 #lower real limit,1st bin\\r\\n bins = N.zeros(numbins)\\r\\n extrapoints = 0\\r\\n for num in inarray:\\r\\n try:\\r\\n if (num-lowerreallimit) < 0:\\r\\n extrapoints = extrapoints + 1\\r\\n else:\\r\\n bintoincrement = int((num-lowerreallimit) / float(binsize))\\r\\n bins[bintoincrement] = bins[bintoincrement] + 1\\r\\n except: # point outside lower/upper limits\\r\\n extrapoints = extrapoints + 1\\r\\n if (extrapoints > 0 and printextras == 1):\\r\\n print '\\\\nPoints outside given histogram range =',extrapoints\\r\\n return (bins, lowerreallimit, binsize, extrapoints)\",\n \"def _make_histogram(values, bins):\\n values = values.reshape(-1)\\n counts, limits = np.histogram(values, bins=bins)\\n limits = limits[1:]\\n\\n sum_sq = values.dot(values)\\n return HistogramProto(min=values.min(),\\n max=values.max(),\\n num=len(values),\\n sum=values.sum(),\\n sum_squares=sum_sq,\\n bucket_limit=limits,\\n bucket=counts)\",\n \"def color_hist_block(aois):\\n hist = cv2.calcHist([aois[0]], [0], None, [30], [0, 256])\\n contrasts = []\\n for aoi in aois[1:]:\\n hist = hist + cv2.calcHist([aoi], [0], None, [30], [0, 256])\\n contrasts.append(compute_contrast(aoi))\\n hist = cv2.normalize(hist, hist).flatten()\\n # print hist,contrasts\\n return hist\",\n \"def create_hist(pVals,bins=1000,log=False,max_val=False):\\n\\t# gets an array of pValues and returns an array of bins with counts\\n\\thist_count = np.zeros(bins)\\n\\tif (log):\\n\\t\\tnlp = -1.0*np.log10(pVals)\\n\\t\\tif (max_val):\\n\\t\\t\\tnlp_max=max_val\\n\\t\\telse:\\n\\t\\t\\tnlp_max = nlp.max()\\n\\t\\tpVals = pVals/nlp_max\\n\\tfor i in pVals:\\n\\t\\tj=int(bins*i)\\n\\t\\tif j == bins:\\n\\t\\t\\tj -= 1\\n\\t\\thist_count[j] += 1\\n\\treturn hist_count\",\n \"def _printHist(self):\\n bins = [0] * self.displayBins\\n binSize = self.maxValue / self.displayBins\\n displaySamps = self.samples[:]\\n displaySamps.sort()\\n currLimit = binSize\\n binIndex = 0\\n partIndex = 0\\n while partIndex < self.numParticles:\\n part = displaySamps[partIndex]\\n if binIndex >= self.displayBins:\\n # if value beyond max value, add to last bin and go on to next particle\\n bins[19] += 1\\n partIndex += 1\\n elif part < currLimit:\\n # count particle in current bin, go on to next particle\\n bins[binIndex] += 1\\n partIndex += 1\\n else:\\n # go on to next bin, don't go on to next particle\\n binIndex += 1\\n currLimit += binSize\\n self.printMapPattern(binSize)\\n histStr = \\\"{0:3d} \\\"\\n printStr = \\\"\\\"\\n for b in bins:\\n printStr += histStr.format(b)\\n print(printStr)\",\n \"def normalize_hist(hist) -> [float]:\\n hsum = np.sum(hist)\\n newhist = []\\n for hi in hist:\\n newhist.append(hi/hsum)\\n\\n return newhist\",\n \"def histograms(probs, actual, bins=100):\\n actual = actual.astype(np.bool)\\n edges, step = np.linspace(0., 1., bins, retstep=True, endpoint=False)\\n idx = np.digitize(probs, edges) - 1\\n top = np.bincount(idx, weights=actual, minlength=bins)\\n bot = np.bincount(idx, weights=(~actual), minlength=bins)\\n return top, bot, edges, step\",\n \"def test_get_result_histogram_stat(self):\\n pass\",\n \"def OF1_CalculateRawHistogram(image):\\n h = np.zeros(256, np.float_)\\n for i in np.nditer(image):\\n h[i - 1] = h[i - 1] + 1\\n\\n return h\",\n \"def histogram(f, option=\\\"uint16\\\"):\\n from numpy import searchsorted, sort, ravel, concatenate, product\\n\\n n = searchsorted(sort(ravel(f)), range(f.max()+1))\\n n = concatenate([n, [product(f.shape)]])\\n h = n[1:]-n[:-1]\\n return h\",\n \"def normalized(self):\\n total = self.total()\\n result = Histogram()\\n for value, count in self.items():\\n try:\\n result[value] = count / float(total)\\n except UnorderableElements:\\n result = Histogram.from_dict(dict(result), key=hash)\\n result[value] = count / float(total)\\n return result\",\n \"def OF1_CalculateNormalizedHistogram(image):\\n\\n raw = OF1_CalculateRawHistogram(image)\\n norm = np.zeros(256, np.float_)\\n\\n for i in range(256):\\n norm[i] = raw[i] / image.size\\n\\n return norm\",\n \"def gc_percent_hist(data):\\n result = [0] * 101 # 0-100\\n for s in data:\\n percent = _gc_percent(s)\\n result[percent] += 1\\n return result\",\n \"def avghist(data, weights, bins=None):\\n if bins is not None:\\n sums = np.histogram(data, weights=weights, bins=bins)[0]\\n (counts, buckets) = np.histogram(data, bins=bins)\\n buckets=bins\\n else:\\n sums = np.histogram(data, weights=weights)[0]\\n (counts, buckets) = np.histogram(data)\\n\\n #elements with zero count will by definition have zero sum, ignore div by zero\\n counts[counts == 0] = 1\\n\\n bin_means = np.divide(sums, counts)\\n return (bin_means, buckets)\",\n \"def hist_of_numeric(X):\\n figsize(10,3)\\n for col in get_numeric(X):\\n print(col)\\n X[col].hist(bins=50)\\n show()\",\n \"def create_af_histo(snp_dict,perc):\\n for i in snp_dict.keys():\\n hist=np.histogram(snp_dict[i]['afs'], bins=np.ceil(100.0/perc), range=(0.0,1.0))\\n # get rid of bins with afs == 0 in the spectrum\\n vals=[]\\n bins=[]\\n for j,x in enumerate(hist[0]):\\n if x > 0:\\n if len(vals) == 0:\\n bins.append(hist[1][j])\\n elif (bins[-1] != hist[1][j] ):\\n vals.append(0)\\n bins.append(hist[1][j])\\n vals.append(x)\\n bins.append(hist[1][j+1])\\n snp_dict[i]['afs_hist'] = { 'counts':np.array(vals),'bins':np.array(bins) }\\n return True\",\n \"def histogram_creation(val_addr,val_time,time_range):\\n a=val_time.shape[0]\\n hist = np.zeros((23,23,2*time_range+1))\\n for i in range(a-1):\\n b=1 \\n diff = val_time[i+b]-val_time[i]\\n\\n while diff<=time_range and diff>=0:\\n if val_addr[i]<25 and val_addr[i+b]<25:\\n hist[val_addr[i],val_addr[i+b],time_range+diff]+=1\\n hist[val_addr[i+b],val_addr[i],time_range-diff]+=1\\n b+=1\\n try:\\n diff = val_time[i+b]-val_time[i]\\n except:\\n break\\n return(hist)\",\n \"def compute_hist(query_loc, radius, qtree):\\r\\n hist_result = []\\r\\n for r in radius:\\r\\n nearby_point = qtree.query_ball_point(query_loc, r)\\r\\n hist_result.append(float(len(nearby_point)))\\r\\n\\r\\n index = len(hist_result) - 1\\r\\n while index != 1:\\r\\n hist_result[index] -= hist_result[index-1]\\r\\n index -= 1\\r\\n \\r\\n total_point = sum(hist_result)\\r\\n if total_point != 0:\\r\\n for index in range(0, len(hist_result)):\\r\\n hist_result[index] /= total_point\\r\\n return hist_result\",\n \"def get_hist(self):\\n return self.hist\",\n \"def fullhistogram(img):\\n maxt = img.max()\\n if maxt == 0:\\n return np.array([img.size])\\n return nhistogram(img, np.arange(maxt+2))[0]\",\n \"def correlation_bins(shred):\\n return 0\",\n \"def histograma(frame):\\n #Imagen mejorada por Equalizacion de Histogramas.\\n histograma = cv2.equalizeHist(frame)\\n return histograma\",\n \"def produceHist(self, start=None, end=None, period=24 * 3600):\\n self.sort()\\n if len(self) == 0:\\n return\\n if start is None:\\n start = UTC(self[0].datetime.date)\\n if end is None:\\n end = UTC(self[-1].datetime)\\n entries = int((end - start) / period) + 1\\n hist_list = np.zeros(entries)\\n mag_list = np.zeros(entries)\\n for event in self:\\n #date = UTC(event.datetime.date)\\n entry = int((event.datetime - start) / period)\\n print entry\\n try:\\n hist_list[entry] += 1\\n mag_list[entry] = max(event.magnitude, mag_list[entry])\\n except IndexError:\\n pass\\n return hist_list, mag_list\",\n \"def histmake(self, n, minfreq, maxfreq, bins_, lat1, lat0, abs = False, norm = True,\\\\\\n pole = \\\"north\\\"):\\n\\n assert self.shifted, \\\"Data has not been index-shifted\\\"\\n\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n self.inds = inds\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n timesA, fftA = self.fft_time_holes_integral(signal = NeA,\\\\\\n seconds = secondsA, n = n, fs = self.fs, minfreq\\\\\\n = minfreq, maxfreq = maxfreq)\\n\\n timesB, fftB = self.fft_time_holes_integral(signal = NeB,\\\\\\n seconds = secondsB, n = n, fs = self.fs, minfreq\\\\\\n = minfreq, maxfreq = maxfreq)\\n\\n timesC, fftC = self.fft_time_holes_integral(signal = NeC,\\\\\\n seconds = secondsC, n = n, fs = self.fs, minfreq\\\\\\n = minfreq, maxfreq = maxfreq)\\n\\n\\n BAdiff = self.relative_diff(fftB, fftA, norm = norm, abs = abs)\\n BCdiff = self.relative_diff(fftB, fftC, norm = norm, abs = abs)\\n ACdiff = self.relative_diff(fftA, fftC, norm = norm, abs = abs)\\n\\n BAhist, bins = np.histogram(BAdiff, bins = bins_)\\n BChist, bins = np.histogram(BCdiff, bins = bins_)\\n AChist, bins = np.histogram(ACdiff, bins = bins_)\\n\\n bins = (bins[1:] + bins[:-1])/2\\n hists = [BAhist, BChist, AChist]\\n\\n return(hists, bins)\",\n \"def histogram_equalize(im_orig):\\n\\n color_flag = False\\n image = im_orig\\n\\n\\n if len(im_orig.shape) == 3: #RGB image\\n color_flag = True\\n y_im = rgb2yiq(im_orig)\\n image = y_im[:, :, 0]\\n\\n image *= NORMALIZE\\n hist_orig, bins = np.histogram(image, range(BINS))\\n hist_cum = np.cumsum(hist_orig) #cumulative distribution function\\n\\n cum = ((hist_cum - hist_cum.min()) / ( hist_cum.max() - hist_cum.min())) * NORMALIZE\\n\\n im_eq = cum[image.astype(np.uint8)]\\n\\n hist_eq, bins = np.histogram(im_eq, range(BINS)) #before getting back to float64 does the histogram)\\n\\n im_eq /= NORMALIZE\\n im_eq = im_eq.astype(np.float64)\\n\\n\\n if color_flag:\\n y_im[:, :, 0] = im_eq\\n im_eq = yiq2rgb(y_im)\\n\\n im_eq = im_eq.clip(0,1)\\n return [im_eq, hist_orig, hist_eq]\",\n \"def color_hist_single(aoi):\\n hist = cv2.calcHist([aoi], [0], None, [30], [0, 256])\\n return cv2.normalize(hist, hist).flatten()\",\n \"def get_histogram(folder_name, image_name, save_location):\\n print(\\\"Getting histogram for:\\\" + str(folder_name) + '/' + str(image_name))\\n image = cv2.imread(folder_name + '/' + image_name, cv2.IMREAD_ANYDEPTH)\\n plt.hist(image.ravel(), 256, [0, 65535])\\n plt.xlabel('Pixel Intensity')\\n plt.ylabel('Number of pixels')\\n plt.title('Histogram of normalised reference image. Overnight2')\\n plt.savefig(save_location + 'histogram.png')\\n plt.savefig(save_location + 'histogram.eps', format='eps')\\n # plt.show()\",\n \"def test_get_result_histogram(self):\\n pass\",\n \"def compute_histogram(self, image):\\n\\n hist = [0] * 256\\n x, y = image.shape[:2]\\n #print(image.shape)\\n for i in range(x):\\n for j in range(y):\\n hist[image[i, j]] += 1\\n\\n return hist\",\n \"def calculate_histogram(self, abstract_features_1, abstract_features_2):\\n scores = torch.mm(abstract_features_1, abstract_features_2).detach()\\n scores = scores.view(-1, 1)\\n hist = torch.histc(scores, bins=self.args.bins)\\n hist = hist/torch.sum(hist)\\n hist = hist.view(1, -1)\\n return hist\",\n \"def histogram_summary(self, tag, values, step, bins=1000):\\n self.writer.add_histogram(tag, values, step, bins='auto')\",\n \"def equalize_hist(input):\\n return np.float32(skimage.exposure.equalize_hist(input.numpy()))\",\n \"def readsHistogram(sortedList):\\n M = sortedList[0].getSamples()\\n for item in sortedList:\\n if max(item.getSamples()) < 5000:\\n M = np.vstack((M, item.getSamples()))\\n m = int(np.max(M))\\n M = np.ndarray.flatten(M)\\n # M = M[np.nonzero(M)] #considering zeros or not?\\n hist = np.histogram(M, bins= m)\\n # plt.xlabel(\\\"peak size(reads)\\\")\\n # plt.ylabel(\\\"number of peaks\\\")\\n # plt.title(\\\"Histogram of peaks sizes\\\")\\n # plt.bar(np.arange(50), hist[0][:50])\\n # plt.show()\\n cumulative = np.cumsum(hist[0])\\n mc = np.max(cumulative)\\n treshold = 0\\n indexesTreshold = np.where(cumulative <= mc * (1 - PERCENT_OF_READS_HIST))\\n if indexesTreshold[0].size > 0:\\n treshold = np.max(indexesTreshold)\\n return treshold\",\n \"def calc_stat_values(self):\",\n \"def equalise_hist(image, bin_count=256):\\n # TODO: your histogram equalization code\\n #define arrays\\n image = img_as_ubyte(image)\\n row,col = image.shape\\n new_image = np.zeros((row,col),dtype='uint8') \\n\\n # compute the value of each grayscale,and save in image_hist \\n image_hist = np.bincount(image.flatten(), minlength=(bin_count))\\n\\n # normalise n[]\\n norm_arr = (np.cumsum(image_hist)/(image.size))*(bin_count-1)\\n norm_arr = norm_arr.astype('uint8')\\n \\n #Compute a normalized cumulative histogram\\n for x in range(row):\\n for y in range(col):\\n new_image[x,y] = norm_arr[image[x,y]]\\n \\n return new_image\",\n \"def test_hist_w_unc_zero_case(self):\\n bins, hist, unc, band = hist_w_unc(\\n arr=[],\\n bins=[],\\n )\\n\\n np.testing.assert_almost_equal(bins, [])\\n np.testing.assert_almost_equal(hist, [])\\n np.testing.assert_almost_equal(unc, [])\\n np.testing.assert_almost_equal(band, [])\",\n \"def _hist(xs, bins=100, range=None, stats=('entries', 'mean', 'rms'),\\n xylabels = (), stats_xypos=(0.1, 0.7),\\n *args, **kargs):\\n if (range==None):\\n range = (np.min(xs), np.max(xs))\\n cc = hst.hist(xs, bins=bins, range=range, *args, **kargs);\\n if (not stats):\\n return cc\\n ys, xedges = np.histogram(xs, bins, range=range)\\n ns = len(xs)\\n sel = np.logical_and(xs >= range[0], xs <= range[1])\\n nos, mean, rms = len(xs[sel]), np.mean(xs[sel]), np.std(xs[sel])\\n epsilon = (1.*nos)/(1.*ns)\\n ss = ''\\n if ('total entries') in stats:\\n ss += 'total entries {0:d} \\\\n'.format(ns)\\n if ('entries') in stats:\\n ss += 'entries {0:d} \\\\n'.format(nos)\\n if ('mean') in stats:\\n ss += 'mean {0:.3f} \\\\n'.format(mean)\\n if ('rms') in stats:\\n ss += 'rms {0:.3f} \\\\n'.format(rms)\\n xp, yp = _xypos(xedges, ys, xf=stats_xypos[0], yf=stats_xypos[1])\\n ##plt.set_label(ss)\\n # plt.gca().set_label(ss)\\n # plt.legend()\\n plt.text(xp, yp, ss)\\n return cc\",\n \"def find_histogram(vol, hist, mini, maxi, mask, use_mask):\\n validsize = 0\\n hist = np.zeros(hist.size, dtype=int)\\n if mini == maxi:\\n return -1\\n\\n fA = float(hist.size)/(maxi-mini)\\n fB = (float(hist.size)*float(-mini)) / (maxi-mini)\\n\\n if use_mask:\\n a = vol[mask > 0.5].flatten()\\n else:\\n a = vol.flatten()\\n\\n a = (a*fA + fB).astype(int)\\n h = hist.size - 1\\n\\n for i in np.arange(a.size):\\n hist[max(0, min(a[i], h))] += 1\\n validsize += 1\\n\\n return hist, validsize\",\n \"def rythm_hist(duration_ohe):\\n assert duration_ohe.ndim == 2\\n return duration_ohe.sum(axis=0) / duration_ohe.sum()\",\n \"def histograma(p):\\n img = read_img(p)\\n show_histograma(img.reshape((-1)))\",\n \"def hist(data):\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(111)\\n plt.hold(True)\\n for x in xrange(len(data[:,0,0])):\\n counts, edges = np.histogram(data[x,:,:],bins=100)\\n centers = [(edges[i]+edges[i+1])/2.0 for i,v in enumerate(edges[:-1])]\\n ax1.plot(centers,counts)\\n plt.hold(False)\\n\\n plt.show(block=False)\\n\\n # return fig\",\n \"def _histogram(image,\\n min,\\n max,\\n bins):\\n\\n return numpy.histogram(image, bins, (min, max))[0]\",\n \"def histeq( im, nbr_bins = 256):\\n\\t# get image histogram \\n\\timhist, bins = histogram( im.flatten(), nbr_bins, normed = True) \\n\\tcdf = imhist.cumsum() \\n\\t# cumulative distribution function cdf = 255 * cdf / cdf[-1] \\n\\t# normalize \\n\\t# use linear interpolation of cdf to find new pixel values \\n\\tim2 = interp( im.flatten(), bins[:-1], cdf) \\n\\treturn im2.reshape( im.shape), cdf\",\n \"def test_uniform(self):\\r\\n\\r\\n s = np.random.uniform(-1.35, 0.5, 5000)\\r\\n plt.hist(s, 30, density=False)\\r\\n plt.xlabel('Interlayer point energy [eV]')\\r\\n plt.ylabel('Frequency')\\r\\n plt.show()\",\n \"def normalize(histogram):\\n nbins = histogram.GetNbinsX()\\n integral = histogram.Integral(1,nbins)\\n newhist = histogram.Clone()\\n newhist.Reset()\\n for bin in range(1,nbins+1):\\n ibinY = histogram.GetBinContent(bin)\\n newhist.SetBinContent(bin,ibinY/integral)\\n return newhist\",\n \"def createHistogram(data,cumulative=False,**kargs):\\n y,x = histogram(data,**kargs)\\n if cumulative:\\n y = y.cumsum()\\n return y,x\",\n \"def hist(self, bins=\\\"unit\\\", closed=\\\"left\\\", stat=\\\"sum\\\"):\\n return self.dist.hist(bins=bins, closed=closed, stat=stat)\",\n \"def plot_histogram(self,**kwargs):\\n axes = []\\n for i in range(self.score_length):\\n fig = plt.figure()\\n scores = np.array([s[i] for s in self.scores_list])\\n probs,bins,patches = plt.hist(scores,label=\\\"Sample {}\\\".format(self.labels[i]), **kwargs)\\n plt.vlines(self.xhat,fig.get_axes().get_ylim(),label='Mean',color='r')\\n plt.legend()\\n axes.append(fig.get_axes())\\n return axes\",\n \"def normalise_histogram(histogram):\\n total_sum = np.sum(histogram)\\n for i in range(len(histogram)):\\n histogram[i] /= total_sum\\n\\n return histogram\",\n \"def color_histogram_hsv(im, nbin=10, xmin=0, xmax=255, normalized=True):\\n ndim = im.ndim\\n bins = np.linspace(xmin, xmax, nbin + 1)\\n hsv = matplotlib.colors.rgb_to_hsv(im / xmax) * xmax\\n imhist, bin_edges = np.histogram(hsv[:, :, 0],\\n bins=bins,\\n density=normalized)\\n imhist = imhist * np.diff(bin_edges)\\n\\n return imhist\",\n \"def setup_hist(self):\\n self.x_min = {}\\n self.x_max = {}\\n self.x_max_minus_min = {}\\n self.dx = {}\\n self.n_bins = {}\\n\\n self.histogram_edges = {}\\n self.histogram_values = {}\\n self.histogram_cdf = {}\",\n \"def _compute_null_approximate(self, ma_maps):\\n if isinstance(ma_maps, list):\\n ma_values = self.masker.transform(ma_maps)\\n elif isinstance(ma_maps, np.ndarray):\\n ma_values = ma_maps.copy()\\n else:\\n raise ValueError(f\\\"Unsupported data type '{type(ma_maps)}'\\\")\\n\\n assert \\\"histogram_bins\\\" in self.null_distributions_.keys()\\n\\n def just_histogram(*args, **kwargs):\\n \\\"\\\"\\\"Collect the first output (weights) from numpy histogram.\\\"\\\"\\\"\\n return np.histogram(*args, **kwargs)[0].astype(float)\\n\\n # Derive bin edges from histogram bin centers for numpy histogram function\\n bin_centers = self.null_distributions_[\\\"histogram_bins\\\"]\\n step_size = bin_centers[1] - bin_centers[0]\\n inv_step_size = 1 / step_size\\n bin_edges = bin_centers - (step_size / 2)\\n bin_edges = np.append(bin_centers, bin_centers[-1] + step_size)\\n\\n ma_hists = np.apply_along_axis(just_histogram, 1, ma_values, bins=bin_edges, density=False)\\n\\n # Normalize MA histograms to get probabilities\\n ma_hists /= ma_hists.sum(1)[:, None]\\n\\n ale_hist = ma_hists[0, :].copy()\\n\\n for i_exp in range(1, ma_hists.shape[0]):\\n\\n exp_hist = ma_hists[i_exp, :]\\n\\n # Find histogram bins with nonzero values for each histogram.\\n ale_idx = np.where(ale_hist > 0)[0]\\n exp_idx = np.where(exp_hist > 0)[0]\\n\\n # Compute output MA values, ale_hist indices, and probabilities\\n ale_scores = (\\n 1 - np.outer((1 - bin_centers[exp_idx]), (1 - bin_centers[ale_idx])).ravel()\\n )\\n score_idx = np.floor(ale_scores * inv_step_size).astype(int)\\n probabilities = np.outer(exp_hist[exp_idx], ale_hist[ale_idx]).ravel()\\n\\n # Reset histogram and set probabilities.\\n # Use at() instead of setting values directly (ale_hist[score_idx] = probabilities)\\n # because there can be redundant values in score_idx.\\n ale_hist = np.zeros(ale_hist.shape)\\n np.add.at(ale_hist, score_idx, probabilities)\\n\\n self.null_distributions_[\\\"histweights_corr-none_method-approximate\\\"] = ale_hist\",\n \"def arelfreq(a,numbins=10,defaultreallimits=None):\\r\\n h,l,b,e = histogram(a,numbins,defaultreallimits)\\r\\n h = N.array(h/float(a.shape[0]))\\r\\n return h,l,b,e\",\n \"def makeHist(data, bins, wgt=None, factor=1.0, pdf=False):\\n n_arr, bins = np.histogram(data, bins, weights=wgt)\\n ctr_bins = centerOfBins(bins)\\n \\n if pdf == True:\\n n_arr = asFloat(n_arr) / (float(sum(n_arr)) * (bins[1:] - bins[:-1]))\\n else:\\n n_arr = asFloat(n_arr) * factor\\n \\n return n_arr, ctr_bins\",\n \"def hist_pvalue(perms, ax, name):\\n # Re-weight to obtain distribution\\n pval = np.sum(perms >= perms[0]) / perms.shape[0]\\n weights = np.ones(perms.shape[0]) / perms.shape[0]\\n ax.hist([perms[perms >= perms[0]], perms], histtype='stepfilled',\\n bins=100, label=\\\"p-val<%.3f\\\" % pval,\\n weights=[weights[perms >= perms[0]], weights])\\n ax.axvline(x=perms[0], color=\\\"k\\\", linewidth=2)#, label=\\\"observed statistic\\\")\\n ax.set_ylabel(name)\\n ax.legend()\\n return ax\",\n \"def hist(self):\\r\\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\\r\\n plt.title(self.column_name)\\r\\n plt.savefig(self.column_name + \\\".svg\\\")\\r\\n plt.close()\",\n \"def efficient_Make_Binned_ROC_histograms(title, data, bins, PU_range='full'):\\n diff_ran = (-25,25)\\n diff_bins = diff_ran[1]-diff_ran[0]\\n ratio_ran = (0,10)\\n ratio_bins = 60\\n\\n Diff_hist_list = []\\n Ratio_hist_list = []\\n CSV_hist_list = []\\n ZeroDiv_list = []\\n for bin_ in range(len(bins)-1):\\n Diff_hist_list.append(rt.TH1D(\\\"L4-L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"L4-L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),diff_bins,diff_ran[0],diff_ran[1]))\\n Ratio_hist_list.append(rt.TH1D(\\\"L4_L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"L4_L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),ratio_bins,ratio_ran[0],ratio_ran[1]))\\n CSV_hist_list.append(rt.TH1D(\\\"CSV_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"CSV_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),ratio_bins,0,1))\\n ZeroDiv_list.append(0)\\n\\n for particle in data:\\n if PU_range != 'full':\\n if particle[-1]<PU_range[0] or particle[-1]>PU_range[1]: continue\\n bin_number = FCM.bin_selection(particle,bins)\\n if bin_number == -100: continue\\n\\n Diff_hist_list[bin_number].Fill(particle[8]-particle[5])\\n CSV_hist_list[bin_number].Fill(particle[1])\\n if particle[17] != 0:\\n L4_L1 = particle[20]/particle[17]\\n Ratio_hist_list[bin_number].Fill(L4_L1)\\n else:\\n ZeroDiv_list[bin_number] += 1\\n\\n tfile = rt.TFile(\\\"Thesis_Plots/root_files/{}_histograms.root\\\".format(title),\\\"recreate\\\")\\n for hist in Diff_hist_list:\\n hist.Write()\\n for hist in Ratio_hist_list:\\n hist.Write()\\n for hist in CSV_hist_list:\\n hist.Write()\\n print \\\"saved histograms in Thesis_Plots/root_files/{}_histograms.root\\\".format(title)\\n\\n csv_file = open(\\\"Thesis_Plots/root_files/{}_ZeroDiv.csv\\\".format(title),\\\"wb\\\")\\n writer = csv.writer(csv_file)\\n writer.writerow(ZeroDiv_list)\\n csv_file.close()\\n print \\\"saved zero division occurences in Thesis_Plots/root_files/{}_ZeroDiv.csv\\\".format(title)\",\n \"def test_under_overflow_values(self):\\n values_with_inf = np.array([-1, 1, 2, 100, np.inf])\\n\\n with self.subTest(\\\"Under/overflow values without under/overflow bins.\\\"):\\n bins, hist, _, _ = hist_w_unc(values_with_inf, bins=5, bins_range=(0, 5))\\n np.testing.assert_almost_equal(bins, np.linspace(0, 5, 6))\\n # in this case only 40% of the values are shown in the plot\\n np.testing.assert_almost_equal(hist, np.array([0, 0.2, 0.2, 0, 0]))\\n\\n with self.subTest(\\\"Under/overflow values with under/overflow bins.\\\"):\\n bins, hist, _, _ = hist_w_unc(\\n values_with_inf, bins=5, bins_range=(0, 5), underoverflow=True\\n )\\n np.testing.assert_almost_equal(bins, np.linspace(0, 5, 6))\\n np.testing.assert_almost_equal(hist, np.array([0.2, 0.2, 0.2, 0, 0.4]))\",\n \"def histogramintegrals(self):\\n return {}\",\n \"def Test_Histogram(Graph_MD):\\n \\n Edges = NX.edges(Graph_MD)\\n KnotenNamen = NX.nodes(Graph_MD)\\n \\n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\\n NumKnotenListe = len(KnotenNamenListe)\\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\\n \\n count = 0\\n for Knoten in KnotenLeitung:\\n KnotenLeitung[count] = 0\\n count = count + 1\\n \\n \\n for ii in list(range(NumKnotenListe)):\\n KnotenName = KnotenNamenListe[ii]\\n for edge in Edges:\\n posS = edge[0] == KnotenName\\n posE = edge[1] == KnotenName\\n \\n if posS :\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n if posE:\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n \\n MaxKnotenLeitung = max(KnotenLeitung)\\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\\n \\n for ii in list(range(0, MaxKnotenLeitung + 1)):\\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\\n\\n\\n return HistSegmKnoten\",\n \"def import_histo(w,hz,xmin,xmax):\\n print 'Loading histogram with',hz.GetEntries(),'entries'\\n data = RooDataHist('data','Zmumu MC',RooArgList(w.var('x')),hz)\\n return data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6780593","0.6637294","0.6636672","0.6386098","0.6373501","0.6371298","0.6316349","0.6257009","0.62314403","0.6217895","0.6184364","0.6180108","0.614731","0.6107375","0.60950774","0.6084479","0.60823816","0.6082355","0.60809517","0.607641","0.60702395","0.6045907","0.6033275","0.60037434","0.6000634","0.60003406","0.5990695","0.5979685","0.5969127","0.59676576","0.5965651","0.5964052","0.59610933","0.59607804","0.5957897","0.5945147","0.5941336","0.59382594","0.5933597","0.592346","0.59208864","0.5906836","0.5900292","0.5899982","0.5895518","0.589484","0.5879096","0.58741575","0.5854405","0.5848894","0.5843428","0.5830987","0.58291465","0.5828936","0.58137137","0.5808891","0.58020616","0.57980376","0.5796551","0.57956827","0.5785307","0.57710844","0.5762451","0.5761063","0.57602894","0.575119","0.5749026","0.57480985","0.57453346","0.57363486","0.57324654","0.57319075","0.57315993","0.57291025","0.57259905","0.5707526","0.57031435","0.5703113","0.57021636","0.5694243","0.5687746","0.56782836","0.56761956","0.56722426","0.56659245","0.5665814","0.5665212","0.5660847","0.56559","0.56547916","0.5650371","0.56484824","0.5643416","0.56395215","0.5630981","0.5630265","0.5626693","0.5626405","0.5623487","0.56191164"],"string":"[\n \"0.6780593\",\n \"0.6637294\",\n \"0.6636672\",\n \"0.6386098\",\n \"0.6373501\",\n \"0.6371298\",\n \"0.6316349\",\n \"0.6257009\",\n \"0.62314403\",\n \"0.6217895\",\n \"0.6184364\",\n \"0.6180108\",\n \"0.614731\",\n \"0.6107375\",\n \"0.60950774\",\n \"0.6084479\",\n \"0.60823816\",\n \"0.6082355\",\n \"0.60809517\",\n \"0.607641\",\n \"0.60702395\",\n \"0.6045907\",\n \"0.6033275\",\n \"0.60037434\",\n \"0.6000634\",\n \"0.60003406\",\n \"0.5990695\",\n \"0.5979685\",\n \"0.5969127\",\n \"0.59676576\",\n \"0.5965651\",\n \"0.5964052\",\n \"0.59610933\",\n \"0.59607804\",\n \"0.5957897\",\n \"0.5945147\",\n \"0.5941336\",\n \"0.59382594\",\n \"0.5933597\",\n \"0.592346\",\n \"0.59208864\",\n \"0.5906836\",\n \"0.5900292\",\n \"0.5899982\",\n \"0.5895518\",\n \"0.589484\",\n \"0.5879096\",\n \"0.58741575\",\n \"0.5854405\",\n \"0.5848894\",\n \"0.5843428\",\n \"0.5830987\",\n \"0.58291465\",\n \"0.5828936\",\n \"0.58137137\",\n \"0.5808891\",\n \"0.58020616\",\n \"0.57980376\",\n \"0.5796551\",\n \"0.57956827\",\n \"0.5785307\",\n \"0.57710844\",\n \"0.5762451\",\n \"0.5761063\",\n \"0.57602894\",\n \"0.575119\",\n \"0.5749026\",\n \"0.57480985\",\n \"0.57453346\",\n \"0.57363486\",\n \"0.57324654\",\n \"0.57319075\",\n \"0.57315993\",\n \"0.57291025\",\n \"0.57259905\",\n \"0.5707526\",\n \"0.57031435\",\n \"0.5703113\",\n \"0.57021636\",\n \"0.5694243\",\n \"0.5687746\",\n \"0.56782836\",\n \"0.56761956\",\n \"0.56722426\",\n \"0.56659245\",\n \"0.5665814\",\n \"0.5665212\",\n \"0.5660847\",\n \"0.56559\",\n \"0.56547916\",\n \"0.5650371\",\n \"0.56484824\",\n \"0.5643416\",\n \"0.56395215\",\n \"0.5630981\",\n \"0.5630265\",\n \"0.5626693\",\n \"0.5626405\",\n \"0.5623487\",\n \"0.56191164\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7000032"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83793,"cells":{"query":{"kind":"string","value":"Collect histogram on real value"},"document":{"kind":"string","value":"def collect_value(self, name_to_arr):\n for tensor, data_arr in name_to_arr.items():\n data_arr = np.asarray(data_arr) # noqa: PLW2901\n data_arr = data_arr.flatten() # noqa: PLW2901\n\n if data_arr.size > 0:\n min_value = np.min(data_arr)\n max_value = np.max(data_arr)\n else:\n min_value = 0\n max_value = 0\n\n threshold = max(abs(min_value), abs(max_value))\n\n if tensor in self.histogram_dict:\n old_histogram = self.histogram_dict[tensor]\n self.histogram_dict[tensor] = self.merge_histogram(\n old_histogram, data_arr, min_value, max_value, threshold\n )\n else:\n hist, hist_edges = np.histogram(data_arr, self.num_bins, range=(-threshold, threshold))\n self.histogram_dict[tensor] = (\n hist,\n hist_edges,\n min_value,\n max_value,\n threshold,\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 just_histogram(*args, **kwargs):\n return np.histogram(*args, **kwargs)[0].astype(float)","def add_histogram(self, tag, values, global_step=None, bins='tensorflow'):\n values = make_np(values)\n self.vis.histogram(make_np(values), opts={'title': tag})","def get_histogram(self):\n\n for bin in range(self.bins.size):\n bin_inf = self.bins[bin]\n try: bin_sup = self.bins[bin + 1]\n except IndexError: bin_sup = self.vmax\n self.hist[bin] = np.sum(\n (self.values >= bin_inf)*(self.values < bin_sup))\n\n binned_values = np.sum(self.hist)\n if binned_values == 0: return self.hist # no binned value\n else: self.hist /= np.sum(self.hist)\n return self.hist","def makeHistogram(values, numBins, xLabel, yLabel, title=None):","def hist_of_numeric(X):\n figsize(10,3)\n for col in get_numeric(X):\n print(col)\n X[col].hist(bins=50)\n show()","def get_histogram(self):\n\n values_array = np.array(self.values)\n for bin0 in range(self.bins[0].size):\n bin_inf0 = self.bins[0][bin0]\n try: bin_sup0 = self.bins[0][bin0 + 1]\n except IndexError: bin_sup0 = self.vmax[0]\n values = values_array[\n (values_array[:, 0] >= bin_inf0)\n *(values_array[:, 0] < bin_sup0)][:, 1]\n for bin1 in range(self.bins[1].size):\n bin_inf1 = self.bins[1][bin1]\n try: bin_sup1 = self.bins[1][bin1 + 1]\n except IndexError: bin_sup1 = self.vmax[1]\n self.hist[bin0*self.Nbins[1] + bin1, 2] = (\n np.sum((values >= bin_inf1)*(values < bin_sup1)))\n\n if np.sum(self.hist[:, 2]) > 0: # there are binned values\n self.hist[:, 2] /= np.sum(self.hist[:, 2])\n return self.hist","def _compute_histogram(self, x, momentum):\n num_bins = self.histogram.size(0)\n x_detached = x.detach()\n self.bin_width = (self._max_val - self._min_val) / (num_bins - 1)\n lo = torch.floor((x_detached - self._min_val) / self.bin_width).long()\n hi = (lo + 1).clamp(min=0, max=num_bins - 1)\n hist = x.new_zeros(num_bins)\n alpha = (\n 1.0\n - (x_detached - self._min_val - lo.float() * self.bin_width)\n / self.bin_width\n )\n hist.index_add_(0, lo, alpha)\n hist.index_add_(0, hi, 1.0 - alpha)\n hist = hist / (hist.sum() + 1e-6)\n self.histogram = (1.0 - momentum) * self.histogram + momentum * hist","def test_get_histogram_stat_by(self):\n pass","def histo ( self ,\n xbins = 20 , xmin = None , xmax = None ,\n ybins = 20 , ymin = None , ymax = None ,\n hpars = () , \n histo = None ,\n integral = False ,\n errors = False , \n density = False ) :\n \n \n histos = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\n ybins = ybins , ymin = ymin , ymax = ymax ,\n hpars = hpars ,\n histo = histo )\n\n # loop over the historgam bins \n for ix,iy,x,y,z in histo.items() :\n\n xv , xe = x.value() , x.error()\n yv , ye = y.value() , y.error()\n \n # value at the bin center \n c = self ( xv , yv , error = errors ) \n\n if not integral : \n histo[ix,iy] = c\n continue\n\n # integral over the bin \n v = self.integral( xv - xe , xv + xe , yv - ye , yv + ye )\n \n if errors :\n if 0 == c.cov2 () : pass\n elif 0 != c.value() and 0 != v : \n v = c * ( v / c.value() )\n \n histo[ix,iy] = v \n\n ## coovert to density historgam, if requested \n if density : histo = histo.density()\n \n return histo","def build_hist(concept_values: np.ndarray, num_bins: int = 100) -> np.ndarray:\n hist, _ = np.histogram(concept_values, bins=num_bins, range=(0., 1.), density=True)\n return hist","def histogram(self):\n return self._hist","def histogram_summary(self, tag, values, step, bins=1000):\n self.writer.add_histogram(tag, values, step, bins='auto')","def distribution_magnitude_histogram(cur, var, table, label):\n x = select(cur,var, table)\n print(\"Number of entries: \", len(x))\n print(\"Maximum: \", max(x))\n print(\"Minimum: \", min(x))\n \n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.set_xlabel(\"Sentiment Magnitude\")\n ax.set_ylabel(\"Number of Sentences\")\n fig.suptitle(label)\n ax.hist(x, bins = 20)\n plt.show()","def _make_histogram(values, bins):\n values = values.reshape(-1)\n counts, limits = np.histogram(values, bins=bins)\n limits = limits[1:]\n\n sum_sq = values.dot(values)\n return HistogramProto(min=values.min(),\n max=values.max(),\n num=len(values),\n sum=values.sum(),\n sum_squares=sum_sq,\n bucket_limit=limits,\n bucket=counts)","def OF1_CalculateRawHistogram(image):\n h = np.zeros(256, np.float_)\n for i in np.nditer(image):\n h[i - 1] = h[i - 1] + 1\n\n return h","def histogramintegrals(self):\n return {}","def test_get_histogram_stat_by_breakout(self):\n pass","def normalized(self):\n total = self.total()\n result = Histogram()\n for value, count in self.items():\n try:\n result[value] = count / float(total)\n except UnorderableElements:\n result = Histogram.from_dict(dict(result), key=hash)\n result[value] = count / float(total)\n return result","def build_histogram(iterator, key):\n buckets = defaultdict(int)\n values = {}\n\n num_objects = 0\n for obj in iterator:\n num_objects += 1\n\n try:\n val = obj[key]\n except (KeyError, TypeError):\n continue\n\n value_hash = hashlib.sha1()\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\n value_hash = value_hash.hexdigest()\n\n buckets[value_hash] += 1\n values[value_hash] = val\n\n return [\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\n ]","def create_fixed_hist(self):\n hist = cv2.calcHist([self.obj], [0, 1, 2], None, [32, 8, 8],\n [0, 256, 0, 256, 0, 256])\n self.hist = cv2.normalize(hist).flatten()\n print self.hist","def makeHist(data, bins, wgt=None, factor=1.0, pdf=False):\n n_arr, bins = np.histogram(data, bins, weights=wgt)\n ctr_bins = centerOfBins(bins)\n \n if pdf == True:\n n_arr = asFloat(n_arr) / (float(sum(n_arr)) * (bins[1:] - bins[:-1]))\n else:\n n_arr = asFloat(n_arr) * factor\n \n return n_arr, ctr_bins","def histogram(self, mask=None, extrema=None):\r\n uni, counts = self._getcolors()\r\n return [l for l in counts]","def _histogram_with_spread(self):\n complexity_hist = np.bincount(\n self.epoch.array_annotations['complexity'])\n num_bins = (self.t_stop - self.t_start).rescale(\n self.bin_size.units).item() / self.bin_size.item()\n num_bins = round_binning_errors(num_bins, tolerance=self.tolerance)\n time_hist = np.zeros(num_bins, dtype=int)\n\n start_bins = (self.epoch.times - self.t_start).rescale(\n self.bin_size.units).magnitude / self.bin_size.item()\n stop_bins = (self.epoch.times + self.epoch.durations - self.t_start\n ).rescale(self.bin_size.units\n ).magnitude / self.bin_size.item()\n\n if self.sampling_rate is not None:\n shift = (.5 / self.sampling_rate / self.bin_size).simplified.item()\n # account for the first bin not being shifted in the epoch creation\n # if the shift would move it past t_start\n if self.epoch.times[0] == self.t_start:\n start_bins[1:] += shift\n else:\n start_bins += shift\n stop_bins += shift\n\n start_bins = round_binning_errors(start_bins, tolerance=self.tolerance)\n stop_bins = round_binning_errors(stop_bins, tolerance=self.tolerance)\n\n for idx, (start, stop) in enumerate(zip(start_bins, stop_bins)):\n time_hist[start:stop] = \\\n self.epoch.array_annotations['complexity'][idx]\n\n time_hist = neo.AnalogSignal(\n signal=np.expand_dims(time_hist, axis=1),\n sampling_period=self.bin_size, units=pq.dimensionless,\n t_start=self.t_start)\n\n empty_bins = (self.t_stop - self.t_start - self.epoch.durations.sum())\n empty_bins = empty_bins.rescale(self.bin_size.units\n ).magnitude / self.bin_size.item()\n empty_bins = round_binning_errors(empty_bins, tolerance=self.tolerance)\n complexity_hist[0] = empty_bins\n\n return time_hist, complexity_hist","def np_histogram(data, title, bins=\"auto\"):\n figure = plt.figure()\n canvas = figure.canvas\n plt.hist(data, bins=bins)\n plt.title(title)\n\n canvas.draw()\n w, h = canvas.get_width_height()\n np_hist = np.fromstring(canvas.get_renderer().tostring_rgb(), dtype=np.uint8).reshape(h, w, 3)\n plt.close(figure)\n util.np_info(np_hist)\n return np_hist","def hist(a,bins):\n n=searchsorted(sort(a),bins)\n n=concatenate([n,[len(a)]])\n n=array(list(map(float,n)))\n# n=array(n)\n return n[1:]-n[:-1]","def __value(t,N):\n _,hist=np.unique(t, return_counts=True)\n hist=list(hist)\n hist.append(N-np.sum(hist))\n return EntropyD(np.array(hist))","def create_hist(pVals,bins=1000,log=False,max_val=False):\n\t# gets an array of pValues and returns an array of bins with counts\n\thist_count = np.zeros(bins)\n\tif (log):\n\t\tnlp = -1.0*np.log10(pVals)\n\t\tif (max_val):\n\t\t\tnlp_max=max_val\n\t\telse:\n\t\t\tnlp_max = nlp.max()\n\t\tpVals = pVals/nlp_max\n\tfor i in pVals:\n\t\tj=int(bins*i)\n\t\tif j == bins:\n\t\t\tj -= 1\n\t\thist_count[j] += 1\n\treturn hist_count","def test_get_result_histogram_stat(self):\n pass","def hog_histograms(*args, **kwargs): # real signature unknown\n pass","def test_get_result_histogram(self):\n pass","def hist(self, bins):\n x = self.x\n plt.hist(x, bins)\n plt.xlabel('Observed Data')\n plt.ylabel('Frequency')\n plt.show()","def glGetHistogram( baseFunction, target, reset, format, type, values=None):\r\n if values is None:\r\n width = glGetHistogramParameteriv(\r\n target,\r\n GL_HISTOGRAM_WIDTH,\r\n )\r\n values = images.images.SetupPixelRead( format, (width,4), type )\r\n arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[\r\n images.images.TYPE_TO_ARRAYTYPE.get(type,type)\r\n ]\r\n baseFunction(\r\n target, reset, format, type,\r\n ctypes.c_void_p( arrayType.dataPointer(values))\r\n )\r\n return values","def get_hist(self):\n return self.hist","def get_histogram(self, column):\n\n df_histogram = pd.DataFrame(self.serie)\n #histogramcol = alt.Chart(df_histogram).mark_bar().encode(alt.X(column, bin=True), y='count()')\n histogramcol = alt.Chart(df_histogram).mark_bar().encode(alt.X(column, bin=alt.Bin(maxbins=50)),y='count()')\n return histogramcol","def sum_hist(self, label=None):\n values = [h.values for h in self.hists]\n errors = [h.yerr for h in self.hists]\n hist = deepcopy(self.hists[0])\n hist.values = sum(values)\n hist.yerr = np.sqrt(sum([error*error for error in errors]))\n hist.label = label\n hist.color = style.def_grey\n return hist","def histogram_summary(tag, values, bins):\n tag = _clean_tag(tag)\n values = _make_numpy_array(values)\n hist = _make_histogram(values.astype(float), bins)\n return Summary(value=[Summary.Value(tag=tag, histo=hist)])","def make_line_hist(x,minValue,maxValue,nbins=10,logscale=False):\n if logscale:\n freqs,bins = np.histogram(x,bins=np.logspace(np.log10(minValue),np.log10(maxValue),nbins),normed=True) \n else:\n freqs,bins = np.histogram(x,bins=np.linspace(minValue,maxValue,nbins),normed=True)\n \n \n plt.plot((bins[:-1]+bins[1:])/2,freqs)\n return freqs","def histogram(self, field: str, min_value: float, max_value: float, num_of_buckets: int = 5):\n return self.values(histogram=Histogram(field, min_value, max_value, num_of_buckets))","def create_general_hist(self, obj):\n hist = cv2.calcHist([obj], [0, 1, 2], None, [32, 8, 8],\n [0, 256, 0, 256, 0, 256])\n print cv2.normalize(hist).flatten()\n return cv2.normalize(hist).flatten()","def get_vals_hist(t_vals, num_bin):\n t_vals_hist = np.histogram(t_vals, num_bin)\n return [ t_vals_hist[0].tolist(),\n t_vals_hist[1].tolist(),\n ]","def calcHistogram(Tech_res):\n A_Hist = np.histogram(Tech_res.A_mean, Tech_res.hist_bins)\n top, bin_list, x_steps = list(A_Hist[0]), list(A_Hist[1]), []\n for n in range(np.shape(bin_list)[0]-1):\n x_steps.append((bin_list[n+1] + bin_list[n]) / 2)\n Tech_res.update_tech_meas(Hist_tops=top, Hist_steps=x_steps)\n return","def histogram(self):\n if np.size(self.stats['Counts']): # don't do anything to an empty list\n if np.size(self.bins) and not self.redo:\n return self.bins, self.occs, self.thresh\n elif np.size(self.bin_array) > 0: \n self.occs, self.bins = np.histogram(self.stats['Counts'], self.bin_array) # fixed bins. \n else:\n try:\n lo, hi = min(self.stats['Counts'])*0.97, max(self.stats['Counts'])*1.02\n # scale number of bins with number of files in histogram and with separation of peaks\n num_bins = int(15 + self.ind//100 + (abs(hi - abs(lo))/hi)**2*15) \n self.occs, self.bins = np.histogram(self.stats['Counts'], bins=np.linspace(lo, hi, num_bins+1)) # no bins provided by user\n except: \n self.occs, self.bins = np.histogram(self.stats['Counts'])\n else: self.occs, self.bins = np.zeros(10), np.arange(0,1.1,0.1)\n return self.bins, self.occs, self.thresh","def compute_histogram(self):\n # compute distance between points \n distmatrix = np.sqrt(pdist(self.points))\n if not self.mean_dist:\n self.mean_dist = np.mean(distmatrix)\n distmatrix = distmatrix/self.mean_dist\n distmatrix = squareform(distmatrix)\n #compute angles between points\n angles = compute_angles(self.points)\n #quantize angles to a bin\n tbins = np.floor(angles / (2 * pi / self.nbins_theta))\n lg = np.logspace(self.r1, self.r2, num=5)\n #quantize radious to bins\n rbins = np.ones(angles.shape) * -1\n for r in lg:\n counts = (distmatrix < r) \n rbins = rbins + counts.astype(int) \n return rbins, tbins","def import_histo(w,hz,xmin,xmax):\n print 'Loading histogram with',hz.GetEntries(),'entries'\n data = RooDataHist('data','Zmumu MC',RooArgList(w.var('x')),hz)\n return data","def roo_histo ( self ,\n xbins = 20 , xmin = None , xmax = None ,\n ybins = 20 , ymin = None , ymax = None ,\n hpars = () , \n histo = None , \n events = True ) :\n \n histo = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\n ybins = ybins , ymin = ymin , ymax = ymax ,\n hpars = hpars ,\n histo = histo )\n \n hh = self.pdf.createHistogram (\n hID() ,\n self.xvar , self.binning ( histo.GetXaxis() , 'histo2x' ) ,\n ROOT.RooFit.YVar ( self.yvar , self.binning ( histo.GetYaxis() , 'histo2y' ) ) , \n ROOT.RooFit.Scaling ( False ) , \n ROOT.RooFit.Extended ( False ) ) \n\n for i in hh : hh.SetBinError ( i , 0 ) \n \n if events and self.pdf.mustBeExtended() :\n \n for ix , iy , x , y , z in hh.items() :\n volume = 4 * x.error() * y.error() \n hh [ ix , iy ] *= volume\n \n hh *= self.pdf.expectedEvents ( self.vars ) / hh.sum() \n \n histo += hh\n \n return histo","def collect_absolute_value(self, name_to_arr):\n for tensor, data_arr in name_to_arr.items():\n data_arr = np.asarray(data_arr) # noqa: PLW2901\n data_arr = data_arr.flatten() # noqa: PLW2901\n if data_arr.size > 0:\n min_value = np.min(data_arr)\n max_value = np.max(data_arr)\n else:\n min_value = 0\n max_value = 0\n\n data_arr = np.absolute(data_arr) # only consider absolute value # noqa: PLW2901\n\n if tensor not in self.histogram_dict:\n # first time it uses num_bins to compute histogram.\n hist, hist_edges = np.histogram(data_arr, bins=self.num_bins)\n self.histogram_dict[tensor] = (hist, hist_edges, min_value, max_value)\n else:\n old_histogram = self.histogram_dict[tensor]\n old_min = old_histogram[2]\n old_max = old_histogram[3]\n old_hist = old_histogram[0]\n old_hist_edges = old_histogram[1]\n temp_amax = np.max(data_arr)\n if temp_amax > old_hist_edges[-1]:\n # increase the number of bins\n width = old_hist_edges[1] - old_hist_edges[0]\n # NOTE: np.arange may create an extra bin after the one containing temp_amax\n new_bin_edges = np.arange(old_hist_edges[-1] + width, temp_amax + width, width)\n old_hist_edges = np.hstack((old_hist_edges, new_bin_edges))\n hist, hist_edges = np.histogram(data_arr, bins=old_hist_edges)\n hist[: len(old_hist)] += old_hist\n self.histogram_dict[tensor] = (hist, hist_edges, min(old_min, min_value), max(old_max, max_value))","def test_bins(self):\n min_val = 0\n max_val = 1\n buckets = 10\n values_per_bucket = 10\n\n import numpy\n\n data = list(numpy.linspace(min_val, max_val, buckets * values_per_bucket))\n bins = numpy.linspace(min_val, max_val + sys.float_info.epsilon, buckets + 1)\n digitized = numpy.digitize(data, bins)\n counts = numpy.bincount(digitized)\n self.assertEqual(buckets + 1, len(counts))\n self.assertEqual(0, counts[0])\n for bucket in counts[1:]:\n self.assertEqual(values_per_bucket, bucket)","def hist(self):\r\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\r\n plt.title(self.column_name)\r\n plt.savefig(self.column_name + \".svg\")\r\n plt.close()","def getHistogramData(self):\n return (self.numBins, self.binWidth, self.minFreq, self.maxFreq)","def distribution_sentimentscore_histogram(cur, var, table, label):\n x = select(cur,var, table)\n print(\"Number of entries: \", len(x))\n print(\"Maximum: \", max(x))\n print(\"Minimum: \", min(x))\n \n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.set_xlabel(\"Sentiment Score\")\n ax.set_ylabel(\"Number of Loans\")\n fig.suptitle(label)\n ax.hist(x, bins = 15)\n plt.show()","def compute_histogram(self, image):\n\n hist = [0] * 256\n x, y = image.shape[:2]\n #print(image.shape)\n for i in range(x):\n for j in range(y):\n hist[image[i, j]] += 1\n\n return hist","def histo_summary(self, tag, values, step, bins=1000):\n\n # Create a histogram using numpy\n counts, bin_edges = np.histogram(values, bins=bins)\n\n # Fill the fields of the histogram proto\n hist = tf.HistogramProto()\n hist.min = float(np.min(values))\n hist.max = float(np.max(values))\n hist.num = int(np.prod(values.shape))\n hist.sum = float(np.sum(values))\n hist.sum_squares = float(np.sum(values**2))\n\n # Drop the start of the first bin\n bin_edges = bin_edges[1:]\n\n # Add bin edges and counts\n for edge in bin_edges:\n hist.bucket_limit.append(edge)\n for c in counts:\n hist.bucket.append(c)\n\n # Create and write Summary\n with self.writer.as_default():\n tf.summary.histogram(name=tag, data=hist, step=step)\n self.writer.flush()","def test_histogram_standard(self):\n histogram_file = self.get_file(\"histogram.csv\")\n\n schema = [(\"value\", int)]\n\n # Big data frame from data with 33% correct predicted ratings\n self.frame_histogram = self.context.frame.import_csv(histogram_file,\n schema=schema)\n result = self.frame_histogram.histogram(\"value\", num_bins=10)\n\n # verified known results based on data crafted\n cutoffs = [1.0, 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1, 10.0]\n histogram = [10.0, 10.0, 10.0, 10.0, 10.0,\n 10.0, 10.0, 10.0, 10.0, 10.0]\n density = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]\n\n self.assertAlmostEqual(cutoffs, result.cutoffs)\n self.assertAlmostEqual(histogram, result.hist)\n self.assertAlmostEqual(density, result.density)","def makeHistogram(values, numBins, xLabel, yLabel, title=None):\r\n pylab.hist(values, bins = numBins)\r\n pylab.xlabel(xLabel)\r\n pylab.ylabel(yLabel)\r\n if title != None:\r\n pylab.title(title)\r\n pylab.show()","def anticum_hist(data, bins=None, toadd=0, zero=False, zerox=False):\n\n from numpy import histogram, unique, append, cumsum, zeros, array\n data = array(data)\n\n if bins is None:\n temp, bins = histogram(data, unique(data))\n hist = append(cumsum(temp[::-1])[::-1], 1)\n else:\n if len(data) == 0:\n return zeros(len(bins)), bins\n # if max(data) > max(bins):\n # print \"Must have the largest bin be bigger than the largest data point.\"\n # print max(bins)\n # print max(data)\n # import sys\n # sys.exit(1337)\n temp, bins = histogram(data, bins=bins)\n numbig = data[data > bins.max()].shape[0]\n # add on the objects that are above the last bin to the last count, so that they're included in the cumulative sum\n temp[-1] += numbig\n hist = append(cumsum(temp[::-1])[::-1], numbig)\n\n hist = hist + toadd # add some number to all the values\n\n if zero:\n hist = append(hist, 1e-10)\n bins = append(bins, bins[-1])\n if zerox:\n hist = append(hist[0], hist)\n bins = append(1e-10, bins)\n\n return hist, bins","def gc_percent_hist(data):\n result = [0] * 101 # 0-100\n for s in data:\n percent = _gc_percent(s)\n result[percent] += 1\n return result","def _printHist(self):\n bins = [0] * self.displayBins\n binSize = self.maxValue / self.displayBins\n displaySamps = self.samples[:]\n displaySamps.sort()\n currLimit = binSize\n binIndex = 0\n partIndex = 0\n while partIndex < self.numParticles:\n part = displaySamps[partIndex]\n if binIndex >= self.displayBins:\n # if value beyond max value, add to last bin and go on to next particle\n bins[19] += 1\n partIndex += 1\n elif part < currLimit:\n # count particle in current bin, go on to next particle\n bins[binIndex] += 1\n partIndex += 1\n else:\n # go on to next bin, don't go on to next particle\n binIndex += 1\n currLimit += binSize\n self.printMapPattern(binSize)\n histStr = \"{0:3d} \"\n printStr = \"\"\n for b in bins:\n printStr += histStr.format(b)\n print(printStr)","def makeHistogram(values, numBins, xLabel, yLabel, title=None):\n pylab.hist(values, bins = numBins)\n pylab.xlabel(xLabel)\n pylab.ylabel(yLabel)\n if not title == None:\n pylab.title(title)\n pylab.show()","def fast_histogram(\n val: List[float],\n discrete: Optional[bool] = None,\n bins: Optional[List[float]] = None,\n) -> Mapping[str, float]:\n val = np.asarray(val, dtype=float)\n size = len(val)\n\n # Unique does not work on nan since nan != nan\n val = val[~np.isnan(val)]\n size_nan = size - len(val)\n discrete = is_discrete(val) if discrete is None else discrete\n\n if discrete:\n bins, counts = np.unique(val, return_counts=True)\n bin_to_count = {str(bins[i]): counts[i] for i in range(len(bins))}\n if size_nan > 0:\n bin_to_count[\"nan\"] = size_nan\n return bin_to_count\n\n # Counts nan as part of infinity bin\n val = val[~np.isinf(val)]\n size_inf = size - len(val)\n if len(val) == 0:\n return {\"+Inf\": size_inf}\n\n # Take the negative of all values to use \"le\" as the bin upper bound\n bins = bins or get_bins(val)\n counts, _ = np.histogram(-val, bins=-np.flip([bins[0]] + bins))\n counts = np.flip(counts)\n bin_to_count = dict(p for p in zip(map(str, bins), counts))\n\n # Add infinity bin last to preserve insertion order\n bin_to_count[\"+Inf\"] = size_inf\n return bin_to_count","def update_histo_frame():\n min_histo.text = str(MIN_RANGE_F) # Display the legend\n max_histo.text = str(MAX_RANGE_F)\n\n histogram = np.zeros(GRID_AXIS) # Clear histogram accumulation array\n # Collect camera data and calculate the histogram\n for _row in range(0, GRID_AXIS):\n for _col in range(0, GRID_AXIS):\n histo_index = int(map_range(GRID_DATA[_col, _row], 0, 1, 0, GRID_AXIS - 1))\n histogram[histo_index] = histogram[histo_index] + 1\n\n histo_scale = np.max(histogram) / (GRID_AXIS - 1)\n if histo_scale <= 0:\n histo_scale = 1\n\n # Display the histogram\n for _col in range(0, GRID_AXIS):\n for _row in range(0, GRID_AXIS):\n if histogram[_col] / histo_scale > GRID_AXIS - 1 - _row:\n image_group[((_row * GRID_AXIS) + _col)].fill = index_to_rgb(\n round((_col / GRID_AXIS), 3)\n )\n else:\n image_group[((_row * GRID_AXIS) + _col)].fill = BLACK","def hist(data):\n\n fig = plt.figure()\n ax1 = fig.add_subplot(111)\n plt.hold(True)\n for x in xrange(len(data[:,0,0])):\n counts, edges = np.histogram(data[x,:,:],bins=100)\n centers = [(edges[i]+edges[i+1])/2.0 for i,v in enumerate(edges[:-1])]\n ax1.plot(centers,counts)\n plt.hold(False)\n\n plt.show(block=False)\n\n # return fig","def rythm_hist(duration_ohe):\n assert duration_ohe.ndim == 2\n return duration_ohe.sum(axis=0) / duration_ohe.sum()","def _make_hist(self, oned_arr):\n hist_ = np.histogram(\n a=oned_arr,\n bins=self.null_distributions_[\"histogram_bins\"],\n range=(\n np.min(self.null_distributions_[\"histogram_bins\"]),\n np.max(self.null_distributions_[\"histogram_bins\"]),\n ),\n density=False,\n )[0]\n return hist_","def getHistogram( self, img):\n bins = 256\n range_scale = [0,254]\n nivel_transparencia = 0.5\n plt.hist(img.ravel(),bins,range_scale, label=\"histogram\", alpha=nivel_transparencia);\n plt.legend(loc='upper right')\n plt.show()","def make_histogram(points, bucket_size):\r\n return Counter(bucketize(point, bucket_size) for point in points)","def get_histo(values, bins=1000):\n if isinstance(values, list):\n values = np.array(values)\n\n # Create histogram using numpy\n counts, bin_edges = np.histogram(values, bins=bins)\n\n # Fill fields of histogram proto\n hist = tf.HistogramProto()\n hist.min = float(np.min(values))\n hist.max = float(np.max(values))\n hist.num = int(np.prod(values.shape))\n hist.sum = float(np.sum(values))\n hist.sum_squares = float(np.sum(values**2))\n\n # Requires equal number as bins, where the first goes from -DBL_MAX to bin_edges[1]\n # See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/summary.proto#L30\n # Thus, we drop the start of the first bin\n bin_edges = bin_edges[1:]\n\n # Add bin edges and counts\n for edge in bin_edges:\n hist.bucket_limit.append(edge)\n for c in counts:\n hist.bucket.append(c)\n\n return hist","def equalize_hist(input):\n return np.float32(skimage.exposure.equalize_hist(input.numpy()))","def hist_bins(bins, vals):\r\n\r\n hist = zeros(len(bins))\r\n j = 0\r\n for i in vals:\r\n while bins[j] < i:\r\n j += 1\r\n hist[j] += 1\r\n\r\n return asarray(bins), hist","def makeHistogram(values, numBins, xLabel, yLabel, title=None):\r\n # TODO\r\n pylab.hist(values, bins = numBins)\r\n pylab.xlabel(xLabel)\r\n pylab.ylabel(yLabel)\r\n if title != None:\r\n pylab.title(title)\r\n pylab.show()","def setup_hist(self):\n self.x_min = {}\n self.x_max = {}\n self.x_max_minus_min = {}\n self.dx = {}\n self.n_bins = {}\n\n self.histogram_edges = {}\n self.histogram_values = {}\n self.histogram_cdf = {}","def histogram_function(r_min, a, N, nbins):\n r_min_no_selfdistance = r_min - np.identity(len(r_min)) #remove identitity matrix so own distance will be treated as 0\n histarray = np.array(r_min_no_selfdistance).flatten()\n histogram = np.histogram(histarray,bins=np.linspace(0,a,nbins))\n histogram[0][0] = histogram[0][0] - N # remove N from the first bin to prevent it counting particle distance to itself\n return histogram[0]","def histo_summary(self, tag, values, step, bins=1000):\n\n # Create a histogram using numpy\n counts, bin_edges = np.histogram(values, bins=bins)\n\n # Fill the fields of the histogram proto\n hist = tf.HistogramProto()\n hist.min = float(np.min(values))\n hist.max = float(np.max(values))\n hist.num = int(np.prod(values.shape))\n hist.sum = float(np.sum(values))\n hist.sum_squares = float(np.sum(values**2))\n\n # Drop the start of the first bin\n bin_edges = bin_edges[1:]\n\n # Add bin edges and counts\n for edge in bin_edges:\n hist.bucket_limit.append(edge)\n for c in counts:\n hist.bucket.append(c)\n\n # Create and write Summary\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\n self.writer.add_summary(summary, step)\n self.writer.flush()","def histo_summary(self, tag, values, step, bins=1000):\n\n # Convert to a numpy array\n values = np.array(values)\n\n # Create a histogram using numpy\n counts, bin_edges = np.histogram(values, bins=bins)\n\n # Fill the fields of the histogram proto\n hist = tf.HistogramProto()\n hist.min = float(np.min(values))\n hist.max = float(np.max(values))\n hist.num = int(np.prod(values.shape))\n hist.sum = float(np.sum(values))\n hist.sum_squares = float(np.sum(values**2))\n\n # Drop the start of the first bin\n bin_edges = bin_edges[1:]\n\n # Add bin edges and counts\n for edge in bin_edges:\n hist.bucket_limit.append(edge)\n for c in counts:\n hist.bucket.append(c)\n\n # Create and write Summary\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\n self.writer.add_summary(summary, step)\n self.writer.flush()","def histogram(data,binwidth, xmin,xmax):\n bins = arange(xmin,xmax, binwidth)\n binsc = bins + (0.5 * binwidth)\n try: #FIXME: use updated numpy.histogram\n histo = numpyhisto(data, bins, new=False)[0]\n except:\n histo = numpyhisto(data, bins)[0]\n return binsc[:len(histo)], histo","def efficient_Make_Binned_ROC_histograms(title, data, bins, PU_range='full'):\n diff_ran = (-25,25)\n diff_bins = diff_ran[1]-diff_ran[0]\n ratio_ran = (0,10)\n ratio_bins = 60\n\n Diff_hist_list = []\n Ratio_hist_list = []\n CSV_hist_list = []\n ZeroDiv_list = []\n for bin_ in range(len(bins)-1):\n Diff_hist_list.append(rt.TH1D(\"L4-L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"L4-L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),diff_bins,diff_ran[0],diff_ran[1]))\n Ratio_hist_list.append(rt.TH1D(\"L4_L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"L4_L1_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),ratio_bins,ratio_ran[0],ratio_ran[1]))\n CSV_hist_list.append(rt.TH1D(\"CSV_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),\"CSV_\"+str(bins[bin_])+\"_\"+str(bins[bin_+1]),ratio_bins,0,1))\n ZeroDiv_list.append(0)\n\n for particle in data:\n if PU_range != 'full':\n if particle[-1]<PU_range[0] or particle[-1]>PU_range[1]: continue\n bin_number = FCM.bin_selection(particle,bins)\n if bin_number == -100: continue\n\n Diff_hist_list[bin_number].Fill(particle[8]-particle[5])\n CSV_hist_list[bin_number].Fill(particle[1])\n if particle[17] != 0:\n L4_L1 = particle[20]/particle[17]\n Ratio_hist_list[bin_number].Fill(L4_L1)\n else:\n ZeroDiv_list[bin_number] += 1\n\n tfile = rt.TFile(\"Thesis_Plots/root_files/{}_histograms.root\".format(title),\"recreate\")\n for hist in Diff_hist_list:\n hist.Write()\n for hist in Ratio_hist_list:\n hist.Write()\n for hist in CSV_hist_list:\n hist.Write()\n print \"saved histograms in Thesis_Plots/root_files/{}_histograms.root\".format(title)\n\n csv_file = open(\"Thesis_Plots/root_files/{}_ZeroDiv.csv\".format(title),\"wb\")\n writer = csv.writer(csv_file)\n writer.writerow(ZeroDiv_list)\n csv_file.close()\n print \"saved zero division occurences in Thesis_Plots/root_files/{}_ZeroDiv.csv\".format(title)","def getHistogram(self, var, idx = None, translation = None, other = None,\\\n verbose = 1, ab = [], bins = 100, minmax = None):\n \n if idx is None: idx = np.arange(self.atoms.shape[0])\n if translation is None: translation = [0]\n if isinstance(translation, (int, np.integer)): translation = [translation]\n\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\n verbose = verbose, ab = ab, other = other)\n x = []\n y = []\n for i, item in enumerate(data):\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\n x.append((bin[:-1] + bin[1:]) / 2)\n y.append(cnt)\n\n return x, y, lbl, leg","def _fast_hist(data, bin_edges):\n # Yes, I've tested this against histogram().\n return np.bincount(np.digitize(data, bin_edges[1:-1]), minlength=len(bin_edges) - 1)","def calc_histogram(self, img_data):\n\n histogram = [0] * self.color_depth\n\n for w in range(img_data.shape[0]):\n for h in range(img_data.shape[1]):\n pixel = img_data[w][h]\n histogram[pixel] += 1\n\n return histogram","def _find_histogram(cls, clt):\n num_labels = np.arange(0, len(np.unique(clt.labels_)) + 1)\n (hist, _) = np.histogram(clt.labels_, bins=num_labels)\n\n hist = hist.astype(\"float\")\n hist /= hist.sum()\n\n return hist","def hist(img):\n bottom_half = img[img.shape[0]//2:,:] # 0:img.shape[0]//2 is the top half\n histogram = bottom_half.sum(axis=0) \n \n return histogram","def histogram(self, number_concentration=True):\n\n\t\tresp = []\n\t\tself.spi.transfer([0x30], [0x00], 1)\n\t\ttime.sleep(10e-3)\n\t\tfor i in range(62):\n\t\t\trb = [0x00]\n\t\t\tself.spi.transfer([0x00], rb, 1)\n\t\t\tif rb[0] < 0:\n\t\t\t\trb[0] += 256\n\t\t\tresp.append(rb[0])\n\t\t\n\t\tself._hist_dict['bin0'] = _16bit_unsigned(resp[0], resp[1])\n\t\tself._hist_dict['bin1'] = _16bit_unsigned(resp[2], resp[3])\n\t\tself._hist_dict['bin2'] = _16bit_unsigned(resp[4], resp[5])\n\t\tself._hist_dict['bin3'] = _16bit_unsigned(resp[6], resp[7])\n\t\tself._hist_dict['bin4'] = _16bit_unsigned(resp[8], resp[9])\n\t\tself._hist_dict['bin5'] = _16bit_unsigned(resp[10], resp[11])\n\t\tself._hist_dict['bin6'] = _16bit_unsigned(resp[12], resp[13])\n\t\tself._hist_dict['bin7'] = _16bit_unsigned(resp[14], resp[15])\n\t\tself._hist_dict['bin8'] = _16bit_unsigned(resp[16], resp[17])\n\t\tself._hist_dict['bin9'] = _16bit_unsigned(resp[18], resp[19])\n\t\tself._hist_dict['bin10'] = _16bit_unsigned(resp[20], resp[21])\n\t\tself._hist_dict['bin11'] = _16bit_unsigned(resp[22], resp[23])\n\t\tself._hist_dict['bin12'] = _16bit_unsigned(resp[24], resp[25])\n\t\tself._hist_dict['bin13'] = _16bit_unsigned(resp[26], resp[27])\n\t\tself._hist_dict['bin14'] = _16bit_unsigned(resp[28], resp[29])\n\t\tself._hist_dict['bin15'] = _16bit_unsigned(resp[30], resp[31])\n\n\t\tself._hist_dict['bin1_MToF'] = _calculate_mtof(resp[32])\n\t\tself._hist_dict['bin3_MToF'] = _calculate_mtof(resp[33])\n\t\tself._hist_dict['bin5_MToF'] = _calculate_mtof(resp[34])\n\t\tself._hist_dict['bin7_MToF'] = _calculate_mtof(resp[35])\n\n\t\tself._hist_dict['sfr'] = _calculate_float(resp[36:40])\t\t## Sample flow rate\n\n\t\t## Alright, we don't know whether it is temp or pressure since it switches...\n\t\ttmp = _calculate_pressure(resp[40:44])\n\t\tif tmp > 98000:\n\t\t\tself._hist_dict['temperature'] = None\n\t\t\tself._hist_dict['pressure'] = tmp\n\t\telse:\n\t\t\ttmp = _calculate_temp(resp[40:44])\n\t\t\tif tmp < 500:\n\t\t\t\tself._hist_dict['temperature'] = tmp\n\t\t\t\tself._hist_dict['pressure'] = None\n\t\t\telse:\n\t\t\t\tself._hist_dict['temperature'] = None\n\t\t\t\tself._hist_dict['pressure'] = None\n\n\t\tself._hist_dict['period'] = _calculate_float(resp[44:48])\t\t## Sampling period\n\n\t\tself._hist_dict['checksum'] = _16bit_unsigned(resp[48], resp[49])\n\n\t\tself._hist_dict['PM1'] = _calculate_float(resp[50:54])\n\t\tself._hist_dict['PM2.5'] = _calculate_float(resp[54:58])\n\t\tself._hist_dict['PM10'] = _calculate_float(resp[58:])\n\n\t\t## Calculate the sum of the histogram bins\n\t\thistogram_sum = self._hist_dict['bin0'] + self._hist_dict['bin1'] + self._hist_dict['bin2'] + \\\n\t\t\t\tself._hist_dict['bin3'] + self._hist_dict['bin4'] + self._hist_dict['bin5'] + self._hist_dict['bin6'] + \\\n\t\t\t\tself._hist_dict['bin7'] + self._hist_dict['bin8'] + self._hist_dict['bin9'] + self._hist_dict['bin10'] + \\\n\t\t\t\tself._hist_dict['bin11'] + self._hist_dict['bin12'] + self._hist_dict['bin13'] + self._hist_dict['bin14'] + \\\n\t\t\t\tself._hist_dict['bin15']\n\n\t\t## Check that checksum and the least significant bits of the sum of histogram bins are equivilant\n\t\tif (histogram_sum & 0x0000FFFF) != self._hist_dict['checksum']:\n\t\t\tprint(f\"[{self.__class__.__name__}::histogram] CHECKSUM ERROR: Data transfer was incomplete\")\n\t\t\treturn None\n\n\t\t## If number_concentration flag is set, convert histogram values to number concentration\n\t\tif number_concentration is True:\n\t\t\t_conv_ = self._hist_dict['sfr'] * self._hist_dict['period'] \t## Divider in units of ml (cc)\n\n\t\t\tself._hist_dict['bin0'] /= _conv_\n\t\t\tself._hist_dict['bin1'] /= _conv_\n\t\t\tself._hist_dict['bin2'] /= _conv_\n\t\t\tself._hist_dict['bin3'] /= _conv_\n\t\t\tself._hist_dict['bin4'] /= _conv_\n\t\t\tself._hist_dict['bin5'] /= _conv_\n\t\t\tself._hist_dict['bin6'] /= _conv_\n\t\t\tself._hist_dict['bin7'] /= _conv_\n\t\t\tself._hist_dict['bin8'] /= _conv_\n\t\t\tself._hist_dict['bin9'] /= _conv_\n\t\t\tself._hist_dict['bin10'] /= _conv_\n\t\t\tself._hist_dict['bin11'] /= _conv_\n\t\t\tself._hist_dict['bin12'] /= _conv_\n\t\t\tself._hist_dict['bin13'] /= _conv_\n\t\t\tself._hist_dict['bin14'] /= _conv_\n\t\t\tself._hist_dict['bin15'] /= _conv_\n\n\t\ttime.sleep(0.1)\n\t\treturn self._hist_dict","def extract_histogram(self, bins=10):\n assert len(self.images) > 0, 'No images loaded! Did you call ' \\\n 'load_images() ?'\n histograms = []\n for image in self.images:\n grey = skicol.rgb2gray(image)\n hist_values, bins = np.histogram(grey, range=(0, 1), bins=bins)\n histograms.append(hist_values)\n histograms = np.array(histograms)\n histograms = histograms.astype('float')\n return histograms","def make_histogram(points, bucket_size):\n return Counter(bucketize(point, bucket_size) for point in points)","def make_histogram(points, bucket_size):\n return Counter(bucketize(point, bucket_size) for point in points)","def calculate_histogram(self, abstract_features_1, abstract_features_2):\n scores = torch.mm(abstract_features_1, abstract_features_2).detach()\n scores = scores.view(-1, 1)\n hist = torch.histc(scores, bins=self.args.bins)\n hist = hist/torch.sum(hist)\n hist = hist.view(1, -1)\n return hist","def produceHist(self, start=None, end=None, period=24 * 3600):\n self.sort()\n if len(self) == 0:\n return\n if start is None:\n start = UTC(self[0].datetime.date)\n if end is None:\n end = UTC(self[-1].datetime)\n entries = int((end - start) / period) + 1\n hist_list = np.zeros(entries)\n mag_list = np.zeros(entries)\n for event in self:\n #date = UTC(event.datetime.date)\n entry = int((event.datetime - start) / period)\n print entry\n try:\n hist_list[entry] += 1\n mag_list[entry] = max(event.magnitude, mag_list[entry])\n except IndexError:\n pass\n return hist_list, mag_list","def fullhistogram(img):\n maxt = img.max()\n if maxt == 0:\n return np.array([img.size])\n return nhistogram(img, np.arange(maxt+2))[0]","def test_histogramdd(device):\n torch.manual_seed(0)\n\n # set up\n N = 1000\n bins = 20\n\n x_data = torch.rand(N, device=device)\n y_data = torch.rand(N, device=device)\n\n # all values inside\n epsilon = 1e-6\n x_edges = torch.linspace(\n x_data.min() - epsilon, x_data.max() + epsilon, steps=bins + 1, device=device\n )\n y_edges = torch.linspace(\n y_data.min() - epsilon, y_data.max() + epsilon, steps=bins + 1, device=device\n )\n\n # run\n sample = torch.stack((x_data, y_data))\n\n torch_hist, _ = histogramdd(sample, bins=(x_edges, y_edges))\n\n numpy_hist, _, _ = numpy.histogram2d(\n x_data.cpu().numpy(),\n y_data.cpu().numpy(),\n bins=(x_edges.cpu().numpy(), y_edges.cpu().numpy()),\n )\n\n # compare\n torch_hist = torch_hist.cpu().int()\n numpy_hist = torch.from_numpy(numpy_hist).int()\n\n assert torch.allclose(torch_hist, numpy_hist)","def getHistogram(self, copy: bool=True):\n for item in self.getPlotWidget().getItems():\n if item.getName() == 'histogram':\n return (item.getValueData(copy=copy),\n item.getBinEdgesData(copy=copy))\n else:\n return None","def dp_hist ( data, num_bins=10, epsilon=1.0, delta=0.1, histtype = 'continuous' ):\n\n import numpy as np\n\n if epsilon < 0.0:\n print('ERROR: Epsilon should be positive.')\n return\n elif delta < 0.0 or delta > 1.0:\n print('ERROR: Delta should be bounded in [0,1].')\n return\n else:\n if histtype == 'discrete':\n num_bins = len( np.unique(data) )\n hist_counts = [0] * num_bins\n data_min = min(data)\n data_max = max(data)\n bin_edges = np.linspace(data_min, data_max, num_bins+1)\n interval = (data_max - data_min) + 0.000000000001\n \n for kk in data:\n loc = (kk - data_min) / interval\n index = int(loc * num_bins)\n hist_counts[index] += 1.0\n\n if delta==0:\n noise = np.random.laplace(loc = 0, scale = 1.0/epsilon, size = (1,len(hist_counts)))\n else:\n sigma = (1.0/epsilon)*np.sqrt(2*np.log(1.25/delta))\n noise = np.random.normal(0.0, sigma, len(hist_counts))\n\n hist_array=np.asarray(hist_counts)\n noise_array=np.asarray(noise)\n dp_hist_counts = hist_array+noise_array\n\n return ( dp_hist_counts, bin_edges )","def histogram(self):\r\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\r\n\r\n #create a window, the reference must be stored, because the window\r\n #gets destroyed when its reference is garbage collected\r\n #make plotWindow a list and append to that if multiple windows should be possible\r\n title = \"histogram of {:s} channel\".format(self.ui.channel_selection.currentText())\r\n self.plotWindow = pyguitools.SimplePlotWindow(name = title)\r\n self.plotWindow.ax1.hist(self.npImg[self.ui.y0.value():self.ui.y1.value(),\r\n self.ui.x0.value():self.ui.x1.value(), \r\n channel].flatten(),\r\n bins=self.settings[\"histogramm bins\"],\r\n range=(self.settings[\"histogramm min\"],self.settings[\"histogramm max\"]))\r\n self.plotWindow.ax1.set_xlim(self.settings[\"histogramm min\"],self.settings[\"histogramm max\"]) \r\n self.plotWindow.show()","def histogram(self, table, **kwargs):\n kwargs = self._preprocess(**kwargs) # pylint: disable=protected-access\n with Session() as lib:\n file_context = lib.virtualfile_from_data(check_kind=\"vector\", data=table)\n with file_context as infile:\n arg_str = \" \".join([infile, build_arg_string(kwargs)])\n lib.call_module(\"histogram\", arg_str)","def test_make_histograms(self):\r\n raw_lengths = [90, 100, 110, 110, 130, 135]\r\n pre_lengths = [100, 110, 105, 130, 135]\r\n post_lengths = [130, 135]\r\n raw_hist, pre_hist, post_hist, bin_edges = \\\r\n make_histograms(raw_lengths, pre_lengths, post_lengths)\r\n assert_almost_equal(pre_hist, array([0, 2, 1, 0, 2]))\r\n assert_almost_equal(post_hist, array([0, 0, 0, 0, 2]))\r\n assert_almost_equal(bin_edges, array([90, 100, 110, 120, 130, 140]))","def histogram(f, option=\"uint16\"):\n from numpy import searchsorted, sort, ravel, concatenate, product\n\n n = searchsorted(sort(ravel(f)), range(f.max()+1))\n n = concatenate([n, [product(f.shape)]])\n h = n[1:]-n[:-1]\n return h","def hist(self, bins=\"unit\", closed=\"left\", stat=\"sum\"):\n return self.dist.hist(bins=bins, closed=closed, stat=stat)","def histogram(self, data, global_step, bins=1000, tag='histogram'):\n\n data = np.array(data)\n\n # Create histogram using numpy\n counts, bin_edges = np.histogram(data, bins=bins)\n\n # Fill fields of histogram proto\n hist = tf.HistogramProto()\n hist.min = float(np.min(data))\n hist.max = float(np.max(data))\n hist.num = int(np.prod(data.shape))\n hist.sum = float(np.sum(data))\n hist.sum_squares = float(np.sum(data ** 2))\n\n # Requires equal number as bins, where the first goes from -DBL_MAX to bin_edges[1]\n # See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/summary.proto#L30\n # Thus, we drop the start of the first bin\n bin_edges = bin_edges[1:]\n\n # Add bin edges and counts\n for edge in bin_edges:\n hist.bucket_limit.append(edge)\n for c in counts:\n hist.bucket.append(c)\n\n # Create and write Summary\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\n self.summary_writer.add_summary(summary, global_step)\n self.summary_writer.flush()","def _histogram(image,\n min,\n max,\n bins):\n\n return numpy.histogram(image, bins, (min, max))[0]","def normalize_hist(hist) -> [float]:\n hsum = np.sum(hist)\n newhist = []\n for hi in hist:\n newhist.append(hi/hsum)\n\n return newhist","def histograms(probs, actual, bins=100):\n actual = actual.astype(np.bool)\n edges, step = np.linspace(0., 1., bins, retstep=True, endpoint=False)\n idx = np.digitize(probs, edges) - 1\n top = np.bincount(idx, weights=actual, minlength=bins)\n bot = np.bincount(idx, weights=(~actual), minlength=bins)\n return top, bot, edges, step","def arelfreq(a,numbins=10,defaultreallimits=None):\r\n h,l,b,e = histogram(a,numbins,defaultreallimits)\r\n h = N.array(h/float(a.shape[0]))\r\n return h,l,b,e","def equalise_hist(image, bin_count=256):\n # TODO: your histogram equalization code\n #define arrays\n image = img_as_ubyte(image)\n row,col = image.shape\n new_image = np.zeros((row,col),dtype='uint8') \n\n # compute the value of each grayscale,and save in image_hist \n image_hist = np.bincount(image.flatten(), minlength=(bin_count))\n\n # normalise n[]\n norm_arr = (np.cumsum(image_hist)/(image.size))*(bin_count-1)\n norm_arr = norm_arr.astype('uint8')\n \n #Compute a normalized cumulative histogram\n for x in range(row):\n for y in range(col):\n new_image[x,y] = norm_arr[image[x,y]]\n \n return new_image"],"string":"[\n \"def just_histogram(*args, **kwargs):\\n return np.histogram(*args, **kwargs)[0].astype(float)\",\n \"def add_histogram(self, tag, values, global_step=None, bins='tensorflow'):\\n values = make_np(values)\\n self.vis.histogram(make_np(values), opts={'title': tag})\",\n \"def get_histogram(self):\\n\\n for bin in range(self.bins.size):\\n bin_inf = self.bins[bin]\\n try: bin_sup = self.bins[bin + 1]\\n except IndexError: bin_sup = self.vmax\\n self.hist[bin] = np.sum(\\n (self.values >= bin_inf)*(self.values < bin_sup))\\n\\n binned_values = np.sum(self.hist)\\n if binned_values == 0: return self.hist # no binned value\\n else: self.hist /= np.sum(self.hist)\\n return self.hist\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\",\n \"def hist_of_numeric(X):\\n figsize(10,3)\\n for col in get_numeric(X):\\n print(col)\\n X[col].hist(bins=50)\\n show()\",\n \"def get_histogram(self):\\n\\n values_array = np.array(self.values)\\n for bin0 in range(self.bins[0].size):\\n bin_inf0 = self.bins[0][bin0]\\n try: bin_sup0 = self.bins[0][bin0 + 1]\\n except IndexError: bin_sup0 = self.vmax[0]\\n values = values_array[\\n (values_array[:, 0] >= bin_inf0)\\n *(values_array[:, 0] < bin_sup0)][:, 1]\\n for bin1 in range(self.bins[1].size):\\n bin_inf1 = self.bins[1][bin1]\\n try: bin_sup1 = self.bins[1][bin1 + 1]\\n except IndexError: bin_sup1 = self.vmax[1]\\n self.hist[bin0*self.Nbins[1] + bin1, 2] = (\\n np.sum((values >= bin_inf1)*(values < bin_sup1)))\\n\\n if np.sum(self.hist[:, 2]) > 0: # there are binned values\\n self.hist[:, 2] /= np.sum(self.hist[:, 2])\\n return self.hist\",\n \"def _compute_histogram(self, x, momentum):\\n num_bins = self.histogram.size(0)\\n x_detached = x.detach()\\n self.bin_width = (self._max_val - self._min_val) / (num_bins - 1)\\n lo = torch.floor((x_detached - self._min_val) / self.bin_width).long()\\n hi = (lo + 1).clamp(min=0, max=num_bins - 1)\\n hist = x.new_zeros(num_bins)\\n alpha = (\\n 1.0\\n - (x_detached - self._min_val - lo.float() * self.bin_width)\\n / self.bin_width\\n )\\n hist.index_add_(0, lo, alpha)\\n hist.index_add_(0, hi, 1.0 - alpha)\\n hist = hist / (hist.sum() + 1e-6)\\n self.histogram = (1.0 - momentum) * self.histogram + momentum * hist\",\n \"def test_get_histogram_stat_by(self):\\n pass\",\n \"def histo ( self ,\\n xbins = 20 , xmin = None , xmax = None ,\\n ybins = 20 , ymin = None , ymax = None ,\\n hpars = () , \\n histo = None ,\\n integral = False ,\\n errors = False , \\n density = False ) :\\n \\n \\n histos = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\\n ybins = ybins , ymin = ymin , ymax = ymax ,\\n hpars = hpars ,\\n histo = histo )\\n\\n # loop over the historgam bins \\n for ix,iy,x,y,z in histo.items() :\\n\\n xv , xe = x.value() , x.error()\\n yv , ye = y.value() , y.error()\\n \\n # value at the bin center \\n c = self ( xv , yv , error = errors ) \\n\\n if not integral : \\n histo[ix,iy] = c\\n continue\\n\\n # integral over the bin \\n v = self.integral( xv - xe , xv + xe , yv - ye , yv + ye )\\n \\n if errors :\\n if 0 == c.cov2 () : pass\\n elif 0 != c.value() and 0 != v : \\n v = c * ( v / c.value() )\\n \\n histo[ix,iy] = v \\n\\n ## coovert to density historgam, if requested \\n if density : histo = histo.density()\\n \\n return histo\",\n \"def build_hist(concept_values: np.ndarray, num_bins: int = 100) -> np.ndarray:\\n hist, _ = np.histogram(concept_values, bins=num_bins, range=(0., 1.), density=True)\\n return hist\",\n \"def histogram(self):\\n return self._hist\",\n \"def histogram_summary(self, tag, values, step, bins=1000):\\n self.writer.add_histogram(tag, values, step, bins='auto')\",\n \"def distribution_magnitude_histogram(cur, var, table, label):\\n x = select(cur,var, table)\\n print(\\\"Number of entries: \\\", len(x))\\n print(\\\"Maximum: \\\", max(x))\\n print(\\\"Minimum: \\\", min(x))\\n \\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.set_xlabel(\\\"Sentiment Magnitude\\\")\\n ax.set_ylabel(\\\"Number of Sentences\\\")\\n fig.suptitle(label)\\n ax.hist(x, bins = 20)\\n plt.show()\",\n \"def _make_histogram(values, bins):\\n values = values.reshape(-1)\\n counts, limits = np.histogram(values, bins=bins)\\n limits = limits[1:]\\n\\n sum_sq = values.dot(values)\\n return HistogramProto(min=values.min(),\\n max=values.max(),\\n num=len(values),\\n sum=values.sum(),\\n sum_squares=sum_sq,\\n bucket_limit=limits,\\n bucket=counts)\",\n \"def OF1_CalculateRawHistogram(image):\\n h = np.zeros(256, np.float_)\\n for i in np.nditer(image):\\n h[i - 1] = h[i - 1] + 1\\n\\n return h\",\n \"def histogramintegrals(self):\\n return {}\",\n \"def test_get_histogram_stat_by_breakout(self):\\n pass\",\n \"def normalized(self):\\n total = self.total()\\n result = Histogram()\\n for value, count in self.items():\\n try:\\n result[value] = count / float(total)\\n except UnorderableElements:\\n result = Histogram.from_dict(dict(result), key=hash)\\n result[value] = count / float(total)\\n return result\",\n \"def build_histogram(iterator, key):\\n buckets = defaultdict(int)\\n values = {}\\n\\n num_objects = 0\\n for obj in iterator:\\n num_objects += 1\\n\\n try:\\n val = obj[key]\\n except (KeyError, TypeError):\\n continue\\n\\n value_hash = hashlib.sha1()\\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\\n value_hash = value_hash.hexdigest()\\n\\n buckets[value_hash] += 1\\n values[value_hash] = val\\n\\n return [\\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\\n ]\",\n \"def create_fixed_hist(self):\\n hist = cv2.calcHist([self.obj], [0, 1, 2], None, [32, 8, 8],\\n [0, 256, 0, 256, 0, 256])\\n self.hist = cv2.normalize(hist).flatten()\\n print self.hist\",\n \"def makeHist(data, bins, wgt=None, factor=1.0, pdf=False):\\n n_arr, bins = np.histogram(data, bins, weights=wgt)\\n ctr_bins = centerOfBins(bins)\\n \\n if pdf == True:\\n n_arr = asFloat(n_arr) / (float(sum(n_arr)) * (bins[1:] - bins[:-1]))\\n else:\\n n_arr = asFloat(n_arr) * factor\\n \\n return n_arr, ctr_bins\",\n \"def histogram(self, mask=None, extrema=None):\\r\\n uni, counts = self._getcolors()\\r\\n return [l for l in counts]\",\n \"def _histogram_with_spread(self):\\n complexity_hist = np.bincount(\\n self.epoch.array_annotations['complexity'])\\n num_bins = (self.t_stop - self.t_start).rescale(\\n self.bin_size.units).item() / self.bin_size.item()\\n num_bins = round_binning_errors(num_bins, tolerance=self.tolerance)\\n time_hist = np.zeros(num_bins, dtype=int)\\n\\n start_bins = (self.epoch.times - self.t_start).rescale(\\n self.bin_size.units).magnitude / self.bin_size.item()\\n stop_bins = (self.epoch.times + self.epoch.durations - self.t_start\\n ).rescale(self.bin_size.units\\n ).magnitude / self.bin_size.item()\\n\\n if self.sampling_rate is not None:\\n shift = (.5 / self.sampling_rate / self.bin_size).simplified.item()\\n # account for the first bin not being shifted in the epoch creation\\n # if the shift would move it past t_start\\n if self.epoch.times[0] == self.t_start:\\n start_bins[1:] += shift\\n else:\\n start_bins += shift\\n stop_bins += shift\\n\\n start_bins = round_binning_errors(start_bins, tolerance=self.tolerance)\\n stop_bins = round_binning_errors(stop_bins, tolerance=self.tolerance)\\n\\n for idx, (start, stop) in enumerate(zip(start_bins, stop_bins)):\\n time_hist[start:stop] = \\\\\\n self.epoch.array_annotations['complexity'][idx]\\n\\n time_hist = neo.AnalogSignal(\\n signal=np.expand_dims(time_hist, axis=1),\\n sampling_period=self.bin_size, units=pq.dimensionless,\\n t_start=self.t_start)\\n\\n empty_bins = (self.t_stop - self.t_start - self.epoch.durations.sum())\\n empty_bins = empty_bins.rescale(self.bin_size.units\\n ).magnitude / self.bin_size.item()\\n empty_bins = round_binning_errors(empty_bins, tolerance=self.tolerance)\\n complexity_hist[0] = empty_bins\\n\\n return time_hist, complexity_hist\",\n \"def np_histogram(data, title, bins=\\\"auto\\\"):\\n figure = plt.figure()\\n canvas = figure.canvas\\n plt.hist(data, bins=bins)\\n plt.title(title)\\n\\n canvas.draw()\\n w, h = canvas.get_width_height()\\n np_hist = np.fromstring(canvas.get_renderer().tostring_rgb(), dtype=np.uint8).reshape(h, w, 3)\\n plt.close(figure)\\n util.np_info(np_hist)\\n return np_hist\",\n \"def hist(a,bins):\\n n=searchsorted(sort(a),bins)\\n n=concatenate([n,[len(a)]])\\n n=array(list(map(float,n)))\\n# n=array(n)\\n return n[1:]-n[:-1]\",\n \"def __value(t,N):\\n _,hist=np.unique(t, return_counts=True)\\n hist=list(hist)\\n hist.append(N-np.sum(hist))\\n return EntropyD(np.array(hist))\",\n \"def create_hist(pVals,bins=1000,log=False,max_val=False):\\n\\t# gets an array of pValues and returns an array of bins with counts\\n\\thist_count = np.zeros(bins)\\n\\tif (log):\\n\\t\\tnlp = -1.0*np.log10(pVals)\\n\\t\\tif (max_val):\\n\\t\\t\\tnlp_max=max_val\\n\\t\\telse:\\n\\t\\t\\tnlp_max = nlp.max()\\n\\t\\tpVals = pVals/nlp_max\\n\\tfor i in pVals:\\n\\t\\tj=int(bins*i)\\n\\t\\tif j == bins:\\n\\t\\t\\tj -= 1\\n\\t\\thist_count[j] += 1\\n\\treturn hist_count\",\n \"def test_get_result_histogram_stat(self):\\n pass\",\n \"def hog_histograms(*args, **kwargs): # real signature unknown\\n pass\",\n \"def test_get_result_histogram(self):\\n pass\",\n \"def hist(self, bins):\\n x = self.x\\n plt.hist(x, bins)\\n plt.xlabel('Observed Data')\\n plt.ylabel('Frequency')\\n plt.show()\",\n \"def glGetHistogram( baseFunction, target, reset, format, type, values=None):\\r\\n if values is None:\\r\\n width = glGetHistogramParameteriv(\\r\\n target,\\r\\n GL_HISTOGRAM_WIDTH,\\r\\n )\\r\\n values = images.images.SetupPixelRead( format, (width,4), type )\\r\\n arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[\\r\\n images.images.TYPE_TO_ARRAYTYPE.get(type,type)\\r\\n ]\\r\\n baseFunction(\\r\\n target, reset, format, type,\\r\\n ctypes.c_void_p( arrayType.dataPointer(values))\\r\\n )\\r\\n return values\",\n \"def get_hist(self):\\n return self.hist\",\n \"def get_histogram(self, column):\\n\\n df_histogram = pd.DataFrame(self.serie)\\n #histogramcol = alt.Chart(df_histogram).mark_bar().encode(alt.X(column, bin=True), y='count()')\\n histogramcol = alt.Chart(df_histogram).mark_bar().encode(alt.X(column, bin=alt.Bin(maxbins=50)),y='count()')\\n return histogramcol\",\n \"def sum_hist(self, label=None):\\n values = [h.values for h in self.hists]\\n errors = [h.yerr for h in self.hists]\\n hist = deepcopy(self.hists[0])\\n hist.values = sum(values)\\n hist.yerr = np.sqrt(sum([error*error for error in errors]))\\n hist.label = label\\n hist.color = style.def_grey\\n return hist\",\n \"def histogram_summary(tag, values, bins):\\n tag = _clean_tag(tag)\\n values = _make_numpy_array(values)\\n hist = _make_histogram(values.astype(float), bins)\\n return Summary(value=[Summary.Value(tag=tag, histo=hist)])\",\n \"def make_line_hist(x,minValue,maxValue,nbins=10,logscale=False):\\n if logscale:\\n freqs,bins = np.histogram(x,bins=np.logspace(np.log10(minValue),np.log10(maxValue),nbins),normed=True) \\n else:\\n freqs,bins = np.histogram(x,bins=np.linspace(minValue,maxValue,nbins),normed=True)\\n \\n \\n plt.plot((bins[:-1]+bins[1:])/2,freqs)\\n return freqs\",\n \"def histogram(self, field: str, min_value: float, max_value: float, num_of_buckets: int = 5):\\n return self.values(histogram=Histogram(field, min_value, max_value, num_of_buckets))\",\n \"def create_general_hist(self, obj):\\n hist = cv2.calcHist([obj], [0, 1, 2], None, [32, 8, 8],\\n [0, 256, 0, 256, 0, 256])\\n print cv2.normalize(hist).flatten()\\n return cv2.normalize(hist).flatten()\",\n \"def get_vals_hist(t_vals, num_bin):\\n t_vals_hist = np.histogram(t_vals, num_bin)\\n return [ t_vals_hist[0].tolist(),\\n t_vals_hist[1].tolist(),\\n ]\",\n \"def calcHistogram(Tech_res):\\n A_Hist = np.histogram(Tech_res.A_mean, Tech_res.hist_bins)\\n top, bin_list, x_steps = list(A_Hist[0]), list(A_Hist[1]), []\\n for n in range(np.shape(bin_list)[0]-1):\\n x_steps.append((bin_list[n+1] + bin_list[n]) / 2)\\n Tech_res.update_tech_meas(Hist_tops=top, Hist_steps=x_steps)\\n return\",\n \"def histogram(self):\\n if np.size(self.stats['Counts']): # don't do anything to an empty list\\n if np.size(self.bins) and not self.redo:\\n return self.bins, self.occs, self.thresh\\n elif np.size(self.bin_array) > 0: \\n self.occs, self.bins = np.histogram(self.stats['Counts'], self.bin_array) # fixed bins. \\n else:\\n try:\\n lo, hi = min(self.stats['Counts'])*0.97, max(self.stats['Counts'])*1.02\\n # scale number of bins with number of files in histogram and with separation of peaks\\n num_bins = int(15 + self.ind//100 + (abs(hi - abs(lo))/hi)**2*15) \\n self.occs, self.bins = np.histogram(self.stats['Counts'], bins=np.linspace(lo, hi, num_bins+1)) # no bins provided by user\\n except: \\n self.occs, self.bins = np.histogram(self.stats['Counts'])\\n else: self.occs, self.bins = np.zeros(10), np.arange(0,1.1,0.1)\\n return self.bins, self.occs, self.thresh\",\n \"def compute_histogram(self):\\n # compute distance between points \\n distmatrix = np.sqrt(pdist(self.points))\\n if not self.mean_dist:\\n self.mean_dist = np.mean(distmatrix)\\n distmatrix = distmatrix/self.mean_dist\\n distmatrix = squareform(distmatrix)\\n #compute angles between points\\n angles = compute_angles(self.points)\\n #quantize angles to a bin\\n tbins = np.floor(angles / (2 * pi / self.nbins_theta))\\n lg = np.logspace(self.r1, self.r2, num=5)\\n #quantize radious to bins\\n rbins = np.ones(angles.shape) * -1\\n for r in lg:\\n counts = (distmatrix < r) \\n rbins = rbins + counts.astype(int) \\n return rbins, tbins\",\n \"def import_histo(w,hz,xmin,xmax):\\n print 'Loading histogram with',hz.GetEntries(),'entries'\\n data = RooDataHist('data','Zmumu MC',RooArgList(w.var('x')),hz)\\n return data\",\n \"def roo_histo ( self ,\\n xbins = 20 , xmin = None , xmax = None ,\\n ybins = 20 , ymin = None , ymax = None ,\\n hpars = () , \\n histo = None , \\n events = True ) :\\n \\n histo = self.make_histo ( xbins = xbins , xmin = xmin , xmax = xmax ,\\n ybins = ybins , ymin = ymin , ymax = ymax ,\\n hpars = hpars ,\\n histo = histo )\\n \\n hh = self.pdf.createHistogram (\\n hID() ,\\n self.xvar , self.binning ( histo.GetXaxis() , 'histo2x' ) ,\\n ROOT.RooFit.YVar ( self.yvar , self.binning ( histo.GetYaxis() , 'histo2y' ) ) , \\n ROOT.RooFit.Scaling ( False ) , \\n ROOT.RooFit.Extended ( False ) ) \\n\\n for i in hh : hh.SetBinError ( i , 0 ) \\n \\n if events and self.pdf.mustBeExtended() :\\n \\n for ix , iy , x , y , z in hh.items() :\\n volume = 4 * x.error() * y.error() \\n hh [ ix , iy ] *= volume\\n \\n hh *= self.pdf.expectedEvents ( self.vars ) / hh.sum() \\n \\n histo += hh\\n \\n return histo\",\n \"def collect_absolute_value(self, name_to_arr):\\n for tensor, data_arr in name_to_arr.items():\\n data_arr = np.asarray(data_arr) # noqa: PLW2901\\n data_arr = data_arr.flatten() # noqa: PLW2901\\n if data_arr.size > 0:\\n min_value = np.min(data_arr)\\n max_value = np.max(data_arr)\\n else:\\n min_value = 0\\n max_value = 0\\n\\n data_arr = np.absolute(data_arr) # only consider absolute value # noqa: PLW2901\\n\\n if tensor not in self.histogram_dict:\\n # first time it uses num_bins to compute histogram.\\n hist, hist_edges = np.histogram(data_arr, bins=self.num_bins)\\n self.histogram_dict[tensor] = (hist, hist_edges, min_value, max_value)\\n else:\\n old_histogram = self.histogram_dict[tensor]\\n old_min = old_histogram[2]\\n old_max = old_histogram[3]\\n old_hist = old_histogram[0]\\n old_hist_edges = old_histogram[1]\\n temp_amax = np.max(data_arr)\\n if temp_amax > old_hist_edges[-1]:\\n # increase the number of bins\\n width = old_hist_edges[1] - old_hist_edges[0]\\n # NOTE: np.arange may create an extra bin after the one containing temp_amax\\n new_bin_edges = np.arange(old_hist_edges[-1] + width, temp_amax + width, width)\\n old_hist_edges = np.hstack((old_hist_edges, new_bin_edges))\\n hist, hist_edges = np.histogram(data_arr, bins=old_hist_edges)\\n hist[: len(old_hist)] += old_hist\\n self.histogram_dict[tensor] = (hist, hist_edges, min(old_min, min_value), max(old_max, max_value))\",\n \"def test_bins(self):\\n min_val = 0\\n max_val = 1\\n buckets = 10\\n values_per_bucket = 10\\n\\n import numpy\\n\\n data = list(numpy.linspace(min_val, max_val, buckets * values_per_bucket))\\n bins = numpy.linspace(min_val, max_val + sys.float_info.epsilon, buckets + 1)\\n digitized = numpy.digitize(data, bins)\\n counts = numpy.bincount(digitized)\\n self.assertEqual(buckets + 1, len(counts))\\n self.assertEqual(0, counts[0])\\n for bucket in counts[1:]:\\n self.assertEqual(values_per_bucket, bucket)\",\n \"def hist(self):\\r\\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\\r\\n plt.title(self.column_name)\\r\\n plt.savefig(self.column_name + \\\".svg\\\")\\r\\n plt.close()\",\n \"def getHistogramData(self):\\n return (self.numBins, self.binWidth, self.minFreq, self.maxFreq)\",\n \"def distribution_sentimentscore_histogram(cur, var, table, label):\\n x = select(cur,var, table)\\n print(\\\"Number of entries: \\\", len(x))\\n print(\\\"Maximum: \\\", max(x))\\n print(\\\"Minimum: \\\", min(x))\\n \\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.set_xlabel(\\\"Sentiment Score\\\")\\n ax.set_ylabel(\\\"Number of Loans\\\")\\n fig.suptitle(label)\\n ax.hist(x, bins = 15)\\n plt.show()\",\n \"def compute_histogram(self, image):\\n\\n hist = [0] * 256\\n x, y = image.shape[:2]\\n #print(image.shape)\\n for i in range(x):\\n for j in range(y):\\n hist[image[i, j]] += 1\\n\\n return hist\",\n \"def histo_summary(self, tag, values, step, bins=1000):\\n\\n # Create a histogram using numpy\\n counts, bin_edges = np.histogram(values, bins=bins)\\n\\n # Fill the fields of the histogram proto\\n hist = tf.HistogramProto()\\n hist.min = float(np.min(values))\\n hist.max = float(np.max(values))\\n hist.num = int(np.prod(values.shape))\\n hist.sum = float(np.sum(values))\\n hist.sum_squares = float(np.sum(values**2))\\n\\n # Drop the start of the first bin\\n bin_edges = bin_edges[1:]\\n\\n # Add bin edges and counts\\n for edge in bin_edges:\\n hist.bucket_limit.append(edge)\\n for c in counts:\\n hist.bucket.append(c)\\n\\n # Create and write Summary\\n with self.writer.as_default():\\n tf.summary.histogram(name=tag, data=hist, step=step)\\n self.writer.flush()\",\n \"def test_histogram_standard(self):\\n histogram_file = self.get_file(\\\"histogram.csv\\\")\\n\\n schema = [(\\\"value\\\", int)]\\n\\n # Big data frame from data with 33% correct predicted ratings\\n self.frame_histogram = self.context.frame.import_csv(histogram_file,\\n schema=schema)\\n result = self.frame_histogram.histogram(\\\"value\\\", num_bins=10)\\n\\n # verified known results based on data crafted\\n cutoffs = [1.0, 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1, 10.0]\\n histogram = [10.0, 10.0, 10.0, 10.0, 10.0,\\n 10.0, 10.0, 10.0, 10.0, 10.0]\\n density = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]\\n\\n self.assertAlmostEqual(cutoffs, result.cutoffs)\\n self.assertAlmostEqual(histogram, result.hist)\\n self.assertAlmostEqual(density, result.density)\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\\r\\n pylab.hist(values, bins = numBins)\\r\\n pylab.xlabel(xLabel)\\r\\n pylab.ylabel(yLabel)\\r\\n if title != None:\\r\\n pylab.title(title)\\r\\n pylab.show()\",\n \"def anticum_hist(data, bins=None, toadd=0, zero=False, zerox=False):\\n\\n from numpy import histogram, unique, append, cumsum, zeros, array\\n data = array(data)\\n\\n if bins is None:\\n temp, bins = histogram(data, unique(data))\\n hist = append(cumsum(temp[::-1])[::-1], 1)\\n else:\\n if len(data) == 0:\\n return zeros(len(bins)), bins\\n # if max(data) > max(bins):\\n # print \\\"Must have the largest bin be bigger than the largest data point.\\\"\\n # print max(bins)\\n # print max(data)\\n # import sys\\n # sys.exit(1337)\\n temp, bins = histogram(data, bins=bins)\\n numbig = data[data > bins.max()].shape[0]\\n # add on the objects that are above the last bin to the last count, so that they're included in the cumulative sum\\n temp[-1] += numbig\\n hist = append(cumsum(temp[::-1])[::-1], numbig)\\n\\n hist = hist + toadd # add some number to all the values\\n\\n if zero:\\n hist = append(hist, 1e-10)\\n bins = append(bins, bins[-1])\\n if zerox:\\n hist = append(hist[0], hist)\\n bins = append(1e-10, bins)\\n\\n return hist, bins\",\n \"def gc_percent_hist(data):\\n result = [0] * 101 # 0-100\\n for s in data:\\n percent = _gc_percent(s)\\n result[percent] += 1\\n return result\",\n \"def _printHist(self):\\n bins = [0] * self.displayBins\\n binSize = self.maxValue / self.displayBins\\n displaySamps = self.samples[:]\\n displaySamps.sort()\\n currLimit = binSize\\n binIndex = 0\\n partIndex = 0\\n while partIndex < self.numParticles:\\n part = displaySamps[partIndex]\\n if binIndex >= self.displayBins:\\n # if value beyond max value, add to last bin and go on to next particle\\n bins[19] += 1\\n partIndex += 1\\n elif part < currLimit:\\n # count particle in current bin, go on to next particle\\n bins[binIndex] += 1\\n partIndex += 1\\n else:\\n # go on to next bin, don't go on to next particle\\n binIndex += 1\\n currLimit += binSize\\n self.printMapPattern(binSize)\\n histStr = \\\"{0:3d} \\\"\\n printStr = \\\"\\\"\\n for b in bins:\\n printStr += histStr.format(b)\\n print(printStr)\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\\n pylab.hist(values, bins = numBins)\\n pylab.xlabel(xLabel)\\n pylab.ylabel(yLabel)\\n if not title == None:\\n pylab.title(title)\\n pylab.show()\",\n \"def fast_histogram(\\n val: List[float],\\n discrete: Optional[bool] = None,\\n bins: Optional[List[float]] = None,\\n) -> Mapping[str, float]:\\n val = np.asarray(val, dtype=float)\\n size = len(val)\\n\\n # Unique does not work on nan since nan != nan\\n val = val[~np.isnan(val)]\\n size_nan = size - len(val)\\n discrete = is_discrete(val) if discrete is None else discrete\\n\\n if discrete:\\n bins, counts = np.unique(val, return_counts=True)\\n bin_to_count = {str(bins[i]): counts[i] for i in range(len(bins))}\\n if size_nan > 0:\\n bin_to_count[\\\"nan\\\"] = size_nan\\n return bin_to_count\\n\\n # Counts nan as part of infinity bin\\n val = val[~np.isinf(val)]\\n size_inf = size - len(val)\\n if len(val) == 0:\\n return {\\\"+Inf\\\": size_inf}\\n\\n # Take the negative of all values to use \\\"le\\\" as the bin upper bound\\n bins = bins or get_bins(val)\\n counts, _ = np.histogram(-val, bins=-np.flip([bins[0]] + bins))\\n counts = np.flip(counts)\\n bin_to_count = dict(p for p in zip(map(str, bins), counts))\\n\\n # Add infinity bin last to preserve insertion order\\n bin_to_count[\\\"+Inf\\\"] = size_inf\\n return bin_to_count\",\n \"def update_histo_frame():\\n min_histo.text = str(MIN_RANGE_F) # Display the legend\\n max_histo.text = str(MAX_RANGE_F)\\n\\n histogram = np.zeros(GRID_AXIS) # Clear histogram accumulation array\\n # Collect camera data and calculate the histogram\\n for _row in range(0, GRID_AXIS):\\n for _col in range(0, GRID_AXIS):\\n histo_index = int(map_range(GRID_DATA[_col, _row], 0, 1, 0, GRID_AXIS - 1))\\n histogram[histo_index] = histogram[histo_index] + 1\\n\\n histo_scale = np.max(histogram) / (GRID_AXIS - 1)\\n if histo_scale <= 0:\\n histo_scale = 1\\n\\n # Display the histogram\\n for _col in range(0, GRID_AXIS):\\n for _row in range(0, GRID_AXIS):\\n if histogram[_col] / histo_scale > GRID_AXIS - 1 - _row:\\n image_group[((_row * GRID_AXIS) + _col)].fill = index_to_rgb(\\n round((_col / GRID_AXIS), 3)\\n )\\n else:\\n image_group[((_row * GRID_AXIS) + _col)].fill = BLACK\",\n \"def hist(data):\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(111)\\n plt.hold(True)\\n for x in xrange(len(data[:,0,0])):\\n counts, edges = np.histogram(data[x,:,:],bins=100)\\n centers = [(edges[i]+edges[i+1])/2.0 for i,v in enumerate(edges[:-1])]\\n ax1.plot(centers,counts)\\n plt.hold(False)\\n\\n plt.show(block=False)\\n\\n # return fig\",\n \"def rythm_hist(duration_ohe):\\n assert duration_ohe.ndim == 2\\n return duration_ohe.sum(axis=0) / duration_ohe.sum()\",\n \"def _make_hist(self, oned_arr):\\n hist_ = np.histogram(\\n a=oned_arr,\\n bins=self.null_distributions_[\\\"histogram_bins\\\"],\\n range=(\\n np.min(self.null_distributions_[\\\"histogram_bins\\\"]),\\n np.max(self.null_distributions_[\\\"histogram_bins\\\"]),\\n ),\\n density=False,\\n )[0]\\n return hist_\",\n \"def getHistogram( self, img):\\n bins = 256\\n range_scale = [0,254]\\n nivel_transparencia = 0.5\\n plt.hist(img.ravel(),bins,range_scale, label=\\\"histogram\\\", alpha=nivel_transparencia);\\n plt.legend(loc='upper right')\\n plt.show()\",\n \"def make_histogram(points, bucket_size):\\r\\n return Counter(bucketize(point, bucket_size) for point in points)\",\n \"def get_histo(values, bins=1000):\\n if isinstance(values, list):\\n values = np.array(values)\\n\\n # Create histogram using numpy\\n counts, bin_edges = np.histogram(values, bins=bins)\\n\\n # Fill fields of histogram proto\\n hist = tf.HistogramProto()\\n hist.min = float(np.min(values))\\n hist.max = float(np.max(values))\\n hist.num = int(np.prod(values.shape))\\n hist.sum = float(np.sum(values))\\n hist.sum_squares = float(np.sum(values**2))\\n\\n # Requires equal number as bins, where the first goes from -DBL_MAX to bin_edges[1]\\n # See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/summary.proto#L30\\n # Thus, we drop the start of the first bin\\n bin_edges = bin_edges[1:]\\n\\n # Add bin edges and counts\\n for edge in bin_edges:\\n hist.bucket_limit.append(edge)\\n for c in counts:\\n hist.bucket.append(c)\\n\\n return hist\",\n \"def equalize_hist(input):\\n return np.float32(skimage.exposure.equalize_hist(input.numpy()))\",\n \"def hist_bins(bins, vals):\\r\\n\\r\\n hist = zeros(len(bins))\\r\\n j = 0\\r\\n for i in vals:\\r\\n while bins[j] < i:\\r\\n j += 1\\r\\n hist[j] += 1\\r\\n\\r\\n return asarray(bins), hist\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\\r\\n # TODO\\r\\n pylab.hist(values, bins = numBins)\\r\\n pylab.xlabel(xLabel)\\r\\n pylab.ylabel(yLabel)\\r\\n if title != None:\\r\\n pylab.title(title)\\r\\n pylab.show()\",\n \"def setup_hist(self):\\n self.x_min = {}\\n self.x_max = {}\\n self.x_max_minus_min = {}\\n self.dx = {}\\n self.n_bins = {}\\n\\n self.histogram_edges = {}\\n self.histogram_values = {}\\n self.histogram_cdf = {}\",\n \"def histogram_function(r_min, a, N, nbins):\\n r_min_no_selfdistance = r_min - np.identity(len(r_min)) #remove identitity matrix so own distance will be treated as 0\\n histarray = np.array(r_min_no_selfdistance).flatten()\\n histogram = np.histogram(histarray,bins=np.linspace(0,a,nbins))\\n histogram[0][0] = histogram[0][0] - N # remove N from the first bin to prevent it counting particle distance to itself\\n return histogram[0]\",\n \"def histo_summary(self, tag, values, step, bins=1000):\\n\\n # Create a histogram using numpy\\n counts, bin_edges = np.histogram(values, bins=bins)\\n\\n # Fill the fields of the histogram proto\\n hist = tf.HistogramProto()\\n hist.min = float(np.min(values))\\n hist.max = float(np.max(values))\\n hist.num = int(np.prod(values.shape))\\n hist.sum = float(np.sum(values))\\n hist.sum_squares = float(np.sum(values**2))\\n\\n # Drop the start of the first bin\\n bin_edges = bin_edges[1:]\\n\\n # Add bin edges and counts\\n for edge in bin_edges:\\n hist.bucket_limit.append(edge)\\n for c in counts:\\n hist.bucket.append(c)\\n\\n # Create and write Summary\\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\\n self.writer.add_summary(summary, step)\\n self.writer.flush()\",\n \"def histo_summary(self, tag, values, step, bins=1000):\\n\\n # Convert to a numpy array\\n values = np.array(values)\\n\\n # Create a histogram using numpy\\n counts, bin_edges = np.histogram(values, bins=bins)\\n\\n # Fill the fields of the histogram proto\\n hist = tf.HistogramProto()\\n hist.min = float(np.min(values))\\n hist.max = float(np.max(values))\\n hist.num = int(np.prod(values.shape))\\n hist.sum = float(np.sum(values))\\n hist.sum_squares = float(np.sum(values**2))\\n\\n # Drop the start of the first bin\\n bin_edges = bin_edges[1:]\\n\\n # Add bin edges and counts\\n for edge in bin_edges:\\n hist.bucket_limit.append(edge)\\n for c in counts:\\n hist.bucket.append(c)\\n\\n # Create and write Summary\\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\\n self.writer.add_summary(summary, step)\\n self.writer.flush()\",\n \"def histogram(data,binwidth, xmin,xmax):\\n bins = arange(xmin,xmax, binwidth)\\n binsc = bins + (0.5 * binwidth)\\n try: #FIXME: use updated numpy.histogram\\n histo = numpyhisto(data, bins, new=False)[0]\\n except:\\n histo = numpyhisto(data, bins)[0]\\n return binsc[:len(histo)], histo\",\n \"def efficient_Make_Binned_ROC_histograms(title, data, bins, PU_range='full'):\\n diff_ran = (-25,25)\\n diff_bins = diff_ran[1]-diff_ran[0]\\n ratio_ran = (0,10)\\n ratio_bins = 60\\n\\n Diff_hist_list = []\\n Ratio_hist_list = []\\n CSV_hist_list = []\\n ZeroDiv_list = []\\n for bin_ in range(len(bins)-1):\\n Diff_hist_list.append(rt.TH1D(\\\"L4-L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"L4-L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),diff_bins,diff_ran[0],diff_ran[1]))\\n Ratio_hist_list.append(rt.TH1D(\\\"L4_L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"L4_L1_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),ratio_bins,ratio_ran[0],ratio_ran[1]))\\n CSV_hist_list.append(rt.TH1D(\\\"CSV_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),\\\"CSV_\\\"+str(bins[bin_])+\\\"_\\\"+str(bins[bin_+1]),ratio_bins,0,1))\\n ZeroDiv_list.append(0)\\n\\n for particle in data:\\n if PU_range != 'full':\\n if particle[-1]<PU_range[0] or particle[-1]>PU_range[1]: continue\\n bin_number = FCM.bin_selection(particle,bins)\\n if bin_number == -100: continue\\n\\n Diff_hist_list[bin_number].Fill(particle[8]-particle[5])\\n CSV_hist_list[bin_number].Fill(particle[1])\\n if particle[17] != 0:\\n L4_L1 = particle[20]/particle[17]\\n Ratio_hist_list[bin_number].Fill(L4_L1)\\n else:\\n ZeroDiv_list[bin_number] += 1\\n\\n tfile = rt.TFile(\\\"Thesis_Plots/root_files/{}_histograms.root\\\".format(title),\\\"recreate\\\")\\n for hist in Diff_hist_list:\\n hist.Write()\\n for hist in Ratio_hist_list:\\n hist.Write()\\n for hist in CSV_hist_list:\\n hist.Write()\\n print \\\"saved histograms in Thesis_Plots/root_files/{}_histograms.root\\\".format(title)\\n\\n csv_file = open(\\\"Thesis_Plots/root_files/{}_ZeroDiv.csv\\\".format(title),\\\"wb\\\")\\n writer = csv.writer(csv_file)\\n writer.writerow(ZeroDiv_list)\\n csv_file.close()\\n print \\\"saved zero division occurences in Thesis_Plots/root_files/{}_ZeroDiv.csv\\\".format(title)\",\n \"def getHistogram(self, var, idx = None, translation = None, other = None,\\\\\\n verbose = 1, ab = [], bins = 100, minmax = None):\\n \\n if idx is None: idx = np.arange(self.atoms.shape[0])\\n if translation is None: translation = [0]\\n if isinstance(translation, (int, np.integer)): translation = [translation]\\n\\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\\\\n verbose = verbose, ab = ab, other = other)\\n x = []\\n y = []\\n for i, item in enumerate(data):\\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\\n x.append((bin[:-1] + bin[1:]) / 2)\\n y.append(cnt)\\n\\n return x, y, lbl, leg\",\n \"def _fast_hist(data, bin_edges):\\n # Yes, I've tested this against histogram().\\n return np.bincount(np.digitize(data, bin_edges[1:-1]), minlength=len(bin_edges) - 1)\",\n \"def calc_histogram(self, img_data):\\n\\n histogram = [0] * self.color_depth\\n\\n for w in range(img_data.shape[0]):\\n for h in range(img_data.shape[1]):\\n pixel = img_data[w][h]\\n histogram[pixel] += 1\\n\\n return histogram\",\n \"def _find_histogram(cls, clt):\\n num_labels = np.arange(0, len(np.unique(clt.labels_)) + 1)\\n (hist, _) = np.histogram(clt.labels_, bins=num_labels)\\n\\n hist = hist.astype(\\\"float\\\")\\n hist /= hist.sum()\\n\\n return hist\",\n \"def hist(img):\\n bottom_half = img[img.shape[0]//2:,:] # 0:img.shape[0]//2 is the top half\\n histogram = bottom_half.sum(axis=0) \\n \\n return histogram\",\n \"def histogram(self, number_concentration=True):\\n\\n\\t\\tresp = []\\n\\t\\tself.spi.transfer([0x30], [0x00], 1)\\n\\t\\ttime.sleep(10e-3)\\n\\t\\tfor i in range(62):\\n\\t\\t\\trb = [0x00]\\n\\t\\t\\tself.spi.transfer([0x00], rb, 1)\\n\\t\\t\\tif rb[0] < 0:\\n\\t\\t\\t\\trb[0] += 256\\n\\t\\t\\tresp.append(rb[0])\\n\\t\\t\\n\\t\\tself._hist_dict['bin0'] = _16bit_unsigned(resp[0], resp[1])\\n\\t\\tself._hist_dict['bin1'] = _16bit_unsigned(resp[2], resp[3])\\n\\t\\tself._hist_dict['bin2'] = _16bit_unsigned(resp[4], resp[5])\\n\\t\\tself._hist_dict['bin3'] = _16bit_unsigned(resp[6], resp[7])\\n\\t\\tself._hist_dict['bin4'] = _16bit_unsigned(resp[8], resp[9])\\n\\t\\tself._hist_dict['bin5'] = _16bit_unsigned(resp[10], resp[11])\\n\\t\\tself._hist_dict['bin6'] = _16bit_unsigned(resp[12], resp[13])\\n\\t\\tself._hist_dict['bin7'] = _16bit_unsigned(resp[14], resp[15])\\n\\t\\tself._hist_dict['bin8'] = _16bit_unsigned(resp[16], resp[17])\\n\\t\\tself._hist_dict['bin9'] = _16bit_unsigned(resp[18], resp[19])\\n\\t\\tself._hist_dict['bin10'] = _16bit_unsigned(resp[20], resp[21])\\n\\t\\tself._hist_dict['bin11'] = _16bit_unsigned(resp[22], resp[23])\\n\\t\\tself._hist_dict['bin12'] = _16bit_unsigned(resp[24], resp[25])\\n\\t\\tself._hist_dict['bin13'] = _16bit_unsigned(resp[26], resp[27])\\n\\t\\tself._hist_dict['bin14'] = _16bit_unsigned(resp[28], resp[29])\\n\\t\\tself._hist_dict['bin15'] = _16bit_unsigned(resp[30], resp[31])\\n\\n\\t\\tself._hist_dict['bin1_MToF'] = _calculate_mtof(resp[32])\\n\\t\\tself._hist_dict['bin3_MToF'] = _calculate_mtof(resp[33])\\n\\t\\tself._hist_dict['bin5_MToF'] = _calculate_mtof(resp[34])\\n\\t\\tself._hist_dict['bin7_MToF'] = _calculate_mtof(resp[35])\\n\\n\\t\\tself._hist_dict['sfr'] = _calculate_float(resp[36:40])\\t\\t## Sample flow rate\\n\\n\\t\\t## Alright, we don't know whether it is temp or pressure since it switches...\\n\\t\\ttmp = _calculate_pressure(resp[40:44])\\n\\t\\tif tmp > 98000:\\n\\t\\t\\tself._hist_dict['temperature'] = None\\n\\t\\t\\tself._hist_dict['pressure'] = tmp\\n\\t\\telse:\\n\\t\\t\\ttmp = _calculate_temp(resp[40:44])\\n\\t\\t\\tif tmp < 500:\\n\\t\\t\\t\\tself._hist_dict['temperature'] = tmp\\n\\t\\t\\t\\tself._hist_dict['pressure'] = None\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself._hist_dict['temperature'] = None\\n\\t\\t\\t\\tself._hist_dict['pressure'] = None\\n\\n\\t\\tself._hist_dict['period'] = _calculate_float(resp[44:48])\\t\\t## Sampling period\\n\\n\\t\\tself._hist_dict['checksum'] = _16bit_unsigned(resp[48], resp[49])\\n\\n\\t\\tself._hist_dict['PM1'] = _calculate_float(resp[50:54])\\n\\t\\tself._hist_dict['PM2.5'] = _calculate_float(resp[54:58])\\n\\t\\tself._hist_dict['PM10'] = _calculate_float(resp[58:])\\n\\n\\t\\t## Calculate the sum of the histogram bins\\n\\t\\thistogram_sum = self._hist_dict['bin0'] + self._hist_dict['bin1'] + self._hist_dict['bin2'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin3'] + self._hist_dict['bin4'] + self._hist_dict['bin5'] + self._hist_dict['bin6'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin7'] + self._hist_dict['bin8'] + self._hist_dict['bin9'] + self._hist_dict['bin10'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin11'] + self._hist_dict['bin12'] + self._hist_dict['bin13'] + self._hist_dict['bin14'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin15']\\n\\n\\t\\t## Check that checksum and the least significant bits of the sum of histogram bins are equivilant\\n\\t\\tif (histogram_sum & 0x0000FFFF) != self._hist_dict['checksum']:\\n\\t\\t\\tprint(f\\\"[{self.__class__.__name__}::histogram] CHECKSUM ERROR: Data transfer was incomplete\\\")\\n\\t\\t\\treturn None\\n\\n\\t\\t## If number_concentration flag is set, convert histogram values to number concentration\\n\\t\\tif number_concentration is True:\\n\\t\\t\\t_conv_ = self._hist_dict['sfr'] * self._hist_dict['period'] \\t## Divider in units of ml (cc)\\n\\n\\t\\t\\tself._hist_dict['bin0'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin1'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin2'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin3'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin4'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin5'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin6'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin7'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin8'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin9'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin10'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin11'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin12'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin13'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin14'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin15'] /= _conv_\\n\\n\\t\\ttime.sleep(0.1)\\n\\t\\treturn self._hist_dict\",\n \"def extract_histogram(self, bins=10):\\n assert len(self.images) > 0, 'No images loaded! Did you call ' \\\\\\n 'load_images() ?'\\n histograms = []\\n for image in self.images:\\n grey = skicol.rgb2gray(image)\\n hist_values, bins = np.histogram(grey, range=(0, 1), bins=bins)\\n histograms.append(hist_values)\\n histograms = np.array(histograms)\\n histograms = histograms.astype('float')\\n return histograms\",\n \"def make_histogram(points, bucket_size):\\n return Counter(bucketize(point, bucket_size) for point in points)\",\n \"def make_histogram(points, bucket_size):\\n return Counter(bucketize(point, bucket_size) for point in points)\",\n \"def calculate_histogram(self, abstract_features_1, abstract_features_2):\\n scores = torch.mm(abstract_features_1, abstract_features_2).detach()\\n scores = scores.view(-1, 1)\\n hist = torch.histc(scores, bins=self.args.bins)\\n hist = hist/torch.sum(hist)\\n hist = hist.view(1, -1)\\n return hist\",\n \"def produceHist(self, start=None, end=None, period=24 * 3600):\\n self.sort()\\n if len(self) == 0:\\n return\\n if start is None:\\n start = UTC(self[0].datetime.date)\\n if end is None:\\n end = UTC(self[-1].datetime)\\n entries = int((end - start) / period) + 1\\n hist_list = np.zeros(entries)\\n mag_list = np.zeros(entries)\\n for event in self:\\n #date = UTC(event.datetime.date)\\n entry = int((event.datetime - start) / period)\\n print entry\\n try:\\n hist_list[entry] += 1\\n mag_list[entry] = max(event.magnitude, mag_list[entry])\\n except IndexError:\\n pass\\n return hist_list, mag_list\",\n \"def fullhistogram(img):\\n maxt = img.max()\\n if maxt == 0:\\n return np.array([img.size])\\n return nhistogram(img, np.arange(maxt+2))[0]\",\n \"def test_histogramdd(device):\\n torch.manual_seed(0)\\n\\n # set up\\n N = 1000\\n bins = 20\\n\\n x_data = torch.rand(N, device=device)\\n y_data = torch.rand(N, device=device)\\n\\n # all values inside\\n epsilon = 1e-6\\n x_edges = torch.linspace(\\n x_data.min() - epsilon, x_data.max() + epsilon, steps=bins + 1, device=device\\n )\\n y_edges = torch.linspace(\\n y_data.min() - epsilon, y_data.max() + epsilon, steps=bins + 1, device=device\\n )\\n\\n # run\\n sample = torch.stack((x_data, y_data))\\n\\n torch_hist, _ = histogramdd(sample, bins=(x_edges, y_edges))\\n\\n numpy_hist, _, _ = numpy.histogram2d(\\n x_data.cpu().numpy(),\\n y_data.cpu().numpy(),\\n bins=(x_edges.cpu().numpy(), y_edges.cpu().numpy()),\\n )\\n\\n # compare\\n torch_hist = torch_hist.cpu().int()\\n numpy_hist = torch.from_numpy(numpy_hist).int()\\n\\n assert torch.allclose(torch_hist, numpy_hist)\",\n \"def getHistogram(self, copy: bool=True):\\n for item in self.getPlotWidget().getItems():\\n if item.getName() == 'histogram':\\n return (item.getValueData(copy=copy),\\n item.getBinEdgesData(copy=copy))\\n else:\\n return None\",\n \"def dp_hist ( data, num_bins=10, epsilon=1.0, delta=0.1, histtype = 'continuous' ):\\n\\n import numpy as np\\n\\n if epsilon < 0.0:\\n print('ERROR: Epsilon should be positive.')\\n return\\n elif delta < 0.0 or delta > 1.0:\\n print('ERROR: Delta should be bounded in [0,1].')\\n return\\n else:\\n if histtype == 'discrete':\\n num_bins = len( np.unique(data) )\\n hist_counts = [0] * num_bins\\n data_min = min(data)\\n data_max = max(data)\\n bin_edges = np.linspace(data_min, data_max, num_bins+1)\\n interval = (data_max - data_min) + 0.000000000001\\n \\n for kk in data:\\n loc = (kk - data_min) / interval\\n index = int(loc * num_bins)\\n hist_counts[index] += 1.0\\n\\n if delta==0:\\n noise = np.random.laplace(loc = 0, scale = 1.0/epsilon, size = (1,len(hist_counts)))\\n else:\\n sigma = (1.0/epsilon)*np.sqrt(2*np.log(1.25/delta))\\n noise = np.random.normal(0.0, sigma, len(hist_counts))\\n\\n hist_array=np.asarray(hist_counts)\\n noise_array=np.asarray(noise)\\n dp_hist_counts = hist_array+noise_array\\n\\n return ( dp_hist_counts, bin_edges )\",\n \"def histogram(self):\\r\\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\\r\\n\\r\\n #create a window, the reference must be stored, because the window\\r\\n #gets destroyed when its reference is garbage collected\\r\\n #make plotWindow a list and append to that if multiple windows should be possible\\r\\n title = \\\"histogram of {:s} channel\\\".format(self.ui.channel_selection.currentText())\\r\\n self.plotWindow = pyguitools.SimplePlotWindow(name = title)\\r\\n self.plotWindow.ax1.hist(self.npImg[self.ui.y0.value():self.ui.y1.value(),\\r\\n self.ui.x0.value():self.ui.x1.value(), \\r\\n channel].flatten(),\\r\\n bins=self.settings[\\\"histogramm bins\\\"],\\r\\n range=(self.settings[\\\"histogramm min\\\"],self.settings[\\\"histogramm max\\\"]))\\r\\n self.plotWindow.ax1.set_xlim(self.settings[\\\"histogramm min\\\"],self.settings[\\\"histogramm max\\\"]) \\r\\n self.plotWindow.show()\",\n \"def histogram(self, table, **kwargs):\\n kwargs = self._preprocess(**kwargs) # pylint: disable=protected-access\\n with Session() as lib:\\n file_context = lib.virtualfile_from_data(check_kind=\\\"vector\\\", data=table)\\n with file_context as infile:\\n arg_str = \\\" \\\".join([infile, build_arg_string(kwargs)])\\n lib.call_module(\\\"histogram\\\", arg_str)\",\n \"def test_make_histograms(self):\\r\\n raw_lengths = [90, 100, 110, 110, 130, 135]\\r\\n pre_lengths = [100, 110, 105, 130, 135]\\r\\n post_lengths = [130, 135]\\r\\n raw_hist, pre_hist, post_hist, bin_edges = \\\\\\r\\n make_histograms(raw_lengths, pre_lengths, post_lengths)\\r\\n assert_almost_equal(pre_hist, array([0, 2, 1, 0, 2]))\\r\\n assert_almost_equal(post_hist, array([0, 0, 0, 0, 2]))\\r\\n assert_almost_equal(bin_edges, array([90, 100, 110, 120, 130, 140]))\",\n \"def histogram(f, option=\\\"uint16\\\"):\\n from numpy import searchsorted, sort, ravel, concatenate, product\\n\\n n = searchsorted(sort(ravel(f)), range(f.max()+1))\\n n = concatenate([n, [product(f.shape)]])\\n h = n[1:]-n[:-1]\\n return h\",\n \"def hist(self, bins=\\\"unit\\\", closed=\\\"left\\\", stat=\\\"sum\\\"):\\n return self.dist.hist(bins=bins, closed=closed, stat=stat)\",\n \"def histogram(self, data, global_step, bins=1000, tag='histogram'):\\n\\n data = np.array(data)\\n\\n # Create histogram using numpy\\n counts, bin_edges = np.histogram(data, bins=bins)\\n\\n # Fill fields of histogram proto\\n hist = tf.HistogramProto()\\n hist.min = float(np.min(data))\\n hist.max = float(np.max(data))\\n hist.num = int(np.prod(data.shape))\\n hist.sum = float(np.sum(data))\\n hist.sum_squares = float(np.sum(data ** 2))\\n\\n # Requires equal number as bins, where the first goes from -DBL_MAX to bin_edges[1]\\n # See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/summary.proto#L30\\n # Thus, we drop the start of the first bin\\n bin_edges = bin_edges[1:]\\n\\n # Add bin edges and counts\\n for edge in bin_edges:\\n hist.bucket_limit.append(edge)\\n for c in counts:\\n hist.bucket.append(c)\\n\\n # Create and write Summary\\n summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])\\n self.summary_writer.add_summary(summary, global_step)\\n self.summary_writer.flush()\",\n \"def _histogram(image,\\n min,\\n max,\\n bins):\\n\\n return numpy.histogram(image, bins, (min, max))[0]\",\n \"def normalize_hist(hist) -> [float]:\\n hsum = np.sum(hist)\\n newhist = []\\n for hi in hist:\\n newhist.append(hi/hsum)\\n\\n return newhist\",\n \"def histograms(probs, actual, bins=100):\\n actual = actual.astype(np.bool)\\n edges, step = np.linspace(0., 1., bins, retstep=True, endpoint=False)\\n idx = np.digitize(probs, edges) - 1\\n top = np.bincount(idx, weights=actual, minlength=bins)\\n bot = np.bincount(idx, weights=(~actual), minlength=bins)\\n return top, bot, edges, step\",\n \"def arelfreq(a,numbins=10,defaultreallimits=None):\\r\\n h,l,b,e = histogram(a,numbins,defaultreallimits)\\r\\n h = N.array(h/float(a.shape[0]))\\r\\n return h,l,b,e\",\n \"def equalise_hist(image, bin_count=256):\\n # TODO: your histogram equalization code\\n #define arrays\\n image = img_as_ubyte(image)\\n row,col = image.shape\\n new_image = np.zeros((row,col),dtype='uint8') \\n\\n # compute the value of each grayscale,and save in image_hist \\n image_hist = np.bincount(image.flatten(), minlength=(bin_count))\\n\\n # normalise n[]\\n norm_arr = (np.cumsum(image_hist)/(image.size))*(bin_count-1)\\n norm_arr = norm_arr.astype('uint8')\\n \\n #Compute a normalized cumulative histogram\\n for x in range(row):\\n for y in range(col):\\n new_image[x,y] = norm_arr[image[x,y]]\\n \\n return new_image\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73119396","0.7298664","0.72432923","0.7087078","0.70734334","0.7008626","0.69554347","0.6877622","0.6859786","0.6762288","0.6739682","0.6714061","0.6659528","0.6620292","0.6579403","0.657029","0.65458226","0.6535959","0.6534714","0.6524735","0.6502923","0.6501256","0.6478444","0.64760584","0.6471867","0.6469994","0.646217","0.6430884","0.6400605","0.6400493","0.63960737","0.63918245","0.6379196","0.6369984","0.63570046","0.63407886","0.63366824","0.6336231","0.6334787","0.6332182","0.6321834","0.6317509","0.6308188","0.63026774","0.6289841","0.6285849","0.62735575","0.627251","0.6264091","0.6257991","0.6250698","0.62485945","0.6247001","0.6245256","0.6240385","0.6234251","0.6227434","0.622694","0.6223712","0.6217535","0.6198397","0.619805","0.6195292","0.6194873","0.6194194","0.61933297","0.6188666","0.6186918","0.61839205","0.6183619","0.61794317","0.6164481","0.6147716","0.6144833","0.61440116","0.6130364","0.61282253","0.61272734","0.6125459","0.6113672","0.6111635","0.61075485","0.6104572","0.6104572","0.6101622","0.6097892","0.60935664","0.60865635","0.60803336","0.6068449","0.6068167","0.60669416","0.6066868","0.60663766","0.6062474","0.60616773","0.60611254","0.60596424","0.60510457","0.60491735","0.6044977"],"string":"[\n \"0.73119396\",\n \"0.7298664\",\n \"0.72432923\",\n \"0.7087078\",\n \"0.70734334\",\n \"0.7008626\",\n \"0.69554347\",\n \"0.6877622\",\n \"0.6859786\",\n \"0.6762288\",\n \"0.6739682\",\n \"0.6714061\",\n \"0.6659528\",\n \"0.6620292\",\n \"0.6579403\",\n \"0.657029\",\n \"0.65458226\",\n \"0.6535959\",\n \"0.6534714\",\n \"0.6524735\",\n \"0.6502923\",\n \"0.6501256\",\n \"0.6478444\",\n \"0.64760584\",\n \"0.6471867\",\n \"0.6469994\",\n \"0.646217\",\n \"0.6430884\",\n \"0.6400605\",\n \"0.6400493\",\n \"0.63960737\",\n \"0.63918245\",\n \"0.6379196\",\n \"0.6369984\",\n \"0.63570046\",\n \"0.63407886\",\n \"0.63366824\",\n \"0.6336231\",\n \"0.6334787\",\n \"0.6332182\",\n \"0.6321834\",\n \"0.6317509\",\n \"0.6308188\",\n \"0.63026774\",\n \"0.6289841\",\n \"0.6285849\",\n \"0.62735575\",\n \"0.627251\",\n \"0.6264091\",\n \"0.6257991\",\n \"0.6250698\",\n \"0.62485945\",\n \"0.6247001\",\n \"0.6245256\",\n \"0.6240385\",\n \"0.6234251\",\n \"0.6227434\",\n \"0.622694\",\n \"0.6223712\",\n \"0.6217535\",\n \"0.6198397\",\n \"0.619805\",\n \"0.6195292\",\n \"0.6194873\",\n \"0.6194194\",\n \"0.61933297\",\n \"0.6188666\",\n \"0.6186918\",\n \"0.61839205\",\n \"0.6183619\",\n \"0.61794317\",\n \"0.6164481\",\n \"0.6147716\",\n \"0.6144833\",\n \"0.61440116\",\n \"0.6130364\",\n \"0.61282253\",\n \"0.61272734\",\n \"0.6125459\",\n \"0.6113672\",\n \"0.6111635\",\n \"0.61075485\",\n \"0.6104572\",\n \"0.6104572\",\n \"0.6101622\",\n \"0.6097892\",\n \"0.60935664\",\n \"0.60865635\",\n \"0.60803336\",\n \"0.6068449\",\n \"0.6068167\",\n \"0.60669416\",\n \"0.6066868\",\n \"0.60663766\",\n \"0.6062474\",\n \"0.60616773\",\n \"0.60611254\",\n \"0.60596424\",\n \"0.60510457\",\n \"0.60491735\",\n \"0.6044977\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83794,"cells":{"query":{"kind":"string","value":"Given a dataset, find the optimal threshold for quantizing it. The reference distribution is `q`, and the candidate distribution is `p`. `q` is a truncated version of the original distribution."},"document":{"kind":"string","value":"def get_entropy_threshold(self, histogram, num_quantized_bins):\n import copy\n\n from scipy.stats import entropy\n\n hist = histogram[0]\n hist_edges = histogram[1]\n num_bins = hist.size\n zero_bin_index = num_bins // 2\n num_half_quantized_bin = num_quantized_bins // 2\n\n kl_divergence = np.zeros(zero_bin_index - num_half_quantized_bin + 1)\n thresholds = [(0, 0) for i in range(kl_divergence.size)]\n\n # <------------ num bins ---------------->\n # <--- quantized bins ---->\n # |======|===========|===========|=======|\n # zero bin index\n # ^ ^\n # | |\n # start index end index (start of iteration)\n # ^ ^\n # | |\n # start index end index ...\n # ^ ^\n # | |\n # start index end index (end of iteration)\n\n for i in range(num_half_quantized_bin, zero_bin_index + 1, 1):\n start_index = zero_bin_index - i\n end_index = zero_bin_index + i + 1 if (zero_bin_index + i + 1) <= num_bins else num_bins\n\n thresholds[i - num_half_quantized_bin] = (\n float(hist_edges[start_index]),\n float(hist_edges[end_index]),\n )\n\n sliced_distribution = copy.deepcopy(hist[start_index:end_index])\n\n # reference distribution p\n p = sliced_distribution.copy() # a copy of np array\n left_outliers_count = sum(hist[:start_index])\n right_outliers_count = sum(hist[end_index:])\n p[0] += left_outliers_count\n p[-1] += right_outliers_count\n\n # nonzeros[i] incidates whether p[i] is non-zero\n nonzeros = (p != 0).astype(np.int64)\n\n # quantize p.size bins into quantized bins (default 128 bins)\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int64)\n num_merged_bins = sliced_distribution.size // num_quantized_bins\n\n # merge bins into quantized bins\n for index in range(num_quantized_bins):\n start = index * num_merged_bins\n end = start + num_merged_bins\n quantized_bins[index] = sum(sliced_distribution[start:end])\n quantized_bins[-1] += sum(sliced_distribution[num_quantized_bins * num_merged_bins :])\n\n # in order to compare p and q, we need to make length of q equals to length of p\n # expand quantized bins into p.size bins\n q = np.zeros(p.size, dtype=np.int64)\n for index in range(num_quantized_bins):\n start = index * num_merged_bins\n end = start + num_merged_bins\n\n norm = sum(nonzeros[start:end])\n if norm != 0:\n q[start:end] = float(quantized_bins[index]) / float(norm)\n\n p = smooth_distribution(p)\n q = smooth_distribution(q)\n\n if isinstance(q, np.ndarray):\n kl_divergence[i - num_half_quantized_bin] = entropy(p, q)\n else:\n kl_divergence[i - num_half_quantized_bin] = float(\"inf\")\n\n min_kl_divergence_idx = np.argmin(kl_divergence)\n optimal_threshold = thresholds[min_kl_divergence_idx]\n min_value = histogram[2]\n max_value = histogram[3]\n if optimal_threshold[0] < min_value:\n optimal_threshold = (min_value, optimal_threshold[1])\n if optimal_threshold[1] > max_value:\n optimal_threshold = (optimal_threshold[0], max_value)\n return optimal_threshold"},"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 Quantile(data, q, precision=1.0):\n N, bins = np.histogram(data, bins=precision*np.sqrt(len(data)))\n norm_cumul = 1.0*N.cumsum() / len(data)\n\n for i in range(0, len(norm_cumul)):\n if norm_cumul[i] > q:\n return bins[i]","def data_quality(dset):\n dq_threshold = config.tech[_SECTION].threshold.int\n return np.nan_to_num(dset.data_quality) <= dq_threshold","def top_quantile_positive_constraint(x: Tensor, q: float, bias: float = 0.1) -> Tensor:\n\n if x.dim() != 2:\n raise ValueError(\n f'operation only supported for 2D tensors (got {x.dim()}D).'\n )\n\n if not (0. <= q <= 1.):\n raise ValueError(\n f'`q` must be in range [0, 1] but is {q}.'\n )\n\n if q == 0.:\n return torch.relu(-x.max(dim=1)[0]).mean() + bias\n if q == 1.:\n return positive_constraint(x, bias=bias)\n else:\n k = int(q * x.size(1))\n return torch.relu(-x.topk(k, dim=1)[0]).mean() + bias","def kernel_quantile_heuristic(X, q=0.5):\n pairwise_sq_dists = pdist(X, 'sqeuclidean')\n quantile_heuristic_s2 = np.quantile(pairwise_sq_dists, q=q)\n return quantile_heuristic_s2","def KB_Dist(P,Q):\r\n \r\n \r\n K=0\r\n Epsilon=0.000001\r\n Q+=Epsilon\r\n P+=Epsilon\r\n for x in range(len(Q)):\r\n K-=P[x]*np.log(Q[x]/P[x])\r\n return K","def target_distribution(q):\n weight = q ** 2 / q.sum(0)\n return (weight.T / weight.sum(1)).T","def threshold_func(distribution: List[float], alpha: List[float], **kwargs) -> float:\n threshold = np.quantile(distribution, q=alpha, interpolation=\"lower\", **kwargs)\n return threshold","def quality(X, boost=2):\n X = np.abs(np.sort(X, axis=-1).astype(float))\n Q = 1 - np.log(2 + X[..., -2]) / np.log(2 + X[..., -1])\n Q = (Q * 2).clip(0, 1)\n return Q","def find_quant(trainy, train_tree_node_ID, pred_tree_node_ID, qntl):\n npred = pred_tree_node_ID.shape[0]\n out = np.zeros((npred, qntl.size))*np.nan\n for i in prange(pred_tree_node_ID.shape[0]):\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\n sample = trainy[idxs]\n out[i, :] = np.quantile(sample, qntl)\n return out","def quantile(xs: List[float], p: float) -> float:\n p_index = int(p * len(xs))\n return sorted(xs)[p_index]","def quantile(x, p):\n sorted_x = sorted(x)\n # round p_index to base int\n p_index = int(p * len(x))\n return sorted_x[p_index]","def quality_threshold_value(vals: list, q_factor=1):\n s = list(sorted(vals))\n keep_up_too = int(np.ceil(len(vals) * q_factor))\n thresh_index = len(vals) - keep_up_too\n return s[thresh_index]","def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\n if not isinstance(arr, np.ndarray):\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\n ' while received type=%s' % (str(type(arr))))\n min_val = np.min(arr)\n max_val = np.max(arr)\n th = max(abs(min_val), abs(max_val))\n\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\n zero_bin_idx = num_bins // 2\n num_half_quantized_bins = num_quantized_bins // 2\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\n 0, rtol=1e-5, atol=1e-7)\n\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\n divergence = np.zeros_like(thresholds)\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\n # i means the number of bins on half axis excluding the zero bin.\n for i in range(num_quantized_bins // 2,\n num_bins // 2 + 1):\n p_bin_idx_start = zero_bin_idx - i\n p_bin_idx_stop = zero_bin_idx + i + 1\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\n\n # generate reference distribution p\n p = sliced_nd_hist.copy()\n assert p.size % 2 == 1\n assert p.size >= num_quantized_bins\n # put left outlier count in p[0]\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\n p[0] += left_outlier_count\n # put right outlier count in p[-1]\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\n p[-1] += right_outlier_count\n # is_nonzeros[k] indicates whether hist[k] is nonzero\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\n\n # calculate how many bins should be merged to generate quantized distribution q\n num_merged_bins = p.size // num_quantized_bins\n # merge hist into num_quantized_bins bins\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n stop = start + num_merged_bins\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\n # expand quantized_bins into p.size bins\n q = np.zeros(p.size, dtype=np.float32)\n for j in range(num_quantized_bins):\n start = j * num_merged_bins\n if j == num_quantized_bins - 1:\n stop = -1\n else:\n stop = start + num_merged_bins\n norm = is_nonzeros[start:stop].sum()\n if norm != 0:\n q[start:stop] = float(quantized_bins[j]) / float(norm)\n q[sliced_nd_hist == 0] = 0\n p = _smooth_distribution(p)\n # There is a chance that q is an invalid probability distribution.\n try:\n q = _smooth_distribution(q)\n except ValueError:\n divergence[i - num_half_quantized_bins] = float(\"inf\")\n else:\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\n quantized_bins[:] = 0\n\n min_divergence_idx = np.argmin(divergence)\n min_divergence = divergence[min_divergence_idx]\n opt_th = thresholds[min_divergence_idx]\n return min_val, max_val, min_divergence, opt_th","def quantile(self, q: float) -> np.array:\n assert 0 <= q <= 1\n return np.array(\n list(\n chain.from_iterable(\n model.predict(self.featurized_data, q)\n for model in self.models\n )\n )\n )","def cmf_find_quantile_index(a, q):\n return jnp.argmax(a >= q)","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def genQuality(self):\n return np.clip(np.random.normal(self.qavgs, self.qstdevs), 0, 40)","def q_criterion(a):\n print(\"Detection method: Q criterion\")\n Q = np.zeros((a.u.shape[0], a.u.shape[1]))\n print(a.u.shape[0], a.u.shape[1])\n #print(Q.shape)\n for i in range(a.u.shape[0]):\n for j in range(a.u.shape[1]):\n Q[i, j] = -0.5*(a.derivative['dudx'][i, j]**2 + a.derivative['dvdy'][i, j]**2) \\\n - a.derivative['dudy'][i, j] * a.derivative['dvdx'][i, j]\n return Q","def dist(p, q):\n return ((p[0] - q[0])**2 + (p[1] - q[1])**2 + (p[2] - q[2])**2)**0.5","def find_threshold(labels, predictions, wqs, post_shift):\n if post_shift:\n sorted_groups = []\n for q in range(1, 5):\n sorted_group = sorted(\n [(prediction[0], label)\n for (prediction, label, wq) in zip(predictions, labels, wqs)\n if wq == q],\n reverse=True)\n sorted_groups.append(sorted_group)\n\n cut_indices = [\n int(len(sorted_group) * COVERAGE) for sorted_group in sorted_groups\n ]\n\n for _ in range(1000):\n fprs = [\n get_fpr(sorted_group, cut_index)\n for (sorted_group, cut_index) in zip(sorted_groups, cut_indices)\n ]\n min_fpr_index = np.argmin(fprs)\n max_fpr_index = np.argmax(fprs)\n cut_indices[min_fpr_index] = min(cut_indices[min_fpr_index] + 1,\n len(sorted_groups[min_fpr_index]))\n cut_indices[max_fpr_index] = max(cut_indices[max_fpr_index] - 1, 0)\n\n thresholds = [sorted_groups[q][cut_indices[q]][0] for q in range(4)]\n return thresholds\n else:\n return [np.percentile(predictions, 100 - COVERAGE * 100)] * 4","def predict_qs(self, data):\n\n if data['p_gs'] == 0 or data['p_g'] == 0:\n return data\n\n er = data['p_er']\n gs = data['p_gs']\n gp = data['p_g']\n ip = data['p_ip']\n\n a = (gs / (er * (gs / gp)))\n b = ip * (gs / gp)\n c = ((gs + gp) / (gp * 2))**2\n\n data['p_qs'] = (a * b * c) / 4.11556\n return data","def find_optimal_Q(x, y, data, min_Q, max_Q, fs=1., added_kernel = None, plot_BIC=True):\n Qs= np.arange(min_Q, max_Q)\n BIC = np.zeros((Qs.shape[0]))\n \n for i, q in enumerate(Qs):\n sm = SpectralMixture(q, x=x.flatten(),y=y.flatten(),fs=fs)\n for k in sm.kernels:\n if isinstance(k, SpectralMixtureComponent):\n k.lengthscale.prior = tfd.Gamma(f64(8.), f64(.6)) \n k.mixture_weight.prior = tfd.Gamma(f64(2.), f64(1.))\n\n if added_kernel is not None:\n sm += added_kernel\n \n# model = models.ContinuousModel(sm, (util.ensure_tf_matrix(x),util.ensure_tf_matrix(y)))\n model = models.ContinuousModel(sm, data)\n model.train(verbose=False)\n BIC[i] = model.log_posterior_density(\"bic\").numpy()\n \n if plot_BIC:\n fig = plt.figure()\n plt.plot(Qs, BIC)\n plt.xlabel('Number of Spectral Mixture components (Q)')\n plt.show()\n\n return np.argmax(BIC) + min_Q","def quantile(x,p):\n p_index = int(p*len(x))\n return sorted(x)[p_index]","def find_optimal_threshold(self, hist):\n\n # print(\"number of pixels using sum: \", sum(hist))\n probability = np.array((1/sum(hist))*hist)\n expected_value = probability*np.array(range(256))\n # print(\"probability: \\n\", probability)\n # print(\"expected_value: \\n\", expected_value)\n\n threshold = len(hist)/2\n temp_threshold = 0\n\n while abs(threshold - temp_threshold) > 0.001:\n temp1 = []\n temp2 = []\n print(\"New threshold: \", threshold)\n for i in range(len(hist)):\n if i < threshold:\n temp1.append(expected_value[i])\n else:\n temp2.append(expected_value[i])\n mean1 = sum(temp1)\n print(\"mean1: \\n\", mean1)\n mean2 = sum(temp2)\n print(\"mean2: \\n\", mean2)\n temp_threshold = threshold\n threshold = (mean1+mean2)/2\n print(\"threshold: \", threshold)\n print(\"temp_threshold: \", temp_threshold)\n\n return threshold","def quantization(self, data):\n self._check_input_len(data)\n winners_coords = argmin(self._distance_from_weights(data), axis=1)\n return self._weights[unravel_index(winners_coords,\n self._weights.shape[:2])]","def cost(P, Q):\n Q = np.where(Q != 0, Q, 1e-12)\n P = np.where(P != 0, P, 1e-12)\n Div = P / Q\n C = np.sum(P * np.log(Div))\n return C","def decision_problem(P, Q, p, q, eps, mdist, P_dist, Q_dist):\n LF, BF = LF_BF(P, Q, p, q, eps, mdist, P_dist, Q_dist)\n rep, _, _ = LR_BR(LF, BF, p, q)\n return rep","def get_percentile(self, q):\n return None","def get_percentile(self, q):\n return None","def qt(q, df=1, loc=0, scale=1, ncp=None, lowertail=True, log=False):\n # ==========================================================================\n if log:\n raise NotImplementedError(\"Log option is not implemented yet.\")\n elif lowertail:\n return t.ppf(q=q, df=df, loc=loc, scale=scale)\n else:\n return t.isf(q=q, df=df, loc=loc, scale=scale)","def find_optimal_threshold(self, hist):\n k = 256\n threshold = int(k / 2)\n lastexpected1 = lastexpected2 = 0\n\n while True:\n expected1 = expected2 = 0\n t_exp1 = sum(hist[:threshold])\n t_exp2 = sum(hist[threshold:])\n for i in range(threshold):\n expected1 += (hist[i] / t_exp1) * i\n\n for i in range(threshold, k):\n expected2 += (hist[i] / t_exp2) * i\n\n threshold = (expected1 + expected2) / 2\n if abs(expected1 - lastexpected1) != 0 and abs(expected2 - lastexpected2) != 0:\n break\n lastexpected1 = expected1\n lastexpected2 = expected2\n # print(expected2, expected1)\n return threshold","def prob_choice(p):\n \n return np.random.random_sample() < p","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def percentile(t: torch.tensor, q: float):\n # Note that ``kthvalue()`` works one-based, i.e. the first sorted value\n # indeed corresponds to k=1, not k=0! Use float(q) instead of q directly,\n # so that ``round()`` returns an integer, even if q is a np.float32.\n k = 1 + round(.01 * float(q) * (t.numel() - 1))\n result = t.view(-1).kthvalue(k).values.item()\n return result","def quantiles(self, q: int):\n return self.dist.quantiles(q)","def default_quantile():\n return np.logspace(-5, 0, 100)","def dist(p,q):\n return math.sqrt((p[0] - q[0]) ** 2+(p[1] - q[1]) ** 2)","def find_best_threshold(y, y_hat, step_size, score_func, maximize=True):\n best_thres, best_score = 0.0, 0.0 if maximize else 1.0\n for thres in np.arange(0, 1, step_size):\n score = score_for_threshold(y, y_hat, score_func, thres)\n if (maximize and (score > best_score)) or (not maximize and (score < best_score)):\n best_score = score\n best_thres = thres\n\n return best_thres, best_score","def reproducibility_from_fisher(disdf, samplesizes, qthresh):\n\n ## Turn disdf into tidy dataframe\n longpvals = copy.deepcopy(disdf)\n longpvals['otu'] = longpvals.index\n longpvals = pd.melt(longpvals, id_vars='otu',\n value_name='p', var_name='study')\n\n ## Convert two-tailed signed p-values into one-tailed pvalues\n longpvals = convert_to_one_tailed(longpvals).dropna()\n longpvals = pd.melt(longpvals, id_vars=['otu', 'study'],\n value_vars=['p-dis', 'p-h'], var_name='pval_direction')\n\n ## Add sample size for each study\n longpvals['sample_size'] = \\\n longpvals.apply(lambda row: samplesizes.loc[row['study'], 'total'],\n axis=1)\n\n ## Get the combined p-value using weighted stouffer's method\n metap = []\n for grp, subdf in longpvals.groupby(['otu', 'pval_direction']):\n # Only consider genera which are in more than one study\n if subdf.shape[0] > 1:\n # grp is the tuple that defines the group: (otu, direction)\n direction = grp[1]\n otu = grp[0]\n numstudies = subdf.shape[0]\n # Stouffer's weight z-score test\n z, p = combine_pvalues(subdf['value'].astype(float),\n method='stouffer',\n weights=subdf['sample_size'].apply(np.sqrt))\n metap.append([otu, direction, z, p, numstudies])\n metap = pd.DataFrame(metap, columns=['otu', 'direction', 'z', 'p', 'num_studies'])\n\n ## Count number of significant healthy and disease bugs\n # Note that from manual inspection, it doesn't look like any genera\n # are returned as significant in both directions from this method...\n sig_h = metap.query('direction == \"p-h\"').query('p < @qthresh')\n sig_dis = metap.query('direction == \"p-dis\"').query('p < @qthresh')\n\n return sig_h.shape[0] + sig_dis.shape[0]","def get_percentile(self, q):\n return self.sum_stat_sample_ratio.get_percentile(q)","def var_dist(P, Q, X=alph):\n\n dist = 0.5 * sum([abs(P[x] - Q[x]) for x in X])\n\n return dist","def gp_optimize_threshold(gp_model, X_val, y_val, X_scaler, y_scaler, optimize_for=\"profits\"): \n y_hat, conf = gp_model.predict(X_val)\n regressed_payment = y_scaler.inverse_transform(y_hat).reshape(-1)\n loan_amt = X_scaler.inverse_transform(X_val)[:,0]\n\n # This ratio is a guage of how likely a person will pay back.\n # It is compared with a threshold to determine whether or not to loan.\n payment_to_loan_ratio = regressed_payment / loan_amt\n\n # Sort in descending order\n sorted_ind = np.argsort(-payment_to_loan_ratio)\n sorted_payment_to_loan_ratio = payment_to_loan_ratio[sorted_ind]\n X_sorted, y_sorted = X_val[sorted_ind,:], y_val[sorted_ind]\n\n threshold, highest_opt_val = 0, 0\n for i, thresh in enumerate(sorted_payment_to_loan_ratio): \n X_loanee = X_sorted[:i+1,:]\n y_loanee = y_sorted[:i+1]\n \n loan_amt_loanee = np.sum(X_scaler.inverse_transform(X_loanee)[:,0])\n payments_loanee = np.sum(y_loanee)\n\n # Optimize for different values\n if optimize_for == \"profits\":\n opt_val = payments_loanee - loan_amt_loanee\n elif optimize_for == \"profit_percentage\":\n opt_val = (payments_loanee - loan_amt_loanee) / loan_amt_loanee\n else:\n raise Exception(\"Illegal optimize_for value: %s\" % optimize_for)\n\n # Keep track of highest value (that is being optimized for)\n if opt_val > highest_opt_val:\n threshold = thresh\n highest_opt_val = opt_val\n return threshold","def quantile_corner(x, q, weights=None):\n if weights is None:\n return np.percentile(x, [100. * qi for qi in q])\n else:\n idx = np.argsort(x)\n xsorted = x[idx]\n cdf = np.add.accumulate(weights[idx])\n cdf /= cdf[-1]\n return np.interp(q, cdf, xsorted).tolist()","def compute_optimal_token_minimum(token_counts) -> int:\n q1, q3 = compute_quartiles(token_counts)\n iqr = q3 - q1\n low_threshold = q1 - 1.5 * iqr\n return low_threshold","def find_optimal_threshold(self, hist):\n\n\n threshold = int((len(hist)-1)/2)\n ct = len(hist) - 1\n\n while True:\n if(ct < 1):\n break\n threshold1 = self.evalue(hist,0,threshold)\n threshold2 = self.evalue(hist,threshold,len(hist) - 2)\n nt = int((threshold1+threshold2)/2)\n ct = nt - threshold\n threshold = nt\n\n return threshold","def cross_entropy(p: np.ndarray, q: np.ndarray, eps: float = 1e-10) -> float:\n p = np.asarray(p)\n q = np.asarray(q)\n if p.ndim > 2 or q.ndim > 2:\n raise ValueError(\n f\"Not obvious how to reshape arrays: got shapes {p.shape} and {q.shape}.\"\n )\n elif (p.ndim == 2 and p.shape[0] > 1) or (q.ndim == 2 and q.shape[0] > 1):\n raise ValueError(\n f\"Expected 2-dimensional arrays to have shape (1, *): got shapes \\\n {p.shape} and {q.shape}.\"\n )\n p = p.reshape(-1)\n q = q.reshape(-1)\n if p.shape[0] != q.shape[0]:\n raise ValueError(\n f\"Expected arrays of the same length: got lengths {len(p)} and {len(q)}.\"\n )\n if np.any(p < 0) or np.any(q < 0):\n raise ValueError(\"Arrays must both be non-negative.\")\n if np.isclose(p.sum(), 0) or np.isclose(q.sum(), 0):\n raise ValueError(\"Arrays must both be non-zero.\")\n if not np.isclose(p.sum(), 1):\n p /= p.sum()\n if not np.isclose(q.sum(), 1):\n q /= q.sum()\n cross_entropy_pq = (-p * np.log(q + eps)).sum()\n return cross_entropy_pq","def precomp_threshold(dof, len_sim=1e5, beta=.75):\n for d in dof:\n cdt = GaussianCusum(arl=None, beta=beta)\n cdt.fit(x=np.zeros((1, d)), estimate_threshold=True, len_simulation=len_sim,\n verbose=True, precompute_thresholds=True)","def precomp_threshold(dof, len_sim=1e5, beta=.75):\n for d in dof:\n cdt = GaussianCusum(arl=None, beta=beta)\n cdt.fit(x=np.zeros((1, d)), estimate_threshold=True, len_simulation=len_sim,\n verbose=True, precompute_thresholds=True)","def _threshold(data, sigma=2.0):\r\n return np.mean(data)-sigma*np.sqrt(np.var(data))","def compute_critical_values(P, Q, p, q, mdist, P_dist, Q_dist):\n origin = eucl_dist(P[0], Q[0])\n end = eucl_dist(P[-1], Q[-1])\n end_point = max(origin, end)\n cc = set([end_point])\n for i in range(p - 1):\n for j in range(q - 1):\n Lij = point_to_seg(Q[j], P[i], P[i + 1], mdist[i, j], mdist[i + 1, j], P_dist[i])\n if Lij > end_point:\n cc.add(Lij)\n Bij = point_to_seg(P[i], Q[j], Q[j + 1], mdist[i, j], mdist[i, j + 1], Q_dist[j])\n if Bij > end_point:\n cc.add(Bij)\n return sorted(list(cc))","def get_percentile(self, q):\n return self.sum_stat_sample_delta.get_percentile(q)","def find_q(z, hist_orig):\n gray_levels = np.arange(BITS) # vector of all the gray levels in range [0, 255]\n q = np.zeros(len(z)-1)\n for i in range(len(z)-1):\n # formula from the class\n q[i] = np.sum(gray_levels[z[i]:z[i+1]+1]*hist_orig[z[i]:z[i+1]+1]) / np.sum(hist_orig[z[i]:z[i+1]+1])\n return q.round().astype(np.uint8)","def statistics_from_position(target, data, sigma=1.0):\n from ...algorithms.utils.fast_distance import euclidean_distance as ed\n if data is None:\n if target is None:\n return 0.# could be 1.0 ?\n else:\n return 0.\n if target is None:\n return 0.\n\n dmatrix = ed(data, target) / sigma\n sensitivity = dmatrix.min(0)\n sensitivity = np.exp( - 0.5 * sensitivity ** 2)\n sensitivity = np.mean(sensitivity)\n return sensitivity","def point_dist(p, q):\n\tif len(p) != len(q):\n\t\traise ValueError(\"Lengths don't match\", p, q)\n\treturn math.sqrt(sum((a-b)**2 for a,b in zip(p,q)))","def quantile(a, prob):\n a=numpy.asanyarray(a)\n a=a[numpy.logical_not(numpy.isnan(a))].ravel()\n n=a.size\n\n if prob>=1-.5/n:\n return a.max()\n elif prob<=.5/n:\n return a.min()\n\n # find the two bounds we're interpreting between:\n # that is, find i such that (i+.5) / n <= prob <= (i+1.5)/n\n t=n*prob-.5\n i=int(t)\n\n # partial sort so that the ith element is at position i, with bigger ones\n # to the right and smaller to the left\n a.sort()\n\n if i==t: # did we luck out and get an integer index?\n return a[i]\n else:\n # we'll linearly interpolate between this and the next index\n smaller=a[i]\n larger=a[i+1:].min()\n if numpy.isinf(smaller):\n return smaller # avoid inf - inf\n return smaller+(larger-smaller)*(t-i)","def linear_itp_threshold_func(\n distribution: List[float],\n alpha: List[float],\n **kwargs,\n) -> float:\n\n if len(distribution.shape) > 1:\n # for reference attacks\n threshold = np.quantile(\n distribution, q=alpha[1:-1], method=\"linear\", axis=1, **kwargs\n )\n threshold = np.concatenate(\n [\n threshold,\n np.repeat(distribution.max() + 1e-4, distribution.shape[0]).reshape(\n 1, -1\n ),\n ],\n axis=0,\n )\n threshold = np.concatenate(\n [\n np.repeat(distribution.min() - 1e-4, distribution.shape[0]).reshape(\n 1, -1\n ),\n threshold,\n ],\n axis=0,\n )\n\n else:\n threshold = np.quantile(distribution, q=alpha[1:-1], method=\"linear\", **kwargs)\n threshold = np.concatenate(\n [\n np.array(distribution.min() - 1e-4).reshape(-1),\n threshold,\n np.array(distribution.max() + 1e-4).reshape(-1),\n ],\n axis=0,\n )\n\n return threshold","def distance_to_default(q, *args):\n # weights found with trial and error, get some wrist bend, but not much\n weight = [1, 1, 1.3, 1] \n return np.sqrt(np.sum([(qi - q0i)**2 * wi\n for qi,q0i,wi in zip(q, self.q0, weight)]))","def distance_to_default(q, *args):\n # weights found with trial and error,\n # get some wrist bend, but not much\n weight = [1, 1, 1.3]\n return np.sqrt(np.sum([(qi - q0i)**2 * wi\n for qi, q0i, wi in zip(q, self.q0, weight)]))","def _evaluate_quality(self, fit_data: curve.CurveFitResult) -> Union[str, None]:\n freq_increment = np.mean(np.diff(fit_data.x_data))\n\n fit_a = fit_data.ufloat_params[\"a\"]\n fit_b = fit_data.ufloat_params[\"b\"]\n fit_freq = fit_data.ufloat_params[\"freq\"]\n fit_kappa = fit_data.ufloat_params[\"kappa\"]\n\n snr = abs(fit_a.n) / np.sqrt(abs(np.median(fit_data.y_data) - fit_b.n))\n fit_width_ratio = fit_kappa.n / np.ptp(fit_data.x_data)\n\n criteria = [\n fit_data.x_range[0] <= fit_freq.n <= fit_data.x_range[1],\n 1.5 * freq_increment < fit_kappa.n,\n fit_width_ratio < 0.25,\n fit_data.reduced_chisq < 3,\n curve.utils.is_error_not_significant(fit_kappa),\n snr > 2,\n ]\n\n if all(criteria):\n return \"good\"\n\n return \"bad\"","def KL(p, q):\n return np.sum(p * np.log(p / q))","def get_percentile(self, q):\n raise NotImplementedError(\"This is an abstract method and needs to be implemented in derived classes.\")","def ea_from_q(p, q):\n return p * q / (0.622 + 0.378 * q)","def achisqprob(chisq,df):\r\n BIG = 200.0\r\n def ex(x):\r\n BIG = 200.0\r\n exponents = N.where(N.less(x,-BIG),-BIG,x)\r\n return N.exp(exponents)\r\n\r\n if type(chisq) == N.ndarray:\r\n arrayflag = 1\r\n else:\r\n arrayflag = 0\r\n chisq = N.array([chisq])\r\n if df < 1:\r\n return N.ones(chisq.shape,N.float)\r\n probs = N.zeros(chisq.shape,N.float_)\r\n probs = N.where(N.less_equal(chisq,0),1.0,probs) # set prob=1 for chisq<0\r\n a = 0.5 * chisq\r\n if df > 1:\r\n y = ex(-a)\r\n if df%2 == 0:\r\n even = 1\r\n s = y*1\r\n s2 = s*1\r\n else:\r\n even = 0\r\n s = 2.0 * azprob(-N.sqrt(chisq))\r\n s2 = s*1\r\n if (df > 2):\r\n chisq = 0.5 * (df - 1.0)\r\n if even:\r\n z = N.ones(probs.shape,N.float_)\r\n else:\r\n z = 0.5 *N.ones(probs.shape,N.float_)\r\n if even:\r\n e = N.zeros(probs.shape,N.float_)\r\n else:\r\n e = N.log(N.sqrt(N.pi)) *N.ones(probs.shape,N.float_)\r\n c = N.log(a)\r\n mask = N.zeros(probs.shape)\r\n a_big = N.greater(a,BIG)\r\n a_big_frozen = -1 *N.ones(probs.shape,N.float_)\r\n totalelements = N.multiply.reduce(N.array(probs.shape))\r\n while asum(mask)<>totalelements:\r\n e = N.log(z) + e\r\n s = s + ex(c*z-a-e)\r\n z = z + 1.0\r\n# print z, e, s\r\n newmask = N.greater(z,chisq)\r\n a_big_frozen = N.where(newmask*N.equal(mask,0)*a_big, s, a_big_frozen)\r\n mask = N.clip(newmask+mask,0,1)\r\n if even:\r\n z = N.ones(probs.shape,N.float_)\r\n e = N.ones(probs.shape,N.float_)\r\n else:\r\n z = 0.5 *N.ones(probs.shape,N.float_)\r\n e = 1.0 / N.sqrt(N.pi) / N.sqrt(a) * N.ones(probs.shape,N.float_)\r\n c = 0.0\r\n mask = N.zeros(probs.shape)\r\n a_notbig_frozen = -1 *N.ones(probs.shape,N.float_)\r\n while asum(mask)<>totalelements:\r\n e = e * (a/z.astype(N.float_))\r\n c = c + e\r\n z = z + 1.0\r\n# print '#2', z, e, c, s, c*y+s2\r\n newmask = N.greater(z,chisq)\r\n a_notbig_frozen = N.where(newmask*N.equal(mask,0)*(1-a_big),\r\n c*y+s2, a_notbig_frozen)\r\n mask = N.clip(newmask+mask,0,1)\r\n probs = N.where(N.equal(probs,1),1,\r\n N.where(N.greater(a,BIG),a_big_frozen,a_notbig_frozen))\r\n return probs\r\n else:\r\n return s","def probabilistic_thresholding(cmndf, thresholds, p_min, p_max, absolute_min_prob, F_axis, Fs, beta_distr,\n parabolic_interp=True):\n # restrict search range to interval [p_min:p_max]\n cmndf[:p_min] = np.inf\n cmndf[p_max:] = np.inf\n\n # find local minima (assuming that cmndf is real in [p_min:p_max], you will always find a minimum,\n # at least p_min or p_max)\n min_idxs = (np.argwhere((cmndf[1:-1] < cmndf[0:-2]) & (cmndf[1:-1] < cmndf[2:]))).flatten().astype(np.int64) + 1\n\n O_m = np.zeros(2 * len(F_axis))\n\n # return if no minima are found, e.g., when frame is silence\n if min_idxs.size == 0:\n return O_m, np.ones_like(thresholds)*p_min, np.ones_like(thresholds)\n\n # Optional: Parabolic Interpolation of local minima\n if parabolic_interp:\n # do not interpolate at the boarders, Numba compatible workaround for np.delete()\n min_idxs_interp = delete_numba(min_idxs, np.argwhere(min_idxs == p_min))\n min_idxs_interp = delete_numba(min_idxs_interp, np.argwhere(min_idxs_interp == p_max - 1))\n p_corr, cmndf[min_idxs_interp] = parabolic_interpolation(cmndf[min_idxs_interp - 1],\n cmndf[min_idxs_interp],\n cmndf[min_idxs_interp + 1])\n else:\n p_corr = np.zeros_like(min_idxs).astype(np.float64)\n\n # set p_corr=0 at the boarders (no correction done later)\n if min_idxs[0] == p_min:\n p_corr = np.concatenate((np.array([0.0]), p_corr))\n\n if min_idxs[-1] == p_max - 1:\n p_corr = np.concatenate((p_corr, np.array([0.0])))\n\n lag_thr = np.zeros_like(thresholds)\n val_thr = np.zeros_like(thresholds)\n\n # loop over all thresholds\n for i, threshold in enumerate(thresholds):\n # minima below absolute threshold\n min_idxs_thr = min_idxs[cmndf[min_idxs] < threshold]\n\n # find first local minimum\n if not min_idxs_thr.size:\n lag = np.argmin(cmndf) # choose absolute minimum when no local minimum is found\n am_prob = absolute_min_prob\n val = np.min(cmndf)\n else:\n am_prob = 1\n lag = np.min(min_idxs_thr) # choose first local minimum\n val = cmndf[lag]\n\n # correct lag\n if parabolic_interp:\n lag += p_corr[np.argmin(min_idxs_thr)]\n\n # ensure that lag is in [p_min:p_max]\n if lag < p_min:\n lag = p_min\n elif lag >= p_max:\n lag = p_max - 1\n\n lag_thr[i] = lag\n val_thr[i] = val\n\n idx = np.argmin(np.abs(1200 * np.log2(F_axis / (Fs / lag)))) # quantize estimated period\n O_m[idx] += am_prob * beta_distr[i] # pYIN-Paper, Formula 4/5\n\n return O_m, lag_thr, val_thr","def get_optimal_threshhold(true_label, prediction, iterations=100, size=17):\n best_threshhold = [0.2]*size\n for t in range(size):\n best_fbeta = 0\n temp_threshhold = [0.2]*size\n for i in range(iterations):\n temp_value = i / float(iterations)\n temp_threshhold[t] = temp_value\n temp_fbeta = fbeta(true_label, prediction > temp_threshhold)\n if temp_fbeta > best_fbeta:\n best_fbeta = temp_fbeta\n best_threshhold[t] = temp_value\n return best_threshhold","def torch_percentile(t, q):\n # Note that ``kthvalue()`` works one-based, i.e. the first sorted value\n # indeed corresponds to k=1, not k=0! Use float(q) instead of q directly,\n # so that ``round()`` returns an integer, even if q is a np.float32.\n k = 1 + round(.01 * float(q) * (t.numel() - 1))\n result = t.view(-1).kthvalue(k).values.item()\n return result","def KL(P,Q):\n epsilon = 0.00001\n \n #You may want to instead make copies to avoid changing the np arrays.\n P = P+epsilon\n Q = Q+epsilon\n \n divergence = np.sum(P*np.log(P/Q))\n return divergence","def distance(p, q):\n return norm(np.asarray(p) - np.asarray(q))","def relative_entropy(P, Q):\n return rel_entropy_P_Q","def dp_quantile(data, alpha, candidates=None, lower=None, upper=None, mechanism=\"Automatic\", privacy_usage=None, interpolation=\"midpoint\", **kwargs):\n return Component(\n \"DPQuantile\",\n arguments={\n 'data': Component.of(data),\n 'candidates': Component.of(candidates),\n 'lower': Component.of(lower),\n 'upper': Component.of(upper)\n },\n options={\n 'alpha': alpha,\n 'mechanism': mechanism,\n 'privacy_usage': serialize_privacy_usage(privacy_usage),\n 'interpolation': interpolation\n },\n constraints=kwargs)","def calculate_cramer_von_mises(p, q, num_samples=100, _random_state=None, **kwargs): # pylint: disable=unused-argument\n logging.warning(\"This function is deprecated, please use `calculate_goodness_of_fit`\") # pragma: no cover","def selectThreshold(yval, pval):\n bestEpsilon = 0\n bestF1 = 0\n F1 = 0\n\n stepsize = (pval.max()-pval.min())/1000\n for epsilon in np.arange(pval.min(), pval.max()+stepsize/2, stepsize):\n predictions = (pval < epsilon)\n tp = ((predictions == 1) & (yval == 1)).sum()\n fp = ((predictions == 1) & (yval == 0)).sum()\n fn = ((predictions == 0) & (yval == 1)).sum()\n prec = tp/(tp+fp)\n rec = tp/(tp+fn)\n F1 = 2*prec*rec/(prec+rec)\n\n if F1 > bestF1:\n bestF1 = F1\n bestEpsilon = epsilon\n\n return bestEpsilon, bestF1","def _set_target_quality(self):\n best_model = clone(self.model)\n # train and avaluate the model on the full size of potential dataset\n best_model.fit(self.dataset.train_data, np.ravel(self.dataset.train_labels))\n test_prediction = best_model.predict(self.dataset.test_data) \n max_quality = self.quality_method(self.dataset.test_labels, test_prediction)\n # the target_quality after which the episode stops is a proportion of the max quality\n self.target_quality = self.tolerance_level*max_quality","def FMScore(x,p,d):\n \n if x <= d[p][0.20]:\n return 1\n elif x <= d[p][0.4]:\n return 2\n elif x <= d[p][0.6]: \n return 3\n elif x <= d[p][0.8]:\n return 4\n else:\n return 5","def FMScore(x,p,d):\n \n if x <= d[p][0.20]:\n return 1\n elif x <= d[p][0.4]:\n return 2\n elif x <= d[p][0.6]: \n return 3\n elif x <= d[p][0.8]:\n return 4\n else:\n return 5","def ham_dist(p, q):\n count = 0\n for i in range(len(p)):\n if p[i] != q[i]:\n count += 1\n return count","def ham_dist(p, q):\n count = 0\n for i in range(len(p)):\n if p[i] != q[i]:\n count += 1\n return count","def quantile_normalize_using_target(x, target):\n\n target_sorted = np.sort(target)\n\n return target_sorted[x.argsort().argsort()]","def find_metric_threshold(self):\n logger.info(\"compute metric threshold\")\n\n ### Beaucoup trop lent quand on a beaucoup de models ###\n\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\n\n if len(df_results_not_aggregated) == 0:\n logger.info(\"threshold = None\")\n return None\n\n main_scorer = \"test_%s\" % self.job_config.main_scorer\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\n min_cv = df_results_not_aggregated.groupby(\"job_id\")[main_scorer].min().values\n delta_min_max_cv = np.median(\n df_results_not_aggregated.groupby(\"job_id\")[main_scorer].apply(lambda x: x.max() - x.min())\n )\n\n if len(min_cv) <= self.min_nb_of_models:\n logger.info(\"threshold = None\")\n return None\n\n min_cv = -np.sort(-min_cv)\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\n\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\n\n logger.info(\"threshold : %2.2f\" % result)\n return result","def sample_distrib(d_t, data_set, set_size, max_wanted_samples):\n # when distrib is updated it seems some distrib[i] are updated too much so max is really high and\n training_samples = []\n # distrib_mean = np.mean(d_t)\n distrib_max = max(d_t)\n for _ in range(max_wanted_samples):\n id = rd.randint(0, set_size)\n sample = data_set[id]\n # v = rd.uniform(0, distrib_mean)\n v = rd.uniform(0, distrib_max)\n if d_t[id] > v:\n training_samples.append(sample)\n return training_samples","def threshold_fit_quantile(X, y, alpha, gamma, n_class, kernel_type, loss_function,\n opt_type, opt_params, mode='QE', max_iter=1000, \n verbose=False, tol=1e-12, sample_weight=None):\n\n X, y = check_X_y(X, y, accept_sparse='csr')\n unique_y = np.sort(np.unique(y))\n '''\n if not np.all(unique_y == np.arange(unique_y.size)):\n raise ValueError(\n 'Values in y must be %s, instead got %s'\n % (np.arange(unique_y.size), unique_y))\n '''\n n_samples, n_features = X.shape\n\n # convert from c to theta\n L = np.zeros((n_class - 1, n_class - 1))\n L[np.tril_indices(n_class-1)] = 1.\n\n if mode == '0-1' or mode == 'Direct':\n loss_fd = (1 - gamma) * np.diag(np.ones(n_class - 1)) + \\\n gamma * np.diag(np.ones(n_class - 2), k=-1)\n loss_fd = np.vstack((loss_fd, np.zeros(n_class - 1)))\n loss_fd[-1, -1] = gamma # border case\n elif mode == 'AE':\n # loss forward difference\n loss_fd = np.ones((n_class, n_class - 1)) * (1 - gamma)\n lower_indices = np.tril_indices(n = n_class, k = -1)\n loss_fd[lower_indices] = gamma\n else:\n raise NotImplementedError\n\n x0 = np.zeros(n_features + n_class - 1)\n x0[X.shape[1]:] = np.arange(n_class - 1)\n options = {'maxiter' : max_iter, 'disp': verbose}\n if n_class > 2:\n bounds = [(None, None)] * (n_features + 1) + \\\n [(0, None)] * (n_class - 2)\n else:\n bounds = None\n\n if (mode != 'Direct'):\n if(opt_type == 'SciPy'):\n sol = optimize.minimize(obj_margin, x0, method='L-BFGS-B',\n bounds=bounds, options=options, \n args=(X, y, alpha, n_class, loss_fd, L, kernel_type, loss_function, sample_weight),\n tol=tol)\n sol = sol.x\n else: \n sol = optimize_batch(obj_function=obj_margin, x0=x0, method=opt_type, \n bounds=bounds, gradient=grad_margin, opt_params=opt_params,\n args=(X, y, alpha, n_class, loss_fd, L, kernel_type, loss_function, sample_weight))\n else:\n sol = optimize.minimize(obj_direct, x0, method='L-BFGS-B',\n jac=grad_direct, bounds=bounds, options=options,\n args=(X, y, alpha, gamma, n_class, loss_fd, L, kernel_type, loss_function, sample_weight),\n tol=tol)\n \n if verbose and not sol.success:\n print(sol.message)\n\n w, c = sol[:X.shape[1]], sol[X.shape[1]:]\n theta = L.dot(c)\n return w, theta","def maxOldQ(self,feat):\r\n maxQ = float('-inf')\r\n for a in self.actions:\r\n q = self.oldQ(feat,a)\r\n \r\n if q > maxQ:\r\n maxQ = q\r\n \r\n return(maxQ)","def selectThreshold(yval, pval):\n\tbestEpsilon = 0\n\tbestF1 = 0\n\tstepsize = (np.max(pval) - np.min(pval)) / 1000\n\n\tfor epsilon in np.arange(np.min(pval), np.max(pval), stepsize):\n\t\tpredictions = (pval < epsilon) + 0\n\t\ttp = np.sum((yval == 1) & (predictions == 1))\n\t\tfp = np.sum((yval == 0) & (predictions == 1))\n\t\tfn = np.sum((yval == 1) & (predictions == 0))\n\t\tif tp + fp == 0:\n\t\t\tcontinue\n\t\tprec = float(tp) / (tp + fp) # tips: cast int to float, or you will get 0\n\t\trec = float(tp) / (tp + fn)\n\t\tF1 = 2.0 * prec * rec / (prec + rec)\n\t\tif F1 > bestF1:\n\t\t\tbestF1 = F1\n\t\t\tbestEpsilon = epsilon\n\treturn bestEpsilon, bestF1","def quantile(self, q, *, axis=0, **kwargs) -> \"Dataset\":\n return self._quantile(q, axis=axis, func=np.quantile, **kwargs)","def get_variance_threshold(variances, whisker_percent, whisker_length):\n low_percentiles, high_percentiles = np.percentile(variances, (whisker_percent, 100-whisker_percent))\n threshold = high_percentiles + (high_percentiles - low_percentiles) * whisker_length\n\n return threshold","def dataset_quality_score(data_matrix, threshold=0.2, good_days=None,\n use_advanced=True):\n if good_days is None:\n if use_advanced:\n good_days = daily_missing_data_advanced(data_matrix, threshold=threshold)\n else:\n good_days = daily_missing_data_simple(data_matrix, threshold=threshold)\n score = np.sum(good_days) / data_matrix.shape[1]\n return score","def tpr(positive, negative, fpr):\n threshold = np.percentile(np.asarray(negative), 100 - fpr)\n total_true_positives = sum(positive > threshold)\n\n return total_true_positives / len(positive)","def perform_thresholding(f,M,type):\n if type == \"largest\":\n a = np.sort(np.ravel(abs(f)))[::-1] #sort a 1D copy of F in descending order\n T = a[M]\n y = f*(abs(f) > T)\n elif type == \"soft\":\n s = abs(f) - M\n s = (s + abs(s))/2\n y = np.sign(f)*s\n elif type == \"hard\":\n y = f*(abs(f) > M)\n return y","def get_optimal_bst(p, q):\n\n assert p is not None\n assert q is not None\n assert len(p) == len(q)\n n = len(p) - 1\n assert n >= 0\n\n if n == 0:\n return 1.0, []\n\n e = [[-1 for _ in range(0, n + 1)] for _ in range(0, n + 1)]\n root = [[-1 for _ in range(0, n)] for _ in range(0, n)]\n\n for i in range(1, n + 1):\n e[i][i] = (q[i - 1] + q[i]) * 2 + p[i]\n root[i - 1][i - 1] = i\n\n for i in range(n + 1, 0, -1):\n for j in range(i + 1, n + 1):\n w = sum(q[i - 1:j + 1]) + sum(p[i:j + 1])\n min_cost = sys.maxsize\n current_root = -1\n for r in range(i, j + 1):\n assert (r == i or e[i][r - 1] > 0) and (r == j or e[r + 1][j] > 0)\n e_left = q[i - 1] if r == i else e[i][r - 1]\n e_right = q[j] if r == j else e[r + 1][j]\n e_cost = w + e_left + e_right\n\n if e_cost < min_cost:\n min_cost = e_cost\n current_root = r\n\n e[i][j] = min_cost\n root[i - 1][j - 1] = current_root\n\n return e[1][n], root","def test__quantile(self):\r\n # regular cases\r\n sample_data = array(range(25, 42))\r\n assert_almost_equal(_quantile(sample_data, 0.5), median(sample_data))\r\n\r\n # sorted data is assumed for this function\r\n sample_data = sorted(\r\n array([0.17483293, 0.99891939, 0.81377467, 0.8137437,\r\n 0.51990174, 0.35521497, 0.98751461]))\r\n assert_almost_equal(_quantile(sample_data, 0.10), 0.283062154)","def detect_peak(data):\n nonlocal last, ascent_dist, ascent_start\n if data > last:\n if ascent_start is None:\n ascent_start = last\n ascent_dist += 1\n else:\n if ascent_dist:\n peak = last\n ascent_dist = 0\n if (peak - ascent_start) > thresh:\n last = data\n ascent_start = None\n return peak\n ascent_start = None\n last = data\n return None","def calc_q1(data: list) -> float:\n py = copy.copy(data)\n py.sort()\n return py[round(len(py) / 4)]","def fit_threshold(data, rho_cutoff=0., maxedges=None, diag=1e-6):\n from scipy.linalg import inv as scipy_inv\n n,m = data.shape\n sig = np.cov(data,ddof=0,aweights=None) + diag*np.eye(n);\n J = -scipy_inv(sig); J = .5*(J+J.T); # symmetrize just in case\n Jdiag = J[range(n),range(n)]; J[range(n),range(n)] = 0. # zero diagonal for threshold op\n if maxedges is not None:\n if maxedges > J.size: rho_cutoff = 0.\n else: rho_cutoff = max(rho_cutoff, -np.sort(np.abs(J).reshape(-1))[2*maxedges])\n J[ np.abs(J) <= rho_cutoff ] = 0.\n J[range(n),range(n)] = Jdiag; # restore diagonal\n J[range(n),range(n)] -= J.dot(np.mean(data,1)) # add singleton terms (TODO: CHECK)\n return Ising(J)","def delete_outliers_of_data_before(data: np.ndarray, qi_inspect: int, threshold: int):\n idx_to_del = []\n done = False\n for j in range(data.shape[0]):\n if data[j, qi_inspect] < threshold:\n if not done:\n idx_to_del = j\n done = True\n else:\n idx_to_del = np.append(idx_to_del, j)\n return np.delete(data, idx_to_del, axis=0)","def ds_preprocessing(x, error_threshold, min_val=0, max_val=1):\n # Scale in range [min_val, max_val]\n scaler = MinMaxScaler((min_val, max_val))\n processed = scaler.fit_transform(x)\n\n # Quantization\n bins = np.arange(min_val, max_val, 2 * error_threshold)\n digitized = np.digitize(processed, bins)\n quantized = (digitized - 1) * (2 * error_threshold) + error_threshold\n\n return quantized, scaler","def prctile(data, p_vals=[0, 25, 50, 75, 100], sorted_=False):\r\n ps = [p_vals] if np.isscalar(p_vals) else p_vals\r\n\r\n if not sorted_:\r\n data = sorted(data)\r\n n = len(data)\r\n d = []\r\n for p in ps:\r\n fi = p * n / 100 - 0.5\r\n if fi <= 0: # maybe extrapolate?\r\n d.append(data[0])\r\n elif fi >= n - 1:\r\n d.append(data[-1])\r\n else:\r\n i = int(fi)\r\n d.append((i+1 - fi) * data[i] + (fi - i) * data[i+1])\r\n return d[0] if np.isscalar(p_vals) else d","def q_from_ea(ea, p):\n return 0.622 * ea / (p - 0.378 * ea)","def _estimate_threshold(self, **kwargs):\n recompute_threshold = kwargs.pop('recompute_threshold', False)\n # if threshold is in table, then use it.\n current_setting = (self.beta, self.chi2dist.kwds['df'])\n threshold = None\n res = False\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\n for e in _gaussian_cusum_thresholds[current_setting]:\n if e[0] == self.arl:\n threshold = np.array([e[1]])\n res = True\n # if threshold not is in table, estimate it\n if threshold is None:\n len_simulation = kwargs.pop('len_simulation', None)\n if len_simulation is None:\n len_simulation = 10 * self.arl\n self.log.info(\"estimating threshold...\")\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\n plain_cusum.gamma = self.gamma\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\n kwargs.pop('x', None)\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\n **kwargs)\n threshold = plain_cusum.threshold\n self.threshold = threshold\n return res","def test_samples_close_to_inclusion_probability_priority(self):\n # The range we allow around 0.5n\n distance_from_half = 0.01\n # The number of elements we use (computed using Chernoff bounds)\n n = int((6.0 / (distance_from_half**2)) *\n math.log(2 * FAILURE_PROBABILITY_INVERSE, math.e) + 1)\n s = private_sampling.ThresholdSample(\n 0.5, private_sampling.PrioritySamplingMethod)\n for i in range(n):\n s.process(i, 1.0)\n self.assertGreaterEqual(len(s.elements), (0.5 - distance_from_half) * n)\n self.assertLessEqual(len(s.elements), (0.5 + distance_from_half) * n)"],"string":"[\n \"def Quantile(data, q, precision=1.0):\\n N, bins = np.histogram(data, bins=precision*np.sqrt(len(data)))\\n norm_cumul = 1.0*N.cumsum() / len(data)\\n\\n for i in range(0, len(norm_cumul)):\\n if norm_cumul[i] > q:\\n return bins[i]\",\n \"def data_quality(dset):\\n dq_threshold = config.tech[_SECTION].threshold.int\\n return np.nan_to_num(dset.data_quality) <= dq_threshold\",\n \"def top_quantile_positive_constraint(x: Tensor, q: float, bias: float = 0.1) -> Tensor:\\n\\n if x.dim() != 2:\\n raise ValueError(\\n f'operation only supported for 2D tensors (got {x.dim()}D).'\\n )\\n\\n if not (0. <= q <= 1.):\\n raise ValueError(\\n f'`q` must be in range [0, 1] but is {q}.'\\n )\\n\\n if q == 0.:\\n return torch.relu(-x.max(dim=1)[0]).mean() + bias\\n if q == 1.:\\n return positive_constraint(x, bias=bias)\\n else:\\n k = int(q * x.size(1))\\n return torch.relu(-x.topk(k, dim=1)[0]).mean() + bias\",\n \"def kernel_quantile_heuristic(X, q=0.5):\\n pairwise_sq_dists = pdist(X, 'sqeuclidean')\\n quantile_heuristic_s2 = np.quantile(pairwise_sq_dists, q=q)\\n return quantile_heuristic_s2\",\n \"def KB_Dist(P,Q):\\r\\n \\r\\n \\r\\n K=0\\r\\n Epsilon=0.000001\\r\\n Q+=Epsilon\\r\\n P+=Epsilon\\r\\n for x in range(len(Q)):\\r\\n K-=P[x]*np.log(Q[x]/P[x])\\r\\n return K\",\n \"def target_distribution(q):\\n weight = q ** 2 / q.sum(0)\\n return (weight.T / weight.sum(1)).T\",\n \"def threshold_func(distribution: List[float], alpha: List[float], **kwargs) -> float:\\n threshold = np.quantile(distribution, q=alpha, interpolation=\\\"lower\\\", **kwargs)\\n return threshold\",\n \"def quality(X, boost=2):\\n X = np.abs(np.sort(X, axis=-1).astype(float))\\n Q = 1 - np.log(2 + X[..., -2]) / np.log(2 + X[..., -1])\\n Q = (Q * 2).clip(0, 1)\\n return Q\",\n \"def find_quant(trainy, train_tree_node_ID, pred_tree_node_ID, qntl):\\n npred = pred_tree_node_ID.shape[0]\\n out = np.zeros((npred, qntl.size))*np.nan\\n for i in prange(pred_tree_node_ID.shape[0]):\\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\\n sample = trainy[idxs]\\n out[i, :] = np.quantile(sample, qntl)\\n return out\",\n \"def quantile(xs: List[float], p: float) -> float:\\n p_index = int(p * len(xs))\\n return sorted(xs)[p_index]\",\n \"def quantile(x, p):\\n sorted_x = sorted(x)\\n # round p_index to base int\\n p_index = int(p * len(x))\\n return sorted_x[p_index]\",\n \"def quality_threshold_value(vals: list, q_factor=1):\\n s = list(sorted(vals))\\n keep_up_too = int(np.ceil(len(vals) * q_factor))\\n thresh_index = len(vals) - keep_up_too\\n return s[thresh_index]\",\n \"def _get_optimal_threshold(arr, num_bins=1001, num_quantized_bins=255):\\n if not isinstance(arr, np.ndarray):\\n raise TypeError('get_optimal_threshold only supports input type of np.ndarray,'\\n ' while received type=%s' % (str(type(arr))))\\n min_val = np.min(arr)\\n max_val = np.max(arr)\\n th = max(abs(min_val), abs(max_val))\\n\\n hist, hist_edges = np.histogram(arr, bins=num_bins, range=(-th, th))\\n zero_bin_idx = num_bins // 2\\n num_half_quantized_bins = num_quantized_bins // 2\\n assert np.allclose(hist_edges[zero_bin_idx] + hist_edges[zero_bin_idx + 1],\\n 0, rtol=1e-5, atol=1e-7)\\n\\n thresholds = np.zeros(num_bins // 2 + 1 - num_quantized_bins // 2)\\n divergence = np.zeros_like(thresholds)\\n quantized_bins = np.zeros(num_quantized_bins, dtype=np.int32)\\n # i means the number of bins on half axis excluding the zero bin.\\n for i in range(num_quantized_bins // 2,\\n num_bins // 2 + 1):\\n p_bin_idx_start = zero_bin_idx - i\\n p_bin_idx_stop = zero_bin_idx + i + 1\\n thresholds[i - num_half_quantized_bins] = hist_edges[p_bin_idx_stop]\\n sliced_nd_hist = hist[p_bin_idx_start:p_bin_idx_stop]\\n\\n # generate reference distribution p\\n p = sliced_nd_hist.copy()\\n assert p.size % 2 == 1\\n assert p.size >= num_quantized_bins\\n # put left outlier count in p[0]\\n left_outlier_count = np.sum(hist[0:p_bin_idx_start])\\n p[0] += left_outlier_count\\n # put right outlier count in p[-1]\\n right_outlier_count = np.sum(hist[p_bin_idx_stop:])\\n p[-1] += right_outlier_count\\n # is_nonzeros[k] indicates whether hist[k] is nonzero\\n is_nonzeros = (sliced_nd_hist != 0).astype(np.int32)\\n\\n # calculate how many bins should be merged to generate quantized distribution q\\n num_merged_bins = p.size // num_quantized_bins\\n # merge hist into num_quantized_bins bins\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n stop = start + num_merged_bins\\n quantized_bins[j] = sliced_nd_hist[start:stop].sum()\\n quantized_bins[-1] += sliced_nd_hist[num_quantized_bins * num_merged_bins:].sum()\\n # expand quantized_bins into p.size bins\\n q = np.zeros(p.size, dtype=np.float32)\\n for j in range(num_quantized_bins):\\n start = j * num_merged_bins\\n if j == num_quantized_bins - 1:\\n stop = -1\\n else:\\n stop = start + num_merged_bins\\n norm = is_nonzeros[start:stop].sum()\\n if norm != 0:\\n q[start:stop] = float(quantized_bins[j]) / float(norm)\\n q[sliced_nd_hist == 0] = 0\\n p = _smooth_distribution(p)\\n # There is a chance that q is an invalid probability distribution.\\n try:\\n q = _smooth_distribution(q)\\n except ValueError:\\n divergence[i - num_half_quantized_bins] = float(\\\"inf\\\")\\n else:\\n divergence[i - num_half_quantized_bins] = stats.entropy(p, q)\\n quantized_bins[:] = 0\\n\\n min_divergence_idx = np.argmin(divergence)\\n min_divergence = divergence[min_divergence_idx]\\n opt_th = thresholds[min_divergence_idx]\\n return min_val, max_val, min_divergence, opt_th\",\n \"def quantile(self, q: float) -> np.array:\\n assert 0 <= q <= 1\\n return np.array(\\n list(\\n chain.from_iterable(\\n model.predict(self.featurized_data, q)\\n for model in self.models\\n )\\n )\\n )\",\n \"def cmf_find_quantile_index(a, q):\\n return jnp.argmax(a >= q)\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def genQuality(self):\\n return np.clip(np.random.normal(self.qavgs, self.qstdevs), 0, 40)\",\n \"def q_criterion(a):\\n print(\\\"Detection method: Q criterion\\\")\\n Q = np.zeros((a.u.shape[0], a.u.shape[1]))\\n print(a.u.shape[0], a.u.shape[1])\\n #print(Q.shape)\\n for i in range(a.u.shape[0]):\\n for j in range(a.u.shape[1]):\\n Q[i, j] = -0.5*(a.derivative['dudx'][i, j]**2 + a.derivative['dvdy'][i, j]**2) \\\\\\n - a.derivative['dudy'][i, j] * a.derivative['dvdx'][i, j]\\n return Q\",\n \"def dist(p, q):\\n return ((p[0] - q[0])**2 + (p[1] - q[1])**2 + (p[2] - q[2])**2)**0.5\",\n \"def find_threshold(labels, predictions, wqs, post_shift):\\n if post_shift:\\n sorted_groups = []\\n for q in range(1, 5):\\n sorted_group = sorted(\\n [(prediction[0], label)\\n for (prediction, label, wq) in zip(predictions, labels, wqs)\\n if wq == q],\\n reverse=True)\\n sorted_groups.append(sorted_group)\\n\\n cut_indices = [\\n int(len(sorted_group) * COVERAGE) for sorted_group in sorted_groups\\n ]\\n\\n for _ in range(1000):\\n fprs = [\\n get_fpr(sorted_group, cut_index)\\n for (sorted_group, cut_index) in zip(sorted_groups, cut_indices)\\n ]\\n min_fpr_index = np.argmin(fprs)\\n max_fpr_index = np.argmax(fprs)\\n cut_indices[min_fpr_index] = min(cut_indices[min_fpr_index] + 1,\\n len(sorted_groups[min_fpr_index]))\\n cut_indices[max_fpr_index] = max(cut_indices[max_fpr_index] - 1, 0)\\n\\n thresholds = [sorted_groups[q][cut_indices[q]][0] for q in range(4)]\\n return thresholds\\n else:\\n return [np.percentile(predictions, 100 - COVERAGE * 100)] * 4\",\n \"def predict_qs(self, data):\\n\\n if data['p_gs'] == 0 or data['p_g'] == 0:\\n return data\\n\\n er = data['p_er']\\n gs = data['p_gs']\\n gp = data['p_g']\\n ip = data['p_ip']\\n\\n a = (gs / (er * (gs / gp)))\\n b = ip * (gs / gp)\\n c = ((gs + gp) / (gp * 2))**2\\n\\n data['p_qs'] = (a * b * c) / 4.11556\\n return data\",\n \"def find_optimal_Q(x, y, data, min_Q, max_Q, fs=1., added_kernel = None, plot_BIC=True):\\n Qs= np.arange(min_Q, max_Q)\\n BIC = np.zeros((Qs.shape[0]))\\n \\n for i, q in enumerate(Qs):\\n sm = SpectralMixture(q, x=x.flatten(),y=y.flatten(),fs=fs)\\n for k in sm.kernels:\\n if isinstance(k, SpectralMixtureComponent):\\n k.lengthscale.prior = tfd.Gamma(f64(8.), f64(.6)) \\n k.mixture_weight.prior = tfd.Gamma(f64(2.), f64(1.))\\n\\n if added_kernel is not None:\\n sm += added_kernel\\n \\n# model = models.ContinuousModel(sm, (util.ensure_tf_matrix(x),util.ensure_tf_matrix(y)))\\n model = models.ContinuousModel(sm, data)\\n model.train(verbose=False)\\n BIC[i] = model.log_posterior_density(\\\"bic\\\").numpy()\\n \\n if plot_BIC:\\n fig = plt.figure()\\n plt.plot(Qs, BIC)\\n plt.xlabel('Number of Spectral Mixture components (Q)')\\n plt.show()\\n\\n return np.argmax(BIC) + min_Q\",\n \"def quantile(x,p):\\n p_index = int(p*len(x))\\n return sorted(x)[p_index]\",\n \"def find_optimal_threshold(self, hist):\\n\\n # print(\\\"number of pixels using sum: \\\", sum(hist))\\n probability = np.array((1/sum(hist))*hist)\\n expected_value = probability*np.array(range(256))\\n # print(\\\"probability: \\\\n\\\", probability)\\n # print(\\\"expected_value: \\\\n\\\", expected_value)\\n\\n threshold = len(hist)/2\\n temp_threshold = 0\\n\\n while abs(threshold - temp_threshold) > 0.001:\\n temp1 = []\\n temp2 = []\\n print(\\\"New threshold: \\\", threshold)\\n for i in range(len(hist)):\\n if i < threshold:\\n temp1.append(expected_value[i])\\n else:\\n temp2.append(expected_value[i])\\n mean1 = sum(temp1)\\n print(\\\"mean1: \\\\n\\\", mean1)\\n mean2 = sum(temp2)\\n print(\\\"mean2: \\\\n\\\", mean2)\\n temp_threshold = threshold\\n threshold = (mean1+mean2)/2\\n print(\\\"threshold: \\\", threshold)\\n print(\\\"temp_threshold: \\\", temp_threshold)\\n\\n return threshold\",\n \"def quantization(self, data):\\n self._check_input_len(data)\\n winners_coords = argmin(self._distance_from_weights(data), axis=1)\\n return self._weights[unravel_index(winners_coords,\\n self._weights.shape[:2])]\",\n \"def cost(P, Q):\\n Q = np.where(Q != 0, Q, 1e-12)\\n P = np.where(P != 0, P, 1e-12)\\n Div = P / Q\\n C = np.sum(P * np.log(Div))\\n return C\",\n \"def decision_problem(P, Q, p, q, eps, mdist, P_dist, Q_dist):\\n LF, BF = LF_BF(P, Q, p, q, eps, mdist, P_dist, Q_dist)\\n rep, _, _ = LR_BR(LF, BF, p, q)\\n return rep\",\n \"def get_percentile(self, q):\\n return None\",\n \"def get_percentile(self, q):\\n return None\",\n \"def qt(q, df=1, loc=0, scale=1, ncp=None, lowertail=True, log=False):\\n # ==========================================================================\\n if log:\\n raise NotImplementedError(\\\"Log option is not implemented yet.\\\")\\n elif lowertail:\\n return t.ppf(q=q, df=df, loc=loc, scale=scale)\\n else:\\n return t.isf(q=q, df=df, loc=loc, scale=scale)\",\n \"def find_optimal_threshold(self, hist):\\n k = 256\\n threshold = int(k / 2)\\n lastexpected1 = lastexpected2 = 0\\n\\n while True:\\n expected1 = expected2 = 0\\n t_exp1 = sum(hist[:threshold])\\n t_exp2 = sum(hist[threshold:])\\n for i in range(threshold):\\n expected1 += (hist[i] / t_exp1) * i\\n\\n for i in range(threshold, k):\\n expected2 += (hist[i] / t_exp2) * i\\n\\n threshold = (expected1 + expected2) / 2\\n if abs(expected1 - lastexpected1) != 0 and abs(expected2 - lastexpected2) != 0:\\n break\\n lastexpected1 = expected1\\n lastexpected2 = expected2\\n # print(expected2, expected1)\\n return threshold\",\n \"def prob_choice(p):\\n \\n return np.random.random_sample() < p\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def percentile(t: torch.tensor, q: float):\\n # Note that ``kthvalue()`` works one-based, i.e. the first sorted value\\n # indeed corresponds to k=1, not k=0! Use float(q) instead of q directly,\\n # so that ``round()`` returns an integer, even if q is a np.float32.\\n k = 1 + round(.01 * float(q) * (t.numel() - 1))\\n result = t.view(-1).kthvalue(k).values.item()\\n return result\",\n \"def quantiles(self, q: int):\\n return self.dist.quantiles(q)\",\n \"def default_quantile():\\n return np.logspace(-5, 0, 100)\",\n \"def dist(p,q):\\n return math.sqrt((p[0] - q[0]) ** 2+(p[1] - q[1]) ** 2)\",\n \"def find_best_threshold(y, y_hat, step_size, score_func, maximize=True):\\n best_thres, best_score = 0.0, 0.0 if maximize else 1.0\\n for thres in np.arange(0, 1, step_size):\\n score = score_for_threshold(y, y_hat, score_func, thres)\\n if (maximize and (score > best_score)) or (not maximize and (score < best_score)):\\n best_score = score\\n best_thres = thres\\n\\n return best_thres, best_score\",\n \"def reproducibility_from_fisher(disdf, samplesizes, qthresh):\\n\\n ## Turn disdf into tidy dataframe\\n longpvals = copy.deepcopy(disdf)\\n longpvals['otu'] = longpvals.index\\n longpvals = pd.melt(longpvals, id_vars='otu',\\n value_name='p', var_name='study')\\n\\n ## Convert two-tailed signed p-values into one-tailed pvalues\\n longpvals = convert_to_one_tailed(longpvals).dropna()\\n longpvals = pd.melt(longpvals, id_vars=['otu', 'study'],\\n value_vars=['p-dis', 'p-h'], var_name='pval_direction')\\n\\n ## Add sample size for each study\\n longpvals['sample_size'] = \\\\\\n longpvals.apply(lambda row: samplesizes.loc[row['study'], 'total'],\\n axis=1)\\n\\n ## Get the combined p-value using weighted stouffer's method\\n metap = []\\n for grp, subdf in longpvals.groupby(['otu', 'pval_direction']):\\n # Only consider genera which are in more than one study\\n if subdf.shape[0] > 1:\\n # grp is the tuple that defines the group: (otu, direction)\\n direction = grp[1]\\n otu = grp[0]\\n numstudies = subdf.shape[0]\\n # Stouffer's weight z-score test\\n z, p = combine_pvalues(subdf['value'].astype(float),\\n method='stouffer',\\n weights=subdf['sample_size'].apply(np.sqrt))\\n metap.append([otu, direction, z, p, numstudies])\\n metap = pd.DataFrame(metap, columns=['otu', 'direction', 'z', 'p', 'num_studies'])\\n\\n ## Count number of significant healthy and disease bugs\\n # Note that from manual inspection, it doesn't look like any genera\\n # are returned as significant in both directions from this method...\\n sig_h = metap.query('direction == \\\"p-h\\\"').query('p < @qthresh')\\n sig_dis = metap.query('direction == \\\"p-dis\\\"').query('p < @qthresh')\\n\\n return sig_h.shape[0] + sig_dis.shape[0]\",\n \"def get_percentile(self, q):\\n return self.sum_stat_sample_ratio.get_percentile(q)\",\n \"def var_dist(P, Q, X=alph):\\n\\n dist = 0.5 * sum([abs(P[x] - Q[x]) for x in X])\\n\\n return dist\",\n \"def gp_optimize_threshold(gp_model, X_val, y_val, X_scaler, y_scaler, optimize_for=\\\"profits\\\"): \\n y_hat, conf = gp_model.predict(X_val)\\n regressed_payment = y_scaler.inverse_transform(y_hat).reshape(-1)\\n loan_amt = X_scaler.inverse_transform(X_val)[:,0]\\n\\n # This ratio is a guage of how likely a person will pay back.\\n # It is compared with a threshold to determine whether or not to loan.\\n payment_to_loan_ratio = regressed_payment / loan_amt\\n\\n # Sort in descending order\\n sorted_ind = np.argsort(-payment_to_loan_ratio)\\n sorted_payment_to_loan_ratio = payment_to_loan_ratio[sorted_ind]\\n X_sorted, y_sorted = X_val[sorted_ind,:], y_val[sorted_ind]\\n\\n threshold, highest_opt_val = 0, 0\\n for i, thresh in enumerate(sorted_payment_to_loan_ratio): \\n X_loanee = X_sorted[:i+1,:]\\n y_loanee = y_sorted[:i+1]\\n \\n loan_amt_loanee = np.sum(X_scaler.inverse_transform(X_loanee)[:,0])\\n payments_loanee = np.sum(y_loanee)\\n\\n # Optimize for different values\\n if optimize_for == \\\"profits\\\":\\n opt_val = payments_loanee - loan_amt_loanee\\n elif optimize_for == \\\"profit_percentage\\\":\\n opt_val = (payments_loanee - loan_amt_loanee) / loan_amt_loanee\\n else:\\n raise Exception(\\\"Illegal optimize_for value: %s\\\" % optimize_for)\\n\\n # Keep track of highest value (that is being optimized for)\\n if opt_val > highest_opt_val:\\n threshold = thresh\\n highest_opt_val = opt_val\\n return threshold\",\n \"def quantile_corner(x, q, weights=None):\\n if weights is None:\\n return np.percentile(x, [100. * qi for qi in q])\\n else:\\n idx = np.argsort(x)\\n xsorted = x[idx]\\n cdf = np.add.accumulate(weights[idx])\\n cdf /= cdf[-1]\\n return np.interp(q, cdf, xsorted).tolist()\",\n \"def compute_optimal_token_minimum(token_counts) -> int:\\n q1, q3 = compute_quartiles(token_counts)\\n iqr = q3 - q1\\n low_threshold = q1 - 1.5 * iqr\\n return low_threshold\",\n \"def find_optimal_threshold(self, hist):\\n\\n\\n threshold = int((len(hist)-1)/2)\\n ct = len(hist) - 1\\n\\n while True:\\n if(ct < 1):\\n break\\n threshold1 = self.evalue(hist,0,threshold)\\n threshold2 = self.evalue(hist,threshold,len(hist) - 2)\\n nt = int((threshold1+threshold2)/2)\\n ct = nt - threshold\\n threshold = nt\\n\\n return threshold\",\n \"def cross_entropy(p: np.ndarray, q: np.ndarray, eps: float = 1e-10) -> float:\\n p = np.asarray(p)\\n q = np.asarray(q)\\n if p.ndim > 2 or q.ndim > 2:\\n raise ValueError(\\n f\\\"Not obvious how to reshape arrays: got shapes {p.shape} and {q.shape}.\\\"\\n )\\n elif (p.ndim == 2 and p.shape[0] > 1) or (q.ndim == 2 and q.shape[0] > 1):\\n raise ValueError(\\n f\\\"Expected 2-dimensional arrays to have shape (1, *): got shapes \\\\\\n {p.shape} and {q.shape}.\\\"\\n )\\n p = p.reshape(-1)\\n q = q.reshape(-1)\\n if p.shape[0] != q.shape[0]:\\n raise ValueError(\\n f\\\"Expected arrays of the same length: got lengths {len(p)} and {len(q)}.\\\"\\n )\\n if np.any(p < 0) or np.any(q < 0):\\n raise ValueError(\\\"Arrays must both be non-negative.\\\")\\n if np.isclose(p.sum(), 0) or np.isclose(q.sum(), 0):\\n raise ValueError(\\\"Arrays must both be non-zero.\\\")\\n if not np.isclose(p.sum(), 1):\\n p /= p.sum()\\n if not np.isclose(q.sum(), 1):\\n q /= q.sum()\\n cross_entropy_pq = (-p * np.log(q + eps)).sum()\\n return cross_entropy_pq\",\n \"def precomp_threshold(dof, len_sim=1e5, beta=.75):\\n for d in dof:\\n cdt = GaussianCusum(arl=None, beta=beta)\\n cdt.fit(x=np.zeros((1, d)), estimate_threshold=True, len_simulation=len_sim,\\n verbose=True, precompute_thresholds=True)\",\n \"def precomp_threshold(dof, len_sim=1e5, beta=.75):\\n for d in dof:\\n cdt = GaussianCusum(arl=None, beta=beta)\\n cdt.fit(x=np.zeros((1, d)), estimate_threshold=True, len_simulation=len_sim,\\n verbose=True, precompute_thresholds=True)\",\n \"def _threshold(data, sigma=2.0):\\r\\n return np.mean(data)-sigma*np.sqrt(np.var(data))\",\n \"def compute_critical_values(P, Q, p, q, mdist, P_dist, Q_dist):\\n origin = eucl_dist(P[0], Q[0])\\n end = eucl_dist(P[-1], Q[-1])\\n end_point = max(origin, end)\\n cc = set([end_point])\\n for i in range(p - 1):\\n for j in range(q - 1):\\n Lij = point_to_seg(Q[j], P[i], P[i + 1], mdist[i, j], mdist[i + 1, j], P_dist[i])\\n if Lij > end_point:\\n cc.add(Lij)\\n Bij = point_to_seg(P[i], Q[j], Q[j + 1], mdist[i, j], mdist[i, j + 1], Q_dist[j])\\n if Bij > end_point:\\n cc.add(Bij)\\n return sorted(list(cc))\",\n \"def get_percentile(self, q):\\n return self.sum_stat_sample_delta.get_percentile(q)\",\n \"def find_q(z, hist_orig):\\n gray_levels = np.arange(BITS) # vector of all the gray levels in range [0, 255]\\n q = np.zeros(len(z)-1)\\n for i in range(len(z)-1):\\n # formula from the class\\n q[i] = np.sum(gray_levels[z[i]:z[i+1]+1]*hist_orig[z[i]:z[i+1]+1]) / np.sum(hist_orig[z[i]:z[i+1]+1])\\n return q.round().astype(np.uint8)\",\n \"def statistics_from_position(target, data, sigma=1.0):\\n from ...algorithms.utils.fast_distance import euclidean_distance as ed\\n if data is None:\\n if target is None:\\n return 0.# could be 1.0 ?\\n else:\\n return 0.\\n if target is None:\\n return 0.\\n\\n dmatrix = ed(data, target) / sigma\\n sensitivity = dmatrix.min(0)\\n sensitivity = np.exp( - 0.5 * sensitivity ** 2)\\n sensitivity = np.mean(sensitivity)\\n return sensitivity\",\n \"def point_dist(p, q):\\n\\tif len(p) != len(q):\\n\\t\\traise ValueError(\\\"Lengths don't match\\\", p, q)\\n\\treturn math.sqrt(sum((a-b)**2 for a,b in zip(p,q)))\",\n \"def quantile(a, prob):\\n a=numpy.asanyarray(a)\\n a=a[numpy.logical_not(numpy.isnan(a))].ravel()\\n n=a.size\\n\\n if prob>=1-.5/n:\\n return a.max()\\n elif prob<=.5/n:\\n return a.min()\\n\\n # find the two bounds we're interpreting between:\\n # that is, find i such that (i+.5) / n <= prob <= (i+1.5)/n\\n t=n*prob-.5\\n i=int(t)\\n\\n # partial sort so that the ith element is at position i, with bigger ones\\n # to the right and smaller to the left\\n a.sort()\\n\\n if i==t: # did we luck out and get an integer index?\\n return a[i]\\n else:\\n # we'll linearly interpolate between this and the next index\\n smaller=a[i]\\n larger=a[i+1:].min()\\n if numpy.isinf(smaller):\\n return smaller # avoid inf - inf\\n return smaller+(larger-smaller)*(t-i)\",\n \"def linear_itp_threshold_func(\\n distribution: List[float],\\n alpha: List[float],\\n **kwargs,\\n) -> float:\\n\\n if len(distribution.shape) > 1:\\n # for reference attacks\\n threshold = np.quantile(\\n distribution, q=alpha[1:-1], method=\\\"linear\\\", axis=1, **kwargs\\n )\\n threshold = np.concatenate(\\n [\\n threshold,\\n np.repeat(distribution.max() + 1e-4, distribution.shape[0]).reshape(\\n 1, -1\\n ),\\n ],\\n axis=0,\\n )\\n threshold = np.concatenate(\\n [\\n np.repeat(distribution.min() - 1e-4, distribution.shape[0]).reshape(\\n 1, -1\\n ),\\n threshold,\\n ],\\n axis=0,\\n )\\n\\n else:\\n threshold = np.quantile(distribution, q=alpha[1:-1], method=\\\"linear\\\", **kwargs)\\n threshold = np.concatenate(\\n [\\n np.array(distribution.min() - 1e-4).reshape(-1),\\n threshold,\\n np.array(distribution.max() + 1e-4).reshape(-1),\\n ],\\n axis=0,\\n )\\n\\n return threshold\",\n \"def distance_to_default(q, *args):\\n # weights found with trial and error, get some wrist bend, but not much\\n weight = [1, 1, 1.3, 1] \\n return np.sqrt(np.sum([(qi - q0i)**2 * wi\\n for qi,q0i,wi in zip(q, self.q0, weight)]))\",\n \"def distance_to_default(q, *args):\\n # weights found with trial and error,\\n # get some wrist bend, but not much\\n weight = [1, 1, 1.3]\\n return np.sqrt(np.sum([(qi - q0i)**2 * wi\\n for qi, q0i, wi in zip(q, self.q0, weight)]))\",\n \"def _evaluate_quality(self, fit_data: curve.CurveFitResult) -> Union[str, None]:\\n freq_increment = np.mean(np.diff(fit_data.x_data))\\n\\n fit_a = fit_data.ufloat_params[\\\"a\\\"]\\n fit_b = fit_data.ufloat_params[\\\"b\\\"]\\n fit_freq = fit_data.ufloat_params[\\\"freq\\\"]\\n fit_kappa = fit_data.ufloat_params[\\\"kappa\\\"]\\n\\n snr = abs(fit_a.n) / np.sqrt(abs(np.median(fit_data.y_data) - fit_b.n))\\n fit_width_ratio = fit_kappa.n / np.ptp(fit_data.x_data)\\n\\n criteria = [\\n fit_data.x_range[0] <= fit_freq.n <= fit_data.x_range[1],\\n 1.5 * freq_increment < fit_kappa.n,\\n fit_width_ratio < 0.25,\\n fit_data.reduced_chisq < 3,\\n curve.utils.is_error_not_significant(fit_kappa),\\n snr > 2,\\n ]\\n\\n if all(criteria):\\n return \\\"good\\\"\\n\\n return \\\"bad\\\"\",\n \"def KL(p, q):\\n return np.sum(p * np.log(p / q))\",\n \"def get_percentile(self, q):\\n raise NotImplementedError(\\\"This is an abstract method and needs to be implemented in derived classes.\\\")\",\n \"def ea_from_q(p, q):\\n return p * q / (0.622 + 0.378 * q)\",\n \"def achisqprob(chisq,df):\\r\\n BIG = 200.0\\r\\n def ex(x):\\r\\n BIG = 200.0\\r\\n exponents = N.where(N.less(x,-BIG),-BIG,x)\\r\\n return N.exp(exponents)\\r\\n\\r\\n if type(chisq) == N.ndarray:\\r\\n arrayflag = 1\\r\\n else:\\r\\n arrayflag = 0\\r\\n chisq = N.array([chisq])\\r\\n if df < 1:\\r\\n return N.ones(chisq.shape,N.float)\\r\\n probs = N.zeros(chisq.shape,N.float_)\\r\\n probs = N.where(N.less_equal(chisq,0),1.0,probs) # set prob=1 for chisq<0\\r\\n a = 0.5 * chisq\\r\\n if df > 1:\\r\\n y = ex(-a)\\r\\n if df%2 == 0:\\r\\n even = 1\\r\\n s = y*1\\r\\n s2 = s*1\\r\\n else:\\r\\n even = 0\\r\\n s = 2.0 * azprob(-N.sqrt(chisq))\\r\\n s2 = s*1\\r\\n if (df > 2):\\r\\n chisq = 0.5 * (df - 1.0)\\r\\n if even:\\r\\n z = N.ones(probs.shape,N.float_)\\r\\n else:\\r\\n z = 0.5 *N.ones(probs.shape,N.float_)\\r\\n if even:\\r\\n e = N.zeros(probs.shape,N.float_)\\r\\n else:\\r\\n e = N.log(N.sqrt(N.pi)) *N.ones(probs.shape,N.float_)\\r\\n c = N.log(a)\\r\\n mask = N.zeros(probs.shape)\\r\\n a_big = N.greater(a,BIG)\\r\\n a_big_frozen = -1 *N.ones(probs.shape,N.float_)\\r\\n totalelements = N.multiply.reduce(N.array(probs.shape))\\r\\n while asum(mask)<>totalelements:\\r\\n e = N.log(z) + e\\r\\n s = s + ex(c*z-a-e)\\r\\n z = z + 1.0\\r\\n# print z, e, s\\r\\n newmask = N.greater(z,chisq)\\r\\n a_big_frozen = N.where(newmask*N.equal(mask,0)*a_big, s, a_big_frozen)\\r\\n mask = N.clip(newmask+mask,0,1)\\r\\n if even:\\r\\n z = N.ones(probs.shape,N.float_)\\r\\n e = N.ones(probs.shape,N.float_)\\r\\n else:\\r\\n z = 0.5 *N.ones(probs.shape,N.float_)\\r\\n e = 1.0 / N.sqrt(N.pi) / N.sqrt(a) * N.ones(probs.shape,N.float_)\\r\\n c = 0.0\\r\\n mask = N.zeros(probs.shape)\\r\\n a_notbig_frozen = -1 *N.ones(probs.shape,N.float_)\\r\\n while asum(mask)<>totalelements:\\r\\n e = e * (a/z.astype(N.float_))\\r\\n c = c + e\\r\\n z = z + 1.0\\r\\n# print '#2', z, e, c, s, c*y+s2\\r\\n newmask = N.greater(z,chisq)\\r\\n a_notbig_frozen = N.where(newmask*N.equal(mask,0)*(1-a_big),\\r\\n c*y+s2, a_notbig_frozen)\\r\\n mask = N.clip(newmask+mask,0,1)\\r\\n probs = N.where(N.equal(probs,1),1,\\r\\n N.where(N.greater(a,BIG),a_big_frozen,a_notbig_frozen))\\r\\n return probs\\r\\n else:\\r\\n return s\",\n \"def probabilistic_thresholding(cmndf, thresholds, p_min, p_max, absolute_min_prob, F_axis, Fs, beta_distr,\\n parabolic_interp=True):\\n # restrict search range to interval [p_min:p_max]\\n cmndf[:p_min] = np.inf\\n cmndf[p_max:] = np.inf\\n\\n # find local minima (assuming that cmndf is real in [p_min:p_max], you will always find a minimum,\\n # at least p_min or p_max)\\n min_idxs = (np.argwhere((cmndf[1:-1] < cmndf[0:-2]) & (cmndf[1:-1] < cmndf[2:]))).flatten().astype(np.int64) + 1\\n\\n O_m = np.zeros(2 * len(F_axis))\\n\\n # return if no minima are found, e.g., when frame is silence\\n if min_idxs.size == 0:\\n return O_m, np.ones_like(thresholds)*p_min, np.ones_like(thresholds)\\n\\n # Optional: Parabolic Interpolation of local minima\\n if parabolic_interp:\\n # do not interpolate at the boarders, Numba compatible workaround for np.delete()\\n min_idxs_interp = delete_numba(min_idxs, np.argwhere(min_idxs == p_min))\\n min_idxs_interp = delete_numba(min_idxs_interp, np.argwhere(min_idxs_interp == p_max - 1))\\n p_corr, cmndf[min_idxs_interp] = parabolic_interpolation(cmndf[min_idxs_interp - 1],\\n cmndf[min_idxs_interp],\\n cmndf[min_idxs_interp + 1])\\n else:\\n p_corr = np.zeros_like(min_idxs).astype(np.float64)\\n\\n # set p_corr=0 at the boarders (no correction done later)\\n if min_idxs[0] == p_min:\\n p_corr = np.concatenate((np.array([0.0]), p_corr))\\n\\n if min_idxs[-1] == p_max - 1:\\n p_corr = np.concatenate((p_corr, np.array([0.0])))\\n\\n lag_thr = np.zeros_like(thresholds)\\n val_thr = np.zeros_like(thresholds)\\n\\n # loop over all thresholds\\n for i, threshold in enumerate(thresholds):\\n # minima below absolute threshold\\n min_idxs_thr = min_idxs[cmndf[min_idxs] < threshold]\\n\\n # find first local minimum\\n if not min_idxs_thr.size:\\n lag = np.argmin(cmndf) # choose absolute minimum when no local minimum is found\\n am_prob = absolute_min_prob\\n val = np.min(cmndf)\\n else:\\n am_prob = 1\\n lag = np.min(min_idxs_thr) # choose first local minimum\\n val = cmndf[lag]\\n\\n # correct lag\\n if parabolic_interp:\\n lag += p_corr[np.argmin(min_idxs_thr)]\\n\\n # ensure that lag is in [p_min:p_max]\\n if lag < p_min:\\n lag = p_min\\n elif lag >= p_max:\\n lag = p_max - 1\\n\\n lag_thr[i] = lag\\n val_thr[i] = val\\n\\n idx = np.argmin(np.abs(1200 * np.log2(F_axis / (Fs / lag)))) # quantize estimated period\\n O_m[idx] += am_prob * beta_distr[i] # pYIN-Paper, Formula 4/5\\n\\n return O_m, lag_thr, val_thr\",\n \"def get_optimal_threshhold(true_label, prediction, iterations=100, size=17):\\n best_threshhold = [0.2]*size\\n for t in range(size):\\n best_fbeta = 0\\n temp_threshhold = [0.2]*size\\n for i in range(iterations):\\n temp_value = i / float(iterations)\\n temp_threshhold[t] = temp_value\\n temp_fbeta = fbeta(true_label, prediction > temp_threshhold)\\n if temp_fbeta > best_fbeta:\\n best_fbeta = temp_fbeta\\n best_threshhold[t] = temp_value\\n return best_threshhold\",\n \"def torch_percentile(t, q):\\n # Note that ``kthvalue()`` works one-based, i.e. the first sorted value\\n # indeed corresponds to k=1, not k=0! Use float(q) instead of q directly,\\n # so that ``round()`` returns an integer, even if q is a np.float32.\\n k = 1 + round(.01 * float(q) * (t.numel() - 1))\\n result = t.view(-1).kthvalue(k).values.item()\\n return result\",\n \"def KL(P,Q):\\n epsilon = 0.00001\\n \\n #You may want to instead make copies to avoid changing the np arrays.\\n P = P+epsilon\\n Q = Q+epsilon\\n \\n divergence = np.sum(P*np.log(P/Q))\\n return divergence\",\n \"def distance(p, q):\\n return norm(np.asarray(p) - np.asarray(q))\",\n \"def relative_entropy(P, Q):\\n return rel_entropy_P_Q\",\n \"def dp_quantile(data, alpha, candidates=None, lower=None, upper=None, mechanism=\\\"Automatic\\\", privacy_usage=None, interpolation=\\\"midpoint\\\", **kwargs):\\n return Component(\\n \\\"DPQuantile\\\",\\n arguments={\\n 'data': Component.of(data),\\n 'candidates': Component.of(candidates),\\n 'lower': Component.of(lower),\\n 'upper': Component.of(upper)\\n },\\n options={\\n 'alpha': alpha,\\n 'mechanism': mechanism,\\n 'privacy_usage': serialize_privacy_usage(privacy_usage),\\n 'interpolation': interpolation\\n },\\n constraints=kwargs)\",\n \"def calculate_cramer_von_mises(p, q, num_samples=100, _random_state=None, **kwargs): # pylint: disable=unused-argument\\n logging.warning(\\\"This function is deprecated, please use `calculate_goodness_of_fit`\\\") # pragma: no cover\",\n \"def selectThreshold(yval, pval):\\n bestEpsilon = 0\\n bestF1 = 0\\n F1 = 0\\n\\n stepsize = (pval.max()-pval.min())/1000\\n for epsilon in np.arange(pval.min(), pval.max()+stepsize/2, stepsize):\\n predictions = (pval < epsilon)\\n tp = ((predictions == 1) & (yval == 1)).sum()\\n fp = ((predictions == 1) & (yval == 0)).sum()\\n fn = ((predictions == 0) & (yval == 1)).sum()\\n prec = tp/(tp+fp)\\n rec = tp/(tp+fn)\\n F1 = 2*prec*rec/(prec+rec)\\n\\n if F1 > bestF1:\\n bestF1 = F1\\n bestEpsilon = epsilon\\n\\n return bestEpsilon, bestF1\",\n \"def _set_target_quality(self):\\n best_model = clone(self.model)\\n # train and avaluate the model on the full size of potential dataset\\n best_model.fit(self.dataset.train_data, np.ravel(self.dataset.train_labels))\\n test_prediction = best_model.predict(self.dataset.test_data) \\n max_quality = self.quality_method(self.dataset.test_labels, test_prediction)\\n # the target_quality after which the episode stops is a proportion of the max quality\\n self.target_quality = self.tolerance_level*max_quality\",\n \"def FMScore(x,p,d):\\n \\n if x <= d[p][0.20]:\\n return 1\\n elif x <= d[p][0.4]:\\n return 2\\n elif x <= d[p][0.6]: \\n return 3\\n elif x <= d[p][0.8]:\\n return 4\\n else:\\n return 5\",\n \"def FMScore(x,p,d):\\n \\n if x <= d[p][0.20]:\\n return 1\\n elif x <= d[p][0.4]:\\n return 2\\n elif x <= d[p][0.6]: \\n return 3\\n elif x <= d[p][0.8]:\\n return 4\\n else:\\n return 5\",\n \"def ham_dist(p, q):\\n count = 0\\n for i in range(len(p)):\\n if p[i] != q[i]:\\n count += 1\\n return count\",\n \"def ham_dist(p, q):\\n count = 0\\n for i in range(len(p)):\\n if p[i] != q[i]:\\n count += 1\\n return count\",\n \"def quantile_normalize_using_target(x, target):\\n\\n target_sorted = np.sort(target)\\n\\n return target_sorted[x.argsort().argsort()]\",\n \"def find_metric_threshold(self):\\n logger.info(\\\"compute metric threshold\\\")\\n\\n ### Beaucoup trop lent quand on a beaucoup de models ###\\n\\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\\n\\n if len(df_results_not_aggregated) == 0:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n main_scorer = \\\"test_%s\\\" % self.job_config.main_scorer\\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\\n min_cv = df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].min().values\\n delta_min_max_cv = np.median(\\n df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].apply(lambda x: x.max() - x.min())\\n )\\n\\n if len(min_cv) <= self.min_nb_of_models:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n min_cv = -np.sort(-min_cv)\\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\\n\\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\\n\\n logger.info(\\\"threshold : %2.2f\\\" % result)\\n return result\",\n \"def sample_distrib(d_t, data_set, set_size, max_wanted_samples):\\n # when distrib is updated it seems some distrib[i] are updated too much so max is really high and\\n training_samples = []\\n # distrib_mean = np.mean(d_t)\\n distrib_max = max(d_t)\\n for _ in range(max_wanted_samples):\\n id = rd.randint(0, set_size)\\n sample = data_set[id]\\n # v = rd.uniform(0, distrib_mean)\\n v = rd.uniform(0, distrib_max)\\n if d_t[id] > v:\\n training_samples.append(sample)\\n return training_samples\",\n \"def threshold_fit_quantile(X, y, alpha, gamma, n_class, kernel_type, loss_function,\\n opt_type, opt_params, mode='QE', max_iter=1000, \\n verbose=False, tol=1e-12, sample_weight=None):\\n\\n X, y = check_X_y(X, y, accept_sparse='csr')\\n unique_y = np.sort(np.unique(y))\\n '''\\n if not np.all(unique_y == np.arange(unique_y.size)):\\n raise ValueError(\\n 'Values in y must be %s, instead got %s'\\n % (np.arange(unique_y.size), unique_y))\\n '''\\n n_samples, n_features = X.shape\\n\\n # convert from c to theta\\n L = np.zeros((n_class - 1, n_class - 1))\\n L[np.tril_indices(n_class-1)] = 1.\\n\\n if mode == '0-1' or mode == 'Direct':\\n loss_fd = (1 - gamma) * np.diag(np.ones(n_class - 1)) + \\\\\\n gamma * np.diag(np.ones(n_class - 2), k=-1)\\n loss_fd = np.vstack((loss_fd, np.zeros(n_class - 1)))\\n loss_fd[-1, -1] = gamma # border case\\n elif mode == 'AE':\\n # loss forward difference\\n loss_fd = np.ones((n_class, n_class - 1)) * (1 - gamma)\\n lower_indices = np.tril_indices(n = n_class, k = -1)\\n loss_fd[lower_indices] = gamma\\n else:\\n raise NotImplementedError\\n\\n x0 = np.zeros(n_features + n_class - 1)\\n x0[X.shape[1]:] = np.arange(n_class - 1)\\n options = {'maxiter' : max_iter, 'disp': verbose}\\n if n_class > 2:\\n bounds = [(None, None)] * (n_features + 1) + \\\\\\n [(0, None)] * (n_class - 2)\\n else:\\n bounds = None\\n\\n if (mode != 'Direct'):\\n if(opt_type == 'SciPy'):\\n sol = optimize.minimize(obj_margin, x0, method='L-BFGS-B',\\n bounds=bounds, options=options, \\n args=(X, y, alpha, n_class, loss_fd, L, kernel_type, loss_function, sample_weight),\\n tol=tol)\\n sol = sol.x\\n else: \\n sol = optimize_batch(obj_function=obj_margin, x0=x0, method=opt_type, \\n bounds=bounds, gradient=grad_margin, opt_params=opt_params,\\n args=(X, y, alpha, n_class, loss_fd, L, kernel_type, loss_function, sample_weight))\\n else:\\n sol = optimize.minimize(obj_direct, x0, method='L-BFGS-B',\\n jac=grad_direct, bounds=bounds, options=options,\\n args=(X, y, alpha, gamma, n_class, loss_fd, L, kernel_type, loss_function, sample_weight),\\n tol=tol)\\n \\n if verbose and not sol.success:\\n print(sol.message)\\n\\n w, c = sol[:X.shape[1]], sol[X.shape[1]:]\\n theta = L.dot(c)\\n return w, theta\",\n \"def maxOldQ(self,feat):\\r\\n maxQ = float('-inf')\\r\\n for a in self.actions:\\r\\n q = self.oldQ(feat,a)\\r\\n \\r\\n if q > maxQ:\\r\\n maxQ = q\\r\\n \\r\\n return(maxQ)\",\n \"def selectThreshold(yval, pval):\\n\\tbestEpsilon = 0\\n\\tbestF1 = 0\\n\\tstepsize = (np.max(pval) - np.min(pval)) / 1000\\n\\n\\tfor epsilon in np.arange(np.min(pval), np.max(pval), stepsize):\\n\\t\\tpredictions = (pval < epsilon) + 0\\n\\t\\ttp = np.sum((yval == 1) & (predictions == 1))\\n\\t\\tfp = np.sum((yval == 0) & (predictions == 1))\\n\\t\\tfn = np.sum((yval == 1) & (predictions == 0))\\n\\t\\tif tp + fp == 0:\\n\\t\\t\\tcontinue\\n\\t\\tprec = float(tp) / (tp + fp) # tips: cast int to float, or you will get 0\\n\\t\\trec = float(tp) / (tp + fn)\\n\\t\\tF1 = 2.0 * prec * rec / (prec + rec)\\n\\t\\tif F1 > bestF1:\\n\\t\\t\\tbestF1 = F1\\n\\t\\t\\tbestEpsilon = epsilon\\n\\treturn bestEpsilon, bestF1\",\n \"def quantile(self, q, *, axis=0, **kwargs) -> \\\"Dataset\\\":\\n return self._quantile(q, axis=axis, func=np.quantile, **kwargs)\",\n \"def get_variance_threshold(variances, whisker_percent, whisker_length):\\n low_percentiles, high_percentiles = np.percentile(variances, (whisker_percent, 100-whisker_percent))\\n threshold = high_percentiles + (high_percentiles - low_percentiles) * whisker_length\\n\\n return threshold\",\n \"def dataset_quality_score(data_matrix, threshold=0.2, good_days=None,\\n use_advanced=True):\\n if good_days is None:\\n if use_advanced:\\n good_days = daily_missing_data_advanced(data_matrix, threshold=threshold)\\n else:\\n good_days = daily_missing_data_simple(data_matrix, threshold=threshold)\\n score = np.sum(good_days) / data_matrix.shape[1]\\n return score\",\n \"def tpr(positive, negative, fpr):\\n threshold = np.percentile(np.asarray(negative), 100 - fpr)\\n total_true_positives = sum(positive > threshold)\\n\\n return total_true_positives / len(positive)\",\n \"def perform_thresholding(f,M,type):\\n if type == \\\"largest\\\":\\n a = np.sort(np.ravel(abs(f)))[::-1] #sort a 1D copy of F in descending order\\n T = a[M]\\n y = f*(abs(f) > T)\\n elif type == \\\"soft\\\":\\n s = abs(f) - M\\n s = (s + abs(s))/2\\n y = np.sign(f)*s\\n elif type == \\\"hard\\\":\\n y = f*(abs(f) > M)\\n return y\",\n \"def get_optimal_bst(p, q):\\n\\n assert p is not None\\n assert q is not None\\n assert len(p) == len(q)\\n n = len(p) - 1\\n assert n >= 0\\n\\n if n == 0:\\n return 1.0, []\\n\\n e = [[-1 for _ in range(0, n + 1)] for _ in range(0, n + 1)]\\n root = [[-1 for _ in range(0, n)] for _ in range(0, n)]\\n\\n for i in range(1, n + 1):\\n e[i][i] = (q[i - 1] + q[i]) * 2 + p[i]\\n root[i - 1][i - 1] = i\\n\\n for i in range(n + 1, 0, -1):\\n for j in range(i + 1, n + 1):\\n w = sum(q[i - 1:j + 1]) + sum(p[i:j + 1])\\n min_cost = sys.maxsize\\n current_root = -1\\n for r in range(i, j + 1):\\n assert (r == i or e[i][r - 1] > 0) and (r == j or e[r + 1][j] > 0)\\n e_left = q[i - 1] if r == i else e[i][r - 1]\\n e_right = q[j] if r == j else e[r + 1][j]\\n e_cost = w + e_left + e_right\\n\\n if e_cost < min_cost:\\n min_cost = e_cost\\n current_root = r\\n\\n e[i][j] = min_cost\\n root[i - 1][j - 1] = current_root\\n\\n return e[1][n], root\",\n \"def test__quantile(self):\\r\\n # regular cases\\r\\n sample_data = array(range(25, 42))\\r\\n assert_almost_equal(_quantile(sample_data, 0.5), median(sample_data))\\r\\n\\r\\n # sorted data is assumed for this function\\r\\n sample_data = sorted(\\r\\n array([0.17483293, 0.99891939, 0.81377467, 0.8137437,\\r\\n 0.51990174, 0.35521497, 0.98751461]))\\r\\n assert_almost_equal(_quantile(sample_data, 0.10), 0.283062154)\",\n \"def detect_peak(data):\\n nonlocal last, ascent_dist, ascent_start\\n if data > last:\\n if ascent_start is None:\\n ascent_start = last\\n ascent_dist += 1\\n else:\\n if ascent_dist:\\n peak = last\\n ascent_dist = 0\\n if (peak - ascent_start) > thresh:\\n last = data\\n ascent_start = None\\n return peak\\n ascent_start = None\\n last = data\\n return None\",\n \"def calc_q1(data: list) -> float:\\n py = copy.copy(data)\\n py.sort()\\n return py[round(len(py) / 4)]\",\n \"def fit_threshold(data, rho_cutoff=0., maxedges=None, diag=1e-6):\\n from scipy.linalg import inv as scipy_inv\\n n,m = data.shape\\n sig = np.cov(data,ddof=0,aweights=None) + diag*np.eye(n);\\n J = -scipy_inv(sig); J = .5*(J+J.T); # symmetrize just in case\\n Jdiag = J[range(n),range(n)]; J[range(n),range(n)] = 0. # zero diagonal for threshold op\\n if maxedges is not None:\\n if maxedges > J.size: rho_cutoff = 0.\\n else: rho_cutoff = max(rho_cutoff, -np.sort(np.abs(J).reshape(-1))[2*maxedges])\\n J[ np.abs(J) <= rho_cutoff ] = 0.\\n J[range(n),range(n)] = Jdiag; # restore diagonal\\n J[range(n),range(n)] -= J.dot(np.mean(data,1)) # add singleton terms (TODO: CHECK)\\n return Ising(J)\",\n \"def delete_outliers_of_data_before(data: np.ndarray, qi_inspect: int, threshold: int):\\n idx_to_del = []\\n done = False\\n for j in range(data.shape[0]):\\n if data[j, qi_inspect] < threshold:\\n if not done:\\n idx_to_del = j\\n done = True\\n else:\\n idx_to_del = np.append(idx_to_del, j)\\n return np.delete(data, idx_to_del, axis=0)\",\n \"def ds_preprocessing(x, error_threshold, min_val=0, max_val=1):\\n # Scale in range [min_val, max_val]\\n scaler = MinMaxScaler((min_val, max_val))\\n processed = scaler.fit_transform(x)\\n\\n # Quantization\\n bins = np.arange(min_val, max_val, 2 * error_threshold)\\n digitized = np.digitize(processed, bins)\\n quantized = (digitized - 1) * (2 * error_threshold) + error_threshold\\n\\n return quantized, scaler\",\n \"def prctile(data, p_vals=[0, 25, 50, 75, 100], sorted_=False):\\r\\n ps = [p_vals] if np.isscalar(p_vals) else p_vals\\r\\n\\r\\n if not sorted_:\\r\\n data = sorted(data)\\r\\n n = len(data)\\r\\n d = []\\r\\n for p in ps:\\r\\n fi = p * n / 100 - 0.5\\r\\n if fi <= 0: # maybe extrapolate?\\r\\n d.append(data[0])\\r\\n elif fi >= n - 1:\\r\\n d.append(data[-1])\\r\\n else:\\r\\n i = int(fi)\\r\\n d.append((i+1 - fi) * data[i] + (fi - i) * data[i+1])\\r\\n return d[0] if np.isscalar(p_vals) else d\",\n \"def q_from_ea(ea, p):\\n return 0.622 * ea / (p - 0.378 * ea)\",\n \"def _estimate_threshold(self, **kwargs):\\n recompute_threshold = kwargs.pop('recompute_threshold', False)\\n # if threshold is in table, then use it.\\n current_setting = (self.beta, self.chi2dist.kwds['df'])\\n threshold = None\\n res = False\\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\\n for e in _gaussian_cusum_thresholds[current_setting]:\\n if e[0] == self.arl:\\n threshold = np.array([e[1]])\\n res = True\\n # if threshold not is in table, estimate it\\n if threshold is None:\\n len_simulation = kwargs.pop('len_simulation', None)\\n if len_simulation is None:\\n len_simulation = 10 * self.arl\\n self.log.info(\\\"estimating threshold...\\\")\\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\\n plain_cusum.gamma = self.gamma\\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\\n kwargs.pop('x', None)\\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\\n **kwargs)\\n threshold = plain_cusum.threshold\\n self.threshold = threshold\\n return res\",\n \"def test_samples_close_to_inclusion_probability_priority(self):\\n # The range we allow around 0.5n\\n distance_from_half = 0.01\\n # The number of elements we use (computed using Chernoff bounds)\\n n = int((6.0 / (distance_from_half**2)) *\\n math.log(2 * FAILURE_PROBABILITY_INVERSE, math.e) + 1)\\n s = private_sampling.ThresholdSample(\\n 0.5, private_sampling.PrioritySamplingMethod)\\n for i in range(n):\\n s.process(i, 1.0)\\n self.assertGreaterEqual(len(s.elements), (0.5 - distance_from_half) * n)\\n self.assertLessEqual(len(s.elements), (0.5 + distance_from_half) * n)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6154804","0.60241234","0.5915163","0.5851482","0.5744234","0.56960785","0.5515238","0.54940593","0.5455812","0.5423219","0.5397638","0.53936654","0.5350975","0.53223306","0.52922076","0.52854943","0.52854943","0.52854943","0.5275716","0.5255272","0.52247465","0.5217178","0.52116954","0.5206813","0.5174021","0.5168736","0.51607096","0.51522523","0.5141877","0.5134799","0.5134799","0.51287234","0.5119268","0.50963515","0.5094937","0.50790054","0.50754297","0.50696456","0.5059379","0.5051333","0.50431293","0.5034282","0.50064534","0.49988934","0.4997431","0.49895817","0.4986127","0.49836615","0.49760944","0.49760944","0.49726933","0.49657646","0.49622977","0.4955022","0.4950896","0.49355292","0.49327773","0.49316892","0.49013624","0.48953196","0.48919192","0.4885871","0.4879194","0.48760322","0.48756346","0.48731253","0.4865087","0.48632553","0.48560795","0.4839433","0.48354387","0.4827764","0.48258767","0.48232868","0.48219728","0.48195583","0.48195583","0.4810462","0.4810462","0.48096597","0.48094255","0.48092303","0.48000124","0.4799032","0.47974673","0.47940922","0.47906184","0.47848222","0.47841296","0.47825557","0.47824532","0.47817212","0.47814077","0.47790965","0.47739163","0.47719184","0.4763188","0.47531712","0.474949","0.47481328","0.47473085"],"string":"[\n \"0.6154804\",\n \"0.60241234\",\n \"0.5915163\",\n \"0.5851482\",\n \"0.5744234\",\n \"0.56960785\",\n \"0.5515238\",\n \"0.54940593\",\n \"0.5455812\",\n \"0.5423219\",\n \"0.5397638\",\n \"0.53936654\",\n \"0.5350975\",\n \"0.53223306\",\n \"0.52922076\",\n \"0.52854943\",\n \"0.52854943\",\n \"0.52854943\",\n \"0.5275716\",\n \"0.5255272\",\n \"0.52247465\",\n \"0.5217178\",\n \"0.52116954\",\n \"0.5206813\",\n \"0.5174021\",\n \"0.5168736\",\n \"0.51607096\",\n \"0.51522523\",\n \"0.5141877\",\n \"0.5134799\",\n \"0.5134799\",\n \"0.51287234\",\n \"0.5119268\",\n \"0.50963515\",\n \"0.5094937\",\n \"0.50790054\",\n \"0.50754297\",\n \"0.50696456\",\n \"0.5059379\",\n \"0.5051333\",\n \"0.50431293\",\n \"0.5034282\",\n \"0.50064534\",\n \"0.49988934\",\n \"0.4997431\",\n \"0.49895817\",\n \"0.4986127\",\n \"0.49836615\",\n \"0.49760944\",\n \"0.49760944\",\n \"0.49726933\",\n \"0.49657646\",\n \"0.49622977\",\n \"0.4955022\",\n \"0.4950896\",\n \"0.49355292\",\n \"0.49327773\",\n \"0.49316892\",\n \"0.49013624\",\n \"0.48953196\",\n \"0.48919192\",\n \"0.4885871\",\n \"0.4879194\",\n \"0.48760322\",\n \"0.48756346\",\n \"0.48731253\",\n \"0.4865087\",\n \"0.48632553\",\n \"0.48560795\",\n \"0.4839433\",\n \"0.48354387\",\n \"0.4827764\",\n \"0.48258767\",\n \"0.48232868\",\n \"0.48219728\",\n \"0.48195583\",\n \"0.48195583\",\n \"0.4810462\",\n \"0.4810462\",\n \"0.48096597\",\n \"0.48094255\",\n \"0.48092303\",\n \"0.48000124\",\n \"0.4799032\",\n \"0.47974673\",\n \"0.47940922\",\n \"0.47906184\",\n \"0.47848222\",\n \"0.47841296\",\n \"0.47825557\",\n \"0.47824532\",\n \"0.47817212\",\n \"0.47814077\",\n \"0.47790965\",\n \"0.47739163\",\n \"0.47719184\",\n \"0.4763188\",\n \"0.47531712\",\n \"0.474949\",\n \"0.47481328\",\n \"0.47473085\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83795,"cells":{"query":{"kind":"string","value":"Computes entropyregularized optimal transport between x and y"},"document":{"kind":"string","value":"def compute(self, x, y, u=None, grad=False):\n assert_histograms(x, y)\n if u is not None:\n self.__u = u\n else:\n self.__u = rescale(self.__u)\n self.__assert_correct_size(x, y)\n self.__compute(x, y)\n\n obj = self.__ground_metric.gamma * (x.T.dot(log_with_zeros(self.__u)) + y.T.dot(log_with_zeros(self.__v)) - 1\n + self.__u.T.dot(self.__ground_metric.dot(self.__v)))\n\n if grad:\n return obj, self.get_gradient(self.__v)\n return obj"},"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 transfer_entropy(X, Y):\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\n\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\n for y_f, x_p, y_p in coords.keys():\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\n\n p_yp = p_dist.sum(axis=2).sum(axis=1)\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\n\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\n denominator[denominator == 0] = np.nan\n\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\n division[division == 0] = np.nan\n\n log = np.log2(division)\n\n return np.nansum(np.multiply(p_dist, log))","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def dist_calc(self, x, y):\n p_xy = self.d2_bin(x, y)\n p_x = np.sum(p_xy, axis=1)\n p_y = np.sum(p_xy, axis=0)\n\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\n\n output = max(0.0, (1 - (info / entropy)))\n return output","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def mutual_information(x, y):\r\n\r\n # INSERT YOUR CODE HERE\r\n xvalue, xcount = np.unique(x,return_counts = True)\r\n probx = xcount.astype(float)/len(x)\r\n Hyx = 0.0\r\n for pxval,xval in zip(probx,xvalue):\r\n Hyx += (pxval)*entropy(y[x==xval])\r\n \r\n Ixy = entropy(y) - Hyx\r\n return Ixy\r\n raise Exception('Function not yet implemented!')","def _cal_igr(x, y):\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","def entropy(self):\n\n \"\"\"Gets the first neighbours, which are the first 2*r+1 cells.\"\"\"\n current_neighbours = []\n amount = [0] * self.k ** (2 * self.r + 1)\n for i in range(2 * self.r + 1):\n current_neighbours.append(self.config[self.t, i % self.width])\n\n \"\"\"Calculates the rule and adds one to it's amount. It then removes the\n leftmost cell and adds a cell to the right.\"\"\"\n for i in range(len(self.config[self.t]) - 1):\n rule = 0\n for j in range(len(current_neighbours)):\n rule += int(current_neighbours[j] *\n self.k ** ((2 * self.r + 1) - j - 1))\n amount[len(amount) - 1 - rule] += 1\n current_neighbours.pop(0)\n current_neighbours.append(\n self.config[self.t, (2 * self.r + 1 + i) % self.width])\n\n \"\"\"Calculates the rule for the last neighbourhood.\"\"\"\n rule = 0\n for j in range(len(current_neighbours)):\n rule += int(current_neighbours[j] *\n self.k ** ((2 * self.r + 1) - j - 1))\n amount[len(amount)-1 - rule] += 1\n\n \"\"\"Calculates the Shannon entropy and the the average entropy so far.\"\"\"\n shannon = 0\n for i in range(len(amount)):\n if(amount[i] != 0):\n probability = amount[i] / self.width\n shannon -= probability * np.log2(probability)\n self.average_entropy = (self.average_entropy *\n self.t + shannon) / (self.t + 1)","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def calc_entropy(graph, X, res=1):\n\n ## x, y, speed, start_x, start_y, end_x, end_y, direction_x, direction_y, distance, sigma, w\n M = X.shape[0]\n N = X.shape[1]\n # calculate the distance of each particle from the beginning of its road segment\n dists = np.linalg.norm(X[:,:, :2] - X[:,:, 3:5], axis=-1)\n\n h = np.zeros(M)\n for start in graph.keys():\n for end in graph[start].keys():\n length = graph[start][end]\n # find the particles on this road segment\n on_edge = np.all(X[:,:, 3:7] == start + end, axis=-1)\n for idx in range(M):\n bin_start = 0.0\n while bin_start < length:\n in_bin = np.all([dists >= bin_start, dists <= bin_start + res], axis=0)\n\n count = np.sum(np.all([on_edge[idx], in_bin[idx]], axis=0))# + np.sum(np.all([on_edge, in_bin_reverse], axis=0))\n p = count / (N)\n if p > 0:\n h[idx] -= p*np.log(p)\n bin_start += res\n return h#, [get_pos_var(X[idx], hist) for idx in range(M)], counts, probs","def entropy(y,w):\r\n\r\n\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\r\n\r\n # y_partition = partition(y)\r\n # elements,counts = np.unique(y,return_counts = True)\r\n # entropy=0\r\n\r\n # for i in range(len(elements)):\r\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\r\n # return entropy\r\n\r\n entropy = 0\r\n # two hypothesis cases 0,1\r\n h = {0: 0, 1: 0}\r\n leny = len(y)\r\n for i in range(leny):\r\n # if y is 0 add 0 to the weight\r\n if y[i] == 0:\r\n h[0] += w[i]\r\n # if y is 1 add 1 to the weight\r\n elif y[i] == 1:\r\n h[1] += + w[i]\r\n # summing all the weighted values \r\n val_sum = h[0] + h[1]\r\n\r\n # entropy calculation\r\n for j in range(len(h)):\r\n h[j] = h[j]/val_sum\r\n # to prevent divide by zero\r\n if h[j] != 0:\r\n entropy += h[j] * np.log2(h[j])\r\n entropy = -(entropy)\r\n return entropy","def fit(self, x, y):\n # *** START CODE HERE ***\n num_examples = x.shape[0]\n num_features = x.shape[1]\n iteration = 1\n if self.theta == None:\n self.theta = np.zeros((num_features,))\n while iteration <= self.max_iter:\n h_theta = np.dot(x, self.theta)\n g_theta = self.sigmoid(h_theta)\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\n d_theta = - np.linalg.solve(H, J_prime)\n self.theta += d_theta\n if np.linalg.norm(d_theta, 1) < self.eps:\n break\n if self.verbose:\n print(\"Loss value: \", J_cost)\n iteration += 1\n # *** END CODE HERE ***","def attack(self, x, y_p, **kwargs):\n inputs = []\n outputs = []\n\n # Create the initial random perturbation\n device_name = '/gpu:0'\n self.model.set_device(device_name)\n with tf.device(device_name):\n with tf.variable_scope('init_rand'):\n if self.rand_init:\n eta = tf.random_uniform(tf.shape(x), -self.eps, self.eps)\n eta = clip_eta(eta, self.ord, self.eps)\n eta = tf.stop_gradient(eta)\n else:\n eta = tf.zeros_like(x)\n\n # TODO: Break the graph only nGPU times instead of nb_iter times.\n # The current implementation by the time an adversarial example is\n # used for training, the weights of the model have changed nb_iter\n # times. This can cause slower convergence compared to the single GPU\n # adversarial training.\n for i in range(self.nb_iter):\n # Create the graph for i'th step of attack\n inputs += [OrderedDict()]\n outputs += [OrderedDict()]\n device_name = x.device\n self.model.set_device(device_name)\n with tf.device(device_name):\n with tf.variable_scope('step%d' % i):\n if i > 0:\n # Clone the variables to separate the graph of 2 GPUs\n x = clone_variable('x', x)\n y_p = clone_variable('y_p', y_p)\n eta = clone_variable('eta', eta)\n\n inputs[i]['x'] = x\n inputs[i]['y_p'] = y_p\n outputs[i]['x'] = x\n outputs[i]['y_p'] = y_p\n inputs[i]['eta'] = eta\n\n eta = self.attack_single_step(x, eta, y_p)\n\n if i < self.nb_iter-1:\n outputs[i]['eta'] = eta\n else:\n # adv_x, not eta is the output of the last step\n adv_x = x + eta\n if (self.clip_min is not None and self.clip_max is not None):\n adv_x = tf.clip_by_value(adv_x, self.clip_min, self.clip_max)\n adv_x = tf.stop_gradient(adv_x, name='adv_x')\n outputs[i]['adv_x'] = adv_x\n\n return inputs, outputs","def fit(self, x, y):\n def initiate_theta(dim):\n self.theta = np.zeros(dim)\n # print('self.theta initiated is {}'.format(self.theta))\n \n def implement_sigmoid(x):\n if self.theta is None:\n initiate_theta(x.shape[1])\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\n \n def implement_partial_loss(x, y):\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\n \n def implement_transposed_hess(x):\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\n hess2 = np.diag(sigmoid_hadamard)\n hess = np.matmul(hess2,x)\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\n hess_inverse = np.linalg.inv(hess)\n return hess_inverse\n \n def train(x, y):\n count = 0\n if self.theta is None:\n initiate_theta(x.shape[1])\n while count < self.max_iter:\n if self.verbose:\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\n print('Average empirical loss for step {} is {}'.format(count, loss))\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\n new_theta = self.theta - delta * self.step_size\n delta_theta = np.linalg.norm(new_theta - self.theta)\n # print('delta is {}'.format(delta_theta))\n if delta_theta < self.eps:\n return new_theta\n else:\n self.theta = new_theta\n count += 1\n return self.theta\n \n return train(x, y)","def proximal(self):\n functional = self\n\n class EntRegOptTransProximal(Operator):\n\n \"\"\"Proximal operator of entropy regularized optimal transport.\n\n The prox is given by::\n\n prox_[gamma*T_eps](mu1) = arg min_x (T_epsilon(mu0, x) +\n 1/(2*gamma) ||x - mu1||^2_2)\n \"\"\"\n\n def __init__(self, sigma):\n \"\"\"Initialize a new instance.\n\n Parameters\n ----------\n sigma : positive float\n \"\"\"\n self.sigma = float(sigma)\n super().__init__(domain=functional.domain,\n range=functional.domain, linear=False)\n\n # Setting up parameters\n self.const = 1 / (functional.epsilon * sigma)\n\n def _call(self, x):\n \"\"\"Apply the operator to ``x``.\"\"\"\n u = functional.tmp_u_prox\n v = functional.tmp_v_prox\n\n # Running generalized Sinkhorn iterations\n for j in range(functional.niter):\n # Safe-guarded u-update, to avoid divide-by-zero error.\n u_old = u.copy()\n tmp1 = functional.K_op(v)\n if np.min(tmp1) < 1e-30 or np.max(tmp1) > 1e+50:\n print('Numerical instability, truncation in Transport prox (Kv)',\n str(np.min(tmp1)), str(np.max(tmp1)))\n\n tmp = np.fmax(tmp1, 1e-30)\n\n\n u = functional.mu0 / tmp\n if np.min(u) < 1e-30 or np.max(u) > 1e+50:\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\n\n # Safe-guarded v-update, to avoid divide-by-zero error.\n v_old = v.copy()\n\n tmp3 = functional.K_op_adjoint(u)\n if np.min(tmp3) < 1e-30 or np.max(tmp3) > 1e+50:\n print('Truncation in Transport prox (KTu)',\n str(np.min(tmp3)), str(np.max(tmp3)))\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\n\n tmp4 = (self.const * tmp3 * np.exp(self.const * x))\n\n if np.min(tmp4) < 1e-30 or np.max(tmp4) > 1e+200:\n print('Argument in lambdert omega (min/max)',\n str(np.min(tmp4)), str(np.max(tmp4)))\n\n v = np.exp(self.const * x - lambertw_fulfix(tmp4))\n\n v1 = np.exp(self.const * x - scipy.special.lambertw(\n tmp4))\n if (v-v1).norm() > 1e-10:\n print('diff pga ny lambderw omega funciton',\n str((v-v1).norm()))\n print('v (min/max)', str(np.min(v)), str(np.max(v)))\n print('Argument in lambdert omega (min/max)',\n str(np.min(tmp4)), str(np.max(tmp4)))\n\n # If the updates in both u and v are small, break the loop\n if ((np.log(v)-np.log(v_old)).norm() < 1e-8 and\n (np.log(u)-np.log(u_old)).norm() < 1e-8):\n break\n\n # Store the u and v in the internal temporary variables of the\n # functional\n functional.tmp_u_prox = u\n functional.tmp_v_prox = v\n\n return x - self.sigma * functional.epsilon * np.log(v)\n\n return EntRegOptTransProximal","def ev_harvest(t, x, y):\n Iq, UC, U = x\n return Iq * sign(U)","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def _energy(self, X, y):\n yhat = self.evaluate(X)\n loss = ((y - yhat) ** 2).sum() / 2\n return loss","def cost(h, y):\n\tm = y.shape[0]\n\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\n\treturn cost","def calc_euclidian_dists(x, y):\n n = x.shape[0]\n m = y.shape[0]\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)","def J(W1, b1, W2, b2, x, y):\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\n return crossEntropy(y, yhat)","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\n y=np.zeros([np.size(x)])\n D=np.zeros([2]) \n #define fitnss\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \n #degradation\n deg=fmax*x[1]/(x[1]+Kd) \n #ODE of eco-evo dynamics\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\n \n return y","def elbo(self, x, y):\n self.forward(x, y)\n\n # prior-posterior divergence\n kl_loss = kl.kl_divergence(\n self.prior_latent_distribution, self.posterior_latent_distribution).mean()\n\n # reconstruction loss\n if not self.training:\n # resample output based on prior, not posterior\n self.forward(x)\n reconstruction_loss = self.recon_loss_fun(self.y_hat_raw, y[:, 0])\n\n # training loss\n loss = reconstruction_loss + self.beta * kl_loss\n\n # statictics about prior and posterior\n mu_prior = self.prior_latent_distribution.mean\n mu_posterior = self.posterior_latent_distribution.mean\n mu_dist = torch.norm(mu_prior - mu_posterior, dim=-1).mean()\n std_prior = self.prior_latent_distribution.stddev\n std_prior = torch.norm(std_prior - mu_posterior, dim=-1).mean()\n std_posterior = self.posterior_latent_distribution.stddev\n std_posterior = torch.norm(std_posterior - mu_posterior, dim=-1).mean()\n\n return loss, reconstruction_loss, kl_loss, mu_dist, std_prior, std_posterior","def E(x, y):\n # sum of products of neighboring paris {xi, yi}\n xxm = np.zeros_like(x)\n xxm[:-1, :] = x[1:, :] # down\n xxm[1:, :] += x[:-1, :] # up\n xxm[:, :-1] += x[:, 1:] # right\n xxm[:, 1:] += x[:, :-1] # left\n xx = np.sum(xxm * x)\n xy = np.sum(x * y)\n xsum = np.sum(x)\n return h * xsum - beta * xx - eta * xy","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def non_uniform_ToninaEldar(x, x_data, y_data):\n T = max(x_data) - min(x_data)\n \n ## equation 15a\n # shifts between all pairs of sampled times, used in bottom sin in product in 15a\n sample_shifts = np.expand_dims(x_data, axis=-1) - np.expand_dims(x_data, axis=0)\n product_bottom = np.sin(np.pi*sample_shifts/T)\n # shifts between all target and sampled times, used in top sin in product in 15a\n target_shifts = np.expand_dims(x, axis=-1) - np.expand_dims(x_data, axis=0)\n product_top = np.sin(np.pi*target_shifts/T)\n # in the product in 15a\n product = np.zeros(shape=(len(x), len(x_data)))\n for i, j in np.ndindex(product.shape):\n fraction = product_top[i] / product_bottom[j]\n # in the product, we skip the term where the shift j is equal to the shift\n # in the product_bottom (this term will be -inf), set it to 1 so it has\n # no effect on the product computation\n fraction[j] = 1\n product[i, j] = np.product(fraction)\n cosine_term = np.cos(np.pi*target_shifts/T)\n weights = cosine_term * product\n \n ## equation 14\n weighted_points = y_data * weights\n interpolated = np.sum(weighted_points, axis=-1)\n return interpolated","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def tsne(x, no_dims=2, perplexity=30.0, max_iter=1000):\n\n # Check inputs\n if isinstance(no_dims, float):\n print(\"Error: array x should have type float.\")\n return -1\n\n (n, d) = x.shape\n\n # 动量\n initial_momentum = 0.5\n final_momentum = 0.8\n eta = 500\n min_gain = 0.01\n # 随机初始化Y\n y = np.random.randn(n, no_dims)\n # dy梯度\n dy = np.zeros((n, no_dims))\n # iy是什么\n iy = np.zeros((n, no_dims))\n\n gains = np.ones((n, no_dims))\n\n # 对称化\n P = seach_prob(x, 1e-5, perplexity)\n P = P + np.transpose(P)\n P = P / np.sum(P) #pij\n # early exaggeration\n # pi\\j，提前夸大\n print (\"T-SNE DURING:%s\" % time.clock())\n P = P * 4\n P = np.maximum(P, 1e-12)\n\n # Run iterations\n for iter in range(max_iter):\n # Compute pairwise affinities\n sum_y = np.sum(np.square(y), 1)\n num = 1 / (1 + np.add(np.add(-2 * np.dot(y, y.T), sum_y).T, sum_y))\n num[range(n), range(n)] = 0\n Q = num / np.sum(num) #qij\n Q = np.maximum(Q, 1e-12) #X与Y逐位比较取其大者\n\n # Compute gradient\n # np.tile(A,N) 重复数组AN次 [1],5 [1,1,1,1,1]\n # pij-qij\n PQ = P - Q\n # 梯度dy\n for i in range(n):\n dy[i,:] = np.sum(np.tile(PQ[:,i] * num[:,i], (no_dims, 1)).T * (y[i,:] - y), 0)\n\n # Perform the update\n if iter < 20:\n momentum = initial_momentum\n else:\n momentum = final_momentum\n\n gains = (gains + 0.2) * ((dy > 0) != (iy > 0)) + (gains * 0.8) * ((dy > 0) == (iy > 0))\n gains[gains < min_gain] = min_gain\n # 迭代\n iy = momentum * iy - eta * (gains * dy)\n y = y + iy\n y = y - np.tile(np.mean(y, 0), (n, 1))\n # Compute current value of cost function\\\n if (iter + 1) % 100 == 0:\n C = np.sum(P * np.log(P / Q))\n print(\"Iteration \", (iter + 1), \": error is \", C)\n if (iter+1) != 100:\n ratio = C/oldC\n print(\"ratio \", ratio)\n if ratio >= 0.95:\n break\n oldC = C\n # Stop lying about P-values\n if iter == 100:\n P = P / 4\n print(\"finished training!\")\n return y","def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def Kernel(x, y):\n\n Result = (np.dot(x_train[x, :], x_train[y, :])+1)**5 # Polynomial\n #Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\n #Gaussian\n \"\"\"\n sigma = 1\n if np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\n elif (np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\n elif np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\n \"\"\"\n return Result","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def H(x, X, Y, dY):\n\n def L(i):\n #return p[i] * (x ** i)\n p = [(x - X[i]) / (X[j] - X[i]) for j in range(n) if j != i]\n return reduce(op.mul, p)\n\n def dL(i):\n #return d[i-1] * (x ** (i-1))\n if i < n-1:\n return (Y[i+1] - Y[i]) / (X[i+1] - X[i])\n else:\n return (Y[i] - Y[i-1]) / (X[i] - X[i-1])\n\n def A(i):\n return (1 - 2 * (x - X[i]) * dL(i)) * (L(i) ** 2)\n\n def B(i):\n return (x - X[i]) * (L(i) ** 2)\n\n assert(len(X) != 0 and len(X) == len(Y)), 'Quantidade de valores em X e Y diferentes'\n n = len(X)\n #p = interpolate.lagrange(X, Y)\n #d = polyder(p)\n h1 = sum(A(i) * Y[i] for i in range(n))\n h2 = sum(B(i) * dY[i] for i in range(n))\n return h1 + h2","def calc_entropy( r, X, res=5):\n\n ## x, y, speed, start_x, start_y, end_x, end_y, direction_x, direction_y, distance, sigma, w\n M = X.shape[0]\n N = X.shape[1]\n # calculate the distance of each particle from the beginning of its road segment\n dists = np.linalg.norm(X[:, :, :2] - X[:, :, 2:4], axis=-1)\n\n h = 0\n for start in r.keys():\n for end in r[start].keys():\n length = r[start][end]\n bin_start = 0.0\n # find the particles on this road segment\n on_edge = np.all(X[:, :, 2:6] == start + end, axis=-1)\n while bin_start < length:\n in_bin = np.all([dists >= bin_start, dists <= bin_start + res], axis=0)\n count = np.sum(np.all([on_edge, in_bin], axis=0))\n p = count / (N*M)\n if p > 0:\n h -= p*np.log(p)\n #\n bin_start += res\n #\n #\n #\n return h","def _kernel(self, x, y, t):\n return (self.C / (2 * np.pi * self.sigma_x * self.sigma_y * t)) * \\\n tf.exp(- self.beta * t - (tf.square(x)/tf.square(self.sigma_x) + tf.square(y)/tf.square(self.sigma_y)) / (2*t))","def pdist(x, y):\n\n x2 = tf.tile(tf.expand_dims(tf.reduce_sum(tf.square(x), 1), 1),\n tf.pack([1, tf.shape(y)[0]]))\n y2 = tf.tile(tf.transpose(tf.expand_dims(tf.reduce_sum(\n tf.square(y), 1), 1)), tf.pack([tf.shape(x)[0], 1]))\n xy = tf.matmul(x, y, transpose_b=True)\n return x2 - 2 * xy + y2","def regress_origin(x, y):\r\n x, y = array(x, 'Float64'), array(y, 'Float64')\r\n return sum(x * y) / sum(x * x), 0","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def converge(p_tx, beta, converge_dist, p_x, p_yx, p_yx_co_occur):\n\n # To return\n p_yt = None\n iterations = 0\n # To compute free energy\n p_t = None\n js_div = None\n\n while True:\n iterations = iterations + 1\n \n p_t = p_tx.T.dot(p_x)\n\n p_yt_co_occur = p_yx_co_occur.map(lambda (a, v): np.outer(p_tx[a, :], v.toarray())) \\\n .sum()\n p_yt = norm(p_yt_co_occur)\n\n # new p(t|x)\n if js_div:\n js_div.unpersist()\n p_yt_sum = np.sum(p_yt, axis=1)\n js_div = p_yx.map(lambda (a, v): (a, distance(v, p_yt, p_yt_sum))).cache()\n\n new_p_tx = js_div.map(lambda (a, v): (a, get_membership(v, p_t, beta))) \\\n .sortByKey() \\\n .map(lambda p: p[1]).collect()\n new_p_tx = np.array(new_p_tx)\n\n max_diff = np.max(distance(p_tx, new_p_tx))\n if max_diff <= converge_dist:\n break\n\n p_tx = new_p_tx\n\n free_energy = get_free_energy(p_tx, p_t, p_x, js_div, beta)\n js_div.unpersist()\n\n return p_yt, p_tx, free_energy, iterations","def DyEvo(x, t, T0, r1, r2, K_co, K_ch, alpha, n):\n y=np.zeros([np.size(x)])\n D=np.zeros([2]) \n #define fitnss\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \n #degradation\n deg=fmax*x[1]/(x[1]+Kd) \n #ODE of eco-evo dynamics\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r1*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\n y[2]=x[2]*(r2*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\n \n return y","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def softmax_loss(x, y):\n N, C = x.shape\n loss, dx = 0, np.zeros(x.shape) \n for i in range(N):\n loss += -np.log(np.exp(x[i,y[i]])/np.sum(np.exp(x[i,:])))\n dx[i,:] = np.exp(x[i,:])/np.sum(np.exp(x[i,:]))\n dx[i,y[i]] += (-1)\n \n loss /= N\n dx /= N\n return loss, dx","def fit(self, X, y):\n\n\t\trgen = np.random.RandomState(self.random_state)\n\t\tself.w_ = rgen.normal(loc=0.0, scale=0.01, size=1+X.shape[1])\n\t\tself.cost_ = []\n\n\t\tfor i in range(self.n_iter):\n\t\t\tnet_input = self.net_input(X)\n\t\t\toutput = self.activation(net_input)\n\t\t\terrors = y - output\n\t\t\tself.w_[1:] += self.eta * X.T.dot(errors)\n\t\t\tself.w_[0] += self.eta * errors.sum()\n\t\t\tcost = - y.dot(np.log(output)) - ((1-y).dot(np.log(1-output)))\n\t\t\tself.cost_.append(cost)\n\t\treturn self","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def conditional_entropy_hyper(self) -> float:\n pass","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def mutual_information(x, y, w):\r\n \r\n\r\n total_entropy = entropy(y,w)\r\n\r\n partitioned_x = partition(x)\r\n weighted_entropy = 0\r\n # calculate the weighted entropy over the partition of x\r\n vals,counts= np.unique(x,return_counts=True)\r\n for key in partitioned_x:\r\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\r\n\r\n information_gain = total_entropy - weighted_entropy\r\n return information_gain","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","def train(self, X, y):\n m = X.shape[0]\n D = np.empty(m)\n D.fill(1/(m*1.0))\n\n hs = 0\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n eps = 0\n\n for j in range(m): \n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\n eps+=D[j]\n\n self.w[t] =0.5*math.log((1/eps)-1)\n\n Dtmp = []\n for j in range(m):\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\n\n Dtmp = np.array(Dtmp) \n s = np.sum(Dtmp)\n\n for i in range(m):\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","def prediction_cost(a, y):\n return np.sum((a - y) ** 2) / 2","def evaluate(t, x, y):\n r = np.sqrt(x**2 + y**2)\n return contrast * np.cos(kx_g*x + ky_g*y - w_g*t) * (1 - heaviside(r - patch_diameter*0.5))","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def TargetFunction(p,x,y):\n \n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y","def regress(x, y):\r\n x, y = array(x, 'Float64'), array(y, 'Float64')\r\n N = len(x)\r\n Sx = sum(x)\r\n Sy = sum(y)\r\n Sxx = sum(x * x)\r\n Syy = sum(y * y)\r\n Sxy = sum(x * y)\r\n det = Sxx * N - Sx * Sx\r\n return (Sxy * N - Sy * Sx) / det, (Sxx * Sy - Sx * Sxy) / det","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def to_thermo(x,y):\n\tp = p_from_y(y)\n\tT_C = T_from_xp(x,p) - C_to_K\n\treturn T_C, p","def optimize(self, X, y):\n print(\"Performing TPOT genetic optimization.\")\n self.model.fit(X, y)\n self.optimized = True","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def CHARGE(t, x, y):\n Iq, UC, U = x\n E, Umax = y # time discrete state vector\n E_new = E + Cp/2 * U**2\n return array([0.0, UC, 0.0]), array([E_new, U])","def _raw_ot_integration(\n Xs: np.ndarray, Xt: np.ndarray, metric: str = \"sqeuclidean\", eps=1e-3, verbose=False\n):\n n, d1 = Xs.shape\n m, d2 = Xt.shape\n\n assert (\n d1 == d2\n ), \"Dimensions do not coincide %i (source) vs %i (target). Terminating...\" % (\n d1,\n d2,\n )\n\n w_x, w_y = np.ones((n,)) / n, np.ones((m,)) / m\n if verbose:\n print(\"> Computing distance matrix...\")\n M = dist(Xs, Xt, metric=metric)\n M /= M.max()\n if verbose:\n print(\"> Computing optimal transport plan...\")\n Gs = sinkhorn(w_x, w_y, M, eps)\n if verbose:\n print(\"> Projecting source dataset...\")\n return np.diag(1 / w_x) @ Gs @ Xt","def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n f = -(x + y) / 2\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\n return t - f","def nt_xent_loss(out_1, out_2, temperature, eps=1e-6):\n # gather representations in case of distributed training\n # out_1_dist: [batch_size * world_size, dim]\n # out_2_dist: [batch_size * world_size, dim]\n if torch.distributed.is_available() and torch.distributed.is_initialized():\n out_1_dist = SyncFunction.apply(out_1)\n out_2_dist = SyncFunction.apply(out_2)\n else:\n out_1_dist = out_1\n out_2_dist = out_2\n\n # out: [2 * batch_size, dim]\n # out_dist: [2 * batch_size * world_size, dim]\n out = torch.cat([out_1, out_2], dim=0)\n out_dist = torch.cat([out_1_dist, out_2_dist], dim=0)\n\n # cov and sim: [2 * batch_size, 2 * batch_size * world_size]\n # neg: [2 * batch_size]\n cov = torch.mm(out, out_dist.t().contiguous())\n sim = torch.exp(cov / temperature)\n neg = sim.sum(dim=-1)\n\n # from each row, subtract e^1 to remove similarity measure for x1.x1\n row_sub = torch.Tensor(neg.shape).fill_(math.e).to(neg.device)\n neg = torch.clamp(neg - row_sub, min=eps) # clamp for numerical stability\n\n # Positive similarity, pos becomes [2 * batch_size]\n pos = torch.exp(torch.sum(out_1 * out_2, dim=-1) / temperature)\n pos = torch.cat([pos, pos], dim=0)\n\n loss = -torch.log(pos / (neg + eps)).mean()\n\n return loss","def energy_function(self, x):\n \n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\n T.dot(T.transpose(self.b), x)","def deriv_costFunction(self, x, y):\n self.yEst = self.forward_propagate(x)\n\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\n #partial deriv of cost wrt hidden -> output weights\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\n\n ones_o = np.ones( delta_o.shape[0] )\n #partial deriv of cost wrt output biases\n partial_J_b_o = np.dot( ones_o, delta_o )\n\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\n #partial deriv of cost wrt input -> hidden weights\n partial_J_w_ih = np.dot( x.T, delta_h )\n \n ones_h = np.ones( delta_h.shape[0] )\n #partial deriv of cost wrt hidden biases\n partial_J_b_h = np.dot( ones_h, delta_h)\n\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o","def SSE(y, yhat):\n\n return np.sum(np.power(yhat - y, 2))","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def forward(self, y):\n # landmarks are the weighted average y\n # activations across each channel\n y_projected = torch.zeros_like(y)\n y = self.softmax(y)\n\n # self.save_image(y[0, :, :, :])\n\n # print(y.size())\n # y_0 = y\n y = y.view(y.size(0), y.size(1), -1)\n # print(y[0, :].min(), y[0, :].max())\n mu_y = y * self.yv.reshape(1, 1, -1)\n mu_y = mu_y.sum(dim=-1) #/ y.sum(dim=-1)\n mu_x = y * self.xv.reshape(1, 1, -1)\n mu_x = mu_x.sum(dim=-1) #/ y.sum(dim=-1)\n means = torch.cat((mu_y.unsqueeze(-1), mu_x.unsqueeze(-1)), dim=-1)\n\n # project landmarsk to guassain fuction with fixed standard deviation\n # yv, xv = torch.meshgrid([torch.arange(0, y.size(-2)), torch.arange(0, y.size(-1))])\n # h_act = torch.zeros(y_projected.size(0), y_projected.size(1), device=y.device)\n for batch_id in range(y_projected.size(0)):\n for heatmap_id in range(y_projected.size(1)):\n gdist = MultivariateNormal(means[batch_id, heatmap_id, :], covariance_matrix=self.cov)\n logprobs = gdist.log_prob(torch.cat((self.yv.unsqueeze(0), self.xv.unsqueeze(0)), dim=0).t())\n y_projected[batch_id, heatmap_id, :, :] = torch.exp(logprobs).reshape(y_projected.size(-2), y_projected.size(-1))\n # y_projected[batch_id, heatmap_id, :, :] -= y_projected[batch_id, heatmap_id, :, :].min()\n # y_projected[batch_id, heatmap_id, :, :] /= y_projected[batch_id, heatmap_id, :, :].max()\n # coords = means[batch_id, heatmap_id, :].round().long()\n # h_act[batch_id, heatmap_id] = y_0[batch_id, heatmap_id, coords[0], coords[1]]\n # h_act[batch_id, heatmap_id]\n # max_coords = y_0[batch_id, heatmap_id, :, :].clone()\n # max_coords[max_coords < max_coords.max()] = 0\n # # print(max_coords.size())\n # if batch_id == 0 and heatmap_id == 0:\n # print(means[batch_id, heatmap_id, :], max_coords.nonzero().float().mean(0))\n # a = 'fail' if y.pow(2).mean() > h_act.mean() else 'pass'\n # print(h_act.mean(), y.mean())\n # print(y_projected.max(), y_projected.min())\n # y_out = y_projected.sum(dim=1)\n # self.save_image(y_out.unsqueeze(1), normalize=True)\n # self.save_image(y_out.unsqueeze(1), normalize=True, output='landmarks')\n return y_projected, self.prior_loss(means, y)","def get_evaporation_latent_heat() -> float:\n theta = 28.0\n return 2500.8 - 2.3668 * theta","def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for low temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n S_low = (\n -gbar\n * np.sqrt(2)\n / (6 * np.pi ** 2)\n * tt_low ** (3 / 2)\n * vv_low\n * (\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\n )\n )\n # low temperatures - high numbers\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((S_low, S_high)).reshape(y.shape)","def interp_n2(t, x, y):\n\n return y[:, 0] + (t - x[0]) * (y[:, 1] - y[:, 0]) / (x[1] - x[0])","def softmax_loss(x, y):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################\n N=x.shape[0]\n\n \n x-=np.max(x,axis=1,keepdims=True)\n temp=np.exp(x)\n dr_vec=np.sum(temp,axis=1,keepdims=True)\n\n nr=(x[np.arange(N),y]).reshape([N,1])\n loss=np.sum(-(nr)+np.log(dr_vec))\n \n loss=(loss/N)\n temp/=dr_vec\n temp[np.arange(N),y] -= 1\n \n dx = temp/N\n \n return loss, dx","def forward(self, x, y, t):\r\n # Compute shapes.\r\n batch_size = x.shape[0]\r\n n_in = x.shape[1]\r\n n_out = t.lshape[1]\r\n \r\n #pdb.set_trace()\r\n\r\n # Compute the pairwise distances.\r\n # Shape: (batch, n_in, n_out).\r\n \r\n #pdb.set_tracdb.set_trace()\r\n dists = compute_dists(x, t)\r\n\r\n # Compute the weights.\r\n # Shape: (batch, n_in, n_out, in_channels).\r\n wt = self.rbf(dists)\r\n\r\n # Compute the extra density channel.\r\n # Shape: (batch, n_in, 1).\r\n density = torch.ones(batch_size, n_in, 1).to(device)\r\n\r\n # Concatenate the channel.\r\n # Shape: (batch, n_in, in_channels + 1).\r\n y_out = torch.cat([density, y], dim=2)\r\n\r\n # Perform the weighting.\r\n # Shape: (batch, n_in, n_out, in_channels + 1).\r\n y_out = y_out.view(batch_size, n_in, -1, self.in_channels) * wt\r\n\r\n # Sum over the inputs.\r\n # Shape: (batch, n_out, in_channels + 1).\r\n y_out = y_out.sum(1)\r\n\r\n # Use density channel to normalize convolution.\r\n density, conv = y_out[..., :1], y_out[..., 1:]\r\n normalized_conv = conv / (density + 1e-8)\r\n y_out = torch.cat((density, normalized_conv), dim=-1)\r\n\r\n # Apply the point-wise function.\r\n # Shape: (batch, n_out, out_channels).\r\n y_out = y_out.view(batch_size * n_out, self.in_channels)\r\n y_out = self.g(y_out)\r\n y_out = y_out.view(batch_size, n_out, self.out_channels)\r\n\r\n return y_out","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def DyCheat(x, t, T0, r2, K, alpha, n):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r2*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def fit(self,X,y):\n \n rand_num = np.random.RandomState(self.random_state)\n self.w_ = rand_num.normal(loc = 0.0, scale = 0.01,size = 1 + X.shape[1])\n self.cost_ = []\n \n for i in range(self.n_iter):\n net_input = self.net_input(X)\n output = self.activation(net_input)\n errors = (y - output)\n self.w_[1:] += self.eta * X.T.dot(errors)\n self.w_[0] += self.eta * errors.sum()\n cost = (errors**2).sum()/2.0\n self.cost_.append(cost)\n return self","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def SG(self, h, y):\n self.check_sg_weights()\n\n A = self.sg_weights[0] #(n, n)\n B = self.sg_weights[1] #(10, n)\n C = self.sg_weights[2] #(1, n)\n\n delta = np.matmul(h, A) + np.matmul(y, B) + C\n return delta","def power_output_candidate_thermal_rule(_m, g, y, s, t):\r\n\r\n if y != m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y != m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n else:\r\n raise Exception(f'Unhandled case: {g, y, s, t}')","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def cross_entropy(y_observed, p):\n\n pass","def fit(self, X, y):\n\t\trgen = np.random.RandomState(self.random_state)\n\t\tself.w_ = rgen.normal(loc=0.0, scale=0.01, size=1+X.shape[1])\n\t\tself.cost_ = []\n\n\t\tfor i in range(self.n_iter):\n\t\t\tnet_input = self.net_input(X)\n\t\t\toutput = self.activation(net_input)\n\t\t\terrors = y - output\n\t\t\t#update weights\n\t\t\tself.w_[1:] += self.eta * X.T.dot(errors)\n\t\t\tself.w_[0] += self.eta * errors.sum()\n\t\t\tcost = (errors**2).sum() / 2.0\n\t\t\tself.cost_.append(cost)\n\t\treturn self","def y(x):\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def cost_function(data_x, data_y, parameters):\n # Residual sum of squares\n rss = np.sum((data_x @ parameters - data_y) ** 2)\n\n # Number of rows times 2\n nb_rows_x2 = 2 * data_x.shape[0]\n\n return rss / nb_rows_x2"],"string":"[\n \"def transfer_entropy(X, Y):\\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\\n\\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\\n for y_f, x_p, y_p in coords.keys():\\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\\n\\n p_yp = p_dist.sum(axis=2).sum(axis=1)\\n p_joint_cond_yp = p_dist / p_yp[:, None, None]\\n p_yf_cond_yp = p_dist.sum(axis=2) / p_yp[:, None]\\n p_xp_cond_yp = p_dist.sum(axis=1) / p_yp[:, None]\\n\\n denominator = np.multiply(p_yf_cond_yp, p_xp_cond_yp)\\n denominator[denominator == 0] = np.nan\\n\\n division = np.divide(p_joint_cond_yp, denominator[:, :, None])\\n division[division == 0] = np.nan\\n\\n log = np.log2(division)\\n\\n return np.nansum(np.multiply(p_dist, log))\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def dist_calc(self, x, y):\\n p_xy = self.d2_bin(x, y)\\n p_x = np.sum(p_xy, axis=1)\\n p_y = np.sum(p_xy, axis=0)\\n\\n p_x_times_p_y = np.tensordot(p_x, p_y, axes = 0)\\n info = np.sum(p_xy * np.ma.log(np.ma.divide(p_xy, p_x_times_p_y)))\\n entropy = np.sum(-1 * p_xy * np.ma.log(p_xy))\\n\\n output = max(0.0, (1 - (info / entropy)))\\n return output\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def mutual_information(x, y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n xvalue, xcount = np.unique(x,return_counts = True)\\r\\n probx = xcount.astype(float)/len(x)\\r\\n Hyx = 0.0\\r\\n for pxval,xval in zip(probx,xvalue):\\r\\n Hyx += (pxval)*entropy(y[x==xval])\\r\\n \\r\\n Ixy = entropy(y) - Hyx\\r\\n return Ixy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def _cal_igr(x, y):\\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\n \"def entropy(self):\\n\\n \\\"\\\"\\\"Gets the first neighbours, which are the first 2*r+1 cells.\\\"\\\"\\\"\\n current_neighbours = []\\n amount = [0] * self.k ** (2 * self.r + 1)\\n for i in range(2 * self.r + 1):\\n current_neighbours.append(self.config[self.t, i % self.width])\\n\\n \\\"\\\"\\\"Calculates the rule and adds one to it's amount. It then removes the\\n leftmost cell and adds a cell to the right.\\\"\\\"\\\"\\n for i in range(len(self.config[self.t]) - 1):\\n rule = 0\\n for j in range(len(current_neighbours)):\\n rule += int(current_neighbours[j] *\\n self.k ** ((2 * self.r + 1) - j - 1))\\n amount[len(amount) - 1 - rule] += 1\\n current_neighbours.pop(0)\\n current_neighbours.append(\\n self.config[self.t, (2 * self.r + 1 + i) % self.width])\\n\\n \\\"\\\"\\\"Calculates the rule for the last neighbourhood.\\\"\\\"\\\"\\n rule = 0\\n for j in range(len(current_neighbours)):\\n rule += int(current_neighbours[j] *\\n self.k ** ((2 * self.r + 1) - j - 1))\\n amount[len(amount)-1 - rule] += 1\\n\\n \\\"\\\"\\\"Calculates the Shannon entropy and the the average entropy so far.\\\"\\\"\\\"\\n shannon = 0\\n for i in range(len(amount)):\\n if(amount[i] != 0):\\n probability = amount[i] / self.width\\n shannon -= probability * np.log2(probability)\\n self.average_entropy = (self.average_entropy *\\n self.t + shannon) / (self.t + 1)\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def calc_entropy(graph, X, res=1):\\n\\n ## x, y, speed, start_x, start_y, end_x, end_y, direction_x, direction_y, distance, sigma, w\\n M = X.shape[0]\\n N = X.shape[1]\\n # calculate the distance of each particle from the beginning of its road segment\\n dists = np.linalg.norm(X[:,:, :2] - X[:,:, 3:5], axis=-1)\\n\\n h = np.zeros(M)\\n for start in graph.keys():\\n for end in graph[start].keys():\\n length = graph[start][end]\\n # find the particles on this road segment\\n on_edge = np.all(X[:,:, 3:7] == start + end, axis=-1)\\n for idx in range(M):\\n bin_start = 0.0\\n while bin_start < length:\\n in_bin = np.all([dists >= bin_start, dists <= bin_start + res], axis=0)\\n\\n count = np.sum(np.all([on_edge[idx], in_bin[idx]], axis=0))# + np.sum(np.all([on_edge, in_bin_reverse], axis=0))\\n p = count / (N)\\n if p > 0:\\n h[idx] -= p*np.log(p)\\n bin_start += res\\n return h#, [get_pos_var(X[idx], hist) for idx in range(M)], counts, probs\",\n \"def entropy(y,w):\\r\\n\\r\\n\\t# my original entropy function commented below is not working as desired. The below implementation is based on from Sai Ram Chappidi's explanation\\r\\n\\r\\n # y_partition = partition(y)\\r\\n # elements,counts = np.unique(y,return_counts = True)\\r\\n # entropy=0\\r\\n\\r\\n # for i in range(len(elements)):\\r\\n # entropy += ((-(np.sum(w[y_partition[i]])))/np.sum(w))*np.log2(np.sum(w[y_partition[i]])/np.sum(w))\\r\\n # return entropy\\r\\n\\r\\n entropy = 0\\r\\n # two hypothesis cases 0,1\\r\\n h = {0: 0, 1: 0}\\r\\n leny = len(y)\\r\\n for i in range(leny):\\r\\n # if y is 0 add 0 to the weight\\r\\n if y[i] == 0:\\r\\n h[0] += w[i]\\r\\n # if y is 1 add 1 to the weight\\r\\n elif y[i] == 1:\\r\\n h[1] += + w[i]\\r\\n # summing all the weighted values \\r\\n val_sum = h[0] + h[1]\\r\\n\\r\\n # entropy calculation\\r\\n for j in range(len(h)):\\r\\n h[j] = h[j]/val_sum\\r\\n # to prevent divide by zero\\r\\n if h[j] != 0:\\r\\n entropy += h[j] * np.log2(h[j])\\r\\n entropy = -(entropy)\\r\\n return entropy\",\n \"def fit(self, x, y):\\n # *** START CODE HERE ***\\n num_examples = x.shape[0]\\n num_features = x.shape[1]\\n iteration = 1\\n if self.theta == None:\\n self.theta = np.zeros((num_features,))\\n while iteration <= self.max_iter:\\n h_theta = np.dot(x, self.theta)\\n g_theta = self.sigmoid(h_theta)\\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\\n d_theta = - np.linalg.solve(H, J_prime)\\n self.theta += d_theta\\n if np.linalg.norm(d_theta, 1) < self.eps:\\n break\\n if self.verbose:\\n print(\\\"Loss value: \\\", J_cost)\\n iteration += 1\\n # *** END CODE HERE ***\",\n \"def attack(self, x, y_p, **kwargs):\\n inputs = []\\n outputs = []\\n\\n # Create the initial random perturbation\\n device_name = '/gpu:0'\\n self.model.set_device(device_name)\\n with tf.device(device_name):\\n with tf.variable_scope('init_rand'):\\n if self.rand_init:\\n eta = tf.random_uniform(tf.shape(x), -self.eps, self.eps)\\n eta = clip_eta(eta, self.ord, self.eps)\\n eta = tf.stop_gradient(eta)\\n else:\\n eta = tf.zeros_like(x)\\n\\n # TODO: Break the graph only nGPU times instead of nb_iter times.\\n # The current implementation by the time an adversarial example is\\n # used for training, the weights of the model have changed nb_iter\\n # times. This can cause slower convergence compared to the single GPU\\n # adversarial training.\\n for i in range(self.nb_iter):\\n # Create the graph for i'th step of attack\\n inputs += [OrderedDict()]\\n outputs += [OrderedDict()]\\n device_name = x.device\\n self.model.set_device(device_name)\\n with tf.device(device_name):\\n with tf.variable_scope('step%d' % i):\\n if i > 0:\\n # Clone the variables to separate the graph of 2 GPUs\\n x = clone_variable('x', x)\\n y_p = clone_variable('y_p', y_p)\\n eta = clone_variable('eta', eta)\\n\\n inputs[i]['x'] = x\\n inputs[i]['y_p'] = y_p\\n outputs[i]['x'] = x\\n outputs[i]['y_p'] = y_p\\n inputs[i]['eta'] = eta\\n\\n eta = self.attack_single_step(x, eta, y_p)\\n\\n if i < self.nb_iter-1:\\n outputs[i]['eta'] = eta\\n else:\\n # adv_x, not eta is the output of the last step\\n adv_x = x + eta\\n if (self.clip_min is not None and self.clip_max is not None):\\n adv_x = tf.clip_by_value(adv_x, self.clip_min, self.clip_max)\\n adv_x = tf.stop_gradient(adv_x, name='adv_x')\\n outputs[i]['adv_x'] = adv_x\\n\\n return inputs, outputs\",\n \"def fit(self, x, y):\\n def initiate_theta(dim):\\n self.theta = np.zeros(dim)\\n # print('self.theta initiated is {}'.format(self.theta))\\n \\n def implement_sigmoid(x):\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\\n \\n def implement_partial_loss(x, y):\\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\\n \\n def implement_transposed_hess(x):\\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\\n hess2 = np.diag(sigmoid_hadamard)\\n hess = np.matmul(hess2,x)\\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\\n hess_inverse = np.linalg.inv(hess)\\n return hess_inverse\\n \\n def train(x, y):\\n count = 0\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n while count < self.max_iter:\\n if self.verbose:\\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\\n print('Average empirical loss for step {} is {}'.format(count, loss))\\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\\n new_theta = self.theta - delta * self.step_size\\n delta_theta = np.linalg.norm(new_theta - self.theta)\\n # print('delta is {}'.format(delta_theta))\\n if delta_theta < self.eps:\\n return new_theta\\n else:\\n self.theta = new_theta\\n count += 1\\n return self.theta\\n \\n return train(x, y)\",\n \"def proximal(self):\\n functional = self\\n\\n class EntRegOptTransProximal(Operator):\\n\\n \\\"\\\"\\\"Proximal operator of entropy regularized optimal transport.\\n\\n The prox is given by::\\n\\n prox_[gamma*T_eps](mu1) = arg min_x (T_epsilon(mu0, x) +\\n 1/(2*gamma) ||x - mu1||^2_2)\\n \\\"\\\"\\\"\\n\\n def __init__(self, sigma):\\n \\\"\\\"\\\"Initialize a new instance.\\n\\n Parameters\\n ----------\\n sigma : positive float\\n \\\"\\\"\\\"\\n self.sigma = float(sigma)\\n super().__init__(domain=functional.domain,\\n range=functional.domain, linear=False)\\n\\n # Setting up parameters\\n self.const = 1 / (functional.epsilon * sigma)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the operator to ``x``.\\\"\\\"\\\"\\n u = functional.tmp_u_prox\\n v = functional.tmp_v_prox\\n\\n # Running generalized Sinkhorn iterations\\n for j in range(functional.niter):\\n # Safe-guarded u-update, to avoid divide-by-zero error.\\n u_old = u.copy()\\n tmp1 = functional.K_op(v)\\n if np.min(tmp1) < 1e-30 or np.max(tmp1) > 1e+50:\\n print('Numerical instability, truncation in Transport prox (Kv)',\\n str(np.min(tmp1)), str(np.max(tmp1)))\\n\\n tmp = np.fmax(tmp1, 1e-30)\\n\\n\\n u = functional.mu0 / tmp\\n if np.min(u) < 1e-30 or np.max(u) > 1e+50:\\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\\n\\n # Safe-guarded v-update, to avoid divide-by-zero error.\\n v_old = v.copy()\\n\\n tmp3 = functional.K_op_adjoint(u)\\n if np.min(tmp3) < 1e-30 or np.max(tmp3) > 1e+50:\\n print('Truncation in Transport prox (KTu)',\\n str(np.min(tmp3)), str(np.max(tmp3)))\\n print('u (min/max)', str(np.min(u)), str(np.max(u)))\\n\\n tmp4 = (self.const * tmp3 * np.exp(self.const * x))\\n\\n if np.min(tmp4) < 1e-30 or np.max(tmp4) > 1e+200:\\n print('Argument in lambdert omega (min/max)',\\n str(np.min(tmp4)), str(np.max(tmp4)))\\n\\n v = np.exp(self.const * x - lambertw_fulfix(tmp4))\\n\\n v1 = np.exp(self.const * x - scipy.special.lambertw(\\n tmp4))\\n if (v-v1).norm() > 1e-10:\\n print('diff pga ny lambderw omega funciton',\\n str((v-v1).norm()))\\n print('v (min/max)', str(np.min(v)), str(np.max(v)))\\n print('Argument in lambdert omega (min/max)',\\n str(np.min(tmp4)), str(np.max(tmp4)))\\n\\n # If the updates in both u and v are small, break the loop\\n if ((np.log(v)-np.log(v_old)).norm() < 1e-8 and\\n (np.log(u)-np.log(u_old)).norm() < 1e-8):\\n break\\n\\n # Store the u and v in the internal temporary variables of the\\n # functional\\n functional.tmp_u_prox = u\\n functional.tmp_v_prox = v\\n\\n return x - self.sigma * functional.epsilon * np.log(v)\\n\\n return EntRegOptTransProximal\",\n \"def ev_harvest(t, x, y):\\n Iq, UC, U = x\\n return Iq * sign(U)\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def _energy(self, X, y):\\n yhat = self.evaluate(X)\\n loss = ((y - yhat) ** 2).sum() / 2\\n return loss\",\n \"def cost(h, y):\\n\\tm = y.shape[0]\\n\\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\\n\\treturn cost\",\n \"def calc_euclidian_dists(x, y):\\n n = x.shape[0]\\n m = y.shape[0]\\n x = tf.tile(tf.expand_dims(x, 1), [1, m, 1])\\n y = tf.tile(tf.expand_dims(y, 0), [n, 1, 1])\\n return tf.reduce_mean(tf.math.pow(x - y, 2), 2)\",\n \"def J(W1, b1, W2, b2, x, y):\\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\\n return crossEntropy(y, yhat)\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\\n y=np.zeros([np.size(x)])\\n D=np.zeros([2]) \\n #define fitnss\\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \\n #degradation\\n deg=fmax*x[1]/(x[1]+Kd) \\n #ODE of eco-evo dynamics\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\\n \\n return y\",\n \"def elbo(self, x, y):\\n self.forward(x, y)\\n\\n # prior-posterior divergence\\n kl_loss = kl.kl_divergence(\\n self.prior_latent_distribution, self.posterior_latent_distribution).mean()\\n\\n # reconstruction loss\\n if not self.training:\\n # resample output based on prior, not posterior\\n self.forward(x)\\n reconstruction_loss = self.recon_loss_fun(self.y_hat_raw, y[:, 0])\\n\\n # training loss\\n loss = reconstruction_loss + self.beta * kl_loss\\n\\n # statictics about prior and posterior\\n mu_prior = self.prior_latent_distribution.mean\\n mu_posterior = self.posterior_latent_distribution.mean\\n mu_dist = torch.norm(mu_prior - mu_posterior, dim=-1).mean()\\n std_prior = self.prior_latent_distribution.stddev\\n std_prior = torch.norm(std_prior - mu_posterior, dim=-1).mean()\\n std_posterior = self.posterior_latent_distribution.stddev\\n std_posterior = torch.norm(std_posterior - mu_posterior, dim=-1).mean()\\n\\n return loss, reconstruction_loss, kl_loss, mu_dist, std_prior, std_posterior\",\n \"def E(x, y):\\n # sum of products of neighboring paris {xi, yi}\\n xxm = np.zeros_like(x)\\n xxm[:-1, :] = x[1:, :] # down\\n xxm[1:, :] += x[:-1, :] # up\\n xxm[:, :-1] += x[:, 1:] # right\\n xxm[:, 1:] += x[:, :-1] # left\\n xx = np.sum(xxm * x)\\n xy = np.sum(x * y)\\n xsum = np.sum(x)\\n return h * xsum - beta * xx - eta * xy\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def non_uniform_ToninaEldar(x, x_data, y_data):\\n T = max(x_data) - min(x_data)\\n \\n ## equation 15a\\n # shifts between all pairs of sampled times, used in bottom sin in product in 15a\\n sample_shifts = np.expand_dims(x_data, axis=-1) - np.expand_dims(x_data, axis=0)\\n product_bottom = np.sin(np.pi*sample_shifts/T)\\n # shifts between all target and sampled times, used in top sin in product in 15a\\n target_shifts = np.expand_dims(x, axis=-1) - np.expand_dims(x_data, axis=0)\\n product_top = np.sin(np.pi*target_shifts/T)\\n # in the product in 15a\\n product = np.zeros(shape=(len(x), len(x_data)))\\n for i, j in np.ndindex(product.shape):\\n fraction = product_top[i] / product_bottom[j]\\n # in the product, we skip the term where the shift j is equal to the shift\\n # in the product_bottom (this term will be -inf), set it to 1 so it has\\n # no effect on the product computation\\n fraction[j] = 1\\n product[i, j] = np.product(fraction)\\n cosine_term = np.cos(np.pi*target_shifts/T)\\n weights = cosine_term * product\\n \\n ## equation 14\\n weighted_points = y_data * weights\\n interpolated = np.sum(weighted_points, axis=-1)\\n return interpolated\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def tsne(x, no_dims=2, perplexity=30.0, max_iter=1000):\\n\\n # Check inputs\\n if isinstance(no_dims, float):\\n print(\\\"Error: array x should have type float.\\\")\\n return -1\\n\\n (n, d) = x.shape\\n\\n # 动量\\n initial_momentum = 0.5\\n final_momentum = 0.8\\n eta = 500\\n min_gain = 0.01\\n # 随机初始化Y\\n y = np.random.randn(n, no_dims)\\n # dy梯度\\n dy = np.zeros((n, no_dims))\\n # iy是什么\\n iy = np.zeros((n, no_dims))\\n\\n gains = np.ones((n, no_dims))\\n\\n # 对称化\\n P = seach_prob(x, 1e-5, perplexity)\\n P = P + np.transpose(P)\\n P = P / np.sum(P) #pij\\n # early exaggeration\\n # pi\\\\j，提前夸大\\n print (\\\"T-SNE DURING:%s\\\" % time.clock())\\n P = P * 4\\n P = np.maximum(P, 1e-12)\\n\\n # Run iterations\\n for iter in range(max_iter):\\n # Compute pairwise affinities\\n sum_y = np.sum(np.square(y), 1)\\n num = 1 / (1 + np.add(np.add(-2 * np.dot(y, y.T), sum_y).T, sum_y))\\n num[range(n), range(n)] = 0\\n Q = num / np.sum(num) #qij\\n Q = np.maximum(Q, 1e-12) #X与Y逐位比较取其大者\\n\\n # Compute gradient\\n # np.tile(A,N) 重复数组AN次 [1],5 [1,1,1,1,1]\\n # pij-qij\\n PQ = P - Q\\n # 梯度dy\\n for i in range(n):\\n dy[i,:] = np.sum(np.tile(PQ[:,i] * num[:,i], (no_dims, 1)).T * (y[i,:] - y), 0)\\n\\n # Perform the update\\n if iter < 20:\\n momentum = initial_momentum\\n else:\\n momentum = final_momentum\\n\\n gains = (gains + 0.2) * ((dy > 0) != (iy > 0)) + (gains * 0.8) * ((dy > 0) == (iy > 0))\\n gains[gains < min_gain] = min_gain\\n # 迭代\\n iy = momentum * iy - eta * (gains * dy)\\n y = y + iy\\n y = y - np.tile(np.mean(y, 0), (n, 1))\\n # Compute current value of cost function\\\\\\n if (iter + 1) % 100 == 0:\\n C = np.sum(P * np.log(P / Q))\\n print(\\\"Iteration \\\", (iter + 1), \\\": error is \\\", C)\\n if (iter+1) != 100:\\n ratio = C/oldC\\n print(\\\"ratio \\\", ratio)\\n if ratio >= 0.95:\\n break\\n oldC = C\\n # Stop lying about P-values\\n if iter == 100:\\n P = P / 4\\n print(\\\"finished training!\\\")\\n return y\",\n \"def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def Kernel(x, y):\\n\\n Result = (np.dot(x_train[x, :], x_train[y, :])+1)**5 # Polynomial\\n #Result = (np.dot(x_train[x, :], x_train[y, :])+1) # Linear\\n #Gaussian\\n \\\"\\\"\\\"\\n sigma = 1\\n if np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) == 1:\\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2)) ** 2 / (2 * sigma ** 2))\\n elif (np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) == 1) or (np.ndim(x_train[x, :]) == 1 and np.ndim(x_train[y, :]) > 1):\\n Result = np.exp(- (np.linalg.norm(x_train[x, :] - x_train[y, :], 2, axis=1) ** 2) / (2 * sigma ** 2))\\n elif np.ndim(x_train[x, :]) > 1 and np.ndim(x_train[y, :]) > 1:\\n Result = np.exp(- (np.linalg.norm(x[:, np.newaxis] - y[np.newaxis, :], 2, axis=2) ** 2) / (2 * sigma ** 2))\\n \\\"\\\"\\\"\\n return Result\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def H(x, X, Y, dY):\\n\\n def L(i):\\n #return p[i] * (x ** i)\\n p = [(x - X[i]) / (X[j] - X[i]) for j in range(n) if j != i]\\n return reduce(op.mul, p)\\n\\n def dL(i):\\n #return d[i-1] * (x ** (i-1))\\n if i < n-1:\\n return (Y[i+1] - Y[i]) / (X[i+1] - X[i])\\n else:\\n return (Y[i] - Y[i-1]) / (X[i] - X[i-1])\\n\\n def A(i):\\n return (1 - 2 * (x - X[i]) * dL(i)) * (L(i) ** 2)\\n\\n def B(i):\\n return (x - X[i]) * (L(i) ** 2)\\n\\n assert(len(X) != 0 and len(X) == len(Y)), 'Quantidade de valores em X e Y diferentes'\\n n = len(X)\\n #p = interpolate.lagrange(X, Y)\\n #d = polyder(p)\\n h1 = sum(A(i) * Y[i] for i in range(n))\\n h2 = sum(B(i) * dY[i] for i in range(n))\\n return h1 + h2\",\n \"def calc_entropy( r, X, res=5):\\n\\n ## x, y, speed, start_x, start_y, end_x, end_y, direction_x, direction_y, distance, sigma, w\\n M = X.shape[0]\\n N = X.shape[1]\\n # calculate the distance of each particle from the beginning of its road segment\\n dists = np.linalg.norm(X[:, :, :2] - X[:, :, 2:4], axis=-1)\\n\\n h = 0\\n for start in r.keys():\\n for end in r[start].keys():\\n length = r[start][end]\\n bin_start = 0.0\\n # find the particles on this road segment\\n on_edge = np.all(X[:, :, 2:6] == start + end, axis=-1)\\n while bin_start < length:\\n in_bin = np.all([dists >= bin_start, dists <= bin_start + res], axis=0)\\n count = np.sum(np.all([on_edge, in_bin], axis=0))\\n p = count / (N*M)\\n if p > 0:\\n h -= p*np.log(p)\\n #\\n bin_start += res\\n #\\n #\\n #\\n return h\",\n \"def _kernel(self, x, y, t):\\n return (self.C / (2 * np.pi * self.sigma_x * self.sigma_y * t)) * \\\\\\n tf.exp(- self.beta * t - (tf.square(x)/tf.square(self.sigma_x) + tf.square(y)/tf.square(self.sigma_y)) / (2*t))\",\n \"def pdist(x, y):\\n\\n x2 = tf.tile(tf.expand_dims(tf.reduce_sum(tf.square(x), 1), 1),\\n tf.pack([1, tf.shape(y)[0]]))\\n y2 = tf.tile(tf.transpose(tf.expand_dims(tf.reduce_sum(\\n tf.square(y), 1), 1)), tf.pack([tf.shape(x)[0], 1]))\\n xy = tf.matmul(x, y, transpose_b=True)\\n return x2 - 2 * xy + y2\",\n \"def regress_origin(x, y):\\r\\n x, y = array(x, 'Float64'), array(y, 'Float64')\\r\\n return sum(x * y) / sum(x * x), 0\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def converge(p_tx, beta, converge_dist, p_x, p_yx, p_yx_co_occur):\\n\\n # To return\\n p_yt = None\\n iterations = 0\\n # To compute free energy\\n p_t = None\\n js_div = None\\n\\n while True:\\n iterations = iterations + 1\\n \\n p_t = p_tx.T.dot(p_x)\\n\\n p_yt_co_occur = p_yx_co_occur.map(lambda (a, v): np.outer(p_tx[a, :], v.toarray())) \\\\\\n .sum()\\n p_yt = norm(p_yt_co_occur)\\n\\n # new p(t|x)\\n if js_div:\\n js_div.unpersist()\\n p_yt_sum = np.sum(p_yt, axis=1)\\n js_div = p_yx.map(lambda (a, v): (a, distance(v, p_yt, p_yt_sum))).cache()\\n\\n new_p_tx = js_div.map(lambda (a, v): (a, get_membership(v, p_t, beta))) \\\\\\n .sortByKey() \\\\\\n .map(lambda p: p[1]).collect()\\n new_p_tx = np.array(new_p_tx)\\n\\n max_diff = np.max(distance(p_tx, new_p_tx))\\n if max_diff <= converge_dist:\\n break\\n\\n p_tx = new_p_tx\\n\\n free_energy = get_free_energy(p_tx, p_t, p_x, js_div, beta)\\n js_div.unpersist()\\n\\n return p_yt, p_tx, free_energy, iterations\",\n \"def DyEvo(x, t, T0, r1, r2, K_co, K_ch, alpha, n):\\n y=np.zeros([np.size(x)])\\n D=np.zeros([2]) \\n #define fitnss\\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \\n #degradation\\n deg=fmax*x[1]/(x[1]+Kd) \\n #ODE of eco-evo dynamics\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r1*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\\n y[2]=x[2]*(r2*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\\n \\n return y\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def softmax_loss(x, y):\\n N, C = x.shape\\n loss, dx = 0, np.zeros(x.shape) \\n for i in range(N):\\n loss += -np.log(np.exp(x[i,y[i]])/np.sum(np.exp(x[i,:])))\\n dx[i,:] = np.exp(x[i,:])/np.sum(np.exp(x[i,:]))\\n dx[i,y[i]] += (-1)\\n \\n loss /= N\\n dx /= N\\n return loss, dx\",\n \"def fit(self, X, y):\\n\\n\\t\\trgen = np.random.RandomState(self.random_state)\\n\\t\\tself.w_ = rgen.normal(loc=0.0, scale=0.01, size=1+X.shape[1])\\n\\t\\tself.cost_ = []\\n\\n\\t\\tfor i in range(self.n_iter):\\n\\t\\t\\tnet_input = self.net_input(X)\\n\\t\\t\\toutput = self.activation(net_input)\\n\\t\\t\\terrors = y - output\\n\\t\\t\\tself.w_[1:] += self.eta * X.T.dot(errors)\\n\\t\\t\\tself.w_[0] += self.eta * errors.sum()\\n\\t\\t\\tcost = - y.dot(np.log(output)) - ((1-y).dot(np.log(1-output)))\\n\\t\\t\\tself.cost_.append(cost)\\n\\t\\treturn self\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def mutual_information(x, y, w):\\r\\n \\r\\n\\r\\n total_entropy = entropy(y,w)\\r\\n\\r\\n partitioned_x = partition(x)\\r\\n weighted_entropy = 0\\r\\n # calculate the weighted entropy over the partition of x\\r\\n vals,counts= np.unique(x,return_counts=True)\\r\\n for key in partitioned_x:\\r\\n weighted_entropy += np.sum([(np.sum(w[partitioned_x[key]])/np.sum(w)) * entropy(y[partitioned_x[key]],w[partitioned_x[key]])])\\r\\n\\r\\n information_gain = total_entropy - weighted_entropy\\r\\n return information_gain\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\n \"def train(self, X, y):\\n m = X.shape[0]\\n D = np.empty(m)\\n D.fill(1/(m*1.0))\\n\\n hs = 0\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n eps = 0\\n\\n for j in range(m): \\n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\\n eps+=D[j]\\n\\n self.w[t] =0.5*math.log((1/eps)-1)\\n\\n Dtmp = []\\n for j in range(m):\\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\\n\\n Dtmp = np.array(Dtmp) \\n s = np.sum(Dtmp)\\n\\n for i in range(m):\\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\n \"def prediction_cost(a, y):\\n return np.sum((a - y) ** 2) / 2\",\n \"def evaluate(t, x, y):\\n r = np.sqrt(x**2 + y**2)\\n return contrast * np.cos(kx_g*x + ky_g*y - w_g*t) * (1 - heaviside(r - patch_diameter*0.5))\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def TargetFunction(p,x,y):\\n \\n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y\",\n \"def regress(x, y):\\r\\n x, y = array(x, 'Float64'), array(y, 'Float64')\\r\\n N = len(x)\\r\\n Sx = sum(x)\\r\\n Sy = sum(y)\\r\\n Sxx = sum(x * x)\\r\\n Syy = sum(y * y)\\r\\n Sxy = sum(x * y)\\r\\n det = Sxx * N - Sx * Sx\\r\\n return (Sxy * N - Sy * Sx) / det, (Sxx * Sy - Sx * Sxy) / det\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def to_thermo(x,y):\\n\\tp = p_from_y(y)\\n\\tT_C = T_from_xp(x,p) - C_to_K\\n\\treturn T_C, p\",\n \"def optimize(self, X, y):\\n print(\\\"Performing TPOT genetic optimization.\\\")\\n self.model.fit(X, y)\\n self.optimized = True\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def CHARGE(t, x, y):\\n Iq, UC, U = x\\n E, Umax = y # time discrete state vector\\n E_new = E + Cp/2 * U**2\\n return array([0.0, UC, 0.0]), array([E_new, U])\",\n \"def _raw_ot_integration(\\n Xs: np.ndarray, Xt: np.ndarray, metric: str = \\\"sqeuclidean\\\", eps=1e-3, verbose=False\\n):\\n n, d1 = Xs.shape\\n m, d2 = Xt.shape\\n\\n assert (\\n d1 == d2\\n ), \\\"Dimensions do not coincide %i (source) vs %i (target). Terminating...\\\" % (\\n d1,\\n d2,\\n )\\n\\n w_x, w_y = np.ones((n,)) / n, np.ones((m,)) / m\\n if verbose:\\n print(\\\"> Computing distance matrix...\\\")\\n M = dist(Xs, Xt, metric=metric)\\n M /= M.max()\\n if verbose:\\n print(\\\"> Computing optimal transport plan...\\\")\\n Gs = sinkhorn(w_x, w_y, M, eps)\\n if verbose:\\n print(\\\"> Projecting source dataset...\\\")\\n return np.diag(1 / w_x) @ Gs @ Xt\",\n \"def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n f = -(x + y) / 2\\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\\n return t - f\",\n \"def nt_xent_loss(out_1, out_2, temperature, eps=1e-6):\\n # gather representations in case of distributed training\\n # out_1_dist: [batch_size * world_size, dim]\\n # out_2_dist: [batch_size * world_size, dim]\\n if torch.distributed.is_available() and torch.distributed.is_initialized():\\n out_1_dist = SyncFunction.apply(out_1)\\n out_2_dist = SyncFunction.apply(out_2)\\n else:\\n out_1_dist = out_1\\n out_2_dist = out_2\\n\\n # out: [2 * batch_size, dim]\\n # out_dist: [2 * batch_size * world_size, dim]\\n out = torch.cat([out_1, out_2], dim=0)\\n out_dist = torch.cat([out_1_dist, out_2_dist], dim=0)\\n\\n # cov and sim: [2 * batch_size, 2 * batch_size * world_size]\\n # neg: [2 * batch_size]\\n cov = torch.mm(out, out_dist.t().contiguous())\\n sim = torch.exp(cov / temperature)\\n neg = sim.sum(dim=-1)\\n\\n # from each row, subtract e^1 to remove similarity measure for x1.x1\\n row_sub = torch.Tensor(neg.shape).fill_(math.e).to(neg.device)\\n neg = torch.clamp(neg - row_sub, min=eps) # clamp for numerical stability\\n\\n # Positive similarity, pos becomes [2 * batch_size]\\n pos = torch.exp(torch.sum(out_1 * out_2, dim=-1) / temperature)\\n pos = torch.cat([pos, pos], dim=0)\\n\\n loss = -torch.log(pos / (neg + eps)).mean()\\n\\n return loss\",\n \"def energy_function(self, x):\\n \\n return -T.dot(T.transpose(x), T.dot(self.W, x)) -\\\\\\n T.dot(T.transpose(self.b), x)\",\n \"def deriv_costFunction(self, x, y):\\n self.yEst = self.forward_propagate(x)\\n\\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\\n #partial deriv of cost wrt hidden -> output weights\\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\\n\\n ones_o = np.ones( delta_o.shape[0] )\\n #partial deriv of cost wrt output biases\\n partial_J_b_o = np.dot( ones_o, delta_o )\\n\\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\\n #partial deriv of cost wrt input -> hidden weights\\n partial_J_w_ih = np.dot( x.T, delta_h )\\n \\n ones_h = np.ones( delta_h.shape[0] )\\n #partial deriv of cost wrt hidden biases\\n partial_J_b_h = np.dot( ones_h, delta_h)\\n\\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o\",\n \"def SSE(y, yhat):\\n\\n return np.sum(np.power(yhat - y, 2))\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def forward(self, y):\\n # landmarks are the weighted average y\\n # activations across each channel\\n y_projected = torch.zeros_like(y)\\n y = self.softmax(y)\\n\\n # self.save_image(y[0, :, :, :])\\n\\n # print(y.size())\\n # y_0 = y\\n y = y.view(y.size(0), y.size(1), -1)\\n # print(y[0, :].min(), y[0, :].max())\\n mu_y = y * self.yv.reshape(1, 1, -1)\\n mu_y = mu_y.sum(dim=-1) #/ y.sum(dim=-1)\\n mu_x = y * self.xv.reshape(1, 1, -1)\\n mu_x = mu_x.sum(dim=-1) #/ y.sum(dim=-1)\\n means = torch.cat((mu_y.unsqueeze(-1), mu_x.unsqueeze(-1)), dim=-1)\\n\\n # project landmarsk to guassain fuction with fixed standard deviation\\n # yv, xv = torch.meshgrid([torch.arange(0, y.size(-2)), torch.arange(0, y.size(-1))])\\n # h_act = torch.zeros(y_projected.size(0), y_projected.size(1), device=y.device)\\n for batch_id in range(y_projected.size(0)):\\n for heatmap_id in range(y_projected.size(1)):\\n gdist = MultivariateNormal(means[batch_id, heatmap_id, :], covariance_matrix=self.cov)\\n logprobs = gdist.log_prob(torch.cat((self.yv.unsqueeze(0), self.xv.unsqueeze(0)), dim=0).t())\\n y_projected[batch_id, heatmap_id, :, :] = torch.exp(logprobs).reshape(y_projected.size(-2), y_projected.size(-1))\\n # y_projected[batch_id, heatmap_id, :, :] -= y_projected[batch_id, heatmap_id, :, :].min()\\n # y_projected[batch_id, heatmap_id, :, :] /= y_projected[batch_id, heatmap_id, :, :].max()\\n # coords = means[batch_id, heatmap_id, :].round().long()\\n # h_act[batch_id, heatmap_id] = y_0[batch_id, heatmap_id, coords[0], coords[1]]\\n # h_act[batch_id, heatmap_id]\\n # max_coords = y_0[batch_id, heatmap_id, :, :].clone()\\n # max_coords[max_coords < max_coords.max()] = 0\\n # # print(max_coords.size())\\n # if batch_id == 0 and heatmap_id == 0:\\n # print(means[batch_id, heatmap_id, :], max_coords.nonzero().float().mean(0))\\n # a = 'fail' if y.pow(2).mean() > h_act.mean() else 'pass'\\n # print(h_act.mean(), y.mean())\\n # print(y_projected.max(), y_projected.min())\\n # y_out = y_projected.sum(dim=1)\\n # self.save_image(y_out.unsqueeze(1), normalize=True)\\n # self.save_image(y_out.unsqueeze(1), normalize=True, output='landmarks')\\n return y_projected, self.prior_loss(means, y)\",\n \"def get_evaporation_latent_heat() -> float:\\n theta = 28.0\\n return 2500.8 - 2.3668 * theta\",\n \"def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for low temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n S_low = (\\n -gbar\\n * np.sqrt(2)\\n / (6 * np.pi ** 2)\\n * tt_low ** (3 / 2)\\n * vv_low\\n * (\\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\\n )\\n )\\n # low temperatures - high numbers\\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((S_low, S_high)).reshape(y.shape)\",\n \"def interp_n2(t, x, y):\\n\\n return y[:, 0] + (t - x[0]) * (y[:, 1] - y[:, 0]) / (x[1] - x[0])\",\n \"def softmax_loss(x, y):\\n #raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\\n N=x.shape[0]\\n\\n \\n x-=np.max(x,axis=1,keepdims=True)\\n temp=np.exp(x)\\n dr_vec=np.sum(temp,axis=1,keepdims=True)\\n\\n nr=(x[np.arange(N),y]).reshape([N,1])\\n loss=np.sum(-(nr)+np.log(dr_vec))\\n \\n loss=(loss/N)\\n temp/=dr_vec\\n temp[np.arange(N),y] -= 1\\n \\n dx = temp/N\\n \\n return loss, dx\",\n \"def forward(self, x, y, t):\\r\\n # Compute shapes.\\r\\n batch_size = x.shape[0]\\r\\n n_in = x.shape[1]\\r\\n n_out = t.lshape[1]\\r\\n \\r\\n #pdb.set_trace()\\r\\n\\r\\n # Compute the pairwise distances.\\r\\n # Shape: (batch, n_in, n_out).\\r\\n \\r\\n #pdb.set_tracdb.set_trace()\\r\\n dists = compute_dists(x, t)\\r\\n\\r\\n # Compute the weights.\\r\\n # Shape: (batch, n_in, n_out, in_channels).\\r\\n wt = self.rbf(dists)\\r\\n\\r\\n # Compute the extra density channel.\\r\\n # Shape: (batch, n_in, 1).\\r\\n density = torch.ones(batch_size, n_in, 1).to(device)\\r\\n\\r\\n # Concatenate the channel.\\r\\n # Shape: (batch, n_in, in_channels + 1).\\r\\n y_out = torch.cat([density, y], dim=2)\\r\\n\\r\\n # Perform the weighting.\\r\\n # Shape: (batch, n_in, n_out, in_channels + 1).\\r\\n y_out = y_out.view(batch_size, n_in, -1, self.in_channels) * wt\\r\\n\\r\\n # Sum over the inputs.\\r\\n # Shape: (batch, n_out, in_channels + 1).\\r\\n y_out = y_out.sum(1)\\r\\n\\r\\n # Use density channel to normalize convolution.\\r\\n density, conv = y_out[..., :1], y_out[..., 1:]\\r\\n normalized_conv = conv / (density + 1e-8)\\r\\n y_out = torch.cat((density, normalized_conv), dim=-1)\\r\\n\\r\\n # Apply the point-wise function.\\r\\n # Shape: (batch, n_out, out_channels).\\r\\n y_out = y_out.view(batch_size * n_out, self.in_channels)\\r\\n y_out = self.g(y_out)\\r\\n y_out = y_out.view(batch_size, n_out, self.out_channels)\\r\\n\\r\\n return y_out\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def DyCheat(x, t, T0, r2, K, alpha, n):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r2*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def fit(self,X,y):\\n \\n rand_num = np.random.RandomState(self.random_state)\\n self.w_ = rand_num.normal(loc = 0.0, scale = 0.01,size = 1 + X.shape[1])\\n self.cost_ = []\\n \\n for i in range(self.n_iter):\\n net_input = self.net_input(X)\\n output = self.activation(net_input)\\n errors = (y - output)\\n self.w_[1:] += self.eta * X.T.dot(errors)\\n self.w_[0] += self.eta * errors.sum()\\n cost = (errors**2).sum()/2.0\\n self.cost_.append(cost)\\n return self\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def SG(self, h, y):\\n self.check_sg_weights()\\n\\n A = self.sg_weights[0] #(n, n)\\n B = self.sg_weights[1] #(10, n)\\n C = self.sg_weights[2] #(1, n)\\n\\n delta = np.matmul(h, A) + np.matmul(y, B) + C\\n return delta\",\n \"def power_output_candidate_thermal_rule(_m, g, y, s, t):\\r\\n\\r\\n if y != m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y != m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n else:\\r\\n raise Exception(f'Unhandled case: {g, y, s, t}')\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def fit(self, X, y):\\n\\t\\trgen = np.random.RandomState(self.random_state)\\n\\t\\tself.w_ = rgen.normal(loc=0.0, scale=0.01, size=1+X.shape[1])\\n\\t\\tself.cost_ = []\\n\\n\\t\\tfor i in range(self.n_iter):\\n\\t\\t\\tnet_input = self.net_input(X)\\n\\t\\t\\toutput = self.activation(net_input)\\n\\t\\t\\terrors = y - output\\n\\t\\t\\t#update weights\\n\\t\\t\\tself.w_[1:] += self.eta * X.T.dot(errors)\\n\\t\\t\\tself.w_[0] += self.eta * errors.sum()\\n\\t\\t\\tcost = (errors**2).sum() / 2.0\\n\\t\\t\\tself.cost_.append(cost)\\n\\t\\treturn self\",\n \"def y(x):\\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def cost_function(data_x, data_y, parameters):\\n # Residual sum of squares\\n rss = np.sum((data_x @ parameters - data_y) ** 2)\\n\\n # Number of rows times 2\\n nb_rows_x2 = 2 * data_x.shape[0]\\n\\n return rss / nb_rows_x2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6386833","0.6281865","0.6155928","0.6110233","0.59215057","0.59209555","0.58993256","0.5835102","0.5834109","0.58311456","0.58072424","0.5790104","0.5757953","0.57465935","0.57386595","0.56911635","0.5677439","0.5672302","0.5649353","0.5635235","0.56268895","0.56268895","0.5580255","0.55776644","0.5576921","0.5575335","0.5568885","0.55651116","0.55568516","0.55488086","0.55478364","0.55434865","0.55277324","0.5522637","0.5520894","0.55188495","0.5517053","0.5514781","0.55101824","0.55054504","0.5500502","0.5499963","0.54988426","0.5484543","0.54813474","0.54775","0.54640055","0.5462382","0.54608387","0.5458313","0.54569405","0.5441317","0.5431281","0.5430466","0.5421909","0.54185605","0.5414892","0.54136646","0.5412292","0.5411319","0.5408747","0.540202","0.53887063","0.5386882","0.53842765","0.53824747","0.53812027","0.536591","0.53513116","0.5338281","0.52940935","0.52932966","0.52918386","0.52890253","0.5288373","0.5283436","0.5283177","0.5277268","0.5274962","0.52713716","0.5268838","0.5267588","0.5263867","0.525955","0.5256748","0.5249995","0.5248105","0.52435195","0.5234984","0.5232131","0.52292943","0.5226649","0.5217866","0.52172244","0.5210937","0.5202351","0.51955","0.5194678","0.51889503","0.5181447","0.51812553"],"string":"[\n \"0.6386833\",\n \"0.6281865\",\n \"0.6155928\",\n \"0.6110233\",\n \"0.59215057\",\n \"0.59209555\",\n \"0.58993256\",\n \"0.5835102\",\n \"0.5834109\",\n \"0.58311456\",\n \"0.58072424\",\n \"0.5790104\",\n \"0.5757953\",\n \"0.57465935\",\n \"0.57386595\",\n \"0.56911635\",\n \"0.5677439\",\n \"0.5672302\",\n \"0.5649353\",\n \"0.5635235\",\n \"0.56268895\",\n \"0.56268895\",\n \"0.5580255\",\n \"0.55776644\",\n \"0.5576921\",\n \"0.5575335\",\n \"0.5568885\",\n \"0.55651116\",\n \"0.55568516\",\n \"0.55488086\",\n \"0.55478364\",\n \"0.55434865\",\n \"0.55277324\",\n \"0.5522637\",\n \"0.5520894\",\n \"0.55188495\",\n \"0.5517053\",\n \"0.5514781\",\n \"0.55101824\",\n \"0.55054504\",\n \"0.5500502\",\n \"0.5499963\",\n \"0.54988426\",\n \"0.5484543\",\n \"0.54813474\",\n \"0.54775\",\n \"0.54640055\",\n \"0.5462382\",\n \"0.54608387\",\n \"0.5458313\",\n \"0.54569405\",\n \"0.5441317\",\n \"0.5431281\",\n \"0.5430466\",\n \"0.5421909\",\n \"0.54185605\",\n \"0.5414892\",\n \"0.54136646\",\n \"0.5412292\",\n \"0.5411319\",\n \"0.5408747\",\n \"0.540202\",\n \"0.53887063\",\n \"0.5386882\",\n \"0.53842765\",\n \"0.53824747\",\n \"0.53812027\",\n \"0.536591\",\n \"0.53513116\",\n \"0.5338281\",\n \"0.52940935\",\n \"0.52932966\",\n \"0.52918386\",\n \"0.52890253\",\n \"0.5288373\",\n \"0.5283436\",\n \"0.5283177\",\n \"0.5277268\",\n \"0.5274962\",\n \"0.52713716\",\n \"0.5268838\",\n \"0.5267588\",\n \"0.5263867\",\n \"0.525955\",\n \"0.5256748\",\n \"0.5249995\",\n \"0.5248105\",\n \"0.52435195\",\n \"0.5234984\",\n \"0.5232131\",\n \"0.52292943\",\n \"0.5226649\",\n \"0.5217866\",\n \"0.52172244\",\n \"0.5210937\",\n \"0.5202351\",\n \"0.51955\",\n \"0.5194678\",\n \"0.51889503\",\n \"0.5181447\",\n \"0.51812553\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":83796,"cells":{"query":{"kind":"string","value":"Find the line that contains or matches substr since line ``start``."},"document":{"kind":"string","value":"def find_line(lines: List[str], substr: Predicate, start: int = 0) -> int:\n if isinstance(substr, str):\n pred = _string_contains\n elif isinstance(substr, tuple):\n pred = _pattern_value_match\n else:\n pred = _apply_func\n\n for i in range(start, len(lines)):\n if pred(lines[i], substr):\n return i\n\n raise Exception(\"Not found: \" + str(substr) + \"\\n text:\" + str(lines) )"},"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 _match_start_get_remaining(self, start, text):\n if not text.startswith(start):\n return\n return text[len(start):]","def _get_prev_line_having_substr(substr):\n last_occ_idx = vim.eval(SEARCH_LAST_CMD.format(substr=substr))\n if last_occ_idx == 0:\n return\n line_content = vim.eval(GET_LINE_CMD.format(line_num=last_occ_idx))\n line_content = line_content.strip().split()\n substr_container = line_content[1]\n substr_name, _ = substr_container.split(\"(\")\n return substr_name","def get_str_between_s_and_e(start_str, end_str, line):\n\tstart = line.find(start_str)\n\tif start >= 0:\n\t\tstart = start + len(start_str)\n\t\tend = line.find(end_str, start)\n\t\tif end >= 0:\n\t\t\treturn line[start:end].strip()\n\telse:\n\t\treturn None","def line_substring(\n self, start: ir.FloatingValue, end: ir.FloatingValue\n ) -> ir.LineStringValue:\n return ops.GeoLineSubstring(self, start, end).to_expr()","def find_start_end(text, start_text, end_text, start=0):\n # return (s, e) or None\n s = text.find(start_text, start)\n if s < 0:\n return None\n e = text.find(end_text, s+1)\n if e < 0:\n return None\n e += len(end_text)\n return s, e","def reverse_search(view, what, start=0, end=-1, flags=0):\n if end == -1:\n end = view.size()\n end = find_eol(view, view.line(end).a)\n\n last_match = None\n\n lo, hi = start, end\n while True:\n middle = (lo + hi) / 2\n line = view.line(middle)\n middle, eol = find_bol(view, line.a), find_eol(view, line.a)\n\n if search_in_range(view, what, middle, hi, flags):\n lo = middle\n elif search_in_range(view, what, lo, middle - 1, flags):\n hi = middle -1\n\n # Don't search forever the same line.\n if last_match and line.contains(last_match):\n match = find_last_match(view, what, lo, hi, flags=flags)\n return view.rowcol(match.begin())[0] + 1\n\n last_match = sublime.Region(line.begin(), line.end())","def find_line(view, start=0, end=-1, target=0):\r\n if target < 0 or target > view.size():\r\n return -1\r\n\r\n if end == -1: end = view.size()\r\n\r\n lo, hi = start, end\r\n while lo <= hi:\r\n middle = lo + (hi - lo) / 2\r\n if get_line_nr(view, middle) < target:\r\n lo = getEOL(view, middle) + 1\r\n elif get_line_nr(view, middle) > target:\r\n hi = getBOL(view, middle) - 1\r\n else:\r\n return view.full_line(middle)\r\n return -1","def find_text_between(start,end,haystack):\n found = re.search(start+'(.*)'+end,haystack,re.IGNORECASE | re.DOTALL)\n \n if found:\n return found.group(1).strip()\n else:\n raise Exception(\"There is no substring starting with '{}', ending\"\n \" with '{}' in content '{}' \".format(start,end,haystack))","def find_start(self): # -> str | None:\n ...","def find(a, sub, start=0, end=None):\n return _vec_string(\n a, int_, 'find', [sub, start] + _clean_args(end))","def find_start(lines, start_str, reverse=True):\n start = -1\n # Iterate backwards until the last value is found\n if reverse:\n for i, line in reversed(list(enumerate(lines))):\n if start_str == line:\n return i\n else:\n for i, line in enumerate(lines):\n if start_str == line:\n return i\n return start","def find(self, sub, start=0, end=None):\n return find(self, sub, start, end)","def rfind(a, sub, start=0, end=None):\n return _vec_string(\n a, int_, 'rfind', [sub, start] + _clean_args(end))","def findWithStart(astring, achar, start=0):\n ix = start\n found = False\n while ix < len(astring) and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def findWithStart(astring, achar, start=0):\n ix = start\n found = False\n while ix < len(astring) and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def findWithStart(astring, achar, start=0):\n ix = start\n found = False\n while ix < len(astring) and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def rfind(self, sub, start=0, end=None):\n return rfind(self, sub, start, end)","def _visit_str_match(\n node,\n string,\n left_offset,\n result: ObjectParserResult\n) -> ParseDelegationReturnMetadata:\n look_for = node.value[1:-1]\n does_start_with = string.startswith(look_for)\n if does_start_with:\n result.remaining_start_i += len(look_for)\n return ParseDelegationReturnMetadata(does_start_with, string, left_offset,\n node, len(look_for))\n else:\n return ParseDelegationReturnMetadata(False, string, left_offset, node, None)","def partial_word_matches(self):\n start = '1.0'\n while True:\n start = self.text.search(self.term, start, stopindex=tk.END)\n if not start:\n break\n end = start + f'+{self.chars}c'\n self.text.tag_add('found', start, end)\n start = end","def partial_word_matches(self):\n start = '1.0'\n while True:\n start = self.text.search(self.term, start, stopindex=tk.END)\n if not start:\n break\n end = start + f'+{self.chars}c'\n self.text.tag_add('found', start, end)\n start = end","def next_word(self, start):\n end_idx = self.idx + len(start)\n if self.match(start):\n return self.line[end_idx] if end_idx < len(self.line) else END","def find_substring_offset(\n context: bytes,\n substring: bytes,\n):\n start = 0\n while True:\n start = context.find(substring, start)\n # use start += 1 to find overlapping matches\n if start == -1:\n return\n yield start\n start += len(substring)","def findWithEnd(astring, achar, start=0, end=None):\n ix = start\n if end == None:\n end = len(astring)\n\n found = False\n while ix < end and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def findWithEnd(astring, achar, start=0, end=None):\n ix = start\n if end == None:\n end = len(astring)\n\n found = False\n while ix < end and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def findWithEnd(astring, achar, start=0, end=None):\n ix = start\n if end == None:\n end = len(astring)\n\n found = False\n while ix < end and not found:\n if astring[ix] == achar:\n found = True\n else:\n ix = ix + 1\n if found:\n return ix\n else:\n return -1","def find_last_match(view, what, start, end, flags=0):\n match = view.find(what, start, flags)\n new_match = None\n while match:\n new_match = view.find(what, match.end(), flags)\n if new_match and new_match.end() <= end:\n match = new_match\n else:\n return match","def is_in_log(self, regex, start=0):\n\n ex = re.compile(regex)\n for l in self.logs[start:]:\n if ex.search(l):\n logging.debug(\"Found '%s' in logs\", regex)\n return l\n\n logging.debug(\"Did not find '%s' in logs\", regex)\n return None","def _find_or_none(string, substring, start):\n index = string.find(substring, start)\n return index if index != -1 else None","def _start_magic(line):\n return start(line)","def next_section_start_pos(text, start):\n section_re = re.compile(\"^.*\\n-+$\", re.I|re.MULTILINE) \n next_section = section_re.search(text, start)\n return len(text) if next_section is None else next_section.start()","def findInLine(self) -> str:\n raise NotImplementedError","def find(self, stripped_line):\n return self._index.get(stripped_line, ())","def find_text_in_string(string, start_text, end_text):\r\n index_start = string.rfind(start_text)\r\n if not index_start==-1:\r\n index_end = string.rfind(end_text)\r\n str = string[index_start+len(start_text):index_end]\r\n return str","def getDataPart( job, data, lineStart ):\n\tposOne = data.find( lineStart )\n\tif posOne != -1:\n\t\tposOne = posOne + len( lineStart )\n\t\tposTwo = data.find( \"\\n\", posOne )\n\t\tsubstring = data[posOne:posTwo]\n\t\treturn substring\n\telse:\n\t\tjob.log(\"\\tCould not find \\\"\" + lineStart + \"\\\"\" )\n\t\treturn None","def getDataPart( job, data, lineStart ):\n\tposOne = data.find( lineStart )\n\tif posOne != -1:\n\t\tposOne = posOne + len( lineStart )\n\t\tposTwo = data.find( \"\\n\", posOne )\n\t\tsubstring = data[posOne:posTwo]\n\t\treturn substring\n\telse:\n\t\tjob.log(\"\\tCould not find \\\"\" + lineStart + \"\\\"\" )\n\t\treturn None","def match_start_string(list_to_search, substring):\n # Whitespace is stripped before and after the substring,\n # but not within (e.g. \" New York City \" -> \"New York City\").\n clean_substring = substring.lstrip().rstrip().lower()\n items_found = []\n ([items_found.append(item) for item in list_to_search\n if clean_substring == item[:len(clean_substring)].lower()])\n return items_found","def try_match(self, i: int, line: str) -> ScannedStringSegment:\n start = line[i:] # take the unmatched string\n for regex, token in self.rules:\n compiled_regex = re.compile(regex) # compile regex\n match = compiled_regex.match(start) # verify to see if the string matches the regex\n if match: # if a match is found\n begin, end = match.span() # take the begin and end index\n return ScannedStringSegment(token, i, start[:end], end)\n return ScannedStringSegment(None, None, start, None) # if a match if not found","def starts_with(text, substring):\n assert text.startswith(substring), \"%r doesn't start with %r\" % (text,\n substring)","def slice_by_pos(val: str, start: SourcePos, end: SourcePos) -> str:\n if \"\\n\" in val:\n lines = val.split(\"\\n\")\n if end.row > start.row:\n top = lines[start.row][start.col :]\n filling = lines[start.row + 1 : end.row]\n bottom = lines[end.row][: end.col]\n return \"\\n\".join(line for line in chain([top], filling, [bottom]))\n else:\n return lines[start.row][start.col : end.col]\n else:\n return val[start.col : end.col]","def test_line_substring():\n for _x in range(100):\n l_str = random_str(50, 100)\n line = Line(l_str, random_str(10, 20), randint(1, 10000))\n # Try a single charater\n c_idx = randint(0, len(l_str)-1)\n sub_line = line[c_idx]\n assert sub_line == l_str[c_idx]\n assert isinstance(sub_line, Line)\n assert sub_line.file == line.file\n assert sub_line.number == line.number\n # Try a range\n s_idx = randint(0, (len(l_str) // 2) - 1)\n e_idx = randint(len(l_str) // 2, len(l_str) - 1)\n sub_line = line[s_idx:e_idx]\n assert sub_line == l_str[s_idx:e_idx]\n assert sub_line.file == line.file\n assert sub_line.number == line.number","def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode) -> ghidra.program.model.address.Address:\n ...","def match(line,keyword):\n line=line.lstrip()\n length=len(keyword)\n if line[:length] == keyword:\n return line[length:]\n else:\n return None","def match(self, string, substr):\n hp = self.hash(substr)\n hh = self.hash(string[0:0+len(substr)])\n if hh == hp:\n if string[0:0+len(substr)] == substr:\n return 0\n for i in xrange(1, len(string) - len(substr) + 1):\n hh = hh - ord(string[i-1]) + ord(string[i + len(substr) -1])\n if hh == hp:\n if string[i:i+len(substr)] == substr:\n return i\n return -1","def find_all_iter( source, substring, start=None, end=None, overlap=False ):\n data = source\n base = 0\n if end is not None:\n data = data[:end]\n if start is not None:\n data = data[start:]\n base = start\n pointer = 0\n increment = 1 if overlap else (len( substring ) or 1)\n while True:\n pointer = data.find( substring, pointer )\n if pointer == -1:\n return\n yield base+pointer\n pointer += increment","def substring_match(recipe, word):\n if names_only:\n line = recipe.name\n else:\n line = str(recipe)\n\n if not case:\n word = word.lower()\n line = line.lower()\n\n return line.find(word) != -1","def extract_line(line, pos):\n found = u''\n depth = 0\n offset = 0\n for c in line:\n if c == '<':\n depth += 1\n elif c == '>':\n depth -= 1\n if depth == 0:\n pos -= process_match(found[1:], pos + offset)\n found = u''\n\n if depth > 0:\n found += c\n\n offset += 1\n return pos + offset","def test_match_regexp_including_start():\r\n runmatch(lcode)","def get_substring(self, start, end):\n return self.input[start:end]","def startswith(a, prefix, start=0, end=None):\n return _vec_string(\n a, bool_, 'startswith', [prefix, start] + _clean_args(end))","def find_next(lines, find_str, start_index):\n mode = None\n if isinstance(find_str, basestring):\n mode = 'normal'\n message = find_str\n elif isinstance(find_str, Invert):\n mode = 'invert'\n message = str(find_str)\n else:\n raise TypeError(\"Unsupported message type\")\n for i in range(start_index, len(lines)):\n if re.search(message, lines[i]):\n return mode == 'normal', i, lines[i]\n elif message in lines[i]:\n return mode == 'normal', i, lines[i]\n if mode == 'invert':\n return True, len(lines), None\n raise LookupError(\"Not found\")","def between_markers(text: str, begin: str, end: str) -> str:\n # your code here\n return text[text.find(begin) + 1:text.find(end)]","def whole_word_matches(self):\n start = '1.0'\n while True:\n start = self.text.search(self.term, start, stopindex=tk.END)\n if not start:\n break\n end = start + ' wordend'\n # whole word includes a space before\n found = self.text.get(start + '-1c', end)\n if found == ' ' + self.term:\n self.text.tag_add('found', start, end)\n start = end","def whole_word_matches(self):\n start = '1.0'\n while True:\n start = self.text.search(self.term, start, stopindex=tk.END)\n if not start:\n break\n end = start + ' wordend'\n # whole word includes a space before\n found = self.text.get(start + '-1c', end)\n if found == ' ' + self.term:\n self.text.tag_add('found', start, end)\n start = end","def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode, matchLimit: int, alignment: int) -> List[ghidra.program.model.address.Address]:\n ...","def _linesearch(self):\n pass","def test_match_start_check_at_beginning_of_string(self):\n first_letter = \"a\"\n s = \"abcdef\"\n self.assertEqual(__, re.search(first_letter, s).group())","def get_line(file: str, line: str, logfile: str) -> Union[str, bool]:\n current_file = read_file_log(file, logfile)\n m = re_search(rf\"{line}\", current_file)\n if m is not None:\n return m.group(0)\n return False","def find_section(lines, MF=3, MT=3):\n v = [l[70:75] for l in lines]\n n = len(v)\n cmpstr = '%2s%3s' % (MF, MT) # search string\n i0 = v.index(cmpstr) # first occurrence\n i1 = n - v[::-1].index(cmpstr) # last occurrence\n return lines[i0: i1]","def find_log_lines_with_content(self, prefixes, needle_substring, required_count, return_first_line):\n required_count = int(required_count)\n\n def check_function():\n all_data = []\n for prefix in prefixes:\n print('Analyzing prefix {}'.format(prefix))\n all_files = self.get_files_in_bucket(prefix=prefix,\n limit=self.S3_LISTING_REQUEST_LIMIT)\n for file in all_files:\n print('Analyzing file {}'.format(file))\n content = self.get_file_content_from_bucket(file)\n for line in content.splitlines():\n if needle_substring in line:\n data = json.loads(line)\n all_data.append(data)\n if len(all_data) >= required_count and required_count != 0:\n return all_data\n\n if len(all_data) > 0 and required_count == 0:\n return all_data\n\n result = legion_test.utils.wait_until(check_function,\n self.WAIT_FILE_TIME, self.WAIT_FILE_ITERATIONS)\n if not result:\n raise Exception('{} log line(s) with {!r} has not been found'.format(required_count, needle_substring))\n if return_first_line:\n return result[0]\n else:\n return result","def match_segment(var, pattern, input, bindings, start=0):\n\n # If there are no words in pattern following var, we can just match var\n # to the remainder of the input.\n if not pattern:\n return match_variable(var, input, bindings)\n\n # Get the segment boundary word and look for the first occurrence in\n # the input starting from index start.\n word = pattern[0]\n try:\n pos = start + input[start:].index(word)\n except ValueError:\n # When the boundary word doesn't appear in the input, no match.\n return False\n\n # Match the located substring to the segment variable and recursively\n # pattern match using the resulting bindings.\n var_match = match_variable(var, input[:pos], dict(bindings))\n match = match_pattern(pattern, input[pos:], var_match)\n\n # If pattern matching fails with this substring, try a longer one.\n if not match:\n return match_segment(var, pattern, input, bindings, start + 1)\n \n return match","def test_search_must_not_start_at_the_beginning(self):\n pattern = \"cde\"\n s = \"abcdefabcdef\"\n self.assertEqual(__, re.search(pattern, s).group())","def get_substr(self, y, x1, x2):\n return self.lines[y][x1 : x2]","def subStringMatchExact(target,key,length):\r\n index = find(target,key)\r\n if index < 0:\r\n return ()\r\n else:\r\n matches = subStringMatchExact(target[index+len(key):len(target)],key,length)\r\n index += (length - len(target))\r\n matches += (index,)\r\n print matches\r\n return matches","def extract_string(line, idx, result):\n\n begin = line.find(resource_string_prefix, idx)\n if begin == -1:\n return -1\n \n begin = begin + len(resource_string_prefix)\n end = -1\n for i in range(begin, len(line)):\n if not is_valid_char(line[i]):\n end = i\n break\n\n result.add(line[begin:end])\n return end","def remove_from_start_if_present(target, start):\n if target and target.startswith(start):\n return ''.join(target[len(start):])\n return target","def want_line(self, op, first = 0):\n for ii in range(first, len(self.__content)):\n match = re.match(op, self.__content[ii], re.IGNORECASE)\n if match:\n return (ii, match.group(1))\n return None","def _get_start(self, variant, reference_start, cigar, ignore_softclip=False):\n indels = get_indel_from_cigar(cigar, ignore_softclip)\n start = variant.POS - reference_start - 1\n # for pos, val in indels.iteritems(): # python2\n for pos, val in indels.items():\n if pos > start:\n break\n if val[0] == 'I':\n start += val[1]\n elif val[0] == 'D':\n start -= val[1]\n return start","def find_segment(p, line, start_vertex=0):\n EPS = 1e-9\n for seg in range(start_vertex, len(line)-1):\n if is_near(p, line[seg]):\n return seg, 0\n if line[seg][0] == line[seg+1][0]:\n if not (p[0]-EPS <= line[seg][0] <= p[0]+EPS):\n continue\n px = None\n else:\n px = (p[0] - line[seg][0]) / (line[seg+1][0] - line[seg][0])\n if px is None or (0 <= px <= 1):\n if line[seg][1] == line[seg+1][1]:\n if not (p[1]-EPS <= line[seg][1] <= p[1]+EPS):\n continue\n py = None\n else:\n py = (p[1] - line[seg][1]) / (line[seg+1][1] - line[seg][1])\n if py is None or (0 <= py <= 1):\n if py is None or px is None or (px-EPS <= py <= px+EPS):\n return seg, px or py\n return None, None","def word_at_position(\n self,\n position: Position,\n re_start_word: Pattern = RE_START_WORD,\n re_end_word: Pattern = RE_END_WORD,\n ) -> str:\n lines = self.lines\n if position.line >= len(lines):\n return \"\"\n\n pos = position_from_utf16(lines, position)\n row, col = pos.line, pos.character\n line = lines[row]\n # Split word in two\n start = line[:col]\n end = line[col:]\n\n # Take end of start and start of end to find word\n # These are guaranteed to match, even if they match the empty string\n m_start = re_start_word.findall(start)\n m_end = re_end_word.findall(end)\n\n return m_start[0] + m_end[-1]","def getMatchingLine(self, line):\n tokens = map(str.lower, line.text.split()) # easy way to ignore case and whitespace\n for l in self.lines:\n if map(str.lower, l.text.split()) == tokens:\n return l # found a match\n \n return None # no matches found","def check_that_starter_log_contains(self, substring: str):\n if self.count_occurances_in_starter_log(substring) > 0:\n return\n else:\n raise Exception(\n f\"Expected to find the following string: {substring}\\n in this log file:\\n{str(self.log_file)}\"\n )","def search_start_end_index_in_sentence(sent, np):\n\n nps = [x for x in np.split() if x]\n if len(nps) == 0:\n return (-1, -1)\n elif len(nps) == 1:\n indices = search_one_token_reducing_suffix(sent, np)\n if len(indices) > 0:\n return (indices[0], search_next_whitespace(sent, indices[0]))\n else:\n return (-1, -1)\n else:\n # search start:\n start = search_correct_position(sent, nps)\n end = search_correct_position(sent, nps, True)\n if end != -1:\n end = search_next_whitespace(sent, end)\n return (start,end)","def re_search(pattern, text: str, start_indx: int = 0) -> Optional[int]:\n # \n match = pattern.search(text, start_indx)\n if match is not None:\n indx = match.start()\n else:\n indx = None\n return indx","def line_parser(line_starts_with: str, line: str) -> str: # pure function\n\n if line is None:\n return 'empty'\n elif line.startswith(line_starts_with):\n return 'start'\n elif line[0] in [' ', '\\t', '#', '\\n']:\n return 'empty'\n else:\n print('End works: ', line)\n return 'end'","def _is_start(self, line):\n if re.match(\".*\\:\\s*\\(groupid\", line):\n return True","def InStr(*args):\n if len(args) == 2:\n text, subtext = args\n return text.find(subtext) + 1\n else:\n start, text, subtext = args\n pos = text[start - 1:].find(subtext)\n if pos == -1:\n return 0\n else:\n return pos + start","def extract(string, start_marker, end_marker):\n start_loc = string.find(start_marker)\n end_loc = string.find(end_marker)\n if start_loc == -1 or end_loc == -1:\n return \"\"\n return string[start_loc+len(start_marker):end_loc]","def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\n # print(\"rages\", tgt_start, tgt_end, src_start, src_end)\n if tgt_end < 0:\n return \n # If `src_align_idx` out of the `src_start` and `src_target`.\n for src_align_idx, tgt_align_idx in alignment:\n # target align point\n # sorce align point out of range\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \n (src_align_idx < src_start or src_align_idx > src_end)): \n return\n phrase_set = set()\n ts = tgt_start # For increment\n while True:\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\n # te = tgt_end \n while True:\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\n src_phrase = \" \".join(src_sent[i] for i in range(src_start,src_end+1))\n tgt_phrase = \" \".join(tgt_sent[i] for i in range(ts,te+1))\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\n te+= 1\n # Add phrase until `te` aligned or out of range\n if te in tgt_aligned or te == tgt_len:\n break\n ts-=1\n # Add phrase until `te` aligned or out of range\n if ts in tgt_aligned or ts < 0:\n break\n \n return phrase_set","def startswith(self, prefix, start=0, end=None):\n return startswith(self, prefix, start, end)","def flyc_nofly_cord_pos_search(po, fwmdlfile, start_pos, func_align, data_align, min_match_accepted):\n fwmdlfile.seek(0, os.SEEK_END)\n fwmdlfile_len = fwmdlfile.tell()\n enfcord = FlycNoFlyCoords()\n match_count = 0\n match_pos = -1\n match_entries = 0\n reached_eof = False\n pos = start_pos\n while (True):\n # Check how many correct zone entries we have\n entry_count = 0\n entry_pos = pos\n while (True):\n fwmdlfile.seek(entry_pos, os.SEEK_SET)\n if fwmdlfile.readinto(enfcord) != sizeof(enfcord):\n reached_eof = True\n break\n # The array ends with int value storing its size\n if (entry_count >= min_match_accepted) and (enfcord.latitude == entry_count):\n break\n if not flyc_nofly_is_proper_cord_entry(po, fwmdlfile, fwmdlfile_len, enfcord, func_align, data_align, pos, entry_pos):\n break\n entry_count += 1\n entry_pos += sizeof(enfcord)\n # Do not allow entry at EOF\n if (reached_eof):\n break\n # If entry is ok, consider it a match\n if entry_count > min_match_accepted:\n if (po.verbose > 1):\n print(\"{}: Matching coords array at 0x{:08x}: {:d} entries\".format(po.mdlfile,pos,entry_count))\n if (entry_count >= match_entries):\n match_pos = pos\n match_entries = entry_count\n match_count += 1\n # Set position to search for next entry\n if entry_count >= min_match_accepted:\n pos += entry_count * sizeof(enfcord)\n else:\n pos += data_align - (pos%data_align)\n if (match_count > 1):\n eprint(\"{}: Warning: multiple ({:d}) matches found for fly coords array with alignment 0x{:02x}\".format(po.mdlfile,match_count,data_align))\n if (match_count < 1):\n return -1, 0\n return match_pos, match_entries","def start_with_start_codon(rna: str):\n return rna.find(START_CODON)","def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode, matchLimit: int) -> List[ghidra.program.model.address.Address]:\n ...","def test_match_must_start_at_the_beginning(self):\n third_letter = \"c\"\n s = \"abcdef\"\n self.assertEqual(__, re.match(third_letter, s))","def _mb_substr(string, start, length):\n return string.decode(_ENCODING)[start: start + length]","def test_single_match_returns_line(self):\n eq_(self.line,line_matches_greps(self.line,[\"foo\"]))","def match_substring(self, str):\n if self.repo_relative_path.find(str) >= 0:\n return True\n\n if self.uuid:\n if (\"uuid://%s%s\" % (self.uuid, self.repo_relative_path)).find(str) >= 0:\n return True\n\n if self.url:\n if (self.url + self.repo_relative_path).find(str) >= 0:\n return True\n\n return False","def find_in_database(mac):\n with open('source/oui.txt', 'r') as start:\n for line in start:\n if line.count(mac) == 1:\n _,_,_,*last = line.split()\n last = ' '.join(last)\n return last","def find_word(self,word):\r\n self.start_pos = []\r\n #check each row\r\n for i in range(0,len(self.wordsearch)):\r\n #check each column\r\n for j in range(0, len(self.wordsearch[i])):\r\n #find all coordinates which have the first letter of the word and store them\r\n if self.wordsearch[i][j] == self.word[0]:\r\n self.start_pos.append([i,j])\r\n \r\n \r\n #print(count)\r\n for pos in self.start_pos:\r\n if self.check_start(self.word, pos):\r\n \r\n return","def starts_with(strn, prefix):\n return strn.startswith(prefix)","def __find_between(self, s, first, last):\n try:\n start = s.index(first) + len(first)\n end = s.index(last, start)\n return s[start:end]\n except ValueError:\n return \"\"","def InStrRev(text, subtext, start=None, compare=None):\n assert compare is None, \"Compare modes not allowed for InStrRev\"\n if start is None:\n start = len(text)\n if subtext == \"\":\n return len(text)\n elif start > len(text):\n return 0\n else:\n return text[:start].rfind(subtext) + 1","def contains(strn, substr):\n try:\n strn.index(substr)\n return True\n except ValueError:\n return False","def _get_line_with_str(lines, string, index):\n relevant_lines = [line for line in lines if string in line]\n if len(relevant_lines) == 0 or (index != -1 and len(relevant_lines) <= index):\n return None\n return relevant_lines[index]","def test_match_can_find_longer_sequences_starting_at_beginning_of_string(self):\n first_three_letters = \"abc\"\n s = \"abcdef\"\n self.assertEqual(__, re.match(first_three_letters, s).group())","def match(self, context, line):\n\t\t\n\t\treturn line.kind == 'code' and line.partitioned[0] in self._both","def find_text_in_file(file_path, start_text, end_text):\r\n\r\n pkg_file=file(file_path,'r') \r\n for row in pkg_file: \r\n pid = find_text_in_string(row, start_text, end_text)\r\n if pid != None:\r\n pkg_file.close()\r\n return pid\r\n\r\n pkg_file.close() \r\n return None","def valid_start(start, lines):\r\n if start.isalpha(): # start word must be alphabetic\r\n if len(start) > 1: # start word must be larger than 1 character\r\n if start in lines: # start word must be in the list of words\r\n return \"0\"\r\n else:\r\n return \"Start word not in list of words....please reenter\"\r\n else:\r\n return \"Start word must contain more than one letter....please reenter\"\r\n else:\r\n return \"Start word must contain only letters....please reenter\"","def overlap(a, b, min_length=3):\n start = 0 # start all the way at the left\n\n while True:\n start = a.find(b[:min_length], start) # look for b's suffix i a\n if start == -1: # no more occurrences to right\n return 0\n # found occurrence; check for full suffix/prefix match\n if b.startswith(a[start:]):\n return len(a) - start\n start += 1 # move just paat previous match","def FindFirstAsciiString(self, start, end=None, min_length=32):\n if not end: end = start + 64\n for slot in range(start, end):\n if not self.reader.IsValidAddress(slot): break\n message = self.reader.ReadAsciiString(slot)\n if len(message) > min_length:\n return (slot, message)\n return (None,None)","def search(self, word):\n now = self.tree\n for i in word:\n if i in now:\n now = now[i]\n else:\n return False\n return True if 'end' in now else False"],"string":"[\n \"def _match_start_get_remaining(self, start, text):\\n if not text.startswith(start):\\n return\\n return text[len(start):]\",\n \"def _get_prev_line_having_substr(substr):\\n last_occ_idx = vim.eval(SEARCH_LAST_CMD.format(substr=substr))\\n if last_occ_idx == 0:\\n return\\n line_content = vim.eval(GET_LINE_CMD.format(line_num=last_occ_idx))\\n line_content = line_content.strip().split()\\n substr_container = line_content[1]\\n substr_name, _ = substr_container.split(\\\"(\\\")\\n return substr_name\",\n \"def get_str_between_s_and_e(start_str, end_str, line):\\n\\tstart = line.find(start_str)\\n\\tif start >= 0:\\n\\t\\tstart = start + len(start_str)\\n\\t\\tend = line.find(end_str, start)\\n\\t\\tif end >= 0:\\n\\t\\t\\treturn line[start:end].strip()\\n\\telse:\\n\\t\\treturn None\",\n \"def line_substring(\\n self, start: ir.FloatingValue, end: ir.FloatingValue\\n ) -> ir.LineStringValue:\\n return ops.GeoLineSubstring(self, start, end).to_expr()\",\n \"def find_start_end(text, start_text, end_text, start=0):\\n # return (s, e) or None\\n s = text.find(start_text, start)\\n if s < 0:\\n return None\\n e = text.find(end_text, s+1)\\n if e < 0:\\n return None\\n e += len(end_text)\\n return s, e\",\n \"def reverse_search(view, what, start=0, end=-1, flags=0):\\n if end == -1:\\n end = view.size()\\n end = find_eol(view, view.line(end).a)\\n\\n last_match = None\\n\\n lo, hi = start, end\\n while True:\\n middle = (lo + hi) / 2\\n line = view.line(middle)\\n middle, eol = find_bol(view, line.a), find_eol(view, line.a)\\n\\n if search_in_range(view, what, middle, hi, flags):\\n lo = middle\\n elif search_in_range(view, what, lo, middle - 1, flags):\\n hi = middle -1\\n\\n # Don't search forever the same line.\\n if last_match and line.contains(last_match):\\n match = find_last_match(view, what, lo, hi, flags=flags)\\n return view.rowcol(match.begin())[0] + 1\\n\\n last_match = sublime.Region(line.begin(), line.end())\",\n \"def find_line(view, start=0, end=-1, target=0):\\r\\n if target < 0 or target > view.size():\\r\\n return -1\\r\\n\\r\\n if end == -1: end = view.size()\\r\\n\\r\\n lo, hi = start, end\\r\\n while lo <= hi:\\r\\n middle = lo + (hi - lo) / 2\\r\\n if get_line_nr(view, middle) < target:\\r\\n lo = getEOL(view, middle) + 1\\r\\n elif get_line_nr(view, middle) > target:\\r\\n hi = getBOL(view, middle) - 1\\r\\n else:\\r\\n return view.full_line(middle)\\r\\n return -1\",\n \"def find_text_between(start,end,haystack):\\n found = re.search(start+'(.*)'+end,haystack,re.IGNORECASE | re.DOTALL)\\n \\n if found:\\n return found.group(1).strip()\\n else:\\n raise Exception(\\\"There is no substring starting with '{}', ending\\\"\\n \\\" with '{}' in content '{}' \\\".format(start,end,haystack))\",\n \"def find_start(self): # -> str | None:\\n ...\",\n \"def find(a, sub, start=0, end=None):\\n return _vec_string(\\n a, int_, 'find', [sub, start] + _clean_args(end))\",\n \"def find_start(lines, start_str, reverse=True):\\n start = -1\\n # Iterate backwards until the last value is found\\n if reverse:\\n for i, line in reversed(list(enumerate(lines))):\\n if start_str == line:\\n return i\\n else:\\n for i, line in enumerate(lines):\\n if start_str == line:\\n return i\\n return start\",\n \"def find(self, sub, start=0, end=None):\\n return find(self, sub, start, end)\",\n \"def rfind(a, sub, start=0, end=None):\\n return _vec_string(\\n a, int_, 'rfind', [sub, start] + _clean_args(end))\",\n \"def findWithStart(astring, achar, start=0):\\n ix = start\\n found = False\\n while ix < len(astring) and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def findWithStart(astring, achar, start=0):\\n ix = start\\n found = False\\n while ix < len(astring) and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def findWithStart(astring, achar, start=0):\\n ix = start\\n found = False\\n while ix < len(astring) and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def rfind(self, sub, start=0, end=None):\\n return rfind(self, sub, start, end)\",\n \"def _visit_str_match(\\n node,\\n string,\\n left_offset,\\n result: ObjectParserResult\\n) -> ParseDelegationReturnMetadata:\\n look_for = node.value[1:-1]\\n does_start_with = string.startswith(look_for)\\n if does_start_with:\\n result.remaining_start_i += len(look_for)\\n return ParseDelegationReturnMetadata(does_start_with, string, left_offset,\\n node, len(look_for))\\n else:\\n return ParseDelegationReturnMetadata(False, string, left_offset, node, None)\",\n \"def partial_word_matches(self):\\n start = '1.0'\\n while True:\\n start = self.text.search(self.term, start, stopindex=tk.END)\\n if not start:\\n break\\n end = start + f'+{self.chars}c'\\n self.text.tag_add('found', start, end)\\n start = end\",\n \"def partial_word_matches(self):\\n start = '1.0'\\n while True:\\n start = self.text.search(self.term, start, stopindex=tk.END)\\n if not start:\\n break\\n end = start + f'+{self.chars}c'\\n self.text.tag_add('found', start, end)\\n start = end\",\n \"def next_word(self, start):\\n end_idx = self.idx + len(start)\\n if self.match(start):\\n return self.line[end_idx] if end_idx < len(self.line) else END\",\n \"def find_substring_offset(\\n context: bytes,\\n substring: bytes,\\n):\\n start = 0\\n while True:\\n start = context.find(substring, start)\\n # use start += 1 to find overlapping matches\\n if start == -1:\\n return\\n yield start\\n start += len(substring)\",\n \"def findWithEnd(astring, achar, start=0, end=None):\\n ix = start\\n if end == None:\\n end = len(astring)\\n\\n found = False\\n while ix < end and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def findWithEnd(astring, achar, start=0, end=None):\\n ix = start\\n if end == None:\\n end = len(astring)\\n\\n found = False\\n while ix < end and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def findWithEnd(astring, achar, start=0, end=None):\\n ix = start\\n if end == None:\\n end = len(astring)\\n\\n found = False\\n while ix < end and not found:\\n if astring[ix] == achar:\\n found = True\\n else:\\n ix = ix + 1\\n if found:\\n return ix\\n else:\\n return -1\",\n \"def find_last_match(view, what, start, end, flags=0):\\n match = view.find(what, start, flags)\\n new_match = None\\n while match:\\n new_match = view.find(what, match.end(), flags)\\n if new_match and new_match.end() <= end:\\n match = new_match\\n else:\\n return match\",\n \"def is_in_log(self, regex, start=0):\\n\\n ex = re.compile(regex)\\n for l in self.logs[start:]:\\n if ex.search(l):\\n logging.debug(\\\"Found '%s' in logs\\\", regex)\\n return l\\n\\n logging.debug(\\\"Did not find '%s' in logs\\\", regex)\\n return None\",\n \"def _find_or_none(string, substring, start):\\n index = string.find(substring, start)\\n return index if index != -1 else None\",\n \"def _start_magic(line):\\n return start(line)\",\n \"def next_section_start_pos(text, start):\\n section_re = re.compile(\\\"^.*\\\\n-+$\\\", re.I|re.MULTILINE) \\n next_section = section_re.search(text, start)\\n return len(text) if next_section is None else next_section.start()\",\n \"def findInLine(self) -> str:\\n raise NotImplementedError\",\n \"def find(self, stripped_line):\\n return self._index.get(stripped_line, ())\",\n \"def find_text_in_string(string, start_text, end_text):\\r\\n index_start = string.rfind(start_text)\\r\\n if not index_start==-1:\\r\\n index_end = string.rfind(end_text)\\r\\n str = string[index_start+len(start_text):index_end]\\r\\n return str\",\n \"def getDataPart( job, data, lineStart ):\\n\\tposOne = data.find( lineStart )\\n\\tif posOne != -1:\\n\\t\\tposOne = posOne + len( lineStart )\\n\\t\\tposTwo = data.find( \\\"\\\\n\\\", posOne )\\n\\t\\tsubstring = data[posOne:posTwo]\\n\\t\\treturn substring\\n\\telse:\\n\\t\\tjob.log(\\\"\\\\tCould not find \\\\\\\"\\\" + lineStart + \\\"\\\\\\\"\\\" )\\n\\t\\treturn None\",\n \"def getDataPart( job, data, lineStart ):\\n\\tposOne = data.find( lineStart )\\n\\tif posOne != -1:\\n\\t\\tposOne = posOne + len( lineStart )\\n\\t\\tposTwo = data.find( \\\"\\\\n\\\", posOne )\\n\\t\\tsubstring = data[posOne:posTwo]\\n\\t\\treturn substring\\n\\telse:\\n\\t\\tjob.log(\\\"\\\\tCould not find \\\\\\\"\\\" + lineStart + \\\"\\\\\\\"\\\" )\\n\\t\\treturn None\",\n \"def match_start_string(list_to_search, substring):\\n # Whitespace is stripped before and after the substring,\\n # but not within (e.g. \\\" New York City \\\" -> \\\"New York City\\\").\\n clean_substring = substring.lstrip().rstrip().lower()\\n items_found = []\\n ([items_found.append(item) for item in list_to_search\\n if clean_substring == item[:len(clean_substring)].lower()])\\n return items_found\",\n \"def try_match(self, i: int, line: str) -> ScannedStringSegment:\\n start = line[i:] # take the unmatched string\\n for regex, token in self.rules:\\n compiled_regex = re.compile(regex) # compile regex\\n match = compiled_regex.match(start) # verify to see if the string matches the regex\\n if match: # if a match is found\\n begin, end = match.span() # take the begin and end index\\n return ScannedStringSegment(token, i, start[:end], end)\\n return ScannedStringSegment(None, None, start, None) # if a match if not found\",\n \"def starts_with(text, substring):\\n assert text.startswith(substring), \\\"%r doesn't start with %r\\\" % (text,\\n substring)\",\n \"def slice_by_pos(val: str, start: SourcePos, end: SourcePos) -> str:\\n if \\\"\\\\n\\\" in val:\\n lines = val.split(\\\"\\\\n\\\")\\n if end.row > start.row:\\n top = lines[start.row][start.col :]\\n filling = lines[start.row + 1 : end.row]\\n bottom = lines[end.row][: end.col]\\n return \\\"\\\\n\\\".join(line for line in chain([top], filling, [bottom]))\\n else:\\n return lines[start.row][start.col : end.col]\\n else:\\n return val[start.col : end.col]\",\n \"def test_line_substring():\\n for _x in range(100):\\n l_str = random_str(50, 100)\\n line = Line(l_str, random_str(10, 20), randint(1, 10000))\\n # Try a single charater\\n c_idx = randint(0, len(l_str)-1)\\n sub_line = line[c_idx]\\n assert sub_line == l_str[c_idx]\\n assert isinstance(sub_line, Line)\\n assert sub_line.file == line.file\\n assert sub_line.number == line.number\\n # Try a range\\n s_idx = randint(0, (len(l_str) // 2) - 1)\\n e_idx = randint(len(l_str) // 2, len(l_str) - 1)\\n sub_line = line[s_idx:e_idx]\\n assert sub_line == l_str[s_idx:e_idx]\\n assert sub_line.file == line.file\\n assert sub_line.number == line.number\",\n \"def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode) -> ghidra.program.model.address.Address:\\n ...\",\n \"def match(line,keyword):\\n line=line.lstrip()\\n length=len(keyword)\\n if line[:length] == keyword:\\n return line[length:]\\n else:\\n return None\",\n \"def match(self, string, substr):\\n hp = self.hash(substr)\\n hh = self.hash(string[0:0+len(substr)])\\n if hh == hp:\\n if string[0:0+len(substr)] == substr:\\n return 0\\n for i in xrange(1, len(string) - len(substr) + 1):\\n hh = hh - ord(string[i-1]) + ord(string[i + len(substr) -1])\\n if hh == hp:\\n if string[i:i+len(substr)] == substr:\\n return i\\n return -1\",\n \"def find_all_iter( source, substring, start=None, end=None, overlap=False ):\\n data = source\\n base = 0\\n if end is not None:\\n data = data[:end]\\n if start is not None:\\n data = data[start:]\\n base = start\\n pointer = 0\\n increment = 1 if overlap else (len( substring ) or 1)\\n while True:\\n pointer = data.find( substring, pointer )\\n if pointer == -1:\\n return\\n yield base+pointer\\n pointer += increment\",\n \"def substring_match(recipe, word):\\n if names_only:\\n line = recipe.name\\n else:\\n line = str(recipe)\\n\\n if not case:\\n word = word.lower()\\n line = line.lower()\\n\\n return line.find(word) != -1\",\n \"def extract_line(line, pos):\\n found = u''\\n depth = 0\\n offset = 0\\n for c in line:\\n if c == '<':\\n depth += 1\\n elif c == '>':\\n depth -= 1\\n if depth == 0:\\n pos -= process_match(found[1:], pos + offset)\\n found = u''\\n\\n if depth > 0:\\n found += c\\n\\n offset += 1\\n return pos + offset\",\n \"def test_match_regexp_including_start():\\r\\n runmatch(lcode)\",\n \"def get_substring(self, start, end):\\n return self.input[start:end]\",\n \"def startswith(a, prefix, start=0, end=None):\\n return _vec_string(\\n a, bool_, 'startswith', [prefix, start] + _clean_args(end))\",\n \"def find_next(lines, find_str, start_index):\\n mode = None\\n if isinstance(find_str, basestring):\\n mode = 'normal'\\n message = find_str\\n elif isinstance(find_str, Invert):\\n mode = 'invert'\\n message = str(find_str)\\n else:\\n raise TypeError(\\\"Unsupported message type\\\")\\n for i in range(start_index, len(lines)):\\n if re.search(message, lines[i]):\\n return mode == 'normal', i, lines[i]\\n elif message in lines[i]:\\n return mode == 'normal', i, lines[i]\\n if mode == 'invert':\\n return True, len(lines), None\\n raise LookupError(\\\"Not found\\\")\",\n \"def between_markers(text: str, begin: str, end: str) -> str:\\n # your code here\\n return text[text.find(begin) + 1:text.find(end)]\",\n \"def whole_word_matches(self):\\n start = '1.0'\\n while True:\\n start = self.text.search(self.term, start, stopindex=tk.END)\\n if not start:\\n break\\n end = start + ' wordend'\\n # whole word includes a space before\\n found = self.text.get(start + '-1c', end)\\n if found == ' ' + self.term:\\n self.text.tag_add('found', start, end)\\n start = end\",\n \"def whole_word_matches(self):\\n start = '1.0'\\n while True:\\n start = self.text.search(self.term, start, stopindex=tk.END)\\n if not start:\\n break\\n end = start + ' wordend'\\n # whole word includes a space before\\n found = self.text.get(start + '-1c', end)\\n if found == ' ' + self.term:\\n self.text.tag_add('found', start, end)\\n start = end\",\n \"def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode, matchLimit: int, alignment: int) -> List[ghidra.program.model.address.Address]:\\n ...\",\n \"def _linesearch(self):\\n pass\",\n \"def test_match_start_check_at_beginning_of_string(self):\\n first_letter = \\\"a\\\"\\n s = \\\"abcdef\\\"\\n self.assertEqual(__, re.search(first_letter, s).group())\",\n \"def get_line(file: str, line: str, logfile: str) -> Union[str, bool]:\\n current_file = read_file_log(file, logfile)\\n m = re_search(rf\\\"{line}\\\", current_file)\\n if m is not None:\\n return m.group(0)\\n return False\",\n \"def find_section(lines, MF=3, MT=3):\\n v = [l[70:75] for l in lines]\\n n = len(v)\\n cmpstr = '%2s%3s' % (MF, MT) # search string\\n i0 = v.index(cmpstr) # first occurrence\\n i1 = n - v[::-1].index(cmpstr) # last occurrence\\n return lines[i0: i1]\",\n \"def find_log_lines_with_content(self, prefixes, needle_substring, required_count, return_first_line):\\n required_count = int(required_count)\\n\\n def check_function():\\n all_data = []\\n for prefix in prefixes:\\n print('Analyzing prefix {}'.format(prefix))\\n all_files = self.get_files_in_bucket(prefix=prefix,\\n limit=self.S3_LISTING_REQUEST_LIMIT)\\n for file in all_files:\\n print('Analyzing file {}'.format(file))\\n content = self.get_file_content_from_bucket(file)\\n for line in content.splitlines():\\n if needle_substring in line:\\n data = json.loads(line)\\n all_data.append(data)\\n if len(all_data) >= required_count and required_count != 0:\\n return all_data\\n\\n if len(all_data) > 0 and required_count == 0:\\n return all_data\\n\\n result = legion_test.utils.wait_until(check_function,\\n self.WAIT_FILE_TIME, self.WAIT_FILE_ITERATIONS)\\n if not result:\\n raise Exception('{} log line(s) with {!r} has not been found'.format(required_count, needle_substring))\\n if return_first_line:\\n return result[0]\\n else:\\n return result\",\n \"def match_segment(var, pattern, input, bindings, start=0):\\n\\n # If there are no words in pattern following var, we can just match var\\n # to the remainder of the input.\\n if not pattern:\\n return match_variable(var, input, bindings)\\n\\n # Get the segment boundary word and look for the first occurrence in\\n # the input starting from index start.\\n word = pattern[0]\\n try:\\n pos = start + input[start:].index(word)\\n except ValueError:\\n # When the boundary word doesn't appear in the input, no match.\\n return False\\n\\n # Match the located substring to the segment variable and recursively\\n # pattern match using the resulting bindings.\\n var_match = match_variable(var, input[:pos], dict(bindings))\\n match = match_pattern(pattern, input[pos:], var_match)\\n\\n # If pattern matching fails with this substring, try a longer one.\\n if not match:\\n return match_segment(var, pattern, input, bindings, start + 1)\\n \\n return match\",\n \"def test_search_must_not_start_at_the_beginning(self):\\n pattern = \\\"cde\\\"\\n s = \\\"abcdefabcdef\\\"\\n self.assertEqual(__, re.search(pattern, s).group())\",\n \"def get_substr(self, y, x1, x2):\\n return self.lines[y][x1 : x2]\",\n \"def subStringMatchExact(target,key,length):\\r\\n index = find(target,key)\\r\\n if index < 0:\\r\\n return ()\\r\\n else:\\r\\n matches = subStringMatchExact(target[index+len(key):len(target)],key,length)\\r\\n index += (length - len(target))\\r\\n matches += (index,)\\r\\n print matches\\r\\n return matches\",\n \"def extract_string(line, idx, result):\\n\\n begin = line.find(resource_string_prefix, idx)\\n if begin == -1:\\n return -1\\n \\n begin = begin + len(resource_string_prefix)\\n end = -1\\n for i in range(begin, len(line)):\\n if not is_valid_char(line[i]):\\n end = i\\n break\\n\\n result.add(line[begin:end])\\n return end\",\n \"def remove_from_start_if_present(target, start):\\n if target and target.startswith(start):\\n return ''.join(target[len(start):])\\n return target\",\n \"def want_line(self, op, first = 0):\\n for ii in range(first, len(self.__content)):\\n match = re.match(op, self.__content[ii], re.IGNORECASE)\\n if match:\\n return (ii, match.group(1))\\n return None\",\n \"def _get_start(self, variant, reference_start, cigar, ignore_softclip=False):\\n indels = get_indel_from_cigar(cigar, ignore_softclip)\\n start = variant.POS - reference_start - 1\\n # for pos, val in indels.iteritems(): # python2\\n for pos, val in indels.items():\\n if pos > start:\\n break\\n if val[0] == 'I':\\n start += val[1]\\n elif val[0] == 'D':\\n start -= val[1]\\n return start\",\n \"def find_segment(p, line, start_vertex=0):\\n EPS = 1e-9\\n for seg in range(start_vertex, len(line)-1):\\n if is_near(p, line[seg]):\\n return seg, 0\\n if line[seg][0] == line[seg+1][0]:\\n if not (p[0]-EPS <= line[seg][0] <= p[0]+EPS):\\n continue\\n px = None\\n else:\\n px = (p[0] - line[seg][0]) / (line[seg+1][0] - line[seg][0])\\n if px is None or (0 <= px <= 1):\\n if line[seg][1] == line[seg+1][1]:\\n if not (p[1]-EPS <= line[seg][1] <= p[1]+EPS):\\n continue\\n py = None\\n else:\\n py = (p[1] - line[seg][1]) / (line[seg+1][1] - line[seg][1])\\n if py is None or (0 <= py <= 1):\\n if py is None or px is None or (px-EPS <= py <= px+EPS):\\n return seg, px or py\\n return None, None\",\n \"def word_at_position(\\n self,\\n position: Position,\\n re_start_word: Pattern = RE_START_WORD,\\n re_end_word: Pattern = RE_END_WORD,\\n ) -> str:\\n lines = self.lines\\n if position.line >= len(lines):\\n return \\\"\\\"\\n\\n pos = position_from_utf16(lines, position)\\n row, col = pos.line, pos.character\\n line = lines[row]\\n # Split word in two\\n start = line[:col]\\n end = line[col:]\\n\\n # Take end of start and start of end to find word\\n # These are guaranteed to match, even if they match the empty string\\n m_start = re_start_word.findall(start)\\n m_end = re_end_word.findall(end)\\n\\n return m_start[0] + m_end[-1]\",\n \"def getMatchingLine(self, line):\\n tokens = map(str.lower, line.text.split()) # easy way to ignore case and whitespace\\n for l in self.lines:\\n if map(str.lower, l.text.split()) == tokens:\\n return l # found a match\\n \\n return None # no matches found\",\n \"def check_that_starter_log_contains(self, substring: str):\\n if self.count_occurances_in_starter_log(substring) > 0:\\n return\\n else:\\n raise Exception(\\n f\\\"Expected to find the following string: {substring}\\\\n in this log file:\\\\n{str(self.log_file)}\\\"\\n )\",\n \"def search_start_end_index_in_sentence(sent, np):\\n\\n nps = [x for x in np.split() if x]\\n if len(nps) == 0:\\n return (-1, -1)\\n elif len(nps) == 1:\\n indices = search_one_token_reducing_suffix(sent, np)\\n if len(indices) > 0:\\n return (indices[0], search_next_whitespace(sent, indices[0]))\\n else:\\n return (-1, -1)\\n else:\\n # search start:\\n start = search_correct_position(sent, nps)\\n end = search_correct_position(sent, nps, True)\\n if end != -1:\\n end = search_next_whitespace(sent, end)\\n return (start,end)\",\n \"def re_search(pattern, text: str, start_indx: int = 0) -> Optional[int]:\\n # \\n match = pattern.search(text, start_indx)\\n if match is not None:\\n indx = match.start()\\n else:\\n indx = None\\n return indx\",\n \"def line_parser(line_starts_with: str, line: str) -> str: # pure function\\n\\n if line is None:\\n return 'empty'\\n elif line.startswith(line_starts_with):\\n return 'start'\\n elif line[0] in [' ', '\\\\t', '#', '\\\\n']:\\n return 'empty'\\n else:\\n print('End works: ', line)\\n return 'end'\",\n \"def _is_start(self, line):\\n if re.match(\\\".*\\\\:\\\\s*\\\\(groupid\\\", line):\\n return True\",\n \"def InStr(*args):\\n if len(args) == 2:\\n text, subtext = args\\n return text.find(subtext) + 1\\n else:\\n start, text, subtext = args\\n pos = text[start - 1:].find(subtext)\\n if pos == -1:\\n return 0\\n else:\\n return pos + start\",\n \"def extract(string, start_marker, end_marker):\\n start_loc = string.find(start_marker)\\n end_loc = string.find(end_marker)\\n if start_loc == -1 or end_loc == -1:\\n return \\\"\\\"\\n return string[start_loc+len(start_marker):end_loc]\",\n \"def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\\n # print(\\\"rages\\\", tgt_start, tgt_end, src_start, src_end)\\n if tgt_end < 0:\\n return \\n # If `src_align_idx` out of the `src_start` and `src_target`.\\n for src_align_idx, tgt_align_idx in alignment:\\n # target align point\\n # sorce align point out of range\\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \\n (src_align_idx < src_start or src_align_idx > src_end)): \\n return\\n phrase_set = set()\\n ts = tgt_start # For increment\\n while True:\\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\\n # te = tgt_end \\n while True:\\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\\n src_phrase = \\\" \\\".join(src_sent[i] for i in range(src_start,src_end+1))\\n tgt_phrase = \\\" \\\".join(tgt_sent[i] for i in range(ts,te+1))\\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\\n te+= 1\\n # Add phrase until `te` aligned or out of range\\n if te in tgt_aligned or te == tgt_len:\\n break\\n ts-=1\\n # Add phrase until `te` aligned or out of range\\n if ts in tgt_aligned or ts < 0:\\n break\\n \\n return phrase_set\",\n \"def startswith(self, prefix, start=0, end=None):\\n return startswith(self, prefix, start, end)\",\n \"def flyc_nofly_cord_pos_search(po, fwmdlfile, start_pos, func_align, data_align, min_match_accepted):\\n fwmdlfile.seek(0, os.SEEK_END)\\n fwmdlfile_len = fwmdlfile.tell()\\n enfcord = FlycNoFlyCoords()\\n match_count = 0\\n match_pos = -1\\n match_entries = 0\\n reached_eof = False\\n pos = start_pos\\n while (True):\\n # Check how many correct zone entries we have\\n entry_count = 0\\n entry_pos = pos\\n while (True):\\n fwmdlfile.seek(entry_pos, os.SEEK_SET)\\n if fwmdlfile.readinto(enfcord) != sizeof(enfcord):\\n reached_eof = True\\n break\\n # The array ends with int value storing its size\\n if (entry_count >= min_match_accepted) and (enfcord.latitude == entry_count):\\n break\\n if not flyc_nofly_is_proper_cord_entry(po, fwmdlfile, fwmdlfile_len, enfcord, func_align, data_align, pos, entry_pos):\\n break\\n entry_count += 1\\n entry_pos += sizeof(enfcord)\\n # Do not allow entry at EOF\\n if (reached_eof):\\n break\\n # If entry is ok, consider it a match\\n if entry_count > min_match_accepted:\\n if (po.verbose > 1):\\n print(\\\"{}: Matching coords array at 0x{:08x}: {:d} entries\\\".format(po.mdlfile,pos,entry_count))\\n if (entry_count >= match_entries):\\n match_pos = pos\\n match_entries = entry_count\\n match_count += 1\\n # Set position to search for next entry\\n if entry_count >= min_match_accepted:\\n pos += entry_count * sizeof(enfcord)\\n else:\\n pos += data_align - (pos%data_align)\\n if (match_count > 1):\\n eprint(\\\"{}: Warning: multiple ({:d}) matches found for fly coords array with alignment 0x{:02x}\\\".format(po.mdlfile,match_count,data_align))\\n if (match_count < 1):\\n return -1, 0\\n return match_pos, match_entries\",\n \"def start_with_start_codon(rna: str):\\n return rna.find(START_CODON)\",\n \"def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode, matchLimit: int) -> List[ghidra.program.model.address.Address]:\\n ...\",\n \"def test_match_must_start_at_the_beginning(self):\\n third_letter = \\\"c\\\"\\n s = \\\"abcdef\\\"\\n self.assertEqual(__, re.match(third_letter, s))\",\n \"def _mb_substr(string, start, length):\\n return string.decode(_ENCODING)[start: start + length]\",\n \"def test_single_match_returns_line(self):\\n eq_(self.line,line_matches_greps(self.line,[\\\"foo\\\"]))\",\n \"def match_substring(self, str):\\n if self.repo_relative_path.find(str) >= 0:\\n return True\\n\\n if self.uuid:\\n if (\\\"uuid://%s%s\\\" % (self.uuid, self.repo_relative_path)).find(str) >= 0:\\n return True\\n\\n if self.url:\\n if (self.url + self.repo_relative_path).find(str) >= 0:\\n return True\\n\\n return False\",\n \"def find_in_database(mac):\\n with open('source/oui.txt', 'r') as start:\\n for line in start:\\n if line.count(mac) == 1:\\n _,_,_,*last = line.split()\\n last = ' '.join(last)\\n return last\",\n \"def find_word(self,word):\\r\\n self.start_pos = []\\r\\n #check each row\\r\\n for i in range(0,len(self.wordsearch)):\\r\\n #check each column\\r\\n for j in range(0, len(self.wordsearch[i])):\\r\\n #find all coordinates which have the first letter of the word and store them\\r\\n if self.wordsearch[i][j] == self.word[0]:\\r\\n self.start_pos.append([i,j])\\r\\n \\r\\n \\r\\n #print(count)\\r\\n for pos in self.start_pos:\\r\\n if self.check_start(self.word, pos):\\r\\n \\r\\n return\",\n \"def starts_with(strn, prefix):\\n return strn.startswith(prefix)\",\n \"def __find_between(self, s, first, last):\\n try:\\n start = s.index(first) + len(first)\\n end = s.index(last, start)\\n return s[start:end]\\n except ValueError:\\n return \\\"\\\"\",\n \"def InStrRev(text, subtext, start=None, compare=None):\\n assert compare is None, \\\"Compare modes not allowed for InStrRev\\\"\\n if start is None:\\n start = len(text)\\n if subtext == \\\"\\\":\\n return len(text)\\n elif start > len(text):\\n return 0\\n else:\\n return text[:start].rfind(subtext) + 1\",\n \"def contains(strn, substr):\\n try:\\n strn.index(substr)\\n return True\\n except ValueError:\\n return False\",\n \"def _get_line_with_str(lines, string, index):\\n relevant_lines = [line for line in lines if string in line]\\n if len(relevant_lines) == 0 or (index != -1 and len(relevant_lines) <= index):\\n return None\\n return relevant_lines[index]\",\n \"def test_match_can_find_longer_sequences_starting_at_beginning_of_string(self):\\n first_three_letters = \\\"abc\\\"\\n s = \\\"abcdef\\\"\\n self.assertEqual(__, re.match(first_three_letters, s).group())\",\n \"def match(self, context, line):\\n\\t\\t\\n\\t\\treturn line.kind == 'code' and line.partitioned[0] in self._both\",\n \"def find_text_in_file(file_path, start_text, end_text):\\r\\n\\r\\n pkg_file=file(file_path,'r') \\r\\n for row in pkg_file: \\r\\n pid = find_text_in_string(row, start_text, end_text)\\r\\n if pid != None:\\r\\n pkg_file.close()\\r\\n return pid\\r\\n\\r\\n pkg_file.close() \\r\\n return None\",\n \"def valid_start(start, lines):\\r\\n if start.isalpha(): # start word must be alphabetic\\r\\n if len(start) > 1: # start word must be larger than 1 character\\r\\n if start in lines: # start word must be in the list of words\\r\\n return \\\"0\\\"\\r\\n else:\\r\\n return \\\"Start word not in list of words....please reenter\\\"\\r\\n else:\\r\\n return \\\"Start word must contain more than one letter....please reenter\\\"\\r\\n else:\\r\\n return \\\"Start word must contain only letters....please reenter\\\"\",\n \"def overlap(a, b, min_length=3):\\n start = 0 # start all the way at the left\\n\\n while True:\\n start = a.find(b[:min_length], start) # look for b's suffix i a\\n if start == -1: # no more occurrences to right\\n return 0\\n # found occurrence; check for full suffix/prefix match\\n if b.startswith(a[start:]):\\n return len(a) - start\\n start += 1 # move just paat previous match\",\n \"def FindFirstAsciiString(self, start, end=None, min_length=32):\\n if not end: end = start + 64\\n for slot in range(start, end):\\n if not self.reader.IsValidAddress(slot): break\\n message = self.reader.ReadAsciiString(slot)\\n if len(message) > min_length:\\n return (slot, message)\\n return (None,None)\",\n \"def search(self, word):\\n now = self.tree\\n for i in word:\\n if i in now:\\n now = now[i]\\n else:\\n return False\\n return True if 'end' in now else False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6829045","0.6382696","0.6371454","0.6307071","0.62964875","0.60427123","0.60387963","0.6038122","0.60191697","0.59272146","0.59037364","0.5864446","0.5817685","0.58130187","0.58130187","0.58130187","0.5806736","0.5797243","0.5758163","0.5758163","0.57465506","0.5733957","0.5701574","0.5701574","0.5701574","0.5686932","0.56831867","0.56691283","0.5651975","0.5650282","0.56474656","0.5572139","0.5565383","0.55598295","0.55598295","0.55563897","0.55495864","0.5486532","0.54848176","0.5461953","0.5456078","0.5451042","0.54328364","0.5406237","0.54059416","0.54033846","0.5403219","0.53963774","0.53706944","0.536555","0.53630555","0.535534","0.535534","0.53429437","0.5335566","0.5328202","0.5326451","0.5315423","0.53145504","0.5307003","0.5303897","0.5302704","0.52933717","0.5290126","0.5268503","0.5267654","0.5264804","0.5251354","0.5249586","0.5248654","0.5241543","0.52369946","0.52327925","0.52322793","0.5231605","0.5231232","0.5227873","0.52077824","0.5206333","0.51887","0.51758367","0.51425004","0.5140046","0.5139781","0.51247734","0.51204544","0.5116756","0.5115937","0.5112298","0.51119757","0.5111772","0.5109432","0.5109283","0.5107054","0.51058054","0.51040095","0.50946045","0.5084141","0.50811535","0.5061304"],"string":"[\n \"0.6829045\",\n \"0.6382696\",\n \"0.6371454\",\n \"0.6307071\",\n \"0.62964875\",\n \"0.60427123\",\n \"0.60387963\",\n \"0.6038122\",\n \"0.60191697\",\n \"0.59272146\",\n \"0.59037364\",\n \"0.5864446\",\n \"0.5817685\",\n \"0.58130187\",\n \"0.58130187\",\n \"0.58130187\",\n \"0.5806736\",\n \"0.5797243\",\n \"0.5758163\",\n \"0.5758163\",\n \"0.57465506\",\n \"0.5733957\",\n \"0.5701574\",\n \"0.5701574\",\n \"0.5701574\",\n \"0.5686932\",\n \"0.56831867\",\n \"0.56691283\",\n \"0.5651975\",\n \"0.5650282\",\n \"0.56474656\",\n \"0.5572139\",\n \"0.5565383\",\n \"0.55598295\",\n \"0.55598295\",\n \"0.55563897\",\n \"0.55495864\",\n \"0.5486532\",\n \"0.54848176\",\n \"0.5461953\",\n \"0.5456078\",\n \"0.5451042\",\n \"0.54328364\",\n \"0.5406237\",\n \"0.54059416\",\n \"0.54033846\",\n \"0.5403219\",\n \"0.53963774\",\n \"0.53706944\",\n \"0.536555\",\n \"0.53630555\",\n \"0.535534\",\n \"0.535534\",\n \"0.53429437\",\n \"0.5335566\",\n \"0.5328202\",\n \"0.5326451\",\n \"0.5315423\",\n \"0.53145504\",\n \"0.5307003\",\n \"0.5303897\",\n \"0.5302704\",\n \"0.52933717\",\n \"0.5290126\",\n \"0.5268503\",\n \"0.5267654\",\n \"0.5264804\",\n \"0.5251354\",\n \"0.5249586\",\n \"0.5248654\",\n \"0.5241543\",\n \"0.52369946\",\n \"0.52327925\",\n \"0.52322793\",\n \"0.5231605\",\n \"0.5231232\",\n \"0.5227873\",\n \"0.52077824\",\n \"0.5206333\",\n \"0.51887\",\n \"0.51758367\",\n \"0.51425004\",\n \"0.5140046\",\n \"0.5139781\",\n \"0.51247734\",\n \"0.51204544\",\n \"0.5116756\",\n \"0.5115937\",\n \"0.5112298\",\n \"0.51119757\",\n \"0.5111772\",\n \"0.5109432\",\n \"0.5109283\",\n \"0.5107054\",\n \"0.51058054\",\n \"0.51040095\",\n \"0.50946045\",\n \"0.5084141\",\n \"0.50811535\",\n \"0.5061304\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73265594"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83797,"cells":{"query":{"kind":"string","value":"Extract the lines between the line containing ``begin`` and the line containing ``end`` (excluding both lines) in ``parent``."},"document":{"kind":"string","value":"def extract_lines(parent: str, begin: Predicate, end: Predicate) -> str:\n lines = parent.splitlines()\n\n begin_line = find_line(lines, begin)\n end_line = find_line(lines, end, begin_line+1)\n\n new_lines = lines[begin_line+1:end_line]\n\n return \"\\n\".join(new_lines)"},"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 section(fle, begin, end):\n with open(fle) as f:\n for line in f:\n # found start of section so start iterating from next line\n if line.startswith(begin):\n for line in f: \n # found end so end function\n if line.startswith(end):\n return\n # yield every line in the section\n yield line.rstrip()","def inject_lines(parent: str, begin: Predicate, end: Predicate, generated: str) -> str:\n lines = parent.splitlines()\n\n begin_line = find_line(lines, begin)\n end_line = find_line(lines, end, begin_line+1)\n\n new_lines = lines[:begin_line+1] + generated.splitlines() + lines[end_line:]\n\n return \"\\n\".join(new_lines)","def get_subgraph_between_nodes(self, start, end):\n nodes = set()\n nodes.add(start)\n\n to_visit = set()\n to_visit.add(start)\n\n while len(to_visit) > 0:\n current_visit = copy.copy(to_visit)\n for tv in current_visit:\n to_visit.remove(tv)\n if tv is not end:\n for s in self.successors(tv):\n to_visit.add(s)\n nodes.add(s)\n\n nodes.add(end)\n\n return self.subgraph(nodes)","def subseq(self, start_offset=0, end_offset=None):\n def subseq_iter(start_offset, end_offset):\n for point in self._elements:\n #Skip until start\n if point[offset_attr] < start_offset:\n continue\n\n #Yield points start_offset <= point < end_offset\n if end_offset is None or point[offset_attr] < end_offset:\n yield point\n else:\n raise StopIteration\n return _OSeq(subseq_iter(start_offset, end_offset))","def lines(self):\n return lines(self.startEA, self.endEA)","def find_lines_by_parent_line_id(self, parent_line_id):\n for line in self._data_lines:\n if six.text_type(line.get(\"parent_line_id\")) == six.text_type(parent_line_id):\n yield line","def subseq(self, start_offset=0, end_offset=None):\n from .core import DURATION_64\n\n def subseq_iter(start_offset, end_offset):\n cur_offset = 0\n for point in self._elements:\n try:\n cur_offset += point[DURATION_64]\n except KeyError:\n raise ValueError(\"HSeq.subseq requires all points to have a %s attribute\" % DURATION_64)\n #Skip until start\n if cur_offset < start_offset:\n continue\n\n #Yield points start_offset <= point < end_offset\n if end_offset is None or cur_offset < end_offset:\n yield point\n else:\n raise StopIteration\n return HSeq(subseq_iter(start_offset, end_offset))","def trace_path(parent_map: dict, start, end) -> List[str]:\n # start with end node\n path = [end]\n # find until we reach start node\n while path[-1] != start:\n # append parent of current node\n path.append(parent_map[path[-1]])\n path.reverse()\n return path","def get_slice(the_tree,begin_element,end_element):\n all_elements=[e for e in the_tree.iter()]\n begin_index=all_elements.index(begin_element)\n end_index=all_elements.index(end_element)+1\n uniq_elements=[]\n for element in all_elements[begin_index:end_index]:\n tempset=set(uniq_elements)\n ancestors=set([e for e in element.iterancestors()])\n if len (tempset & ancestors) == 0:\n uniq_elements.append(element)\n return uniq_elements","def sub_poset(self, start, end):\n if start < 1 or start > end or end > self.size() + 1:\n raise ValueError(\"Invalid starting or ending value, accepted: 1 <= start <= end <= size+1\")\n if start == end:\n return TamariIntervalPoset(0, [])\n relations = [(i - start + 1, j - start + 1) for (i, j) in self.increasing_cover_relations() if i >= start and j < end]\n relations.extend([(j - start + 1, i - start + 1) for (j, i) in self.decreasing_cover_relations() if i >= start and j < end])\n return TamariIntervalPoset(end - start, relations)","def between_markers(text: str, begin: str, end: str): # -> str\n begin_pos = text.find(begin)\n end_pos = text.find(end)\n \n if (begin_pos != -1 and end_pos != -1 and begin_pos < end_pos):\n return text[begin_pos + len(begin) : end_pos]\n elif (begin_pos == -1 and end_pos != -1):\n return text[0: end_pos]\n elif (begin_pos != -1 and end_pos == -1):\n return text[begin_pos + len(begin) :]\n elif(begin_pos == -1 and end_pos == -1):\n return text\n elif (begin_pos != -1 and end_pos != -1 and begin_pos > end_pos):\n return ''","def raw_segments_with_ancestors(\n self,\n ) -> List[Tuple[\"RawSegment\", List[PathStep]]]:\n buffer = []\n code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code)\n for idx, seg in enumerate(self.segments):\n # If it's a raw, yield it with this segment as the parent\n new_step = [PathStep(self, idx, len(self.segments), code_idxs)]\n if seg.is_type(\"raw\"):\n buffer.append((cast(\"RawSegment\", seg), new_step))\n # If it's not, recurse - prepending self to the ancestor stack\n else:\n buffer.extend(\n [\n (raw_seg, new_step + stack)\n for raw_seg, stack in seg.raw_segments_with_ancestors\n ]\n )\n return buffer","def _trim_start_end(data: pd.DataFrame, start: int, end: int):\n start_idx = data.loc[:, \"start_locus\"].searchsorted(start)\n end_idx = data.loc[:, \"start_locus\"].searchsorted(end, side=\"right\")\n return data.iloc[start_idx:end_idx, :]","def slice_region( self, ini, end ):\n return self[(self['frame'] >= ini) & (self['frame'] <= end)]","def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\n # print(\"rages\", tgt_start, tgt_end, src_start, src_end)\n if tgt_end < 0:\n return \n # If `src_align_idx` out of the `src_start` and `src_target`.\n for src_align_idx, tgt_align_idx in alignment:\n # target align point\n # sorce align point out of range\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \n (src_align_idx < src_start or src_align_idx > src_end)): \n return\n phrase_set = set()\n ts = tgt_start # For increment\n while True:\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\n # te = tgt_end \n while True:\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\n src_phrase = \" \".join(src_sent[i] for i in range(src_start,src_end+1))\n tgt_phrase = \" \".join(tgt_sent[i] for i in range(ts,te+1))\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\n te+= 1\n # Add phrase until `te` aligned or out of range\n if te in tgt_aligned or te == tgt_len:\n break\n ts-=1\n # Add phrase until `te` aligned or out of range\n if ts in tgt_aligned or ts < 0:\n break\n \n return phrase_set","def find_path(self, start_vertex, end_vertex):\n if not self.contains(start_vertex) or not self.contains(end_vertex):\n return None\n path = []\n visited = set()\n self._find_path(start_vertex, end_vertex, path, visited)\n if path[-1] != end_vertex:\n return []\n return path","def _get_all_parents(parent, wit_path, stop_at='None'):\n\n for _, parents in _get_all_parents_and_sons(parent, wit_path, stop_at):\n yield parents","def between_markers(text: str, begin: str, end: str) -> str:\n # your code here\n return text[text.find(begin) + 1:text.find(end)]","def getAncestors():","def _find_all_paths(self, start_vertex: str, end_vertex: str, path=[]):\n path = path + [start_vertex]\n if start_vertex == end_vertex:\n return [path]\n\n paths = []\n for vertex in self.graph[start_vertex]:\n if vertex not in path:\n extended_paths = self._find_all_paths(vertex,\n end_vertex,\n path)\n for p in extended_paths:\n paths.append(p)\n return paths","def entity(entity):\n for start, end in entity.spans:\n yield start, end-start","def line_range(self) -> Tuple[int, int]:\n if self._line_range is None:\n node_extent = self.node.extent\n comment_extent = self.node.comment_extent\n if comment_extent.start.file is None:\n comment_extent = node_extent\n\n self._line_range = (\n min(node_extent.start.line, comment_extent.start.line),\n max(node_extent.end.line, comment_extent.end.line),\n )\n\n return self._line_range","def line_end(self):\n curr = self\n while curr.next:\n curr = curr.next\n return curr","def find_lines(self):\n return []","def subgraph_within_dates(self, start_date, end_date):\n new = Graph.graph_with_graph(self)\n for u, v in self.nx_graph.edges_iter():\n edge = new.nx_graph.edge[u][v]\n done = False\n while len(edge['timestamps']) and not done:\n top = bottom = False\n if edge['timestamps'][0] >= end_date:\n edge['timestamps'].pop(0)\n else:\n top = True\n\n if len(edge['timestamps']) and edge['timestamps'][-1] < start_date:\n edge['timestamps'].pop(-1)\n else:\n bottom = True\n\n done = top and bottom\n\n if not len(edge['timestamps']):\n new.nx_graph.remove_edge(u, v)\n\n # min = 100000000\n # max = -100000000\n # for u,v, data in new.nx_graph.edges_iter(data=True):\n # for time in data['timestamps']:\n # if time < min:\n # min = time\n # elif time > max:\n # max = time\n\n new.max_date = end_date\n new.min_date = start_date\n return new","def get_end_vertices(self):\n # Note that concatenating two vertices needs to make a\n # vertices for the frame.\n extesion_fraction = self.extesion_fraction\n\n corx = extesion_fraction*2.\n cory = 1./(1. - corx)\n x1, y1, w, h = 0, 0, 1, 1\n x2, y2 = x1 + w, y1 + h\n dw, dh = w*extesion_fraction, h*extesion_fraction*cory\n\n if self.extend in [\"min\", \"both\"]:\n bottom = [(x1, y1),\n (x1+w/2., y1-dh),\n (x2, y1)]\n else:\n bottom = [(x1, y1),\n (x2, y1)]\n\n if self.extend in [\"max\", \"both\"]:\n top = [(x2, y2),\n (x1+w/2., y2+dh),\n (x1, y2)]\n else:\n top = [(x2, y2),\n (x1, y2)]\n\n if self.orientation == \"horizontal\":\n bottom = [(y,x) for (x,y) in bottom]\n top = [(y,x) for (x,y) in top]\n\n return bottom, top","def get_pruned_tree_path (self, index_1_beg, index_1_end,\n index_2_beg, index_2_end, in_between_children = False ):\n tempo_2_beg = index_2_beg\n tempo_2_end = index_2_end\n if index_1_beg >= index_2_end:\n index_2_beg = index_1_beg\n index_2_end = index_1_end\n index_1_beg = tempo_2_beg\n index_1_end = tempo_2_end\n \n if index_1_end - index_1_beg > 1:\n lca_1_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_1_end )\n else:\n lca_1_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_1_end )[:-1]\n\n if index_2_end - index_2_beg > 1:\n lca_2_index = self.tree.treeposition_spanning_leaves( index_2_beg, index_2_end )\n else:\n lca_2_index = self.tree.treeposition_spanning_leaves( index_2_beg, index_2_end )[:-1]\n \n if index_2_end - index_1_beg > 1:\n lca_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\n else:\n lca_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]\n \n lca = self.tree[lca_index]\n new_tree = ParentedTree('(' + lca.node + ')')\n\n #Point to the root\n # Branch of the first entity\n current_pointer = new_tree\n tempo_lca = lca\n# try:\n for i in xrange(len(lca_index), len(lca_1_index)):\n tempo_lca = tempo_lca[lca_1_index[i]]\n if not (type(tempo_lca) == str or type(tempo_lca) == unicode):\n current_pointer.insert(0, ParentedTree('('+tempo_lca.node +')'))\n current_pointer = current_pointer[0]\n\n current_pointer = new_tree\n #Insert the first level of children of lca\n if len(lca_index) < len(lca_1_index) and len(lca_index) < len(lca_2_index):\n if in_between_children:\n for i in xrange(lca_1_index[len(lca_index)] + 1, lca_2_index[len(lca_index)]):\n current_pointer.insert(i, ParentedTree('('+lca[i].node +')'))\n\n #Point to the root\n # Branch of the second entity\n current_pointer = new_tree\n tempo_lca = lca\n first_time = True\n for i in xrange(len(lca_index), len(lca_2_index)):\n tempo_lca = tempo_lca[lca_2_index[i]]\n if not (type(tempo_lca) == str or type(tempo_lca) == unicode):\n if first_time:\n if not in_between_children:\n children_index_of_2nd_branch = 1\n else:\n \"\"\"\n Don't really need to check lca_2_index[len(lca_index)]\n 'cause if it come to this point, the length constraint\n is already satisfied\n However, it's necessary to check lca_1_index[len(lca_index)]\n \"\"\"\n if len(lca_index) < len(lca_1_index):\n children_index_of_2nd_branch = lca_2_index[len(lca_index)]\\\n - lca_1_index[len(lca_index)]\n else:\n \"\"\"\n No left child, no in_between_children\n \"\"\"\n children_index_of_2nd_branch = 0\n current_pointer.insert(children_index_of_2nd_branch,\n ParentedTree('('+tempo_lca.node +')'))\n current_pointer = current_pointer[children_index_of_2nd_branch]\n first_time = False\n else:\n current_pointer.insert(0, ParentedTree('('+tempo_lca.node +')'))\n current_pointer = current_pointer[0]\n return new_tree","def startAndEnd(self):\n upperRow = 0\n upperCol = 0\n lowerRow = 0\n lowerCol = 0\n if self.selectionMode == kSelectionNone:\n upperRow = self.penRow\n upperCol = self.penCol\n lowerRow = self.penRow\n lowerCol = self.penCol\n elif self.selectionMode == kSelectionAll:\n upperRow = 0\n upperCol = 0\n lowerRow = self.parser.rowCount() - 1\n lowerCol = self.parser.rowWidth(-1)\n elif self.selectionMode == kSelectionBlock:\n upperRow = min(self.markerRow, self.penRow)\n upperCol = min(self.markerCol, self.penCol)\n lowerRow = max(self.markerRow, self.penRow)\n lowerCol = max(self.markerCol, self.penCol)\n elif (self.selectionMode == kSelectionCharacter or\n self.selectionMode == kSelectionLine or\n self.selectionMode == kSelectionWord):\n upperRow = self.markerRow\n upperCol = self.markerCol\n lowerRow = self.penRow\n lowerCol = self.penCol\n if upperRow == lowerRow and upperCol > lowerCol:\n upperCol, lowerCol = lowerCol, upperCol\n elif upperRow > lowerRow:\n upperRow, lowerRow = lowerRow, upperRow\n upperCol, lowerCol = lowerCol, upperCol\n #app.log.detail('start and end', upperRow, upperCol, lowerRow, lowerCol)\n return (upperRow, upperCol, lowerRow, lowerCol)","def build_path(start, end):\n a = hierarchy.index(start)\n b = hierarchy.index(end)\n if a == b:\n return []\n elif a < b:\n return hierarchy[a + 1 : b + 1]\n return list(reversed(hierarchy[b:a]))","def slice_by_pos(val: str, start: SourcePos, end: SourcePos) -> str:\n if \"\\n\" in val:\n lines = val.split(\"\\n\")\n if end.row > start.row:\n top = lines[start.row][start.col :]\n filling = lines[start.row + 1 : end.row]\n bottom = lines[end.row][: end.col]\n return \"\\n\".join(line for line in chain([top], filling, [bottom]))\n else:\n return lines[start.row][start.col : end.col]\n else:\n return val[start.col : end.col]","def find_bound_paragraph(c: Cmdr) -> tuple[str, list[str], str]:\n head, ins, tail = c.frame.body.getInsertLines()\n head_lines = g.splitLines(head)\n tail_lines = g.splitLines(tail)\n result = []\n insert_lines = g.splitLines(ins)\n para_lines = insert_lines + tail_lines\n # If the present line doesn't start a paragraph,\n # scan backward, adding trailing lines of head to ins.\n if insert_lines and not startsParagraph(insert_lines[0]):\n n = 0 # number of moved lines.\n for s in reversed(head_lines):\n if ends_paragraph(s) or single_line_paragraph(s):\n break\n elif startsParagraph(s):\n n += 1\n break\n else:\n n += 1\n if n > 0:\n para_lines = head_lines[-n :] + para_lines\n head_lines = head_lines[: -n]\n ended, started = False, False\n for i, s in enumerate(para_lines):\n if started:\n if ends_paragraph(s) or startsParagraph(s):\n ended = True\n break\n else:\n result.append(s)\n elif s.strip():\n result.append(s)\n started = True\n if ends_paragraph(s) or single_line_paragraph(s):\n i += 1\n ended = True\n break\n else:\n head_lines.append(s)\n if started:\n head = ''.join(head_lines)\n tail_lines = para_lines[i:] if ended else []\n tail = ''.join(tail_lines)\n return head, result, tail # string, list, string\n return None, None, None","def get_start_end_points(path, transect): \n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\",\")\n start_point = transect_array[2 * transect, :]\n end_point = transect_array[2 * transect + 1, :]\n \n # force start points to be west of end points\n if start_point[0] > end_point[0]:\n previous_start_point = start_point\n start_point = end_point\n end_point = previous_start_point\n return start_point, end_point","def linerange_fix(node):\n # deal with multiline strings lineno behavior (Python issue #16806)\n lines = linerange(node)\n if hasattr(node, 'sibling') and hasattr(node.sibling, 'lineno'):\n start = min(lines)\n delta = node.sibling.lineno - start\n if delta > 1:\n return list(range(start, node.sibling.lineno))\n return lines","def find_all_iter( source, substring, start=None, end=None, overlap=False ):\n data = source\n base = 0\n if end is not None:\n data = data[:end]\n if start is not None:\n data = data[start:]\n base = start\n pointer = 0\n increment = 1 if overlap else (len( substring ) or 1)\n while True:\n pointer = data.find( substring, pointer )\n if pointer == -1:\n return\n yield base+pointer\n pointer += increment","def find_text_between(start,end,haystack):\n found = re.search(start+'(.*)'+end,haystack,re.IGNORECASE | re.DOTALL)\n \n if found:\n return found.group(1).strip()\n else:\n raise Exception(\"There is no substring starting with '{}', ending\"\n \" with '{}' in content '{}' \".format(start,end,haystack))","def enumerate_stripped(self, start_at=0):\n idx = start_at\n if start_at:\n lines = self._stripped_lines[start_at:]\n else:\n lines = self._stripped_lines\n for line in lines:\n # if line:\n yield idx, line\n idx += 1","def find_all_paths(parents_to_children, start, end, path=[]):\r\n path = path + [start]\r\n if start == end:\r\n return [path]\r\n if start not in parents_to_children.keys():\r\n return []\r\n paths = []\r\n for node in parents_to_children[start]:\r\n if node not in path:\r\n newpaths = find_all_paths(parents_to_children, node, end, path)\r\n for newpath in newpaths:\r\n paths.append(tuple(newpath))\r\n return paths","def get_file_lines(self, filepath, start, stop):\n\n if self._file_lines is None:\n with open(os.path.join(self.repo_path, filepath)) as f:\n self._file_lines = f.readlines()\n\n if stop is None:\n lines = self._file_lines[start - 1:]\n else:\n lines = self._file_lines[start - 1:stop]\n for i, line in enumerate(lines):\n lines[i] = [start + i, True, line.rstrip()]\n while lines and self.is_empty_line(lines[-1][-1]):\n lines.pop()\n\n if not lines:\n return []\n\n stop = lines[0][0]\n start = max(1, stop - self.surround_by)\n prefix_lines = []\n for i, line in enumerate(self._file_lines[start - 1:stop - 1], start=start):\n prefix_lines.append([i, False, line.rstrip()])\n\n start = lines[-1][0] + 1\n stop = start + self.surround_by\n suffix_lines = []\n for i, line in enumerate(self._file_lines[start - 1:stop - 1], start=start):\n suffix_lines.append([i, False, line.rstrip()])\n\n return prefix_lines + lines + suffix_lines","def span(self, raw):\n if raw.lower() in ('*', '-', 'all'):\n raw = ':'\n results = self.spanpattern.search(raw)\n if not results:\n raise IndexError\n if not results.group('separator'):\n return [self[self._to_index(results.group('start'))]]\n start = self._to_index(results.group('start')) or 0 # Ensure start is not None\n end = self._to_index(results.group('end'))\n reverse = False\n if end is not None:\n if end < start:\n (start, end) = (end, start)\n reverse = True\n end += 1\n result = self[start:end]\n if reverse:\n result.reverse()\n return result","def find_all_path(self, start_vertex, end_vertex, path=[]):\n\n graph = self.__graph_dict\n path = path + [start_vertex]\n if start_vertex == end_vertex:\n return [path]\n\n if start_vertex not in graph:\n return []\n\n paths = []\n for vertex in graph[start_vertex]:\n if vertex not in path:\n extended_paths = self.find_all_path(vertex, end_vertex,path)\n for p in extended_paths:\n paths.append(p)\n return paths","def test_start_equals_end_is_fine(self):\n with stdin_as_string(self.ifile):\n self.assertLines(\n [\"-i\", \"0-0\"],\n [\n \"id\",\n \"0\",\n ],\n )\n\n with stdin_as_string(self.ifile):\n self.assertLines(\n [\"-i\", \"3-3\"],\n [\n \"id\",\n \"3\",\n ],\n )","def segments(self):\n return (self._subset((i,i+1)) for i in range(len(self)-1))","def iter_fragments(self, frag_id_begin = None, frag_id_end = None):\n return iter_fragments(iter(self.fragment_list), frag_id_begin, frag_id_end)","def find_start_end(text, start_text, end_text, start=0):\n # return (s, e) or None\n s = text.find(start_text, start)\n if s < 0:\n return None\n e = text.find(end_text, s+1)\n if e < 0:\n return None\n e += len(end_text)\n return s, e","def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:\n # The current line might still wait for trailing comments. At DEDENT time\n # there won't be any (they would be prefixes on the preceding NEWLINE).\n # Emit the line then.\n yield from self.line()\n\n # While DEDENT has no value, its prefix may contain standalone comments\n # that belong to the current indentation level. Get 'em.\n yield from self.visit_default(node)\n\n # Finally, emit the dedent.\n yield from self.line(-1)","def extract(lines):\n prefix = 'Note: including file: '\n for line in lines:\n if line.startswith(prefix):\n line = os.path.normpath(line[len(prefix):])\n # Determine the depth by counting the number of spaces starting the line.\n depth = len(line) - len(line.lstrip()) + 1\n yield (depth, line.strip())","def _get_multiline(self):\n lines = []\n line = self._get_line()\n lines.append(line)\n if line[3:4] == \"-\":\n code = line[:3]\n while 1:\n nextline = self._get_line()\n lines.append(nextline)\n if nextline[:3] == code and nextline[3:4] != \"-\":\n break\n return lines","def find_all_path(self, start, end, path=[]):\n path = path+[start]\n if start == end:\n return path\n paths = []\n for node in self.graph[start]:\n if node not in path:\n newpaths = self.find_path(node, end, path)\n paths.append(newpaths)\n return paths","def between(current, end):\n text_list = []\n\n while current and current != end:\n if isinstance(current, bs4.NavigableString):\n text = current.strip()\n if text:\n texts = text.split(\"\\n\")\n for text in texts:\n content_str = ''\n for c in text:\n if is_chinese(c):\n content_str += c\n text_list.append(content_str)\n\n current = current.next_element\n return text_list","def getEnds(self) -> List[int]:\n ...","def traversal(self, start: str, end: str=None) -> None:\n if not isinstance(start, str):\n raise TypeError('Traversal takes in one param which must be a string')\n if not start:\n raise ValueError('Please enter a string')\n if end is None:\n curr = self._base\n for idx, char in enumerate(start, start=1):\n if idx == len(start) and char in curr:\n yield start\n curr = curr[char]\n for char in curr:\n if not char == '$':\n yield char\n for each_char in self.traversal(start, curr[char]):\n yield each_char\n elif char in curr:\n curr = curr[char]\n else:\n raise ValueError('String not in trie')\n else:\n for char in end:\n if not char == '$':\n yield char\n for each_char in self.traversal(start, end[char]):\n yield each_char","def getRecordListUnzipped(self, region=None, chrom=None,\n start=None, end=None):\n lst = []\n if region is None:\n #lst.append(prev_last_rec)\n for rec in self.reader:\n lst.append(rec)\n self.prev_last_rec = lst[-1]\n return lst\n #return lst, lst[-1]\n\n if (self.prev_last_rec is not None and\n region.containsRecord(self.prev_last_rec) == 'in'):\n lst.append(self.prev_last_rec)\n elif (self.prev_last_rec is not None and\n region.containsRecord(self.prev_last_rec) == 'after'):\n return []\n rec = next(self.reader,None)\n if rec is None:\n self.prev_last_rec = None\n return lst\n #return lst,None\n place = region.containsRecord(rec)\n while rec is not None and place != 'after':\n if place == 'in':\n lst.append(rec)\n rec = next(self.reader,None)\n if rec is None:\n break\n place = region.containsRecord(rec)\n self.prev_last_rec = rec\n return lst\n #return lst, prev_last_rec","def find(self, sub, start=0, end=None):\n return find(self, sub, start, end)","def _parents(self, prefix):\n if self.inherit:\n suffix = self.inherit.name\n value = self.tracconfig.get(\n self.section, '%s.%s' % (prefix, suffix), default=None)\n if value:\n return self._parents_to_list(value)\n return None","def parent_addresses(self):\n address = self.address\n if not address.startswith(\"/\"):\n address = \"/\" + address\n if address.endswith(\"/\"):\n address = address[:-1]\n\n if address:\n return address.split(\"/\")[:-1]\n\n return []","def find_isolated_endpoints(lines):\n \n isolated_endpoints = []\n count = len(lines)\n print(\"Finding isolated end points 2/3\")\n pb = pbar.ProgressBar(count)\n for i, line in enumerate(lines):\n pb += 1\n other_lines = lines[:i] + lines[i+1:]\n for q in [0,-1]:\n endpoint = Point(line.coords[q])\n if any(endpoint.touches(another_line) \n for another_line in other_lines):\n continue\n else:\n isolated_endpoints.append(endpoint)\n del pb\n return isolated_endpoints","def Segments():\n for n in range(ida_segment.get_segm_qty()):\n seg = ida_segment.getnseg(n)\n if seg:\n yield seg.start_ea","def getAllParents(start):\n parent = start.getParent()\n\n while parent:\n node = parent\n yield parent\n parent = node.getParent()","def find_all_paths(graph, start, end, path=[]):\n path = path + [start]\n if start == end:\n return [path]\n paths = []\n for node in graph[start]:\n newpaths = find_all_paths(graph, node, end, path)\n paths += newpaths\n return paths","def get_start_end_addresses(lineId):\n\n return Db().get_first_and_last_address(lineId)","def span(self):\r\n return self._start, self._end","def interpolate_to_parent(self, start, end, linspace_count):\n \n v = end - start\n length = norm(v)\n v = v / length # Make v a unit vector\n l = np.linspace(0, length, linspace_count) \n\n return np.array([start[i] + v[i] * l for i in range(3)])","def find_start_and_end(arr):\n start = None\n end = None\n for i, line in enumerate(arr):\n for j, node in enumerate(line):\n if node.symbol is 'A':\n start = node\n if node.symbol is 'B':\n end = node\n return start, end","def segment(self):\n start = self.alignment.matching_function_startpoint(self.idx)\n end = self.alignment.matching_function_endpoint(self.idx)\n return [start, end]","def traverse_graph_start_end_extra_node(graph):\n\n # get tree with starting node tags\n\n def traverse(graph, node):\n\n children = [int(c) for c in graph[node][\"children\"]]\n tagged_children = []\n for child in children:\n ellipsed_parents = [int(p) for p in graph[child][\"ellipsed_parents\"]]\n # if the child is explicit\n if node not in ellipsed_parents:\n if graph[child][\"terminal\"] == \"yes\":\n tagged_children.append(ParentedTree(graph[child][\"tag\"], [graph[child][\"text\"]]))\n else:\n tagged_children.append(traverse(graph, child))\n # if the child is ellipsed\n else:\n ellipsis_tag = get_ellipsis_tag_from_graph(graph, child)\n tagged_children.append(ParentedTree(ellipsis_tag, []))\n \n tree = ParentedTree(graph[node][\"tag\"], tagged_children)\n\n return tree\n\n tree = traverse(graph, 0)\n\n # get ending node tags\n positions = [pos for pos in tree.treepositions() if pos not in tree.treepositions(\"leaves\")]\n end_tags = []\n ellipsis_id = 0 # assign an id to each ellipsis start and end nodes\n for pos_i, pos in enumerate(positions):\n if tree[pos].label().startswith(\"start\"):\n ellipsis_tag = tree[pos].label().split(\"start\")[-1]\n tree[pos].set_label(\"start\" + str(ellipsis_id))\n end_location = get_ellipsis_location(tree, ellipsis_tag)\n end_tag = \"end\" + str(ellipsis_id)\n end_tags.append((end_location, end_tag))\n ellipsis_id += 1\n\n # insert ending node tags\n for index, st in enumerate(tree.subtrees()):\n for end_location, end_tag in end_tags:\n if st.treeposition() == end_location:\n st.insert(index, ParentedTree(end_tag, []))\n\n positions = [pos for pos in tree.treepositions() if pos not in tree.treepositions(\"leaves\")]\n rev_positions = [pos for pos in reversed(positions)]\n for pos_i, pos in enumerate(rev_positions):\n # append start tag to the previous node\n if tree[pos].label().startswith(\"start\"):\n prev_pos_i = pos_i + 1\n prev_pos = rev_positions[prev_pos_i]\n tree[prev_pos].set_label(tree[prev_pos].label() + tree[pos].label())\n del tree[pos]\n # append end tag to the parent of the current node\n elif tree[pos].label().startswith(\"end\"):\n parent_pos = tree[pos].parent().treeposition()\n tree[parent_pos].set_label(tree[parent_pos].label() + tree[pos].label())\n del tree[pos] \n\n # wrap each constituent that has end or start tags with extra nodes\n\n def add_extra_nodes(tree):\n children = []\n for subtree in tree:\n if type(subtree) == str:\n children.append(subtree)\n else:\n splits = re.split(\"(start|end)\", subtree.label())\n const_tag = splits[0]\n ellipsis_tag = \"\".join(splits[1:]) \n if len(ellipsis_tag) > 0:\n children.append(Tree(subtree.label(), [Tree(const_tag, [sst for sst in subtree])]))\n else:\n children.append(add_extra_nodes(subtree))\n\n return Tree(tree.label(), children)\n\n tree = add_extra_nodes(tree)\n\n return tree","def get_descendant_ids(cur, node):\n sql = \"\"\"\n SELECT\n node\n FROM\n ancestors\n WHERE\n ancestor=%s;\n \"\"\"\n cur.execute(sql, (str(node), ))\n for result in cur:\n yield str(result['node'])","def get(self, *args):\n return _libsbml.ListOfLineSegments_get(self, *args)","def parsed_span(self, start, end, include_boundaries=False):\n start_sent, start_tok = start\n end_sent, end_tok = end\n\n if start_sent == end_sent:\n span = self.conll[start_sent][start_tok:end_tok]\n\n else:\n\n span = self.conll[start_sent][start_tok:]\n\n if include_boundaries:\n span.append([-1, 'EOS'])\n\n for sent in range(start_sent + 1, end_sent):\n span.extend(self.conll[sent])\n\n if include_boundaries:\n span.append([-1, 'EOS'])\n\n span.extend(self.conll[end_sent][:end_tok])\n\n return span","def _split_code_lines(ast_nodes, text):\n if not ast_nodes:\n yield ([], text)\n return\n assert text.startpos <= ast_nodes[0].startpos\n assert ast_nodes[-1].startpos < text.endpos\n if text.startpos != ast_nodes[0].startpos:\n # Starting noncode lines.\n yield ([], text[text.startpos:ast_nodes[0].startpos])\n end_sentinel = _DummyAst_Node()\n end_sentinel.startpos = text.endpos\n for node, next_node in zip(ast_nodes, ast_nodes[1:] + [end_sentinel]):\n startpos = node.startpos\n next_startpos = next_node.startpos\n assert startpos < next_startpos\n # We have the start position of this node. Figure out the end\n # position, excluding noncode lines (standalone comments and blank\n # lines).\n if hasattr(node, 'endpos'):\n # We have an endpos for the node because this was a multi-line\n # string. Start with the node endpos.\n endpos = node.endpos\n assert startpos < endpos <= next_startpos\n # enpos points to the character *after* the ending quote, so we\n # know that this is never at the beginning of the line.\n assert endpos.colno != 1\n # Advance past whitespace an inline comment, if any. Do NOT\n # advance past other code that could be on the same line, nor past\n # blank lines and comments on subsequent lines.\n line = text[endpos : min(text.endpos, FilePos(endpos.lineno+1,1))]\n if _is_comment_or_blank(line):\n endpos = FilePos(endpos.lineno+1, 1)\n else:\n endpos = next_startpos\n assert endpos <= text.endpos\n # We don't have an endpos yet; what we do have is the next node's\n # startpos (or the position at the end of the text). Start there\n # and work backward.\n if endpos.colno != 1:\n if endpos == text.endpos:\n # There could be a comment on the last line and no\n # trailing newline.\n # TODO: do this in a more principled way.\n if _is_comment_or_blank(text[endpos.lineno]):\n assert startpos.lineno < endpos.lineno\n if not text[endpos.lineno-1].endswith(\"\\\\\"):\n endpos = FilePos(endpos.lineno,1)\n else:\n # We're not at end of file, yet the next node starts in\n # the middle of the line. This should only happen with if\n # we're not looking at a comment. [The first character in\n # the line could still be \"#\" if we're inside a multiline\n # string that's the last child of the parent node.\n # Therefore we don't assert 'not\n # _is_comment_or_blank(...)'.]\n pass\n if endpos.colno == 1:\n while (endpos.lineno-1 > startpos.lineno and\n _is_comment_or_blank(text[endpos.lineno-1]) and\n (not text[endpos.lineno-2].endswith(\"\\\\\") or\n _is_comment_or_blank(text[endpos.lineno-2]))):\n endpos = FilePos(endpos.lineno-1, 1)\n assert startpos < endpos <= next_startpos\n yield ([node], text[startpos:endpos])\n if endpos != next_startpos:\n yield ([], text[endpos:next_startpos])","def intervals_between(self, start: dt.datetime, end: dt.datetime) -> List[Interval]:\n relevant_intervals: List[Interval] = []\n\n for interval in self.intervals:\n if start <= interval.start_time < end:\n relevant_intervals.append(interval)\n\n return relevant_intervals","def outer(self):\n if self.parent is not None:\n self.parent.lines += self.lines\n # print (f\"{self.name} -> {self.parent.name}\")\n return self.parent","def sub_get_lines(treeiter):\n while treeiter != None:\n tup = self.store[treeiter]\n if criteria(tup):\n lines.append({\n 'jid': tup[0],\n 'country': tup[3],\n 'ip': tup[4]})\n if self.store.iter_has_child(treeiter):\n childiter = self.store.iter_children(treeiter)\n sub_get_lines(childiter)\n treeiter = self.store.iter_next(treeiter)","def findPath(g, start, end, path=[]):\n path = path + [start]\n if start == end:\n return path\n if not start in g:\n return None\n for node in g[start]:\n if node not in path:\n newpath = findPath(g, node, end, path)\n if newpath: return newpath\n return None","def _get_start_end(self):\n with open(self._file_properties['file_name'], 'r') as in_file:\n self._file_properties['line_count'] = 0\n for (i, line) in enumerate(in_file):\n # Check for \"start data\" string\n if line[0:5] == '$$SOE':\n self._file_properties['start_ind'] = i\n\n # Check for \"end data\" string\n if line[0:5] == '$$EOE':\n self._file_properties['stop_ind'] = i\n\n # Count total number of lines\n self._file_properties['line_count'] += 1","def test_intersect_line_in_no_point(start, end):\n circle = ConstructionCircle((0, 0), 1.0)\n assert len(circle.intersect_line(ConstructionLine(start, end))) == 0","async def get_sub_block_in_range(\n self,\n start: int,\n stop: int,\n ) -> Dict[bytes32, SubBlockRecord]:\n\n formatted_str = (\n f\"SELECT header_hash,sub_block from sub_block_records WHERE sub_height >= {start} and sub_height <= {stop}\"\n )\n\n cursor = await self.db.execute(formatted_str)\n rows = await cursor.fetchall()\n await cursor.close()\n ret: Dict[bytes32, SubBlockRecord] = {}\n for row in rows:\n header_hash = bytes.fromhex(row[0])\n ret[header_hash] = SubBlockRecord.from_bytes(row[1])\n\n return ret","def path(self):\r\n node, p = self, []\r\n while node:\r\n p.append(node)\r\n node = node.parent\r\n yield from reversed(p)","def parentsUntil(self,selector):\n nList = self.htmlDom.find(selector)\n parentsList = []\n tmpList = []\n selectedNodesList = []\n for node in self.nodeList:\n if not node.ancestorList:\n node.generateAncestorList()\n tmpList = node.ancestorList\n for selectedNode in nList.nodeList:\n try:\n index = tmpList.index( selectedNode )\n selectedNodeList = tmpList[:index]\n parentsList += self.getUniqueNodes( parentsList, selectedNodeList )\n break\n except ValueError:\n pass\n else:\n parentsList += self.getUniqueNodes( parentsList, tmpList )\n parentsList = sorted( parentsList, key = lambda x: x.pos )\n return HtmlNodeList( parentsList, self.htmlDom, self.nodeList, self )","def FindAllPaths(graph, start, end, path=[]):\n path = path + [start]\n if start == end:\n return [path]\n if start not in graph:\n return None\n paths = []\n for node in graph[start]:\n if node not in path:\n newpaths = find_all_paths(graph, node, end, path)\n for newpath in newpaths:\n paths.append(newpath)\n return paths","def find_path(self, start_vertex, end_vertex, path=[]):\n\n graph = self.__graph_dict\n path = path + [start_vertex]\n if start_vertex == end_vertex:\n return path\n\n if start_vertex not in graph:\n return None\n\n for vertex in graph[start_vertex]:\n if vertex not in path:\n extended_path = self.find_path(vertex, end_vertex,path)\n if extended_path:\n return extended_path\n return None","def get_parents(self, node):\n pass","def feed(self, inline, endchar=None):\n # preserve the original line\n # for error messages\n if endchar is None:\n self.origline = inline\n inline = inline.lstrip()\n #\n outlist = []\n comma_needed = False\n found_comma = False\n while inline:\n # NOTE: this sort of operation would be quicker\n # with lists - but then can't use regexes\n thischar = inline[0]\n if thischar == '#':\n # reached a comment\n # end of the line...\n break\n #\n if thischar == endchar:\n return outlist, inline[1:]\n #\n if comma_needed:\n if thischar == ',':\n inline = inline[1:].lstrip()\n comma_needed = False\n found_comma = True\n continue\n raise BadLineError('Line is badly built :\\n%s' % self.origline)\n #\n try:\n # the character that marks the end of the list\n listend = self.liststart[thischar]\n except KeyError:\n pass\n else:\n if not self.recursive and endchar is not None:\n raise BadLineError('Line is badly built :\\n%s' % self.origline)\n newlist, inline = self.feed(inline[1:], endchar=listend)\n outlist.append(newlist)\n inline = inline.lstrip()\n comma_needed = True\n continue\n #\n if thischar in self.quotes:\n # this might raise an error\n # FIXME: trap the error and raise a more appropriate one ?\n element, inline = unquote(inline, fullquote=False, \n retain=self.retain)\n inline = inline.lstrip()\n outlist.append(element)\n comma_needed = True\n continue\n #\n # must be an unquoted element\n mat = unquoted.match(inline)\n if mat is not None:\n # FIXME: if the regex was better we wouldn't need an rstrip\n element = mat.group(1).rstrip()\n # group 2 will be ``None`` if we reach the end of the line\n inline = mat.group(2) or ''\n outlist.append(element)\n comma_needed = True\n continue\n # or it's a badly built line\n raise BadLineError('Line is badly built :\\n%s' % self.origline)\n #\n # if we've been called recursively\n # we shouldn't have got this far\n if endchar is not None:\n raise BadLineError('Line is badly built :\\n%s' % self.origline)\n #\n if not found_comma:\n # if we didn't find a comma\n # the value could be a nested list\n if outlist:\n outlist = outlist[0]\n else:\n outlist = ''\n if self.force_list and not isinstance(outlist, list):\n if outlist:\n outlist = [outlist]\n else:\n outlist = []\n if not self.comment:\n if inline:\n raise CommentError('Comment not allowed :\\n%s' % self.origline)\n return outlist\n return outlist, inline","def getCoveringRanges( self, left_ranges, right_ranges, parent_ranges ):\n \n child_ranges = map( lambda x: (x[0], x[1], 0), left_ranges)\n child_ranges += map( lambda x: (x[0], x[1], 1), right_ranges)\n \n child_ranges.sort()\n parent_ranges.sort()\n \n new_left_ranges = []\n new_right_ranges = []\n \n parent_index = 0\n last_to = 0\n \n parent_left, parent_right = parent_ranges[parent_index]\n\n self.debug( \"child_ranges=%s\" % str(child_ranges) )\n self.debug( \"parent_ranges=%s\" % str(parent_ranges))\n \n last_left, last_right, last_is_right = child_ranges[0]\n \n for this_left, this_right, this_is_right in child_ranges[1:]:\n \n ## look at previous segment last_left to last_right:\n ## find matching parent_index:\n old_parent_index = parent_index\n while (min(parent_right, last_right) - max(parent_left, last_left)) < 0:\n parent_index += 1\n if parent_index == len(parent_ranges): break\n parent_left, parent_right = parent_ranges[parent_index]\n \n ## skip fragments that do not overlap\n if parent_index == len(parent_ranges):\n parent_index = old_parent_index\n last_left, last_right, last_is_right = this_left, this_right, this_is_right\n continue\n \n ## firstly: make segment covering\n new_left = min(parent_left, last_left)\n new_right = min(max(parent_right, last_right), this_left)\n \n if last_is_right:\n new_right_ranges.append((new_left, new_right))\n else:\n new_left_ranges.append((new_left, new_right))\n \n ## reduce parent on left side\n parent_left=max(new_right, parent_left)\n \n last_left, last_right, last_is_right = this_left, this_right, this_is_right\n \n ## process last segment\n while (min(parent_right, last_right) - max(parent_left, last_left)) < 0:\n parent_index += 1\n if parent_index >= len(parent_ranges): break \n parent_left, parent_right = parent_ranges[parent_index]\n \n new_left = min(parent_left, last_left)\n new_right = max(parent_right, last_right)\n \n if last_is_right:\n new_right_ranges.append((new_left, new_right))\n else:\n new_left_ranges.append((new_left, new_right))\n \n self.debug( \"old left ranges=%s\" % str(left_ranges))\n self.debug( \"new left ranges=%s\" % str(new_left_ranges))\n self.debug( \"old right ranges=%s\" % str(right_ranges))\n self.debug( \"new right ranges=%s\" % str(new_right_ranges))\n \n return new_left_ranges, new_right_ranges","def relations_from(self, start_node):","def get_ancestor_ids(cur, node):\n # TODO: add sort parameter\n sql = \"\"\"\n SELECT\n ancestor\n FROM\n ancestors\n WHERE\n node=%s;\n \"\"\"\n cur.execute(sql, (str(node), ))\n for result in cur:\n yield str(result['ancestor'])","def getLines(self):\n f = open(self.__father.getpath() + self.__father.getidFile() + \".TRN\", \"r\")\n lines = f.readlines()\n subUnitLines = []\n\n if self.__speakerId == \"A\":\n for line in lines:\n if self.__speakerId == line.split(\"-\")[-2]:\n subUnitLines.append(line)\n elif self.__speakerId == \"B\":\n for line in reversed(lines):\n if self.__speakerId == line.split(\"-\")[-2]:\n subUnitLines.append(line)\n\n f.close()\n return subUnitLines","def mid(start_row, start_peg, end_row, end_peg):\n if start_row + 2 == end_row:\n mid_row = start_row + 1\n elif start_row == end_row + 2:\n mid_row = start_row - 1\n elif start_row == end_row:\n mid_row = start_row\n\n if start_peg + 2 == end_peg:\n mid_peg = start_peg + 1\n elif start_peg == end_peg + 2:\n mid_peg = start_peg - 1\n elif start_peg == end_peg:\n mid_peg = start_peg\n\n return (mid_row, mid_peg)","def test_intersect_line_in_one_point(start, end):\n circle = ConstructionCircle((0, 0), 1.0)\n assert len(circle.intersect_line(ConstructionLine(start, end))) == 1","def get_with_ancestors(\n self,\n ipfs_client: ipfsapi.Client = None) -> Iterator[\"VersionTreeNode\"]:\n yield self\n parent_hash = self.parent_hash\n while parent_hash is not None:\n parent_node = self.get_node_by_hash(\n parent_hash,\n (ipfs_client or self.ipfs_client))\n parent_hash = parent_node.parent_hash\n yield parent_node","def extends(self):\n p = re.compile(r\"^{%\\s+(extends\\s*(?P<parent>.*))\\s+%}\")\n e = p.match(self.source)\n # extends detact must be done at the begining of parsing.\n # return None if there is no extends tag.\n if not e:\n return None\n self.cur += len(e.group())\n return e.group(\"parent\")","def line(self, indent: int = 0) -> Iterator[Line]:\n if not self.current_line:\n self.current_line.depth += indent\n return # Line is empty, don't emit. Creating a new one unnecessary.\n\n if (\n Preview.improved_async_statements_handling in self.mode\n and len(self.current_line.leaves) == 1\n and is_async_stmt_or_funcdef(self.current_line.leaves[0])\n ):\n # Special case for async def/for/with statements. `visit_async_stmt`\n # adds an `ASYNC` leaf then visits the child def/for/with statement\n # nodes. Line yields from those nodes shouldn't treat the former\n # `ASYNC` leaf as a complete line.\n return\n\n complete_line = self.current_line\n self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)\n yield complete_line","def _ancestors(self) -> Iterator['Node']:\n yield self\n if self.parent:\n yield from self.parent._ancestors()","def get_text_lines(instText):\n\n # Find out which part this is\n part = instText.part\n # Get the necessary parameters: lng, ext, dir\n sLng = part.corpus.get_lng_display()\n sDir = part.dir\n sName = instText.fileName\n sFormat = instText.get_format_display()\n # Now try to get the information\n oBack = get_crpp_text(sLng, sDir, sFormat, sName)\n # Prepare what we return\n if oBack == None or oBack['status'] == 'error':\n return None\n else:\n return oBack","def linerange(node):\n strip = {\"body\": None, \"orelse\": None,\n \"handlers\": None, \"finalbody\": None}\n for key in strip.keys():\n if hasattr(node, key):\n strip[key] = getattr(node, key)\n setattr(node, key, [])\n\n lines_min = 9999999999\n lines_max = -1\n for n in ast.walk(node):\n if hasattr(n, 'lineno'):\n lines_min = min(lines_min, n.lineno)\n lines_max = max(lines_max, n.lineno)\n\n for key in strip.keys():\n if strip[key] is not None:\n setattr(node, key, strip[key])\n\n if lines_max > -1:\n return list(range(lines_min, lines_max + 1))\n return [0, 1]","def iter_fragments(self):\n if self.segment is None:\n return iter(list())\n return self.segment.iter_fragments()","def iter_fragments(self):\n if self.segment is None:\n return iter(list())\n return self.segment.iter_fragments()","def segments(self):\n L = len(self.vertices)\n return itertools.chain((self._subset((i,i+1)) for i in range(len(self)-1)),\n (self._subset((L-1,0)),))","def parents( self, selector = None ): \n tmpList = []\n for node in self.nodeList:\n if not node.ancestorList:\n node.generateAncestorList()\n tmpList += self.getUniqueNodes( tmpList, node.ancestorList )\n if selector:\n return HtmlNodeList( tmpList, self.htmlDom, self.nodeList, self ).filter( selector )\n else:\n tmpList = sorted( tmpList, key = lambda x: x.pos ) \n return HtmlNodeList( tmpList, self.htmlDom, self.nodeList, self)","def splitlines(self, keepends=None):\n return splitlines(self, keepends)","def find_path(self, start, end, path=[]):\n path = path+[start]\n if start == end:\n return path\n for node in self.graph[start]:\n if node not in path:\n newpath = self.find_path(node, end, path)\n if newpath:\n return newpath\n return None"],"string":"[\n \"def section(fle, begin, end):\\n with open(fle) as f:\\n for line in f:\\n # found start of section so start iterating from next line\\n if line.startswith(begin):\\n for line in f: \\n # found end so end function\\n if line.startswith(end):\\n return\\n # yield every line in the section\\n yield line.rstrip()\",\n \"def inject_lines(parent: str, begin: Predicate, end: Predicate, generated: str) -> str:\\n lines = parent.splitlines()\\n\\n begin_line = find_line(lines, begin)\\n end_line = find_line(lines, end, begin_line+1)\\n\\n new_lines = lines[:begin_line+1] + generated.splitlines() + lines[end_line:]\\n\\n return \\\"\\\\n\\\".join(new_lines)\",\n \"def get_subgraph_between_nodes(self, start, end):\\n nodes = set()\\n nodes.add(start)\\n\\n to_visit = set()\\n to_visit.add(start)\\n\\n while len(to_visit) > 0:\\n current_visit = copy.copy(to_visit)\\n for tv in current_visit:\\n to_visit.remove(tv)\\n if tv is not end:\\n for s in self.successors(tv):\\n to_visit.add(s)\\n nodes.add(s)\\n\\n nodes.add(end)\\n\\n return self.subgraph(nodes)\",\n \"def subseq(self, start_offset=0, end_offset=None):\\n def subseq_iter(start_offset, end_offset):\\n for point in self._elements:\\n #Skip until start\\n if point[offset_attr] < start_offset:\\n continue\\n\\n #Yield points start_offset <= point < end_offset\\n if end_offset is None or point[offset_attr] < end_offset:\\n yield point\\n else:\\n raise StopIteration\\n return _OSeq(subseq_iter(start_offset, end_offset))\",\n \"def lines(self):\\n return lines(self.startEA, self.endEA)\",\n \"def find_lines_by_parent_line_id(self, parent_line_id):\\n for line in self._data_lines:\\n if six.text_type(line.get(\\\"parent_line_id\\\")) == six.text_type(parent_line_id):\\n yield line\",\n \"def subseq(self, start_offset=0, end_offset=None):\\n from .core import DURATION_64\\n\\n def subseq_iter(start_offset, end_offset):\\n cur_offset = 0\\n for point in self._elements:\\n try:\\n cur_offset += point[DURATION_64]\\n except KeyError:\\n raise ValueError(\\\"HSeq.subseq requires all points to have a %s attribute\\\" % DURATION_64)\\n #Skip until start\\n if cur_offset < start_offset:\\n continue\\n\\n #Yield points start_offset <= point < end_offset\\n if end_offset is None or cur_offset < end_offset:\\n yield point\\n else:\\n raise StopIteration\\n return HSeq(subseq_iter(start_offset, end_offset))\",\n \"def trace_path(parent_map: dict, start, end) -> List[str]:\\n # start with end node\\n path = [end]\\n # find until we reach start node\\n while path[-1] != start:\\n # append parent of current node\\n path.append(parent_map[path[-1]])\\n path.reverse()\\n return path\",\n \"def get_slice(the_tree,begin_element,end_element):\\n all_elements=[e for e in the_tree.iter()]\\n begin_index=all_elements.index(begin_element)\\n end_index=all_elements.index(end_element)+1\\n uniq_elements=[]\\n for element in all_elements[begin_index:end_index]:\\n tempset=set(uniq_elements)\\n ancestors=set([e for e in element.iterancestors()])\\n if len (tempset & ancestors) == 0:\\n uniq_elements.append(element)\\n return uniq_elements\",\n \"def sub_poset(self, start, end):\\n if start < 1 or start > end or end > self.size() + 1:\\n raise ValueError(\\\"Invalid starting or ending value, accepted: 1 <= start <= end <= size+1\\\")\\n if start == end:\\n return TamariIntervalPoset(0, [])\\n relations = [(i - start + 1, j - start + 1) for (i, j) in self.increasing_cover_relations() if i >= start and j < end]\\n relations.extend([(j - start + 1, i - start + 1) for (j, i) in self.decreasing_cover_relations() if i >= start and j < end])\\n return TamariIntervalPoset(end - start, relations)\",\n \"def between_markers(text: str, begin: str, end: str): # -> str\\n begin_pos = text.find(begin)\\n end_pos = text.find(end)\\n \\n if (begin_pos != -1 and end_pos != -1 and begin_pos < end_pos):\\n return text[begin_pos + len(begin) : end_pos]\\n elif (begin_pos == -1 and end_pos != -1):\\n return text[0: end_pos]\\n elif (begin_pos != -1 and end_pos == -1):\\n return text[begin_pos + len(begin) :]\\n elif(begin_pos == -1 and end_pos == -1):\\n return text\\n elif (begin_pos != -1 and end_pos != -1 and begin_pos > end_pos):\\n return ''\",\n \"def raw_segments_with_ancestors(\\n self,\\n ) -> List[Tuple[\\\"RawSegment\\\", List[PathStep]]]:\\n buffer = []\\n code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code)\\n for idx, seg in enumerate(self.segments):\\n # If it's a raw, yield it with this segment as the parent\\n new_step = [PathStep(self, idx, len(self.segments), code_idxs)]\\n if seg.is_type(\\\"raw\\\"):\\n buffer.append((cast(\\\"RawSegment\\\", seg), new_step))\\n # If it's not, recurse - prepending self to the ancestor stack\\n else:\\n buffer.extend(\\n [\\n (raw_seg, new_step + stack)\\n for raw_seg, stack in seg.raw_segments_with_ancestors\\n ]\\n )\\n return buffer\",\n \"def _trim_start_end(data: pd.DataFrame, start: int, end: int):\\n start_idx = data.loc[:, \\\"start_locus\\\"].searchsorted(start)\\n end_idx = data.loc[:, \\\"start_locus\\\"].searchsorted(end, side=\\\"right\\\")\\n return data.iloc[start_idx:end_idx, :]\",\n \"def slice_region( self, ini, end ):\\n return self[(self['frame'] >= ini) & (self['frame'] <= end)]\",\n \"def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\\n # print(\\\"rages\\\", tgt_start, tgt_end, src_start, src_end)\\n if tgt_end < 0:\\n return \\n # If `src_align_idx` out of the `src_start` and `src_target`.\\n for src_align_idx, tgt_align_idx in alignment:\\n # target align point\\n # sorce align point out of range\\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \\n (src_align_idx < src_start or src_align_idx > src_end)): \\n return\\n phrase_set = set()\\n ts = tgt_start # For increment\\n while True:\\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\\n # te = tgt_end \\n while True:\\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\\n src_phrase = \\\" \\\".join(src_sent[i] for i in range(src_start,src_end+1))\\n tgt_phrase = \\\" \\\".join(tgt_sent[i] for i in range(ts,te+1))\\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\\n te+= 1\\n # Add phrase until `te` aligned or out of range\\n if te in tgt_aligned or te == tgt_len:\\n break\\n ts-=1\\n # Add phrase until `te` aligned or out of range\\n if ts in tgt_aligned or ts < 0:\\n break\\n \\n return phrase_set\",\n \"def find_path(self, start_vertex, end_vertex):\\n if not self.contains(start_vertex) or not self.contains(end_vertex):\\n return None\\n path = []\\n visited = set()\\n self._find_path(start_vertex, end_vertex, path, visited)\\n if path[-1] != end_vertex:\\n return []\\n return path\",\n \"def _get_all_parents(parent, wit_path, stop_at='None'):\\n\\n for _, parents in _get_all_parents_and_sons(parent, wit_path, stop_at):\\n yield parents\",\n \"def between_markers(text: str, begin: str, end: str) -> str:\\n # your code here\\n return text[text.find(begin) + 1:text.find(end)]\",\n \"def getAncestors():\",\n \"def _find_all_paths(self, start_vertex: str, end_vertex: str, path=[]):\\n path = path + [start_vertex]\\n if start_vertex == end_vertex:\\n return [path]\\n\\n paths = []\\n for vertex in self.graph[start_vertex]:\\n if vertex not in path:\\n extended_paths = self._find_all_paths(vertex,\\n end_vertex,\\n path)\\n for p in extended_paths:\\n paths.append(p)\\n return paths\",\n \"def entity(entity):\\n for start, end in entity.spans:\\n yield start, end-start\",\n \"def line_range(self) -> Tuple[int, int]:\\n if self._line_range is None:\\n node_extent = self.node.extent\\n comment_extent = self.node.comment_extent\\n if comment_extent.start.file is None:\\n comment_extent = node_extent\\n\\n self._line_range = (\\n min(node_extent.start.line, comment_extent.start.line),\\n max(node_extent.end.line, comment_extent.end.line),\\n )\\n\\n return self._line_range\",\n \"def line_end(self):\\n curr = self\\n while curr.next:\\n curr = curr.next\\n return curr\",\n \"def find_lines(self):\\n return []\",\n \"def subgraph_within_dates(self, start_date, end_date):\\n new = Graph.graph_with_graph(self)\\n for u, v in self.nx_graph.edges_iter():\\n edge = new.nx_graph.edge[u][v]\\n done = False\\n while len(edge['timestamps']) and not done:\\n top = bottom = False\\n if edge['timestamps'][0] >= end_date:\\n edge['timestamps'].pop(0)\\n else:\\n top = True\\n\\n if len(edge['timestamps']) and edge['timestamps'][-1] < start_date:\\n edge['timestamps'].pop(-1)\\n else:\\n bottom = True\\n\\n done = top and bottom\\n\\n if not len(edge['timestamps']):\\n new.nx_graph.remove_edge(u, v)\\n\\n # min = 100000000\\n # max = -100000000\\n # for u,v, data in new.nx_graph.edges_iter(data=True):\\n # for time in data['timestamps']:\\n # if time < min:\\n # min = time\\n # elif time > max:\\n # max = time\\n\\n new.max_date = end_date\\n new.min_date = start_date\\n return new\",\n \"def get_end_vertices(self):\\n # Note that concatenating two vertices needs to make a\\n # vertices for the frame.\\n extesion_fraction = self.extesion_fraction\\n\\n corx = extesion_fraction*2.\\n cory = 1./(1. - corx)\\n x1, y1, w, h = 0, 0, 1, 1\\n x2, y2 = x1 + w, y1 + h\\n dw, dh = w*extesion_fraction, h*extesion_fraction*cory\\n\\n if self.extend in [\\\"min\\\", \\\"both\\\"]:\\n bottom = [(x1, y1),\\n (x1+w/2., y1-dh),\\n (x2, y1)]\\n else:\\n bottom = [(x1, y1),\\n (x2, y1)]\\n\\n if self.extend in [\\\"max\\\", \\\"both\\\"]:\\n top = [(x2, y2),\\n (x1+w/2., y2+dh),\\n (x1, y2)]\\n else:\\n top = [(x2, y2),\\n (x1, y2)]\\n\\n if self.orientation == \\\"horizontal\\\":\\n bottom = [(y,x) for (x,y) in bottom]\\n top = [(y,x) for (x,y) in top]\\n\\n return bottom, top\",\n \"def get_pruned_tree_path (self, index_1_beg, index_1_end,\\n index_2_beg, index_2_end, in_between_children = False ):\\n tempo_2_beg = index_2_beg\\n tempo_2_end = index_2_end\\n if index_1_beg >= index_2_end:\\n index_2_beg = index_1_beg\\n index_2_end = index_1_end\\n index_1_beg = tempo_2_beg\\n index_1_end = tempo_2_end\\n \\n if index_1_end - index_1_beg > 1:\\n lca_1_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_1_end )\\n else:\\n lca_1_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_1_end )[:-1]\\n\\n if index_2_end - index_2_beg > 1:\\n lca_2_index = self.tree.treeposition_spanning_leaves( index_2_beg, index_2_end )\\n else:\\n lca_2_index = self.tree.treeposition_spanning_leaves( index_2_beg, index_2_end )[:-1]\\n \\n if index_2_end - index_1_beg > 1:\\n lca_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )\\n else:\\n lca_index = self.tree.treeposition_spanning_leaves( index_1_beg, index_2_end )[:-1]\\n \\n lca = self.tree[lca_index]\\n new_tree = ParentedTree('(' + lca.node + ')')\\n\\n #Point to the root\\n # Branch of the first entity\\n current_pointer = new_tree\\n tempo_lca = lca\\n# try:\\n for i in xrange(len(lca_index), len(lca_1_index)):\\n tempo_lca = tempo_lca[lca_1_index[i]]\\n if not (type(tempo_lca) == str or type(tempo_lca) == unicode):\\n current_pointer.insert(0, ParentedTree('('+tempo_lca.node +')'))\\n current_pointer = current_pointer[0]\\n\\n current_pointer = new_tree\\n #Insert the first level of children of lca\\n if len(lca_index) < len(lca_1_index) and len(lca_index) < len(lca_2_index):\\n if in_between_children:\\n for i in xrange(lca_1_index[len(lca_index)] + 1, lca_2_index[len(lca_index)]):\\n current_pointer.insert(i, ParentedTree('('+lca[i].node +')'))\\n\\n #Point to the root\\n # Branch of the second entity\\n current_pointer = new_tree\\n tempo_lca = lca\\n first_time = True\\n for i in xrange(len(lca_index), len(lca_2_index)):\\n tempo_lca = tempo_lca[lca_2_index[i]]\\n if not (type(tempo_lca) == str or type(tempo_lca) == unicode):\\n if first_time:\\n if not in_between_children:\\n children_index_of_2nd_branch = 1\\n else:\\n \\\"\\\"\\\"\\n Don't really need to check lca_2_index[len(lca_index)]\\n 'cause if it come to this point, the length constraint\\n is already satisfied\\n However, it's necessary to check lca_1_index[len(lca_index)]\\n \\\"\\\"\\\"\\n if len(lca_index) < len(lca_1_index):\\n children_index_of_2nd_branch = lca_2_index[len(lca_index)]\\\\\\n - lca_1_index[len(lca_index)]\\n else:\\n \\\"\\\"\\\"\\n No left child, no in_between_children\\n \\\"\\\"\\\"\\n children_index_of_2nd_branch = 0\\n current_pointer.insert(children_index_of_2nd_branch,\\n ParentedTree('('+tempo_lca.node +')'))\\n current_pointer = current_pointer[children_index_of_2nd_branch]\\n first_time = False\\n else:\\n current_pointer.insert(0, ParentedTree('('+tempo_lca.node +')'))\\n current_pointer = current_pointer[0]\\n return new_tree\",\n \"def startAndEnd(self):\\n upperRow = 0\\n upperCol = 0\\n lowerRow = 0\\n lowerCol = 0\\n if self.selectionMode == kSelectionNone:\\n upperRow = self.penRow\\n upperCol = self.penCol\\n lowerRow = self.penRow\\n lowerCol = self.penCol\\n elif self.selectionMode == kSelectionAll:\\n upperRow = 0\\n upperCol = 0\\n lowerRow = self.parser.rowCount() - 1\\n lowerCol = self.parser.rowWidth(-1)\\n elif self.selectionMode == kSelectionBlock:\\n upperRow = min(self.markerRow, self.penRow)\\n upperCol = min(self.markerCol, self.penCol)\\n lowerRow = max(self.markerRow, self.penRow)\\n lowerCol = max(self.markerCol, self.penCol)\\n elif (self.selectionMode == kSelectionCharacter or\\n self.selectionMode == kSelectionLine or\\n self.selectionMode == kSelectionWord):\\n upperRow = self.markerRow\\n upperCol = self.markerCol\\n lowerRow = self.penRow\\n lowerCol = self.penCol\\n if upperRow == lowerRow and upperCol > lowerCol:\\n upperCol, lowerCol = lowerCol, upperCol\\n elif upperRow > lowerRow:\\n upperRow, lowerRow = lowerRow, upperRow\\n upperCol, lowerCol = lowerCol, upperCol\\n #app.log.detail('start and end', upperRow, upperCol, lowerRow, lowerCol)\\n return (upperRow, upperCol, lowerRow, lowerCol)\",\n \"def build_path(start, end):\\n a = hierarchy.index(start)\\n b = hierarchy.index(end)\\n if a == b:\\n return []\\n elif a < b:\\n return hierarchy[a + 1 : b + 1]\\n return list(reversed(hierarchy[b:a]))\",\n \"def slice_by_pos(val: str, start: SourcePos, end: SourcePos) -> str:\\n if \\\"\\\\n\\\" in val:\\n lines = val.split(\\\"\\\\n\\\")\\n if end.row > start.row:\\n top = lines[start.row][start.col :]\\n filling = lines[start.row + 1 : end.row]\\n bottom = lines[end.row][: end.col]\\n return \\\"\\\\n\\\".join(line for line in chain([top], filling, [bottom]))\\n else:\\n return lines[start.row][start.col : end.col]\\n else:\\n return val[start.col : end.col]\",\n \"def find_bound_paragraph(c: Cmdr) -> tuple[str, list[str], str]:\\n head, ins, tail = c.frame.body.getInsertLines()\\n head_lines = g.splitLines(head)\\n tail_lines = g.splitLines(tail)\\n result = []\\n insert_lines = g.splitLines(ins)\\n para_lines = insert_lines + tail_lines\\n # If the present line doesn't start a paragraph,\\n # scan backward, adding trailing lines of head to ins.\\n if insert_lines and not startsParagraph(insert_lines[0]):\\n n = 0 # number of moved lines.\\n for s in reversed(head_lines):\\n if ends_paragraph(s) or single_line_paragraph(s):\\n break\\n elif startsParagraph(s):\\n n += 1\\n break\\n else:\\n n += 1\\n if n > 0:\\n para_lines = head_lines[-n :] + para_lines\\n head_lines = head_lines[: -n]\\n ended, started = False, False\\n for i, s in enumerate(para_lines):\\n if started:\\n if ends_paragraph(s) or startsParagraph(s):\\n ended = True\\n break\\n else:\\n result.append(s)\\n elif s.strip():\\n result.append(s)\\n started = True\\n if ends_paragraph(s) or single_line_paragraph(s):\\n i += 1\\n ended = True\\n break\\n else:\\n head_lines.append(s)\\n if started:\\n head = ''.join(head_lines)\\n tail_lines = para_lines[i:] if ended else []\\n tail = ''.join(tail_lines)\\n return head, result, tail # string, list, string\\n return None, None, None\",\n \"def get_start_end_points(path, transect): \\n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\\\",\\\")\\n start_point = transect_array[2 * transect, :]\\n end_point = transect_array[2 * transect + 1, :]\\n \\n # force start points to be west of end points\\n if start_point[0] > end_point[0]:\\n previous_start_point = start_point\\n start_point = end_point\\n end_point = previous_start_point\\n return start_point, end_point\",\n \"def linerange_fix(node):\\n # deal with multiline strings lineno behavior (Python issue #16806)\\n lines = linerange(node)\\n if hasattr(node, 'sibling') and hasattr(node.sibling, 'lineno'):\\n start = min(lines)\\n delta = node.sibling.lineno - start\\n if delta > 1:\\n return list(range(start, node.sibling.lineno))\\n return lines\",\n \"def find_all_iter( source, substring, start=None, end=None, overlap=False ):\\n data = source\\n base = 0\\n if end is not None:\\n data = data[:end]\\n if start is not None:\\n data = data[start:]\\n base = start\\n pointer = 0\\n increment = 1 if overlap else (len( substring ) or 1)\\n while True:\\n pointer = data.find( substring, pointer )\\n if pointer == -1:\\n return\\n yield base+pointer\\n pointer += increment\",\n \"def find_text_between(start,end,haystack):\\n found = re.search(start+'(.*)'+end,haystack,re.IGNORECASE | re.DOTALL)\\n \\n if found:\\n return found.group(1).strip()\\n else:\\n raise Exception(\\\"There is no substring starting with '{}', ending\\\"\\n \\\" with '{}' in content '{}' \\\".format(start,end,haystack))\",\n \"def enumerate_stripped(self, start_at=0):\\n idx = start_at\\n if start_at:\\n lines = self._stripped_lines[start_at:]\\n else:\\n lines = self._stripped_lines\\n for line in lines:\\n # if line:\\n yield idx, line\\n idx += 1\",\n \"def find_all_paths(parents_to_children, start, end, path=[]):\\r\\n path = path + [start]\\r\\n if start == end:\\r\\n return [path]\\r\\n if start not in parents_to_children.keys():\\r\\n return []\\r\\n paths = []\\r\\n for node in parents_to_children[start]:\\r\\n if node not in path:\\r\\n newpaths = find_all_paths(parents_to_children, node, end, path)\\r\\n for newpath in newpaths:\\r\\n paths.append(tuple(newpath))\\r\\n return paths\",\n \"def get_file_lines(self, filepath, start, stop):\\n\\n if self._file_lines is None:\\n with open(os.path.join(self.repo_path, filepath)) as f:\\n self._file_lines = f.readlines()\\n\\n if stop is None:\\n lines = self._file_lines[start - 1:]\\n else:\\n lines = self._file_lines[start - 1:stop]\\n for i, line in enumerate(lines):\\n lines[i] = [start + i, True, line.rstrip()]\\n while lines and self.is_empty_line(lines[-1][-1]):\\n lines.pop()\\n\\n if not lines:\\n return []\\n\\n stop = lines[0][0]\\n start = max(1, stop - self.surround_by)\\n prefix_lines = []\\n for i, line in enumerate(self._file_lines[start - 1:stop - 1], start=start):\\n prefix_lines.append([i, False, line.rstrip()])\\n\\n start = lines[-1][0] + 1\\n stop = start + self.surround_by\\n suffix_lines = []\\n for i, line in enumerate(self._file_lines[start - 1:stop - 1], start=start):\\n suffix_lines.append([i, False, line.rstrip()])\\n\\n return prefix_lines + lines + suffix_lines\",\n \"def span(self, raw):\\n if raw.lower() in ('*', '-', 'all'):\\n raw = ':'\\n results = self.spanpattern.search(raw)\\n if not results:\\n raise IndexError\\n if not results.group('separator'):\\n return [self[self._to_index(results.group('start'))]]\\n start = self._to_index(results.group('start')) or 0 # Ensure start is not None\\n end = self._to_index(results.group('end'))\\n reverse = False\\n if end is not None:\\n if end < start:\\n (start, end) = (end, start)\\n reverse = True\\n end += 1\\n result = self[start:end]\\n if reverse:\\n result.reverse()\\n return result\",\n \"def find_all_path(self, start_vertex, end_vertex, path=[]):\\n\\n graph = self.__graph_dict\\n path = path + [start_vertex]\\n if start_vertex == end_vertex:\\n return [path]\\n\\n if start_vertex not in graph:\\n return []\\n\\n paths = []\\n for vertex in graph[start_vertex]:\\n if vertex not in path:\\n extended_paths = self.find_all_path(vertex, end_vertex,path)\\n for p in extended_paths:\\n paths.append(p)\\n return paths\",\n \"def test_start_equals_end_is_fine(self):\\n with stdin_as_string(self.ifile):\\n self.assertLines(\\n [\\\"-i\\\", \\\"0-0\\\"],\\n [\\n \\\"id\\\",\\n \\\"0\\\",\\n ],\\n )\\n\\n with stdin_as_string(self.ifile):\\n self.assertLines(\\n [\\\"-i\\\", \\\"3-3\\\"],\\n [\\n \\\"id\\\",\\n \\\"3\\\",\\n ],\\n )\",\n \"def segments(self):\\n return (self._subset((i,i+1)) for i in range(len(self)-1))\",\n \"def iter_fragments(self, frag_id_begin = None, frag_id_end = None):\\n return iter_fragments(iter(self.fragment_list), frag_id_begin, frag_id_end)\",\n \"def find_start_end(text, start_text, end_text, start=0):\\n # return (s, e) or None\\n s = text.find(start_text, start)\\n if s < 0:\\n return None\\n e = text.find(end_text, s+1)\\n if e < 0:\\n return None\\n e += len(end_text)\\n return s, e\",\n \"def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:\\n # The current line might still wait for trailing comments. At DEDENT time\\n # there won't be any (they would be prefixes on the preceding NEWLINE).\\n # Emit the line then.\\n yield from self.line()\\n\\n # While DEDENT has no value, its prefix may contain standalone comments\\n # that belong to the current indentation level. Get 'em.\\n yield from self.visit_default(node)\\n\\n # Finally, emit the dedent.\\n yield from self.line(-1)\",\n \"def extract(lines):\\n prefix = 'Note: including file: '\\n for line in lines:\\n if line.startswith(prefix):\\n line = os.path.normpath(line[len(prefix):])\\n # Determine the depth by counting the number of spaces starting the line.\\n depth = len(line) - len(line.lstrip()) + 1\\n yield (depth, line.strip())\",\n \"def _get_multiline(self):\\n lines = []\\n line = self._get_line()\\n lines.append(line)\\n if line[3:4] == \\\"-\\\":\\n code = line[:3]\\n while 1:\\n nextline = self._get_line()\\n lines.append(nextline)\\n if nextline[:3] == code and nextline[3:4] != \\\"-\\\":\\n break\\n return lines\",\n \"def find_all_path(self, start, end, path=[]):\\n path = path+[start]\\n if start == end:\\n return path\\n paths = []\\n for node in self.graph[start]:\\n if node not in path:\\n newpaths = self.find_path(node, end, path)\\n paths.append(newpaths)\\n return paths\",\n \"def between(current, end):\\n text_list = []\\n\\n while current and current != end:\\n if isinstance(current, bs4.NavigableString):\\n text = current.strip()\\n if text:\\n texts = text.split(\\\"\\\\n\\\")\\n for text in texts:\\n content_str = ''\\n for c in text:\\n if is_chinese(c):\\n content_str += c\\n text_list.append(content_str)\\n\\n current = current.next_element\\n return text_list\",\n \"def getEnds(self) -> List[int]:\\n ...\",\n \"def traversal(self, start: str, end: str=None) -> None:\\n if not isinstance(start, str):\\n raise TypeError('Traversal takes in one param which must be a string')\\n if not start:\\n raise ValueError('Please enter a string')\\n if end is None:\\n curr = self._base\\n for idx, char in enumerate(start, start=1):\\n if idx == len(start) and char in curr:\\n yield start\\n curr = curr[char]\\n for char in curr:\\n if not char == '$':\\n yield char\\n for each_char in self.traversal(start, curr[char]):\\n yield each_char\\n elif char in curr:\\n curr = curr[char]\\n else:\\n raise ValueError('String not in trie')\\n else:\\n for char in end:\\n if not char == '$':\\n yield char\\n for each_char in self.traversal(start, end[char]):\\n yield each_char\",\n \"def getRecordListUnzipped(self, region=None, chrom=None,\\n start=None, end=None):\\n lst = []\\n if region is None:\\n #lst.append(prev_last_rec)\\n for rec in self.reader:\\n lst.append(rec)\\n self.prev_last_rec = lst[-1]\\n return lst\\n #return lst, lst[-1]\\n\\n if (self.prev_last_rec is not None and\\n region.containsRecord(self.prev_last_rec) == 'in'):\\n lst.append(self.prev_last_rec)\\n elif (self.prev_last_rec is not None and\\n region.containsRecord(self.prev_last_rec) == 'after'):\\n return []\\n rec = next(self.reader,None)\\n if rec is None:\\n self.prev_last_rec = None\\n return lst\\n #return lst,None\\n place = region.containsRecord(rec)\\n while rec is not None and place != 'after':\\n if place == 'in':\\n lst.append(rec)\\n rec = next(self.reader,None)\\n if rec is None:\\n break\\n place = region.containsRecord(rec)\\n self.prev_last_rec = rec\\n return lst\\n #return lst, prev_last_rec\",\n \"def find(self, sub, start=0, end=None):\\n return find(self, sub, start, end)\",\n \"def _parents(self, prefix):\\n if self.inherit:\\n suffix = self.inherit.name\\n value = self.tracconfig.get(\\n self.section, '%s.%s' % (prefix, suffix), default=None)\\n if value:\\n return self._parents_to_list(value)\\n return None\",\n \"def parent_addresses(self):\\n address = self.address\\n if not address.startswith(\\\"/\\\"):\\n address = \\\"/\\\" + address\\n if address.endswith(\\\"/\\\"):\\n address = address[:-1]\\n\\n if address:\\n return address.split(\\\"/\\\")[:-1]\\n\\n return []\",\n \"def find_isolated_endpoints(lines):\\n \\n isolated_endpoints = []\\n count = len(lines)\\n print(\\\"Finding isolated end points 2/3\\\")\\n pb = pbar.ProgressBar(count)\\n for i, line in enumerate(lines):\\n pb += 1\\n other_lines = lines[:i] + lines[i+1:]\\n for q in [0,-1]:\\n endpoint = Point(line.coords[q])\\n if any(endpoint.touches(another_line) \\n for another_line in other_lines):\\n continue\\n else:\\n isolated_endpoints.append(endpoint)\\n del pb\\n return isolated_endpoints\",\n \"def Segments():\\n for n in range(ida_segment.get_segm_qty()):\\n seg = ida_segment.getnseg(n)\\n if seg:\\n yield seg.start_ea\",\n \"def getAllParents(start):\\n parent = start.getParent()\\n\\n while parent:\\n node = parent\\n yield parent\\n parent = node.getParent()\",\n \"def find_all_paths(graph, start, end, path=[]):\\n path = path + [start]\\n if start == end:\\n return [path]\\n paths = []\\n for node in graph[start]:\\n newpaths = find_all_paths(graph, node, end, path)\\n paths += newpaths\\n return paths\",\n \"def get_start_end_addresses(lineId):\\n\\n return Db().get_first_and_last_address(lineId)\",\n \"def span(self):\\r\\n return self._start, self._end\",\n \"def interpolate_to_parent(self, start, end, linspace_count):\\n \\n v = end - start\\n length = norm(v)\\n v = v / length # Make v a unit vector\\n l = np.linspace(0, length, linspace_count) \\n\\n return np.array([start[i] + v[i] * l for i in range(3)])\",\n \"def find_start_and_end(arr):\\n start = None\\n end = None\\n for i, line in enumerate(arr):\\n for j, node in enumerate(line):\\n if node.symbol is 'A':\\n start = node\\n if node.symbol is 'B':\\n end = node\\n return start, end\",\n \"def segment(self):\\n start = self.alignment.matching_function_startpoint(self.idx)\\n end = self.alignment.matching_function_endpoint(self.idx)\\n return [start, end]\",\n \"def traverse_graph_start_end_extra_node(graph):\\n\\n # get tree with starting node tags\\n\\n def traverse(graph, node):\\n\\n children = [int(c) for c in graph[node][\\\"children\\\"]]\\n tagged_children = []\\n for child in children:\\n ellipsed_parents = [int(p) for p in graph[child][\\\"ellipsed_parents\\\"]]\\n # if the child is explicit\\n if node not in ellipsed_parents:\\n if graph[child][\\\"terminal\\\"] == \\\"yes\\\":\\n tagged_children.append(ParentedTree(graph[child][\\\"tag\\\"], [graph[child][\\\"text\\\"]]))\\n else:\\n tagged_children.append(traverse(graph, child))\\n # if the child is ellipsed\\n else:\\n ellipsis_tag = get_ellipsis_tag_from_graph(graph, child)\\n tagged_children.append(ParentedTree(ellipsis_tag, []))\\n \\n tree = ParentedTree(graph[node][\\\"tag\\\"], tagged_children)\\n\\n return tree\\n\\n tree = traverse(graph, 0)\\n\\n # get ending node tags\\n positions = [pos for pos in tree.treepositions() if pos not in tree.treepositions(\\\"leaves\\\")]\\n end_tags = []\\n ellipsis_id = 0 # assign an id to each ellipsis start and end nodes\\n for pos_i, pos in enumerate(positions):\\n if tree[pos].label().startswith(\\\"start\\\"):\\n ellipsis_tag = tree[pos].label().split(\\\"start\\\")[-1]\\n tree[pos].set_label(\\\"start\\\" + str(ellipsis_id))\\n end_location = get_ellipsis_location(tree, ellipsis_tag)\\n end_tag = \\\"end\\\" + str(ellipsis_id)\\n end_tags.append((end_location, end_tag))\\n ellipsis_id += 1\\n\\n # insert ending node tags\\n for index, st in enumerate(tree.subtrees()):\\n for end_location, end_tag in end_tags:\\n if st.treeposition() == end_location:\\n st.insert(index, ParentedTree(end_tag, []))\\n\\n positions = [pos for pos in tree.treepositions() if pos not in tree.treepositions(\\\"leaves\\\")]\\n rev_positions = [pos for pos in reversed(positions)]\\n for pos_i, pos in enumerate(rev_positions):\\n # append start tag to the previous node\\n if tree[pos].label().startswith(\\\"start\\\"):\\n prev_pos_i = pos_i + 1\\n prev_pos = rev_positions[prev_pos_i]\\n tree[prev_pos].set_label(tree[prev_pos].label() + tree[pos].label())\\n del tree[pos]\\n # append end tag to the parent of the current node\\n elif tree[pos].label().startswith(\\\"end\\\"):\\n parent_pos = tree[pos].parent().treeposition()\\n tree[parent_pos].set_label(tree[parent_pos].label() + tree[pos].label())\\n del tree[pos] \\n\\n # wrap each constituent that has end or start tags with extra nodes\\n\\n def add_extra_nodes(tree):\\n children = []\\n for subtree in tree:\\n if type(subtree) == str:\\n children.append(subtree)\\n else:\\n splits = re.split(\\\"(start|end)\\\", subtree.label())\\n const_tag = splits[0]\\n ellipsis_tag = \\\"\\\".join(splits[1:]) \\n if len(ellipsis_tag) > 0:\\n children.append(Tree(subtree.label(), [Tree(const_tag, [sst for sst in subtree])]))\\n else:\\n children.append(add_extra_nodes(subtree))\\n\\n return Tree(tree.label(), children)\\n\\n tree = add_extra_nodes(tree)\\n\\n return tree\",\n \"def get_descendant_ids(cur, node):\\n sql = \\\"\\\"\\\"\\n SELECT\\n node\\n FROM\\n ancestors\\n WHERE\\n ancestor=%s;\\n \\\"\\\"\\\"\\n cur.execute(sql, (str(node), ))\\n for result in cur:\\n yield str(result['node'])\",\n \"def get(self, *args):\\n return _libsbml.ListOfLineSegments_get(self, *args)\",\n \"def parsed_span(self, start, end, include_boundaries=False):\\n start_sent, start_tok = start\\n end_sent, end_tok = end\\n\\n if start_sent == end_sent:\\n span = self.conll[start_sent][start_tok:end_tok]\\n\\n else:\\n\\n span = self.conll[start_sent][start_tok:]\\n\\n if include_boundaries:\\n span.append([-1, 'EOS'])\\n\\n for sent in range(start_sent + 1, end_sent):\\n span.extend(self.conll[sent])\\n\\n if include_boundaries:\\n span.append([-1, 'EOS'])\\n\\n span.extend(self.conll[end_sent][:end_tok])\\n\\n return span\",\n \"def _split_code_lines(ast_nodes, text):\\n if not ast_nodes:\\n yield ([], text)\\n return\\n assert text.startpos <= ast_nodes[0].startpos\\n assert ast_nodes[-1].startpos < text.endpos\\n if text.startpos != ast_nodes[0].startpos:\\n # Starting noncode lines.\\n yield ([], text[text.startpos:ast_nodes[0].startpos])\\n end_sentinel = _DummyAst_Node()\\n end_sentinel.startpos = text.endpos\\n for node, next_node in zip(ast_nodes, ast_nodes[1:] + [end_sentinel]):\\n startpos = node.startpos\\n next_startpos = next_node.startpos\\n assert startpos < next_startpos\\n # We have the start position of this node. Figure out the end\\n # position, excluding noncode lines (standalone comments and blank\\n # lines).\\n if hasattr(node, 'endpos'):\\n # We have an endpos for the node because this was a multi-line\\n # string. Start with the node endpos.\\n endpos = node.endpos\\n assert startpos < endpos <= next_startpos\\n # enpos points to the character *after* the ending quote, so we\\n # know that this is never at the beginning of the line.\\n assert endpos.colno != 1\\n # Advance past whitespace an inline comment, if any. Do NOT\\n # advance past other code that could be on the same line, nor past\\n # blank lines and comments on subsequent lines.\\n line = text[endpos : min(text.endpos, FilePos(endpos.lineno+1,1))]\\n if _is_comment_or_blank(line):\\n endpos = FilePos(endpos.lineno+1, 1)\\n else:\\n endpos = next_startpos\\n assert endpos <= text.endpos\\n # We don't have an endpos yet; what we do have is the next node's\\n # startpos (or the position at the end of the text). Start there\\n # and work backward.\\n if endpos.colno != 1:\\n if endpos == text.endpos:\\n # There could be a comment on the last line and no\\n # trailing newline.\\n # TODO: do this in a more principled way.\\n if _is_comment_or_blank(text[endpos.lineno]):\\n assert startpos.lineno < endpos.lineno\\n if not text[endpos.lineno-1].endswith(\\\"\\\\\\\\\\\"):\\n endpos = FilePos(endpos.lineno,1)\\n else:\\n # We're not at end of file, yet the next node starts in\\n # the middle of the line. This should only happen with if\\n # we're not looking at a comment. [The first character in\\n # the line could still be \\\"#\\\" if we're inside a multiline\\n # string that's the last child of the parent node.\\n # Therefore we don't assert 'not\\n # _is_comment_or_blank(...)'.]\\n pass\\n if endpos.colno == 1:\\n while (endpos.lineno-1 > startpos.lineno and\\n _is_comment_or_blank(text[endpos.lineno-1]) and\\n (not text[endpos.lineno-2].endswith(\\\"\\\\\\\\\\\") or\\n _is_comment_or_blank(text[endpos.lineno-2]))):\\n endpos = FilePos(endpos.lineno-1, 1)\\n assert startpos < endpos <= next_startpos\\n yield ([node], text[startpos:endpos])\\n if endpos != next_startpos:\\n yield ([], text[endpos:next_startpos])\",\n \"def intervals_between(self, start: dt.datetime, end: dt.datetime) -> List[Interval]:\\n relevant_intervals: List[Interval] = []\\n\\n for interval in self.intervals:\\n if start <= interval.start_time < end:\\n relevant_intervals.append(interval)\\n\\n return relevant_intervals\",\n \"def outer(self):\\n if self.parent is not None:\\n self.parent.lines += self.lines\\n # print (f\\\"{self.name} -> {self.parent.name}\\\")\\n return self.parent\",\n \"def sub_get_lines(treeiter):\\n while treeiter != None:\\n tup = self.store[treeiter]\\n if criteria(tup):\\n lines.append({\\n 'jid': tup[0],\\n 'country': tup[3],\\n 'ip': tup[4]})\\n if self.store.iter_has_child(treeiter):\\n childiter = self.store.iter_children(treeiter)\\n sub_get_lines(childiter)\\n treeiter = self.store.iter_next(treeiter)\",\n \"def findPath(g, start, end, path=[]):\\n path = path + [start]\\n if start == end:\\n return path\\n if not start in g:\\n return None\\n for node in g[start]:\\n if node not in path:\\n newpath = findPath(g, node, end, path)\\n if newpath: return newpath\\n return None\",\n \"def _get_start_end(self):\\n with open(self._file_properties['file_name'], 'r') as in_file:\\n self._file_properties['line_count'] = 0\\n for (i, line) in enumerate(in_file):\\n # Check for \\\"start data\\\" string\\n if line[0:5] == '$$SOE':\\n self._file_properties['start_ind'] = i\\n\\n # Check for \\\"end data\\\" string\\n if line[0:5] == '$$EOE':\\n self._file_properties['stop_ind'] = i\\n\\n # Count total number of lines\\n self._file_properties['line_count'] += 1\",\n \"def test_intersect_line_in_no_point(start, end):\\n circle = ConstructionCircle((0, 0), 1.0)\\n assert len(circle.intersect_line(ConstructionLine(start, end))) == 0\",\n \"async def get_sub_block_in_range(\\n self,\\n start: int,\\n stop: int,\\n ) -> Dict[bytes32, SubBlockRecord]:\\n\\n formatted_str = (\\n f\\\"SELECT header_hash,sub_block from sub_block_records WHERE sub_height >= {start} and sub_height <= {stop}\\\"\\n )\\n\\n cursor = await self.db.execute(formatted_str)\\n rows = await cursor.fetchall()\\n await cursor.close()\\n ret: Dict[bytes32, SubBlockRecord] = {}\\n for row in rows:\\n header_hash = bytes.fromhex(row[0])\\n ret[header_hash] = SubBlockRecord.from_bytes(row[1])\\n\\n return ret\",\n \"def path(self):\\r\\n node, p = self, []\\r\\n while node:\\r\\n p.append(node)\\r\\n node = node.parent\\r\\n yield from reversed(p)\",\n \"def parentsUntil(self,selector):\\n nList = self.htmlDom.find(selector)\\n parentsList = []\\n tmpList = []\\n selectedNodesList = []\\n for node in self.nodeList:\\n if not node.ancestorList:\\n node.generateAncestorList()\\n tmpList = node.ancestorList\\n for selectedNode in nList.nodeList:\\n try:\\n index = tmpList.index( selectedNode )\\n selectedNodeList = tmpList[:index]\\n parentsList += self.getUniqueNodes( parentsList, selectedNodeList )\\n break\\n except ValueError:\\n pass\\n else:\\n parentsList += self.getUniqueNodes( parentsList, tmpList )\\n parentsList = sorted( parentsList, key = lambda x: x.pos )\\n return HtmlNodeList( parentsList, self.htmlDom, self.nodeList, self )\",\n \"def FindAllPaths(graph, start, end, path=[]):\\n path = path + [start]\\n if start == end:\\n return [path]\\n if start not in graph:\\n return None\\n paths = []\\n for node in graph[start]:\\n if node not in path:\\n newpaths = find_all_paths(graph, node, end, path)\\n for newpath in newpaths:\\n paths.append(newpath)\\n return paths\",\n \"def find_path(self, start_vertex, end_vertex, path=[]):\\n\\n graph = self.__graph_dict\\n path = path + [start_vertex]\\n if start_vertex == end_vertex:\\n return path\\n\\n if start_vertex not in graph:\\n return None\\n\\n for vertex in graph[start_vertex]:\\n if vertex not in path:\\n extended_path = self.find_path(vertex, end_vertex,path)\\n if extended_path:\\n return extended_path\\n return None\",\n \"def get_parents(self, node):\\n pass\",\n \"def feed(self, inline, endchar=None):\\n # preserve the original line\\n # for error messages\\n if endchar is None:\\n self.origline = inline\\n inline = inline.lstrip()\\n #\\n outlist = []\\n comma_needed = False\\n found_comma = False\\n while inline:\\n # NOTE: this sort of operation would be quicker\\n # with lists - but then can't use regexes\\n thischar = inline[0]\\n if thischar == '#':\\n # reached a comment\\n # end of the line...\\n break\\n #\\n if thischar == endchar:\\n return outlist, inline[1:]\\n #\\n if comma_needed:\\n if thischar == ',':\\n inline = inline[1:].lstrip()\\n comma_needed = False\\n found_comma = True\\n continue\\n raise BadLineError('Line is badly built :\\\\n%s' % self.origline)\\n #\\n try:\\n # the character that marks the end of the list\\n listend = self.liststart[thischar]\\n except KeyError:\\n pass\\n else:\\n if not self.recursive and endchar is not None:\\n raise BadLineError('Line is badly built :\\\\n%s' % self.origline)\\n newlist, inline = self.feed(inline[1:], endchar=listend)\\n outlist.append(newlist)\\n inline = inline.lstrip()\\n comma_needed = True\\n continue\\n #\\n if thischar in self.quotes:\\n # this might raise an error\\n # FIXME: trap the error and raise a more appropriate one ?\\n element, inline = unquote(inline, fullquote=False, \\n retain=self.retain)\\n inline = inline.lstrip()\\n outlist.append(element)\\n comma_needed = True\\n continue\\n #\\n # must be an unquoted element\\n mat = unquoted.match(inline)\\n if mat is not None:\\n # FIXME: if the regex was better we wouldn't need an rstrip\\n element = mat.group(1).rstrip()\\n # group 2 will be ``None`` if we reach the end of the line\\n inline = mat.group(2) or ''\\n outlist.append(element)\\n comma_needed = True\\n continue\\n # or it's a badly built line\\n raise BadLineError('Line is badly built :\\\\n%s' % self.origline)\\n #\\n # if we've been called recursively\\n # we shouldn't have got this far\\n if endchar is not None:\\n raise BadLineError('Line is badly built :\\\\n%s' % self.origline)\\n #\\n if not found_comma:\\n # if we didn't find a comma\\n # the value could be a nested list\\n if outlist:\\n outlist = outlist[0]\\n else:\\n outlist = ''\\n if self.force_list and not isinstance(outlist, list):\\n if outlist:\\n outlist = [outlist]\\n else:\\n outlist = []\\n if not self.comment:\\n if inline:\\n raise CommentError('Comment not allowed :\\\\n%s' % self.origline)\\n return outlist\\n return outlist, inline\",\n \"def getCoveringRanges( self, left_ranges, right_ranges, parent_ranges ):\\n \\n child_ranges = map( lambda x: (x[0], x[1], 0), left_ranges)\\n child_ranges += map( lambda x: (x[0], x[1], 1), right_ranges)\\n \\n child_ranges.sort()\\n parent_ranges.sort()\\n \\n new_left_ranges = []\\n new_right_ranges = []\\n \\n parent_index = 0\\n last_to = 0\\n \\n parent_left, parent_right = parent_ranges[parent_index]\\n\\n self.debug( \\\"child_ranges=%s\\\" % str(child_ranges) )\\n self.debug( \\\"parent_ranges=%s\\\" % str(parent_ranges))\\n \\n last_left, last_right, last_is_right = child_ranges[0]\\n \\n for this_left, this_right, this_is_right in child_ranges[1:]:\\n \\n ## look at previous segment last_left to last_right:\\n ## find matching parent_index:\\n old_parent_index = parent_index\\n while (min(parent_right, last_right) - max(parent_left, last_left)) < 0:\\n parent_index += 1\\n if parent_index == len(parent_ranges): break\\n parent_left, parent_right = parent_ranges[parent_index]\\n \\n ## skip fragments that do not overlap\\n if parent_index == len(parent_ranges):\\n parent_index = old_parent_index\\n last_left, last_right, last_is_right = this_left, this_right, this_is_right\\n continue\\n \\n ## firstly: make segment covering\\n new_left = min(parent_left, last_left)\\n new_right = min(max(parent_right, last_right), this_left)\\n \\n if last_is_right:\\n new_right_ranges.append((new_left, new_right))\\n else:\\n new_left_ranges.append((new_left, new_right))\\n \\n ## reduce parent on left side\\n parent_left=max(new_right, parent_left)\\n \\n last_left, last_right, last_is_right = this_left, this_right, this_is_right\\n \\n ## process last segment\\n while (min(parent_right, last_right) - max(parent_left, last_left)) < 0:\\n parent_index += 1\\n if parent_index >= len(parent_ranges): break \\n parent_left, parent_right = parent_ranges[parent_index]\\n \\n new_left = min(parent_left, last_left)\\n new_right = max(parent_right, last_right)\\n \\n if last_is_right:\\n new_right_ranges.append((new_left, new_right))\\n else:\\n new_left_ranges.append((new_left, new_right))\\n \\n self.debug( \\\"old left ranges=%s\\\" % str(left_ranges))\\n self.debug( \\\"new left ranges=%s\\\" % str(new_left_ranges))\\n self.debug( \\\"old right ranges=%s\\\" % str(right_ranges))\\n self.debug( \\\"new right ranges=%s\\\" % str(new_right_ranges))\\n \\n return new_left_ranges, new_right_ranges\",\n \"def relations_from(self, start_node):\",\n \"def get_ancestor_ids(cur, node):\\n # TODO: add sort parameter\\n sql = \\\"\\\"\\\"\\n SELECT\\n ancestor\\n FROM\\n ancestors\\n WHERE\\n node=%s;\\n \\\"\\\"\\\"\\n cur.execute(sql, (str(node), ))\\n for result in cur:\\n yield str(result['ancestor'])\",\n \"def getLines(self):\\n f = open(self.__father.getpath() + self.__father.getidFile() + \\\".TRN\\\", \\\"r\\\")\\n lines = f.readlines()\\n subUnitLines = []\\n\\n if self.__speakerId == \\\"A\\\":\\n for line in lines:\\n if self.__speakerId == line.split(\\\"-\\\")[-2]:\\n subUnitLines.append(line)\\n elif self.__speakerId == \\\"B\\\":\\n for line in reversed(lines):\\n if self.__speakerId == line.split(\\\"-\\\")[-2]:\\n subUnitLines.append(line)\\n\\n f.close()\\n return subUnitLines\",\n \"def mid(start_row, start_peg, end_row, end_peg):\\n if start_row + 2 == end_row:\\n mid_row = start_row + 1\\n elif start_row == end_row + 2:\\n mid_row = start_row - 1\\n elif start_row == end_row:\\n mid_row = start_row\\n\\n if start_peg + 2 == end_peg:\\n mid_peg = start_peg + 1\\n elif start_peg == end_peg + 2:\\n mid_peg = start_peg - 1\\n elif start_peg == end_peg:\\n mid_peg = start_peg\\n\\n return (mid_row, mid_peg)\",\n \"def test_intersect_line_in_one_point(start, end):\\n circle = ConstructionCircle((0, 0), 1.0)\\n assert len(circle.intersect_line(ConstructionLine(start, end))) == 1\",\n \"def get_with_ancestors(\\n self,\\n ipfs_client: ipfsapi.Client = None) -> Iterator[\\\"VersionTreeNode\\\"]:\\n yield self\\n parent_hash = self.parent_hash\\n while parent_hash is not None:\\n parent_node = self.get_node_by_hash(\\n parent_hash,\\n (ipfs_client or self.ipfs_client))\\n parent_hash = parent_node.parent_hash\\n yield parent_node\",\n \"def extends(self):\\n p = re.compile(r\\\"^{%\\\\s+(extends\\\\s*(?P<parent>.*))\\\\s+%}\\\")\\n e = p.match(self.source)\\n # extends detact must be done at the begining of parsing.\\n # return None if there is no extends tag.\\n if not e:\\n return None\\n self.cur += len(e.group())\\n return e.group(\\\"parent\\\")\",\n \"def line(self, indent: int = 0) -> Iterator[Line]:\\n if not self.current_line:\\n self.current_line.depth += indent\\n return # Line is empty, don't emit. Creating a new one unnecessary.\\n\\n if (\\n Preview.improved_async_statements_handling in self.mode\\n and len(self.current_line.leaves) == 1\\n and is_async_stmt_or_funcdef(self.current_line.leaves[0])\\n ):\\n # Special case for async def/for/with statements. `visit_async_stmt`\\n # adds an `ASYNC` leaf then visits the child def/for/with statement\\n # nodes. Line yields from those nodes shouldn't treat the former\\n # `ASYNC` leaf as a complete line.\\n return\\n\\n complete_line = self.current_line\\n self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)\\n yield complete_line\",\n \"def _ancestors(self) -> Iterator['Node']:\\n yield self\\n if self.parent:\\n yield from self.parent._ancestors()\",\n \"def get_text_lines(instText):\\n\\n # Find out which part this is\\n part = instText.part\\n # Get the necessary parameters: lng, ext, dir\\n sLng = part.corpus.get_lng_display()\\n sDir = part.dir\\n sName = instText.fileName\\n sFormat = instText.get_format_display()\\n # Now try to get the information\\n oBack = get_crpp_text(sLng, sDir, sFormat, sName)\\n # Prepare what we return\\n if oBack == None or oBack['status'] == 'error':\\n return None\\n else:\\n return oBack\",\n \"def linerange(node):\\n strip = {\\\"body\\\": None, \\\"orelse\\\": None,\\n \\\"handlers\\\": None, \\\"finalbody\\\": None}\\n for key in strip.keys():\\n if hasattr(node, key):\\n strip[key] = getattr(node, key)\\n setattr(node, key, [])\\n\\n lines_min = 9999999999\\n lines_max = -1\\n for n in ast.walk(node):\\n if hasattr(n, 'lineno'):\\n lines_min = min(lines_min, n.lineno)\\n lines_max = max(lines_max, n.lineno)\\n\\n for key in strip.keys():\\n if strip[key] is not None:\\n setattr(node, key, strip[key])\\n\\n if lines_max > -1:\\n return list(range(lines_min, lines_max + 1))\\n return [0, 1]\",\n \"def iter_fragments(self):\\n if self.segment is None:\\n return iter(list())\\n return self.segment.iter_fragments()\",\n \"def iter_fragments(self):\\n if self.segment is None:\\n return iter(list())\\n return self.segment.iter_fragments()\",\n \"def segments(self):\\n L = len(self.vertices)\\n return itertools.chain((self._subset((i,i+1)) for i in range(len(self)-1)),\\n (self._subset((L-1,0)),))\",\n \"def parents( self, selector = None ): \\n tmpList = []\\n for node in self.nodeList:\\n if not node.ancestorList:\\n node.generateAncestorList()\\n tmpList += self.getUniqueNodes( tmpList, node.ancestorList )\\n if selector:\\n return HtmlNodeList( tmpList, self.htmlDom, self.nodeList, self ).filter( selector )\\n else:\\n tmpList = sorted( tmpList, key = lambda x: x.pos ) \\n return HtmlNodeList( tmpList, self.htmlDom, self.nodeList, self)\",\n \"def splitlines(self, keepends=None):\\n return splitlines(self, keepends)\",\n \"def find_path(self, start, end, path=[]):\\n path = path+[start]\\n if start == end:\\n return path\\n for node in self.graph[start]:\\n if node not in path:\\n newpath = self.find_path(node, end, path)\\n if newpath:\\n return newpath\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58529377","0.5581693","0.54582626","0.5362531","0.5349962","0.5346175","0.53401434","0.51990694","0.5192469","0.5124478","0.49769285","0.49085382","0.48960736","0.48947686","0.48660842","0.48560873","0.48549527","0.485269","0.4845138","0.48439127","0.48220178","0.480558","0.4803328","0.4797692","0.47944328","0.47736752","0.4747656","0.47411427","0.4740556","0.47385687","0.4724786","0.47239247","0.47198513","0.47192618","0.47187155","0.47177082","0.4684615","0.4671079","0.464064","0.4633553","0.46291345","0.46140298","0.46081704","0.45996073","0.4599099","0.4596323","0.45899472","0.45873365","0.45836774","0.4580793","0.4571836","0.45696598","0.45502156","0.4546937","0.45468506","0.45435366","0.45414248","0.45375898","0.45358273","0.4535309","0.453462","0.45333228","0.4532443","0.4532011","0.45319963","0.45318222","0.45254177","0.45191607","0.45187134","0.4493359","0.4488994","0.44850743","0.44797438","0.44719678","0.44709975","0.446485","0.44566843","0.4454258","0.4448934","0.4444215","0.4442582","0.4441559","0.4440375","0.4436594","0.44339862","0.4433548","0.44252804","0.44249827","0.4417582","0.4411244","0.44103143","0.44078305","0.4407231","0.43904907","0.43902022","0.43902022","0.4383925","0.4380482","0.43799642","0.43789622"],"string":"[\n \"0.58529377\",\n \"0.5581693\",\n \"0.54582626\",\n \"0.5362531\",\n \"0.5349962\",\n \"0.5346175\",\n \"0.53401434\",\n \"0.51990694\",\n \"0.5192469\",\n \"0.5124478\",\n \"0.49769285\",\n \"0.49085382\",\n \"0.48960736\",\n \"0.48947686\",\n \"0.48660842\",\n \"0.48560873\",\n \"0.48549527\",\n \"0.485269\",\n \"0.4845138\",\n \"0.48439127\",\n \"0.48220178\",\n \"0.480558\",\n \"0.4803328\",\n \"0.4797692\",\n \"0.47944328\",\n \"0.47736752\",\n \"0.4747656\",\n \"0.47411427\",\n \"0.4740556\",\n \"0.47385687\",\n \"0.4724786\",\n \"0.47239247\",\n \"0.47198513\",\n \"0.47192618\",\n \"0.47187155\",\n \"0.47177082\",\n \"0.4684615\",\n \"0.4671079\",\n \"0.464064\",\n \"0.4633553\",\n \"0.46291345\",\n \"0.46140298\",\n \"0.46081704\",\n \"0.45996073\",\n \"0.4599099\",\n \"0.4596323\",\n \"0.45899472\",\n \"0.45873365\",\n \"0.45836774\",\n \"0.4580793\",\n \"0.4571836\",\n \"0.45696598\",\n \"0.45502156\",\n \"0.4546937\",\n \"0.45468506\",\n \"0.45435366\",\n \"0.45414248\",\n \"0.45375898\",\n \"0.45358273\",\n \"0.4535309\",\n \"0.453462\",\n \"0.45333228\",\n \"0.4532443\",\n \"0.4532011\",\n \"0.45319963\",\n \"0.45318222\",\n \"0.45254177\",\n \"0.45191607\",\n \"0.45187134\",\n \"0.4493359\",\n \"0.4488994\",\n \"0.44850743\",\n \"0.44797438\",\n \"0.44719678\",\n \"0.44709975\",\n \"0.446485\",\n \"0.44566843\",\n \"0.4454258\",\n \"0.4448934\",\n \"0.4444215\",\n \"0.4442582\",\n \"0.4441559\",\n \"0.4440375\",\n \"0.4436594\",\n \"0.44339862\",\n \"0.4433548\",\n \"0.44252804\",\n \"0.44249827\",\n \"0.4417582\",\n \"0.4411244\",\n \"0.44103143\",\n \"0.44078305\",\n \"0.4407231\",\n \"0.43904907\",\n \"0.43902022\",\n \"0.43902022\",\n \"0.4383925\",\n \"0.4380482\",\n \"0.43799642\",\n \"0.43789622\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81444484"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83798,"cells":{"query":{"kind":"string","value":"Replace the lines between the line containing ``begin`` and the line containing ``end`` (excluding both lines) in ``parent`` with ``generated``."},"document":{"kind":"string","value":"def inject_lines(parent: str, begin: Predicate, end: Predicate, generated: str) -> str:\n lines = parent.splitlines()\n\n begin_line = find_line(lines, begin)\n end_line = find_line(lines, end, begin_line+1)\n\n new_lines = lines[:begin_line+1] + generated.splitlines() + lines[end_line:]\n\n return \"\\n\".join(new_lines)"},"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 generate_new_file(file, new_content):\n with open(file, 'r') as f:\n old_content = f.read()\n\n try:\n before, begin_marker, _, end_marker, after = re.split(r'(// GENERATED-MARKER\\n)', old_content, flags=re.MULTILINE | re.DOTALL)\n except ValueError:\n raise RuntimeError(\"Failed to split {} based on markers, please make sure the file has exactly two '// GENERATED-MARKER' occurrences\".format(file))\n\n return before + begin_marker + new_content + end_marker + after","def extract_lines(parent: str, begin: Predicate, end: Predicate) -> str:\n lines = parent.splitlines()\n\n begin_line = find_line(lines, begin)\n end_line = find_line(lines, end, begin_line+1)\n\n new_lines = lines[begin_line+1:end_line]\n\n return \"\\n\".join(new_lines)","def parent_gen(self):\n yield self\n if self.parent is not None:\n yield from self.parent.parent_gen","def decorate(self, content: StringList) -> None:\n super().decorate(content)\n for line in content[:20]:\n if line.startswith(TITLE_MARKER):\n title = line[len(TITLE_MARKER) :].strip()\n fence = \"=\" * len(title)\n content.insert(0, \"\", \"<generated>\", 0)\n content.insert(0, fence, \"<generated>\", 0)\n content.insert(0, title, \"<generated>\", 0)\n content.insert(0, fence, \"<generated>\", 0)","def generate_child(self, parent1, parent2):\n if np.random.random() < self.crossover_prob:\n # crossover\n x, y = np.sort(np.random.randint(len(parent1), size=2))\n return np.vstack((parent1[:x], parent2[x:y], parent1[y:]))\n else:\n # mutation\n return self.generate_conformations()[0]","def derive(self, code_of_source: str) -> str:\n min_to_change = self.mr_config['min_to_change']\n max_to_change = self.mr_config['max_to_change']\n n_gate_to_change = random.randint(min_to_change, max_to_change)\n max_to_change = min(n_gate_to_change, self.tot_n_x_gates)\n\n sections = metamorph.get_sections(code_of_source)\n source_code_circuit = sections[\"CIRCUIT\"]\n\n x_gates_to_replace = random.sample(\n self.instruction_x_gate, max_to_change)\n\n mr_metadata = {}\n mr_metadata[\"x_gates_to_replace\"] = str(x_gates_to_replace)\n\n changed_section = source_code_circuit\n lines = source_code_circuit.split(\"\\n\")\n\n x_gates_to_replace_reverse_order = sorted(\n x_gates_to_replace, key=lambda x: x[\"lineno\"], reverse=True)\n # we start replacing gates, from the last one because each\n # substitution of an X gate makes the code longer.\n for x_gate in x_gates_to_replace_reverse_order:\n # remove gate\n edit_location = x_gate[\"lineno\"] - 1\n removed_original = lines.pop(edit_location)\n\n h_gate_last = removed_original.replace(\"XGate\", \"HGate\")\n lines.insert(edit_location, h_gate_last)\n s_gate_last = removed_original.replace(\"XGate\", \"SGate\")\n lines.insert(edit_location, s_gate_last)\n s_gate_first = removed_original.replace(\"XGate\", \"SGate\")\n lines.insert(edit_location, s_gate_first)\n h_gate_first = removed_original.replace(\"XGate\", \"HGate\")\n lines.insert(edit_location, h_gate_first)\n\n changed_section = \"\\n\".join(lines)\n\n sections[\"CIRCUIT\"] = changed_section\n\n self.metadata = mr_metadata\n\n return metamorph.reconstruct_sections(sections)","def remove_generated_parts(message):\n all_lines = []\n for line in message.split(\"\\n\"):\n if \"<generated>\" in line.lower():\n continue\n if has_stacktrace_keywords(line) or has_more_lines_pattern(line):\n continue\n for symbol in [r\"\\$\", \"@\"]:\n all_found_parts = set()\n for m in re.finditer(r\"%s+(.+?)\\b\" % symbol, line):\n found_part = m.group(1).strip().strip(symbol).strip()\n if found_part != \"\":\n all_found_parts.add((found_part, m.group(0).strip()))\n sorted_parts = sorted(list(all_found_parts), key=lambda x: len(x[1]), reverse=True)\n for found_part in sorted_parts:\n whole_found_part = found_part[1].replace(\"$\", r\"\\$\")\n found_part = found_part[0]\n part_to_replace = \"\"\n if re.search(r\"\\d\", found_part):\n part_with_numbers_in_the_end = re.search(r\"[a-zA-z]{5,}\\d+\", found_part)\n if part_with_numbers_in_the_end and part_with_numbers_in_the_end.group(0) == found_part:\n part_to_replace = \" %s\" % found_part\n else:\n part_to_replace = \"\"\n else:\n part_to_replace = \".%s\" % found_part\n try:\n line = re.sub(whole_found_part, part_to_replace, line)\n except: # noqa\n pass\n\n line = re.sub(r\"\\.+\", \".\", line)\n all_lines.append(line)\n return \"\\n\".join(all_lines)","def __iter__(self: Self) -> Iterator[str]:\n for line in heapq.merge(sorted(self.removed), sorted(self.added)):\n if line in self.removed:\n yield f\"- {line}\"\n else:\n yield f\"+ {line}\"","def update_bases_yaml_as_text(lines: List[str]) -> List[str]:\n out = []\n indent: Optional[str] = None\n done: bool = False\n for line in lines:\n print(f\"processing {line.strip()}\")\n if done:\n print(\"appending\")\n out.append(line)\n continue\n base_match = BASES_MATCH.match(line)\n if base_match:\n print(\"base matched\")\n if base_match and indent is None:\n indent = base_match[1]\n continue\n if indent is not None and not done:\n if line.startswith(indent) and len(line.strip()) != 0:\n # ignore lines that are in the base indent.\n continue\n else:\n # we've reached the end of block so replace the bases with our slot\n out.extend(BASES_LIST)\n done = True\n out.append(line)\n if done is False and indent is not None:\n out.extend(BASES_LIST)\n return out","def generate(self, diagram):","def gen_child(self, g, ng, child):\n with About(child.debug, self.relation):\n self.remap_node((g, child), g, child, ng, ng.apply())","def RewriteFile(start, end, original_dir, original_filename, snippet,\n outdir=None):\n original_path = GetPath(os.path.join(original_dir, original_filename))\n original = file(original_path, 'r')\n original_content = original.read()\n original.close()\n if outdir:\n outpath = os.path.join(outdir, original_filename)\n else:\n outpath = original_path\n out = file(outpath, 'w')\n rx = re.compile(r'%s\\n.*?%s\\n' % (re.escape(start), re.escape(end)),\n re.DOTALL)\n new_content = re.sub(rx, '%s\\n%s%s\\n' % (start, snippet, end),\n original_content)\n out.write(new_content)\n out.close()\n print 'Output ' + os.path.normpath(outpath)","def merge_lines(self, curr, new):\n\n if len(new) > 2 or new[0] != \"NOT:\":\n add = []\n for i in range(len(new)):\n if \":\" in new[i] and new[i+1] != \"{\":\n if new[i] in curr:\n ind = curr.index(new[i])+1\n curr[ind] = self.merge(curr[ind], new[i+1])\n else:\n add.append(new[i])\n add.append(new[i+1])\n if add:\n if curr[-1] == \"}\":\n curr = curr[:-1] + add + [curr[-1]]\n else:\n curr = curr + add\n else:\n curr = curr[:-1]\n return curr","def _generate_examples(self, source_file, target_file):\n with epath.Path(source_file).open() as f:\n source_sentences = f.read().split(\"\\n\")\n with epath.Path(target_file).open() as f:\n target_sentences = f.read().split(\"\\n\")\n\n assert len(target_sentences) == len(\n source_sentences\n ), \"Sizes do not match: %d vs %d for %s vs %s.\" % (\n len(source_sentences),\n len(target_sentences),\n source_file,\n target_file,\n )\n\n source, target = self.builder_config.language_pair\n for idx, (l1, l2) in enumerate(zip(source_sentences, target_sentences)):\n result = {source: l1, target: l2}\n # Make sure that both translations are non-empty.\n if all(result.values()):\n yield idx, result","def process_file(src_file, dest_file):\n # read data\n with open(src_file) as fil:\n new_data = fil.read()\n # generate a chain of templates\n parent_template = None\n current_template = dest_file\n cursor = 1\n if EXTEND_FLAG in new_data:\n new_data = new_data.replace(EXTEND_FLAG, \"\")\n while exists(current_template):\n parent_template = current_template\n current_template = \"%s%s%d\" % (dest_file, CHILD_TPL_FLAG, cursor)\n cursor += 1\n # write data\n with open(current_template, \"w\") as fil:\n if parent_template:\n # in the chain of templates each has to extend one another\n new_data = \"\\n\".join([\n \"{%% extends \\\"%s\\\" %%}\" % parent_template,\n new_data\n ])\n fil.write(new_data)","def process(self,line):\n\n pattern = re.compile(\"@.*?@\")\n matches = pattern.findall(line)\n for m in matches:\n replacement = r\"<small>{}</small>\".format(re.escape(m[1:-1]))\n line = pattern.sub(replacement,line)\n\n return line","def test_move_lines_up_into_docstring(self):\n before_b = '''\\\n #@@language python\n def test():\n \"\"\" a\n b\n c\n \"\"\"\n print 1\n \n print 2\n '''\n after_b = '''\\\n #@@language python\n def test():\n \"\"\" a\n b\n c\n print 1\n \"\"\"\n \n print 2\n '''\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"7.1\", \"7.1\"),\n after_sel=(\"6.1\", \"6.1\"),\n command_name=\"move-lines-up\",\n )","def test_commentline_relationship_unlink(create):\n clazz1 = create(ClassItem, UML.Class)\n clazz2 = create(ClassItem, UML.Class)\n gen = create(GeneralizationItem)\n\n connect(gen, gen.head, clazz1)\n connect(gen, gen.tail, clazz2)\n\n assert gen.subject\n\n # now, connect comment to a generalization (relationship)\n comment = create(CommentItem, Comment)\n line = create(CommentLineItem)\n connect(line, line.head, comment)\n connect(line, line.tail, gen)\n\n assert gen.subject in comment.subject.annotatedElement\n assert comment.subject in gen.subject.comment\n\n gen.unlink()\n\n assert not comment.subject.annotatedElement\n assert gen.subject is None","def test_commentline_relationship_disconnect(create):\n clazz1 = create(ClassItem, UML.Class)\n clazz2 = create(ClassItem, UML.Class)\n gen = create(GeneralizationItem)\n\n connect(gen, gen.head, clazz1)\n connect(gen, gen.tail, clazz2)\n\n assert gen.subject\n\n # now, connect comment to a generalization (relationship)\n comment = create(CommentItem, Comment)\n line = create(CommentLineItem)\n connect(line, line.head, comment)\n connect(line, line.tail, gen)\n\n assert gen.subject in comment.subject.annotatedElement\n assert comment.subject in gen.subject.comment\n\n disconnect(gen, gen.head)\n\n assert gen.subject is None\n assert not comment.subject.annotatedElement","def generate(self):\n self.graph_repl = self.master.graph_repl","def draw(self, parent, cr):\n for x, y in self.get_block_coords():\n parent.draw_block_element(cr, x, y)","def deduce_new_block_endings(line, hints, block_endings):\n # Reversing line (extra empty cell removed from the end and put at the end)\n newline = copy(line[-2::-1] + [-1])\n block_origins = [len(newline) - 2 - ending for ending in block_endings[::-1]]\n\n # Solving equivalent problem with reversed line\n sth_changed, block_origins = deduce_new_block_origins(newline, hints[::-1],\n block_origins)\n\n # Reversing back obtained solution\n block_endings = [len(newline) - 2 - origin for origin in block_origins[::-1]]\n\n return sth_changed, block_endings","def test_reverse_region(self):\n before_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n after_b = \"\"\"\\\n\n last line\n line c\n line b\n line a\n line 1\n first line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"7.0\"),\n after_sel=(\"7.10\", \"7.10\"),\n command_name=\"reverse-region\",\n )","def test_extend_to_line(self):\n before_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n after_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"3.3\", \"3.3\"),\n after_sel=(\"3.0\", \"3.10\"),\n command_name=\"extend-to-line\",\n )","def generate(self, lines: List[str]) -> None:\n raise NotImplemented()","def edit_pointers_in_range(self, rng, diff, allow_double_edits=False):\n # Reinserters with poiner reassignments need double edits enabled (Appareden).\n #print(\"Called edit_pointers_in_range\", self.filename, rng, diff)\n start, stop = rng\n\n if diff != 0:\n print(\"Editing pointers in range %s %s with diff %s\" % (hex(start), hex(stop), hex(diff)))\n #print(self.pointers)\n #for p in self.pointers:\n #print(hex(p))\n\n # Need to move pointers if there are any in this range\n\n if self.blocks:\n #print([hex(p) for p in range(start+1, stop+1)])\n #print([hex(p) for p in self.pointer_locations])\n for offset in [p for p in range(start+1, stop+1) if p in self.pointer_locations]:\n print(hex(offset), \"needs to be moved\")\n for p in self.pointers:\n for loc in self.pointers[p]:\n if loc.original_location == offset:\n print(\"moving %s -> %s\" % (hex(loc.location), hex(loc.location + diff)))\n loc.move_pointer_location(diff)\n #print(loc)\n self.pointer_locations.remove(offset)\n self.pointer_locations.append(offset + diff)\n #for p in self.pointers:\n # print(hex(p), self.pointers[p])\n else:\n # Don't need to move pointers if there's no block for them to be in\n pass\n\n\n for offset in [p for p in range(start+1, stop+1) if p in self.pointers]:\n print(offset, self.pointers[offset])\n for ptr in self.pointers[offset]:\n print(\"editing %s (originally %s)\" % (ptr, hex(ptr.original_location)))\n #print(hex(ptr.text_location), hex(ptr.original_text_location))\n if allow_double_edits:\n ptr.edit(diff)\n else:\n if start+1 <= ptr.original_text_location <= stop+1:\n if self.blocks:\n block_found = False\n for b in self.blocks:\n if b.start <= ptr.original_location <= b.stop:\n block_found = True\n ptr.edit(diff, block=b)\n if not block_found:\n ptr.edit(diff)\n else:\n ptr.edit(diff)\n else:\n print(\"Skipping this one to avoid double-edit\")","def annotate_entity(\n self,\n ent: Span,\n sub_preceding: List[Span],\n sub_following: List[Span],\n ) -> None:\n if self.within_ents:\n cues = [m for m in sub_preceding if m.end <= ent.end]\n cues += [m for m in sub_following if m.start >= ent.start]\n else:\n cues = [m for m in sub_preceding if m.end <= ent.start]\n cues += [m for m in sub_following if m.start >= ent.end]\n\n negation = ent._.negation or bool(cues)\n\n ent._.negation = negation\n\n if self.explain and negation:\n ent._.negation_cues += cues\n\n if not self.on_ents_only and negation:\n for token in ent:\n token._.negation = True","def ress_move_on_page(self, content=None):\n outside_ress = self.outside_ress\n content = content or self.content\n\n for blo in outside_ress:\n\n mch = re.search(r'(\\s|\\t)-block %s'%blo, content) # blo = links, onload etc\n\n if not mch:\n\n warn(blo+' block is undefined in root template %s'%self.origin.__str__()) # raise Exception(blo+' block is undefined in root template %s'%origin.__str__())\n\n super_block = r'\\t\\t={ block.super }\\n'\n content = re.sub(\n r'(-extends \"[\\w\\.]+\")\"', r'\\1\\n\\t-block %s%s%s'%(\n blo, super_block, __indent_block(r'\\t\\t', outside_ress[blo].value)\n ),\n content\n )\n\n else:\n _blo = self.__indent_block(mch.groups()[0]+' '*4, outside_ress[blo].value)\n\n # (\\s|\\t)-block \\w+(([\\s:]*={ *block.super *})|) ={ *block.super *} - \\2\n\n content = re.sub(r'(\\s|\\t)(-block %s)'%blo, r'\\1\\2\\n'+_blo, content)\n\n## _blo = _indent_block(mch.groups()[0]+' '*8, blo)\n## _blo = '\\n\\1 :javascript\\n' + _blo\n\n return content","def replace_id(self, old_id, new_id):\n def replace(prf):\n for item in prf.items:\n item.prevs = [new_id if id == old_id else id for id in item.prevs]\n if item.subproof:\n replace(item.subproof)\n\n prf = self.prf.get_parent_proof(old_id)\n replace(prf)\n\n self.remove_line(old_id)","def get_line_changed_regions(self, old_line_num, old_line,\n new_line_num, new_line):\n return \\\n super(MarkdownDiffChunkGenerator, self).get_line_changed_regions(\n old_line_num,\n strip_tags(old_line),\n new_line_num,\n strip_tags(new_line))","def extend_template(base, text):\n\n block_search = re.compile(\"{{(block) (\\w+)}}\")\n has_blocks = re.search(block_search, base)\n if not has_blocks:\n return base\n else:\n find_content = re.compile(\"({{block \"+has_blocks.group(2)+\"}})(.*?)({{endblock}})\", re.DOTALL)\n \n content = re.search(find_content, text).group(2)\n base = re.sub(\"{{block \"+has_blocks.group(2)+\"}}\", content, base)\n return extend_template(base, text)","def reconstruct_path(start, current, came_from):\n\n while current in came_from:\n current = came_from[current]\n if current != start:\n current.add_block(GOLDEN)\n pygame.display.update()","def process_SEQ(self, seq_in, original_pos, read_pos, original_end, read_end):\n if original_pos > read_end or original_end < read_pos:\n return \"Remove\"\n # By having the positions, we can address which case are we dealing with, and transform the sequence accordingly.\n if original_pos == read_pos and original_end == read_end:\n where = \"==\"\n cutoff = 0\n seq = seq_in\n elif original_pos > read_pos and original_end == read_end:\n where = \"+=\"\n cutoff = original_pos - read_pos\n seq = seq_in[cutoff:]\n elif original_pos > read_pos and original_end > read_end:\n where = \"++\"\n cutoff_init = original_pos - read_pos\n cutoff_end = original_end - read_end\n seq = seq_in[cutoff_init:] + \" \" * cutoff_end\n elif original_pos == read_pos and original_end > read_end:\n where = \"=+\"\n cutoff_end = original_end - read_end\n seq = seq_in + \" \" * cutoff_end\n elif original_pos == read_pos and original_end < read_end:\n where = \"=-\"\n cutoff_end = original_end - read_end # it will be negative\n seq = seq_in[:cutoff_end]\n elif original_pos < read_pos and original_end == read_end:\n where = \"-=\"\n cutoff_init = read_pos - original_pos\n seq = cutoff_init * \" \" + seq_in\n elif original_pos < read_pos and original_end < read_end:\n where = \"--\"\n cutoff_init = read_pos - original_pos\n cutoff_end = original_end - read_end\n seq = cutoff_init * \" \" + seq_in[:cutoff_end]\n elif original_pos > read_pos and original_end < read_end:\n where = \"+-\"\n cutoff_init = original_pos - read_pos\n cutoff_end = original_end - read_end\n seq = seq_in[cutoff_init:cutoff_end]\n elif original_pos < read_pos and original_end > read_end:\n where = \"-+\"\n cutoff_init = read_pos - original_pos\n cutoff_end = original_end - read_end\n seq = cutoff_init * \" \" + seq_in + cutoff_end * \" \"\n return seq","def modifyends(dna, left=\"\", right=\"\", add=0, add_right=0, add_left=0, supfeature=False, product=None, process_name=None, \n process_description=None, pn=None, pd=None, quinable=True, **kwargs):\n\n kwargs.setdefault(\"_sourcefile\", None) \n kwargs.setdefault(\"process_id\", None)\n kwargs.setdefault(\"original_ids\", []) \n _sourcefile = kwargs[\"_sourcefile\"] \n process_id = kwargs[\"process_id\"] \n original_ids = kwargs[\"original_ids\"]\n\n if dna._ssdna == True:\n raise TypeError(\"ssDNA object cannot be processed by `modifydna` function\") \n \n project = None\n project = project if product is None else product\n process_name = pn if process_name is None else process_name\n process_description = pd if process_description is None else process_description\n\n if dna.topology == \"circular\":\n raise ValueError(\"End sequence structures cannot be modified. The topology of the given QUEEN_object is circular.\") \n else:\n pass\n \n def parse(seq,count=0):\n l_bracket = re.compile(\"\\(\")\n r_bracket = re.compile(\"\\)\")\n l_brace = re.compile(\"\\{\")\n r_brace = re.compile(\"\\}\")\n if set(str(seq)) <= set(\"0123456789ATGCRYKMSWBDHVNatgcnrykmswbdhv{}()/-*\"):\n lbk_list = [l.start() for l in re.finditer(l_bracket,seq)]\n lbc_list = [l.start() for l in re.finditer(l_brace,seq)]\n rbc_list = [l.start() for l in re.finditer(r_brace,seq)]\n rbk_list = []\n for bk in lbk_list:\n n = 0\n p = bk\n for c in seq[bk:]:\n if c == \"(\":\n n += 1\n elif c == \")\":\n n -= 1\n if n == 0:\n rbk_list.append(p)\n break\n p += 1\n \n if len(lbk_list) == len(rbk_list):\n bk_set = list(zip(lbk_list,rbk_list))\n bc_set = list(zip(lbc_list,rbc_list))\n if len(bk_set) > 0:\n for bks in bk_set:\n new_seq = seq[bks[0]+1:bks[1]] \n if \"(\" not in new_seq: \n num = 0\n flag = 0\n sub_lbc_list = [l.start() for l in re.finditer(l_brace,new_seq)]\n sub_rbc_list = [l.start() for l in re.finditer(r_brace,new_seq)]\n sub_bc_set = list(zip(sub_lbc_list, sub_rbc_list))\n new_new_seq = new_seq\n sub_bc_set.sort()\n for bcs in sub_bc_set:\n try:\n num = int(new_seq[bcs[0]+1:bcs[1]])\n except:\n return False\n if num > 0:\n new_new_seq = new_new_seq[:new_new_seq.find(\"{\")-1] + new_seq[bcs[0]-1] * num + new_seq[bcs[1]+1:] \n else:\n pass\n new_seq = new_new_seq\n num = 0\n for bcs in bc_set:\n if bcs[0] == bks[1]+1:\n try:\n num = int(seq[bcs[0]+1:bcs[1]])\n except:\n return False\n break\n else:\n pass\n if num > 0:\n new_seq = new_seq * num\n else:\n pass\n break\n else:\n pass\n new_seq = seq[:bks[0]] + new_seq + seq[bcs[1]+1:]\n \n else:\n new_seq = seq\n bc_set.sort()\n for bcs in bc_set:\n try:\n num = int(seq[bcs[0]+1:bcs[1]])\n except:\n return False\n if num > 0:\n new_seq = new_seq[:new_seq.find(\"{\")-1] + seq[bcs[0]-1] * num + seq[bcs[1]+1:] \n else:\n pass\n \n if set(str(new_seq)) <= set(\"ATGCRYKMSWBDHVNatgcnrykmswbdhv/-*\"):\n pass\n else:\n new_seq = parse(new_seq,count+1)\n return new_seq\n else:\n return False\n else:\n return False\n \n def check_endseq(top, bottom):\n #Check if the top strand seqeunce is complement with the bottom strand. \n new_top = \"\"\n new_bottom = \"\"\n for t,b in zip(top,bottom):\n if t != b.translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")) and (t != \"-\" and b != \"-\"):\n return False, False\n new_top += t\n new_bottom += b\n return new_top, new_bottom\n \n if left == \"\":\n left = \"*/*\"\n \n if right == \"\":\n right = \"*/*\"\n \n left_origin, right_origin = left, right\n left, right = parse(left.upper()), parse(right.upper())\n left, rihgt = str(left), str(right) \n pattern1, pattern2, patternl1, patternl2, patternr1, patternr2 = \"[ATGCRYKMSWBDHVN*-]*/?[ATGCRYKMSWBDHVN*-]*\", \"[ATGCRYKMSWBDHVN*]+-+[ATGCRYKMSWBDHVN*]+\", \"^[ATGCRYKMSWBDHVN*]+-+/\", \"/[ATGCRYKMSWBDHVN*]+-+$\", \"^-+[ATGCRYKMSWBDHVN*]+/\", \"/-+[ATGCRYKMSWBDHVN*]+$\" \n pattern1 = re.compile(pattern1) \n pattern2 = re.compile(pattern2) \n patternl1 = re.compile(patternl1)\n patternl2 = re.compile(patternl2)\n patternr1 = re.compile(patternr1)\n patternr2 = re.compile(patternr2)\n left_end, right_end = left, right\n \n if pattern1.fullmatch(left_end) != None and pattern2.search(left_end) is None and patternl1.search(left_end) is None and patternl2.search(left_end) is None:\n pass \n else:\n raise TypeError(\"Please sepcify a proper sequence pattern for the 'left' argument\") \n \n if pattern1.fullmatch(right_end) != None and pattern2.search(right_end) is None and patternr1.search(right_end) is None and patternr2.search(right_end) is None:\n pass\n else:\n raise TypeError(\"Please sepcify a proper sequence pattern for the 'right' argument\") \n \n if \"/\" in left_end:\n left_end_top, left_end_bottom = left_end.split(\"/\")\n else:\n add = 1\n add_left = 1\n left_end_top, left_end_bottom = left_end, left_end.translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\"))\n left_end = left_end_top + \"/\" + left_end_bottom\n\n if len(left_end_top) != len(left_end_bottom):\n raise ValueError(\"Please specify a proper end sequence structure for the 'left' argument.\")\n \n elif \"-\" in left_end or \"*\" in left_end:\n left_end_top, left_end_bottom = check_endseq(left_end_top, left_end_bottom)\n if left_end_top != False:\n left_end_length = len(left_end_top)\n if \"*\" in left_end_top or \"*\" in left_end_bottom:\n if set(left_end_top) <= set([\"*\",\"-\"]) and set(left_end_bottom) <= set([\"*\",\"-\"]):\n left_end_top = \"\".join([s if q != \"-\" else \"-\" for s,q in zip(dna.seq[:left_end_length], left_end_top)])\n left_end_bottom = \"\".join([s if q != \"-\" else \"-\" for s,q in zip(dna.seq[:left_end_length].translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")), left_end_bottom)])\n else:\n raise ValueError(\"'*' cannot be used wih IUPAC nucleotide codes\")\n \n left_end_top, left_end_bottom = left_end_top.replace(\"-\",\"\"), left_end_bottom.replace(\"-\",\"\") \n if len(left_end_top) < len(left_end_bottom):\n left_length = len(left_end_bottom)\n left_end = left_end_bottom[0:len(left_end_bottom)-1*len(left_end_top)].translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")) \n left_end_top = -1\n left_end_bottom = 1\n\n elif len(left_end_top) > len(left_end_bottom):\n left_length = len(left_end_top)\n left_end = left_end_top[0:len(left_end_top)-1*len(left_end_bottom)]\n left_end_top = 1\n left_end_bottom = -1\n \n else:\n left_length = len(left_end_top)\n left_end = left_end_top[0:len(left_end_top)-1*len(left_end_bottom)]\n left_end_top = 1\n left_end_bottom = 1\n else:\n add = 1\n add_left = 1\n left_end = left_end_top + \"/\" + left_end_bottom\n\n else:\n raise ValueError(\"Please specify a proper end sequence structure for the 'left' argument.\")\n else:\n left_end_length = len(left_end_top) \n left_length = len(left_end_top)\n left_end_top = 1\n left_end_bottom = 1\n\n if \"/\" in right_end:\n right_end_top, right_end_bottom = right_end.split(\"/\")\n else:\n add = 1\n add_right = 1 \n right_end_top, right_end_bottom = right_end, right_end.translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\"))\n right_end = right_end_top + \"/\" + right_end_bottom\n \n if len(right_end_top) != len(right_end_bottom):\n raise ValueError(\"Please specify a proper end sequence structure for the 'right' argument.\")\n \n elif \"-\" in right_end or \"*\" in right_end:\n right_end_top, right_end_bottom = check_endseq(right_end_top, right_end_bottom)\n if right_end_top != False:\n right_end_length = len(right_end_top)\n if \"*\" in right_end_top or \"*\" in right_end_bottom:\n if set(right_end_top) <= set([\"*\",\"-\"]) and set(right_end_bottom) <= set([\"*\",\"-\"]):\n right_end_top = \"\".join([s if q != \"-\" else \"-\" for s,q in zip(dna.seq[-1*right_end_length:], right_end_top)])\n right_end_bottom = \"\".join([s if q != \"-\" else \"-\" for s,q in zip(dna.seq[-1*right_end_length:].translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")), right_end_bottom)])\n else:\n raise ValueError(\"'*' cannot be used wih characters for DNA sequence.\")\n\n right_end_top, right_end_bottom = right_end_top.replace(\"-\",\"\"), right_end_bottom.replace(\"-\",\"\") \n if len(right_end_top) < len(right_end_bottom):\n right_length = len(right_end_bottom)\n right_end = right_end_bottom[len(right_end_top):].translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")) \n right_end_top = -1\n right_end_bottom = 1\n\n elif len(right_end_top) > len(right_end_bottom):\n right_length = len(right_end_top)\n right_end = right_end_top[len(right_end_bottom):] \n right_end_top = 1\n right_end_bottom = -1\n \n else:\n right_length = len(right_end_top)\n right_end = right_end_top[len(right_end_bottom):] \n right_end_top = 1\n right_end_bottom = 1\n else:\n add = 1\n add_right = 1 \n right_end = right_end_top + \"/\" + right_end_bottom\n\n else:\n raise ValueError(\"Please specify a proper end sequence structure for the 'right' argument.\")\n else:\n right_end_length = len(right_end_top) \n right_length = len(right_end_top) \n right_end_top = 1\n right_end_bottom = 1\n \n if add == 1 or (left_end != dna.seq[left_end_length-left_length:left_end_length-left_length+len(left_end)] \n or right_end != str(dna[len(dna.seq)-right_end_length + right_length - len(right_end):len(dna.seq)-right_end_length + right_length].seq)):\n \n if add_left == 1 and add_right == 1:\n new_dna = dna.__class__(seq=left_end.split(\"/\")[0] + dna.seq + right_end.split(\"/\")[0] + \"/\" \n + left_end.split(\"/\")[1] + dna.seq.translate(str.maketrans(\"ATGCRYKMSWBDHV\",\"TACGYRMKWSVHDB\")) + right_end.split(\"/\")[1], quinable=0) \n new_dna._dnafeatures = _slide(dna.dnafeatures, len(left_end.split(\"/\")[0])) \n new_dna.record = copy.copy(dna.record) \n new_dna.record.features = new_dna.dnafeatures\n new_dna._positions = (-1,) * len(left_end.split(\"/\")[0]) + new_dna._positions + (-1,) * len(right_end.split(\"/\")[0])\n \n \n elif add_right == 1:\n left_end = dna.__class__(seq=left_end, quinable=0) \n right_end = dna.__class__(seq=right_end, quinalbe=0) \n new_dna = cropdna(dna, start=left_end_length-left_length, end=len(dna.seq), quinable=0) + right_end\n new_dna._right_end = right_end._right_end\n new_dna._left_end = left_end.seq\n new_dna._left_end_top = left_end_top \n new_dna._left_end_bottom = left_end_bottom\n new_dna._positions = new_dna._positions + (-1,) * len(right_end.seq)\n \n else:\n left_end = dna.__class__(seq=left_end, quinable=0) \n right_end = dna.__class__(seq=right_end, quinable=0) \n new_dna = left_end + cropdna(dna, start=0, end=len(dna.seq)-right_end_length+right_length, quinable=0)\n new_dna._left_end = left_end._left_end\n new_dna._right_end = right_end.seq\n new_dna._right_end_top = right_end_top \n new_dna._right_end_bottom = right_end_bottom\n new_dna._positions = (-1,) * len(left_end.seq) + new_dna._positions\n \n if type(left_origin) == new_dna.seq.__class__ and left_origin.parental_class == \"QUEEN\": \n parental_id = left_origin.parental_id\n tmp_left = None\n if left_origin.name is not None: \n if left_origin.name == \"rcseq\":\n tmp_left = flipdna(left_origin.parent, quinable==0) \n else:\n tmp_left = None\n else:\n tmp_left = left_origin.parent\n \n if tmp_left is not None:\n new_dna._dnafeatures = tmp_left.dnafeatures + new_dna._dnafeatures\n\n if type(right_origin) == new_dna.seq.__class__ and right_origin.parental_class == \"QUEEN\": \n parental_id = right_origin.parental_id\n tmp_right = None\n if right_origin.name is not None: \n if right_origin.name == \"rcseq\":\n tmp_right = flipdna(right_origin.parent, quinable==0) \n else:\n tmp_right = None\n else:\n tmp_right = right_origin.parent\n\n if tmp_right is not None:\n new_dna._dnafeatures += _slide(tmp_right.dnafeatures, len(left_end.split(\"/\")[0]) + len(dna.seq))\n \n new_dna._history_feature = dna._history_feature \n \n #Recover fragmented features if complete sequence is in the construct.\n new_features = [] \n remove_features = [] \n for feat in new_dna.dnafeatures:\n if \"broken_feature\" in feat.qualifiers:\n note = feat.qualifiers[\"broken_feature\"][0]\n label = \":\".join(note.split(\":\")[:-1])\n poss, pose = list(map(int,note.split(\":\")[-1].split(\"..\")))\n length = int(note.split(\":\")[-4]) \n if feat.location.strand != -1:\n sfeat = feat.start-(poss-1) \n sfeat = sfeat if sfeat > 0 else len(new_dna.seq) + sfeat\n efeat = feat.end+(length-pose)\n else:\n sfeat = feat.start-(length-pose) \n sfeat = sfeat if sfeat > 0 else len(new_dna.seq) + sfeat\n efeat = feat.end+(poss-1) \n \n if note.split(\":\")[-3] == new_dna.printsequence(sfeat, efeat, strand=feat.location.strand):\n if sfeat < efeat:\n location = FeatureLocation(sfeat, efeat, feat.location.strand) \n else:\n location = CompoundLocation([FeatureLocation(sfeat, len(new_dna.seq)), FeatureLocation(0, efeat, feat.location.strand)]) \n newfeat = feat.__class__(location=location, subject=new_dna)\n newfeat.type = feat.type\n newfeat.qualifiers = feat.qualifiers\n del newfeat.qualifiers[\"broken_feature\"]\n newfeat._id = label.split(\":\")[1]\n new_features.append(newfeat)\n remove_features.append(feat)\n \n for feat in remove_features:\n del new_dna._dnafeatures[new_dna.dnafeatures.index(feat)] \n \n for feat in new_features:\n new_dna._dnafeatures.append(feat) \n else:\n new_dna = copy.deepcopy(dna) \n new_dna._left_end = left_end\n new_dna._right_end = right_end\n new_dna._left_end_top = left_end_top \n new_dna._left_end_bottom = left_end_bottom\n new_dna._right_end_top = right_end_top\n new_dna._right_end_bottom = right_end_bottom\n \n if project is None:\n new_dna._unique_id = dna._unique_id \n else:\n new_dna._unique_id = project\n \n if type(supfeature) in (tuple, list) and type(supfeature[0]) == dict:\n for feature_dict in supfeature: \n new_dna.setfeature(feature_dict) \n elif type(supfeature) == dict:\n new_dna.setfeature(supfeature)\n \n if quinable == True:\n args = [] \n history_features = [new_dna._history_feature] \n args.append(\"'{}'\".format(new_dna._unique_id))\n args.append(\"'{}'\".format(dna._unique_id)) \n ends = [] \n if type(left_origin) == new_dna.seq.__class__:\n if left_origin.parental_class == \"DNAFeature\":\n qkey = left_origin.qkey\n for qindex, qfeat in enumerate(new_dna.__class__.queried_features_dict[qkey]):\n if qfeat._second_id == left_origin.parental_id:\n break\n if type(left_origin.item) == int:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].{}[{}]\".format(qkey, qindex, \"seq\" , left_origin.item))\n elif type(left_origin.item) == slice:\n sl_start = left_origin.item.start\n sl_stop = left_origin.item.stop \n sl_step = left_origin.item.step\n sl_start = \"\" if sl_start is None else sl_start\n sl_stop = \"\" if sl_stop is None else sl_stop\n if sl_step == 1 or sl_step == None:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}]\".format(qkey, qindex, sl_start, sl_stop))\n else:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}:{}]\".format(qkey, qindex, sl_start, sl_stop, sl_step))\n else:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq\".format(qkey, qindex))\n history_features.append(left_origin.parent.subject._history_feature) \n\n elif left_origin.parental_class == \"QUEEN\": \n parental_id = left_origin.parental_id\n\n if left_origin.name != None: \n if \"printsequence\" in left_origin.name:\n if len(left_origin.name.split(\"_\")) == 2: \n seqname = \"QUEEN.dna_dict['{}'].printsequence(strand={})\".format(parental_id, left_origin.name.split(\"_\")[-1]) \n else:\n seqname = \"QUEEN.dna_dict['{}'].printsequence(start={}, end={}, strand={})\".format(parental_id, *left_origin.name.split(\"_\")[1:])\n elif lefet_origin.name == \"rcseq\":\n seqname = \"QUEEN.dna_dict['{}'].rcseq\".format(parental_id) \n else:\n seqname = \"QUEEN.dna_dict['{}'].seq\".format(parental_id)\n\n if type(left_origin.item) == int:\n args.append(\"{}.seq[{}]\".format(seqname, left_origin.item))\n elif type(left_origin.item) == slice:\n sl_start = left_origin.item.start\n sl_stop = left_origin.item.stop \n sl_step = left_origin.item.step\n sl_start = \"\" if sl_start is None else sl_start\n sl_stop = \"\" if sl_stop is None else sl_stop\n if sl_step == 1 or sl_step == None:\n args.append(\"{}[{}:{}]\".format(seqname, sl_start, sl_stop))\n else:\n args.append(\"{}[{}:{}:{}]\".format(seqname, sl_start, sl_stop, sl_step))\n else:\n args.append(\"{}\".format(seqname))\n history_features.append(left_origin.parent._history_feature) \n \n elif left_origin.parental_class == \"Cutsite\":\n if left_origin.parent.name not in cs.defaultkeys:\n cs.new_cutsites.append((left_origin.parent.name, left_origin.parent.cutsite)) \n args.append(\"cs.lib['{}'].{}\".format(left_origin.parent.name, left_origin.name)) \n else:\n args.append(\"'{}'\".format(left_origin)) \n ends.append(left) \n else:\n ends.append(left_origin) \n args.append(\"'{}'\".format(left_origin)) \n \n if type(right_origin) == new_dna.seq.__class__:\n if right_origin.parental_class == \"DNAFeature\":\n qkey = right_origin.qkey\n for qindex, qfeat in enumerate(new_dna.__class__.queried_features_dict[qkey]):\n if qfeat._second_id == right_origin.parental_id:\n break\n if type(right_origin.item) == int:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].{}[{}]\".format(qkey, qindex, \"seq\" , right_origin.item))\n elif type(right_origin.item) == slice:\n sl_start = right_origin.item.start \n sl_stop = right_origin.item.stop \n sl_step = right_origin.item.step\n sl_start = \"\" if sl_start is None else sl_start\n sl_stop = \"\" if sl_stop is None else sl_stop\n if sl_step == 1 or sl_step == None:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}]\".format(qkey, qindex, sl_start, sl_stop))\n else:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}:{}]\".format(qkey, qindex, sl_start, sl_stop, sl_step))\n else:\n args.append(\"QUEEN.queried_features_dict['{}'][{}].seq\".format(qkey, qindex))\n history_features.append(right_origin.parent.subject._history_feature) \n\n elif right_origin.parental_class == \"QUEEN\": \n parental_id = right_origin.parental_id\n \n if right_origin.name != None: \n if \"printsequence\" in right_origin.name:\n if len(right_origin.name.split(\"_\")) == 2: \n seqname = \"QUEEN.dna_dict['{}'].printsequence(strand={})\".format(parental_id, right_origin.name.split(\"_\")[-1]) \n else:\n seqname = \"QUEEN.dna_dict['{}'].printsequence(start={}, end={}, strand={})\".format(parental_id, *right_origin.name.split(\"_\")[1:])\n elif right_origin.name == \"rcseq\":\n seqname = \"QUEEN.dna_dict['{}'].rcseq\".format(parental_id) \n else:\n seqname = \"QUEEN.dna_dict['{}'].seq\".format(parental_id)\n \n if type(right_origin.item) == int:\n args.append(\"{}[{}]\".format(seqname, right_origin.item))\n \n elif type(right_origin.item) == slice:\n sl_start = right_origin.item.start\n sl_stop = right_origin.item.stop \n sl_step = right_origin.item.step\n sl_start = \"\" if sl_start is None else sl_start\n sl_stop = \"\" if sl_stop is None else sl_stop\n if sl_step == 1 or sl_step == None:\n args.append(\"{}[{}:{}]\".format(seqname, sl_start, sl_stop))\n else:\n args.append(\"{}[{}:{}:{}]\".format(seqname, sl_start, sl_stop, sl_step))\n else:\n args.append(\"{}\".format(seqname))\n history_features.append(right_origin.parent._history_feature) \n \n elif right_origin.parental_class == \"Cutsite\":\n if right_origin.parent.name not in cs.defaultkeys:\n cs.new_cutsites.add((right_origin.parent.name, right_origin.parent.cutsite)) \n args.append(\"cs.lib['{}'].{}\".format(right_origin.parent.name, right_origin.name)) \n\n else:\n args.append(\"'{}'\".format(right_origin)) \n ends.append(right)\n else:\n ends.append(right_origin) \n args.append(\"'{}'\".format(right_origin)) \n\n project = \"\" \n fsupfeature = \"\" if supfeature == False else \", supfeature={}\".format(str(supfeature)) \n fproduct = \"\" if product is None else \", product='\" + product + \"'\"\n process_name = \"\" if process_name is None else \", process_name='\" + process_name + \"'\"\n process_description = \"\" if process_description is None else \", process_description='\" + process_description + \"'\" \n\n new_dna._product_id = new_dna._unique_id if product is None else product \n building_history = \"QUEEN.dna_dict['{}'] = modifyends(QUEEN.dna_dict['{}'], left={}, right={}{}{}{}{}{})\".format(new_dna._product_id, dna._product_id, args[2], args[3], fsupfeature, project, fproduct, process_name, process_description) \n history_feature = _combine_history(new_dna, history_features) \n new_dna._history_feature = history_feature\n process_id, original_ids = make_processid(new_dna, building_history, process_id, original_ids)\n add_history(new_dna, [building_history, \"left: {}; right: {}; leftobj: {}; rightobj: {}\".format(*ends, args[2], args[3]), \",\".join([process_id] + original_ids)], _sourcefile) \n new_dna._check_uniqueness()\n else:\n new_dna.__dict__[\"_product_id\"] = dna._product_id if \"_product_id\" in dna.__dict__ else dna._unique_id\n\n for dnafeature in new_dna.dnafeatures:\n dnafeature.subject = new_dna\n \n if product is None:\n pass \n else:\n product = product.replace(\" \",\"\")\n match = re.fullmatch(\"(.+)\\[(.+)\\]\", product)\n if match:\n if match.group(2).isdecimal() == True:\n new_dna.__class__._namespace[match.group(1)][int(match.group(2))] = new_dna\n else:\n new_dna.__class__._namespace[match.group(1)][match.group(2)] = new_dna\n else: \n new_dna.__class__._namespace[product] = new_dna\n return new_dna","def generateCommentBlock(self):\n\t\tself.printt_cls(\"# ===================================================================\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# WARNING: This is an auto-generated file. Do not modify this file.\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# ===================================================================\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"#\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# {} Model\".format(self.objName), cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"#\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# ===================================================================\", cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# Generated on: {ts}\".format(ts = str(datetime.now())), cs.PASTEL_YELLOW)\n\t\tself.printt_cls(\"# ===================================================================\", cs.PASTEL_YELLOW)","def GenerateDiff(self, args):\n raise NotImplementedError(\n \"abstract method -- subclass %s must override\" % self.__class__)","def generate_output(input_filename: str, output_filename: str, goal_node: Node,\n generated: set) -> None:\n\n input_stream = io.open(input_filename, 'r', encoding='utf-8', errors='ignore',\n newline='\\n')\n with open(output_filename, 'w') as out_file:\n for i in range(0, 10):\n out_file.write(input_stream.readline().rstrip())\n out_file.write('\\n')\n \"\"\" The first ten lines of the output file are identical to those in the \n input file. The tenth line should be skipped because it's blank.\"\"\"\n out_file.write(str(goal_node.path_cost) + '\\n')\n # Line 11 of the output, the depth level d\n out_file.write(str(len(generated)) + '\\n')\n # Line 12 of the output, the total number of nodes generated\n\n # Writing Line 13 of the output, the sequence of moves\n length = len(goal_node.path_history)\n for i in range(length - 1):\n out_file.write(goal_node.path_history[i] + ' ')\n out_file.write(goal_node.path_history[length - 1] + '\\n')\n\n # Writing Line 14 of the output, the f(n) values\n f_line = str(goal_node.f) + ' '\n parent = goal_node.parent\n while parent: # Loop stops when parent == None\n f_line += (str(parent.f) + ' ')\n parent = parent.parent\n f_list = f_line.split(' ')\n # Breaks down the string to the integers it contains\n reverse = ''\n for i in range(len(f_list) - 2, -1, -1):\n # f_line[len(f_line)-1] is an extra whitespace character and\n # thus shouldn't be copied\n reverse += str(f_list[i])\n if i != 0:\n reverse += ' '\n \"\"\" The order of the f(n) values in f_line is from goal node \n to root node. The four lines above reverse the order, which \n is what the output format expects.\"\"\"\n out_file.write(reverse)\n\n out_file.close()","def translate(self):\n self.get_t_sect()[\n 'datetime_start'] = datetime.datetime.now().isoformat()\n seen_noncomment = False\n parsing_gate = False\n gate_def = ''\n gate_start_line = None\n gate_start_linenum = None\n seen_open_curly = False\n\n while self.source_frame_stack.depth():\n filenum, linenum, line = self.source_frame_stack.next()\n if line is None:\n self.source_frame_stack.pop()\n continue\n astElement = None\n line = line.strip()\n line = line.replace(', ', ',')\n line = line.replace(' ;', ';')\n eolComment = ASTType.ast_eol_comment(line)\n\n if parsing_gate:\n if not seen_open_curly:\n x = QTRegEx.START_CURLY.search(line)\n if not x:\n raise Qasm_Gate_Missing_Open_Curly_Exception(filenum,\n self.get_nth_filepath(\n filenum),\n linenum,\n gate_start_line,\n gate_start_linenum)\n else:\n seen_open_curly = True\n gate_def = gate_def + line + ' '\n x = QTRegEx.END_CURLY.search(line)\n if x:\n self.user_gate_definition(\n gate_start_linenum, gate_def)\n parsing_gate = False\n gate_def = ''\n gate_start_line = None\n gate_start_linenum = None\n seen_open_curly = False\n else:\n gate_def = gate_def + line + ' '\n x = QTRegEx.END_CURLY.search(line)\n if x:\n self.user_gate_definition(\n filenum, gate_start_linenum, gate_def)\n parsing_gate = False\n gate_def = ''\n gate_start_line = None\n gate_start_linenum = None\n seen_open_curly = False\n\n continue\n\n astElement = ASTElementUnknown(filenum, linenum, line)\n astType = ASTType.astType(line)\n if astType == ASTType.BLANK:\n continue\n if not seen_noncomment and astType != ASTType.COMMENT:\n if astType == ASTType.DECLARATION_QASM_2_0:\n seen_noncomment = True\n else:\n raise Qasm_Declaration_Absent_Exception(\n filenum, self.get_nth_filepath(filenum), linenum, line)\n\n # Now step thru types\n if astType == ASTType.COMMENT:\n astElement = ASTElementComment(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n elif astType == ASTType.DECLARATION_QASM_2_0:\n astElement = ASTElementDeclarationQasm2_0(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n if astType == ASTType.INCLUDE:\n astElement = ASTElementInclude(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n self.push_include(astElement.out()['include'])\n elif astType == ASTType.CTL_2:\n astElement = ASTElementCtl2(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n elif astType == ASTType.QREG:\n astElement = ASTElementQReg(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n elif astType == ASTType.CREG:\n astElement = ASTElementCReg(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n elif astType == ASTType.MEASURE:\n astElement = ASTElementMeasure(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n elif astType == ASTType.BARRIER:\n astElement = ASTElementBarrier(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n\n elif astType == ASTType.GATE:\n if self.show_gate_decls:\n astElement = ASTElementGateDefinitionPlaceholder(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n self.append_ast(astElement.out())\n parsing_gate = True\n gate_start_line = line\n gate_start_linenum = linenum\n gate_def = line + ' '\n x = QTRegEx.START_CURLY.search(line)\n if x:\n seen_open_curly = True\n x = QTRegEx.END_CURLY.search(line)\n if x:\n self.user_gate_definition(\n filenum, gate_start_linenum, gate_def)\n parsing_gate = False\n gate_def = ''\n gate_start_line = None\n gate_start_linenum = None\n seen_open_curly = False\n continue\n\n elif astType == ASTType.OP:\n astElement = ASTElementOp(\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\n if type(astElement) is ASTElementUnknown and self.no_unknown:\n raise Qasm_Unknown_Element_Exception(filenum,\n self.get_nth_filepath(\n filenum),\n linenum,\n line)\n self.append_ast(astElement.out())\n\n if parsing_gate:\n raise Qasm_Incomplete_Gate_Exception(\n filenum,\n self.get_nth_filepath(filenum),\n linenum,\n gate_start_line,\n gate_start_linenum)\n\n self.t_sect.t_sect['datetime_finish'] = datetime.datetime.now(\n ).isoformat()","def test_reformat_paragraph_new_code_4_of_8(self):\n before_b = \"\"\"\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 11.\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n after_b = \"\"\"\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 11.\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"1.0\"),\n after_sel=(\"3.0\", \"3.0\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def iter_patches(self, templated_file: TemplatedFile) -> Iterator[FixPatch]:\n # Does it match? If so we can ignore it.\n assert self.pos_marker\n templated_raw = templated_file.templated_str[self.pos_marker.templated_slice]\n matches = self.raw == templated_raw\n if matches:\n # First yield any source fixes\n yield from self._iter_source_fix_patches(templated_file)\n # Then return.\n return\n\n # If we're here, the segment doesn't match the original.\n linter_logger.debug(\n \"# Changed Segment Found: %s at %s: Original: [%r] Fixed: [%r]\",\n type(self).__name__,\n self.pos_marker.templated_slice,\n templated_raw,\n self.raw,\n )\n\n # If it's all literal, then we don't need to recurse.\n if self.pos_marker.is_literal():\n # First yield any source fixes\n yield from self._iter_source_fix_patches(templated_file)\n # Then yield the position in the source file and the patch\n yield FixPatch(\n source_slice=self.pos_marker.source_slice,\n templated_slice=self.pos_marker.templated_slice,\n patch_category=\"literal\",\n fixed_raw=self.raw,\n templated_str=templated_file.templated_str[\n self.pos_marker.templated_slice\n ],\n source_str=templated_file.source_str[self.pos_marker.source_slice],\n )\n # Can we go deeper?\n elif not self.segments:\n # It's not literal, but it's also a raw segment. If we're going\n # to yield a change, we would have done it from the parent, so\n # we just abort from here.\n return # pragma: no cover TODO?\n else:\n # This segment isn't a literal, but has changed, we need to go deeper.\n\n # If there's an end of file segment or indent, ignore them just for the\n # purposes of patch iteration.\n # NOTE: This doesn't mutate the underlying `self.segments`.\n segments = self.segments\n while segments and segments[-1].is_type(\"end_of_file\", \"indent\"):\n segments = segments[:-1]\n\n # Iterate through the child segments\n source_idx = self.pos_marker.source_slice.start\n templated_idx = self.pos_marker.templated_slice.start\n insert_buff = \"\"\n for segment in segments:\n # First check for insertions.\n # At this stage, everything should have a position.\n assert segment.pos_marker\n # We know it's an insertion if it has length but not in the templated\n # file.\n if segment.raw and segment.pos_marker.is_point():\n # Add it to the insertion buffer if it has length:\n if segment.raw:\n insert_buff += segment.raw\n linter_logger.debug(\n \"Appending insertion buffer. %r @idx: %s\",\n insert_buff,\n templated_idx,\n )\n continue\n\n # If we get here, then we know it's an original. Check for deletions at\n # the point before this segment (vs the TEMPLATED).\n # Deletions in this sense could also mean source consumption.\n start_diff = segment.pos_marker.templated_slice.start - templated_idx\n\n # Check to see whether there's a discontinuity before the current\n # segment\n if start_diff > 0 or insert_buff:\n # If we have an insert buffer, then it's an edit, otherwise a\n # deletion.\n\n # For the start of the next segment, we need the position of the\n # first raw, not the pos marker of the whole thing. That accounts\n # better for loops.\n first_segment_pos = segment.raw_segments[0].pos_marker\n yield FixPatch(\n # Whether the source slice is zero depends on the start_diff.\n # A non-zero start diff implies a deletion, or more likely\n # a consumed element of the source. We can use the tracking\n # markers from the last segment to recreate where this element\n # should be inserted in both source and template.\n source_slice=slice(\n source_idx,\n first_segment_pos.source_slice.start,\n ),\n templated_slice=slice(\n templated_idx,\n first_segment_pos.templated_slice.start,\n ),\n patch_category=\"mid_point\",\n fixed_raw=insert_buff,\n templated_str=\"\",\n source_str=\"\",\n )\n\n insert_buff = \"\"\n\n # Now we deal with any changes *within* the segment itself.\n yield from segment.iter_patches(templated_file=templated_file)\n\n # Once we've dealt with any patches from the segment, update\n # our position markers.\n source_idx = segment.pos_marker.source_slice.stop\n templated_idx = segment.pos_marker.templated_slice.stop\n\n # After the loop, we check whether there's a trailing deletion\n # or insert. Also valid if we still have an insertion buffer here.\n end_diff = self.pos_marker.templated_slice.stop - templated_idx\n if end_diff or insert_buff:\n source_slice = slice(\n source_idx,\n self.pos_marker.source_slice.stop,\n )\n templated_slice = slice(\n templated_idx,\n self.pos_marker.templated_slice.stop,\n )\n # We determine the source_slice directly rather than\n # inferring it so that we can be very specific that\n # we ensure that fixes adjacent to source-only slices\n # (e.g. {% endif %}) are placed appropriately relative\n # to source-only slices.\n yield FixPatch(\n source_slice=source_slice,\n templated_slice=templated_slice,\n patch_category=\"end_point\",\n fixed_raw=insert_buff,\n templated_str=templated_file.templated_str[templated_slice],\n source_str=templated_file.source_str[source_slice],\n )","def deleteComments(self: Self, event: Event = None) -> None:\n #@+<< deleteComments docstring >>\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\n #@@pagewidth 50\n #@-<< deleteComments docstring >>\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\n #\n # \"Before\" snapshot.\n bunch = u.beforeChangeBody(p)\n #\n # Initial data.\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\n if not lines:\n g.warning('no text selected')\n return\n # The default language in effect at p.\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\n if c.hasAmbiguousLanguage(p):\n language = c.getLanguageAtCursor(p, language)\n d1, d2, d3 = g.set_delims_from_language(language)\n #\n # Calculate the result.\n changed, result = False, []\n if d1:\n # Remove the single-line comment delim in front of each line\n d1b = d1 + ' '\n n1, n1b = len(d1), len(d1b)\n for s in lines:\n i = g.skip_ws(s, 0)\n if g.match(s, i, d1b):\n result.append(s[:i] + s[i + n1b :])\n changed = True\n elif g.match(s, i, d1):\n result.append(s[:i] + s[i + n1 :])\n changed = True\n else:\n result.append(s)\n else:\n # Remove the block comment delimiters from each line.\n n2, n3 = len(d2), len(d3)\n for s in lines:\n i = g.skip_ws(s, 0)\n j = s.find(d3, i + n2)\n if g.match(s, i, d2) and j > -1:\n first = i + n2\n if g.match(s, first, ' '):\n first += 1\n last = j\n if g.match(s, last - 1, ' '):\n last -= 1\n result.append(s[:i] + s[first:last] + s[j + n3 :])\n changed = True\n else:\n result.append(s)\n if not changed:\n return\n #\n # Set p.b and w's text first.\n middle = ''.join(result)\n p.b = head + middle + tail # Sets dirty and changed bits.\n w.setAllText(head + middle + tail)\n #\n # Set the selection range and scroll position.\n i = len(head)\n j = ins = max(i, len(head) + len(middle) - 1)\n w.setSelectionRange(i, j, insert=ins)\n w.setYScrollPosition(oldYview)\n #\n # \"after\" snapshot.\n u.afterChangeBody(p, 'Indent Region', bunch)","def __generatorFinished(self):\n QApplication.restoreOverrideCursor()\n self.refreshButton.setEnabled(True)\n \n diff1, diff2, errors, fileSeparators = self.__diffGenerator.getResult()\n \n if diff1:\n self.contents.setPlainText(\"\".join(diff1))\n else:\n self.contents.setPlainText(\n self.tr('There is no difference.'))\n \n if diff2:\n self.contents2.setPlainText(\"\".join(diff2))\n else:\n self.contents2.setPlainText(\n self.tr('There is no difference.'))\n \n if errors:\n self.errorGroup.show()\n self.errors.setPlainText(errors)\n self.errors.ensureCursorVisible()\n \n self.buttonBox.button(QDialogButtonBox.Save).setEnabled(bool(diff2))\n self.buttonBox.button(QDialogButtonBox.Close).setEnabled(True)\n self.buttonBox.button(QDialogButtonBox.Close).setDefault(True)\n self.buttonBox.button(QDialogButtonBox.Close).setFocus(\n Qt.OtherFocusReason)\n \n for contents in [self.contents, self.contents2]:\n tc = contents.textCursor()\n tc.movePosition(QTextCursor.Start)\n contents.setTextCursor(tc)\n contents.ensureCursorVisible()\n \n fileSeparators = self.__mergeFileSeparators(fileSeparators)\n self.filesCombo.addItem(self.tr(\"<Start>\"), (0, 0))\n self.filesCombo.addItem(self.tr(\"<End>\"), (-1, -1))\n for oldFile, newFile, pos1, pos2 in sorted(fileSeparators):\n if oldFile != newFile:\n self.filesCombo.addItem(\n \"{0} -- {1}\".format(oldFile, newFile), (pos1, pos2))\n else:\n self.filesCombo.addItem(oldFile, (pos1, pos2))","def reaching_definitions(self):\n dirty = True\n while dirty:\n dirty = False\n for block in self.blocks:\n i_input = 0\n for parent in block.parents:\n i_input |= parent.i_output\n i_output = (i_input & ~block.i_kill) | block.i_gen\n if i_output != block.i_output:\n dirty = True\n block.i_input = i_input\n block.i_output = i_output","def reaching_definitions(self):\n dirty = True\n while dirty:\n dirty = False\n for block in self.blocks:\n i_input = 0\n for parent in block.parents:\n i_input |= parent.i_output\n i_output = (i_input & ~block.i_kill) | block.i_gen\n if i_output != block.i_output:\n dirty = True\n block.i_input = i_input\n block.i_output = i_output","def test_generator6(self):\n xpb = XPathBuilder()\n xp1 = xp2 = None\n base_xp = xpb.base.foo.bar\n base_gen = None\n with base_xp as b:\n base_gen = b\n xp1 = xpb.a.b.c.join(b())\n xp2 = xpb.test.join(b())\n xp1_exp = '/a/b/c/base/foo/bar'\n xp2_exp = '/test/base/foo/bar'\n base_exp = '/base/foo/bar'\n # check tree structure\n self.assertTrue(base_xp._parent is None)\n self.assertTrue(len(base_xp._children[0]._children[0]._children) == 0)\n self.assertTrue(base_gen._parent is None)\n self.assertTrue(len(base_gen._children) == 0)\n # check xpath\n self.assertEqual(xp1.tostring(), xp1_exp)\n self.assertEqual(xp2.tostring(), xp2_exp)\n self.assertEqual(base_xp.tostring(), base_exp)\n self.assertEqual(base_gen.tostring(), base_exp)","def render_paths_between_yields(paths): # pragma: no cover\n from graphviz import Digraph\n dot = Digraph(name=\"top\")\n for i, path in enumerate(paths):\n prev = None\n for block in path:\n if isinstance(block, Branch):\n label = \"if \" + astor.to_source(block.cond)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"invhouse\"})\n elif isinstance(block, Yield):\n label = \"id: {}\\n\".format(block.yield_id)\n label += astor.to_source(block.value)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"oval\"})\n elif isinstance(block, BasicBlock):\n label = \"\\n\".join(astor.to_source(stmt) for stmt in block.statements)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n elif isinstance(block, HeadBlock):\n label = \"Initial\"\n dot.node(str(i) + str(id(block)) + \"_start\", label.rstrip(), {\"shape\": \"doublecircle\"})\n label = \"\\n\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\n if hasattr(block, \"initial_yield\"):\n label += \"\\n\" + astor.to_source(block.initial_yield.value)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n dot.edge(str(i) + str(id(block)) + \"_start\", str(i) + str(id(block)))\n elif isinstance(block, State):\n label = \"{}\".format(astor.to_source(block.yield_state).rstrip())\n if block.conds:\n label += \" && \"\n label += \" && \".join(astor.to_source(cond) for cond in block.conds)\n label += \"\\n\"\n label += \"\\n\".join(astor.to_source(statement) for statement in block.statements)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"doubleoctagon\"})\n else:\n raise NotImplementedError(type(block))\n if prev is not None:\n if isinstance(prev, Branch):\n if block is prev.false_edge:\n label = \"F\"\n else:\n label = \"T\"\n else:\n label = \"\"\n dot.edge(str(i) + str(id(prev)), str(i) + str(id(block)), label)\n prev = block\n\n file_name = tempfile.mktemp(\"gv\")\n dot.render(file_name, view=True)","def process(self):\n first_line = self.setup[\"first_line\"]\n last_line = self.setup[\"last_line\"]\n\n self.logger.info(\"Using lines %s - %s\", first_line, last_line)\n\n path_temp = \"{}_\".format(self.path)\n\n with open(self.path, \"r\") as src, open(path_temp, \"w\") as dest:\n lines = src.r..\n copy_lines = lines[first_line-1:last_line]\n dest.write(\"\".join(copy_lines))\n\n os.rename(path_temp, self.path)","def body_lines(self):\n self.parent.finalize()\n for name, svg in self.iter_svgs(): # recurse here\n if name:\n yield '<g id=\"%s\">' % name\n for line in svg._meta.body_lines():\n yield line\n if name:\n yield \"</g>\"\n for elem in self.parent.elements:\n if isinstance(elem, SVG):\n pass\n else:\n yield \"%s\" % elem","def hexdump_diff_iter( source1, source2, start=None, end=None, length=None, major_len=8, minor_len=4, colour=True, before=2, after=2, address_base=None ):\n stride = minor_len*major_len\n start = start if start is not None else 0\n end = end if end is not None else max( len( source1 ), len( source2 ) )\n\n start = max( start, 0 )\n end = min( end, max( len( source1 ), len( source2 ) ) )\n address_base_offset = address_base-start if address_base is not None else 0\n\n diff_lines = []\n for offset in range( start, end, stride ):\n if source1[offset:offset+stride] != source2[offset:offset+stride]:\n diff_lines.append( offset )\n show_all = before is None or after is None\n if show_all:\n show_lines = {x: (2 if x in diff_lines else 1) for x in range( start, end, stride )}\n else:\n show_lines = {x: (2 if x in diff_lines else 0) for x in range( start, end, stride )}\n for index in diff_lines:\n for b in [index-(x+1)*stride for x in range( before )]:\n if b in show_lines and show_lines[b] == 0:\n show_lines[b] = 1\n for a in [index+(x+1)*stride for x in range( after )]:\n if a in show_lines and show_lines[a] == 0:\n show_lines[a] = 1\n\n skip = False\n for offset in sorted( show_lines.keys() ):\n if skip == True and show_lines[offset] != 0:\n yield '...'\n skip = False\n if show_lines[offset] == 2:\n check = basic_diff( source1, source2, start=offset, end=offset+stride )\n highlights = {}\n for (o, l) in check:\n for i in range( o, o+l ):\n highlights[i] = DIFF_COLOUR_MAP[0]\n if offset < len( source1 ):\n yield ansi.format_hexdump_line( source1, offset, min( end, len( source1 ) ), major_len, minor_len, colour, prefix='-', highlight_addr=DIFF_COLOUR_MAP[0], highlight_map=highlights, address_base_offset=address_base_offset )\n highlights = {k: DIFF_COLOUR_MAP[1] for k in highlights.keys()}\n if offset < len( source2 ):\n yield ansi.format_hexdump_line( source2, offset, min( end, len( source2 ) ), major_len, minor_len, colour, prefix='+' , highlight_addr=DIFF_COLOUR_MAP[1], highlight_map=highlights, address_base_offset=address_base_offset )\n elif show_lines[offset] == 1:\n yield ansi.format_hexdump_line( source1, offset, end, major_len, minor_len, colour, prefix=' ', address_base_offset=address_base_offset )\n elif show_lines[offset] == 0:\n skip = True\n\n if skip == True:\n yield '...'\n skip = False\n\n return","def GenerateDiff(self, args):\r\n raise NotImplementedError(\r\n \"abstract method -- subclass %s must override\" % self.__class__)","def __getGenerator(self):\n\n return \"{\\\\*\\\\generator %s;}\\n\" % fix(self.generator)","def test_reformat_paragraph_new_code_8_of_8(self):\n before_b = \"\"\"\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 41.\n \"\"\"\n after_b = \"\"\"\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 41.\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"1.0\"),\n after_sel=(\"3.0\", \"3.0\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def main(pathToseq, start, end, pathToOutputFile):\n infile = open(pathToseq)\n outfile = open(pathToOutputFile, 'w')\n fasta = infile.readline().replace(\"\\n\",\"\")\n sequence =\"\"\n for line in infile:\n sequence+=line.replace(\"\\n\",\"\")\n infile.close()\n outfile.write(\"Region \"+start +\" - \"+ end + \" of \"+fasta)\n\n outfile.write(\"\\n\"+sequence[int(start): int(end)])\n outfile.close()","def reread(self) -> None:\n old = self.getSubgraph(self.uri)\n new = Graph()\n try:\n contents = open(self.path).read()\n if contents.startswith(\"#new\"):\n log.debug(\"%s ignoring empty contents of my new file\",\n self.path)\n # this is a new file we're starting, and we should not\n # patch our graph as if it had just been cleared. We\n # shouldn't even be here reading this, but\n # lastWriteTimestamp didn't work.\n return\n\n new.parse(location=self.path, format='n3')\n self.readPrefixes = dict(new.namespaces())\n except SyntaxError as e:\n print(e)\n traceback.print_exc()\n log.error(\"%s syntax error\", self.path)\n # todo: likely bug- if a file has this error upon first\n # read, I think we don't retry it right.\n return\n except IOError as e:\n log.error(\"%s rereading %s: %r\", self.path, self.uri, e)\n return\n\n old = inContext(old, self.uri)\n new = inContext(new, self.uri)\n\n p = Patch.fromDiff(old, new)\n if p:\n log.debug(\"%s applying patch for changes in file\", self.path)\n self.patch(p, dueToFileChange=True)\n else:\n log.debug(\"old == new after reread of %s\", self.path)","def test_reformat_paragraph_new_code_6_of_8(self):\n before_b = \"\"\"\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 32.\n\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n after_b = \"\"\"\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 32.\n\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"1.0\"),\n after_sel=(\"4.0\", \"4.0\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def test_reformat_paragraph_new_code_7_of_8(self):\n before_b = \"\"\"\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 32.\n\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 41.\n \"\"\"\n after_b = \"\"\"\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 32.\n\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 41.\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"2.11\", \"2.11\"),\n after_sel=(\"3.1\", \"3.1\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def test_back_paragraph_extend_selection(self):\n before_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year,\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\n weather impacts every American. Communities can now rely on the National Weather\n Service’s StormReady program to help them guard against the ravages of Mother\n Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\n communication and safety skills needed to save lives and property– before and\n during the event. StormReady helps community leaders and emergency managers\n strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of\n severe weather through better planning, education, and awareness. No community\n is storm proof, but StormReady can help communities save lives. Does StormReady\n make a difference?\n \"\"\"\n after_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year,\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\n weather impacts every American. Communities can now rely on the National Weather\n Service’s StormReady program to help them guard against the ravages of Mother\n Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\n communication and safety skills needed to save lives and property– before and\n during the event. StormReady helps community leaders and emergency managers\n strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of\n severe weather through better planning, education, and awareness. No community\n is storm proof, but StormReady can help communities save lives. Does StormReady\n make a difference?\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"9.0\", \"9.5\"),\n after_sel=(\"6.7\", \"9.5\"),\n command_name=\"back-paragraph-extend-selection\",\n )","def _generate(self, **kwargs):\n super()._generate(**kwargs)","def _generate(self, **kwargs):\n super()._generate(**kwargs)","def _generate(self, **kwargs):\n super()._generate(**kwargs)","def replace(file, current_line, new_line):\n with fileinput.input(file, inplace=True) as f:\n for line in f:\n if current_line in line:\n line = new_line\n sys.stdout.write(line)","def mature(self,start,end):\n self.matureStart = start\n self.matureEnd = end","def parent_images(self, parents):\n parents = list(parents)\n change_instrs = []\n for instr in self.structure:\n if instr['instruction'] != 'FROM':\n continue\n\n old_image, stage = image_from(instr['value'])\n if old_image is None:\n continue # broken FROM, fixing would just confuse things\n if not parents:\n raise RuntimeError(\"not enough parents to match build stages\")\n\n image = parents.pop(0)\n if image != old_image:\n instr['value'] = '{0} AS {1}'.format(image, stage) if stage else image\n instr['content'] = 'FROM {0}\\n'.format(instr['value'])\n change_instrs.append(instr)\n\n if parents:\n raise RuntimeError(\"trying to update too many parents for build stages\")\n\n lines = self.lines\n for instr in reversed(change_instrs):\n lines[instr['startline']:instr['endline']+1] = [instr['content']]\n\n self.lines = lines","def GenSequence(end, past):\n\tif past[-1] == end:\n\t\tSeq.append(past)\n\t\treturn None\n\tfor n in Neighbour(past[-1][0],past[-1][1]):\n\t\tif n not in past:\n\t\t\tGenSequence(end, past+[n])","def remove_paired_comments(self, program):\n regions = re.compile(\"(/\\*|\\*/)\").split(program)\n depth = 0\n output = []\n for i in range(len(regions)):\n region = regions[i]\n if region==\"/*\":\n depth+=1\n elif region==\"*/\":\n depth-=1\n else:\n #print(\" \"*depth, region.replace(\"\\n\", \"_\"))\n if depth==0:\n output.append(region)\n return \"\".join(output)","def section(fle, begin, end):\n with open(fle) as f:\n for line in f:\n # found start of section so start iterating from next line\n if line.startswith(begin):\n for line in f: \n # found end so end function\n if line.startswith(end):\n return\n # yield every line in the section\n yield line.rstrip()","def test_indent_relative(self):\n before_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n after_b = \"\"\"\\\n first line\n line 1\n line a\n line b\n line c\n last line\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"5.0\", \"5.0\"),\n after_sel=(\"5.8\", \"5.8\"),\n command_name=\"indent-relative\",\n )","def get_des_gen(tree_before: Node, tree_after: Node) -> Iterator[Description]:\n distance, delta = diff(tree_before, tree_after)\n\n tree_before_iter: Iterator[Node] = infinite_none_suffix(\n post_order_tree_traversal(tree_before)\n )\n tree_after_iter: Iterator[Node] = infinite_none_suffix(\n post_order_tree_traversal(tree_after)\n )\n\n cur_node_before: Node = next(tree_before_iter)\n cur_node_after: Node = next(tree_after_iter)\n\n while cur_node_before or cur_node_after:\n while cur_node_after in delta['inserted']:\n yield describe.describe_insertion(cur_node_after)\n cur_node_after = next(tree_after_iter)\n while cur_node_before in delta['deleted']:\n yield describe.describe_deletion(cur_node_before)\n cur_node_before = next(tree_before_iter)\n if cur_node_before in delta['stayed']['before']:\n yield describe.describe_stayed(cur_node_before, cur_node_after)\n cur_node_before = next(tree_before_iter)\n cur_node_after = next(tree_after_iter)\n return","def create_next_gen(self, parents_sreprs_couple):\n child0, child1 = self.recombine(parents_sreprs_couple[0], parents_sreprs_couple[1])\n if random.random() < self.mutate_prob:\n child0 = self.mutate(child0)\n if random.random() < self.mutate_prob:\n child1 = self.mutate(child1)\n\n return child0, child1","def replace_embedded_snipptes(content: str, sc_left: str, sc_right: str, change: bool) -> str:\n\n if change:\n # this regex will turn something like %snippet:foo% into something like {snippet:foo}\n content = re.sub(rf\"{sc_left}(\\w+:\\w+){sc_right}\", r\"{\\1}\", content)\n\n # this line changes the cursor position placeholder (ONLY TEXTEXPANDER TESTED)\n content = re.sub(rf\"{sc_left}\\|\", \"{cursor}\", content)\n\n return content","def generated(self, generated):\n\n self._generated = generated","def bp_ins(filename, start, end):\n with open(filename, 'r') as f:\n lines = f.readlines()\n lines.insert(start-1, \"\")\n lines.insert(end+1, \"\")\n lines.insert(0, \"\")\n lines[start-1] = 'ipdb.set_trace()\\n'\n lines[end+1] = 'ipdb.set_trace()\\n'\n lines[0] = \"import ipdb\\n\"\n with open(f\"break_{filename}\", 'w+') as f:\n f.writelines(lines)","def raw_segments_with_ancestors(\n self,\n ) -> List[Tuple[\"RawSegment\", List[PathStep]]]:\n buffer = []\n code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code)\n for idx, seg in enumerate(self.segments):\n # If it's a raw, yield it with this segment as the parent\n new_step = [PathStep(self, idx, len(self.segments), code_idxs)]\n if seg.is_type(\"raw\"):\n buffer.append((cast(\"RawSegment\", seg), new_step))\n # If it's not, recurse - prepending self to the ancestor stack\n else:\n buffer.extend(\n [\n (raw_seg, new_step + stack)\n for raw_seg, stack in seg.raw_segments_with_ancestors\n ]\n )\n return buffer","def create_gen_xml(self, out_file):\n\n param_list = []\n msg = []\n msg_type = []\n dep_node = []\n for line in self.full_ed_lines:\n param_list.append(line.text())\n dep_pkg = param_list[6].split(', ')\n if dep_pkg[len(dep_pkg) - 1] == '':\n dep_pkg.pop()\n for dep in self.manager.wid.sub_list:\n dep_node.append(dep['msg_type'])\n for dep in self.manager.wid.pub_list:\n dep_node.append(dep['msg_type'])\n for dep in dep_node:\n a, b = dep.split('/')\n msg.append(a)\n msg_type.append(b)\n f = open('../genkernel/templates/package_rosgen.xml')\n o = open(out_file, 'a')\n flag = 0\n while 1:\n line = f.readline()\n if not line: break\n for i in range(6):\n line = line.replace('[{0}]'.format(i), param_list[i])\n line = line.replace('[7]', param_list[7])\n if line.find('[6]') != -1:\n for dep in dep_pkg:\n line_dep = '\\t<depend>{0}</depend>\\n'.format(dep)\n o.write(line_dep)\n flag = 1\n elif line.find('[8]') != -1:\n for dep, tp in zip(msg, msg_type):\n line_dep = '\\t\\t<depend type=\"{1}\">{0}</depend>\\n'.format(dep, tp)\n o.write(line_dep)\n flag = 1\n elif line.find('<subscribers>') != -1:\n o.write('\\t\\t<subscribers>\\n')\n for sub in self.manager.wid.sub_list:\n o.write('\\t\\t\\t<sub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(sub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(sub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(sub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(sub['queue_size']))\n o.write('\\t\\t\\t</sub>\\n')\n o.write('\\t\\t</subscribers>\\n')\n flag = 1\n elif line.find('<publishers>') != -1:\n o.write('\\t\\t<publishers>\\n')\n for pub in self.manager.wid.pub_list:\n o.write('\\t\\t\\t<pub>\\n')\n o.write('\\t\\t\\t\\t<name>{0}</name>\\n'.format(pub['name']))\n o.write('\\t\\t\\t\\t<msg_type>{0}</msg_type>\\n'.format(pub['msg_type']))\n o.write('\\t\\t\\t\\t<topic_name>{0}</topic_name>\\n'.format(pub['topic_name']))\n o.write('\\t\\t\\t\\t<queue_size>{0}</queue_size>\\n'.format(pub['queue_size']))\n o.write('\\t\\t\\t</pub>\\n')\n o.write('\\t\\t</publishers>\\n')\n flag = 1\n if flag == 0:\n o.write(line)\n else:\n flag = 0\n o.close()\n f.close()\n self.changed = False","def manage_resequenceGraphPoints(self, seqmap=(), origseq=(), REQUEST=None):\n retval = resequence(self, self.graphPoints(), seqmap, origseq, REQUEST)\n if REQUEST:\n audit('UI.GraphDefinition.ResequenceGraphPoints', self.id, sequence=seqmap, oldData_={'sequence':origseq})\n return retval","def changed_block(self, old_block, new_block):","def generate_example_label(self):\n label_markup = \"\"\"{keywords}procedure{i} {blocks}Foo{i}\n (An_Integer : {keywords}in out{i} {types}Integer{i} := {numbers}0{i};\n A_String : {types}String{i} := {strings}\"some text\"{i})\n {keywords}with{i} {aspects}Pre => An_Integer >= -1{i};\n{comments}-- Documentation for Foo{i}\n\n---------\n-- Foo --\n---------\n\n{keywords}procedure{i} {blocks}Foo{i}\n (An_Integer : {keywords}in out{i} {types}Integer{i} := {numbers}0{i};\n A_String : {types}String{i} := {strings}\"some text\"{i}) {keywords}is{i}\n{keywords}begin{i}\n {comments}-- Do the actual loop{i}\n\n {keywords}for{i} J {keywords}in{i} A_String'Range {keywords}loop{i}\n Put_Line ({strings}\"bla\"{i} & (A + {numbers}10{i})'Img);\n {keywords}end loop{i};\n{keywords}end{i} {blocks}Foo{i};\n\"\"\"\n # Add line numbers\n num = 1\n prefixed = []\n\n # Compute the preview's gutter foreground color by mixing the editor's\n # foreground and background color.\n # This formula needs to be synchronized with the formula that computes\n # the 'gutter_color' in gps.css.\n gutter_fg_color = self.d['editor_fg'].mix(self.d['editor_bg'], 0.6)\n\n for line in label_markup.splitlines():\n prefixed.append(\n '<span color=\"{}\">{:4d} </span> {}'.format(\n gutter_fg_color.to_hex6_string(),\n num,\n line))\n num = num + 1\n\n font = GPS.Preference(\"Src-Editor-Reference-Style\").get().split(\"@\")[0]\n label_markup = '<span font=\"{}\">'.format(font) + '\\n'.join(\n prefixed) + '</span>'\n\n b = Gtk.HBox()\n label = Gtk.Label()\n b.pack_start(label, False, False, 0)\n _, bg = Gdk.Color.parse(self.d['editor_bg'].to_hex6_string())\n _, fg = Gdk.Color.parse(self.d['editor_fg'].to_hex6_string())\n b.modify_bg(Gtk.StateType.NORMAL, bg)\n label.modify_fg(Gtk.StateType.NORMAL, fg)\n process_dict = {'i': \"</span>\"}\n for key in ['keywords', 'blocks', 'comments',\n 'strings', 'numbers', 'aspects', 'types']:\n val = self.d[key]\n process_dict[key] = '<span {} {} {}>'.format(\n 'color=\"{}\"'.format(val[1].to_hex6_string())\n if val[1].a != 0.0 else '',\n 'background=\"{}\"'.format(val[2].to_hex6_string())\n if val[2].a != 0.0 else '',\n\n 'font-weight=\"BOLD\"' if 'BOLD' in val[0] else '' +\n ' font-style=\"ITALIC\"' if \"ITALIC\" in val[0] else '')\n\n label.set_markup(label_markup.format(**process_dict))\n return b","def transform(stop):\n line = None\n results = {}\n while True:\n if line is not None:\n processor = processors.get(type(line), None)\n if processor:\n processor[0](line, results, *processor[1:])\n if stop.is_set():\n line = generate(results)\n else:\n line = None\n line = yield line","def test_reformat_paragraph_new_code_5_of_8(self):\n before_b = \"\"\"\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 22.\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n after_b = \"\"\"\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n Line 22.\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"2.0\"),\n after_sel=(\"3.0\", \"3.0\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def copy_edge_attributes_to_refined(g_orig,g_new):\n def copy_attributes(j_orig,j_new):\n for field,type_ in g_new.edge_dtype:\n if field not in ['nodes','cells'] and not field.startswith('_'):\n g_new.edges[field][j_new] = g_orig.edges[field][j_orig]\n\n # loop through setting edge marks\n # edges between a midpoint and one of the\n # endpoints\n for j in range(g_new.Nedges()):\n a,b = g_new.edges['nodes'][j]\n if a>b:\n a,b = b,a\n # only care about edges where one node is original,\n # the other is a midpoint.\n # there are no edges where both are original, and\n # edges with both as midpoints or with one as a center\n # always internal.\n if a < g_orig.Nnodes() and b>=g_orig.Nnodes() and b<g_orig.Nnodes()+g_orig.Nedges():\n j_orig = b - g_orig.Nnodes()\n copy_attributes(j_orig,j)","def crossover(parent: list):\n ### GENERAL METHOD\n child1 = []\n child2 = []\n child = []\n geneA = int(random.random() * len(parent[0]))\n geneB = int(random.random() * len(parent[0]))\n startgene = min(geneA, geneB)\n endgene = max(geneA, geneB)\n for i in range(startgene, endgene):\n child1.append(parent[0][i])\n child2 = [item for item in parent[1] if item not in child1]\n child = child2[:startgene] + child1 + child2[startgene:]\n return child","def extend_taa_seq(self, taa_pos_base, old_seq, new_seq):\n taa_pos = None\n termlen = -1 # use -1 to detect abnormal computes\n seq_end = self.cds_end\n new_aa_seq = ''\n i = 0\n while True:\n ci = i*3\n old_codon_seq = old_seq[ci:ci+3]\n new_codon_seq = new_seq[ci:ci+3]\n # if sequence comes to ends, extend sequence from reference file\n if (old_codon_seq not in standard_codon_table or\n new_codon_seq not in standard_codon_table):\n seq_inc = faidx.refgenome.fetch_sequence(self.chrm, seq_end+1, seq_end+100)\n old_seq += seq_inc\n new_seq += seq_inc\n old_codon_seq = old_seq[ci:ci+3]\n new_codon_seq = new_seq[ci:ci+3]\n seq_end += 100\n\n taa_ref_run = codon2aa(old_codon_seq)\n taa_alt_run = codon2aa(new_codon_seq)\n new_aa_seq += taa_alt_run\n # print i, old_codon_seq, new_codon_seq, taa_ref_run, taa_alt_run\n if taa_pos == None and taa_ref_run != taa_alt_run:\n taa_pos = i\n taa_ref = taa_ref_run\n taa_alt = taa_alt_run\n if taa_alt_run == '*':\n if taa_pos == None:\n # stop codon encountered before difference\n return None # nothing occur to protein level\n termlen = i + 1 - taa_pos\n break\n i += 1\n\n new_aa_seq = new_aa_seq[taa_pos:]\n if taa_pos == None:\n print('oldseq', old_seq)\n print('newseq', new_seq)\n taa_pos += taa_pos_base\n\n aae = AAExtension()\n aae.taa_pos = taa_pos\n aae.taa_ref = taa_ref\n aae.taa_alt = taa_alt\n aae.termlen = termlen\n aae.new_aa_seq = new_aa_seq\n\n return aae","def build_model_mutator(self):\n\n\t\tprint \"beginning mutation procedure\"\n\t\twith open(self.rootdir+self.template[0][0]+'.pdb','r') as fp: lines = fp.readlines()\n\t\t\n\t\tregex_seqres = '^SEQRES\\s+[0-9]+\\s+([A-Z])\\s+[0-9]+\\s+(.+)'\n\t\tregex_remark = '^REMARK\\s300\\s([A-Z]+)\\s+'\n\t\t#---if SEQRES is present we get the sequence from it\n\t\t#---note that the seqres protocol below should handle missing residues even if they exist\n\t\t#---...at the beginning of the target sequence\n\t\tif any([re.match(regex_seqres,line) for line in lines]):\n\t\t\tseqresli = [li for li,l in enumerate(lines) if re.match(regex_seqres,l)]\n\t\t\tseqraw = [re.findall(regex_seqres,lines[li])[0] for li in seqresli]\n\t\t\tsequence = ''.join([''.join([aacodemap[j] for j in i[1].split()]) \n\t\t\t\tfor i in seqraw if i[0] == self.template[0][1]])\n\t\t\tmissingli = [re.findall('^REMARK\\s+([0-9]+)\\sMISSING RESIDUES',l)[0] for li,l in enumerate(lines) \n\t\t\t\tif re.match('^REMARK\\s+([0-9]+)\\sMISSING RESIDUES',l)]\n\t\t\tif missingli != []:\n\t\t\t\tif len(missingli)>1: raise Exception('cannot parse multiple MISSING RESIDUE notes')\n\t\t\t\tmissingli = str(missingli[0])\n\t\t\t\tstartres = int([\n\t\t\t\t\tre.findall('^REMARK\\s+'+missingli+'\\s+[A-Z]{3}\\s+[A-Z]\\s+([0-9]+)',l)[0] \n\t\t\t\t\tfor li,l in enumerate(lines)\n\t\t\t\t\tif re.match('^REMARK\\s+'+missingli+'\\s+[A-Z]{3}\\s+[A-Z]\\s+[0-9]+',l)][0])\n\t\t\telse: startres = int([line for line in lines if re.match('^ATOM',line)][0][22:25+1])\n\t\telif any([re.match(regex_remark,line) for line in lines]):\n\t\t\tseqresli = [li for li,l in enumerate(lines) if re.match(regex_remark,l)]\n\t\t\tseqraw = [re.findall(regex_remark,lines[li])[0] for li in seqresli]\n\t\t\tsequence = ''.join(seqraw)\n\t\t\tstartres = int([line for line in lines if re.match('^ATOM',line)][0][22:25+1])\n\t\telse: raise Exception('need either REMARK 300 or SEQRES in your pdb file')\n\t\t\t\n\t\tself.target = []\n\t\tfor mi,mut in enumerate(self.settings['mutations']):\n\t\t\tsequence_mut = list(sequence)\n\t\t\tif sequence[mut[1]-startres] != mut[0]: \n\t\t\t\tmsg = [\n\t\t\t\t\t'USER ERROR!',\n\t\t\t\t\t'sequence: '+sequence,\n\t\t\t\t\t'starting residue number from ATOM record: '+str(startres),\n\t\t\t\t\t'expecting '+str(mut[0])+' at position '+str(mut[1]),\n\t\t\t\t\t'however reading '+str(sequence[mut[1]-startres])+' at that position!',\n\t\t\t\t\t]\n\t\t\t\traise Exception('\\n'.join(msg))\n\t\t\telse: sequence_mut[mut[1]-startres] = mut[2]\n\t\t\tsequence_mut = ''.join(sequence_mut)\n\t\t\tprint 'template sequence = '+sequence\n\t\t\tprint 'mutated sequence = '+sequence_mut\n\t\t\tself.target.append(['mutation'+str(mi),sequence_mut])\n\t\tfor mi,mut in enumerate(self.settings['mutations']):\n\t\t\tprint 'building homology model for mutation '+str(mi)\n\t\t\tself.settings['target_name'] = self.target[mi][0]\n\t\t\t#---we explicitly encode the mutation in the filename so that it can be retrieved later\n\t\t\t#---...particularly in ???\n\t\t\tbatchdir = 'model-v'+('%05d'%(mi))+'-'+self.template[0][0]+'_chain'+self.template[0][1]+\\\n\t\t\t\t'_mut'+''.join([str(j) for j in mut])+'/'\n\t\t\tself.build_model_single(batchdir_override=batchdir,startres=startres)","def _generate_custom(project, docdir, gendir):\n custom_dir = os.path.join(docdir, 'generate')\n print(f\"Generating custom docs for {project} in {gendir!r}\")\n\n for root, _dirs, files in os.walk(custom_dir):\n subdir = root.split(custom_dir, 1)[1].strip('/')\n if subdir:\n try:\n os.mkdir(os.path.join(gendir, subdir))\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n\n for script in sorted(x for x in files if not x.startswith(('.', '_'))):\n script_path = os.path.join(custom_dir, subdir, script)\n if not os.access(script_path, os.X_OK):\n continue\n\n fake_file = StringIO()\n with syspath(os.path.dirname(script_path)):\n module = import_module(os.path.basename(os.path.splitext(script_path)[0]))\n module.main(fake_file, docdir=docdir, gendir=gendir)\n\n fake_file.seek(0)\n if data := fake_file.read():\n rst = os.path.join(gendir, subdir, os.path.splitext(script)[0] + '.rst')\n print(f\"generating {rst}\")\n with open(rst, 'w') as f:\n f.write(data)","def change_line(file_path, included_strings, excluded_strings, replacement):\n if not os.path.isfile(file_path):\n print file_path+\" file not found!\"\n return\n temp_path = file_path+\"_temp\"\n temp_file = open(temp_path, 'w')\n with open(file_path, 'r') as f:\n for line in f:\n if all([x in line for x in included_strings]) and \\\n all([x not in line for x in excluded_strings]):\n temp_file.write(replacement)\n else:\n temp_file.write(line)\n temp_file.close()\n os.system(\"mv \"+temp_path+\" \"+file_path)\n return","def replace_includes(self, file_name):\n\n indexBegin = 0\n indexEnd = 0\n text = self.dir_helper.read_file(file_name)\n while indexBegin != -1:\n indexBegin = text.find('\\input{', indexBegin+1)\n indexEnd = text.find('}', indexBegin+1)\n text_to_replace = text[indexBegin:indexEnd+1]\n if indexBegin != -1:\n # print 'text_to_replace : ' + text_to_replace\n new_path = self.construct_path(text_to_replace)\n new_text = self.replace_includes(file_name = new_path)\n text = text.replace(text_to_replace, new_text)\n\n return text","def replace(self, text, from_line, from_col, to_line, to_col):\n self.remove(from_line, from_col, to_line, to_col)\n self.insert_after(text, from_line, from_col)","def integrate_changes(self, strings):\n other_index = strings.index()\n translation = self.translation()\n lines = []\n for key in sorted(other_index.keys(), key=unicode.lower):\n try: value = translation.index[key]\n except KeyError: value = other_index[key]\n try: translation_comments = translation.index[key].comments\n except: translation_comments = []\n other_comments = other_index[key].comments or ['No comment provided by engineer.']\n for i in range(0, max(len(translation_comments), len(other_comments))):\n try: comment = other_comments[i]\n except IndexError: comment = translation_comments[i]\n lines.append('/* %s */\\n' % comment)\n lines.append('\"%s\" = \"%s\";\\n\\n' % (value.key, value.trans))\n \n try: os.unlink(self.path())\n except OSError: pass\n if lines:\n result = codecs.open(self.path(), 'wb', encoding='utf-16')\n result.writelines(lines)\n result.close()","def replace_plugins(lines):\n starts, ends = [], []\n stripped = [[]]\n exports = []\n plugin = False\n for i, line in enumerate(lines):\n if line.rstrip().endswith(END):\n assert plugin, f\"END PLUGIN without BEGIN PLUGIN found in {lines}\"\n plugin = False\n ends.append(i)\n stripped.append([])\n \n elif line.rstrip().endswith(BEGIN):\n assert not plugin, f\"Nested plugins found in {lines}\"\n starts.append(i)\n exports.append(False)\n plugin = True\n \n elif line.rstrip().endswith(BEGIN_EXPORT):\n assert not plugin, f\"Nested plugins found in {lines}\"\n starts.append(i)\n exports.append(True)\n plugin = True\n\n elif plugin:\n stripped[len(starts) - 1].append(line)\n\n assert len(stripped) == len(starts) + 1 == len(ends) + 1 == len(exports) + 1, f\"Error processing plugins in {lines}\"\n assert all(s < e for s, e in zip(starts, ends))\n\n starts.reverse()\n ends.reverse()\n stripped.reverse()\n stripped = stripped[1:]\n\n lines = lines.copy()\n\n for i, (s, e) in enumerate(zip(starts, ends)):\n config = yaml.full_load(\"\\n\".join(stripped[i]))\n export = exports[i]\n pg = config[\"plugin\"]\n args = \", \".join(config.get(\"args\", []))\n kwargs = \", \".join([f\"{k}={v}\" for k, v in config.get(\"kwargs\", {}).items()])\n\n call = (\"run_plugin\", \"add_plugin_files\")[export]\n\n call = f'grader.{call}(\"{pg}\"'\n if args:\n call += f', {args}'\n if kwargs:\n call += f', {kwargs}'\n call += ')'\n\n del lines[s:e+1]\n lines.insert(s, call)\n\n return lines","def process(self, doc: Doc) -> Doc:\n\n matches = self.get_matches(doc)\n\n terminations = get_spans(matches, \"termination\")\n boundaries = self._boundaries(doc, terminations)\n\n # Removes duplicate matches and pseudo-expressions in one statement\n matches = filter_spans(matches, label_to_remove=\"pseudo\")\n\n entities = list(self.get_spans(doc))\n ents = None\n\n for start, end in boundaries:\n\n ents, entities = consume_spans(\n entities,\n filter=lambda s: check_inclusion(s, start, end),\n second_chance=ents,\n )\n\n sub_matches, matches = consume_spans(\n matches, lambda s: start <= s.start < end\n )\n\n if self.on_ents_only and not ents:\n continue\n\n sub_preceding = get_spans(sub_matches, \"preceding\")\n sub_following = get_spans(sub_matches, \"following\")\n # Verbs preceding negated content\n sub_preceding += get_spans(sub_matches, \"verbs_preceding\")\n # Verbs following negated content\n sub_following += get_spans(sub_matches, \"verbs_following\")\n\n if not sub_preceding + sub_following:\n continue\n\n if not self.on_ents_only:\n for token in doc[start:end]:\n token._.negation = any(\n m.end <= token.i for m in sub_preceding\n ) or any(m.start > token.i for m in sub_following)\n\n for ent in ents:\n self.annotate_entity(\n ent=ent,\n sub_preceding=sub_preceding,\n sub_following=sub_following,\n )\n\n return doc","def update_pre_block(pre_block):\r\n updated_block=\"\";\r\n count=0;\r\n for line in pre_block.splitlines():\r\n count+=1;\r\n if count<len(pre_block.splitlines()):\r\n line=update_line(line)+\"\\n\";\r\n updated_block=updated_block+line;\r\n else:\r\n line=update_line(line);\r\n updated_block=updated_block+line;\r\n return updated_block","def test_extend_to_paragraph(self):\n before_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year,\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\n weather impacts every American. Communities can now rely on the National Weather\n Service’s StormReady program to help them guard against the ravages of Mother\n Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\n communication and safety skills needed to save lives and property– before and\n during the event. StormReady helps community leaders and emergency managers\n strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of\n severe weather through better planning, education, and awareness. No community\n is storm proof, but StormReady can help communities save lives. Does StormReady\n make a difference?\n \"\"\"\n after_b = \"\"\"\\\n Americans live in the most severe weather-prone country on Earth. Each year,\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\n weather impacts every American. Communities can now rely on the National Weather\n Service’s StormReady program to help them guard against the ravages of Mother\n Nature.\n\n Some 90% of all presidentially declared disasters are weather related, leading\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\n communication and safety skills needed to save lives and property– before and\n during the event. StormReady helps community leaders and emergency managers\n strengthen local safety programs.\n\n StormReady communities are better prepared to save lives from the onslaught of\n severe weather through better planning, education, and awareness. No community\n is storm proof, but StormReady can help communities save lives. Does StormReady\n make a difference?\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"9.0\", \"9.0\"),\n after_sel=(\"8.0\", \"13.33\"),\n command_name=\"extend-to-paragraph\",\n )","def generator(self):\n\n # generates speech turns long enough to contain at least one segment\n speech_turns = super(SpeechTurnSubSegmentGenerator, self).generator()\n\n # number of speech turns per \"speech turn batch\"\n if self.per_fold is not None:\n n_speech_turns = self.per_label * self.per_fold\n else:\n n_speech_turns = self.per_label * len(self.data_)\n\n endOfBatch = EndOfBatch()\n while True:\n\n # for each speech turn in batch\n for z in range(n_speech_turns):\n speech_turn = next(speech_turns)\n\n # for each segment in speech turn\n for X in self.iter_segments_(speech_turn['X']):\n\n # all but 'X' fields are left unchanged\n segment = dict(speech_turn)\n segment['X'] = X\n\n # remember that this segment belongs to this speech turn\n segment['z'] = z\n\n yield segment\n\n # let `batchify` know that the \"segment batch\" is complete\n yield endOfBatch","def test_reformat_paragraph_simple_hanging_indent(self):\n before_b = \"\"\"\\\n Honor this line that has a hanging indentation, please. Hanging\n indentation is valuable for lists of all kinds. But it is tricky to get right.\n\n Next paragraph.\n \"\"\"\n after_b = \"\"\"\\\n Honor this line that has a hanging\n indentation, please. Hanging\n indentation is valuable for lists of\n all kinds. But it is tricky to get\n right.\n\n Next paragraph.\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"1.0\"),\n after_sel=(\"7.0\", \"7.0\"),\n command_name=\"reformat-paragraph\",\n directives=\"@language plain\\n@pagewidth 40\\n@tabwidth 8\",\n )","def generate(self):\n\n with open(self.file, \"r\") as file:\n structure = []\n for line in file:\n sub_line = []\n for sprite in line:\n if sprite != '\\n':\n sub_line.append(sprite)\n structure.append(sub_line)\n self.structure = structure","def convert_doxygen_docstring(lines, name):\n\n lines = lines[:]\n newlines = []\n indent = 0\n reading_desc = False\n\n while lines:\n line = lines.pop(0)\n if line.startswith(\"////\"):\n continue\n\n line = line.rstrip()\n if line.startswith('///<'):\n strline = line[4:]\n else:\n strline = line\n\n strline = strline.lstrip('/ \\t')\n\n if strline == \"**\" or strline == \"*/\":\n continue\n\n if strline.startswith(\"** \"):\n strline = strline[3:]\n elif strline.startswith(\"* \"):\n strline = strline[2:]\n elif strline == \"*\":\n strline = \"\"\n\n strline = strline.lstrip(' \\t')\n\n if strline.startswith('@'):\n special = strline.split(' ', 1)[0][1:]\n if special == 'par' and strline.endswith(':') and lines and '@code' in lines[0]:\n newlines.append(' '*indent + strline[5:] + ':')\n newlines.append('')\n line = lines.pop(0)\n offset = line.index('@code')\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"verbatim\" or special == \"code\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. code-block:: guess')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"f[\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. math::')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@f]' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == 'param':\n #TODO\n #if extra is not None:\n # _, name, desc = strline.split(' ', 2)\n # extra['param:' + name] = desc\n continue\n elif special == 'deprecated':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n\n # I'd love to use the proper Sphinx deprecated tag, but it\n # requires a version number, whereas Doxygen doesn't.\n newlines.append('*Deprecated:* ' + convert_doxygen_format(value, name))\n newlines.append('')\n continue\n elif special in ('brief', 'return', 'returns'):\n #TODO\n #if extra is not None:\n # _, value = strline.split(' ', 1)\n # extra[special] = value\n continue\n elif special == 'details':\n strline = strline[9:]\n elif special == 'sa' or special == 'see':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n values = value.split(',')\n\n for i, value in enumerate(values):\n result = resolve_reference(value.partition('(')[0], name)\n if result:\n values[i] = ':{0}:`{1}`'.format(*result)\n else:\n values[i] = ':obj:`{0}`'.format(value)\n\n if special == 'see':\n newlines.append('See {}.'.format(', '.join(values)))\n else:\n newlines.append('See also {}.'.format(', '.join(values)))\n newlines.append('')\n continue\n elif special in ('note', 'warning'):\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. %s:: ' % (special))\n newlines.append('')\n newlines.append(' ' + convert_doxygen_format(strline[2 + len(special):], name))\n while lines and lines[0].strip(' *\\t/'):\n line = lines.pop(0).lstrip(' *\\t')\n newlines.append(' ' + convert_doxygen_format(line, name))\n\n newlines.append('')\n continue\n elif special == 'since':\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. versionadded:: ' + strline[7:])\n newlines.append('')\n continue\n else:\n print(\"Unhandled documentation tag: @\" + special)\n\n if strline or len(newlines) > 0:\n newlines.append(' '*indent + convert_doxygen_format(strline, name))\n\n return newlines","def remLines(origFile):\n\n noLineFile = origFile + \".noline\"\n\n # Generate no line file\n cmd = \"cat %s | sed -e '/^\\s*\\.line.*$/d' | sed -e 's/\\/jumbo//' > %s\" % \\\n (commands.mkarg(origFile), commands.mkarg(noLineFile))\n commands.getstatusoutput(cmd)\n\n if not os.path.exists(noLineFile):\n return None\n\n # Generate line patch\n linesPatch = origFile + \".linepatch\"\n cmd = \"diff -B -u %s %s > %s\" % \\\n (commands.mkarg(noLineFile), commands.mkarg(origFile), commands.mkarg(linesPatch))\n commands.getstatusoutput(cmd)\n\n shutil.move(noLineFile, origFile)\n\n return linesPatch","def reconstruct(new, original):\n\n output = []\n\n # Find deltas between new and original and add newlines to the output wherever they're found in original\n seqm = difflib.SequenceMatcher(None, new, original, False)\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\n delta_a = seqm.a[a0:a1] # Substring in new\n delta_b = seqm.b[b0:b1] # Substring in original\n newline = re.search(r'(\\r|\\n)+', delta_b)\n\n # Always take delta_a over delta_b unless there's a newline\n if opcode == 'equal':\n output.append(delta_a)\n elif opcode == 'insert' and newline: # Append any insertion containing a newline\n output.append(newline.group(0))\n elif opcode == 'delete':\n output.append(delta_a)\n elif opcode == 'replace':\n if newline:\n if re.match(r'\\r|\\n', delta_b[-1]): # If the newline is the last character, insert the newline after delta_a\n output.append(delta_a + newline.group(0))\n else: # Otherwise insert the newline before delta_a\n output.append(newline.group(0) + delta_a)\n else:\n output.append(delta_a)\n\n # Strip leading and trailing whitespace from each line\n new = ''.join(output)\n lines = new.split('\\n')\n for i in range(len(lines)):\n lines[i] = lines[i].strip()\n\n # Write file\n file = open('GenderSwap.txt', 'w')\n file.write('\\n'.join(lines))\n file.close()","def nextGeneration(self):\n # select two parents from the current generation.\n parent_1 = self.selection()\n parent_2 = self.selection()\n # to not get the same parents.\n _ = 0\n while _ < 30 and parent_2 == parent_1:\n parent_2 = self.selection()\n _ += 1\n # apply crossover on those parents (crossover_rate chance).\n crossover_chance = random.uniform(0, 1)\n parents = [parent_1, parent_2]\n if crossover_chance <= self.crossoverRate:\n offspring = self.crossover(parents)\n else:\n return \n # apply mutations on the new offspring (mutation_rate chance).\n mutation_chance = random.uniform(0, 1)\n newoffspring = offspring\n if mutation_chance <= self.mutationRate:\n newoffspring = self.mutation(offspring)\n # replace one of the parents in the new generation, given the loser parent.\n self.replaceLoser(parents, newoffspring)\n\n # now the new generation is available in the self.currentGeneration","def ModifyRange(self, rangeText, nucleotide='-'):\n nucleotide = nucleotide.upper()\n if (self.translated == True):\n self.AlertMessage(\"Can't modify protein sequences.\", 'medium')\n elif (nucleotide not in ['A', 'G', 'C', 'T', 'R', 'K', 'S', 'W', 'M', 'Y', 'D', 'V', 'B', 'H', 'N', '-']):\n self.AlertMessage('Invalid nucleotide. (only AGTC- and IUB nucleotide codes are permitted)', 'high')\n else:\n startTaxon, stopTaxon, startColumn, stopColumn = self.ParseIndex(rangeText)\n if (startTaxon >= 0): #Make sure we have a valid range\n taxon = 0\n newSequences = []\n modificationLength = (stopColumn - startColumn) + 1\n for Sequence in self.alignment:\n if (taxon in range(startTaxon, stopTaxon + 1)):\n if (startColumn > 0):\n Sequence.seq = Sequence.seq[:startColumn] + Seq(nucleotide * modificationLength) + Sequence.seq[stopColumn + 1:]\n else:\n Sequence.seq = Seq(nucleotide * modificationLength) + Sequence.seq[stopColumn + 1:]\n newSequences.append(Sequence)\n taxon += 1\n self.alignment = MultipleSeqAlignment(newSequences)\n self.Show(self.displayedColumn)\n self.BackupAlignment()"],"string":"[\n \"def generate_new_file(file, new_content):\\n with open(file, 'r') as f:\\n old_content = f.read()\\n\\n try:\\n before, begin_marker, _, end_marker, after = re.split(r'(// GENERATED-MARKER\\\\n)', old_content, flags=re.MULTILINE | re.DOTALL)\\n except ValueError:\\n raise RuntimeError(\\\"Failed to split {} based on markers, please make sure the file has exactly two '// GENERATED-MARKER' occurrences\\\".format(file))\\n\\n return before + begin_marker + new_content + end_marker + after\",\n \"def extract_lines(parent: str, begin: Predicate, end: Predicate) -> str:\\n lines = parent.splitlines()\\n\\n begin_line = find_line(lines, begin)\\n end_line = find_line(lines, end, begin_line+1)\\n\\n new_lines = lines[begin_line+1:end_line]\\n\\n return \\\"\\\\n\\\".join(new_lines)\",\n \"def parent_gen(self):\\n yield self\\n if self.parent is not None:\\n yield from self.parent.parent_gen\",\n \"def decorate(self, content: StringList) -> None:\\n super().decorate(content)\\n for line in content[:20]:\\n if line.startswith(TITLE_MARKER):\\n title = line[len(TITLE_MARKER) :].strip()\\n fence = \\\"=\\\" * len(title)\\n content.insert(0, \\\"\\\", \\\"<generated>\\\", 0)\\n content.insert(0, fence, \\\"<generated>\\\", 0)\\n content.insert(0, title, \\\"<generated>\\\", 0)\\n content.insert(0, fence, \\\"<generated>\\\", 0)\",\n \"def generate_child(self, parent1, parent2):\\n if np.random.random() < self.crossover_prob:\\n # crossover\\n x, y = np.sort(np.random.randint(len(parent1), size=2))\\n return np.vstack((parent1[:x], parent2[x:y], parent1[y:]))\\n else:\\n # mutation\\n return self.generate_conformations()[0]\",\n \"def derive(self, code_of_source: str) -> str:\\n min_to_change = self.mr_config['min_to_change']\\n max_to_change = self.mr_config['max_to_change']\\n n_gate_to_change = random.randint(min_to_change, max_to_change)\\n max_to_change = min(n_gate_to_change, self.tot_n_x_gates)\\n\\n sections = metamorph.get_sections(code_of_source)\\n source_code_circuit = sections[\\\"CIRCUIT\\\"]\\n\\n x_gates_to_replace = random.sample(\\n self.instruction_x_gate, max_to_change)\\n\\n mr_metadata = {}\\n mr_metadata[\\\"x_gates_to_replace\\\"] = str(x_gates_to_replace)\\n\\n changed_section = source_code_circuit\\n lines = source_code_circuit.split(\\\"\\\\n\\\")\\n\\n x_gates_to_replace_reverse_order = sorted(\\n x_gates_to_replace, key=lambda x: x[\\\"lineno\\\"], reverse=True)\\n # we start replacing gates, from the last one because each\\n # substitution of an X gate makes the code longer.\\n for x_gate in x_gates_to_replace_reverse_order:\\n # remove gate\\n edit_location = x_gate[\\\"lineno\\\"] - 1\\n removed_original = lines.pop(edit_location)\\n\\n h_gate_last = removed_original.replace(\\\"XGate\\\", \\\"HGate\\\")\\n lines.insert(edit_location, h_gate_last)\\n s_gate_last = removed_original.replace(\\\"XGate\\\", \\\"SGate\\\")\\n lines.insert(edit_location, s_gate_last)\\n s_gate_first = removed_original.replace(\\\"XGate\\\", \\\"SGate\\\")\\n lines.insert(edit_location, s_gate_first)\\n h_gate_first = removed_original.replace(\\\"XGate\\\", \\\"HGate\\\")\\n lines.insert(edit_location, h_gate_first)\\n\\n changed_section = \\\"\\\\n\\\".join(lines)\\n\\n sections[\\\"CIRCUIT\\\"] = changed_section\\n\\n self.metadata = mr_metadata\\n\\n return metamorph.reconstruct_sections(sections)\",\n \"def remove_generated_parts(message):\\n all_lines = []\\n for line in message.split(\\\"\\\\n\\\"):\\n if \\\"<generated>\\\" in line.lower():\\n continue\\n if has_stacktrace_keywords(line) or has_more_lines_pattern(line):\\n continue\\n for symbol in [r\\\"\\\\$\\\", \\\"@\\\"]:\\n all_found_parts = set()\\n for m in re.finditer(r\\\"%s+(.+?)\\\\b\\\" % symbol, line):\\n found_part = m.group(1).strip().strip(symbol).strip()\\n if found_part != \\\"\\\":\\n all_found_parts.add((found_part, m.group(0).strip()))\\n sorted_parts = sorted(list(all_found_parts), key=lambda x: len(x[1]), reverse=True)\\n for found_part in sorted_parts:\\n whole_found_part = found_part[1].replace(\\\"$\\\", r\\\"\\\\$\\\")\\n found_part = found_part[0]\\n part_to_replace = \\\"\\\"\\n if re.search(r\\\"\\\\d\\\", found_part):\\n part_with_numbers_in_the_end = re.search(r\\\"[a-zA-z]{5,}\\\\d+\\\", found_part)\\n if part_with_numbers_in_the_end and part_with_numbers_in_the_end.group(0) == found_part:\\n part_to_replace = \\\" %s\\\" % found_part\\n else:\\n part_to_replace = \\\"\\\"\\n else:\\n part_to_replace = \\\".%s\\\" % found_part\\n try:\\n line = re.sub(whole_found_part, part_to_replace, line)\\n except: # noqa\\n pass\\n\\n line = re.sub(r\\\"\\\\.+\\\", \\\".\\\", line)\\n all_lines.append(line)\\n return \\\"\\\\n\\\".join(all_lines)\",\n \"def __iter__(self: Self) -> Iterator[str]:\\n for line in heapq.merge(sorted(self.removed), sorted(self.added)):\\n if line in self.removed:\\n yield f\\\"- {line}\\\"\\n else:\\n yield f\\\"+ {line}\\\"\",\n \"def update_bases_yaml_as_text(lines: List[str]) -> List[str]:\\n out = []\\n indent: Optional[str] = None\\n done: bool = False\\n for line in lines:\\n print(f\\\"processing {line.strip()}\\\")\\n if done:\\n print(\\\"appending\\\")\\n out.append(line)\\n continue\\n base_match = BASES_MATCH.match(line)\\n if base_match:\\n print(\\\"base matched\\\")\\n if base_match and indent is None:\\n indent = base_match[1]\\n continue\\n if indent is not None and not done:\\n if line.startswith(indent) and len(line.strip()) != 0:\\n # ignore lines that are in the base indent.\\n continue\\n else:\\n # we've reached the end of block so replace the bases with our slot\\n out.extend(BASES_LIST)\\n done = True\\n out.append(line)\\n if done is False and indent is not None:\\n out.extend(BASES_LIST)\\n return out\",\n \"def generate(self, diagram):\",\n \"def gen_child(self, g, ng, child):\\n with About(child.debug, self.relation):\\n self.remap_node((g, child), g, child, ng, ng.apply())\",\n \"def RewriteFile(start, end, original_dir, original_filename, snippet,\\n outdir=None):\\n original_path = GetPath(os.path.join(original_dir, original_filename))\\n original = file(original_path, 'r')\\n original_content = original.read()\\n original.close()\\n if outdir:\\n outpath = os.path.join(outdir, original_filename)\\n else:\\n outpath = original_path\\n out = file(outpath, 'w')\\n rx = re.compile(r'%s\\\\n.*?%s\\\\n' % (re.escape(start), re.escape(end)),\\n re.DOTALL)\\n new_content = re.sub(rx, '%s\\\\n%s%s\\\\n' % (start, snippet, end),\\n original_content)\\n out.write(new_content)\\n out.close()\\n print 'Output ' + os.path.normpath(outpath)\",\n \"def merge_lines(self, curr, new):\\n\\n if len(new) > 2 or new[0] != \\\"NOT:\\\":\\n add = []\\n for i in range(len(new)):\\n if \\\":\\\" in new[i] and new[i+1] != \\\"{\\\":\\n if new[i] in curr:\\n ind = curr.index(new[i])+1\\n curr[ind] = self.merge(curr[ind], new[i+1])\\n else:\\n add.append(new[i])\\n add.append(new[i+1])\\n if add:\\n if curr[-1] == \\\"}\\\":\\n curr = curr[:-1] + add + [curr[-1]]\\n else:\\n curr = curr + add\\n else:\\n curr = curr[:-1]\\n return curr\",\n \"def _generate_examples(self, source_file, target_file):\\n with epath.Path(source_file).open() as f:\\n source_sentences = f.read().split(\\\"\\\\n\\\")\\n with epath.Path(target_file).open() as f:\\n target_sentences = f.read().split(\\\"\\\\n\\\")\\n\\n assert len(target_sentences) == len(\\n source_sentences\\n ), \\\"Sizes do not match: %d vs %d for %s vs %s.\\\" % (\\n len(source_sentences),\\n len(target_sentences),\\n source_file,\\n target_file,\\n )\\n\\n source, target = self.builder_config.language_pair\\n for idx, (l1, l2) in enumerate(zip(source_sentences, target_sentences)):\\n result = {source: l1, target: l2}\\n # Make sure that both translations are non-empty.\\n if all(result.values()):\\n yield idx, result\",\n \"def process_file(src_file, dest_file):\\n # read data\\n with open(src_file) as fil:\\n new_data = fil.read()\\n # generate a chain of templates\\n parent_template = None\\n current_template = dest_file\\n cursor = 1\\n if EXTEND_FLAG in new_data:\\n new_data = new_data.replace(EXTEND_FLAG, \\\"\\\")\\n while exists(current_template):\\n parent_template = current_template\\n current_template = \\\"%s%s%d\\\" % (dest_file, CHILD_TPL_FLAG, cursor)\\n cursor += 1\\n # write data\\n with open(current_template, \\\"w\\\") as fil:\\n if parent_template:\\n # in the chain of templates each has to extend one another\\n new_data = \\\"\\\\n\\\".join([\\n \\\"{%% extends \\\\\\\"%s\\\\\\\" %%}\\\" % parent_template,\\n new_data\\n ])\\n fil.write(new_data)\",\n \"def process(self,line):\\n\\n pattern = re.compile(\\\"@.*?@\\\")\\n matches = pattern.findall(line)\\n for m in matches:\\n replacement = r\\\"<small>{}</small>\\\".format(re.escape(m[1:-1]))\\n line = pattern.sub(replacement,line)\\n\\n return line\",\n \"def test_move_lines_up_into_docstring(self):\\n before_b = '''\\\\\\n #@@language python\\n def test():\\n \\\"\\\"\\\" a\\n b\\n c\\n \\\"\\\"\\\"\\n print 1\\n \\n print 2\\n '''\\n after_b = '''\\\\\\n #@@language python\\n def test():\\n \\\"\\\"\\\" a\\n b\\n c\\n print 1\\n \\\"\\\"\\\"\\n \\n print 2\\n '''\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"7.1\\\", \\\"7.1\\\"),\\n after_sel=(\\\"6.1\\\", \\\"6.1\\\"),\\n command_name=\\\"move-lines-up\\\",\\n )\",\n \"def test_commentline_relationship_unlink(create):\\n clazz1 = create(ClassItem, UML.Class)\\n clazz2 = create(ClassItem, UML.Class)\\n gen = create(GeneralizationItem)\\n\\n connect(gen, gen.head, clazz1)\\n connect(gen, gen.tail, clazz2)\\n\\n assert gen.subject\\n\\n # now, connect comment to a generalization (relationship)\\n comment = create(CommentItem, Comment)\\n line = create(CommentLineItem)\\n connect(line, line.head, comment)\\n connect(line, line.tail, gen)\\n\\n assert gen.subject in comment.subject.annotatedElement\\n assert comment.subject in gen.subject.comment\\n\\n gen.unlink()\\n\\n assert not comment.subject.annotatedElement\\n assert gen.subject is None\",\n \"def test_commentline_relationship_disconnect(create):\\n clazz1 = create(ClassItem, UML.Class)\\n clazz2 = create(ClassItem, UML.Class)\\n gen = create(GeneralizationItem)\\n\\n connect(gen, gen.head, clazz1)\\n connect(gen, gen.tail, clazz2)\\n\\n assert gen.subject\\n\\n # now, connect comment to a generalization (relationship)\\n comment = create(CommentItem, Comment)\\n line = create(CommentLineItem)\\n connect(line, line.head, comment)\\n connect(line, line.tail, gen)\\n\\n assert gen.subject in comment.subject.annotatedElement\\n assert comment.subject in gen.subject.comment\\n\\n disconnect(gen, gen.head)\\n\\n assert gen.subject is None\\n assert not comment.subject.annotatedElement\",\n \"def generate(self):\\n self.graph_repl = self.master.graph_repl\",\n \"def draw(self, parent, cr):\\n for x, y in self.get_block_coords():\\n parent.draw_block_element(cr, x, y)\",\n \"def deduce_new_block_endings(line, hints, block_endings):\\n # Reversing line (extra empty cell removed from the end and put at the end)\\n newline = copy(line[-2::-1] + [-1])\\n block_origins = [len(newline) - 2 - ending for ending in block_endings[::-1]]\\n\\n # Solving equivalent problem with reversed line\\n sth_changed, block_origins = deduce_new_block_origins(newline, hints[::-1],\\n block_origins)\\n\\n # Reversing back obtained solution\\n block_endings = [len(newline) - 2 - origin for origin in block_origins[::-1]]\\n\\n return sth_changed, block_endings\",\n \"def test_reverse_region(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n\\n last line\\n line c\\n line b\\n line a\\n line 1\\n first line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"7.0\\\"),\\n after_sel=(\\\"7.10\\\", \\\"7.10\\\"),\\n command_name=\\\"reverse-region\\\",\\n )\",\n \"def test_extend_to_line(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"3.3\\\", \\\"3.3\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.10\\\"),\\n command_name=\\\"extend-to-line\\\",\\n )\",\n \"def generate(self, lines: List[str]) -> None:\\n raise NotImplemented()\",\n \"def edit_pointers_in_range(self, rng, diff, allow_double_edits=False):\\n # Reinserters with poiner reassignments need double edits enabled (Appareden).\\n #print(\\\"Called edit_pointers_in_range\\\", self.filename, rng, diff)\\n start, stop = rng\\n\\n if diff != 0:\\n print(\\\"Editing pointers in range %s %s with diff %s\\\" % (hex(start), hex(stop), hex(diff)))\\n #print(self.pointers)\\n #for p in self.pointers:\\n #print(hex(p))\\n\\n # Need to move pointers if there are any in this range\\n\\n if self.blocks:\\n #print([hex(p) for p in range(start+1, stop+1)])\\n #print([hex(p) for p in self.pointer_locations])\\n for offset in [p for p in range(start+1, stop+1) if p in self.pointer_locations]:\\n print(hex(offset), \\\"needs to be moved\\\")\\n for p in self.pointers:\\n for loc in self.pointers[p]:\\n if loc.original_location == offset:\\n print(\\\"moving %s -> %s\\\" % (hex(loc.location), hex(loc.location + diff)))\\n loc.move_pointer_location(diff)\\n #print(loc)\\n self.pointer_locations.remove(offset)\\n self.pointer_locations.append(offset + diff)\\n #for p in self.pointers:\\n # print(hex(p), self.pointers[p])\\n else:\\n # Don't need to move pointers if there's no block for them to be in\\n pass\\n\\n\\n for offset in [p for p in range(start+1, stop+1) if p in self.pointers]:\\n print(offset, self.pointers[offset])\\n for ptr in self.pointers[offset]:\\n print(\\\"editing %s (originally %s)\\\" % (ptr, hex(ptr.original_location)))\\n #print(hex(ptr.text_location), hex(ptr.original_text_location))\\n if allow_double_edits:\\n ptr.edit(diff)\\n else:\\n if start+1 <= ptr.original_text_location <= stop+1:\\n if self.blocks:\\n block_found = False\\n for b in self.blocks:\\n if b.start <= ptr.original_location <= b.stop:\\n block_found = True\\n ptr.edit(diff, block=b)\\n if not block_found:\\n ptr.edit(diff)\\n else:\\n ptr.edit(diff)\\n else:\\n print(\\\"Skipping this one to avoid double-edit\\\")\",\n \"def annotate_entity(\\n self,\\n ent: Span,\\n sub_preceding: List[Span],\\n sub_following: List[Span],\\n ) -> None:\\n if self.within_ents:\\n cues = [m for m in sub_preceding if m.end <= ent.end]\\n cues += [m for m in sub_following if m.start >= ent.start]\\n else:\\n cues = [m for m in sub_preceding if m.end <= ent.start]\\n cues += [m for m in sub_following if m.start >= ent.end]\\n\\n negation = ent._.negation or bool(cues)\\n\\n ent._.negation = negation\\n\\n if self.explain and negation:\\n ent._.negation_cues += cues\\n\\n if not self.on_ents_only and negation:\\n for token in ent:\\n token._.negation = True\",\n \"def ress_move_on_page(self, content=None):\\n outside_ress = self.outside_ress\\n content = content or self.content\\n\\n for blo in outside_ress:\\n\\n mch = re.search(r'(\\\\s|\\\\t)-block %s'%blo, content) # blo = links, onload etc\\n\\n if not mch:\\n\\n warn(blo+' block is undefined in root template %s'%self.origin.__str__()) # raise Exception(blo+' block is undefined in root template %s'%origin.__str__())\\n\\n super_block = r'\\\\t\\\\t={ block.super }\\\\n'\\n content = re.sub(\\n r'(-extends \\\"[\\\\w\\\\.]+\\\")\\\"', r'\\\\1\\\\n\\\\t-block %s%s%s'%(\\n blo, super_block, __indent_block(r'\\\\t\\\\t', outside_ress[blo].value)\\n ),\\n content\\n )\\n\\n else:\\n _blo = self.__indent_block(mch.groups()[0]+' '*4, outside_ress[blo].value)\\n\\n # (\\\\s|\\\\t)-block \\\\w+(([\\\\s:]*={ *block.super *})|) ={ *block.super *} - \\\\2\\n\\n content = re.sub(r'(\\\\s|\\\\t)(-block %s)'%blo, r'\\\\1\\\\2\\\\n'+_blo, content)\\n\\n## _blo = _indent_block(mch.groups()[0]+' '*8, blo)\\n## _blo = '\\\\n\\\\1 :javascript\\\\n' + _blo\\n\\n return content\",\n \"def replace_id(self, old_id, new_id):\\n def replace(prf):\\n for item in prf.items:\\n item.prevs = [new_id if id == old_id else id for id in item.prevs]\\n if item.subproof:\\n replace(item.subproof)\\n\\n prf = self.prf.get_parent_proof(old_id)\\n replace(prf)\\n\\n self.remove_line(old_id)\",\n \"def get_line_changed_regions(self, old_line_num, old_line,\\n new_line_num, new_line):\\n return \\\\\\n super(MarkdownDiffChunkGenerator, self).get_line_changed_regions(\\n old_line_num,\\n strip_tags(old_line),\\n new_line_num,\\n strip_tags(new_line))\",\n \"def extend_template(base, text):\\n\\n block_search = re.compile(\\\"{{(block) (\\\\w+)}}\\\")\\n has_blocks = re.search(block_search, base)\\n if not has_blocks:\\n return base\\n else:\\n find_content = re.compile(\\\"({{block \\\"+has_blocks.group(2)+\\\"}})(.*?)({{endblock}})\\\", re.DOTALL)\\n \\n content = re.search(find_content, text).group(2)\\n base = re.sub(\\\"{{block \\\"+has_blocks.group(2)+\\\"}}\\\", content, base)\\n return extend_template(base, text)\",\n \"def reconstruct_path(start, current, came_from):\\n\\n while current in came_from:\\n current = came_from[current]\\n if current != start:\\n current.add_block(GOLDEN)\\n pygame.display.update()\",\n \"def process_SEQ(self, seq_in, original_pos, read_pos, original_end, read_end):\\n if original_pos > read_end or original_end < read_pos:\\n return \\\"Remove\\\"\\n # By having the positions, we can address which case are we dealing with, and transform the sequence accordingly.\\n if original_pos == read_pos and original_end == read_end:\\n where = \\\"==\\\"\\n cutoff = 0\\n seq = seq_in\\n elif original_pos > read_pos and original_end == read_end:\\n where = \\\"+=\\\"\\n cutoff = original_pos - read_pos\\n seq = seq_in[cutoff:]\\n elif original_pos > read_pos and original_end > read_end:\\n where = \\\"++\\\"\\n cutoff_init = original_pos - read_pos\\n cutoff_end = original_end - read_end\\n seq = seq_in[cutoff_init:] + \\\" \\\" * cutoff_end\\n elif original_pos == read_pos and original_end > read_end:\\n where = \\\"=+\\\"\\n cutoff_end = original_end - read_end\\n seq = seq_in + \\\" \\\" * cutoff_end\\n elif original_pos == read_pos and original_end < read_end:\\n where = \\\"=-\\\"\\n cutoff_end = original_end - read_end # it will be negative\\n seq = seq_in[:cutoff_end]\\n elif original_pos < read_pos and original_end == read_end:\\n where = \\\"-=\\\"\\n cutoff_init = read_pos - original_pos\\n seq = cutoff_init * \\\" \\\" + seq_in\\n elif original_pos < read_pos and original_end < read_end:\\n where = \\\"--\\\"\\n cutoff_init = read_pos - original_pos\\n cutoff_end = original_end - read_end\\n seq = cutoff_init * \\\" \\\" + seq_in[:cutoff_end]\\n elif original_pos > read_pos and original_end < read_end:\\n where = \\\"+-\\\"\\n cutoff_init = original_pos - read_pos\\n cutoff_end = original_end - read_end\\n seq = seq_in[cutoff_init:cutoff_end]\\n elif original_pos < read_pos and original_end > read_end:\\n where = \\\"-+\\\"\\n cutoff_init = read_pos - original_pos\\n cutoff_end = original_end - read_end\\n seq = cutoff_init * \\\" \\\" + seq_in + cutoff_end * \\\" \\\"\\n return seq\",\n \"def modifyends(dna, left=\\\"\\\", right=\\\"\\\", add=0, add_right=0, add_left=0, supfeature=False, product=None, process_name=None, \\n process_description=None, pn=None, pd=None, quinable=True, **kwargs):\\n\\n kwargs.setdefault(\\\"_sourcefile\\\", None) \\n kwargs.setdefault(\\\"process_id\\\", None)\\n kwargs.setdefault(\\\"original_ids\\\", []) \\n _sourcefile = kwargs[\\\"_sourcefile\\\"] \\n process_id = kwargs[\\\"process_id\\\"] \\n original_ids = kwargs[\\\"original_ids\\\"]\\n\\n if dna._ssdna == True:\\n raise TypeError(\\\"ssDNA object cannot be processed by `modifydna` function\\\") \\n \\n project = None\\n project = project if product is None else product\\n process_name = pn if process_name is None else process_name\\n process_description = pd if process_description is None else process_description\\n\\n if dna.topology == \\\"circular\\\":\\n raise ValueError(\\\"End sequence structures cannot be modified. The topology of the given QUEEN_object is circular.\\\") \\n else:\\n pass\\n \\n def parse(seq,count=0):\\n l_bracket = re.compile(\\\"\\\\(\\\")\\n r_bracket = re.compile(\\\"\\\\)\\\")\\n l_brace = re.compile(\\\"\\\\{\\\")\\n r_brace = re.compile(\\\"\\\\}\\\")\\n if set(str(seq)) <= set(\\\"0123456789ATGCRYKMSWBDHVNatgcnrykmswbdhv{}()/-*\\\"):\\n lbk_list = [l.start() for l in re.finditer(l_bracket,seq)]\\n lbc_list = [l.start() for l in re.finditer(l_brace,seq)]\\n rbc_list = [l.start() for l in re.finditer(r_brace,seq)]\\n rbk_list = []\\n for bk in lbk_list:\\n n = 0\\n p = bk\\n for c in seq[bk:]:\\n if c == \\\"(\\\":\\n n += 1\\n elif c == \\\")\\\":\\n n -= 1\\n if n == 0:\\n rbk_list.append(p)\\n break\\n p += 1\\n \\n if len(lbk_list) == len(rbk_list):\\n bk_set = list(zip(lbk_list,rbk_list))\\n bc_set = list(zip(lbc_list,rbc_list))\\n if len(bk_set) > 0:\\n for bks in bk_set:\\n new_seq = seq[bks[0]+1:bks[1]] \\n if \\\"(\\\" not in new_seq: \\n num = 0\\n flag = 0\\n sub_lbc_list = [l.start() for l in re.finditer(l_brace,new_seq)]\\n sub_rbc_list = [l.start() for l in re.finditer(r_brace,new_seq)]\\n sub_bc_set = list(zip(sub_lbc_list, sub_rbc_list))\\n new_new_seq = new_seq\\n sub_bc_set.sort()\\n for bcs in sub_bc_set:\\n try:\\n num = int(new_seq[bcs[0]+1:bcs[1]])\\n except:\\n return False\\n if num > 0:\\n new_new_seq = new_new_seq[:new_new_seq.find(\\\"{\\\")-1] + new_seq[bcs[0]-1] * num + new_seq[bcs[1]+1:] \\n else:\\n pass\\n new_seq = new_new_seq\\n num = 0\\n for bcs in bc_set:\\n if bcs[0] == bks[1]+1:\\n try:\\n num = int(seq[bcs[0]+1:bcs[1]])\\n except:\\n return False\\n break\\n else:\\n pass\\n if num > 0:\\n new_seq = new_seq * num\\n else:\\n pass\\n break\\n else:\\n pass\\n new_seq = seq[:bks[0]] + new_seq + seq[bcs[1]+1:]\\n \\n else:\\n new_seq = seq\\n bc_set.sort()\\n for bcs in bc_set:\\n try:\\n num = int(seq[bcs[0]+1:bcs[1]])\\n except:\\n return False\\n if num > 0:\\n new_seq = new_seq[:new_seq.find(\\\"{\\\")-1] + seq[bcs[0]-1] * num + seq[bcs[1]+1:] \\n else:\\n pass\\n \\n if set(str(new_seq)) <= set(\\\"ATGCRYKMSWBDHVNatgcnrykmswbdhv/-*\\\"):\\n pass\\n else:\\n new_seq = parse(new_seq,count+1)\\n return new_seq\\n else:\\n return False\\n else:\\n return False\\n \\n def check_endseq(top, bottom):\\n #Check if the top strand seqeunce is complement with the bottom strand. \\n new_top = \\\"\\\"\\n new_bottom = \\\"\\\"\\n for t,b in zip(top,bottom):\\n if t != b.translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")) and (t != \\\"-\\\" and b != \\\"-\\\"):\\n return False, False\\n new_top += t\\n new_bottom += b\\n return new_top, new_bottom\\n \\n if left == \\\"\\\":\\n left = \\\"*/*\\\"\\n \\n if right == \\\"\\\":\\n right = \\\"*/*\\\"\\n \\n left_origin, right_origin = left, right\\n left, right = parse(left.upper()), parse(right.upper())\\n left, rihgt = str(left), str(right) \\n pattern1, pattern2, patternl1, patternl2, patternr1, patternr2 = \\\"[ATGCRYKMSWBDHVN*-]*/?[ATGCRYKMSWBDHVN*-]*\\\", \\\"[ATGCRYKMSWBDHVN*]+-+[ATGCRYKMSWBDHVN*]+\\\", \\\"^[ATGCRYKMSWBDHVN*]+-+/\\\", \\\"/[ATGCRYKMSWBDHVN*]+-+$\\\", \\\"^-+[ATGCRYKMSWBDHVN*]+/\\\", \\\"/-+[ATGCRYKMSWBDHVN*]+$\\\" \\n pattern1 = re.compile(pattern1) \\n pattern2 = re.compile(pattern2) \\n patternl1 = re.compile(patternl1)\\n patternl2 = re.compile(patternl2)\\n patternr1 = re.compile(patternr1)\\n patternr2 = re.compile(patternr2)\\n left_end, right_end = left, right\\n \\n if pattern1.fullmatch(left_end) != None and pattern2.search(left_end) is None and patternl1.search(left_end) is None and patternl2.search(left_end) is None:\\n pass \\n else:\\n raise TypeError(\\\"Please sepcify a proper sequence pattern for the 'left' argument\\\") \\n \\n if pattern1.fullmatch(right_end) != None and pattern2.search(right_end) is None and patternr1.search(right_end) is None and patternr2.search(right_end) is None:\\n pass\\n else:\\n raise TypeError(\\\"Please sepcify a proper sequence pattern for the 'right' argument\\\") \\n \\n if \\\"/\\\" in left_end:\\n left_end_top, left_end_bottom = left_end.split(\\\"/\\\")\\n else:\\n add = 1\\n add_left = 1\\n left_end_top, left_end_bottom = left_end, left_end.translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\"))\\n left_end = left_end_top + \\\"/\\\" + left_end_bottom\\n\\n if len(left_end_top) != len(left_end_bottom):\\n raise ValueError(\\\"Please specify a proper end sequence structure for the 'left' argument.\\\")\\n \\n elif \\\"-\\\" in left_end or \\\"*\\\" in left_end:\\n left_end_top, left_end_bottom = check_endseq(left_end_top, left_end_bottom)\\n if left_end_top != False:\\n left_end_length = len(left_end_top)\\n if \\\"*\\\" in left_end_top or \\\"*\\\" in left_end_bottom:\\n if set(left_end_top) <= set([\\\"*\\\",\\\"-\\\"]) and set(left_end_bottom) <= set([\\\"*\\\",\\\"-\\\"]):\\n left_end_top = \\\"\\\".join([s if q != \\\"-\\\" else \\\"-\\\" for s,q in zip(dna.seq[:left_end_length], left_end_top)])\\n left_end_bottom = \\\"\\\".join([s if q != \\\"-\\\" else \\\"-\\\" for s,q in zip(dna.seq[:left_end_length].translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")), left_end_bottom)])\\n else:\\n raise ValueError(\\\"'*' cannot be used wih IUPAC nucleotide codes\\\")\\n \\n left_end_top, left_end_bottom = left_end_top.replace(\\\"-\\\",\\\"\\\"), left_end_bottom.replace(\\\"-\\\",\\\"\\\") \\n if len(left_end_top) < len(left_end_bottom):\\n left_length = len(left_end_bottom)\\n left_end = left_end_bottom[0:len(left_end_bottom)-1*len(left_end_top)].translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")) \\n left_end_top = -1\\n left_end_bottom = 1\\n\\n elif len(left_end_top) > len(left_end_bottom):\\n left_length = len(left_end_top)\\n left_end = left_end_top[0:len(left_end_top)-1*len(left_end_bottom)]\\n left_end_top = 1\\n left_end_bottom = -1\\n \\n else:\\n left_length = len(left_end_top)\\n left_end = left_end_top[0:len(left_end_top)-1*len(left_end_bottom)]\\n left_end_top = 1\\n left_end_bottom = 1\\n else:\\n add = 1\\n add_left = 1\\n left_end = left_end_top + \\\"/\\\" + left_end_bottom\\n\\n else:\\n raise ValueError(\\\"Please specify a proper end sequence structure for the 'left' argument.\\\")\\n else:\\n left_end_length = len(left_end_top) \\n left_length = len(left_end_top)\\n left_end_top = 1\\n left_end_bottom = 1\\n\\n if \\\"/\\\" in right_end:\\n right_end_top, right_end_bottom = right_end.split(\\\"/\\\")\\n else:\\n add = 1\\n add_right = 1 \\n right_end_top, right_end_bottom = right_end, right_end.translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\"))\\n right_end = right_end_top + \\\"/\\\" + right_end_bottom\\n \\n if len(right_end_top) != len(right_end_bottom):\\n raise ValueError(\\\"Please specify a proper end sequence structure for the 'right' argument.\\\")\\n \\n elif \\\"-\\\" in right_end or \\\"*\\\" in right_end:\\n right_end_top, right_end_bottom = check_endseq(right_end_top, right_end_bottom)\\n if right_end_top != False:\\n right_end_length = len(right_end_top)\\n if \\\"*\\\" in right_end_top or \\\"*\\\" in right_end_bottom:\\n if set(right_end_top) <= set([\\\"*\\\",\\\"-\\\"]) and set(right_end_bottom) <= set([\\\"*\\\",\\\"-\\\"]):\\n right_end_top = \\\"\\\".join([s if q != \\\"-\\\" else \\\"-\\\" for s,q in zip(dna.seq[-1*right_end_length:], right_end_top)])\\n right_end_bottom = \\\"\\\".join([s if q != \\\"-\\\" else \\\"-\\\" for s,q in zip(dna.seq[-1*right_end_length:].translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")), right_end_bottom)])\\n else:\\n raise ValueError(\\\"'*' cannot be used wih characters for DNA sequence.\\\")\\n\\n right_end_top, right_end_bottom = right_end_top.replace(\\\"-\\\",\\\"\\\"), right_end_bottom.replace(\\\"-\\\",\\\"\\\") \\n if len(right_end_top) < len(right_end_bottom):\\n right_length = len(right_end_bottom)\\n right_end = right_end_bottom[len(right_end_top):].translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")) \\n right_end_top = -1\\n right_end_bottom = 1\\n\\n elif len(right_end_top) > len(right_end_bottom):\\n right_length = len(right_end_top)\\n right_end = right_end_top[len(right_end_bottom):] \\n right_end_top = 1\\n right_end_bottom = -1\\n \\n else:\\n right_length = len(right_end_top)\\n right_end = right_end_top[len(right_end_bottom):] \\n right_end_top = 1\\n right_end_bottom = 1\\n else:\\n add = 1\\n add_right = 1 \\n right_end = right_end_top + \\\"/\\\" + right_end_bottom\\n\\n else:\\n raise ValueError(\\\"Please specify a proper end sequence structure for the 'right' argument.\\\")\\n else:\\n right_end_length = len(right_end_top) \\n right_length = len(right_end_top) \\n right_end_top = 1\\n right_end_bottom = 1\\n \\n if add == 1 or (left_end != dna.seq[left_end_length-left_length:left_end_length-left_length+len(left_end)] \\n or right_end != str(dna[len(dna.seq)-right_end_length + right_length - len(right_end):len(dna.seq)-right_end_length + right_length].seq)):\\n \\n if add_left == 1 and add_right == 1:\\n new_dna = dna.__class__(seq=left_end.split(\\\"/\\\")[0] + dna.seq + right_end.split(\\\"/\\\")[0] + \\\"/\\\" \\n + left_end.split(\\\"/\\\")[1] + dna.seq.translate(str.maketrans(\\\"ATGCRYKMSWBDHV\\\",\\\"TACGYRMKWSVHDB\\\")) + right_end.split(\\\"/\\\")[1], quinable=0) \\n new_dna._dnafeatures = _slide(dna.dnafeatures, len(left_end.split(\\\"/\\\")[0])) \\n new_dna.record = copy.copy(dna.record) \\n new_dna.record.features = new_dna.dnafeatures\\n new_dna._positions = (-1,) * len(left_end.split(\\\"/\\\")[0]) + new_dna._positions + (-1,) * len(right_end.split(\\\"/\\\")[0])\\n \\n \\n elif add_right == 1:\\n left_end = dna.__class__(seq=left_end, quinable=0) \\n right_end = dna.__class__(seq=right_end, quinalbe=0) \\n new_dna = cropdna(dna, start=left_end_length-left_length, end=len(dna.seq), quinable=0) + right_end\\n new_dna._right_end = right_end._right_end\\n new_dna._left_end = left_end.seq\\n new_dna._left_end_top = left_end_top \\n new_dna._left_end_bottom = left_end_bottom\\n new_dna._positions = new_dna._positions + (-1,) * len(right_end.seq)\\n \\n else:\\n left_end = dna.__class__(seq=left_end, quinable=0) \\n right_end = dna.__class__(seq=right_end, quinable=0) \\n new_dna = left_end + cropdna(dna, start=0, end=len(dna.seq)-right_end_length+right_length, quinable=0)\\n new_dna._left_end = left_end._left_end\\n new_dna._right_end = right_end.seq\\n new_dna._right_end_top = right_end_top \\n new_dna._right_end_bottom = right_end_bottom\\n new_dna._positions = (-1,) * len(left_end.seq) + new_dna._positions\\n \\n if type(left_origin) == new_dna.seq.__class__ and left_origin.parental_class == \\\"QUEEN\\\": \\n parental_id = left_origin.parental_id\\n tmp_left = None\\n if left_origin.name is not None: \\n if left_origin.name == \\\"rcseq\\\":\\n tmp_left = flipdna(left_origin.parent, quinable==0) \\n else:\\n tmp_left = None\\n else:\\n tmp_left = left_origin.parent\\n \\n if tmp_left is not None:\\n new_dna._dnafeatures = tmp_left.dnafeatures + new_dna._dnafeatures\\n\\n if type(right_origin) == new_dna.seq.__class__ and right_origin.parental_class == \\\"QUEEN\\\": \\n parental_id = right_origin.parental_id\\n tmp_right = None\\n if right_origin.name is not None: \\n if right_origin.name == \\\"rcseq\\\":\\n tmp_right = flipdna(right_origin.parent, quinable==0) \\n else:\\n tmp_right = None\\n else:\\n tmp_right = right_origin.parent\\n\\n if tmp_right is not None:\\n new_dna._dnafeatures += _slide(tmp_right.dnafeatures, len(left_end.split(\\\"/\\\")[0]) + len(dna.seq))\\n \\n new_dna._history_feature = dna._history_feature \\n \\n #Recover fragmented features if complete sequence is in the construct.\\n new_features = [] \\n remove_features = [] \\n for feat in new_dna.dnafeatures:\\n if \\\"broken_feature\\\" in feat.qualifiers:\\n note = feat.qualifiers[\\\"broken_feature\\\"][0]\\n label = \\\":\\\".join(note.split(\\\":\\\")[:-1])\\n poss, pose = list(map(int,note.split(\\\":\\\")[-1].split(\\\"..\\\")))\\n length = int(note.split(\\\":\\\")[-4]) \\n if feat.location.strand != -1:\\n sfeat = feat.start-(poss-1) \\n sfeat = sfeat if sfeat > 0 else len(new_dna.seq) + sfeat\\n efeat = feat.end+(length-pose)\\n else:\\n sfeat = feat.start-(length-pose) \\n sfeat = sfeat if sfeat > 0 else len(new_dna.seq) + sfeat\\n efeat = feat.end+(poss-1) \\n \\n if note.split(\\\":\\\")[-3] == new_dna.printsequence(sfeat, efeat, strand=feat.location.strand):\\n if sfeat < efeat:\\n location = FeatureLocation(sfeat, efeat, feat.location.strand) \\n else:\\n location = CompoundLocation([FeatureLocation(sfeat, len(new_dna.seq)), FeatureLocation(0, efeat, feat.location.strand)]) \\n newfeat = feat.__class__(location=location, subject=new_dna)\\n newfeat.type = feat.type\\n newfeat.qualifiers = feat.qualifiers\\n del newfeat.qualifiers[\\\"broken_feature\\\"]\\n newfeat._id = label.split(\\\":\\\")[1]\\n new_features.append(newfeat)\\n remove_features.append(feat)\\n \\n for feat in remove_features:\\n del new_dna._dnafeatures[new_dna.dnafeatures.index(feat)] \\n \\n for feat in new_features:\\n new_dna._dnafeatures.append(feat) \\n else:\\n new_dna = copy.deepcopy(dna) \\n new_dna._left_end = left_end\\n new_dna._right_end = right_end\\n new_dna._left_end_top = left_end_top \\n new_dna._left_end_bottom = left_end_bottom\\n new_dna._right_end_top = right_end_top\\n new_dna._right_end_bottom = right_end_bottom\\n \\n if project is None:\\n new_dna._unique_id = dna._unique_id \\n else:\\n new_dna._unique_id = project\\n \\n if type(supfeature) in (tuple, list) and type(supfeature[0]) == dict:\\n for feature_dict in supfeature: \\n new_dna.setfeature(feature_dict) \\n elif type(supfeature) == dict:\\n new_dna.setfeature(supfeature)\\n \\n if quinable == True:\\n args = [] \\n history_features = [new_dna._history_feature] \\n args.append(\\\"'{}'\\\".format(new_dna._unique_id))\\n args.append(\\\"'{}'\\\".format(dna._unique_id)) \\n ends = [] \\n if type(left_origin) == new_dna.seq.__class__:\\n if left_origin.parental_class == \\\"DNAFeature\\\":\\n qkey = left_origin.qkey\\n for qindex, qfeat in enumerate(new_dna.__class__.queried_features_dict[qkey]):\\n if qfeat._second_id == left_origin.parental_id:\\n break\\n if type(left_origin.item) == int:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].{}[{}]\\\".format(qkey, qindex, \\\"seq\\\" , left_origin.item))\\n elif type(left_origin.item) == slice:\\n sl_start = left_origin.item.start\\n sl_stop = left_origin.item.stop \\n sl_step = left_origin.item.step\\n sl_start = \\\"\\\" if sl_start is None else sl_start\\n sl_stop = \\\"\\\" if sl_stop is None else sl_stop\\n if sl_step == 1 or sl_step == None:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}]\\\".format(qkey, qindex, sl_start, sl_stop))\\n else:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}:{}]\\\".format(qkey, qindex, sl_start, sl_stop, sl_step))\\n else:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq\\\".format(qkey, qindex))\\n history_features.append(left_origin.parent.subject._history_feature) \\n\\n elif left_origin.parental_class == \\\"QUEEN\\\": \\n parental_id = left_origin.parental_id\\n\\n if left_origin.name != None: \\n if \\\"printsequence\\\" in left_origin.name:\\n if len(left_origin.name.split(\\\"_\\\")) == 2: \\n seqname = \\\"QUEEN.dna_dict['{}'].printsequence(strand={})\\\".format(parental_id, left_origin.name.split(\\\"_\\\")[-1]) \\n else:\\n seqname = \\\"QUEEN.dna_dict['{}'].printsequence(start={}, end={}, strand={})\\\".format(parental_id, *left_origin.name.split(\\\"_\\\")[1:])\\n elif lefet_origin.name == \\\"rcseq\\\":\\n seqname = \\\"QUEEN.dna_dict['{}'].rcseq\\\".format(parental_id) \\n else:\\n seqname = \\\"QUEEN.dna_dict['{}'].seq\\\".format(parental_id)\\n\\n if type(left_origin.item) == int:\\n args.append(\\\"{}.seq[{}]\\\".format(seqname, left_origin.item))\\n elif type(left_origin.item) == slice:\\n sl_start = left_origin.item.start\\n sl_stop = left_origin.item.stop \\n sl_step = left_origin.item.step\\n sl_start = \\\"\\\" if sl_start is None else sl_start\\n sl_stop = \\\"\\\" if sl_stop is None else sl_stop\\n if sl_step == 1 or sl_step == None:\\n args.append(\\\"{}[{}:{}]\\\".format(seqname, sl_start, sl_stop))\\n else:\\n args.append(\\\"{}[{}:{}:{}]\\\".format(seqname, sl_start, sl_stop, sl_step))\\n else:\\n args.append(\\\"{}\\\".format(seqname))\\n history_features.append(left_origin.parent._history_feature) \\n \\n elif left_origin.parental_class == \\\"Cutsite\\\":\\n if left_origin.parent.name not in cs.defaultkeys:\\n cs.new_cutsites.append((left_origin.parent.name, left_origin.parent.cutsite)) \\n args.append(\\\"cs.lib['{}'].{}\\\".format(left_origin.parent.name, left_origin.name)) \\n else:\\n args.append(\\\"'{}'\\\".format(left_origin)) \\n ends.append(left) \\n else:\\n ends.append(left_origin) \\n args.append(\\\"'{}'\\\".format(left_origin)) \\n \\n if type(right_origin) == new_dna.seq.__class__:\\n if right_origin.parental_class == \\\"DNAFeature\\\":\\n qkey = right_origin.qkey\\n for qindex, qfeat in enumerate(new_dna.__class__.queried_features_dict[qkey]):\\n if qfeat._second_id == right_origin.parental_id:\\n break\\n if type(right_origin.item) == int:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].{}[{}]\\\".format(qkey, qindex, \\\"seq\\\" , right_origin.item))\\n elif type(right_origin.item) == slice:\\n sl_start = right_origin.item.start \\n sl_stop = right_origin.item.stop \\n sl_step = right_origin.item.step\\n sl_start = \\\"\\\" if sl_start is None else sl_start\\n sl_stop = \\\"\\\" if sl_stop is None else sl_stop\\n if sl_step == 1 or sl_step == None:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}]\\\".format(qkey, qindex, sl_start, sl_stop))\\n else:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq[{}:{}:{}]\\\".format(qkey, qindex, sl_start, sl_stop, sl_step))\\n else:\\n args.append(\\\"QUEEN.queried_features_dict['{}'][{}].seq\\\".format(qkey, qindex))\\n history_features.append(right_origin.parent.subject._history_feature) \\n\\n elif right_origin.parental_class == \\\"QUEEN\\\": \\n parental_id = right_origin.parental_id\\n \\n if right_origin.name != None: \\n if \\\"printsequence\\\" in right_origin.name:\\n if len(right_origin.name.split(\\\"_\\\")) == 2: \\n seqname = \\\"QUEEN.dna_dict['{}'].printsequence(strand={})\\\".format(parental_id, right_origin.name.split(\\\"_\\\")[-1]) \\n else:\\n seqname = \\\"QUEEN.dna_dict['{}'].printsequence(start={}, end={}, strand={})\\\".format(parental_id, *right_origin.name.split(\\\"_\\\")[1:])\\n elif right_origin.name == \\\"rcseq\\\":\\n seqname = \\\"QUEEN.dna_dict['{}'].rcseq\\\".format(parental_id) \\n else:\\n seqname = \\\"QUEEN.dna_dict['{}'].seq\\\".format(parental_id)\\n \\n if type(right_origin.item) == int:\\n args.append(\\\"{}[{}]\\\".format(seqname, right_origin.item))\\n \\n elif type(right_origin.item) == slice:\\n sl_start = right_origin.item.start\\n sl_stop = right_origin.item.stop \\n sl_step = right_origin.item.step\\n sl_start = \\\"\\\" if sl_start is None else sl_start\\n sl_stop = \\\"\\\" if sl_stop is None else sl_stop\\n if sl_step == 1 or sl_step == None:\\n args.append(\\\"{}[{}:{}]\\\".format(seqname, sl_start, sl_stop))\\n else:\\n args.append(\\\"{}[{}:{}:{}]\\\".format(seqname, sl_start, sl_stop, sl_step))\\n else:\\n args.append(\\\"{}\\\".format(seqname))\\n history_features.append(right_origin.parent._history_feature) \\n \\n elif right_origin.parental_class == \\\"Cutsite\\\":\\n if right_origin.parent.name not in cs.defaultkeys:\\n cs.new_cutsites.add((right_origin.parent.name, right_origin.parent.cutsite)) \\n args.append(\\\"cs.lib['{}'].{}\\\".format(right_origin.parent.name, right_origin.name)) \\n\\n else:\\n args.append(\\\"'{}'\\\".format(right_origin)) \\n ends.append(right)\\n else:\\n ends.append(right_origin) \\n args.append(\\\"'{}'\\\".format(right_origin)) \\n\\n project = \\\"\\\" \\n fsupfeature = \\\"\\\" if supfeature == False else \\\", supfeature={}\\\".format(str(supfeature)) \\n fproduct = \\\"\\\" if product is None else \\\", product='\\\" + product + \\\"'\\\"\\n process_name = \\\"\\\" if process_name is None else \\\", process_name='\\\" + process_name + \\\"'\\\"\\n process_description = \\\"\\\" if process_description is None else \\\", process_description='\\\" + process_description + \\\"'\\\" \\n\\n new_dna._product_id = new_dna._unique_id if product is None else product \\n building_history = \\\"QUEEN.dna_dict['{}'] = modifyends(QUEEN.dna_dict['{}'], left={}, right={}{}{}{}{}{})\\\".format(new_dna._product_id, dna._product_id, args[2], args[3], fsupfeature, project, fproduct, process_name, process_description) \\n history_feature = _combine_history(new_dna, history_features) \\n new_dna._history_feature = history_feature\\n process_id, original_ids = make_processid(new_dna, building_history, process_id, original_ids)\\n add_history(new_dna, [building_history, \\\"left: {}; right: {}; leftobj: {}; rightobj: {}\\\".format(*ends, args[2], args[3]), \\\",\\\".join([process_id] + original_ids)], _sourcefile) \\n new_dna._check_uniqueness()\\n else:\\n new_dna.__dict__[\\\"_product_id\\\"] = dna._product_id if \\\"_product_id\\\" in dna.__dict__ else dna._unique_id\\n\\n for dnafeature in new_dna.dnafeatures:\\n dnafeature.subject = new_dna\\n \\n if product is None:\\n pass \\n else:\\n product = product.replace(\\\" \\\",\\\"\\\")\\n match = re.fullmatch(\\\"(.+)\\\\[(.+)\\\\]\\\", product)\\n if match:\\n if match.group(2).isdecimal() == True:\\n new_dna.__class__._namespace[match.group(1)][int(match.group(2))] = new_dna\\n else:\\n new_dna.__class__._namespace[match.group(1)][match.group(2)] = new_dna\\n else: \\n new_dna.__class__._namespace[product] = new_dna\\n return new_dna\",\n \"def generateCommentBlock(self):\\n\\t\\tself.printt_cls(\\\"# ===================================================================\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# WARNING: This is an auto-generated file. Do not modify this file.\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# ===================================================================\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"#\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# {} Model\\\".format(self.objName), cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"#\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# ===================================================================\\\", cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# Generated on: {ts}\\\".format(ts = str(datetime.now())), cs.PASTEL_YELLOW)\\n\\t\\tself.printt_cls(\\\"# ===================================================================\\\", cs.PASTEL_YELLOW)\",\n \"def GenerateDiff(self, args):\\n raise NotImplementedError(\\n \\\"abstract method -- subclass %s must override\\\" % self.__class__)\",\n \"def generate_output(input_filename: str, output_filename: str, goal_node: Node,\\n generated: set) -> None:\\n\\n input_stream = io.open(input_filename, 'r', encoding='utf-8', errors='ignore',\\n newline='\\\\n')\\n with open(output_filename, 'w') as out_file:\\n for i in range(0, 10):\\n out_file.write(input_stream.readline().rstrip())\\n out_file.write('\\\\n')\\n \\\"\\\"\\\" The first ten lines of the output file are identical to those in the \\n input file. The tenth line should be skipped because it's blank.\\\"\\\"\\\"\\n out_file.write(str(goal_node.path_cost) + '\\\\n')\\n # Line 11 of the output, the depth level d\\n out_file.write(str(len(generated)) + '\\\\n')\\n # Line 12 of the output, the total number of nodes generated\\n\\n # Writing Line 13 of the output, the sequence of moves\\n length = len(goal_node.path_history)\\n for i in range(length - 1):\\n out_file.write(goal_node.path_history[i] + ' ')\\n out_file.write(goal_node.path_history[length - 1] + '\\\\n')\\n\\n # Writing Line 14 of the output, the f(n) values\\n f_line = str(goal_node.f) + ' '\\n parent = goal_node.parent\\n while parent: # Loop stops when parent == None\\n f_line += (str(parent.f) + ' ')\\n parent = parent.parent\\n f_list = f_line.split(' ')\\n # Breaks down the string to the integers it contains\\n reverse = ''\\n for i in range(len(f_list) - 2, -1, -1):\\n # f_line[len(f_line)-1] is an extra whitespace character and\\n # thus shouldn't be copied\\n reverse += str(f_list[i])\\n if i != 0:\\n reverse += ' '\\n \\\"\\\"\\\" The order of the f(n) values in f_line is from goal node \\n to root node. The four lines above reverse the order, which \\n is what the output format expects.\\\"\\\"\\\"\\n out_file.write(reverse)\\n\\n out_file.close()\",\n \"def translate(self):\\n self.get_t_sect()[\\n 'datetime_start'] = datetime.datetime.now().isoformat()\\n seen_noncomment = False\\n parsing_gate = False\\n gate_def = ''\\n gate_start_line = None\\n gate_start_linenum = None\\n seen_open_curly = False\\n\\n while self.source_frame_stack.depth():\\n filenum, linenum, line = self.source_frame_stack.next()\\n if line is None:\\n self.source_frame_stack.pop()\\n continue\\n astElement = None\\n line = line.strip()\\n line = line.replace(', ', ',')\\n line = line.replace(' ;', ';')\\n eolComment = ASTType.ast_eol_comment(line)\\n\\n if parsing_gate:\\n if not seen_open_curly:\\n x = QTRegEx.START_CURLY.search(line)\\n if not x:\\n raise Qasm_Gate_Missing_Open_Curly_Exception(filenum,\\n self.get_nth_filepath(\\n filenum),\\n linenum,\\n gate_start_line,\\n gate_start_linenum)\\n else:\\n seen_open_curly = True\\n gate_def = gate_def + line + ' '\\n x = QTRegEx.END_CURLY.search(line)\\n if x:\\n self.user_gate_definition(\\n gate_start_linenum, gate_def)\\n parsing_gate = False\\n gate_def = ''\\n gate_start_line = None\\n gate_start_linenum = None\\n seen_open_curly = False\\n else:\\n gate_def = gate_def + line + ' '\\n x = QTRegEx.END_CURLY.search(line)\\n if x:\\n self.user_gate_definition(\\n filenum, gate_start_linenum, gate_def)\\n parsing_gate = False\\n gate_def = ''\\n gate_start_line = None\\n gate_start_linenum = None\\n seen_open_curly = False\\n\\n continue\\n\\n astElement = ASTElementUnknown(filenum, linenum, line)\\n astType = ASTType.astType(line)\\n if astType == ASTType.BLANK:\\n continue\\n if not seen_noncomment and astType != ASTType.COMMENT:\\n if astType == ASTType.DECLARATION_QASM_2_0:\\n seen_noncomment = True\\n else:\\n raise Qasm_Declaration_Absent_Exception(\\n filenum, self.get_nth_filepath(filenum), linenum, line)\\n\\n # Now step thru types\\n if astType == ASTType.COMMENT:\\n astElement = ASTElementComment(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n elif astType == ASTType.DECLARATION_QASM_2_0:\\n astElement = ASTElementDeclarationQasm2_0(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n if astType == ASTType.INCLUDE:\\n astElement = ASTElementInclude(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n self.push_include(astElement.out()['include'])\\n elif astType == ASTType.CTL_2:\\n astElement = ASTElementCtl2(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n elif astType == ASTType.QREG:\\n astElement = ASTElementQReg(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n elif astType == ASTType.CREG:\\n astElement = ASTElementCReg(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n elif astType == ASTType.MEASURE:\\n astElement = ASTElementMeasure(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n elif astType == ASTType.BARRIER:\\n astElement = ASTElementBarrier(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n\\n elif astType == ASTType.GATE:\\n if self.show_gate_decls:\\n astElement = ASTElementGateDefinitionPlaceholder(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n self.append_ast(astElement.out())\\n parsing_gate = True\\n gate_start_line = line\\n gate_start_linenum = linenum\\n gate_def = line + ' '\\n x = QTRegEx.START_CURLY.search(line)\\n if x:\\n seen_open_curly = True\\n x = QTRegEx.END_CURLY.search(line)\\n if x:\\n self.user_gate_definition(\\n filenum, gate_start_linenum, gate_def)\\n parsing_gate = False\\n gate_def = ''\\n gate_start_line = None\\n gate_start_linenum = None\\n seen_open_curly = False\\n continue\\n\\n elif astType == ASTType.OP:\\n astElement = ASTElementOp(\\n filenum, linenum, line, self.save_element_source, eol_comment=eolComment)\\n if type(astElement) is ASTElementUnknown and self.no_unknown:\\n raise Qasm_Unknown_Element_Exception(filenum,\\n self.get_nth_filepath(\\n filenum),\\n linenum,\\n line)\\n self.append_ast(astElement.out())\\n\\n if parsing_gate:\\n raise Qasm_Incomplete_Gate_Exception(\\n filenum,\\n self.get_nth_filepath(filenum),\\n linenum,\\n gate_start_line,\\n gate_start_linenum)\\n\\n self.t_sect.t_sect['datetime_finish'] = datetime.datetime.now(\\n ).isoformat()\",\n \"def test_reformat_paragraph_new_code_4_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 11.\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n - Point 1. xxxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 11.\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def iter_patches(self, templated_file: TemplatedFile) -> Iterator[FixPatch]:\\n # Does it match? If so we can ignore it.\\n assert self.pos_marker\\n templated_raw = templated_file.templated_str[self.pos_marker.templated_slice]\\n matches = self.raw == templated_raw\\n if matches:\\n # First yield any source fixes\\n yield from self._iter_source_fix_patches(templated_file)\\n # Then return.\\n return\\n\\n # If we're here, the segment doesn't match the original.\\n linter_logger.debug(\\n \\\"# Changed Segment Found: %s at %s: Original: [%r] Fixed: [%r]\\\",\\n type(self).__name__,\\n self.pos_marker.templated_slice,\\n templated_raw,\\n self.raw,\\n )\\n\\n # If it's all literal, then we don't need to recurse.\\n if self.pos_marker.is_literal():\\n # First yield any source fixes\\n yield from self._iter_source_fix_patches(templated_file)\\n # Then yield the position in the source file and the patch\\n yield FixPatch(\\n source_slice=self.pos_marker.source_slice,\\n templated_slice=self.pos_marker.templated_slice,\\n patch_category=\\\"literal\\\",\\n fixed_raw=self.raw,\\n templated_str=templated_file.templated_str[\\n self.pos_marker.templated_slice\\n ],\\n source_str=templated_file.source_str[self.pos_marker.source_slice],\\n )\\n # Can we go deeper?\\n elif not self.segments:\\n # It's not literal, but it's also a raw segment. If we're going\\n # to yield a change, we would have done it from the parent, so\\n # we just abort from here.\\n return # pragma: no cover TODO?\\n else:\\n # This segment isn't a literal, but has changed, we need to go deeper.\\n\\n # If there's an end of file segment or indent, ignore them just for the\\n # purposes of patch iteration.\\n # NOTE: This doesn't mutate the underlying `self.segments`.\\n segments = self.segments\\n while segments and segments[-1].is_type(\\\"end_of_file\\\", \\\"indent\\\"):\\n segments = segments[:-1]\\n\\n # Iterate through the child segments\\n source_idx = self.pos_marker.source_slice.start\\n templated_idx = self.pos_marker.templated_slice.start\\n insert_buff = \\\"\\\"\\n for segment in segments:\\n # First check for insertions.\\n # At this stage, everything should have a position.\\n assert segment.pos_marker\\n # We know it's an insertion if it has length but not in the templated\\n # file.\\n if segment.raw and segment.pos_marker.is_point():\\n # Add it to the insertion buffer if it has length:\\n if segment.raw:\\n insert_buff += segment.raw\\n linter_logger.debug(\\n \\\"Appending insertion buffer. %r @idx: %s\\\",\\n insert_buff,\\n templated_idx,\\n )\\n continue\\n\\n # If we get here, then we know it's an original. Check for deletions at\\n # the point before this segment (vs the TEMPLATED).\\n # Deletions in this sense could also mean source consumption.\\n start_diff = segment.pos_marker.templated_slice.start - templated_idx\\n\\n # Check to see whether there's a discontinuity before the current\\n # segment\\n if start_diff > 0 or insert_buff:\\n # If we have an insert buffer, then it's an edit, otherwise a\\n # deletion.\\n\\n # For the start of the next segment, we need the position of the\\n # first raw, not the pos marker of the whole thing. That accounts\\n # better for loops.\\n first_segment_pos = segment.raw_segments[0].pos_marker\\n yield FixPatch(\\n # Whether the source slice is zero depends on the start_diff.\\n # A non-zero start diff implies a deletion, or more likely\\n # a consumed element of the source. We can use the tracking\\n # markers from the last segment to recreate where this element\\n # should be inserted in both source and template.\\n source_slice=slice(\\n source_idx,\\n first_segment_pos.source_slice.start,\\n ),\\n templated_slice=slice(\\n templated_idx,\\n first_segment_pos.templated_slice.start,\\n ),\\n patch_category=\\\"mid_point\\\",\\n fixed_raw=insert_buff,\\n templated_str=\\\"\\\",\\n source_str=\\\"\\\",\\n )\\n\\n insert_buff = \\\"\\\"\\n\\n # Now we deal with any changes *within* the segment itself.\\n yield from segment.iter_patches(templated_file=templated_file)\\n\\n # Once we've dealt with any patches from the segment, update\\n # our position markers.\\n source_idx = segment.pos_marker.source_slice.stop\\n templated_idx = segment.pos_marker.templated_slice.stop\\n\\n # After the loop, we check whether there's a trailing deletion\\n # or insert. Also valid if we still have an insertion buffer here.\\n end_diff = self.pos_marker.templated_slice.stop - templated_idx\\n if end_diff or insert_buff:\\n source_slice = slice(\\n source_idx,\\n self.pos_marker.source_slice.stop,\\n )\\n templated_slice = slice(\\n templated_idx,\\n self.pos_marker.templated_slice.stop,\\n )\\n # We determine the source_slice directly rather than\\n # inferring it so that we can be very specific that\\n # we ensure that fixes adjacent to source-only slices\\n # (e.g. {% endif %}) are placed appropriately relative\\n # to source-only slices.\\n yield FixPatch(\\n source_slice=source_slice,\\n templated_slice=templated_slice,\\n patch_category=\\\"end_point\\\",\\n fixed_raw=insert_buff,\\n templated_str=templated_file.templated_str[templated_slice],\\n source_str=templated_file.source_str[source_slice],\\n )\",\n \"def deleteComments(self: Self, event: Event = None) -> None:\\n #@+<< deleteComments docstring >>\\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\\n #@@pagewidth 50\\n #@-<< deleteComments docstring >>\\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\\n #\\n # \\\"Before\\\" snapshot.\\n bunch = u.beforeChangeBody(p)\\n #\\n # Initial data.\\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\\n if not lines:\\n g.warning('no text selected')\\n return\\n # The default language in effect at p.\\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\\n if c.hasAmbiguousLanguage(p):\\n language = c.getLanguageAtCursor(p, language)\\n d1, d2, d3 = g.set_delims_from_language(language)\\n #\\n # Calculate the result.\\n changed, result = False, []\\n if d1:\\n # Remove the single-line comment delim in front of each line\\n d1b = d1 + ' '\\n n1, n1b = len(d1), len(d1b)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n if g.match(s, i, d1b):\\n result.append(s[:i] + s[i + n1b :])\\n changed = True\\n elif g.match(s, i, d1):\\n result.append(s[:i] + s[i + n1 :])\\n changed = True\\n else:\\n result.append(s)\\n else:\\n # Remove the block comment delimiters from each line.\\n n2, n3 = len(d2), len(d3)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n j = s.find(d3, i + n2)\\n if g.match(s, i, d2) and j > -1:\\n first = i + n2\\n if g.match(s, first, ' '):\\n first += 1\\n last = j\\n if g.match(s, last - 1, ' '):\\n last -= 1\\n result.append(s[:i] + s[first:last] + s[j + n3 :])\\n changed = True\\n else:\\n result.append(s)\\n if not changed:\\n return\\n #\\n # Set p.b and w's text first.\\n middle = ''.join(result)\\n p.b = head + middle + tail # Sets dirty and changed bits.\\n w.setAllText(head + middle + tail)\\n #\\n # Set the selection range and scroll position.\\n i = len(head)\\n j = ins = max(i, len(head) + len(middle) - 1)\\n w.setSelectionRange(i, j, insert=ins)\\n w.setYScrollPosition(oldYview)\\n #\\n # \\\"after\\\" snapshot.\\n u.afterChangeBody(p, 'Indent Region', bunch)\",\n \"def __generatorFinished(self):\\n QApplication.restoreOverrideCursor()\\n self.refreshButton.setEnabled(True)\\n \\n diff1, diff2, errors, fileSeparators = self.__diffGenerator.getResult()\\n \\n if diff1:\\n self.contents.setPlainText(\\\"\\\".join(diff1))\\n else:\\n self.contents.setPlainText(\\n self.tr('There is no difference.'))\\n \\n if diff2:\\n self.contents2.setPlainText(\\\"\\\".join(diff2))\\n else:\\n self.contents2.setPlainText(\\n self.tr('There is no difference.'))\\n \\n if errors:\\n self.errorGroup.show()\\n self.errors.setPlainText(errors)\\n self.errors.ensureCursorVisible()\\n \\n self.buttonBox.button(QDialogButtonBox.Save).setEnabled(bool(diff2))\\n self.buttonBox.button(QDialogButtonBox.Close).setEnabled(True)\\n self.buttonBox.button(QDialogButtonBox.Close).setDefault(True)\\n self.buttonBox.button(QDialogButtonBox.Close).setFocus(\\n Qt.OtherFocusReason)\\n \\n for contents in [self.contents, self.contents2]:\\n tc = contents.textCursor()\\n tc.movePosition(QTextCursor.Start)\\n contents.setTextCursor(tc)\\n contents.ensureCursorVisible()\\n \\n fileSeparators = self.__mergeFileSeparators(fileSeparators)\\n self.filesCombo.addItem(self.tr(\\\"<Start>\\\"), (0, 0))\\n self.filesCombo.addItem(self.tr(\\\"<End>\\\"), (-1, -1))\\n for oldFile, newFile, pos1, pos2 in sorted(fileSeparators):\\n if oldFile != newFile:\\n self.filesCombo.addItem(\\n \\\"{0} -- {1}\\\".format(oldFile, newFile), (pos1, pos2))\\n else:\\n self.filesCombo.addItem(oldFile, (pos1, pos2))\",\n \"def reaching_definitions(self):\\n dirty = True\\n while dirty:\\n dirty = False\\n for block in self.blocks:\\n i_input = 0\\n for parent in block.parents:\\n i_input |= parent.i_output\\n i_output = (i_input & ~block.i_kill) | block.i_gen\\n if i_output != block.i_output:\\n dirty = True\\n block.i_input = i_input\\n block.i_output = i_output\",\n \"def reaching_definitions(self):\\n dirty = True\\n while dirty:\\n dirty = False\\n for block in self.blocks:\\n i_input = 0\\n for parent in block.parents:\\n i_input |= parent.i_output\\n i_output = (i_input & ~block.i_kill) | block.i_gen\\n if i_output != block.i_output:\\n dirty = True\\n block.i_input = i_input\\n block.i_output = i_output\",\n \"def test_generator6(self):\\n xpb = XPathBuilder()\\n xp1 = xp2 = None\\n base_xp = xpb.base.foo.bar\\n base_gen = None\\n with base_xp as b:\\n base_gen = b\\n xp1 = xpb.a.b.c.join(b())\\n xp2 = xpb.test.join(b())\\n xp1_exp = '/a/b/c/base/foo/bar'\\n xp2_exp = '/test/base/foo/bar'\\n base_exp = '/base/foo/bar'\\n # check tree structure\\n self.assertTrue(base_xp._parent is None)\\n self.assertTrue(len(base_xp._children[0]._children[0]._children) == 0)\\n self.assertTrue(base_gen._parent is None)\\n self.assertTrue(len(base_gen._children) == 0)\\n # check xpath\\n self.assertEqual(xp1.tostring(), xp1_exp)\\n self.assertEqual(xp2.tostring(), xp2_exp)\\n self.assertEqual(base_xp.tostring(), base_exp)\\n self.assertEqual(base_gen.tostring(), base_exp)\",\n \"def render_paths_between_yields(paths): # pragma: no cover\\n from graphviz import Digraph\\n dot = Digraph(name=\\\"top\\\")\\n for i, path in enumerate(paths):\\n prev = None\\n for block in path:\\n if isinstance(block, Branch):\\n label = \\\"if \\\" + astor.to_source(block.cond)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"invhouse\\\"})\\n elif isinstance(block, Yield):\\n label = \\\"id: {}\\\\n\\\".format(block.yield_id)\\n label += astor.to_source(block.value)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"oval\\\"})\\n elif isinstance(block, BasicBlock):\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt) for stmt in block.statements)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n elif isinstance(block, HeadBlock):\\n label = \\\"Initial\\\"\\n dot.node(str(i) + str(id(block)) + \\\"_start\\\", label.rstrip(), {\\\"shape\\\": \\\"doublecircle\\\"})\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\\n if hasattr(block, \\\"initial_yield\\\"):\\n label += \\\"\\\\n\\\" + astor.to_source(block.initial_yield.value)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n dot.edge(str(i) + str(id(block)) + \\\"_start\\\", str(i) + str(id(block)))\\n elif isinstance(block, State):\\n label = \\\"{}\\\".format(astor.to_source(block.yield_state).rstrip())\\n if block.conds:\\n label += \\\" && \\\"\\n label += \\\" && \\\".join(astor.to_source(cond) for cond in block.conds)\\n label += \\\"\\\\n\\\"\\n label += \\\"\\\\n\\\".join(astor.to_source(statement) for statement in block.statements)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"doubleoctagon\\\"})\\n else:\\n raise NotImplementedError(type(block))\\n if prev is not None:\\n if isinstance(prev, Branch):\\n if block is prev.false_edge:\\n label = \\\"F\\\"\\n else:\\n label = \\\"T\\\"\\n else:\\n label = \\\"\\\"\\n dot.edge(str(i) + str(id(prev)), str(i) + str(id(block)), label)\\n prev = block\\n\\n file_name = tempfile.mktemp(\\\"gv\\\")\\n dot.render(file_name, view=True)\",\n \"def process(self):\\n first_line = self.setup[\\\"first_line\\\"]\\n last_line = self.setup[\\\"last_line\\\"]\\n\\n self.logger.info(\\\"Using lines %s - %s\\\", first_line, last_line)\\n\\n path_temp = \\\"{}_\\\".format(self.path)\\n\\n with open(self.path, \\\"r\\\") as src, open(path_temp, \\\"w\\\") as dest:\\n lines = src.r..\\n copy_lines = lines[first_line-1:last_line]\\n dest.write(\\\"\\\".join(copy_lines))\\n\\n os.rename(path_temp, self.path)\",\n \"def body_lines(self):\\n self.parent.finalize()\\n for name, svg in self.iter_svgs(): # recurse here\\n if name:\\n yield '<g id=\\\"%s\\\">' % name\\n for line in svg._meta.body_lines():\\n yield line\\n if name:\\n yield \\\"</g>\\\"\\n for elem in self.parent.elements:\\n if isinstance(elem, SVG):\\n pass\\n else:\\n yield \\\"%s\\\" % elem\",\n \"def hexdump_diff_iter( source1, source2, start=None, end=None, length=None, major_len=8, minor_len=4, colour=True, before=2, after=2, address_base=None ):\\n stride = minor_len*major_len\\n start = start if start is not None else 0\\n end = end if end is not None else max( len( source1 ), len( source2 ) )\\n\\n start = max( start, 0 )\\n end = min( end, max( len( source1 ), len( source2 ) ) )\\n address_base_offset = address_base-start if address_base is not None else 0\\n\\n diff_lines = []\\n for offset in range( start, end, stride ):\\n if source1[offset:offset+stride] != source2[offset:offset+stride]:\\n diff_lines.append( offset )\\n show_all = before is None or after is None\\n if show_all:\\n show_lines = {x: (2 if x in diff_lines else 1) for x in range( start, end, stride )}\\n else:\\n show_lines = {x: (2 if x in diff_lines else 0) for x in range( start, end, stride )}\\n for index in diff_lines:\\n for b in [index-(x+1)*stride for x in range( before )]:\\n if b in show_lines and show_lines[b] == 0:\\n show_lines[b] = 1\\n for a in [index+(x+1)*stride for x in range( after )]:\\n if a in show_lines and show_lines[a] == 0:\\n show_lines[a] = 1\\n\\n skip = False\\n for offset in sorted( show_lines.keys() ):\\n if skip == True and show_lines[offset] != 0:\\n yield '...'\\n skip = False\\n if show_lines[offset] == 2:\\n check = basic_diff( source1, source2, start=offset, end=offset+stride )\\n highlights = {}\\n for (o, l) in check:\\n for i in range( o, o+l ):\\n highlights[i] = DIFF_COLOUR_MAP[0]\\n if offset < len( source1 ):\\n yield ansi.format_hexdump_line( source1, offset, min( end, len( source1 ) ), major_len, minor_len, colour, prefix='-', highlight_addr=DIFF_COLOUR_MAP[0], highlight_map=highlights, address_base_offset=address_base_offset )\\n highlights = {k: DIFF_COLOUR_MAP[1] for k in highlights.keys()}\\n if offset < len( source2 ):\\n yield ansi.format_hexdump_line( source2, offset, min( end, len( source2 ) ), major_len, minor_len, colour, prefix='+' , highlight_addr=DIFF_COLOUR_MAP[1], highlight_map=highlights, address_base_offset=address_base_offset )\\n elif show_lines[offset] == 1:\\n yield ansi.format_hexdump_line( source1, offset, end, major_len, minor_len, colour, prefix=' ', address_base_offset=address_base_offset )\\n elif show_lines[offset] == 0:\\n skip = True\\n\\n if skip == True:\\n yield '...'\\n skip = False\\n\\n return\",\n \"def GenerateDiff(self, args):\\r\\n raise NotImplementedError(\\r\\n \\\"abstract method -- subclass %s must override\\\" % self.__class__)\",\n \"def __getGenerator(self):\\n\\n return \\\"{\\\\\\\\*\\\\\\\\generator %s;}\\\\n\\\" % fix(self.generator)\",\n \"def test_reformat_paragraph_new_code_8_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def main(pathToseq, start, end, pathToOutputFile):\\n infile = open(pathToseq)\\n outfile = open(pathToOutputFile, 'w')\\n fasta = infile.readline().replace(\\\"\\\\n\\\",\\\"\\\")\\n sequence =\\\"\\\"\\n for line in infile:\\n sequence+=line.replace(\\\"\\\\n\\\",\\\"\\\")\\n infile.close()\\n outfile.write(\\\"Region \\\"+start +\\\" - \\\"+ end + \\\" of \\\"+fasta)\\n\\n outfile.write(\\\"\\\\n\\\"+sequence[int(start): int(end)])\\n outfile.close()\",\n \"def reread(self) -> None:\\n old = self.getSubgraph(self.uri)\\n new = Graph()\\n try:\\n contents = open(self.path).read()\\n if contents.startswith(\\\"#new\\\"):\\n log.debug(\\\"%s ignoring empty contents of my new file\\\",\\n self.path)\\n # this is a new file we're starting, and we should not\\n # patch our graph as if it had just been cleared. We\\n # shouldn't even be here reading this, but\\n # lastWriteTimestamp didn't work.\\n return\\n\\n new.parse(location=self.path, format='n3')\\n self.readPrefixes = dict(new.namespaces())\\n except SyntaxError as e:\\n print(e)\\n traceback.print_exc()\\n log.error(\\\"%s syntax error\\\", self.path)\\n # todo: likely bug- if a file has this error upon first\\n # read, I think we don't retry it right.\\n return\\n except IOError as e:\\n log.error(\\\"%s rereading %s: %r\\\", self.path, self.uri, e)\\n return\\n\\n old = inContext(old, self.uri)\\n new = inContext(new, self.uri)\\n\\n p = Patch.fromDiff(old, new)\\n if p:\\n log.debug(\\\"%s applying patch for changes in file\\\", self.path)\\n self.patch(p, dueToFileChange=True)\\n else:\\n log.debug(\\\"old == new after reread of %s\\\", self.path)\",\n \"def test_reformat_paragraph_new_code_6_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"4.0\\\", \\\"4.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def test_reformat_paragraph_new_code_7_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 32.\\n\\n 2. Point 4 xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 41.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"2.11\\\", \\\"2.11\\\"),\\n after_sel=(\\\"3.1\\\", \\\"3.1\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def test_back_paragraph_extend_selection(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading\\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\\n communication and safety skills needed to save lives and property– before and\\n during the event. StormReady helps community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading\\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\\n communication and safety skills needed to save lives and property– before and\\n during the event. StormReady helps community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"9.0\\\", \\\"9.5\\\"),\\n after_sel=(\\\"6.7\\\", \\\"9.5\\\"),\\n command_name=\\\"back-paragraph-extend-selection\\\",\\n )\",\n \"def _generate(self, **kwargs):\\n super()._generate(**kwargs)\",\n \"def _generate(self, **kwargs):\\n super()._generate(**kwargs)\",\n \"def _generate(self, **kwargs):\\n super()._generate(**kwargs)\",\n \"def replace(file, current_line, new_line):\\n with fileinput.input(file, inplace=True) as f:\\n for line in f:\\n if current_line in line:\\n line = new_line\\n sys.stdout.write(line)\",\n \"def mature(self,start,end):\\n self.matureStart = start\\n self.matureEnd = end\",\n \"def parent_images(self, parents):\\n parents = list(parents)\\n change_instrs = []\\n for instr in self.structure:\\n if instr['instruction'] != 'FROM':\\n continue\\n\\n old_image, stage = image_from(instr['value'])\\n if old_image is None:\\n continue # broken FROM, fixing would just confuse things\\n if not parents:\\n raise RuntimeError(\\\"not enough parents to match build stages\\\")\\n\\n image = parents.pop(0)\\n if image != old_image:\\n instr['value'] = '{0} AS {1}'.format(image, stage) if stage else image\\n instr['content'] = 'FROM {0}\\\\n'.format(instr['value'])\\n change_instrs.append(instr)\\n\\n if parents:\\n raise RuntimeError(\\\"trying to update too many parents for build stages\\\")\\n\\n lines = self.lines\\n for instr in reversed(change_instrs):\\n lines[instr['startline']:instr['endline']+1] = [instr['content']]\\n\\n self.lines = lines\",\n \"def GenSequence(end, past):\\n\\tif past[-1] == end:\\n\\t\\tSeq.append(past)\\n\\t\\treturn None\\n\\tfor n in Neighbour(past[-1][0],past[-1][1]):\\n\\t\\tif n not in past:\\n\\t\\t\\tGenSequence(end, past+[n])\",\n \"def remove_paired_comments(self, program):\\n regions = re.compile(\\\"(/\\\\*|\\\\*/)\\\").split(program)\\n depth = 0\\n output = []\\n for i in range(len(regions)):\\n region = regions[i]\\n if region==\\\"/*\\\":\\n depth+=1\\n elif region==\\\"*/\\\":\\n depth-=1\\n else:\\n #print(\\\" \\\"*depth, region.replace(\\\"\\\\n\\\", \\\"_\\\"))\\n if depth==0:\\n output.append(region)\\n return \\\"\\\".join(output)\",\n \"def section(fle, begin, end):\\n with open(fle) as f:\\n for line in f:\\n # found start of section so start iterating from next line\\n if line.startswith(begin):\\n for line in f: \\n # found end so end function\\n if line.startswith(end):\\n return\\n # yield every line in the section\\n yield line.rstrip()\",\n \"def test_indent_relative(self):\\n before_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n first line\\n line 1\\n line a\\n line b\\n line c\\n last line\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"5.0\\\", \\\"5.0\\\"),\\n after_sel=(\\\"5.8\\\", \\\"5.8\\\"),\\n command_name=\\\"indent-relative\\\",\\n )\",\n \"def get_des_gen(tree_before: Node, tree_after: Node) -> Iterator[Description]:\\n distance, delta = diff(tree_before, tree_after)\\n\\n tree_before_iter: Iterator[Node] = infinite_none_suffix(\\n post_order_tree_traversal(tree_before)\\n )\\n tree_after_iter: Iterator[Node] = infinite_none_suffix(\\n post_order_tree_traversal(tree_after)\\n )\\n\\n cur_node_before: Node = next(tree_before_iter)\\n cur_node_after: Node = next(tree_after_iter)\\n\\n while cur_node_before or cur_node_after:\\n while cur_node_after in delta['inserted']:\\n yield describe.describe_insertion(cur_node_after)\\n cur_node_after = next(tree_after_iter)\\n while cur_node_before in delta['deleted']:\\n yield describe.describe_deletion(cur_node_before)\\n cur_node_before = next(tree_before_iter)\\n if cur_node_before in delta['stayed']['before']:\\n yield describe.describe_stayed(cur_node_before, cur_node_after)\\n cur_node_before = next(tree_before_iter)\\n cur_node_after = next(tree_after_iter)\\n return\",\n \"def create_next_gen(self, parents_sreprs_couple):\\n child0, child1 = self.recombine(parents_sreprs_couple[0], parents_sreprs_couple[1])\\n if random.random() < self.mutate_prob:\\n child0 = self.mutate(child0)\\n if random.random() < self.mutate_prob:\\n child1 = self.mutate(child1)\\n\\n return child0, child1\",\n \"def replace_embedded_snipptes(content: str, sc_left: str, sc_right: str, change: bool) -> str:\\n\\n if change:\\n # this regex will turn something like %snippet:foo% into something like {snippet:foo}\\n content = re.sub(rf\\\"{sc_left}(\\\\w+:\\\\w+){sc_right}\\\", r\\\"{\\\\1}\\\", content)\\n\\n # this line changes the cursor position placeholder (ONLY TEXTEXPANDER TESTED)\\n content = re.sub(rf\\\"{sc_left}\\\\|\\\", \\\"{cursor}\\\", content)\\n\\n return content\",\n \"def generated(self, generated):\\n\\n self._generated = generated\",\n \"def bp_ins(filename, start, end):\\n with open(filename, 'r') as f:\\n lines = f.readlines()\\n lines.insert(start-1, \\\"\\\")\\n lines.insert(end+1, \\\"\\\")\\n lines.insert(0, \\\"\\\")\\n lines[start-1] = 'ipdb.set_trace()\\\\n'\\n lines[end+1] = 'ipdb.set_trace()\\\\n'\\n lines[0] = \\\"import ipdb\\\\n\\\"\\n with open(f\\\"break_{filename}\\\", 'w+') as f:\\n f.writelines(lines)\",\n \"def raw_segments_with_ancestors(\\n self,\\n ) -> List[Tuple[\\\"RawSegment\\\", List[PathStep]]]:\\n buffer = []\\n code_idxs = tuple(idx for idx, seg in enumerate(self.segments) if seg.is_code)\\n for idx, seg in enumerate(self.segments):\\n # If it's a raw, yield it with this segment as the parent\\n new_step = [PathStep(self, idx, len(self.segments), code_idxs)]\\n if seg.is_type(\\\"raw\\\"):\\n buffer.append((cast(\\\"RawSegment\\\", seg), new_step))\\n # If it's not, recurse - prepending self to the ancestor stack\\n else:\\n buffer.extend(\\n [\\n (raw_seg, new_step + stack)\\n for raw_seg, stack in seg.raw_segments_with_ancestors\\n ]\\n )\\n return buffer\",\n \"def create_gen_xml(self, out_file):\\n\\n param_list = []\\n msg = []\\n msg_type = []\\n dep_node = []\\n for line in self.full_ed_lines:\\n param_list.append(line.text())\\n dep_pkg = param_list[6].split(', ')\\n if dep_pkg[len(dep_pkg) - 1] == '':\\n dep_pkg.pop()\\n for dep in self.manager.wid.sub_list:\\n dep_node.append(dep['msg_type'])\\n for dep in self.manager.wid.pub_list:\\n dep_node.append(dep['msg_type'])\\n for dep in dep_node:\\n a, b = dep.split('/')\\n msg.append(a)\\n msg_type.append(b)\\n f = open('../genkernel/templates/package_rosgen.xml')\\n o = open(out_file, 'a')\\n flag = 0\\n while 1:\\n line = f.readline()\\n if not line: break\\n for i in range(6):\\n line = line.replace('[{0}]'.format(i), param_list[i])\\n line = line.replace('[7]', param_list[7])\\n if line.find('[6]') != -1:\\n for dep in dep_pkg:\\n line_dep = '\\\\t<depend>{0}</depend>\\\\n'.format(dep)\\n o.write(line_dep)\\n flag = 1\\n elif line.find('[8]') != -1:\\n for dep, tp in zip(msg, msg_type):\\n line_dep = '\\\\t\\\\t<depend type=\\\"{1}\\\">{0}</depend>\\\\n'.format(dep, tp)\\n o.write(line_dep)\\n flag = 1\\n elif line.find('<subscribers>') != -1:\\n o.write('\\\\t\\\\t<subscribers>\\\\n')\\n for sub in self.manager.wid.sub_list:\\n o.write('\\\\t\\\\t\\\\t<sub>\\\\n')\\n o.write('\\\\t\\\\t\\\\t\\\\t<name>{0}</name>\\\\n'.format(sub['name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<msg_type>{0}</msg_type>\\\\n'.format(sub['msg_type']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<topic_name>{0}</topic_name>\\\\n'.format(sub['topic_name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<queue_size>{0}</queue_size>\\\\n'.format(sub['queue_size']))\\n o.write('\\\\t\\\\t\\\\t</sub>\\\\n')\\n o.write('\\\\t\\\\t</subscribers>\\\\n')\\n flag = 1\\n elif line.find('<publishers>') != -1:\\n o.write('\\\\t\\\\t<publishers>\\\\n')\\n for pub in self.manager.wid.pub_list:\\n o.write('\\\\t\\\\t\\\\t<pub>\\\\n')\\n o.write('\\\\t\\\\t\\\\t\\\\t<name>{0}</name>\\\\n'.format(pub['name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<msg_type>{0}</msg_type>\\\\n'.format(pub['msg_type']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<topic_name>{0}</topic_name>\\\\n'.format(pub['topic_name']))\\n o.write('\\\\t\\\\t\\\\t\\\\t<queue_size>{0}</queue_size>\\\\n'.format(pub['queue_size']))\\n o.write('\\\\t\\\\t\\\\t</pub>\\\\n')\\n o.write('\\\\t\\\\t</publishers>\\\\n')\\n flag = 1\\n if flag == 0:\\n o.write(line)\\n else:\\n flag = 0\\n o.close()\\n f.close()\\n self.changed = False\",\n \"def manage_resequenceGraphPoints(self, seqmap=(), origseq=(), REQUEST=None):\\n retval = resequence(self, self.graphPoints(), seqmap, origseq, REQUEST)\\n if REQUEST:\\n audit('UI.GraphDefinition.ResequenceGraphPoints', self.id, sequence=seqmap, oldData_={'sequence':origseq})\\n return retval\",\n \"def changed_block(self, old_block, new_block):\",\n \"def generate_example_label(self):\\n label_markup = \\\"\\\"\\\"{keywords}procedure{i} {blocks}Foo{i}\\n (An_Integer : {keywords}in out{i} {types}Integer{i} := {numbers}0{i};\\n A_String : {types}String{i} := {strings}\\\"some text\\\"{i})\\n {keywords}with{i} {aspects}Pre => An_Integer >= -1{i};\\n{comments}-- Documentation for Foo{i}\\n\\n---------\\n-- Foo --\\n---------\\n\\n{keywords}procedure{i} {blocks}Foo{i}\\n (An_Integer : {keywords}in out{i} {types}Integer{i} := {numbers}0{i};\\n A_String : {types}String{i} := {strings}\\\"some text\\\"{i}) {keywords}is{i}\\n{keywords}begin{i}\\n {comments}-- Do the actual loop{i}\\n\\n {keywords}for{i} J {keywords}in{i} A_String'Range {keywords}loop{i}\\n Put_Line ({strings}\\\"bla\\\"{i} & (A + {numbers}10{i})'Img);\\n {keywords}end loop{i};\\n{keywords}end{i} {blocks}Foo{i};\\n\\\"\\\"\\\"\\n # Add line numbers\\n num = 1\\n prefixed = []\\n\\n # Compute the preview's gutter foreground color by mixing the editor's\\n # foreground and background color.\\n # This formula needs to be synchronized with the formula that computes\\n # the 'gutter_color' in gps.css.\\n gutter_fg_color = self.d['editor_fg'].mix(self.d['editor_bg'], 0.6)\\n\\n for line in label_markup.splitlines():\\n prefixed.append(\\n '<span color=\\\"{}\\\">{:4d} </span> {}'.format(\\n gutter_fg_color.to_hex6_string(),\\n num,\\n line))\\n num = num + 1\\n\\n font = GPS.Preference(\\\"Src-Editor-Reference-Style\\\").get().split(\\\"@\\\")[0]\\n label_markup = '<span font=\\\"{}\\\">'.format(font) + '\\\\n'.join(\\n prefixed) + '</span>'\\n\\n b = Gtk.HBox()\\n label = Gtk.Label()\\n b.pack_start(label, False, False, 0)\\n _, bg = Gdk.Color.parse(self.d['editor_bg'].to_hex6_string())\\n _, fg = Gdk.Color.parse(self.d['editor_fg'].to_hex6_string())\\n b.modify_bg(Gtk.StateType.NORMAL, bg)\\n label.modify_fg(Gtk.StateType.NORMAL, fg)\\n process_dict = {'i': \\\"</span>\\\"}\\n for key in ['keywords', 'blocks', 'comments',\\n 'strings', 'numbers', 'aspects', 'types']:\\n val = self.d[key]\\n process_dict[key] = '<span {} {} {}>'.format(\\n 'color=\\\"{}\\\"'.format(val[1].to_hex6_string())\\n if val[1].a != 0.0 else '',\\n 'background=\\\"{}\\\"'.format(val[2].to_hex6_string())\\n if val[2].a != 0.0 else '',\\n\\n 'font-weight=\\\"BOLD\\\"' if 'BOLD' in val[0] else '' +\\n ' font-style=\\\"ITALIC\\\"' if \\\"ITALIC\\\" in val[0] else '')\\n\\n label.set_markup(label_markup.format(**process_dict))\\n return b\",\n \"def transform(stop):\\n line = None\\n results = {}\\n while True:\\n if line is not None:\\n processor = processors.get(type(line), None)\\n if processor:\\n processor[0](line, results, *processor[1:])\\n if stop.is_set():\\n line = generate(results)\\n else:\\n line = None\\n line = yield line\",\n \"def test_reformat_paragraph_new_code_5_of_8(self):\\n before_b = \\\"\\\"\\\"\\\\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 22.\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n A. Point 2. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n Line 22.\\n 1. Point 3. xxxxxxxxxxxxxxxxxxxxxxxxxxx\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"2.0\\\"),\\n after_sel=(\\\"3.0\\\", \\\"3.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def copy_edge_attributes_to_refined(g_orig,g_new):\\n def copy_attributes(j_orig,j_new):\\n for field,type_ in g_new.edge_dtype:\\n if field not in ['nodes','cells'] and not field.startswith('_'):\\n g_new.edges[field][j_new] = g_orig.edges[field][j_orig]\\n\\n # loop through setting edge marks\\n # edges between a midpoint and one of the\\n # endpoints\\n for j in range(g_new.Nedges()):\\n a,b = g_new.edges['nodes'][j]\\n if a>b:\\n a,b = b,a\\n # only care about edges where one node is original,\\n # the other is a midpoint.\\n # there are no edges where both are original, and\\n # edges with both as midpoints or with one as a center\\n # always internal.\\n if a < g_orig.Nnodes() and b>=g_orig.Nnodes() and b<g_orig.Nnodes()+g_orig.Nedges():\\n j_orig = b - g_orig.Nnodes()\\n copy_attributes(j_orig,j)\",\n \"def crossover(parent: list):\\n ### GENERAL METHOD\\n child1 = []\\n child2 = []\\n child = []\\n geneA = int(random.random() * len(parent[0]))\\n geneB = int(random.random() * len(parent[0]))\\n startgene = min(geneA, geneB)\\n endgene = max(geneA, geneB)\\n for i in range(startgene, endgene):\\n child1.append(parent[0][i])\\n child2 = [item for item in parent[1] if item not in child1]\\n child = child2[:startgene] + child1 + child2[startgene:]\\n return child\",\n \"def extend_taa_seq(self, taa_pos_base, old_seq, new_seq):\\n taa_pos = None\\n termlen = -1 # use -1 to detect abnormal computes\\n seq_end = self.cds_end\\n new_aa_seq = ''\\n i = 0\\n while True:\\n ci = i*3\\n old_codon_seq = old_seq[ci:ci+3]\\n new_codon_seq = new_seq[ci:ci+3]\\n # if sequence comes to ends, extend sequence from reference file\\n if (old_codon_seq not in standard_codon_table or\\n new_codon_seq not in standard_codon_table):\\n seq_inc = faidx.refgenome.fetch_sequence(self.chrm, seq_end+1, seq_end+100)\\n old_seq += seq_inc\\n new_seq += seq_inc\\n old_codon_seq = old_seq[ci:ci+3]\\n new_codon_seq = new_seq[ci:ci+3]\\n seq_end += 100\\n\\n taa_ref_run = codon2aa(old_codon_seq)\\n taa_alt_run = codon2aa(new_codon_seq)\\n new_aa_seq += taa_alt_run\\n # print i, old_codon_seq, new_codon_seq, taa_ref_run, taa_alt_run\\n if taa_pos == None and taa_ref_run != taa_alt_run:\\n taa_pos = i\\n taa_ref = taa_ref_run\\n taa_alt = taa_alt_run\\n if taa_alt_run == '*':\\n if taa_pos == None:\\n # stop codon encountered before difference\\n return None # nothing occur to protein level\\n termlen = i + 1 - taa_pos\\n break\\n i += 1\\n\\n new_aa_seq = new_aa_seq[taa_pos:]\\n if taa_pos == None:\\n print('oldseq', old_seq)\\n print('newseq', new_seq)\\n taa_pos += taa_pos_base\\n\\n aae = AAExtension()\\n aae.taa_pos = taa_pos\\n aae.taa_ref = taa_ref\\n aae.taa_alt = taa_alt\\n aae.termlen = termlen\\n aae.new_aa_seq = new_aa_seq\\n\\n return aae\",\n \"def build_model_mutator(self):\\n\\n\\t\\tprint \\\"beginning mutation procedure\\\"\\n\\t\\twith open(self.rootdir+self.template[0][0]+'.pdb','r') as fp: lines = fp.readlines()\\n\\t\\t\\n\\t\\tregex_seqres = '^SEQRES\\\\s+[0-9]+\\\\s+([A-Z])\\\\s+[0-9]+\\\\s+(.+)'\\n\\t\\tregex_remark = '^REMARK\\\\s300\\\\s([A-Z]+)\\\\s+'\\n\\t\\t#---if SEQRES is present we get the sequence from it\\n\\t\\t#---note that the seqres protocol below should handle missing residues even if they exist\\n\\t\\t#---...at the beginning of the target sequence\\n\\t\\tif any([re.match(regex_seqres,line) for line in lines]):\\n\\t\\t\\tseqresli = [li for li,l in enumerate(lines) if re.match(regex_seqres,l)]\\n\\t\\t\\tseqraw = [re.findall(regex_seqres,lines[li])[0] for li in seqresli]\\n\\t\\t\\tsequence = ''.join([''.join([aacodemap[j] for j in i[1].split()]) \\n\\t\\t\\t\\tfor i in seqraw if i[0] == self.template[0][1]])\\n\\t\\t\\tmissingli = [re.findall('^REMARK\\\\s+([0-9]+)\\\\sMISSING RESIDUES',l)[0] for li,l in enumerate(lines) \\n\\t\\t\\t\\tif re.match('^REMARK\\\\s+([0-9]+)\\\\sMISSING RESIDUES',l)]\\n\\t\\t\\tif missingli != []:\\n\\t\\t\\t\\tif len(missingli)>1: raise Exception('cannot parse multiple MISSING RESIDUE notes')\\n\\t\\t\\t\\tmissingli = str(missingli[0])\\n\\t\\t\\t\\tstartres = int([\\n\\t\\t\\t\\t\\tre.findall('^REMARK\\\\s+'+missingli+'\\\\s+[A-Z]{3}\\\\s+[A-Z]\\\\s+([0-9]+)',l)[0] \\n\\t\\t\\t\\t\\tfor li,l in enumerate(lines)\\n\\t\\t\\t\\t\\tif re.match('^REMARK\\\\s+'+missingli+'\\\\s+[A-Z]{3}\\\\s+[A-Z]\\\\s+[0-9]+',l)][0])\\n\\t\\t\\telse: startres = int([line for line in lines if re.match('^ATOM',line)][0][22:25+1])\\n\\t\\telif any([re.match(regex_remark,line) for line in lines]):\\n\\t\\t\\tseqresli = [li for li,l in enumerate(lines) if re.match(regex_remark,l)]\\n\\t\\t\\tseqraw = [re.findall(regex_remark,lines[li])[0] for li in seqresli]\\n\\t\\t\\tsequence = ''.join(seqraw)\\n\\t\\t\\tstartres = int([line for line in lines if re.match('^ATOM',line)][0][22:25+1])\\n\\t\\telse: raise Exception('need either REMARK 300 or SEQRES in your pdb file')\\n\\t\\t\\t\\n\\t\\tself.target = []\\n\\t\\tfor mi,mut in enumerate(self.settings['mutations']):\\n\\t\\t\\tsequence_mut = list(sequence)\\n\\t\\t\\tif sequence[mut[1]-startres] != mut[0]: \\n\\t\\t\\t\\tmsg = [\\n\\t\\t\\t\\t\\t'USER ERROR!',\\n\\t\\t\\t\\t\\t'sequence: '+sequence,\\n\\t\\t\\t\\t\\t'starting residue number from ATOM record: '+str(startres),\\n\\t\\t\\t\\t\\t'expecting '+str(mut[0])+' at position '+str(mut[1]),\\n\\t\\t\\t\\t\\t'however reading '+str(sequence[mut[1]-startres])+' at that position!',\\n\\t\\t\\t\\t\\t]\\n\\t\\t\\t\\traise Exception('\\\\n'.join(msg))\\n\\t\\t\\telse: sequence_mut[mut[1]-startres] = mut[2]\\n\\t\\t\\tsequence_mut = ''.join(sequence_mut)\\n\\t\\t\\tprint 'template sequence = '+sequence\\n\\t\\t\\tprint 'mutated sequence = '+sequence_mut\\n\\t\\t\\tself.target.append(['mutation'+str(mi),sequence_mut])\\n\\t\\tfor mi,mut in enumerate(self.settings['mutations']):\\n\\t\\t\\tprint 'building homology model for mutation '+str(mi)\\n\\t\\t\\tself.settings['target_name'] = self.target[mi][0]\\n\\t\\t\\t#---we explicitly encode the mutation in the filename so that it can be retrieved later\\n\\t\\t\\t#---...particularly in ???\\n\\t\\t\\tbatchdir = 'model-v'+('%05d'%(mi))+'-'+self.template[0][0]+'_chain'+self.template[0][1]+\\\\\\n\\t\\t\\t\\t'_mut'+''.join([str(j) for j in mut])+'/'\\n\\t\\t\\tself.build_model_single(batchdir_override=batchdir,startres=startres)\",\n \"def _generate_custom(project, docdir, gendir):\\n custom_dir = os.path.join(docdir, 'generate')\\n print(f\\\"Generating custom docs for {project} in {gendir!r}\\\")\\n\\n for root, _dirs, files in os.walk(custom_dir):\\n subdir = root.split(custom_dir, 1)[1].strip('/')\\n if subdir:\\n try:\\n os.mkdir(os.path.join(gendir, subdir))\\n except OSError as exc:\\n if exc.errno != errno.EEXIST:\\n raise\\n\\n for script in sorted(x for x in files if not x.startswith(('.', '_'))):\\n script_path = os.path.join(custom_dir, subdir, script)\\n if not os.access(script_path, os.X_OK):\\n continue\\n\\n fake_file = StringIO()\\n with syspath(os.path.dirname(script_path)):\\n module = import_module(os.path.basename(os.path.splitext(script_path)[0]))\\n module.main(fake_file, docdir=docdir, gendir=gendir)\\n\\n fake_file.seek(0)\\n if data := fake_file.read():\\n rst = os.path.join(gendir, subdir, os.path.splitext(script)[0] + '.rst')\\n print(f\\\"generating {rst}\\\")\\n with open(rst, 'w') as f:\\n f.write(data)\",\n \"def change_line(file_path, included_strings, excluded_strings, replacement):\\n if not os.path.isfile(file_path):\\n print file_path+\\\" file not found!\\\"\\n return\\n temp_path = file_path+\\\"_temp\\\"\\n temp_file = open(temp_path, 'w')\\n with open(file_path, 'r') as f:\\n for line in f:\\n if all([x in line for x in included_strings]) and \\\\\\n all([x not in line for x in excluded_strings]):\\n temp_file.write(replacement)\\n else:\\n temp_file.write(line)\\n temp_file.close()\\n os.system(\\\"mv \\\"+temp_path+\\\" \\\"+file_path)\\n return\",\n \"def replace_includes(self, file_name):\\n\\n indexBegin = 0\\n indexEnd = 0\\n text = self.dir_helper.read_file(file_name)\\n while indexBegin != -1:\\n indexBegin = text.find('\\\\input{', indexBegin+1)\\n indexEnd = text.find('}', indexBegin+1)\\n text_to_replace = text[indexBegin:indexEnd+1]\\n if indexBegin != -1:\\n # print 'text_to_replace : ' + text_to_replace\\n new_path = self.construct_path(text_to_replace)\\n new_text = self.replace_includes(file_name = new_path)\\n text = text.replace(text_to_replace, new_text)\\n\\n return text\",\n \"def replace(self, text, from_line, from_col, to_line, to_col):\\n self.remove(from_line, from_col, to_line, to_col)\\n self.insert_after(text, from_line, from_col)\",\n \"def integrate_changes(self, strings):\\n other_index = strings.index()\\n translation = self.translation()\\n lines = []\\n for key in sorted(other_index.keys(), key=unicode.lower):\\n try: value = translation.index[key]\\n except KeyError: value = other_index[key]\\n try: translation_comments = translation.index[key].comments\\n except: translation_comments = []\\n other_comments = other_index[key].comments or ['No comment provided by engineer.']\\n for i in range(0, max(len(translation_comments), len(other_comments))):\\n try: comment = other_comments[i]\\n except IndexError: comment = translation_comments[i]\\n lines.append('/* %s */\\\\n' % comment)\\n lines.append('\\\"%s\\\" = \\\"%s\\\";\\\\n\\\\n' % (value.key, value.trans))\\n \\n try: os.unlink(self.path())\\n except OSError: pass\\n if lines:\\n result = codecs.open(self.path(), 'wb', encoding='utf-16')\\n result.writelines(lines)\\n result.close()\",\n \"def replace_plugins(lines):\\n starts, ends = [], []\\n stripped = [[]]\\n exports = []\\n plugin = False\\n for i, line in enumerate(lines):\\n if line.rstrip().endswith(END):\\n assert plugin, f\\\"END PLUGIN without BEGIN PLUGIN found in {lines}\\\"\\n plugin = False\\n ends.append(i)\\n stripped.append([])\\n \\n elif line.rstrip().endswith(BEGIN):\\n assert not plugin, f\\\"Nested plugins found in {lines}\\\"\\n starts.append(i)\\n exports.append(False)\\n plugin = True\\n \\n elif line.rstrip().endswith(BEGIN_EXPORT):\\n assert not plugin, f\\\"Nested plugins found in {lines}\\\"\\n starts.append(i)\\n exports.append(True)\\n plugin = True\\n\\n elif plugin:\\n stripped[len(starts) - 1].append(line)\\n\\n assert len(stripped) == len(starts) + 1 == len(ends) + 1 == len(exports) + 1, f\\\"Error processing plugins in {lines}\\\"\\n assert all(s < e for s, e in zip(starts, ends))\\n\\n starts.reverse()\\n ends.reverse()\\n stripped.reverse()\\n stripped = stripped[1:]\\n\\n lines = lines.copy()\\n\\n for i, (s, e) in enumerate(zip(starts, ends)):\\n config = yaml.full_load(\\\"\\\\n\\\".join(stripped[i]))\\n export = exports[i]\\n pg = config[\\\"plugin\\\"]\\n args = \\\", \\\".join(config.get(\\\"args\\\", []))\\n kwargs = \\\", \\\".join([f\\\"{k}={v}\\\" for k, v in config.get(\\\"kwargs\\\", {}).items()])\\n\\n call = (\\\"run_plugin\\\", \\\"add_plugin_files\\\")[export]\\n\\n call = f'grader.{call}(\\\"{pg}\\\"'\\n if args:\\n call += f', {args}'\\n if kwargs:\\n call += f', {kwargs}'\\n call += ')'\\n\\n del lines[s:e+1]\\n lines.insert(s, call)\\n\\n return lines\",\n \"def process(self, doc: Doc) -> Doc:\\n\\n matches = self.get_matches(doc)\\n\\n terminations = get_spans(matches, \\\"termination\\\")\\n boundaries = self._boundaries(doc, terminations)\\n\\n # Removes duplicate matches and pseudo-expressions in one statement\\n matches = filter_spans(matches, label_to_remove=\\\"pseudo\\\")\\n\\n entities = list(self.get_spans(doc))\\n ents = None\\n\\n for start, end in boundaries:\\n\\n ents, entities = consume_spans(\\n entities,\\n filter=lambda s: check_inclusion(s, start, end),\\n second_chance=ents,\\n )\\n\\n sub_matches, matches = consume_spans(\\n matches, lambda s: start <= s.start < end\\n )\\n\\n if self.on_ents_only and not ents:\\n continue\\n\\n sub_preceding = get_spans(sub_matches, \\\"preceding\\\")\\n sub_following = get_spans(sub_matches, \\\"following\\\")\\n # Verbs preceding negated content\\n sub_preceding += get_spans(sub_matches, \\\"verbs_preceding\\\")\\n # Verbs following negated content\\n sub_following += get_spans(sub_matches, \\\"verbs_following\\\")\\n\\n if not sub_preceding + sub_following:\\n continue\\n\\n if not self.on_ents_only:\\n for token in doc[start:end]:\\n token._.negation = any(\\n m.end <= token.i for m in sub_preceding\\n ) or any(m.start > token.i for m in sub_following)\\n\\n for ent in ents:\\n self.annotate_entity(\\n ent=ent,\\n sub_preceding=sub_preceding,\\n sub_following=sub_following,\\n )\\n\\n return doc\",\n \"def update_pre_block(pre_block):\\r\\n updated_block=\\\"\\\";\\r\\n count=0;\\r\\n for line in pre_block.splitlines():\\r\\n count+=1;\\r\\n if count<len(pre_block.splitlines()):\\r\\n line=update_line(line)+\\\"\\\\n\\\";\\r\\n updated_block=updated_block+line;\\r\\n else:\\r\\n line=update_line(line);\\r\\n updated_block=updated_block+line;\\r\\n return updated_block\",\n \"def test_extend_to_paragraph(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading\\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\\n communication and safety skills needed to save lives and property– before and\\n during the event. StormReady helps community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Americans live in the most severe weather-prone country on Earth. Each year,\\n Americans cope with an average of 10,000 thunderstorms, 2,500 floods, 1,000\\n tornadoes, as well as an average of 6 deadly hurricanes. Potentially deadly\\n weather impacts every American. Communities can now rely on the National Weather\\n Service’s StormReady program to help them guard against the ravages of Mother\\n Nature.\\n\\n Some 90% of all presidentially declared disasters are weather related, leading\\n to around 500 deaths per year and nearly $14 billion in damage. StormReady, a\\n program started in 1999 in Tulsa, OK, helps arm America's communities with the\\n communication and safety skills needed to save lives and property– before and\\n during the event. StormReady helps community leaders and emergency managers\\n strengthen local safety programs.\\n\\n StormReady communities are better prepared to save lives from the onslaught of\\n severe weather through better planning, education, and awareness. No community\\n is storm proof, but StormReady can help communities save lives. Does StormReady\\n make a difference?\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"9.0\\\", \\\"9.0\\\"),\\n after_sel=(\\\"8.0\\\", \\\"13.33\\\"),\\n command_name=\\\"extend-to-paragraph\\\",\\n )\",\n \"def generator(self):\\n\\n # generates speech turns long enough to contain at least one segment\\n speech_turns = super(SpeechTurnSubSegmentGenerator, self).generator()\\n\\n # number of speech turns per \\\"speech turn batch\\\"\\n if self.per_fold is not None:\\n n_speech_turns = self.per_label * self.per_fold\\n else:\\n n_speech_turns = self.per_label * len(self.data_)\\n\\n endOfBatch = EndOfBatch()\\n while True:\\n\\n # for each speech turn in batch\\n for z in range(n_speech_turns):\\n speech_turn = next(speech_turns)\\n\\n # for each segment in speech turn\\n for X in self.iter_segments_(speech_turn['X']):\\n\\n # all but 'X' fields are left unchanged\\n segment = dict(speech_turn)\\n segment['X'] = X\\n\\n # remember that this segment belongs to this speech turn\\n segment['z'] = z\\n\\n yield segment\\n\\n # let `batchify` know that the \\\"segment batch\\\" is complete\\n yield endOfBatch\",\n \"def test_reformat_paragraph_simple_hanging_indent(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Honor this line that has a hanging indentation, please. Hanging\\n indentation is valuable for lists of all kinds. But it is tricky to get right.\\n\\n Next paragraph.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Honor this line that has a hanging\\n indentation, please. Hanging\\n indentation is valuable for lists of\\n all kinds. But it is tricky to get\\n right.\\n\\n Next paragraph.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"1.0\\\"),\\n after_sel=(\\\"7.0\\\", \\\"7.0\\\"),\\n command_name=\\\"reformat-paragraph\\\",\\n directives=\\\"@language plain\\\\n@pagewidth 40\\\\n@tabwidth 8\\\",\\n )\",\n \"def generate(self):\\n\\n with open(self.file, \\\"r\\\") as file:\\n structure = []\\n for line in file:\\n sub_line = []\\n for sprite in line:\\n if sprite != '\\\\n':\\n sub_line.append(sprite)\\n structure.append(sub_line)\\n self.structure = structure\",\n \"def convert_doxygen_docstring(lines, name):\\n\\n lines = lines[:]\\n newlines = []\\n indent = 0\\n reading_desc = False\\n\\n while lines:\\n line = lines.pop(0)\\n if line.startswith(\\\"////\\\"):\\n continue\\n\\n line = line.rstrip()\\n if line.startswith('///<'):\\n strline = line[4:]\\n else:\\n strline = line\\n\\n strline = strline.lstrip('/ \\\\t')\\n\\n if strline == \\\"**\\\" or strline == \\\"*/\\\":\\n continue\\n\\n if strline.startswith(\\\"** \\\"):\\n strline = strline[3:]\\n elif strline.startswith(\\\"* \\\"):\\n strline = strline[2:]\\n elif strline == \\\"*\\\":\\n strline = \\\"\\\"\\n\\n strline = strline.lstrip(' \\\\t')\\n\\n if strline.startswith('@'):\\n special = strline.split(' ', 1)[0][1:]\\n if special == 'par' and strline.endswith(':') and lines and '@code' in lines[0]:\\n newlines.append(' '*indent + strline[5:] + ':')\\n newlines.append('')\\n line = lines.pop(0)\\n offset = line.index('@code')\\n while lines:\\n line = lines.pop(0)\\n if '@endverbatim' in line or '@endcode' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == \\\"verbatim\\\" or special == \\\"code\\\":\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. code-block:: guess')\\n newlines.append('')\\n offset = line.index('@' + special)\\n while lines:\\n line = lines.pop(0)\\n if '@endverbatim' in line or '@endcode' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == \\\"f[\\\":\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. math::')\\n newlines.append('')\\n offset = line.index('@' + special)\\n while lines:\\n line = lines.pop(0)\\n if '@f]' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == 'param':\\n #TODO\\n #if extra is not None:\\n # _, name, desc = strline.split(' ', 2)\\n # extra['param:' + name] = desc\\n continue\\n elif special == 'deprecated':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n _, value = strline.split(' ', 1)\\n\\n # I'd love to use the proper Sphinx deprecated tag, but it\\n # requires a version number, whereas Doxygen doesn't.\\n newlines.append('*Deprecated:* ' + convert_doxygen_format(value, name))\\n newlines.append('')\\n continue\\n elif special in ('brief', 'return', 'returns'):\\n #TODO\\n #if extra is not None:\\n # _, value = strline.split(' ', 1)\\n # extra[special] = value\\n continue\\n elif special == 'details':\\n strline = strline[9:]\\n elif special == 'sa' or special == 'see':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n _, value = strline.split(' ', 1)\\n values = value.split(',')\\n\\n for i, value in enumerate(values):\\n result = resolve_reference(value.partition('(')[0], name)\\n if result:\\n values[i] = ':{0}:`{1}`'.format(*result)\\n else:\\n values[i] = ':obj:`{0}`'.format(value)\\n\\n if special == 'see':\\n newlines.append('See {}.'.format(', '.join(values)))\\n else:\\n newlines.append('See also {}.'.format(', '.join(values)))\\n newlines.append('')\\n continue\\n elif special in ('note', 'warning'):\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. %s:: ' % (special))\\n newlines.append('')\\n newlines.append(' ' + convert_doxygen_format(strline[2 + len(special):], name))\\n while lines and lines[0].strip(' *\\\\t/'):\\n line = lines.pop(0).lstrip(' *\\\\t')\\n newlines.append(' ' + convert_doxygen_format(line, name))\\n\\n newlines.append('')\\n continue\\n elif special == 'since':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. versionadded:: ' + strline[7:])\\n newlines.append('')\\n continue\\n else:\\n print(\\\"Unhandled documentation tag: @\\\" + special)\\n\\n if strline or len(newlines) > 0:\\n newlines.append(' '*indent + convert_doxygen_format(strline, name))\\n\\n return newlines\",\n \"def remLines(origFile):\\n\\n noLineFile = origFile + \\\".noline\\\"\\n\\n # Generate no line file\\n cmd = \\\"cat %s | sed -e '/^\\\\s*\\\\.line.*$/d' | sed -e 's/\\\\/jumbo//' > %s\\\" % \\\\\\n (commands.mkarg(origFile), commands.mkarg(noLineFile))\\n commands.getstatusoutput(cmd)\\n\\n if not os.path.exists(noLineFile):\\n return None\\n\\n # Generate line patch\\n linesPatch = origFile + \\\".linepatch\\\"\\n cmd = \\\"diff -B -u %s %s > %s\\\" % \\\\\\n (commands.mkarg(noLineFile), commands.mkarg(origFile), commands.mkarg(linesPatch))\\n commands.getstatusoutput(cmd)\\n\\n shutil.move(noLineFile, origFile)\\n\\n return linesPatch\",\n \"def reconstruct(new, original):\\n\\n output = []\\n\\n # Find deltas between new and original and add newlines to the output wherever they're found in original\\n seqm = difflib.SequenceMatcher(None, new, original, False)\\n for opcode, a0, a1, b0, b1 in seqm.get_opcodes():\\n delta_a = seqm.a[a0:a1] # Substring in new\\n delta_b = seqm.b[b0:b1] # Substring in original\\n newline = re.search(r'(\\\\r|\\\\n)+', delta_b)\\n\\n # Always take delta_a over delta_b unless there's a newline\\n if opcode == 'equal':\\n output.append(delta_a)\\n elif opcode == 'insert' and newline: # Append any insertion containing a newline\\n output.append(newline.group(0))\\n elif opcode == 'delete':\\n output.append(delta_a)\\n elif opcode == 'replace':\\n if newline:\\n if re.match(r'\\\\r|\\\\n', delta_b[-1]): # If the newline is the last character, insert the newline after delta_a\\n output.append(delta_a + newline.group(0))\\n else: # Otherwise insert the newline before delta_a\\n output.append(newline.group(0) + delta_a)\\n else:\\n output.append(delta_a)\\n\\n # Strip leading and trailing whitespace from each line\\n new = ''.join(output)\\n lines = new.split('\\\\n')\\n for i in range(len(lines)):\\n lines[i] = lines[i].strip()\\n\\n # Write file\\n file = open('GenderSwap.txt', 'w')\\n file.write('\\\\n'.join(lines))\\n file.close()\",\n \"def nextGeneration(self):\\n # select two parents from the current generation.\\n parent_1 = self.selection()\\n parent_2 = self.selection()\\n # to not get the same parents.\\n _ = 0\\n while _ < 30 and parent_2 == parent_1:\\n parent_2 = self.selection()\\n _ += 1\\n # apply crossover on those parents (crossover_rate chance).\\n crossover_chance = random.uniform(0, 1)\\n parents = [parent_1, parent_2]\\n if crossover_chance <= self.crossoverRate:\\n offspring = self.crossover(parents)\\n else:\\n return \\n # apply mutations on the new offspring (mutation_rate chance).\\n mutation_chance = random.uniform(0, 1)\\n newoffspring = offspring\\n if mutation_chance <= self.mutationRate:\\n newoffspring = self.mutation(offspring)\\n # replace one of the parents in the new generation, given the loser parent.\\n self.replaceLoser(parents, newoffspring)\\n\\n # now the new generation is available in the self.currentGeneration\",\n \"def ModifyRange(self, rangeText, nucleotide='-'):\\n nucleotide = nucleotide.upper()\\n if (self.translated == True):\\n self.AlertMessage(\\\"Can't modify protein sequences.\\\", 'medium')\\n elif (nucleotide not in ['A', 'G', 'C', 'T', 'R', 'K', 'S', 'W', 'M', 'Y', 'D', 'V', 'B', 'H', 'N', '-']):\\n self.AlertMessage('Invalid nucleotide. (only AGTC- and IUB nucleotide codes are permitted)', 'high')\\n else:\\n startTaxon, stopTaxon, startColumn, stopColumn = self.ParseIndex(rangeText)\\n if (startTaxon >= 0): #Make sure we have a valid range\\n taxon = 0\\n newSequences = []\\n modificationLength = (stopColumn - startColumn) + 1\\n for Sequence in self.alignment:\\n if (taxon in range(startTaxon, stopTaxon + 1)):\\n if (startColumn > 0):\\n Sequence.seq = Sequence.seq[:startColumn] + Seq(nucleotide * modificationLength) + Sequence.seq[stopColumn + 1:]\\n else:\\n Sequence.seq = Seq(nucleotide * modificationLength) + Sequence.seq[stopColumn + 1:]\\n newSequences.append(Sequence)\\n taxon += 1\\n self.alignment = MultipleSeqAlignment(newSequences)\\n self.Show(self.displayedColumn)\\n self.BackupAlignment()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5403601","0.51225114","0.49107388","0.48132256","0.48054352","0.47870225","0.47572523","0.47332415","0.4713576","0.4713462","0.4688489","0.46581972","0.46474382","0.46446952","0.46335268","0.4598963","0.4561457","0.45551708","0.4552287","0.454125","0.4532039","0.45182794","0.44949493","0.448991","0.44815946","0.44767216","0.44759983","0.44751415","0.4468558","0.44509062","0.44230744","0.4419079","0.4407291","0.44050717","0.43843028","0.43833286","0.43813133","0.4375496","0.43746492","0.43735814","0.4367943","0.4360372","0.4360255","0.4360255","0.43545884","0.43516678","0.43325216","0.43130907","0.43060052","0.4304081","0.4285292","0.42807227","0.42791918","0.42752525","0.42711243","0.42686763","0.42604953","0.42564467","0.42564467","0.42564467","0.42513767","0.42507264","0.42492875","0.42465746","0.42451605","0.42436707","0.4242642","0.4226744","0.4224048","0.42225862","0.42222458","0.42184144","0.42159936","0.42128038","0.4209187","0.42051762","0.42026946","0.42003697","0.41981727","0.41940877","0.41884655","0.4186482","0.41780996","0.41780964","0.41770235","0.4173712","0.41723484","0.41689217","0.4163252","0.4155896","0.41491437","0.4141302","0.4137143","0.4133152","0.41249076","0.41236117","0.41207877","0.41130397","0.41126618","0.41086525"],"string":"[\n \"0.5403601\",\n \"0.51225114\",\n \"0.49107388\",\n \"0.48132256\",\n \"0.48054352\",\n \"0.47870225\",\n \"0.47572523\",\n \"0.47332415\",\n \"0.4713576\",\n \"0.4713462\",\n \"0.4688489\",\n \"0.46581972\",\n \"0.46474382\",\n \"0.46446952\",\n \"0.46335268\",\n \"0.4598963\",\n \"0.4561457\",\n \"0.45551708\",\n \"0.4552287\",\n \"0.454125\",\n \"0.4532039\",\n \"0.45182794\",\n \"0.44949493\",\n \"0.448991\",\n \"0.44815946\",\n \"0.44767216\",\n \"0.44759983\",\n \"0.44751415\",\n \"0.4468558\",\n \"0.44509062\",\n \"0.44230744\",\n \"0.4419079\",\n \"0.4407291\",\n \"0.44050717\",\n \"0.43843028\",\n \"0.43833286\",\n \"0.43813133\",\n \"0.4375496\",\n \"0.43746492\",\n \"0.43735814\",\n \"0.4367943\",\n \"0.4360372\",\n \"0.4360255\",\n \"0.4360255\",\n \"0.43545884\",\n \"0.43516678\",\n \"0.43325216\",\n \"0.43130907\",\n \"0.43060052\",\n \"0.4304081\",\n \"0.4285292\",\n \"0.42807227\",\n \"0.42791918\",\n \"0.42752525\",\n \"0.42711243\",\n \"0.42686763\",\n \"0.42604953\",\n \"0.42564467\",\n \"0.42564467\",\n \"0.42564467\",\n \"0.42513767\",\n \"0.42507264\",\n \"0.42492875\",\n \"0.42465746\",\n \"0.42451605\",\n \"0.42436707\",\n \"0.4242642\",\n \"0.4226744\",\n \"0.4224048\",\n \"0.42225862\",\n \"0.42222458\",\n \"0.42184144\",\n \"0.42159936\",\n \"0.42128038\",\n \"0.4209187\",\n \"0.42051762\",\n \"0.42026946\",\n \"0.42003697\",\n \"0.41981727\",\n \"0.41940877\",\n \"0.41884655\",\n \"0.4186482\",\n \"0.41780996\",\n \"0.41780964\",\n \"0.41770235\",\n \"0.4173712\",\n \"0.41723484\",\n \"0.41689217\",\n \"0.4163252\",\n \"0.4155896\",\n \"0.41491437\",\n \"0.4141302\",\n \"0.4137143\",\n \"0.4133152\",\n \"0.41249076\",\n \"0.41236117\",\n \"0.41207877\",\n \"0.41130397\",\n \"0.41126618\",\n \"0.41086525\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71948594"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":83799,"cells":{"query":{"kind":"string","value":"Setters for _grilleCSV We read the csv file and copy it into _grilleCSV"},"document":{"kind":"string","value":"def _set_grille_csv(self):\n with open(self.csvPath, \"r\") as csvFile:\n fileRead = csv.reader(csvFile, delimiter=\",\")\n\n #We read each row of the csv file\n for row in fileRead:\n rowSplitted = row[0].split(\";\")\n self._grilleCSV.append(rowSplitted)"},"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 read_csv_file(self):\n pass","def read_csv():","def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n self.input_data.append(row)","def csv_reader(file_obj):\n global gagnant\n global gain\n # le tableau qui contient les gagnants\n reader = csv.reader(file_obj, delimiter=';')\n gagnant = next(reader)\n gain = next(reader)\n gagnant = [list(map(int,gagnant))]\n gagnant=gagnant[0]\n gain = [list(map(int,gain))]\n gain=gain[0]","def get_data(self, csv_file):\n pass","def __open_csv(self):\n self.__csv_file = open(self.__csv_file_name, 'w', encoding='utf-8')\n self.__csv_writer = csv.writer(self.__csv_file, delimiter=',', )","def csv_reader2(file_obj):\n global grilles\n # le tableau qui contient les gagnants\n grilles = [list(map(int,rec[1:])) for rec in csv.reader(file_obj, delimiter=';')]","def loadCSV(input_file):","def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.var_type == 'name':\n try:\n self.header = reader.next()\n except StopIteration:\n errormsg(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n raise Exception(_('Data file \"{}\" contains no data'.format(\n self.options.datafile)))\n self.data = []\n for row in reader:\n self.data.append(row)","def __init__(self, path):\n self.csv_path = path\n # check if csv format is valid or not\n self.check_valid_csvformat(self.csv_path)\n \"\"\" empty dict to store all company names\n prepare initial company data in dictionary format \"\"\"\n self.company_data = dict()","def set_input_csv(self):\n if len(self[\"input_csv\"]) > 1:\n raise Exception(\"You must only specify *one* unified CSV file!\")\n self.csv_path = self[\"input_csv\"][0]\n print(\"Using input file\", self.csv_path)","def prepare_CSV(self):\n self.drop_columns()\n self.rename_columns()\n self.spilt_columns()\n self.add_vehicle_id_column()\n self.add_source_column()\n self.add_timestamp_columns()\n self.get_colour_columns()\n self.clean_column_formats()\n\n # print(self.data.info())\n # print(self.data.sample(10))\n\n return self.data","def __init__(self,csvrow):\n self.raw = csvrow\n data = csvrow.split(',')\n self.number = data[0]\n self.area = int(data[1])\n self.population = int(data[5])\n self.latitude = float(data[7])\n self.longitude = float(data[8])","def import_glucose_from_csv(user, csv_file):\n csv_data = []\n reader = csv.reader(csv_file.read().splitlines(), delimiter=',',\n quotechar='\"')\n for row in reader:\n csv_data.append([item.strip() for item in row])\n\n glucose_objects = []\n\n # Check if headers exists. Skip the first entry if true.\n header_check = ['value', 'category', 'date', 'time']\n first_row = [i.lower().strip() for i in csv_data[0]]\n if all(i in first_row for i in header_check):\n csv_data = csv_data[1:]\n\n for row in csv_data:\n # Let's do an extra check to make sure the row is not empty.\n if row:\n try:\n category = Category.objects.get(name__iexact=row[1].strip())\n except ObjectDoesNotExist:\n category = Category.objects.get(name__iexact='No Category'.strip())\n\n # Since we always store the value in mg/dL format in the db, we need\n # to make sure we convert it here if the user's setting is set to\n # mmol/L.\n if user.settings.glucose_unit.name == 'mmol/L':\n value = int(to_mg(row[0]))\n else:\n value = int(row[0])\n\n glucose_objects.append(Glucose(\n user=user,\n value=value,\n category=category,\n record_date=datetime.strptime(row[2], DATE_FORMAT),\n record_time=datetime.strptime(row[3], TIME_FORMAT),\n notes=row[4],\n ))\n\n Glucose.objects.bulk_create(glucose_objects)","def __init__(self, in_csvfile, out_csvfile, col_name, cell_filler):\r\n self.in_csvfile = in_csvfile\r\n self.out_csvfile = out_csvfile\r\n self.col_name = col_name\r\n self.cell_filler = cell_filler","def prepare_csv(self, filename, *args, **kwargs):\n x_possible = getattr(settings, 'IMPORT_CSV_X_FIELDS', ['Lon*', 'x', 'lon*'])\n y_possible = getattr(settings, 'IMPORT_CSV_Y_FIELDS', ['Lat*', 'y', 'lat*'])\n geom_possible = getattr(settings, 'IMPORT_CSV_GEOM_FIELDS',\n ['geom', 'GEOM', 'WKT', 'the_geom', 'THE_GEOM', 'WKB'])\n\n oo = kwargs.get('open_options', [])\n\n oo.append('X_POSSIBLE_NAMES={0}'.format(','.join(x_possible)))\n oo.append('Y_POSSIBLE_NAMES={0}'.format(','.join(y_possible)))\n oo.append('GEOM_POSSIBLE_NAMES={0}'.format(','.join(geom_possible)))\n\n kwargs['open_options'] = oo\n\n return filename, args, kwargs","def __init__(self, *, csv_file_path: str = ''):\n self.__csv_file_path = csv_file_path\n self._parse_csv()","def csv_url(self, csv_url):\n\n self._csv_url = csv_url","def csv_url(self, csv_url):\n\n self._csv_url = csv_url","def __init__(self, csv_file: str = None) -> None:\n super().__init__(csv_file)","def __init__(self, csv_file: str = None) -> None:\n super().__init__(csv_file)","def read_csv(self, csv_input):\n # https://stackoverflow.com/a/45063514\n dtypes = {\n 'lat': 'U',\n 'long': 'U'\n }\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\n\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\n self.log.info('Data read from CSV %s' % csv_input)\n #print('Data read from CSV %s' % csv_input)","def initCSV(self, makeFile, overWrite):\n self.initialized = True\n\n os.chdir(os.path.dirname(os.path.abspath(__file__)))\n\n if os.path.exists(str(self.fileName)):\n\n f = open(str(self.fileName), \"r\")\n\n if not f.read():\n f.close()\n\n f = open(str(self.fileName), \"w\")\n outString = \"\"\n for varName in self.variableDescriptions:\n outString += varName\n outString += \",\"\n\n f.write(outString[0:-1])\n\n f.write('\\n')\n else:\n if overWrite == True:\n f.close()\n\n f = open(str(self.fileName), \"w\")\n outString = \"\"\n for varName in self.variableDescriptions:\n outString += varName\n outString += \",\"\n\n f.write(outString[0:-1])\n\n f.write('\\n')\n if overWrite == False:\n raise OSError(\"csv file is not empty!\")\n\n else:\n if makeFile == True:\n f = open(str(self.fileName), \"w\")\n \n f.close()\n else:\n raise OSError(\"csv file not found!\")","def _read_csv(self):\n with open(self._file_path, 'rb') as f:\n reader = csv.DictReader(f, delimiter=',')\n self._content = [row for row in reader]","def import_csv(self, csvfileobject):\n # Clear previously stored info\n self._tracks = []\n self._selected = None\n\n for row in csvfileobject:\n if row[0] == \"T\":\n track = self.addTrack()\n track.properties = row\n elif row[0] == \"P\":\n period = self.addPeriod([0,1,'-'])\n period.properties = row","def post_init(cr, registry):\n import_csv_data(cr, registry)","def _fill(self, lang, csv_file_name, save_func, start=1):\n with (DATA_PATH / lang / csv_file_name).open() as csv_file:\n lines = enumerate(csv.reader(csv_file, delimiter=';'), 1)\n for line_num, row in dropwhile(lambda line: line[0] != start,\n lines):\n try:\n save_func(row)\n except Exception as error:\n raise ReadCSVError(line_num, csv_file_name, error)","def dataLoad():\n try:\n try: #Python3\n f = open(__file__ + \".csv\",\"rt\")\n except: #Python2\n f = open(__file__ + \".csv\",\"rb\")\n data = f.read().split(',')\n entryCol.entry0.delete(0,END)\n entryCol.entry0.insert(0,data[0])\n entryCol.entry1.delete(0,END)\n entryCol.entry1.insert(0,data[1])\n entryCol.entry2.delete(0,END)\n entryCol.entry2.insert(0,data[2])\n entryCol.entry3.delete(0,END)\n entryCol.entry3.insert(0,data[3])\n botWind.writeN(\"DataLoad: File\")\n except:\n botWind.writeN(\"DataLoad: Default\")","def ort_kreis_reader(self, csv_file):\n\n ort_kreis_df = pd.read_csv(csv_file, usecols=[1,3], names=['Ort', 'Kreis'], skiprows=1)\n\n ort_kreis_df = ort_kreis_df.drop_duplicates(keep='first')\n\n #cities kreis names are null, so fill their kreis slot with that city name\n ort_kreis_df['Kreis'].fillna(ort_kreis_df['Ort'], inplace=True)\n\n cleaned_ort_kreis_df = ort_kreis_df.replace(to_replace=' Städte|-Kreis| Kreis|Kreis | Land|Landkreis |Städteregion ', value='', regex=True)\n\n return cleaned_ort_kreis_df","def __obtain_csv_fieldnames__(self, csvfile):\n self.__fieldnames__ = csvfile.readline()\n self.__obtain_csv_delimiter__(self.__fieldnames__)\n self.__fieldnames__ = self.__remove_break_line__(self.__fieldnames__)\n self.__fieldnames__ = self.__split_for_delimiter__(self.__fieldnames__)","def reload_csv(self):\n self.load_csv()\n self.tableView.insert_data(self.database)\n self.update()","def CsvToJson(nomfichierJson):\n with open(\"save/save.csv\",'r') as f:\n liste_cube = list()\n liste_robot = list()\n \"\"\"deux listes vides pour contenir les objets charges\"\"\"\n for line in f:\n ligne=line.split(\";\")\n if ligne[0] == 'Arene':\n \"\"\"On cree une nouvelle arene avec les parametres trouves sur la ligne, separes par des ';' \"\"\"\n arene = Arene(int(ligne[1]),int(ligne[2]),int(ligne[3]),liste_cube,liste_robot)\n arene.liste_robot=liste_robot\n elif ligne[0] == 'Cube':\n \"\"\"On ajoute le cube a la liste de cube de l'arene, avec parametres trouves sur la ligne\"\"\"\n arene.liste_cube.append(Cube(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5]),int(ligne[6])))\n elif ligne[0] == 'Mur':\n arene.liste_cube.append(Mur(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5]),int(ligne[6])))\n elif ligne[0] == 'Sol':\n arene.liste_cube.append(Sol(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5])))\n elif ligne[0] == 'Robot':\n (x,y,z)=literal_eval(ligne[1])\n ((cax,cay),(cbx,cby),(ccx,ccy),(cdx,cdy))=literal_eval(ligne[2])\n (a,b,c)=literal_eval(ligne[3])\n (lo,la,ha)=literal_eval(ligne[4])\n vitesse=literal_eval(ligne[5])\n arene.liste_robot.append(Robot((x,y,z),((cax,cay),(cbx,cby),(ccx,ccy),(cdx,cdy)),(a,b,c),(lo,la,ha),vitesse))\n saveFic(arene,nomfichierJson)","def __init__(self, csvfile, *args, **kwargs):\n self.encoding = kwargs.pop('encoding', 'utf-8')\n csv.DictReader.__init__(self, csvfile, *args, **kwargs)","def read(self):\n with open(self.filename) as f:\n reader=csv.reader(f)\n for row in reader:\n self.data.appendleft(row)","def __init__(self, csv_path):\n # Checking files\n fdops.check_if_file_exists(csv_path)\n\n # loading proposal data as a data frame\n self._df = pd.read_csv(csv_path)\n\n # Dictionary containing proposal properties\n self.props = self._get_properties(csv_path)","def from_csv(self, user, row):\n if len(row) != 4:\n raise BadRequest(_(\"Invalid line\"))\n self.name = row[1].strip()\n try:\n self.target = RelayDomain.objects.get(name=row[2].strip())\n except RelayDomain.DoesNotExist:\n raise NotFound(_(\"Relay domain %s does not exist\" % row[2].strip()))\n self.enabled = (row[3].strip() == 'True')\n self.save(creator=user)","def read_csv():\n global csvdata\n global CONFIG\n if type(csvdata) == type(None):\n if not os.path.exists(CONFIG[\"csvfile\"]):\n csvdata = pandas.read_csv(CONFIG[\"csvrepo\"],\n na_values=[\"-999999\",\"NOT AVAILABLE\"])\n os.makedirs(CONFIG[\"cachedir\"],exist_ok=True)\n csvdata.to_csv(CONFIG[\"csvfile\"])\n else:\n csvdata = pandas.read_csv(CONFIG[\"csvfile\"])\n return csvdata","def csv(self, file, table=None):\n\n if table:\n table.import_from_csv_file(file)\n else:\n db = self.db\n # This is the preferred method as it updates reference fields\n db.import_from_csv_file(file)\n db.commit()","def load_data_csv(self, filename):\n import csv\n\n self.begin_batch() #avoid unecessary updates\n\n #delete old data\n #TODO: check of deleting data is really what user wants\n #TODO: create method for clearing data\n msg = wx.grid.GridTableMessage(self,\n wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED,\n 0,\n self.GetNumberRows())\n self.rowmask = numpy.array([], dtype = numpy.bool)\n self.data = numpy.empty(shape = (0, len(self.colLabels)), dtype = numpy.object)\n self.GetView().ProcessTableMessage(msg)\n \n #process file\n with open(filename, 'rb') as f:\n\n #read first row to extract fieldnames\n header = csv.reader(f).next()\n\n #parse field header \"name [dynamic] (custom label)\"\n pattern = re.compile(r\"(?P<name>\\w+(\\s\\w+)?)\\s*(\\[(?P<dynamic>.*)\\])?\\s*(\\((?P<label>.*)\\))?\\s*(\\{(?P<options>.*)\\})?\",\n re.VERBOSE)\n fields = []\n dyn_expr = {}\n cust_label = {}\n vis_cols = {}\n for entry in header:\n r = pattern.match(entry)\n d = r.groupdict()\n name = d['name']\n if name:\n fields.append(name)\n if d['dynamic']: dyn_expr[name] = d['dynamic']\n if d['label']: cust_label[name] = d['label']\n if d['options']:\n if '*' in d['options']: vis_cols[name] = True\n\n #set dynamic expressions\n for k, col in enumerate(self.dynamic_cols):\n dexpr = dyn_expr.get(self.colLabels[col])\n if dexpr:\n self.dynamic_expressions[k] = dexpr\n\n #set custom column labels\n for k, label in enumerate(self.colLabels):\n clabel = cust_label.get(label)\n if clabel:\n self.column_labels_custom[k] = clabel\n\n #also show columns which are marked as visible in csv file\n colsel = set(self.colsel)\n for k, label in enumerate(self.colLabels):\n if vis_cols.get(label):\n colsel.add(k)\n colsel = list(colsel)\n colsel.sort()\n self.View.SetColumnSelection(colsel)\n\n #read data\n reader = csv.DictReader(f, fieldnames = fields)\n\n row = -1\n for rowdict in reader:\n row += 1\n self.AppendRows()\n\n if rowdict.get('masked') == 'True':\n self.maskrows(row)\n\n #loop over columns in _actual_ table, \n for col, typelabel in enumerate(zip(self.dataTypes, self.colLabels)):\n datatype, label = typelabel\n\n #ask csv reader whether corresponding entry exists \n value = rowdict.get(label)\n if value is None or value == '':\n continue\n\n try:\n #convert string value to proper type\n #TODO: optimize it by creating a table of conversion functions\n #or a table method that takes a string\n if wx.grid.GRID_VALUE_FLOAT in datatype:\n val = float(value)\n elif wx.grid.GRID_VALUE_NUMBER in datatype:\n val = int(value)\n elif wx.grid.GRID_VALUE_BOOL in datatype:\n if value == '1' or value == 'True':\n val = True\n else:\n val = False\n elif wx.grid.GRID_VALUE_STRING in datatype:\n val = value\n else:\n print \"loading of type %s is not supported\"%datatype\n continue\n\n self.SetValueRaw(row, col, val)\n except ValueError:\n print \"warning reading csv: cannot convert value '%s' to type %s\"%(value, datatype)\n\n self.AppendRows(2) \n self.end_batch()\n self.modified = False","def load_csv(self):\n\n # Close any already opened file if any\n self.close_file()\n\n # Disable cell change check to avoid crashes\n self.check_cell_change = False\n\n # Set the flag to no changes in current file state\n self.file_changed = False\n self.set_save_enabled(False)\n\n csv_file_path = QFileDialog.getOpenFileName(self, \"Load CSV File\", \"\", 'CSV(*.csv)')\n\n # Proceed if and only if a valid file is selected and the file dialog is not cancelled\n if csv_file_path[0]:\n # Get only the file name from path. eg. 'data_file.csv'\n filepath = os.path.normpath(csv_file_path[0])\n filename = filepath.split(os.sep)\n self.csv_file_name = filename[-1]\n\n self.loading_progress = QProgressDialog(\"Reading Rows. Please wait...\", None, 0, 100, self)\n self.loading_progress.setWindowTitle(\"Loading CSV File...\")\n self.loading_progress.setCancelButton(None)\n\n # enable custom window hint\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() | QtCore.Qt.CustomizeWindowHint)\n # disable (but not hide) close button\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() & ~QtCore.Qt.WindowCloseButtonHint)\n\n # Show waiting cursor till the time file is being processed\n QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\n\n self.loading_worker = CsvLoaderWorker(csv_file_path=csv_file_path, csv_data_table=self.csv_data_table,\n column_headers=self.column_headers,\n column_headers_all=self.column_headers_all)\n\n self.loading_thread = QThread()\n # Set higher priority to the GUI Thread so UI remains a bit smoother\n QThread.currentThread().setPriority(QThread.HighPriority)\n\n self.loading_worker.moveToThread(self.loading_thread)\n self.loading_worker.workRequested.connect(self.loading_thread.start)\n self.loading_thread.started.connect(self.loading_worker.process_loading_file)\n self.loading_worker.finished.connect(self.on_loading_finish)\n\n self.loading_worker.relay.connect(self.update_loading_progress)\n self.loading_worker.progress_max.connect(self.set_maximum_progress_value)\n self.loading_worker.update_bottom_toolbar.connect(self.set_bottom_toolbar_info)\n\n self.loading_progress.setValue(0)\n self.loading_worker.request_work()\n\n self.check_cell_change = True\n\n # Close the start page tab and load the file tab\n self.tabWidget.removeTab(0)\n self.tabWidget.insertTab(1, self.csv_table_tab, \"Main Document\")\n\n # Enable Column Layout menu option\n self.action_column_layout.setEnabled(True)\n self.action_add_data.setEnabled(True)\n self.action_add_column.setEnabled(True)\n self.action_toolbar_add_data.setEnabled(True)\n self.action_close_file.setEnabled(True)","def CSV_Load_File( self, infilename ):\n print( 'Loading \"{}\"'.format(infilename) )\n IN = open( infilename, 'r' )\n standname = None\n laststand = None\n for L in IN:\n if( L[0:9] == 'Site/Plot' ): continue\n col = L.split( ',' )\n standname = col[0]\n year = int(col[1])\n #if( re.search( '-', standname ) != None ):\n # loc = re.search( '-', standname )\n # year = int(standname[loc.start()+1:])\n # standname = standname[0:loc.start()]\n #print standname, year\n if( (standname != None ) & (standname != laststand) ): self.Data.Stand[standname] = StandData( standname )\n (treeno, species, dbh, ht, live, status, cclass, tpa) = \\\n (int(col[2]), col[3], float(col[4]), float(col[5]), col[6], col[7], int(float(col[8])), float(col[9]))\n if( OPT['d'] ):\n if( dbh > 10.0 ): dbh *= 1.25\n if( dbh > 15.0 ): dbh *= 1.50\n for t in range( 1, int( math.ceil( tpa ))+1, 1 ):\n ntree = len( self.Data.Stand[standname].Tree ) + 1\n self.Data.Stand[standname].Tree[ntree] = TreeData( species, TreeNumber=treeno )\n self.Data.Stand[standname].Tree[ntree].Year[year] = MeasurementData( dbh, ht, '', 1, live, status, cclass )\n laststand = standname\n IN.close()","def csv_loader(csv_file):\n df = pd.read_csv(csv_file, sep=';', parse_dates=['Data_Alteraçao'])\n pd.set_option('display.float_format', '{:.0f}'.format)\n\n df = df.fillna(0)\n df = df.drop(columns=['Cod. Pareamento', 'Cod. UF', 'Sigla UF', 'Cod. Subarea',\n 'Nome Subarea', 'Cod. Municipio', 'Nome Municipio', 'Codigo Agencia',\n 'Nome Agencia', 'Cod. Setor', 'Cod. Logradouro CNEFE',\n 'Tipo Logradouro CNEFE', 'Titulo Logradouro CNEFE',\n 'Nome Logradouro CNEFE', 'Nome Tratado CNEFE', 'Tipo Logradouro DNE',\n 'Titulo Logradouro DNE', 'Nome Logradouro DNE', 'Nome Tratado DNE',\n 'Logradouro Completo DNE', 'Distancia', 'Cod. Match', 'Motivo Match',\n 'CEPs Face', 'Localidade Face',\n 'Alterar Logradouro para DNE?', 'Observaçao', 'SIAPE Alteração',\n 'Nome Alteraçao', 'Data_Alteraçao', 'Status', 'Unnamed: 33'])\n\n # df.astype({'CEP Logradouro CNEFE': 'int32'}).dtypes\n\n df['CEP'] = df['CEP'].str.replace(' ', '', regex=False)\n\n ceps_dne = []\n for index, row in df.iterrows():\n if type(row.CEP) == str:\n for cep in row.CEP.split(','):\n # print(index, cep)\n ceps_dne.append(int(cep))\n\n ceps_cnefe = df['CEP Logradouro CNEFE'].astype(int).tolist()\n ceps = ceps_dne + ceps_cnefe\n ceps = list(set(ceps))\n return pd.Series(ceps)","def setup_csv(self) -> None:\n csvData = ['Followers', 'Time']\n\n # Create our CSV file header\n with open(self.graphfile, 'w') as csvFile:\n writer = csv.writer(csvFile)\n writer.writerow(csvData)\n csvFile.close()","def csv_handle(self,instance):\n table_origin = self.csv_dataframe\n in_column_num = len(self.column_names) \n in_column_name = self.column_names\n in_column_type = self.column_types\n\n instance.column_num = instance.tables[0].column_num = in_column_num\n for i in range(instance.column_num):\n instance.tables[0].names.append(in_column_name[i])\n instance.tables[0].types.append(Type.getType(in_column_type[i].lower())) #getType is a static method\n instance.tables[0].origins = [i for i in range(instance.tables[0].column_num)]\n \n instance.tuple_num = instance.tables[0].tuple_num = table_origin.shape[0] # the number of rows\n for i in range(instance.tables[0].column_num):\n if instance.tables[0].types[i] == 3: #if there is date type column in csv,convert into datetime format\n col_name = table_origin.columns[i]\n col_type = self.column_types[i]\n self.csv_handle_changedate(col_name,col_type)\n \n #change table column name with table_info column_names (for date type columns)\n for i in range(len(table_origin.columns)):\n table_origin.rename(columns={ table_origin.columns[i] : in_column_name[i] }, inplace=True) \n instance.tables[0].D = table_origin.values.tolist() #dataframe to list type and feed to D(where to store all the table info )\n return instance","def _parse_csv(self):\n try:\n with open(self.__csv_file_path) as csv_file:\n csv_reader = csv.reader(csv_file, delimiter=',')\n for line in csv_reader:\n player = Player(data=line)\n if player.position not in self.__unique_position:\n self.__unique_position.append(player.position)\n self.__players.append(player)\n\n # timsort O(n log n)\n self.__players.sort(key=lambda p: p.ppg, reverse=True)\n except FileNotFoundError as e:\n print(e)","def loadCsv(self):\n # Close any already opened file if any\n self.close_file()\n\n # Disable cell change check to avoid crashes\n self.check_cell_change = False\n\n # Set the flag to no changes in current file state\n self.file_changed = False\n self.setSaveEnabled(False)\n\n csv_file_path = QFileDialog.getOpenFileName(self, \"Load CSV File\", \"\", 'CSV(*.csv)')\n\n # Proceed if and only if a valid file is selected and the file dialog is not cancelled\n if csv_file_path[0]:\n # Get only the file name from path. eg. 'data_file.csv'\n filepath = os.path.normpath(csv_file_path[0])\n filename = filepath.split(os.sep)\n self.csv_file_name = filename[-1]\n\n self.loading_progress = QProgressDialog(\"Reading Rows. Please wait...\", None, 0, 100, self)\n self.loading_progress.setWindowTitle(\"Loading CSV File...\")\n self.loading_progress.setCancelButton(None)\n\n # enable custom window hint\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() | QtCore.Qt.CustomizeWindowHint)\n # disable (but not hide) close button\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() & ~QtCore.Qt.WindowCloseButtonHint)\n\n # Show waiting cursor till the time file is being processed\n QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\n\n self.loading_worker = loader.CsvLoaderWorker(csv_file_path=csv_file_path, csv_data_table=self.csv_data_table,\n column_headers=self.column_headers,\n column_headers_all=self.column_headers_all)\n\n self.loading_thread = QThread()\n # Set higher priority to the GUI Thread so UI remains a bit smoother\n QThread.currentThread().setPriority(QThread.HighPriority)\n\n self.loading_worker.moveToThread(self.loading_thread)\n self.loading_worker.workRequested.connect(self.loading_thread.start)\n self.loading_thread.started.connect(self.loading_worker.processLoadingFile)\n self.loading_worker.finished.connect(self.on_loading_finish)\n\n self.loading_worker.relay.connect(self.update_loading_progress)\n self.loading_worker.progress_max.connect(self.set_maximum_progress_value)\n self.loading_worker.update_bottom_toolbar.connect(self.setBottomToolbarInfo)\n\n self.loading_progress.setValue(0)\n self.loading_worker.requestWork()\n\n self.check_cell_change = True\n\n # Close the start page tab and load the file tab\n self.tabWidget.removeTab(0)\n self.tabWidget.insertTab(1, self.tableTab, \"Main Document\")\n\n # Enable Column Layout menu option\n self.action_column_layout.setEnabled(True)\n self.action_add_data.setEnabled(True)\n self.action_add_column.setEnabled(True)\n self.action_toolbar_add_data.setEnabled(True)\n self.action_close_file.setEnabled(True)","def loadCSVFile (file, sep=\";\"):\n lst = lt.newList(\"ARRAY_LIST\") #Usando implementacion arraylist\n #lst = lt.newList() #Usando implementacion linkedlist\n print(\"Cargando archivo ....\")\n t1_start = process_time() #tiempo inicial\n dialect = csv.excel()\n dialect.delimiter=sep\n try:\n with open(file, encoding=\"utf-8\") as csvfile:\n spamreader = csv.DictReader(csvfile, dialect=dialect)\n for row in spamreader: \n lt.addLast(lst,row)\n except:\n print(\"Hubo un error con la carga del archivo\")\n t1_stop = process_time() #tiempo final\n print(\"Tiempo de ejecución \",t1_stop-t1_start,\" segundos\")\n return lst","def csvfileUsage(self):\n with open(self.csv_path, \"rb+\") as file_obj:\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\n \"\"\" reader.fieldnames returns header , slicing intial 'Month' and\n 'Year' header from list\n \"\"\"\n for com_names in reader.fieldnames[2:]:\n self.company_data[com_names] = {}\n # iterating each row\n for row in reader:\n month, year = self.parse_my(row) # parsing the year and month from row\n # pop the `Month` and `Year` Key to minimize iteration below\n row.pop('Month'), row.pop('Year')\n \"\"\" saving and updating the data at same point of time\n each iteration time, checking the max value and updating \n `Month` `Year` and `Value`\n \"\"\"\n self.prepare_company_data(month, year, row, self.company_data)\n file_obj.close() # close file\n return self.company_data","def _loadCSVFile(self):\n self._df = pd.read_csv(\n self._pathfile, sep=CSV_SEPARATOR, index_col=CSV_INDEX_COL)","def from_csv(self, filename):\n\t\tpoints = np.genfromtxt(filename, delimiter=\",\")\n\t\tassert points.shape[1] == 2\n\n\t\tself.N = points.shape[0]\n\t\tself.points = points\n\t\tself.original_points = points","def onLoadCSVList(self, evt):\n dlg = wx.FileDialog(self.view, \"Choose a file:\", wildcard = \"*.txt; *.csv\" ,\n style=wx.FD_DEFAULT_STYLE | wx.FD_CHANGE_DIR)\n if dlg.ShowModal() == wx.ID_OK:\n print \"You chose %s\" % dlg.GetPath()\n self.config.CSVFilePath = dlg.GetPath()","def cell_map_from_csv(self, source_file: str) -> None:\n if source_file[-4:] == '.csv':\n try:\n self._import_source_data(source_file)\n except Exception:\n print(\"Problem with that CSV file. File extension?\")","def read_csv(self, inputfile):\n d = csv.reader(inputfile)\n for row in d.read():\n self.translations[row[0]] = row[1]","def load_csv(filename):\n # Open csvfile\n with open(filename) as csvfile:\n reader = csv.DictReader(csvfile)\n\n # Put data in gloabal list\n for row in reader:\n # Get data of subject with either or both milk and peanut allergy\n if row[\"MILK_ALG_START\"] != \"NA\" or row[\"PEANUT_ALG_START\"] != \"NA\":\n sub_list = list()\n for key in DATA_KEYS:\n sub_list.append(row[key])\n\n # Add data of subject to all data \n data_list.append(sub_list)","def load_csv(self):\n self.database = pd.read_csv(\n self.settings['database_path'],\n encoding='utf-8')","def csv_reader(self, file_obj):\n reader = csv.reader(file_obj)\n for row in reader:\n row_1 = (' '.join(row))\n self.data.append(row_1.split(';'))\n return self.data","def parse_csv_row(self, row):\n\n for key in self.field_map:\n if self.field_map[key] is not None:\n if key == 'marking':\n self.obstacle_data[key] = self.get_marking_value(row[self.field_map[key]].strip())\n elif key == 'lighting':\n self.obstacle_data[key] = self.get_lighting_value(row[self.field_map[key]].strip())\n elif key == 'obst_type':\n self.obstacle_data['obst_type_id'] = self.get_obstacle_type_id(row[self.field_map[key]].strip())\n else:\n self.obstacle_data[key] = row[self.field_map[key]].strip()","def init_cache_from_csv(self, path: str) -> None:\n log.debug(f\"Initalising {self.name} from csv at {path}\")\n df = io.csv_to_df(path=path)\n df = df.set_index(self.ids).sort_index(axis=0).sort_index(axis=1)\n io.df_to_parquet(df=df, path=self.path)\n log.debug(f\"{self.name} now cached in local parquet.\")","def from_csv(self, user, row):\n if len(row) < 4:\n raise BadRequest(_(\"Invalid line\"))\n self.name = row[1].strip().lower()\n for model in [DomainAlias, Domain]:\n if model.objects.filter(name=self.name).exists():\n raise Conflict\n domname = row[2].strip()\n try:\n self.target = Domain.objects.get(name=domname)\n except Domain.DoesNotExist:\n raise BadRequest(_(\"Unknown domain %s\") % domname)\n core_signals.can_create_object.send(\n sender=\"import\", context=self.target, object_type=\"domain_aliases\")\n self.enabled = row[3].strip().lower() in [\"true\", \"1\", \"yes\", \"y\"]\n self.save(creator=user)","def from_csv(self, user, row):\n if len(row) != 6:\n raise BadRequest(_(\"Invalid line\"))\n self.name = row[1].strip()\n self.target_host = row[2].strip()\n self.service, created = Service.objects.get_or_create(\n name=row[3].strip())\n self.enabled = (row[4].strip() == 'True')\n self.verify_recipients = (row[5].strip() == 'True')\n self.save(creator=user)","def loadCSVFile(self):\n file_name = \"files/parts.csv\"\n\n with open(file_name, \"r\") as csv_f:\n reader = csv.reader(csv_f)\n header_labels = next(reader)\n self.model.setHorizontalHeaderLabels(header_labels)\n for i, row in enumerate(csv.reader(csv_f)):\n items = [QStandardItem(item) for item in row]\n self.model.insertRow(i, items)","def process_csv():\n csv_rows = []\n fieldnames = ['site',\n 'latitude',\n 'longitude',\n 'city',\n 'region_code',\n 'country_code',\n 'continent_code',\n 'min_ip_hex',\n 'max_ip_hex',\n 'transit_provider',\n 'min_ip',\n 'max_ip',\n 'ip_prefix',\n 'min_ipv6_hex',\n 'max_ipv6_hex',\n 'min_ipv6',\n 'max_ipv6',\n 'ipv6_prefix']\n\n location_map = build_location_map()\n\n # Read in the CSV file and augment the columns\n with open(INPUT_FILE, 'rb') as csvfile:\n reader = csv.DictReader(csvfile)\n\n for row in reader:\n csv_rows.append(process_row(row, location_map))\n\n # Write the new CSV file with new columns\n with open(OUTPUT_FILE, 'w') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n writer.writeheader()\n for row in csv_rows:\n writer.writerow(row)\n\n print(\"MLab Sites CSV generated at {0}\".format(OUTPUT_FILE))","def init_csv_file(csv_path):\n with open(csv_path, 'w', newline='') as csv_file:\n writer = csv.writer(csv_file)\n header = ['file_name', 'chart_in_file',\n 'year', 'month', 'row_no', 'bird_species']\n header += list(range(1, 32))\n writer.writerow(header)","def __init__(self, product_name, title, url, csv_file_name):\n # this dictionary will be used to save data in csv file\n self.__values = {'product_name': product_name, 'title': title, 'url': url}\n # __csv_fields make save_data() method writes correctly in csv file.\n self.__csv_fields = self.__values.keys()\n self.__csv_file_name = csv_file_name","def process(self, filename=None):\n if not filename:\n filename = self.input_csv\n\n if filename.endswith('.csv'):\n\n with open(filename) as _file:\n reader = csv.reader(_file)\n data = list(reader)\n\n self.save(self.format(self.purify(data)))\n return\n\n raise TypeError(\n \"Excepting csv filetype got %s \\\n filetype instead.\" % (filename.split('.', 1)[1])\n )","def read_csv(self, filepath, obs_vars = ['obs'], header = True):\n # determine if the type file is gzip\n filetype, encoding = mimetypes.guess_type(filepath)\n if encoding == 'gzip':\n self.data = pd.read_csv(filepath, compression='gzip')\n else:\n self.data = pd.read_csv(filepath)\n\n self.original_data = copy.deepcopy(self.data)\n if self.cutoff:\n self.data = self.data[:self.cutoff]\n \n self.data = self.data[obs_vars]\n self.N = self.data.shape[0]\n return True","def fromCSV(self, filename):\n with open(filename, newline = '') as csvfile:\n read = csv.reader(csvfile, delimiter = ',')\n param = []\n for row in read:\n param.append(row)\n self.c = complex(param[0][0])\n self.xmin = int(param[1][0])\n self.xmax = int(param[2][0])\n self.xlen = int(param[3][0])\n self.ymin = int(param[4][0])\n self.ymax = int(param[5][0])\n self.ylen = int(param[6][0])\n self.fs = np.vectorize(param[7][0])\n self.plane = np.loadtxt(\"plane.csv\", delimiter = ',', dtype = 'int') #Read plane from plane.csv file ","def __init__(self, csvfile, fieldnames, *args, **kwargs):\n self.encoding = kwargs.pop('encoding', 'utf-8')\n csv.DictWriter.__init__(self, csvfile, fieldnames, *args, **kwargs)","def parse_csvfile(self, filepath=None):\n designfilename = self.Filename\n if filepath is None:\n filepath = self.Filepath\n else:\n self.Filepath = filepath\n self.Filename = os.path.dirname(filepath)\n if not filepath:\n print(\"No filepath provided, aborting..:!\")\n return False\n dataset, filefields = self._read_csvfile_from_file(self.Filepath)\n self.FileFields = filefields\n self.Dataset = dataset\n\n if self.Verboselevel > 6:\n print(\"Dataset from file: \" + designfilename)\n print(self.Dataset)\n # Find the key specifying the module... (first 'module', then if no 'module' field, search for 'color').\n self.make_fieldsmap()\n\n # Arrange the data for easier access:\n # Produce whole design set:\n self.Designset = set([row[self.Fields['sequence']] for row in self.Dataset])\n # Prepare a dict with an empty set for every moduleclass:\n self.Modulesets = dict([(row[self.Fields['moduleclass']], set()) for row in self.Dataset])\n self.OligoModules = dict()\n self.OligoInfo = dict() # Map sequence back to info from file/row.\n for row in self.Dataset:\n self.Modulesets[row[self.Fields['moduleclass']]].add(row[self.Fields['sequence']])\n # It should also be easy to find the module of a particular sequence without looping further:\n if row[self.Fields['sequence']] in self.OligoModules:\n print(\"WARNING: sequence \" + row[self.Fields['sequence']] + \" is present multiple times.\")\n if self.OligoModules[row[self.Fields['sequence']]] != row[self.Fields['moduleclass']]:\n print(\"--> AND THE SEQUENCE IS PRESENT IN TWO DIFFERENT MODULES, \" + self.OligoModules[row[self.Fields['sequence']]] + \" and \" + row[self.Fields['moduleclass']])\n self.OligoModules[row[self.Fields['sequence']]] = row[self.Fields['moduleclass']]\n self.OligoInfo[row[self.Fields['sequence']]] = row\n if self.Verboselevel > 5:\n print(\"Design and module-sets for designfile: \" + designfilename)\n print(self.Designset)\n print(self.Modulesets)\n\n return self","def import_csv_dataset():\n import_fields = pd.read_csv('redacted-2020-june-30-wprdc-.csv', header=None).to_numpy()[0, :]\n import_values = pd.read_csv('redacted-2020-june-30-wprdc-.csv').to_numpy()\n import_values = clean_values(import_values)\n return import_fields, import_values","def __close_csv(self):\n if self.__csv_file is not None:\n try:\n self.__csv_file.close()\n except IOError:\n pass\n self.__csv_file = None","def from_csv(cls, load_folder: Path) -> \"Parameters\":\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\n return serializer.load(class_obj=cls, folder_path=load_folder)","def process_loading_file(self):\n column_headers = []\n column_headers_all = []\n\n # Open the file once to get idea of the total rowcount to display progress\n with open(self.csv_file_path[0], newline='') as csv_file:\n self.progress_max.emit(len(csv_file.readlines()) - 2)\n\n with open(self.csv_file_path[0], newline='') as csv_file:\n\n self.csv_data_table.setRowCount(0)\n self.csv_data_table.setColumnCount(0)\n\n csv_file_read = csv.reader(csv_file, delimiter=',', quotechar='|')\n\n # Fetch the column headers and move the iterator to actual data\n column_headers = next(csv_file_read)\n\n # Reflect back the changes in the reference to the column headers\n for header in column_headers:\n self.column_headers.append(header)\n # A backup to keep a list of all the headers to toogle their view later\n self.column_headers_all.append(header)\n\n # TODO: Increase the reading speed by decreasing load on actual table population\n\n # self.csv_data_table.hide()\n\n for row_data in csv_file_read:\n\n self.relay.emit(self.csv_data_table.rowCount())\n # self.relay.emit(self.x)\n # self.x = self.x + 1\n row = self.csv_data_table.rowCount()\n self.csv_data_table.insertRow(row)\n self.csv_data_table.setColumnCount(len(row_data))\n for column, stuff in enumerate(row_data):\n item = QTableWidgetItem(stuff)\n self.csv_data_table.setItem(row, column, item)\n\n self.csv_data_table.setHorizontalHeaderLabels(self.column_headers)\n\n # Set WordWrap to True to make the cells change height according to content\n # Currently set it to false as it looks very decent and makes cell size uniform throughout\n self.csv_data_table.setWordWrap(False)\n # Uncomment below line to stretch to fill the column width according to content\n # self.csv_data_table.resizeColumnsToContents()\n self.csv_data_table.resizeRowsToContents()\n\n # Update the bottom toolbar to reflect changes\n self.update_bottom_toolbar.emit()\n self.finished.emit()","def test_valid_csv(self):\n url=\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\"\n readerobject=requester.url_to_csv(url, fname='wine2')\n self.assertTrue(str(type(readerobject)),\"_csv.reader\")","def __init__(self, csv_path):\r\n # Transforms\r\n self.to_tensor = transforms.ToTensor()\r\n # Read the csv file\r\n self.data_info = pd.read_csv(csv_path, header=None)\r\n # First column contains the image paths\r\n self.image_arr = np.asarray(self.data_info.iloc[:, 0])\r\n # Second column is the labels\r\n self.label_arr = [np.asarray(self.data_info.iloc[:, 1])]\r\n # Third column is for an operation indicator\r\n #self.operation_arr = np.asarray(self.data_info.iloc[:, 2])\r\n # Calculate len\r\n self.data_len = len(self.data_info.index)","def _setprior_csv(self, csv_file):\n\n #-- number of time-points\n npts = self.get_npts()\n\n #-- read state from CSV file\n fmt = self._guess_time_format(csv_file)\n state_inst = sv.get_state_csv(fname=csv_file, fmt=fmt)\n\n #-- LAI,Canopy-Height,Soil-Moisture\n self.prstate = np.empty((3,npts), dtype=np.float64)\n\n for i,date_utc in enumerate(self.schedule_dct['date_utc']):\n idx, timedelt = sv.find_nearest_date_idx(state_inst.date_utc, date_utc)\n if timedelt.days>=1:\n msg = \"for scheduled date ---{}--- \".format(date_utc.strftime('%Y-%m-%dT%H%M'))\n msg += \"time nearest state differs by at least one day!\"\n FileLogger.warn(msg)\n #-- LAI\n self.prstate[0,i] = state_inst.lai[idx]\n #-- canopy-height\n self.prstate[1,i] = state_inst.can_height[idx]\n #-- SM\n self.prstate[2,i] = state_inst.soil_moisture[idx]","def readCSV(filename):\r\n data = list( csv.reader(open('HW_08_DBScan_Data_NOISY_v300.csv','r'),delimiter=','))\r\n for dIdx in range(len(data)):\r\n data[dIdx] = [float(data[dIdx][0]),float(data[dIdx][1]),float(data[dIdx][2])]\r\n #print(data[0])\r\n return data","def convert_csv_to_SQLite3(self,\n csv_path: str=None, # Path to .csv \n destination: str=None, # Where to create .db\n db_name: str=None, # Database name\n table_name: str=None, # table name\n **kwargs # Custom arguments for reader and writter\n ):\n # With scribe reader, read a .csv \n # **kwargs, are used in params in the subclass Scibe_File_Writter\n # **Kwargs Over-write convert_csv_to_db params\n # Inherits from scribe_readers.Scribe_File_Reader\n self.read_from_csv(csv_path, **kwargs) # Inherits from scribe_readers.Scribe_File_Reader\n if db_name != None:\n destination = f\"{destination}\\{db_name}.db\"\n self.db_name = db_name\n conn = self.create_sqlite_connection(destination) # Inherits from scribe_writers_Scribe_Scribe_SQLite_Writer\n # Create connection also creates new db if it does not exist.\n self.create_new_sqlite_table(conn=conn,\n schema=self.dtypes,\n table_name=f\"tbl_{table_name}\",\n close_conn =False)\n \n \"\"\"Insert data into SQLite database\"\"\"\n\n table_name=f\"tbl_{table_name}\"\n self.insert_into_sqlite_table(conn,\n csv_path,\n table_name,\n self.shape,\n self.delimiter)","def load_csv(self):\n options = QFileDialog.Options()\n options |= QFileDialog.DontUseNativeDialog\n files, _ = QFileDialog.getOpenFileNames(\n self,\n \"Select one or more files\",\n \"\",\n \"csv files (*.csv);;All Files (*)\",\n options=options,\n )\n self.show()\n\n if files:\n self.files_now = files\n else:\n self.files_now = None\n\n if self.files_now:\n self.lineEdit_file_name.setText(self.files_now[0])\n self.update_gui_from_csv()","def printGrilleCSV(self):\n print(\"Length grillecsv : \"+str(len(self._get_grille_csv())))\n for row in self._get_grille_csv():\n print(\"(\", end=\"\")\n for cell in row:\n if cell == \"\":\n print(\" ,\", end=\"\")\n else:\n print(cell+\",\", end=\"\")\n print(\")\")","def read_csv(self, filepath, header=True):\n BaseSampler.read_csv(self, filepath, header)\n # convert the data to floats\n self.new_obs = []\n self.img_w, self.img_h = None, None\n for row in self.obs:\n if self.img_w is None:\n self.img_w = int(row[0])\n if self.img_w == 0 or (len(row)-1) % self.img_w != 0:\n raise Exception('The sampler does not understand the format of the data. Did you forget to specify image width in the data file?')\n self.new_obs.append([int(_) for _ in row])\n\n self.obs = np.array(self.new_obs)[:,1:]\n if self.cl_mode:\n self.d_obs = cl.Buffer(self.ctx, self.mf.READ_ONLY | self.mf.COPY_HOST_PTR, hostbuf=self.obs.astype(np.int32))\n\n self.d = self.obs.shape[1]\n self.img_h = int(self.d / self.img_w)\n self.alpha = float(self.N) * 5\n return","def __init__(self, csv_path, column_types=None, set_columns=False, file_headers=True, encoding=\"utf-8-sig\",\n missing_to_zero=False, print_warnings=True):\n\n self.file_path = Path(csv_path)\n self.file_name = self.file_path.stem\n\n self._file_headings = file_headers\n self._encoding = encoding\n\n self.headers = self._extract_headers()\n self.row_length = len(self.headers)\n\n self.missing_to_zero = missing_to_zero\n self.print_warnings = print_warnings\n self.invalid_typed = []\n\n self.column_types = self._determine_column_types(column_types)\n self.row_data, self.column_data, self.column_length = self._set_data(set_columns)\n\n # Old definitions kept for legacy, but new names added for clarity\n self.num_cols = self.row_length\n self.num_rows = self.column_length\n\n if len(self.invalid_typed) > 0 and self.print_warnings:\n print(f\"Warning: The following column-row-value-type where not correct so loaded as strings:\\n\"\n f\"{sorted(self.invalid_typed)}\")","def _importInDjango(self):\n\n with open(settings.DATA_PATH, 'r', encoding='latin-1') as csv_file:\n reader = csv.DictReader(csv_file, delimiter=';')\n for raw in reader:\n\n # Créer ou mettre à jour la division\n division, created = Division.objects.get_or_create(\n nom=raw['Division']\n )\n if created:\n self.stdout.write(\n 'Divion {} ajoutée'.format(division.nom)\n )\n\n # Créer ou mettre à jour les équipes\n equipeDom, created = Equipe.objects.get_or_create(\n nom=raw['Equipe 1'],\n division=division\n )\n if created:\n self.stdout.write(\n 'Equipe {} ajoutée'.format(equipeDom.nom)\n )\n\n equipeExt, created = Equipe.objects.get_or_create(\n nom=raw['Equipe 2'],\n division=division\n )\n if created:\n self.stdout.write(\n 'Equipe {} ajoutée'.format(equipeExt.nom)\n )\n\n # Créer ou mettre à jour la rencontre\n scoreDom = 0 if raw['Score 1'] == '' else int(raw['Score 1'])\n scoreExt = 0 if raw['Score 2'] == '' else int(raw['Score 2'])\n forfaitDom = True if raw['Forfait 1'] == 'true' else False\n forfaitExt = True if raw['Forfait 2'] == 'true' else False\n date = datetime.datetime.strptime(raw['Date de rencontre'], '%d/%m/%Y')\n heure = datetime.datetime.strptime(raw['Heure'], '%H:%M')\n rencontre, created = Rencontre.objects.update_or_create(\n numero=int(raw['N° de match']),\n equipeDom=equipeDom,\n equipeExt=equipeExt,\n defaults={\n 'date': date,\n 'heure': heure,\n 'scoreDom': scoreDom,\n 'scoreExt': scoreExt,\n 'forfaitDom': forfaitDom,\n 'forfaitExt': forfaitExt,\n }\n )\n if created:\n self.stdout.write(\n 'Rencontre {} / {} ajoutée'.format(\n rencontre.equipeDom,\n rencontre.equipeExt\n )\n )","def format_porteurs(filepath):\n fieldnames, rows = get_header_rows(filepath)\n\n if \"statut\" in fieldnames:\n fieldnames.append(\"situation_societariat_entrance\")\n fieldnames.append(\"situation_situation\")\n for row in rows:\n statut = row['statut']\n row['situation_societariat_entrance'] = \"\"\n if statut == \"Associé\":\n row['situation_societariat_entrance'] = \"01/01/2015\"\n row['situation_situation'] = PORTEUR_STATUS_MATCH.get(statut)\n\n\n if 'coordonnees_address1' in fieldnames and 'coordonnees_address2' in fieldnames:\n fieldnames.append('coordonnees_address')\n for row in rows:\n row['coordonnees_address'] = row['coordonnees_address1'] + \\\n '\\n' + row['coordonnees_address2']\n\n if \"coordonnees_civilite\" in fieldnames:\n fieldnames.append('coordonnees_sex')\n for row in rows:\n if row['coordonnees_civilite'].lower() == u\"mademoiselle\":\n row['coordonnees_civilite'] = u\"Madame\"\n\n if row['coordonnees_civilite'] == u'Madame':\n row['coordonnees_sex'] = 'F'\n else:\n row['coordonnees_sex'] = 'M'\n\n if \"zus\" in fieldnames:\n fieldnames.append(\"coordonnees_zone_qual\")\n for row in rows:\n if row['zus'] == '1':\n row['coordonnees_zone_qual'] = 'zus'\n\n write_csv_file(filepath, fieldnames, rows)","def dump_csv(\n self, csv_reader: protocols.Reader, columns: Sequence[str], dest_table: str\n ) -> None:\n self._copy_expert_csv(csv_reader, columns, dest_table)","def data_from_csv(self, filepath):\n self.dataframe = pd.load_csv(filepath, separator='')","def init(fileName):\r\n global grand_prod_cost, grand_album_sales\r\n infile = ''\r\n try:\r\n with open(fileName, mode='r') as infile:\r\n reader = csv.reader(infile)\r\n sniffer = csv.Sniffer()\r\n has_header = sniffer.has_header(infile.read(2048))\r\n infile.seek(0)\r\n if (has_header):\r\n next(reader) # move curser to next row so the header is not included\r\n initBands(reader)\r\n # Reset the curser to start based on presence of header\r\n if(has_header):\r\n infile.seek(0)\r\n # avoid header\r\n next(reader)\r\n else:\r\n infile.seek(0)\r\n splitByBand(reader)\r\n except Exception as e:\r\n print('Exception in init')\r\n raise e","def read(self):\r\n\r\n self.data = []\r\n\r\n with open(self.filename + \".csv\", mode='r') as csv_file:\r\n reader = csv.DictReader(csv_file)\r\n for row in reader:\r\n self.data.append(row)","def __obtain_data_from_csv__(self, csvfile):\n data = csvfile.readlines()\n data = self.__parse_string_for_delimiter__(data)\n return data","def get_csv_string(self, **kwargs):\n ...","def upload_csv_data(self, upload_file):\n db = DataBase(self.DATABASE_DATA)\n db.insert_data_from_file(\n 'triagedata.historicdata',\n ('clinic_id', 'severity', 'date_received', 'date_seen'),\n upload_file,\n ','\n )","def saveCsv(self, filePath = None, rowDeliminator = None, columnDeliminator = None, sheetDeliminator = None, yieldForNone = \"\", skipLineCondition = None):\n\n\t\t\tdef yieldValues(row):\n\t\t\t\tfor cell in row:\n\t\t\t\t\tvalue = cell.value\n\t\t\t\t\tif (value is None):\n\t\t\t\t\t\tyield yieldForNone\n\t\t\t\t\telse:\n\t\t\t\t\t\tyield value\n\n\t\t\tif (skipLineCondition is None):\n\t\t\t\tdef yieldRows(mySheet):\n\t\t\t\t\tfor row in mySheet.thing.rows:\n\t\t\t\t\t\tyield rowDeliminator.join(yieldValues(row))\n\t\t\telse:\n\t\t\t\tdef yieldRows(mySheet):\n\t\t\t\t\tfor row in mySheet.thing.rows:\n\t\t\t\t\t\tif (not skipLineCondition(row)):\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\tyield rowDeliminator.join(yieldValues(row))\n\n\t\t\tdef yieldSheet():\n\t\t\t\tnonlocal self\n\n\t\t\t\tfor mySheet in self:\n\t\t\t\t\tyield columnDeliminator.join(yieldRows(mySheet))\n\n\t\t\t############################\n\n\t\t\trowDeliminator = self.ensure_default(rowDeliminator, \",\")\n\t\t\tsheetDeliminator = self.ensure_default(sheetDeliminator, \"\\n\")\n\t\t\tcolumnDeliminator = self.ensure_default(columnDeliminator, \"\\n\")\n\n\t\t\t_filePath = self.ensure_filePath(self.ensure_default(filePath, default = self.filePath), ending = (\".csv\"), checkExists = False)\n\t\t\twith open(_filePath, \"w+\") as fileHandle:\n\t\t\t\tfileHandle.write(sheetDeliminator.join(yieldSheet()))","def buildFromCSV(self, filepath):\r\n\t\t# TODO: Implement\r\n\t\traise NotImplementedError('This function has not yet been implemented.')\r\n\t\t# with open(filepath, 'r') as scheduleFile:\r\n\t\t# \t# Reusing Parser.parseCSVs(), but not in the intended way; ok because validation is not yet implemented\r\n\t\t# \t# TODO: Split Parser.parseCSVs() into separate people/set file parsers \r\n\t\t# \tn, people, setConstraints = Parser.parseCSVs(-1, scheduleFile, [])\r","def read_csv(self, csv_file):\n mylog.debug('Reading csv file %s for data' % csv_file)\n csv_data = pandas.read_csv(csv_file)\n mylog.debug('Read of csv file complete.')\n #mylog.debug('%s' % csv_data)\n #sometimes the csv has an empty dataframe #\n if csv_data.empty:\n mylog.debug('Data frame is empty; repopuating data')\n csv_info = []\n for item in csv_data:\n #add the data one cell at a time to the list #\n #for some reason, some csvs have the data #\n #with random decimal points #\n csv_info.append(item.split(\".\")[0])\n df = pandas.DataFrame(columns=csv_info)\n df.loc[0]=csv_info\n #write the data from the list back into the cells#\n #one at a time #\n for column in range(0, len(csv_info)): \n df.iloc[0,column] = csv_info[column]\n csv_data = df \n return csv_data","def __init__(self, path=None):\n super().__init__(path=path)\n self.path += '{}.csv'","def map_csv_fields(self):\n etod_csv_fields = {\n 'ctry_id': None,\n 'obst_identifier': None,\n 'obst_name': None,\n 'lon_src': None,\n 'lat_src': None,\n 'agl': None,\n 'amsl': None,\n 'vert_uom': None,\n 'hor_acc': None,\n 'hor_acc_uom': None,\n 'vert_acc': None,\n 'vert_acc_uom': None,\n 'obst_type': None,\n 'lighting': None,\n 'marking': None,\n 'is_group': None,\n }\n\n for field in etod_csv_fields:\n try:\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\n except KeyError:\n etod_csv_fields[field] = None\n\n self.field_map = etod_csv_fields","def ingest_rental_csv(csv_path):\n # Create a CSV import generator (next yields one db row)\n import_generator = import_csv_gen(csv_path)\n # Skip over the title row\n next(import_generator)\n # Iterate over all other rows\n while True:\n try:\n data = next(import_generator)\n if len(data) != 2:\n logger.error(f'Data with incorrect item count: {len(data)}')\n continue\n # extract items from list and add document to database\n with Connection():\n rental = Rental(\n product_id=data[RENTAL_PROD_ID],\n user_id=data[RENTAL_USER_ID]\n )\n rental.save() # This will perform an insert\n except StopIteration:\n break","def importer():\n\n #Lager liste der eg legg transaksjonar som blir henta og ikkje laga:\n get_list = []\n\n #Gjer txt-fila i mappen om til csv-fil\n file_fixer()\n\n with open(out_path) as file:\n reader = csv.reader(file)\n r_0 = next(reader)\n r_0.append(\"type\")\n r_0.append('amount')\n r_0.append('category')\n r_0.append('account')\n r_0.append('project')\n\n\n for row in reader:\n #Legger til dei fire kollonenne (amount, account, subaacount, project), tomme.\n row.append(\"\")\n row.append(\"\")\n\n #Omformatterer rader:\n row = format_fix(row)\n row.append(\"\")\n row.append(\"\")\n row.append(\"\")\n print(row)\n\n\n try:\n obj, created = Transaction.objects.get_or_create(\n date=row[0],\n transaction_type=row[1],\n description=row[2],\n amount=row[3]\n )\n\n except Transaction.MultipleObjectsReturned:\n continue\n\n if not created:\n get_list.append(obj.pk)\n\n return get_list","def lectcsv(NOM):\n #NOM=input(\"nom du fichier:\")#interactif\n #NOM=str(NOM +\".csv\")\n c=[NOM]\n #ouverture du fichier et recuperation du contenu\n with open(NOM) as f:\n contenu = csv.reader(f, delimiter=' ', quotechar='|')\n for row in contenu:\n c.append(row[0].split(';'))#separation du string \n return c","def exportCSV(self, log, csvFile):\n return 0"],"string":"[\n \"def read_csv_file(self):\\n pass\",\n \"def read_csv():\",\n \"def _read_csv(self):\\n self.function_name = '_read_csv'\\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\\n reader = csv.reader(csv_file, dialect='excel')\\n for row in reader:\\n self.input_data.append(row)\",\n \"def csv_reader(file_obj):\\n global gagnant\\n global gain\\n # le tableau qui contient les gagnants\\n reader = csv.reader(file_obj, delimiter=';')\\n gagnant = next(reader)\\n gain = next(reader)\\n gagnant = [list(map(int,gagnant))]\\n gagnant=gagnant[0]\\n gain = [list(map(int,gain))]\\n gain=gain[0]\",\n \"def get_data(self, csv_file):\\n pass\",\n \"def __open_csv(self):\\n self.__csv_file = open(self.__csv_file_name, 'w', encoding='utf-8')\\n self.__csv_writer = csv.writer(self.__csv_file, delimiter=',', )\",\n \"def csv_reader2(file_obj):\\n global grilles\\n # le tableau qui contient les gagnants\\n grilles = [list(map(int,rec[1:])) for rec in csv.reader(file_obj, delimiter=';')]\",\n \"def loadCSV(input_file):\",\n \"def handle_csv(self):\\n try:\\n reader = csv.reader(open(self.options.datafile, 'r'))\\n except IOError:\\n errormsg(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n raise Exception(_('Cannot read \\\"{}\\\"'.format(self.options.datafile)))\\n if self.options.var_type == 'name':\\n try:\\n self.header = reader.next()\\n except StopIteration:\\n errormsg(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n raise Exception(_('Data file \\\"{}\\\" contains no data'.format(\\n self.options.datafile)))\\n self.data = []\\n for row in reader:\\n self.data.append(row)\",\n \"def __init__(self, path):\\n self.csv_path = path\\n # check if csv format is valid or not\\n self.check_valid_csvformat(self.csv_path)\\n \\\"\\\"\\\" empty dict to store all company names\\n prepare initial company data in dictionary format \\\"\\\"\\\"\\n self.company_data = dict()\",\n \"def set_input_csv(self):\\n if len(self[\\\"input_csv\\\"]) > 1:\\n raise Exception(\\\"You must only specify *one* unified CSV file!\\\")\\n self.csv_path = self[\\\"input_csv\\\"][0]\\n print(\\\"Using input file\\\", self.csv_path)\",\n \"def prepare_CSV(self):\\n self.drop_columns()\\n self.rename_columns()\\n self.spilt_columns()\\n self.add_vehicle_id_column()\\n self.add_source_column()\\n self.add_timestamp_columns()\\n self.get_colour_columns()\\n self.clean_column_formats()\\n\\n # print(self.data.info())\\n # print(self.data.sample(10))\\n\\n return self.data\",\n \"def __init__(self,csvrow):\\n self.raw = csvrow\\n data = csvrow.split(',')\\n self.number = data[0]\\n self.area = int(data[1])\\n self.population = int(data[5])\\n self.latitude = float(data[7])\\n self.longitude = float(data[8])\",\n \"def import_glucose_from_csv(user, csv_file):\\n csv_data = []\\n reader = csv.reader(csv_file.read().splitlines(), delimiter=',',\\n quotechar='\\\"')\\n for row in reader:\\n csv_data.append([item.strip() for item in row])\\n\\n glucose_objects = []\\n\\n # Check if headers exists. Skip the first entry if true.\\n header_check = ['value', 'category', 'date', 'time']\\n first_row = [i.lower().strip() for i in csv_data[0]]\\n if all(i in first_row for i in header_check):\\n csv_data = csv_data[1:]\\n\\n for row in csv_data:\\n # Let's do an extra check to make sure the row is not empty.\\n if row:\\n try:\\n category = Category.objects.get(name__iexact=row[1].strip())\\n except ObjectDoesNotExist:\\n category = Category.objects.get(name__iexact='No Category'.strip())\\n\\n # Since we always store the value in mg/dL format in the db, we need\\n # to make sure we convert it here if the user's setting is set to\\n # mmol/L.\\n if user.settings.glucose_unit.name == 'mmol/L':\\n value = int(to_mg(row[0]))\\n else:\\n value = int(row[0])\\n\\n glucose_objects.append(Glucose(\\n user=user,\\n value=value,\\n category=category,\\n record_date=datetime.strptime(row[2], DATE_FORMAT),\\n record_time=datetime.strptime(row[3], TIME_FORMAT),\\n notes=row[4],\\n ))\\n\\n Glucose.objects.bulk_create(glucose_objects)\",\n \"def __init__(self, in_csvfile, out_csvfile, col_name, cell_filler):\\r\\n self.in_csvfile = in_csvfile\\r\\n self.out_csvfile = out_csvfile\\r\\n self.col_name = col_name\\r\\n self.cell_filler = cell_filler\",\n \"def prepare_csv(self, filename, *args, **kwargs):\\n x_possible = getattr(settings, 'IMPORT_CSV_X_FIELDS', ['Lon*', 'x', 'lon*'])\\n y_possible = getattr(settings, 'IMPORT_CSV_Y_FIELDS', ['Lat*', 'y', 'lat*'])\\n geom_possible = getattr(settings, 'IMPORT_CSV_GEOM_FIELDS',\\n ['geom', 'GEOM', 'WKT', 'the_geom', 'THE_GEOM', 'WKB'])\\n\\n oo = kwargs.get('open_options', [])\\n\\n oo.append('X_POSSIBLE_NAMES={0}'.format(','.join(x_possible)))\\n oo.append('Y_POSSIBLE_NAMES={0}'.format(','.join(y_possible)))\\n oo.append('GEOM_POSSIBLE_NAMES={0}'.format(','.join(geom_possible)))\\n\\n kwargs['open_options'] = oo\\n\\n return filename, args, kwargs\",\n \"def __init__(self, *, csv_file_path: str = ''):\\n self.__csv_file_path = csv_file_path\\n self._parse_csv()\",\n \"def csv_url(self, csv_url):\\n\\n self._csv_url = csv_url\",\n \"def csv_url(self, csv_url):\\n\\n self._csv_url = csv_url\",\n \"def __init__(self, csv_file: str = None) -> None:\\n super().__init__(csv_file)\",\n \"def __init__(self, csv_file: str = None) -> None:\\n super().__init__(csv_file)\",\n \"def read_csv(self, csv_input):\\n # https://stackoverflow.com/a/45063514\\n dtypes = {\\n 'lat': 'U',\\n 'long': 'U'\\n }\\n csv_data = pd.read_csv(csv_input, encoding='UTF-8', sep=',', na_values=[''], dtype=dtypes)\\n\\n self.table = csv_data.fillna('').applymap(lambda x: x.strip() if type(x) == str else x)\\n self.log.info('Data read from CSV %s' % csv_input)\\n #print('Data read from CSV %s' % csv_input)\",\n \"def initCSV(self, makeFile, overWrite):\\n self.initialized = True\\n\\n os.chdir(os.path.dirname(os.path.abspath(__file__)))\\n\\n if os.path.exists(str(self.fileName)):\\n\\n f = open(str(self.fileName), \\\"r\\\")\\n\\n if not f.read():\\n f.close()\\n\\n f = open(str(self.fileName), \\\"w\\\")\\n outString = \\\"\\\"\\n for varName in self.variableDescriptions:\\n outString += varName\\n outString += \\\",\\\"\\n\\n f.write(outString[0:-1])\\n\\n f.write('\\\\n')\\n else:\\n if overWrite == True:\\n f.close()\\n\\n f = open(str(self.fileName), \\\"w\\\")\\n outString = \\\"\\\"\\n for varName in self.variableDescriptions:\\n outString += varName\\n outString += \\\",\\\"\\n\\n f.write(outString[0:-1])\\n\\n f.write('\\\\n')\\n if overWrite == False:\\n raise OSError(\\\"csv file is not empty!\\\")\\n\\n else:\\n if makeFile == True:\\n f = open(str(self.fileName), \\\"w\\\")\\n \\n f.close()\\n else:\\n raise OSError(\\\"csv file not found!\\\")\",\n \"def _read_csv(self):\\n with open(self._file_path, 'rb') as f:\\n reader = csv.DictReader(f, delimiter=',')\\n self._content = [row for row in reader]\",\n \"def import_csv(self, csvfileobject):\\n # Clear previously stored info\\n self._tracks = []\\n self._selected = None\\n\\n for row in csvfileobject:\\n if row[0] == \\\"T\\\":\\n track = self.addTrack()\\n track.properties = row\\n elif row[0] == \\\"P\\\":\\n period = self.addPeriod([0,1,'-'])\\n period.properties = row\",\n \"def post_init(cr, registry):\\n import_csv_data(cr, registry)\",\n \"def _fill(self, lang, csv_file_name, save_func, start=1):\\n with (DATA_PATH / lang / csv_file_name).open() as csv_file:\\n lines = enumerate(csv.reader(csv_file, delimiter=';'), 1)\\n for line_num, row in dropwhile(lambda line: line[0] != start,\\n lines):\\n try:\\n save_func(row)\\n except Exception as error:\\n raise ReadCSVError(line_num, csv_file_name, error)\",\n \"def dataLoad():\\n try:\\n try: #Python3\\n f = open(__file__ + \\\".csv\\\",\\\"rt\\\")\\n except: #Python2\\n f = open(__file__ + \\\".csv\\\",\\\"rb\\\")\\n data = f.read().split(',')\\n entryCol.entry0.delete(0,END)\\n entryCol.entry0.insert(0,data[0])\\n entryCol.entry1.delete(0,END)\\n entryCol.entry1.insert(0,data[1])\\n entryCol.entry2.delete(0,END)\\n entryCol.entry2.insert(0,data[2])\\n entryCol.entry3.delete(0,END)\\n entryCol.entry3.insert(0,data[3])\\n botWind.writeN(\\\"DataLoad: File\\\")\\n except:\\n botWind.writeN(\\\"DataLoad: Default\\\")\",\n \"def ort_kreis_reader(self, csv_file):\\n\\n ort_kreis_df = pd.read_csv(csv_file, usecols=[1,3], names=['Ort', 'Kreis'], skiprows=1)\\n\\n ort_kreis_df = ort_kreis_df.drop_duplicates(keep='first')\\n\\n #cities kreis names are null, so fill their kreis slot with that city name\\n ort_kreis_df['Kreis'].fillna(ort_kreis_df['Ort'], inplace=True)\\n\\n cleaned_ort_kreis_df = ort_kreis_df.replace(to_replace=' Städte|-Kreis| Kreis|Kreis | Land|Landkreis |Städteregion ', value='', regex=True)\\n\\n return cleaned_ort_kreis_df\",\n \"def __obtain_csv_fieldnames__(self, csvfile):\\n self.__fieldnames__ = csvfile.readline()\\n self.__obtain_csv_delimiter__(self.__fieldnames__)\\n self.__fieldnames__ = self.__remove_break_line__(self.__fieldnames__)\\n self.__fieldnames__ = self.__split_for_delimiter__(self.__fieldnames__)\",\n \"def reload_csv(self):\\n self.load_csv()\\n self.tableView.insert_data(self.database)\\n self.update()\",\n \"def CsvToJson(nomfichierJson):\\n with open(\\\"save/save.csv\\\",'r') as f:\\n liste_cube = list()\\n liste_robot = list()\\n \\\"\\\"\\\"deux listes vides pour contenir les objets charges\\\"\\\"\\\"\\n for line in f:\\n ligne=line.split(\\\";\\\")\\n if ligne[0] == 'Arene':\\n \\\"\\\"\\\"On cree une nouvelle arene avec les parametres trouves sur la ligne, separes par des ';' \\\"\\\"\\\"\\n arene = Arene(int(ligne[1]),int(ligne[2]),int(ligne[3]),liste_cube,liste_robot)\\n arene.liste_robot=liste_robot\\n elif ligne[0] == 'Cube':\\n \\\"\\\"\\\"On ajoute le cube a la liste de cube de l'arene, avec parametres trouves sur la ligne\\\"\\\"\\\"\\n arene.liste_cube.append(Cube(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5]),int(ligne[6])))\\n elif ligne[0] == 'Mur':\\n arene.liste_cube.append(Mur(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5]),int(ligne[6])))\\n elif ligne[0] == 'Sol':\\n arene.liste_cube.append(Sol(int(ligne[1]),int(ligne[2]),int(ligne[3]),int(ligne[4]),int(ligne[5])))\\n elif ligne[0] == 'Robot':\\n (x,y,z)=literal_eval(ligne[1])\\n ((cax,cay),(cbx,cby),(ccx,ccy),(cdx,cdy))=literal_eval(ligne[2])\\n (a,b,c)=literal_eval(ligne[3])\\n (lo,la,ha)=literal_eval(ligne[4])\\n vitesse=literal_eval(ligne[5])\\n arene.liste_robot.append(Robot((x,y,z),((cax,cay),(cbx,cby),(ccx,ccy),(cdx,cdy)),(a,b,c),(lo,la,ha),vitesse))\\n saveFic(arene,nomfichierJson)\",\n \"def __init__(self, csvfile, *args, **kwargs):\\n self.encoding = kwargs.pop('encoding', 'utf-8')\\n csv.DictReader.__init__(self, csvfile, *args, **kwargs)\",\n \"def read(self):\\n with open(self.filename) as f:\\n reader=csv.reader(f)\\n for row in reader:\\n self.data.appendleft(row)\",\n \"def __init__(self, csv_path):\\n # Checking files\\n fdops.check_if_file_exists(csv_path)\\n\\n # loading proposal data as a data frame\\n self._df = pd.read_csv(csv_path)\\n\\n # Dictionary containing proposal properties\\n self.props = self._get_properties(csv_path)\",\n \"def from_csv(self, user, row):\\n if len(row) != 4:\\n raise BadRequest(_(\\\"Invalid line\\\"))\\n self.name = row[1].strip()\\n try:\\n self.target = RelayDomain.objects.get(name=row[2].strip())\\n except RelayDomain.DoesNotExist:\\n raise NotFound(_(\\\"Relay domain %s does not exist\\\" % row[2].strip()))\\n self.enabled = (row[3].strip() == 'True')\\n self.save(creator=user)\",\n \"def read_csv():\\n global csvdata\\n global CONFIG\\n if type(csvdata) == type(None):\\n if not os.path.exists(CONFIG[\\\"csvfile\\\"]):\\n csvdata = pandas.read_csv(CONFIG[\\\"csvrepo\\\"],\\n na_values=[\\\"-999999\\\",\\\"NOT AVAILABLE\\\"])\\n os.makedirs(CONFIG[\\\"cachedir\\\"],exist_ok=True)\\n csvdata.to_csv(CONFIG[\\\"csvfile\\\"])\\n else:\\n csvdata = pandas.read_csv(CONFIG[\\\"csvfile\\\"])\\n return csvdata\",\n \"def csv(self, file, table=None):\\n\\n if table:\\n table.import_from_csv_file(file)\\n else:\\n db = self.db\\n # This is the preferred method as it updates reference fields\\n db.import_from_csv_file(file)\\n db.commit()\",\n \"def load_data_csv(self, filename):\\n import csv\\n\\n self.begin_batch() #avoid unecessary updates\\n\\n #delete old data\\n #TODO: check of deleting data is really what user wants\\n #TODO: create method for clearing data\\n msg = wx.grid.GridTableMessage(self,\\n wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED,\\n 0,\\n self.GetNumberRows())\\n self.rowmask = numpy.array([], dtype = numpy.bool)\\n self.data = numpy.empty(shape = (0, len(self.colLabels)), dtype = numpy.object)\\n self.GetView().ProcessTableMessage(msg)\\n \\n #process file\\n with open(filename, 'rb') as f:\\n\\n #read first row to extract fieldnames\\n header = csv.reader(f).next()\\n\\n #parse field header \\\"name [dynamic] (custom label)\\\"\\n pattern = re.compile(r\\\"(?P<name>\\\\w+(\\\\s\\\\w+)?)\\\\s*(\\\\[(?P<dynamic>.*)\\\\])?\\\\s*(\\\\((?P<label>.*)\\\\))?\\\\s*(\\\\{(?P<options>.*)\\\\})?\\\",\\n re.VERBOSE)\\n fields = []\\n dyn_expr = {}\\n cust_label = {}\\n vis_cols = {}\\n for entry in header:\\n r = pattern.match(entry)\\n d = r.groupdict()\\n name = d['name']\\n if name:\\n fields.append(name)\\n if d['dynamic']: dyn_expr[name] = d['dynamic']\\n if d['label']: cust_label[name] = d['label']\\n if d['options']:\\n if '*' in d['options']: vis_cols[name] = True\\n\\n #set dynamic expressions\\n for k, col in enumerate(self.dynamic_cols):\\n dexpr = dyn_expr.get(self.colLabels[col])\\n if dexpr:\\n self.dynamic_expressions[k] = dexpr\\n\\n #set custom column labels\\n for k, label in enumerate(self.colLabels):\\n clabel = cust_label.get(label)\\n if clabel:\\n self.column_labels_custom[k] = clabel\\n\\n #also show columns which are marked as visible in csv file\\n colsel = set(self.colsel)\\n for k, label in enumerate(self.colLabels):\\n if vis_cols.get(label):\\n colsel.add(k)\\n colsel = list(colsel)\\n colsel.sort()\\n self.View.SetColumnSelection(colsel)\\n\\n #read data\\n reader = csv.DictReader(f, fieldnames = fields)\\n\\n row = -1\\n for rowdict in reader:\\n row += 1\\n self.AppendRows()\\n\\n if rowdict.get('masked') == 'True':\\n self.maskrows(row)\\n\\n #loop over columns in _actual_ table, \\n for col, typelabel in enumerate(zip(self.dataTypes, self.colLabels)):\\n datatype, label = typelabel\\n\\n #ask csv reader whether corresponding entry exists \\n value = rowdict.get(label)\\n if value is None or value == '':\\n continue\\n\\n try:\\n #convert string value to proper type\\n #TODO: optimize it by creating a table of conversion functions\\n #or a table method that takes a string\\n if wx.grid.GRID_VALUE_FLOAT in datatype:\\n val = float(value)\\n elif wx.grid.GRID_VALUE_NUMBER in datatype:\\n val = int(value)\\n elif wx.grid.GRID_VALUE_BOOL in datatype:\\n if value == '1' or value == 'True':\\n val = True\\n else:\\n val = False\\n elif wx.grid.GRID_VALUE_STRING in datatype:\\n val = value\\n else:\\n print \\\"loading of type %s is not supported\\\"%datatype\\n continue\\n\\n self.SetValueRaw(row, col, val)\\n except ValueError:\\n print \\\"warning reading csv: cannot convert value '%s' to type %s\\\"%(value, datatype)\\n\\n self.AppendRows(2) \\n self.end_batch()\\n self.modified = False\",\n \"def load_csv(self):\\n\\n # Close any already opened file if any\\n self.close_file()\\n\\n # Disable cell change check to avoid crashes\\n self.check_cell_change = False\\n\\n # Set the flag to no changes in current file state\\n self.file_changed = False\\n self.set_save_enabled(False)\\n\\n csv_file_path = QFileDialog.getOpenFileName(self, \\\"Load CSV File\\\", \\\"\\\", 'CSV(*.csv)')\\n\\n # Proceed if and only if a valid file is selected and the file dialog is not cancelled\\n if csv_file_path[0]:\\n # Get only the file name from path. eg. 'data_file.csv'\\n filepath = os.path.normpath(csv_file_path[0])\\n filename = filepath.split(os.sep)\\n self.csv_file_name = filename[-1]\\n\\n self.loading_progress = QProgressDialog(\\\"Reading Rows. Please wait...\\\", None, 0, 100, self)\\n self.loading_progress.setWindowTitle(\\\"Loading CSV File...\\\")\\n self.loading_progress.setCancelButton(None)\\n\\n # enable custom window hint\\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() | QtCore.Qt.CustomizeWindowHint)\\n # disable (but not hide) close button\\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() & ~QtCore.Qt.WindowCloseButtonHint)\\n\\n # Show waiting cursor till the time file is being processed\\n QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\\n\\n self.loading_worker = CsvLoaderWorker(csv_file_path=csv_file_path, csv_data_table=self.csv_data_table,\\n column_headers=self.column_headers,\\n column_headers_all=self.column_headers_all)\\n\\n self.loading_thread = QThread()\\n # Set higher priority to the GUI Thread so UI remains a bit smoother\\n QThread.currentThread().setPriority(QThread.HighPriority)\\n\\n self.loading_worker.moveToThread(self.loading_thread)\\n self.loading_worker.workRequested.connect(self.loading_thread.start)\\n self.loading_thread.started.connect(self.loading_worker.process_loading_file)\\n self.loading_worker.finished.connect(self.on_loading_finish)\\n\\n self.loading_worker.relay.connect(self.update_loading_progress)\\n self.loading_worker.progress_max.connect(self.set_maximum_progress_value)\\n self.loading_worker.update_bottom_toolbar.connect(self.set_bottom_toolbar_info)\\n\\n self.loading_progress.setValue(0)\\n self.loading_worker.request_work()\\n\\n self.check_cell_change = True\\n\\n # Close the start page tab and load the file tab\\n self.tabWidget.removeTab(0)\\n self.tabWidget.insertTab(1, self.csv_table_tab, \\\"Main Document\\\")\\n\\n # Enable Column Layout menu option\\n self.action_column_layout.setEnabled(True)\\n self.action_add_data.setEnabled(True)\\n self.action_add_column.setEnabled(True)\\n self.action_toolbar_add_data.setEnabled(True)\\n self.action_close_file.setEnabled(True)\",\n \"def CSV_Load_File( self, infilename ):\\n print( 'Loading \\\"{}\\\"'.format(infilename) )\\n IN = open( infilename, 'r' )\\n standname = None\\n laststand = None\\n for L in IN:\\n if( L[0:9] == 'Site/Plot' ): continue\\n col = L.split( ',' )\\n standname = col[0]\\n year = int(col[1])\\n #if( re.search( '-', standname ) != None ):\\n # loc = re.search( '-', standname )\\n # year = int(standname[loc.start()+1:])\\n # standname = standname[0:loc.start()]\\n #print standname, year\\n if( (standname != None ) & (standname != laststand) ): self.Data.Stand[standname] = StandData( standname )\\n (treeno, species, dbh, ht, live, status, cclass, tpa) = \\\\\\n (int(col[2]), col[3], float(col[4]), float(col[5]), col[6], col[7], int(float(col[8])), float(col[9]))\\n if( OPT['d'] ):\\n if( dbh > 10.0 ): dbh *= 1.25\\n if( dbh > 15.0 ): dbh *= 1.50\\n for t in range( 1, int( math.ceil( tpa ))+1, 1 ):\\n ntree = len( self.Data.Stand[standname].Tree ) + 1\\n self.Data.Stand[standname].Tree[ntree] = TreeData( species, TreeNumber=treeno )\\n self.Data.Stand[standname].Tree[ntree].Year[year] = MeasurementData( dbh, ht, '', 1, live, status, cclass )\\n laststand = standname\\n IN.close()\",\n \"def csv_loader(csv_file):\\n df = pd.read_csv(csv_file, sep=';', parse_dates=['Data_Alteraçao'])\\n pd.set_option('display.float_format', '{:.0f}'.format)\\n\\n df = df.fillna(0)\\n df = df.drop(columns=['Cod. Pareamento', 'Cod. UF', 'Sigla UF', 'Cod. Subarea',\\n 'Nome Subarea', 'Cod. Municipio', 'Nome Municipio', 'Codigo Agencia',\\n 'Nome Agencia', 'Cod. Setor', 'Cod. Logradouro CNEFE',\\n 'Tipo Logradouro CNEFE', 'Titulo Logradouro CNEFE',\\n 'Nome Logradouro CNEFE', 'Nome Tratado CNEFE', 'Tipo Logradouro DNE',\\n 'Titulo Logradouro DNE', 'Nome Logradouro DNE', 'Nome Tratado DNE',\\n 'Logradouro Completo DNE', 'Distancia', 'Cod. Match', 'Motivo Match',\\n 'CEPs Face', 'Localidade Face',\\n 'Alterar Logradouro para DNE?', 'Observaçao', 'SIAPE Alteração',\\n 'Nome Alteraçao', 'Data_Alteraçao', 'Status', 'Unnamed: 33'])\\n\\n # df.astype({'CEP Logradouro CNEFE': 'int32'}).dtypes\\n\\n df['CEP'] = df['CEP'].str.replace(' ', '', regex=False)\\n\\n ceps_dne = []\\n for index, row in df.iterrows():\\n if type(row.CEP) == str:\\n for cep in row.CEP.split(','):\\n # print(index, cep)\\n ceps_dne.append(int(cep))\\n\\n ceps_cnefe = df['CEP Logradouro CNEFE'].astype(int).tolist()\\n ceps = ceps_dne + ceps_cnefe\\n ceps = list(set(ceps))\\n return pd.Series(ceps)\",\n \"def setup_csv(self) -> None:\\n csvData = ['Followers', 'Time']\\n\\n # Create our CSV file header\\n with open(self.graphfile, 'w') as csvFile:\\n writer = csv.writer(csvFile)\\n writer.writerow(csvData)\\n csvFile.close()\",\n \"def csv_handle(self,instance):\\n table_origin = self.csv_dataframe\\n in_column_num = len(self.column_names) \\n in_column_name = self.column_names\\n in_column_type = self.column_types\\n\\n instance.column_num = instance.tables[0].column_num = in_column_num\\n for i in range(instance.column_num):\\n instance.tables[0].names.append(in_column_name[i])\\n instance.tables[0].types.append(Type.getType(in_column_type[i].lower())) #getType is a static method\\n instance.tables[0].origins = [i for i in range(instance.tables[0].column_num)]\\n \\n instance.tuple_num = instance.tables[0].tuple_num = table_origin.shape[0] # the number of rows\\n for i in range(instance.tables[0].column_num):\\n if instance.tables[0].types[i] == 3: #if there is date type column in csv,convert into datetime format\\n col_name = table_origin.columns[i]\\n col_type = self.column_types[i]\\n self.csv_handle_changedate(col_name,col_type)\\n \\n #change table column name with table_info column_names (for date type columns)\\n for i in range(len(table_origin.columns)):\\n table_origin.rename(columns={ table_origin.columns[i] : in_column_name[i] }, inplace=True) \\n instance.tables[0].D = table_origin.values.tolist() #dataframe to list type and feed to D(where to store all the table info )\\n return instance\",\n \"def _parse_csv(self):\\n try:\\n with open(self.__csv_file_path) as csv_file:\\n csv_reader = csv.reader(csv_file, delimiter=',')\\n for line in csv_reader:\\n player = Player(data=line)\\n if player.position not in self.__unique_position:\\n self.__unique_position.append(player.position)\\n self.__players.append(player)\\n\\n # timsort O(n log n)\\n self.__players.sort(key=lambda p: p.ppg, reverse=True)\\n except FileNotFoundError as e:\\n print(e)\",\n \"def loadCsv(self):\\n # Close any already opened file if any\\n self.close_file()\\n\\n # Disable cell change check to avoid crashes\\n self.check_cell_change = False\\n\\n # Set the flag to no changes in current file state\\n self.file_changed = False\\n self.setSaveEnabled(False)\\n\\n csv_file_path = QFileDialog.getOpenFileName(self, \\\"Load CSV File\\\", \\\"\\\", 'CSV(*.csv)')\\n\\n # Proceed if and only if a valid file is selected and the file dialog is not cancelled\\n if csv_file_path[0]:\\n # Get only the file name from path. eg. 'data_file.csv'\\n filepath = os.path.normpath(csv_file_path[0])\\n filename = filepath.split(os.sep)\\n self.csv_file_name = filename[-1]\\n\\n self.loading_progress = QProgressDialog(\\\"Reading Rows. Please wait...\\\", None, 0, 100, self)\\n self.loading_progress.setWindowTitle(\\\"Loading CSV File...\\\")\\n self.loading_progress.setCancelButton(None)\\n\\n # enable custom window hint\\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() | QtCore.Qt.CustomizeWindowHint)\\n # disable (but not hide) close button\\n self.loading_progress.setWindowFlags(self.loading_progress.windowFlags() & ~QtCore.Qt.WindowCloseButtonHint)\\n\\n # Show waiting cursor till the time file is being processed\\n QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)\\n\\n self.loading_worker = loader.CsvLoaderWorker(csv_file_path=csv_file_path, csv_data_table=self.csv_data_table,\\n column_headers=self.column_headers,\\n column_headers_all=self.column_headers_all)\\n\\n self.loading_thread = QThread()\\n # Set higher priority to the GUI Thread so UI remains a bit smoother\\n QThread.currentThread().setPriority(QThread.HighPriority)\\n\\n self.loading_worker.moveToThread(self.loading_thread)\\n self.loading_worker.workRequested.connect(self.loading_thread.start)\\n self.loading_thread.started.connect(self.loading_worker.processLoadingFile)\\n self.loading_worker.finished.connect(self.on_loading_finish)\\n\\n self.loading_worker.relay.connect(self.update_loading_progress)\\n self.loading_worker.progress_max.connect(self.set_maximum_progress_value)\\n self.loading_worker.update_bottom_toolbar.connect(self.setBottomToolbarInfo)\\n\\n self.loading_progress.setValue(0)\\n self.loading_worker.requestWork()\\n\\n self.check_cell_change = True\\n\\n # Close the start page tab and load the file tab\\n self.tabWidget.removeTab(0)\\n self.tabWidget.insertTab(1, self.tableTab, \\\"Main Document\\\")\\n\\n # Enable Column Layout menu option\\n self.action_column_layout.setEnabled(True)\\n self.action_add_data.setEnabled(True)\\n self.action_add_column.setEnabled(True)\\n self.action_toolbar_add_data.setEnabled(True)\\n self.action_close_file.setEnabled(True)\",\n \"def loadCSVFile (file, sep=\\\";\\\"):\\n lst = lt.newList(\\\"ARRAY_LIST\\\") #Usando implementacion arraylist\\n #lst = lt.newList() #Usando implementacion linkedlist\\n print(\\\"Cargando archivo ....\\\")\\n t1_start = process_time() #tiempo inicial\\n dialect = csv.excel()\\n dialect.delimiter=sep\\n try:\\n with open(file, encoding=\\\"utf-8\\\") as csvfile:\\n spamreader = csv.DictReader(csvfile, dialect=dialect)\\n for row in spamreader: \\n lt.addLast(lst,row)\\n except:\\n print(\\\"Hubo un error con la carga del archivo\\\")\\n t1_stop = process_time() #tiempo final\\n print(\\\"Tiempo de ejecución \\\",t1_stop-t1_start,\\\" segundos\\\")\\n return lst\",\n \"def csvfileUsage(self):\\n with open(self.csv_path, \\\"rb+\\\") as file_obj:\\n reader = csv.DictReader(file_obj, delimiter=',') # CSV DictReader object\\n \\\"\\\"\\\" reader.fieldnames returns header , slicing intial 'Month' and\\n 'Year' header from list\\n \\\"\\\"\\\"\\n for com_names in reader.fieldnames[2:]:\\n self.company_data[com_names] = {}\\n # iterating each row\\n for row in reader:\\n month, year = self.parse_my(row) # parsing the year and month from row\\n # pop the `Month` and `Year` Key to minimize iteration below\\n row.pop('Month'), row.pop('Year')\\n \\\"\\\"\\\" saving and updating the data at same point of time\\n each iteration time, checking the max value and updating \\n `Month` `Year` and `Value`\\n \\\"\\\"\\\"\\n self.prepare_company_data(month, year, row, self.company_data)\\n file_obj.close() # close file\\n return self.company_data\",\n \"def _loadCSVFile(self):\\n self._df = pd.read_csv(\\n self._pathfile, sep=CSV_SEPARATOR, index_col=CSV_INDEX_COL)\",\n \"def from_csv(self, filename):\\n\\t\\tpoints = np.genfromtxt(filename, delimiter=\\\",\\\")\\n\\t\\tassert points.shape[1] == 2\\n\\n\\t\\tself.N = points.shape[0]\\n\\t\\tself.points = points\\n\\t\\tself.original_points = points\",\n \"def onLoadCSVList(self, evt):\\n dlg = wx.FileDialog(self.view, \\\"Choose a file:\\\", wildcard = \\\"*.txt; *.csv\\\" ,\\n style=wx.FD_DEFAULT_STYLE | wx.FD_CHANGE_DIR)\\n if dlg.ShowModal() == wx.ID_OK:\\n print \\\"You chose %s\\\" % dlg.GetPath()\\n self.config.CSVFilePath = dlg.GetPath()\",\n \"def cell_map_from_csv(self, source_file: str) -> None:\\n if source_file[-4:] == '.csv':\\n try:\\n self._import_source_data(source_file)\\n except Exception:\\n print(\\\"Problem with that CSV file. File extension?\\\")\",\n \"def read_csv(self, inputfile):\\n d = csv.reader(inputfile)\\n for row in d.read():\\n self.translations[row[0]] = row[1]\",\n \"def load_csv(filename):\\n # Open csvfile\\n with open(filename) as csvfile:\\n reader = csv.DictReader(csvfile)\\n\\n # Put data in gloabal list\\n for row in reader:\\n # Get data of subject with either or both milk and peanut allergy\\n if row[\\\"MILK_ALG_START\\\"] != \\\"NA\\\" or row[\\\"PEANUT_ALG_START\\\"] != \\\"NA\\\":\\n sub_list = list()\\n for key in DATA_KEYS:\\n sub_list.append(row[key])\\n\\n # Add data of subject to all data \\n data_list.append(sub_list)\",\n \"def load_csv(self):\\n self.database = pd.read_csv(\\n self.settings['database_path'],\\n encoding='utf-8')\",\n \"def csv_reader(self, file_obj):\\n reader = csv.reader(file_obj)\\n for row in reader:\\n row_1 = (' '.join(row))\\n self.data.append(row_1.split(';'))\\n return self.data\",\n \"def parse_csv_row(self, row):\\n\\n for key in self.field_map:\\n if self.field_map[key] is not None:\\n if key == 'marking':\\n self.obstacle_data[key] = self.get_marking_value(row[self.field_map[key]].strip())\\n elif key == 'lighting':\\n self.obstacle_data[key] = self.get_lighting_value(row[self.field_map[key]].strip())\\n elif key == 'obst_type':\\n self.obstacle_data['obst_type_id'] = self.get_obstacle_type_id(row[self.field_map[key]].strip())\\n else:\\n self.obstacle_data[key] = row[self.field_map[key]].strip()\",\n \"def init_cache_from_csv(self, path: str) -> None:\\n log.debug(f\\\"Initalising {self.name} from csv at {path}\\\")\\n df = io.csv_to_df(path=path)\\n df = df.set_index(self.ids).sort_index(axis=0).sort_index(axis=1)\\n io.df_to_parquet(df=df, path=self.path)\\n log.debug(f\\\"{self.name} now cached in local parquet.\\\")\",\n \"def from_csv(self, user, row):\\n if len(row) < 4:\\n raise BadRequest(_(\\\"Invalid line\\\"))\\n self.name = row[1].strip().lower()\\n for model in [DomainAlias, Domain]:\\n if model.objects.filter(name=self.name).exists():\\n raise Conflict\\n domname = row[2].strip()\\n try:\\n self.target = Domain.objects.get(name=domname)\\n except Domain.DoesNotExist:\\n raise BadRequest(_(\\\"Unknown domain %s\\\") % domname)\\n core_signals.can_create_object.send(\\n sender=\\\"import\\\", context=self.target, object_type=\\\"domain_aliases\\\")\\n self.enabled = row[3].strip().lower() in [\\\"true\\\", \\\"1\\\", \\\"yes\\\", \\\"y\\\"]\\n self.save(creator=user)\",\n \"def from_csv(self, user, row):\\n if len(row) != 6:\\n raise BadRequest(_(\\\"Invalid line\\\"))\\n self.name = row[1].strip()\\n self.target_host = row[2].strip()\\n self.service, created = Service.objects.get_or_create(\\n name=row[3].strip())\\n self.enabled = (row[4].strip() == 'True')\\n self.verify_recipients = (row[5].strip() == 'True')\\n self.save(creator=user)\",\n \"def loadCSVFile(self):\\n file_name = \\\"files/parts.csv\\\"\\n\\n with open(file_name, \\\"r\\\") as csv_f:\\n reader = csv.reader(csv_f)\\n header_labels = next(reader)\\n self.model.setHorizontalHeaderLabels(header_labels)\\n for i, row in enumerate(csv.reader(csv_f)):\\n items = [QStandardItem(item) for item in row]\\n self.model.insertRow(i, items)\",\n \"def process_csv():\\n csv_rows = []\\n fieldnames = ['site',\\n 'latitude',\\n 'longitude',\\n 'city',\\n 'region_code',\\n 'country_code',\\n 'continent_code',\\n 'min_ip_hex',\\n 'max_ip_hex',\\n 'transit_provider',\\n 'min_ip',\\n 'max_ip',\\n 'ip_prefix',\\n 'min_ipv6_hex',\\n 'max_ipv6_hex',\\n 'min_ipv6',\\n 'max_ipv6',\\n 'ipv6_prefix']\\n\\n location_map = build_location_map()\\n\\n # Read in the CSV file and augment the columns\\n with open(INPUT_FILE, 'rb') as csvfile:\\n reader = csv.DictReader(csvfile)\\n\\n for row in reader:\\n csv_rows.append(process_row(row, location_map))\\n\\n # Write the new CSV file with new columns\\n with open(OUTPUT_FILE, 'w') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n writer.writeheader()\\n for row in csv_rows:\\n writer.writerow(row)\\n\\n print(\\\"MLab Sites CSV generated at {0}\\\".format(OUTPUT_FILE))\",\n \"def init_csv_file(csv_path):\\n with open(csv_path, 'w', newline='') as csv_file:\\n writer = csv.writer(csv_file)\\n header = ['file_name', 'chart_in_file',\\n 'year', 'month', 'row_no', 'bird_species']\\n header += list(range(1, 32))\\n writer.writerow(header)\",\n \"def __init__(self, product_name, title, url, csv_file_name):\\n # this dictionary will be used to save data in csv file\\n self.__values = {'product_name': product_name, 'title': title, 'url': url}\\n # __csv_fields make save_data() method writes correctly in csv file.\\n self.__csv_fields = self.__values.keys()\\n self.__csv_file_name = csv_file_name\",\n \"def process(self, filename=None):\\n if not filename:\\n filename = self.input_csv\\n\\n if filename.endswith('.csv'):\\n\\n with open(filename) as _file:\\n reader = csv.reader(_file)\\n data = list(reader)\\n\\n self.save(self.format(self.purify(data)))\\n return\\n\\n raise TypeError(\\n \\\"Excepting csv filetype got %s \\\\\\n filetype instead.\\\" % (filename.split('.', 1)[1])\\n )\",\n \"def read_csv(self, filepath, obs_vars = ['obs'], header = True):\\n # determine if the type file is gzip\\n filetype, encoding = mimetypes.guess_type(filepath)\\n if encoding == 'gzip':\\n self.data = pd.read_csv(filepath, compression='gzip')\\n else:\\n self.data = pd.read_csv(filepath)\\n\\n self.original_data = copy.deepcopy(self.data)\\n if self.cutoff:\\n self.data = self.data[:self.cutoff]\\n \\n self.data = self.data[obs_vars]\\n self.N = self.data.shape[0]\\n return True\",\n \"def fromCSV(self, filename):\\n with open(filename, newline = '') as csvfile:\\n read = csv.reader(csvfile, delimiter = ',')\\n param = []\\n for row in read:\\n param.append(row)\\n self.c = complex(param[0][0])\\n self.xmin = int(param[1][0])\\n self.xmax = int(param[2][0])\\n self.xlen = int(param[3][0])\\n self.ymin = int(param[4][0])\\n self.ymax = int(param[5][0])\\n self.ylen = int(param[6][0])\\n self.fs = np.vectorize(param[7][0])\\n self.plane = np.loadtxt(\\\"plane.csv\\\", delimiter = ',', dtype = 'int') #Read plane from plane.csv file \",\n \"def __init__(self, csvfile, fieldnames, *args, **kwargs):\\n self.encoding = kwargs.pop('encoding', 'utf-8')\\n csv.DictWriter.__init__(self, csvfile, fieldnames, *args, **kwargs)\",\n \"def parse_csvfile(self, filepath=None):\\n designfilename = self.Filename\\n if filepath is None:\\n filepath = self.Filepath\\n else:\\n self.Filepath = filepath\\n self.Filename = os.path.dirname(filepath)\\n if not filepath:\\n print(\\\"No filepath provided, aborting..:!\\\")\\n return False\\n dataset, filefields = self._read_csvfile_from_file(self.Filepath)\\n self.FileFields = filefields\\n self.Dataset = dataset\\n\\n if self.Verboselevel > 6:\\n print(\\\"Dataset from file: \\\" + designfilename)\\n print(self.Dataset)\\n # Find the key specifying the module... (first 'module', then if no 'module' field, search for 'color').\\n self.make_fieldsmap()\\n\\n # Arrange the data for easier access:\\n # Produce whole design set:\\n self.Designset = set([row[self.Fields['sequence']] for row in self.Dataset])\\n # Prepare a dict with an empty set for every moduleclass:\\n self.Modulesets = dict([(row[self.Fields['moduleclass']], set()) for row in self.Dataset])\\n self.OligoModules = dict()\\n self.OligoInfo = dict() # Map sequence back to info from file/row.\\n for row in self.Dataset:\\n self.Modulesets[row[self.Fields['moduleclass']]].add(row[self.Fields['sequence']])\\n # It should also be easy to find the module of a particular sequence without looping further:\\n if row[self.Fields['sequence']] in self.OligoModules:\\n print(\\\"WARNING: sequence \\\" + row[self.Fields['sequence']] + \\\" is present multiple times.\\\")\\n if self.OligoModules[row[self.Fields['sequence']]] != row[self.Fields['moduleclass']]:\\n print(\\\"--> AND THE SEQUENCE IS PRESENT IN TWO DIFFERENT MODULES, \\\" + self.OligoModules[row[self.Fields['sequence']]] + \\\" and \\\" + row[self.Fields['moduleclass']])\\n self.OligoModules[row[self.Fields['sequence']]] = row[self.Fields['moduleclass']]\\n self.OligoInfo[row[self.Fields['sequence']]] = row\\n if self.Verboselevel > 5:\\n print(\\\"Design and module-sets for designfile: \\\" + designfilename)\\n print(self.Designset)\\n print(self.Modulesets)\\n\\n return self\",\n \"def import_csv_dataset():\\n import_fields = pd.read_csv('redacted-2020-june-30-wprdc-.csv', header=None).to_numpy()[0, :]\\n import_values = pd.read_csv('redacted-2020-june-30-wprdc-.csv').to_numpy()\\n import_values = clean_values(import_values)\\n return import_fields, import_values\",\n \"def __close_csv(self):\\n if self.__csv_file is not None:\\n try:\\n self.__csv_file.close()\\n except IOError:\\n pass\\n self.__csv_file = None\",\n \"def from_csv(cls, load_folder: Path) -> \\\"Parameters\\\":\\n serializer = serializer_factory(fmt=SerializerEnum.CSV)\\n return serializer.load(class_obj=cls, folder_path=load_folder)\",\n \"def process_loading_file(self):\\n column_headers = []\\n column_headers_all = []\\n\\n # Open the file once to get idea of the total rowcount to display progress\\n with open(self.csv_file_path[0], newline='') as csv_file:\\n self.progress_max.emit(len(csv_file.readlines()) - 2)\\n\\n with open(self.csv_file_path[0], newline='') as csv_file:\\n\\n self.csv_data_table.setRowCount(0)\\n self.csv_data_table.setColumnCount(0)\\n\\n csv_file_read = csv.reader(csv_file, delimiter=',', quotechar='|')\\n\\n # Fetch the column headers and move the iterator to actual data\\n column_headers = next(csv_file_read)\\n\\n # Reflect back the changes in the reference to the column headers\\n for header in column_headers:\\n self.column_headers.append(header)\\n # A backup to keep a list of all the headers to toogle their view later\\n self.column_headers_all.append(header)\\n\\n # TODO: Increase the reading speed by decreasing load on actual table population\\n\\n # self.csv_data_table.hide()\\n\\n for row_data in csv_file_read:\\n\\n self.relay.emit(self.csv_data_table.rowCount())\\n # self.relay.emit(self.x)\\n # self.x = self.x + 1\\n row = self.csv_data_table.rowCount()\\n self.csv_data_table.insertRow(row)\\n self.csv_data_table.setColumnCount(len(row_data))\\n for column, stuff in enumerate(row_data):\\n item = QTableWidgetItem(stuff)\\n self.csv_data_table.setItem(row, column, item)\\n\\n self.csv_data_table.setHorizontalHeaderLabels(self.column_headers)\\n\\n # Set WordWrap to True to make the cells change height according to content\\n # Currently set it to false as it looks very decent and makes cell size uniform throughout\\n self.csv_data_table.setWordWrap(False)\\n # Uncomment below line to stretch to fill the column width according to content\\n # self.csv_data_table.resizeColumnsToContents()\\n self.csv_data_table.resizeRowsToContents()\\n\\n # Update the bottom toolbar to reflect changes\\n self.update_bottom_toolbar.emit()\\n self.finished.emit()\",\n \"def test_valid_csv(self):\\n url=\\\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data\\\"\\n readerobject=requester.url_to_csv(url, fname='wine2')\\n self.assertTrue(str(type(readerobject)),\\\"_csv.reader\\\")\",\n \"def __init__(self, csv_path):\\r\\n # Transforms\\r\\n self.to_tensor = transforms.ToTensor()\\r\\n # Read the csv file\\r\\n self.data_info = pd.read_csv(csv_path, header=None)\\r\\n # First column contains the image paths\\r\\n self.image_arr = np.asarray(self.data_info.iloc[:, 0])\\r\\n # Second column is the labels\\r\\n self.label_arr = [np.asarray(self.data_info.iloc[:, 1])]\\r\\n # Third column is for an operation indicator\\r\\n #self.operation_arr = np.asarray(self.data_info.iloc[:, 2])\\r\\n # Calculate len\\r\\n self.data_len = len(self.data_info.index)\",\n \"def _setprior_csv(self, csv_file):\\n\\n #-- number of time-points\\n npts = self.get_npts()\\n\\n #-- read state from CSV file\\n fmt = self._guess_time_format(csv_file)\\n state_inst = sv.get_state_csv(fname=csv_file, fmt=fmt)\\n\\n #-- LAI,Canopy-Height,Soil-Moisture\\n self.prstate = np.empty((3,npts), dtype=np.float64)\\n\\n for i,date_utc in enumerate(self.schedule_dct['date_utc']):\\n idx, timedelt = sv.find_nearest_date_idx(state_inst.date_utc, date_utc)\\n if timedelt.days>=1:\\n msg = \\\"for scheduled date ---{}--- \\\".format(date_utc.strftime('%Y-%m-%dT%H%M'))\\n msg += \\\"time nearest state differs by at least one day!\\\"\\n FileLogger.warn(msg)\\n #-- LAI\\n self.prstate[0,i] = state_inst.lai[idx]\\n #-- canopy-height\\n self.prstate[1,i] = state_inst.can_height[idx]\\n #-- SM\\n self.prstate[2,i] = state_inst.soil_moisture[idx]\",\n \"def readCSV(filename):\\r\\n data = list( csv.reader(open('HW_08_DBScan_Data_NOISY_v300.csv','r'),delimiter=','))\\r\\n for dIdx in range(len(data)):\\r\\n data[dIdx] = [float(data[dIdx][0]),float(data[dIdx][1]),float(data[dIdx][2])]\\r\\n #print(data[0])\\r\\n return data\",\n \"def convert_csv_to_SQLite3(self,\\n csv_path: str=None, # Path to .csv \\n destination: str=None, # Where to create .db\\n db_name: str=None, # Database name\\n table_name: str=None, # table name\\n **kwargs # Custom arguments for reader and writter\\n ):\\n # With scribe reader, read a .csv \\n # **kwargs, are used in params in the subclass Scibe_File_Writter\\n # **Kwargs Over-write convert_csv_to_db params\\n # Inherits from scribe_readers.Scribe_File_Reader\\n self.read_from_csv(csv_path, **kwargs) # Inherits from scribe_readers.Scribe_File_Reader\\n if db_name != None:\\n destination = f\\\"{destination}\\\\{db_name}.db\\\"\\n self.db_name = db_name\\n conn = self.create_sqlite_connection(destination) # Inherits from scribe_writers_Scribe_Scribe_SQLite_Writer\\n # Create connection also creates new db if it does not exist.\\n self.create_new_sqlite_table(conn=conn,\\n schema=self.dtypes,\\n table_name=f\\\"tbl_{table_name}\\\",\\n close_conn =False)\\n \\n \\\"\\\"\\\"Insert data into SQLite database\\\"\\\"\\\"\\n\\n table_name=f\\\"tbl_{table_name}\\\"\\n self.insert_into_sqlite_table(conn,\\n csv_path,\\n table_name,\\n self.shape,\\n self.delimiter)\",\n \"def load_csv(self):\\n options = QFileDialog.Options()\\n options |= QFileDialog.DontUseNativeDialog\\n files, _ = QFileDialog.getOpenFileNames(\\n self,\\n \\\"Select one or more files\\\",\\n \\\"\\\",\\n \\\"csv files (*.csv);;All Files (*)\\\",\\n options=options,\\n )\\n self.show()\\n\\n if files:\\n self.files_now = files\\n else:\\n self.files_now = None\\n\\n if self.files_now:\\n self.lineEdit_file_name.setText(self.files_now[0])\\n self.update_gui_from_csv()\",\n \"def printGrilleCSV(self):\\n print(\\\"Length grillecsv : \\\"+str(len(self._get_grille_csv())))\\n for row in self._get_grille_csv():\\n print(\\\"(\\\", end=\\\"\\\")\\n for cell in row:\\n if cell == \\\"\\\":\\n print(\\\" ,\\\", end=\\\"\\\")\\n else:\\n print(cell+\\\",\\\", end=\\\"\\\")\\n print(\\\")\\\")\",\n \"def read_csv(self, filepath, header=True):\\n BaseSampler.read_csv(self, filepath, header)\\n # convert the data to floats\\n self.new_obs = []\\n self.img_w, self.img_h = None, None\\n for row in self.obs:\\n if self.img_w is None:\\n self.img_w = int(row[0])\\n if self.img_w == 0 or (len(row)-1) % self.img_w != 0:\\n raise Exception('The sampler does not understand the format of the data. Did you forget to specify image width in the data file?')\\n self.new_obs.append([int(_) for _ in row])\\n\\n self.obs = np.array(self.new_obs)[:,1:]\\n if self.cl_mode:\\n self.d_obs = cl.Buffer(self.ctx, self.mf.READ_ONLY | self.mf.COPY_HOST_PTR, hostbuf=self.obs.astype(np.int32))\\n\\n self.d = self.obs.shape[1]\\n self.img_h = int(self.d / self.img_w)\\n self.alpha = float(self.N) * 5\\n return\",\n \"def __init__(self, csv_path, column_types=None, set_columns=False, file_headers=True, encoding=\\\"utf-8-sig\\\",\\n missing_to_zero=False, print_warnings=True):\\n\\n self.file_path = Path(csv_path)\\n self.file_name = self.file_path.stem\\n\\n self._file_headings = file_headers\\n self._encoding = encoding\\n\\n self.headers = self._extract_headers()\\n self.row_length = len(self.headers)\\n\\n self.missing_to_zero = missing_to_zero\\n self.print_warnings = print_warnings\\n self.invalid_typed = []\\n\\n self.column_types = self._determine_column_types(column_types)\\n self.row_data, self.column_data, self.column_length = self._set_data(set_columns)\\n\\n # Old definitions kept for legacy, but new names added for clarity\\n self.num_cols = self.row_length\\n self.num_rows = self.column_length\\n\\n if len(self.invalid_typed) > 0 and self.print_warnings:\\n print(f\\\"Warning: The following column-row-value-type where not correct so loaded as strings:\\\\n\\\"\\n f\\\"{sorted(self.invalid_typed)}\\\")\",\n \"def _importInDjango(self):\\n\\n with open(settings.DATA_PATH, 'r', encoding='latin-1') as csv_file:\\n reader = csv.DictReader(csv_file, delimiter=';')\\n for raw in reader:\\n\\n # Créer ou mettre à jour la division\\n division, created = Division.objects.get_or_create(\\n nom=raw['Division']\\n )\\n if created:\\n self.stdout.write(\\n 'Divion {} ajoutée'.format(division.nom)\\n )\\n\\n # Créer ou mettre à jour les équipes\\n equipeDom, created = Equipe.objects.get_or_create(\\n nom=raw['Equipe 1'],\\n division=division\\n )\\n if created:\\n self.stdout.write(\\n 'Equipe {} ajoutée'.format(equipeDom.nom)\\n )\\n\\n equipeExt, created = Equipe.objects.get_or_create(\\n nom=raw['Equipe 2'],\\n division=division\\n )\\n if created:\\n self.stdout.write(\\n 'Equipe {} ajoutée'.format(equipeExt.nom)\\n )\\n\\n # Créer ou mettre à jour la rencontre\\n scoreDom = 0 if raw['Score 1'] == '' else int(raw['Score 1'])\\n scoreExt = 0 if raw['Score 2'] == '' else int(raw['Score 2'])\\n forfaitDom = True if raw['Forfait 1'] == 'true' else False\\n forfaitExt = True if raw['Forfait 2'] == 'true' else False\\n date = datetime.datetime.strptime(raw['Date de rencontre'], '%d/%m/%Y')\\n heure = datetime.datetime.strptime(raw['Heure'], '%H:%M')\\n rencontre, created = Rencontre.objects.update_or_create(\\n numero=int(raw['N° de match']),\\n equipeDom=equipeDom,\\n equipeExt=equipeExt,\\n defaults={\\n 'date': date,\\n 'heure': heure,\\n 'scoreDom': scoreDom,\\n 'scoreExt': scoreExt,\\n 'forfaitDom': forfaitDom,\\n 'forfaitExt': forfaitExt,\\n }\\n )\\n if created:\\n self.stdout.write(\\n 'Rencontre {} / {} ajoutée'.format(\\n rencontre.equipeDom,\\n rencontre.equipeExt\\n )\\n )\",\n \"def format_porteurs(filepath):\\n fieldnames, rows = get_header_rows(filepath)\\n\\n if \\\"statut\\\" in fieldnames:\\n fieldnames.append(\\\"situation_societariat_entrance\\\")\\n fieldnames.append(\\\"situation_situation\\\")\\n for row in rows:\\n statut = row['statut']\\n row['situation_societariat_entrance'] = \\\"\\\"\\n if statut == \\\"Associé\\\":\\n row['situation_societariat_entrance'] = \\\"01/01/2015\\\"\\n row['situation_situation'] = PORTEUR_STATUS_MATCH.get(statut)\\n\\n\\n if 'coordonnees_address1' in fieldnames and 'coordonnees_address2' in fieldnames:\\n fieldnames.append('coordonnees_address')\\n for row in rows:\\n row['coordonnees_address'] = row['coordonnees_address1'] + \\\\\\n '\\\\n' + row['coordonnees_address2']\\n\\n if \\\"coordonnees_civilite\\\" in fieldnames:\\n fieldnames.append('coordonnees_sex')\\n for row in rows:\\n if row['coordonnees_civilite'].lower() == u\\\"mademoiselle\\\":\\n row['coordonnees_civilite'] = u\\\"Madame\\\"\\n\\n if row['coordonnees_civilite'] == u'Madame':\\n row['coordonnees_sex'] = 'F'\\n else:\\n row['coordonnees_sex'] = 'M'\\n\\n if \\\"zus\\\" in fieldnames:\\n fieldnames.append(\\\"coordonnees_zone_qual\\\")\\n for row in rows:\\n if row['zus'] == '1':\\n row['coordonnees_zone_qual'] = 'zus'\\n\\n write_csv_file(filepath, fieldnames, rows)\",\n \"def dump_csv(\\n self, csv_reader: protocols.Reader, columns: Sequence[str], dest_table: str\\n ) -> None:\\n self._copy_expert_csv(csv_reader, columns, dest_table)\",\n \"def data_from_csv(self, filepath):\\n self.dataframe = pd.load_csv(filepath, separator='')\",\n \"def init(fileName):\\r\\n global grand_prod_cost, grand_album_sales\\r\\n infile = ''\\r\\n try:\\r\\n with open(fileName, mode='r') as infile:\\r\\n reader = csv.reader(infile)\\r\\n sniffer = csv.Sniffer()\\r\\n has_header = sniffer.has_header(infile.read(2048))\\r\\n infile.seek(0)\\r\\n if (has_header):\\r\\n next(reader) # move curser to next row so the header is not included\\r\\n initBands(reader)\\r\\n # Reset the curser to start based on presence of header\\r\\n if(has_header):\\r\\n infile.seek(0)\\r\\n # avoid header\\r\\n next(reader)\\r\\n else:\\r\\n infile.seek(0)\\r\\n splitByBand(reader)\\r\\n except Exception as e:\\r\\n print('Exception in init')\\r\\n raise e\",\n \"def read(self):\\r\\n\\r\\n self.data = []\\r\\n\\r\\n with open(self.filename + \\\".csv\\\", mode='r') as csv_file:\\r\\n reader = csv.DictReader(csv_file)\\r\\n for row in reader:\\r\\n self.data.append(row)\",\n \"def __obtain_data_from_csv__(self, csvfile):\\n data = csvfile.readlines()\\n data = self.__parse_string_for_delimiter__(data)\\n return data\",\n \"def get_csv_string(self, **kwargs):\\n ...\",\n \"def upload_csv_data(self, upload_file):\\n db = DataBase(self.DATABASE_DATA)\\n db.insert_data_from_file(\\n 'triagedata.historicdata',\\n ('clinic_id', 'severity', 'date_received', 'date_seen'),\\n upload_file,\\n ','\\n )\",\n \"def saveCsv(self, filePath = None, rowDeliminator = None, columnDeliminator = None, sheetDeliminator = None, yieldForNone = \\\"\\\", skipLineCondition = None):\\n\\n\\t\\t\\tdef yieldValues(row):\\n\\t\\t\\t\\tfor cell in row:\\n\\t\\t\\t\\t\\tvalue = cell.value\\n\\t\\t\\t\\t\\tif (value is None):\\n\\t\\t\\t\\t\\t\\tyield yieldForNone\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tyield value\\n\\n\\t\\t\\tif (skipLineCondition is None):\\n\\t\\t\\t\\tdef yieldRows(mySheet):\\n\\t\\t\\t\\t\\tfor row in mySheet.thing.rows:\\n\\t\\t\\t\\t\\t\\tyield rowDeliminator.join(yieldValues(row))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdef yieldRows(mySheet):\\n\\t\\t\\t\\t\\tfor row in mySheet.thing.rows:\\n\\t\\t\\t\\t\\t\\tif (not skipLineCondition(row)):\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\tyield rowDeliminator.join(yieldValues(row))\\n\\n\\t\\t\\tdef yieldSheet():\\n\\t\\t\\t\\tnonlocal self\\n\\n\\t\\t\\t\\tfor mySheet in self:\\n\\t\\t\\t\\t\\tyield columnDeliminator.join(yieldRows(mySheet))\\n\\n\\t\\t\\t############################\\n\\n\\t\\t\\trowDeliminator = self.ensure_default(rowDeliminator, \\\",\\\")\\n\\t\\t\\tsheetDeliminator = self.ensure_default(sheetDeliminator, \\\"\\\\n\\\")\\n\\t\\t\\tcolumnDeliminator = self.ensure_default(columnDeliminator, \\\"\\\\n\\\")\\n\\n\\t\\t\\t_filePath = self.ensure_filePath(self.ensure_default(filePath, default = self.filePath), ending = (\\\".csv\\\"), checkExists = False)\\n\\t\\t\\twith open(_filePath, \\\"w+\\\") as fileHandle:\\n\\t\\t\\t\\tfileHandle.write(sheetDeliminator.join(yieldSheet()))\",\n \"def buildFromCSV(self, filepath):\\r\\n\\t\\t# TODO: Implement\\r\\n\\t\\traise NotImplementedError('This function has not yet been implemented.')\\r\\n\\t\\t# with open(filepath, 'r') as scheduleFile:\\r\\n\\t\\t# \\t# Reusing Parser.parseCSVs(), but not in the intended way; ok because validation is not yet implemented\\r\\n\\t\\t# \\t# TODO: Split Parser.parseCSVs() into separate people/set file parsers \\r\\n\\t\\t# \\tn, people, setConstraints = Parser.parseCSVs(-1, scheduleFile, [])\\r\",\n \"def read_csv(self, csv_file):\\n mylog.debug('Reading csv file %s for data' % csv_file)\\n csv_data = pandas.read_csv(csv_file)\\n mylog.debug('Read of csv file complete.')\\n #mylog.debug('%s' % csv_data)\\n #sometimes the csv has an empty dataframe #\\n if csv_data.empty:\\n mylog.debug('Data frame is empty; repopuating data')\\n csv_info = []\\n for item in csv_data:\\n #add the data one cell at a time to the list #\\n #for some reason, some csvs have the data #\\n #with random decimal points #\\n csv_info.append(item.split(\\\".\\\")[0])\\n df = pandas.DataFrame(columns=csv_info)\\n df.loc[0]=csv_info\\n #write the data from the list back into the cells#\\n #one at a time #\\n for column in range(0, len(csv_info)): \\n df.iloc[0,column] = csv_info[column]\\n csv_data = df \\n return csv_data\",\n \"def __init__(self, path=None):\\n super().__init__(path=path)\\n self.path += '{}.csv'\",\n \"def map_csv_fields(self):\\n etod_csv_fields = {\\n 'ctry_id': None,\\n 'obst_identifier': None,\\n 'obst_name': None,\\n 'lon_src': None,\\n 'lat_src': None,\\n 'agl': None,\\n 'amsl': None,\\n 'vert_uom': None,\\n 'hor_acc': None,\\n 'hor_acc_uom': None,\\n 'vert_acc': None,\\n 'vert_acc_uom': None,\\n 'obst_type': None,\\n 'lighting': None,\\n 'marking': None,\\n 'is_group': None,\\n }\\n\\n for field in etod_csv_fields:\\n try:\\n etod_csv_fields[field] = etod_map[self.ctry_short_name]['fields'][field]\\n except KeyError:\\n etod_csv_fields[field] = None\\n\\n self.field_map = etod_csv_fields\",\n \"def ingest_rental_csv(csv_path):\\n # Create a CSV import generator (next yields one db row)\\n import_generator = import_csv_gen(csv_path)\\n # Skip over the title row\\n next(import_generator)\\n # Iterate over all other rows\\n while True:\\n try:\\n data = next(import_generator)\\n if len(data) != 2:\\n logger.error(f'Data with incorrect item count: {len(data)}')\\n continue\\n # extract items from list and add document to database\\n with Connection():\\n rental = Rental(\\n product_id=data[RENTAL_PROD_ID],\\n user_id=data[RENTAL_USER_ID]\\n )\\n rental.save() # This will perform an insert\\n except StopIteration:\\n break\",\n \"def importer():\\n\\n #Lager liste der eg legg transaksjonar som blir henta og ikkje laga:\\n get_list = []\\n\\n #Gjer txt-fila i mappen om til csv-fil\\n file_fixer()\\n\\n with open(out_path) as file:\\n reader = csv.reader(file)\\n r_0 = next(reader)\\n r_0.append(\\\"type\\\")\\n r_0.append('amount')\\n r_0.append('category')\\n r_0.append('account')\\n r_0.append('project')\\n\\n\\n for row in reader:\\n #Legger til dei fire kollonenne (amount, account, subaacount, project), tomme.\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n\\n #Omformatterer rader:\\n row = format_fix(row)\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n print(row)\\n\\n\\n try:\\n obj, created = Transaction.objects.get_or_create(\\n date=row[0],\\n transaction_type=row[1],\\n description=row[2],\\n amount=row[3]\\n )\\n\\n except Transaction.MultipleObjectsReturned:\\n continue\\n\\n if not created:\\n get_list.append(obj.pk)\\n\\n return get_list\",\n \"def lectcsv(NOM):\\n #NOM=input(\\\"nom du fichier:\\\")#interactif\\n #NOM=str(NOM +\\\".csv\\\")\\n c=[NOM]\\n #ouverture du fichier et recuperation du contenu\\n with open(NOM) as f:\\n contenu = csv.reader(f, delimiter=' ', quotechar='|')\\n for row in contenu:\\n c.append(row[0].split(';'))#separation du string \\n return c\",\n \"def exportCSV(self, log, csvFile):\\n return 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6927725","0.69130695","0.6871285","0.6801644","0.6744654","0.6588532","0.6566736","0.64618015","0.6455032","0.6349118","0.63289684","0.63281035","0.6291599","0.628651","0.6254619","0.6231155","0.62277955","0.62180835","0.62180835","0.62067026","0.62067026","0.6182448","0.6171352","0.61592054","0.6098138","0.6093712","0.60914737","0.60900235","0.60770154","0.6061076","0.6030615","0.6014796","0.6012488","0.60113907","0.5987747","0.5976123","0.5930773","0.5928326","0.59217876","0.5920636","0.59101707","0.59062916","0.5897259","0.5896229","0.5878396","0.58750457","0.58620906","0.5849565","0.5846507","0.5839125","0.583709","0.5830951","0.58272624","0.5817119","0.58138704","0.57921267","0.57752985","0.57473993","0.57448936","0.5741624","0.5736096","0.57309943","0.57284003","0.5723599","0.5723023","0.57160133","0.56954235","0.56823057","0.5680297","0.56741464","0.56683564","0.56664467","0.5663892","0.56557626","0.56550825","0.56527954","0.5642397","0.5641672","0.5637677","0.5632636","0.56306064","0.56290597","0.5628138","0.5625326","0.56251985","0.5614477","0.5612472","0.56080323","0.5606395","0.5605084","0.56013364","0.55994534","0.55803365","0.5576685","0.5565153","0.55623907","0.55486345","0.55424595","0.552805","0.5526462"],"string":"[\n \"0.6927725\",\n \"0.69130695\",\n \"0.6871285\",\n \"0.6801644\",\n \"0.6744654\",\n \"0.6588532\",\n \"0.6566736\",\n \"0.64618015\",\n \"0.6455032\",\n \"0.6349118\",\n \"0.63289684\",\n \"0.63281035\",\n \"0.6291599\",\n \"0.628651\",\n \"0.6254619\",\n \"0.6231155\",\n \"0.62277955\",\n \"0.62180835\",\n \"0.62180835\",\n \"0.62067026\",\n \"0.62067026\",\n \"0.6182448\",\n \"0.6171352\",\n \"0.61592054\",\n \"0.6098138\",\n \"0.6093712\",\n \"0.60914737\",\n \"0.60900235\",\n \"0.60770154\",\n \"0.6061076\",\n \"0.6030615\",\n \"0.6014796\",\n \"0.6012488\",\n \"0.60113907\",\n \"0.5987747\",\n \"0.5976123\",\n \"0.5930773\",\n \"0.5928326\",\n \"0.59217876\",\n \"0.5920636\",\n \"0.59101707\",\n \"0.59062916\",\n \"0.5897259\",\n \"0.5896229\",\n \"0.5878396\",\n \"0.58750457\",\n \"0.58620906\",\n \"0.5849565\",\n \"0.5846507\",\n \"0.5839125\",\n \"0.583709\",\n \"0.5830951\",\n \"0.58272624\",\n \"0.5817119\",\n \"0.58138704\",\n \"0.57921267\",\n \"0.57752985\",\n \"0.57473993\",\n \"0.57448936\",\n \"0.5741624\",\n \"0.5736096\",\n \"0.57309943\",\n \"0.57284003\",\n \"0.5723599\",\n \"0.5723023\",\n \"0.57160133\",\n \"0.56954235\",\n \"0.56823057\",\n \"0.5680297\",\n \"0.56741464\",\n \"0.56683564\",\n \"0.56664467\",\n \"0.5663892\",\n \"0.56557626\",\n \"0.56550825\",\n \"0.56527954\",\n \"0.5642397\",\n \"0.5641672\",\n \"0.5637677\",\n \"0.5632636\",\n \"0.56306064\",\n \"0.56290597\",\n \"0.5628138\",\n \"0.5625326\",\n \"0.56251985\",\n \"0.5614477\",\n \"0.5612472\",\n \"0.56080323\",\n \"0.5606395\",\n \"0.5605084\",\n \"0.56013364\",\n \"0.55994534\",\n \"0.55803365\",\n \"0.5576685\",\n \"0.5565153\",\n \"0.55623907\",\n \"0.55486345\",\n \"0.55424595\",\n \"0.552805\",\n \"0.5526462\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84458977"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":837,"numItemsPerPage":100,"numTotalItems":95772,"offset":83700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjA1NjYxMywianRpIjoiYjJlNDA1ODItMGE4MC00NzE1LTg4MjgtZGZjNjk0ZGI0N2I3Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwNjAyMTMsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.XOaiAKQeLlN8K56R6JSVSghyG8-VVjZfcHC_qR_Yv3VcFjxLES995ZTF82IDVGiW15vB9DNrLCJtMfExOut9Bg","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 |
|---|---|---|---|---|---|---|
Test getting a user with username and email which are archived. | def test_get_users_including_archived(user_store: MockStore, user_email: str, username: str):
# GIVEN a database with a user and an archived user
StoreHelpers.add_user(
name=username, email="old.user@magnolia.com", store=user_store, is_archived=True
)
# WHEN getting users
users: List[User] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_including_archived(user_store: MockStore, archived_user_email: str):\n # GIVEN a database with an archived user\n\n # WHEN querying for a user\n user: User = user_store.get_user(email=archived_user_email, exclude_archived=False)\n\n # THEN it should be returned\n assert user.email ... | [
"0.81211317",
"0.7514452",
"0.64037925",
"0.63772064",
"0.6226215",
"0.6220526",
"0.6183159",
"0.6143586",
"0.610818",
"0.6024082",
"0.60225403",
"0.60225403",
"0.60071534",
"0.59874976",
"0.59364957",
"0.5935404",
"0.58854514",
"0.5874671",
"0.5873215",
"0.5843584",
"0.58432... | 0.7878071 | 1 |
Test getting a user by email. | def test_get_users_no_username(user_store: MockStore, user_email: str):
# GIVEN a database with a user
# WHEN getting users
users: List[User] = user_store.get_users(email=user_email)
# THEN the user should be returned
assert users[0].email == user_email | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_user_by_emailuser_email_get(self):\n pass",
"def test_resource_user_resource_get_user_by_email_address_get(self):\n pass",
"def user(email):\r\n return User.objects.get(email=email)",
"def test_get_user(user_store: MockStore, user_email: str):\n # GIVEN a database with a user... | [
"0.88454765",
"0.83276856",
"0.7962884",
"0.7819175",
"0.76467335",
"0.760338",
"0.75088274",
"0.7479018",
"0.74315584",
"0.74199104",
"0.7391693",
"0.7375329",
"0.7330281",
"0.7316307",
"0.73029596",
"0.7296837",
"0.7296837",
"0.7296077",
"0.7266929",
"0.72588885",
"0.724362... | 0.7113207 | 28 |
add to the running total grade given a certain kind of assignment and weight | def assignment(kind, grade, weight=1):
global running_total
global total_weight
global total_grade
if kind not in running_total:
running_total[kind] = grade
total_grade[kind] = 0
total_weight[kind] = 0
if weight > 1:
grade *= weight
total_grade[kind] += grade
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_weighted_total(self):\r\n self.weighted_setup()\r\n self.submit_question_answer('H1P1', {'2_1': 'Correct', '2_2': 'Correct'})\r\n self.submit_question_answer('FinalQuestion', {'2_1': 'Correct', '2_2': 'Correct'})\r\n self.check_grade_percent(1.0)",
"def update_weight(self,ctr... | [
"0.67640436",
"0.6405597",
"0.6375525",
"0.6192439",
"0.61887383",
"0.6149335",
"0.61008453",
"0.60683244",
"0.6066493",
"0.60514957",
"0.6017797",
"0.59676933",
"0.5939823",
"0.58858883",
"0.5883962",
"0.58807987",
"0.5871791",
"0.5829333",
"0.5798484",
"0.57823825",
"0.5780... | 0.81458527 | 0 |
return the cumulative grade so far based on a set of proportions of assignment kind to overall weight. | def total(proportions):
final = {}
for i in proportions:
if i in running_total:
final[i] = proportions[i] * running_total[i]
print(final)
else:
final[i] = 0
print(final)
total_sum = sum(final.values())
return total_sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assignment(kind, grade, weight=1):\n global running_total\n global total_weight\n global total_grade\n\n if kind not in running_total:\n running_total[kind] = grade\n total_grade[kind] = 0\n total_weight[kind] = 0\n if weight > 1:\n grade *= weight\n total_grade[ki... | [
"0.65765446",
"0.62831384",
"0.595206",
"0.5708253",
"0.56488866",
"0.5574766",
"0.5573747",
"0.553861",
"0.5452227",
"0.5413668",
"0.5413428",
"0.54061526",
"0.53985643",
"0.536465",
"0.53360325",
"0.52808714",
"0.52574164",
"0.5256666",
"0.52544224",
"0.52473426",
"0.524029... | 0.50300044 | 40 |
Create a new (directed) graph instance | def createInstance():
graphTypeEnvVariable = os.getenv('GRAPH_TYPE')
graphTypeKey = graphTypeEnvVariable if graphTypeEnvVariable is not None else 'networkx' # Default to networkx
graphType = GraphFactory.typeMap[str(graphTypeKey)]
return graphType() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_single_node_graph(directed=False):\n if directed:\n graph = DirectedGraph()\n else:\n graph = UndirectedGraph()\n graph.new_node()\n\n return graph",
"def _construct_graph(self):\n raise NotImplementedError",
"def build_2_node_graph(directed=False):\n if directed:\n ... | [
"0.7362396",
"0.7305025",
"0.728026",
"0.7153638",
"0.70312077",
"0.7007304",
"0.696268",
"0.6951953",
"0.6908977",
"0.680827",
"0.6807212",
"0.6760757",
"0.6723978",
"0.67188424",
"0.6717348",
"0.6668516",
"0.66585326",
"0.6607544",
"0.6600618",
"0.6596716",
"0.6584806",
"... | 0.0 | -1 |
writes a string to a text file (UTF8) and returns the number of characters written | def write_file(filename="", text=""):
with open(filename, mode="w", encoding="utf-8") as m:
return m.write(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_file(filename=\"\", text=\"\"):\n with open(filename, mode='w', encoding='utf-8') as f:\n f.write(text)\n with open(filename, encoding='utf-8') as f:\n chars_wrote = 0\n for line in f:\n for chrs in line:\n chars_wrote += 1\n return chars_wrote",
... | [
"0.8017254",
"0.7992519",
"0.7653896",
"0.76335394",
"0.7604036",
"0.75782526",
"0.75011104",
"0.7486993",
"0.7422796",
"0.7185898",
"0.7028778",
"0.6912235",
"0.6856175",
"0.65315163",
"0.647109",
"0.6467817",
"0.63615954",
"0.6310156",
"0.6264829",
"0.62629646",
"0.6224557"... | 0.6605665 | 13 |
Parse and validate command line arguments using argparse. | def parse_arguments():
parser = argparse.ArgumentParser(
description="Convert NES CHR (graphics) data into a PNG file.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument(
"-p", "--palette", nargs=4, default=("000000", "555555", "aaaaaa", "ffffff"),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_args(self, parser: argparse):\n pass",
"def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--... | [
"0.8049023",
"0.7517425",
"0.73794687",
"0.73718673",
"0.73425865",
"0.7335131",
"0.7291243",
"0.72795725",
"0.7270892",
"0.7264726",
"0.7262399",
"0.7254151",
"0.72504383",
"0.7240381",
"0.72390467",
"0.7226859",
"0.7219809",
"0.7207931",
"0.7204468",
"0.7202564",
"0.7197727... | 0.0 | -1 |
Decode a 6digit hexadecimal color code. Return (R, G, B). | def decode_color_code(color):
try:
if len(color) != 6:
raise ValueError
color = int(color, 16)
except ValueError:
sys.exit("Invalid command line color argument.")
return (color >> 16, (color >> 8) & 0xff, color & 0xff) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseColor(c):\n if c in baseColors:\n return baseColors[c]\n if len(c) == 6:\n return tuple(map(lambda x: int(x, 16), (c[:2], c[2:4], c[4:])))\n if len(c) == 3:\n return tuple(map(lambda x: 16*int(x, 16), c))\n raise ValueError(\"Can't find color '{}'\".format(c))",
"def col... | [
"0.70379555",
"0.69850445",
"0.68155867",
"0.6667215",
"0.6667215",
"0.6579798",
"0.65655094",
"0.65628827",
"0.6547301",
"0.6505032",
"0.65026057",
"0.6496214",
"0.64522505",
"0.63568914",
"0.6349273",
"0.6349273",
"0.6349273",
"0.6349273",
"0.6297138",
"0.6291906",
"0.62521... | 0.79295737 | 0 |
Get the start address and size of CHR data in the file. Return (address, size). | def get_CHR_data_position(handle):
# raw CHR data?
fileSize = handle.seek(0, 2)
if fileSize > 0 and fileSize % 256 == 0:
return (0, fileSize)
# iNES ROM file?
try:
iNESInfo = ineslib.parse_iNES_header(handle)
except ineslib.iNESError as error:
sys.exit(
"The... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_file_chunk(self, buf=1000):\n data = self.file.read(buf)\n return data, len(data)",
"def chars(count):\n\n global offset\n\n bytes=midifile[offset:offset+count]\n offset+=count\n return bytes",
"def get_file_size(file_path):\n with open(file_path, 'rb') as infile:\n infi... | [
"0.59651583",
"0.5834163",
"0.57600224",
"0.5742578",
"0.5647145",
"0.56113386",
"0.5561132",
"0.55449986",
"0.5497243",
"0.5456488",
"0.54542714",
"0.5425964",
"0.5419218",
"0.5419066",
"0.5395858",
"0.5369064",
"0.5361087",
"0.5349149",
"0.5306322",
"0.5299539",
"0.52817094... | 0.7074004 | 0 |
Convert NES CHR data into a Pillow image. | def decode_file(source, palette):
(CHRStart, CHRSize) = get_CHR_data_position(source)
charRowCount = CHRSize // 256 # 16 characters/row
img = Image.new("P", (128, charRowCount * 8), 0)
img.putpalette(itertools.chain.from_iterable(palette))
source.seek(CHRStart)
for (y, pixelRow) in enumerate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _tile_image(self, data):\n image = Image.open(BytesIO(data))\n return image.convert('RGBA')",
"def _tile_image(self, data):\n image = Image.open(StringIO(data))\n return image.convert('RGBA')",
"def dwd_RGB_12_12_9i_N(self, backup_orig_data=False):\n self.check_channels(\"HRV\", 0.85, 10... | [
"0.5845652",
"0.57493347",
"0.5670378",
"0.5572581",
"0.5565135",
"0.5561687",
"0.5504968",
"0.5468423",
"0.5449214",
"0.54454327",
"0.5406887",
"0.5396389",
"0.5394998",
"0.53774685",
"0.53612804",
"0.53557503",
"0.53308254",
"0.5289437",
"0.52846557",
"0.5275512",
"0.527226... | 0.52317035 | 24 |
Create frequent candidate 1itemset C1 by scaning data set. | def create_C1(data_set):
C1 = set()
for t in data_set:
for item in t:
item_set = frozenset([item])
C1.add(item_set)
return C1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_C1(data_set):\n C1 = set()\n for t in data_set:\n for item in t:\n item_set = frozenset([item])\n C1.add(item_set)\n return C1",
"def fit(self, filePath):\n # Initialize some variables to hold the tmp result\n transListSet = self.getTransListSet(fil... | [
"0.6886297",
"0.624703",
"0.6201147",
"0.5755",
"0.56995976",
"0.5535812",
"0.5463",
"0.5460324",
"0.54472184",
"0.5409043",
"0.53956145",
"0.5346798",
"0.5327546",
"0.53055555",
"0.53005487",
"0.52838606",
"0.5277245",
"0.5261409",
"0.5238653",
"0.52295136",
"0.5222313",
"... | 0.6865995 | 1 |
Judge whether a frequent candidate kitemset satisfy Apriori property. | def is_apriori(Ck_item, Lksub1):
for item in Ck_item:
sub_Ck = Ck_item - frozenset([item])
if sub_Ck not in Lksub1:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_apriori(Ck_item, Lksub1):\n for item in Ck_item:\n sub_Ck = Ck_item - frozenset([item])\n if sub_Ck not in Lksub1:\n return False\n return True",
"def runApriori(data_iter, minSupport, minConfidence):\n itemSet, transactionList = getItemSetTransactionList(data_iter)\n... | [
"0.66959405",
"0.60583735",
"0.59899515",
"0.5980171",
"0.59638375",
"0.5880278",
"0.57959944",
"0.57608527",
"0.57316625",
"0.5725965",
"0.5725422",
"0.5713746",
"0.5713466",
"0.57089907",
"0.5668989",
"0.563154",
"0.5604906",
"0.55982333",
"0.5576207",
"0.5572789",
"0.55670... | 0.666684 | 1 |
Create Ck, a set which contains all all frequent candidate kitemsets by Lk1's own connection operation. | def create_Ck(Lksub1, k):
Ck = set()
len_Lksub1 = len(Lksub1)
list_Lksub1 = list(Lksub1)
for i in range(len_Lksub1):
for j in range(1, len_Lksub1):
l1 = list(list_Lksub1[i])
l2 = list(list_Lksub1[j])
l1.sort()
l2.sort()
if l1[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_Ck(Lksub1, k):\n Ck = set()\n len_Lksub1 = len(Lksub1)\n Lksub = list(Lksub1)\n for i in range(len_Lksub1):\n for j in range(1, len_Lksub1):\n l1 = list(Lksub[i])\n l2 = list(Lksub[j])\n l1.sort()\n l2.sort()\n if l1[0:k-2] == l2[... | [
"0.7030224",
"0.6693347",
"0.6450786",
"0.6290387",
"0.6284536",
"0.6245179",
"0.6236539",
"0.6200779",
"0.6141162",
"0.6107893",
"0.60948",
"0.59961575",
"0.5984875",
"0.5919703",
"0.5880751",
"0.5827621",
"0.576909",
"0.57687354",
"0.5766544",
"0.5685266",
"0.5683019",
"0... | 0.70728934 | 0 |
Generate Lk by executing a delete policy from Ck. | def generate_Lk_by_Ck(data_set, Ck, min_support, support_data):
Lk = set()
item_count = {}
for t in data_set:
for item in Ck:
if item.issubset(t):
if item not in item_count:
item_count[item] = 1
else:
item_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_cluster_policy(self):\n pass",
"def _generate_delete_sql(self, delete_keys):\n for key in delete_keys:\n app_label, sql_name = key\n old_node = self.from_sql_graph.nodes[key]\n operation = DeleteSQL(sql_name, old_node.reverse_sql, reverse_sql=old_nod... | [
"0.62585837",
"0.610776",
"0.60768133",
"0.5996151",
"0.5908339",
"0.58960474",
"0.58868164",
"0.5757094",
"0.57533836",
"0.5749329",
"0.5724434",
"0.57156825",
"0.57156825",
"0.56706184",
"0.56705767",
"0.5624003",
"0.56201947",
"0.56194127",
"0.5612312",
"0.55946124",
"0.55... | 0.0 | -1 |
Generate all frequent itemsets. | def generate_L(data_set, k, min_support):
support_data = {}
C1 = create_C1(data_set)
L1 = generate_Lk_by_Ck(data_set, C1, min_support, support_data)
Lksub1 = L1.copy()
L = []
L.append(Lksub1)
for i in range(2, k+1):
Ci = create_Ck(Lksub1, i)
Li = generate_Lk_by_Ck(da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ar_gen(frequentItemSets):\n# print frequentItemSets\n for fItemSet in frequentItemSets:\n if fItemSet:\n itemSets = fItemSet.keys()\n for itemSet in itemSets:\n subsets = subset_gen(itemSet)\n# print itemSet\n# print subsets\n ... | [
"0.71493286",
"0.7105992",
"0.6580777",
"0.62979317",
"0.6171453",
"0.61018306",
"0.6101328",
"0.61012286",
"0.60402083",
"0.6023916",
"0.6010784",
"0.5947156",
"0.5888078",
"0.5863928",
"0.58581185",
"0.58263636",
"0.58231854",
"0.57876766",
"0.5702378",
"0.5639596",
"0.5610... | 0.0 | -1 |
Generates DataLoader instances for training and validation data | def _get_data(
self, train_dataset: TensorDataset, validation_dataset: TensorDataset
):
return (
DataLoader(train_dataset, batch_size=self.batch_size, shuffle=True),
DataLoader(validation_dataset, batch_size=self.batch_size * 2),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_creator(config):\n train_dataset, val_dataset = LinearDataset(2, 5), LinearDataset(2, 5)\n train_loader = DataLoader(train_dataset, batch_size=config[\"batch_size\"])\n val_loader = DataLoader(val_dataset, batch_size=config[\"batch_size\"])\n return train_loader, val_loader",
"def creates_da... | [
"0.8210852",
"0.8109314",
"0.8044301",
"0.7968612",
"0.7917862",
"0.7887867",
"0.78700924",
"0.77869165",
"0.7760952",
"0.77082145",
"0.76851207",
"0.7662429",
"0.7631286",
"0.76265687",
"0.7601167",
"0.75591475",
"0.75547343",
"0.750435",
"0.7474078",
"0.74594635",
"0.742464... | 0.75457203 | 17 |
Updates model parameters with a forward and backward pass on a batch, returns loss value and batch size | def _loss_batch(self, x: torch.Tensor, y: torch.Tensor, optimizer=None):
loss = self.loss_function(self.model(x), y)
if optimizer is not None:
loss.backward()
optimizer.step()
optimizer.zero_grad()
return loss.item(), len(x) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_model(engine, batch):\n\t\tengine.model.train()\n\t\tengine.model.rpn.nms_thresh = 0.7\n\t\timg, target = prepare_batch(batch, device=get_device(engine.model))\n\t\tengine.optimizer.zero_grad()\n\t\tloss = engine.model(img, target)\n\t\tlosses = sum(l for l in loss.values())\n\t\tlosses.backward()\n\t\t... | [
"0.7193141",
"0.7010625",
"0.69024",
"0.6887777",
"0.6670186",
"0.6612049",
"0.6582479",
"0.6552454",
"0.6500733",
"0.6500733",
"0.6500733",
"0.64862645",
"0.6413767",
"0.64118475",
"0.64105713",
"0.64071685",
"0.640301",
"0.63606393",
"0.63578224",
"0.6344614",
"0.63444537",... | 0.0 | -1 |
Stores model artifact in 'path' | def save(self, path: str):
torch.save(self.model.state_dict(), path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_model(self, path):\n pass",
"def save_model(self, model_path: str):",
"def model_artifact(self):\n pass",
"def _save_model(self, path):\n self.ov_model._model_exists_or_err()\n path = Path(path)\n path.mkdir(exist_ok=True)\n xml_path = path / self.status['xm... | [
"0.7026439",
"0.6876322",
"0.67974365",
"0.6757171",
"0.6753395",
"0.67059636",
"0.66834545",
"0.6614887",
"0.6585589",
"0.6508608",
"0.6451823",
"0.63897693",
"0.6384008",
"0.6381931",
"0.63744783",
"0.63744783",
"0.63744783",
"0.63744783",
"0.63744783",
"0.63426495",
"0.628... | 0.6117312 | 37 |
judge that element's visible | def is_visible(self, locator, timeout=15):
try:
ui.WebDriverWait(self.driver, timeout).until(EC.visibility_of_element_located((By.CSS_SELECTOR, locator)))
return True
except TimeoutException:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_element_visible(self):\n if self.web_element.is_displayed():\n return True\n else:\n return False",
"def is_visible(self):",
"def is_visible(self, name):\n return self.q(css=\"div.{}\".format(name)).first.visible",
"def isVisible(self):\n\t\treturn True",
"... | [
"0.7998117",
"0.79434115",
"0.73818713",
"0.730582",
"0.7298647",
"0.7232003",
"0.7218634",
"0.71988034",
"0.7181496",
"0.7181496",
"0.7123885",
"0.7094754",
"0.7080614",
"0.7061787",
"0.69975",
"0.69776446",
"0.69749",
"0.6949657",
"0.692268",
"0.68815774",
"0.6865418",
"0... | 0.69461906 | 18 |
short func find element, way to CSSseletor search | def find_element(self, selector):
return self.driver.find_element_by_css_selector(selector) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(elem, xpath):\n if elem is None:\n return None\n return next(iter(elem.xpath(xpath)), None)",
"def css_find(css, wait_time=30):\r\n wait_for_present(css_selector=css, timeout=wait_time)\r\n return world.browser.find_by_css(css)",
"def find_element(self, element: WebElement) -> WebEl... | [
"0.6815187",
"0.6786542",
"0.6672687",
"0.6607929",
"0.6364039",
"0.6354677",
"0.6287534",
"0.6286016",
"0.6274199",
"0.6255014",
"0.6223549",
"0.6140126",
"0.61250657",
"0.610699",
"0.60959023",
"0.6075173",
"0.6055",
"0.59981996",
"0.5985145",
"0.59524626",
"0.594184",
"0... | 0.637397 | 4 |
cookie transplant to session | def set_session_cookie(self):
self.driver.get('{domain}/home/learn/index#/{cid}/go'.format(domain=domain,cid=cid))
for subCookie in self.driver.get_cookies():
self.session.cookies.set(subCookie[u'name'], self.driver.get_cookie(subCookie[u'name'])['value'])
if config.DEBUG:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def save(self, request, response) -> None:\n value = self.cipher.encrypt(request.session.dumps().encode())\n cookie = f'{self.cookie_name}={value.decode()}; SameSite=Lax'\n response.headers['Set-Cookie'] = cookie",
"def _update_cookies():\n global SESSION\n SESSION.cookies = brow... | [
"0.6975678",
"0.65395766",
"0.651551",
"0.64788395",
"0.6411001",
"0.6401638",
"0.6388814",
"0.63399684",
"0.6266068",
"0.6216162",
"0.6212182",
"0.6202752",
"0.6136299",
"0.61301976",
"0.6107034",
"0.61065716",
"0.61032164",
"0.6093326",
"0.6091979",
"0.60879934",
"0.6080099... | 0.62935907 | 8 |
calculator how many class and how many should handler | def add_obItems(self):
self.set_session_cookie()
api_data = self.session.get(
'{domain}/home/learn/getCatalogList?cid={cid}&hidemsg_=true&show='.format(domain=domain,cid=cid))
if config.DEBUG:
print "api_data.url :: \n{url}, content ::\n{content}". \
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_classes(self):",
"def n_classes(self):\n raise NotImplementedError",
"def n_classes(self):\n raise NotImplementedError",
"def n_classes(self):\n raise NotImplementedError()",
"def num_classes(self):\n\t\treturn 10",
"def do_count(self, *args):\n count = 0\n ... | [
"0.69187886",
"0.6613594",
"0.6613594",
"0.6554572",
"0.65268314",
"0.62493396",
"0.61780745",
"0.6160084",
"0.6104748",
"0.6081582",
"0.60603327",
"0.60551685",
"0.60187566",
"0.59950566",
"0.5972611",
"0.5936401",
"0.5935454",
"0.5877726",
"0.5868197",
"0.5832535",
"0.58261... | 0.0 | -1 |
Using Pure fresh Naivasha Ellitrack device. I am going to simulate weekly billing | def automatic_meter_reading_demo():
#Get sensor data from ellitrack
serial = 17112915
#get period dates
first_day_of_the_month = datetime.datetime.today().replace(day=1)
yesterday = datetime.datetime.now().date() - datetime.timedelta(days=1)
#seven_days_earlier = yesterday - datetime.timedelta(days=7)
period_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n dict_logs = {\n 'logs/e_log.log': logging.ERROR,\n 'logs/c_log.log': logging.INFO\n }\n\n logger = create_logger(**dict_logs)\n\n # For using Chrome\n browser = webdriver.Chrome('chromedriver.exe')\n\n url = 'https://www.bestbuy.com/site/nvidia-geforce-rtx-3090-24gb-... | [
"0.54909945",
"0.54586065",
"0.5381838",
"0.5380678",
"0.5356642",
"0.53565866",
"0.53053683",
"0.5258174",
"0.52458274",
"0.5244081",
"0.5229652",
"0.5226608",
"0.5205739",
"0.5198463",
"0.5194624",
"0.5194555",
"0.5188861",
"0.51873434",
"0.5172629",
"0.51712",
"0.5168242",... | 0.4980588 | 42 |
The main function that interacts with the API. We'll do some try/except to make sure that we actually receive data from the API before sending back the callback. | def get_url(url):
logger.debug(f'Trying CoinMarketCap API connection.')
# Try making connection, and then raise exception if a non-200 status response was received.
try:
response = requests.get(url)
response.raise_for_status()
logger.debug(f'CoinMarketCap API request successful.')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call_api(self):\n #generate the final call string\n self.generate_call_string();\n #debug\n #print (self.call_url);\n \n #finally make api call\n try: \n #pass; \n self.return_articles= json.loads(urlopen(self.call_url).read());\n ... | [
"0.67859524",
"0.6489905",
"0.63259",
"0.61163515",
"0.6017064",
"0.5998514",
"0.59876233",
"0.5981442",
"0.59209305",
"0.5907225",
"0.5906987",
"0.5884664",
"0.5880034",
"0.5877678",
"0.5845966",
"0.57924813",
"0.5786819",
"0.578508",
"0.5777931",
"0.5777396",
"0.5765343",
... | 0.0 | -1 |
Builds the URL based on the coin parameter received and calls the get_url() function | def get_coin_data(coin):
url = URL + f"ticker/{coin}"
data = get_url(url)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_url(self, **kwargs):\n path = self.url_path.format(**kwargs)\n return self.poolbot.generate_url(path)",
"def build_url(self):\n url = requests.utils.requote_uri(\n self.torrent_page + self.string_search)\n if self.page == '1337x':\n return(url + '/1... | [
"0.65411425",
"0.63300383",
"0.6040743",
"0.6007516",
"0.5941518",
"0.5924182",
"0.59067404",
"0.5865369",
"0.5839566",
"0.5832496",
"0.57956237",
"0.57749695",
"0.5747344",
"0.5724375",
"0.5723643",
"0.56971496",
"0.5675385",
"0.56733966",
"0.5667794",
"0.5649485",
"0.564533... | 0.54164875 | 45 |
adds windtunnel box to an ax | def draw_windtunnel_border(ax):
x_min = 0
x_max = 1
z_min = 0
z_max = 0.254
y_min = -0.127
y_max = 0.127
draw_rectangular_prism(ax, x_min, x_max, y_min, y_max, z_min, z_max)
plt.draw() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_box(self):\n self.scenes[self.current_scene].add_object(Box())\n self.redraw()",
"def add_box(self, box):\n mz_from = box.from_mz\n mz_to = box.to_mz\n rt_from = box.from_rt\n rt_to = box.to_rt\n self.boxes_mz.addi(mz_from, mz_to, box)\n self.boxes_... | [
"0.58353895",
"0.5790107",
"0.57524234",
"0.5593443",
"0.5475752",
"0.53979737",
"0.53805476",
"0.53432196",
"0.5318134",
"0.53155285",
"0.52366716",
"0.5194952",
"0.51729375",
"0.5148649",
"0.51383233",
"0.51253414",
"0.5115568",
"0.5114796",
"0.5070012",
"0.5055591",
"0.504... | 0.6089721 | 0 |
adds heaters to an ax | def draw_heaters(ax, windtunnel):
draw_heater(ax, windtunnel.heater_l)
draw_heater(ax, windtunnel.heater_r) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_heat_map(self, ax=None, block=True):\n plt.figure()\n ax = sns.heatmap(data=self.data, fmt=\"\", cmap='RdYlGn', linewidths=0.3, ax=ax)\n ax.invert_yaxis()\n ax.set(xlabel='Books index', ylabel='Books values over iterations', title='Heat map for the prediction result'\n ... | [
"0.6191286",
"0.5851744",
"0.5804792",
"0.5803193",
"0.5751369",
"0.575062",
"0.57083535",
"0.56923664",
"0.56552476",
"0.5585687",
"0.5582017",
"0.5570664",
"0.553861",
"0.55253464",
"0.5523711",
"0.55133945",
"0.54960084",
"0.54917896",
"0.5479611",
"0.5449382",
"0.5418402"... | 0.65778947 | 0 |
draw a generic rectangular prism | def draw_rectangular_prism(ax, x_min, x_max, y_min, y_max, z_min, z_max):
alpha = 1
back = Rectangle((y_min, z_min), y_max - y_min, z_max, alpha=alpha, fill=None, linestyle='dotted')
ax.add_patch(back)
art3d.pathpatch_2d_to_3d(back, z=x_min, zdir="x")
front = Rectangle((y_min, z_min), y_max - y_min... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n pt = self.getPoint() # Centre of prism\n\n # Form top,left,right corners\n top = Vector2d(pt.z, pt.y + self.height/2)\n d = self.height*math.tan(self.angle/2)\n left = Vector2d(pt.z - d , pt.y - self.height/2)\n right = Vector2d(pt.z + d, pt.y... | [
"0.72910595",
"0.6515819",
"0.6209327",
"0.6186026",
"0.6058665",
"0.60284466",
"0.5912263",
"0.589943",
"0.5896657",
"0.5882874",
"0.585008",
"0.58448476",
"0.5837638",
"0.5797427",
"0.5788786",
"0.5786838",
"0.5756717",
"0.5756544",
"0.57435954",
"0.5728075",
"0.57125056",
... | 0.68564206 | 1 |
Plot a quiverplot of the gradient | def plot_plume_gradient(plume, ax, thresh, skipevery = 6): # TODO: plot inside windtunnel as in draw_bool_plume
filtered = plume.data[plume.data.gradient_norm > thresh]
if skipevery != 0:
filtered = filtered[::skipevery]
ax.quiver(filtered.x, filtered.y, filtered.z, filtered.gradient_x, filtered.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quick_quiver():\n plt.quiver(x,y,u,v,sig2noise_ratio, scale=50,color='b')\n plt.gca().invert_yaxis()\n plt.gca().set_aspect(1)\n plt.plot(x.flat[xymask],y.flat[xymask],'rx')\n plt.colorbar(orientation='horizontal')",
"def plot_vf(velocities):\n n = np.shape(velocities)[0]\n u = velocitie... | [
"0.65154076",
"0.63556695",
"0.61553794",
"0.61197305",
"0.6090479",
"0.586303",
"0.58170414",
"0.56765515",
"0.56476736",
"0.5598726",
"0.5560891",
"0.5547584",
"0.553222",
"0.54735816",
"0.54416955",
"0.53720146",
"0.5366105",
"0.5361912",
"0.53352004",
"0.5322029",
"0.5320... | 0.6441448 | 1 |
r"""This may be improved its just a hacky way to write SGDWR | def reschedule_learning_rate(model, epoch, scheduler):
if epoch == 7:
optimizer = torch.optim.SGD(model.parameters(), lr=0.005)
current_lr = next(iter(optimizer.param_groups))["lr"]
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, 6, eta_min=current_lr / 100, la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_data():",
"def write(self):",
"def write(self):",
"def w(s):\r\n gv[\"epsf\"].write(s + \"\\n\")",
"def generate_sdfs(timing_data, sdf_path):\n\n def make_speed_model(data):\n \"\"\"\n Makes a speed model structure for the SDF writer\n \"\"\"\n model = dict()\n\n... | [
"0.55522937",
"0.55387354",
"0.55387354",
"0.5400637",
"0.53835016",
"0.5318729",
"0.5311355",
"0.5307885",
"0.528809",
"0.52554166",
"0.52429384",
"0.5242792",
"0.52392423",
"0.5233273",
"0.5229388",
"0.5209131",
"0.5165275",
"0.5147419",
"0.5136346",
"0.51323134",
"0.512195... | 0.0 | -1 |
Periodic correlation, implemented using np.correlate. x and y must be real sequences with the same length. | def periodic_corr_np(x, y):
#
# src: https://stackoverflow.com/questions/28284257/circular-cross-correlation-python
# circular cross correlation python
#
#
return np.correlate(x, np.hstack((y[1:], y)), mode='valid') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def periodic_corr(x, y):\r\n return np.fft.ifft(np.fft.fft(x) * np.fft.fft(y).conj()).real",
"def xcorr(x, y, maxlag=None):\n xl = x.size\n yl = y.size\n if xl != yl:\n raise ValueError('x and y must be equal length')\n\n if maxlag is None:\n maxlag = xl - 1\n else:\n maxla... | [
"0.79519504",
"0.75662684",
"0.74097294",
"0.73958045",
"0.73598063",
"0.7300638",
"0.7269215",
"0.7267762",
"0.72383136",
"0.72049016",
"0.71835554",
"0.7174526",
"0.7106051",
"0.70750237",
"0.69332325",
"0.69196165",
"0.69098467",
"0.68443376",
"0.67585266",
"0.67496026",
"... | 0.8327699 | 0 |
Handles the mouse being moved in the 'normal' state. Prints the data space position of the current mouse position. | def normal_mouse_move(self, event):
plot = self.component
if plot is not None:
if isinstance(plot, BaseXYPlot):
ndx = plot.map_index((event.x, event.y), index_only = True)
x = plot.index.get_data()[ndx]
y = plot.value.get_data()[ndx]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mouse_move_callback(self, event):\n # TODO drag and drop figuriek\n print(\"moving at \", event.x + self.offset_x, event.y + self.offset_y)",
"def report_mouse_position(x_pos=0, y_pos=0):\n print('x-axis:', x_pos, ' Y-axis: ', y_pos, flush=True)",
"def mousePositionRaw(self):",
"def mous... | [
"0.6891763",
"0.6877345",
"0.68201053",
"0.68201053",
"0.6619768",
"0.6596764",
"0.6543408",
"0.6506254",
"0.63932467",
"0.63913417",
"0.6375399",
"0.6339471",
"0.6308581",
"0.62776256",
"0.6249573",
"0.61815065",
"0.61815065",
"0.61744684",
"0.61577696",
"0.6157739",
"0.6156... | 0.74333996 | 0 |
Parse a date string and convert to a naive ``datetime`` object in UTC | def parse(date_string: str):
# parse the date string
date = dateutil.parser.parse(date_string)
# convert to UTC if containing time-zone information
# then drop the timezone information to prevent unsupported errors
if date.tzinfo:
date = date.astimezone(dateutil.tz.UTC).replace(tzinfo=None)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_date(s):\n return parse(s).astimezone(pytz.utc)",
"def parse_datetime(datestr):\r\n try:\r\n return dateutil.parser.parse(datestr).replace(tzinfo=utc)\r\n except ValueError:\r\n raise DashboardError(_(\"Unable to parse date: \") + datestr)",
"def parse_datetime(date_string):\n... | [
"0.7907816",
"0.78428483",
"0.76955104",
"0.7673007",
"0.7471216",
"0.74361444",
"0.7354086",
"0.73491085",
"0.7290312",
"0.7242",
"0.7239528",
"0.7228141",
"0.7222079",
"0.717494",
"0.7138004",
"0.7137841",
"0.7119581",
"0.7117855",
"0.71016157",
"0.70935977",
"0.7070508",
... | 0.8083489 | 0 |
Parse a date string of the form | def parse_date_string(date_string: str):
# try parsing the original date string as a date
try:
epoch = parse(date_string)
except ValueError:
pass
else:
# return the epoch (as list)
return (datetime_to_list(epoch), 0.0)
# split the date string into units and epoch
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_parse(date_string) -> datetime:\n return datetime.strptime(date_string, DATE_FMT)",
"def parse_date(str_date):\n return ciso8601.parse_datetime(str_date)",
"def parse(self, str):\n values = self._exp.findall(str)\n if values is None or len(values) == 0:\n return None\n\n... | [
"0.7754825",
"0.7681746",
"0.7619202",
"0.7595637",
"0.7554202",
"0.7522775",
"0.7512194",
"0.7293273",
"0.7285541",
"0.7257252",
"0.7254006",
"0.7244446",
"0.7221628",
"0.7219147",
"0.72051275",
"0.720416",
"0.7189553",
"0.71871907",
"0.71790546",
"0.71494836",
"0.7117056",
... | 0.64465564 | 85 |
Split a date string into units and epoch | def split_date_string(date_string: str):
try:
units,_,epoch = date_string.split(None, 2)
except ValueError:
raise ValueError(f'Invalid format: {date_string}')
else:
return (units.lower(), parse(epoch)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_date_string(date_string: str):\n # try parsing the original date string as a date\n try:\n epoch = parse(date_string)\n except ValueError:\n pass\n else:\n # return the epoch (as list)\n return (datetime_to_list(epoch), 0.0)\n # split the date string into units ... | [
"0.7257494",
"0.7253272",
"0.67156667",
"0.64704216",
"0.63837385",
"0.6196135",
"0.6182121",
"0.60728586",
"0.6071914",
"0.60442466",
"0.6017566",
"0.60019803",
"0.5955302",
"0.588226",
"0.58331114",
"0.58295196",
"0.5822171",
"0.5812971",
"0.58089995",
"0.57947624",
"0.5778... | 0.78031945 | 0 |
Convert a ``datetime`` object into a list | def datetime_to_list(date):
return [date.year, date.month, date.day,
date.hour, date.minute, date.second] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_datetime_objs(list_of_dates):\n datetime_list = []\n for date in list_of_dates:\n date_obj = datetime.datetime.strptime(date, '%d.%m.%Y')\n datetime_list.append(date_obj)\n return datetime_list",
"def deconstruct_datetime(self, date: datetime) -> List[int]:\n year, month... | [
"0.72302264",
"0.708684",
"0.70127237",
"0.6490613",
"0.6426555",
"0.6377876",
"0.6265655",
"0.62604266",
"0.62300515",
"0.616861",
"0.6105871",
"0.6052892",
"0.6040023",
"0.6040023",
"0.6040023",
"0.6040023",
"0.60229015",
"0.60185957",
"0.6013034",
"0.5994853",
"0.5991498",... | 0.85056525 | 0 |
Calculates the number of days per month for a given year | def calendar_days(year: int | float | np.ndarray) -> np.ndarray:
# Rules in the Gregorian calendar for a year to be a leap year:
# divisible by 4, but not by 100 unless divisible by 400
# True length of the year is about 365.2422 days
# Adding a leap day every four years ==> average 365.25
# Subtrac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numDays(month, year):\n\tif month in [9, 4, 6, 11]:\n\t\treturn 30\n\telif month == 2 and year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):\n\t\treturn 29\n\telif month == 2:\n\t\treturn 28\n\telse:\n\t\treturn 31",
"def dayInYear(month, day, year):\n current = 1\n numberOfDays = day\n while (... | [
"0.7753709",
"0.7750762",
"0.73286164",
"0.73098063",
"0.7175724",
"0.7171483",
"0.7167888",
"0.70833415",
"0.69083405",
"0.6902013",
"0.6811778",
"0.6779676",
"0.67423326",
"0.6646203",
"0.6620933",
"0.6610777",
"0.6599068",
"0.6589264",
"0.6504895",
"0.647074",
"0.64705473"... | 0.7057161 | 8 |
Convert a ``numpy`` ``datetime`` array to seconds since ``epoch`` | def convert_datetime(
date: float | np.ndarray,
epoch: str | tuple | list | np.datetime64 = _unix_epoch
):
# convert epoch to datetime variables
if isinstance(epoch, (tuple, list)):
epoch = np.datetime64(datetime.datetime(*epoch))
elif isinstance(epoch, str):
epoch = np.d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ts_to_epoch_seconds(t) -> float:\n return t.astype(int) / 1e9",
"def epoch2datetime(t):\n return datetime.fromtimestamp(t/1000.0)",
"def seconds_since_epoch(date_time, epoch=None):\n return microseconds_since_epoch(date_time) / 10.0**6",
"def epoch_seconds(date):\n td = date - epoch\n retu... | [
"0.7118472",
"0.7046606",
"0.6772909",
"0.66768813",
"0.66768813",
"0.6676594",
"0.6578405",
"0.65100276",
"0.6425068",
"0.6245704",
"0.6234241",
"0.6234241",
"0.6190503",
"0.61882025",
"0.6174044",
"0.5989631",
"0.5972627",
"0.59568745",
"0.59374034",
"0.5933194",
"0.5920487... | 0.720014 | 0 |
Convert delta time from seconds since ``epoch1`` to time since ``epoch2`` | def convert_delta_time(
delta_time: np.ndarray,
epoch1: str | tuple | list | np.datetime64 | None = None,
epoch2: str | tuple | list | np.datetime64 | None = None,
scale: float = 1.0
):
# convert epochs to datetime variables
if isinstance(epoch1, (tuple, list)):
epoch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epoch2time(time):\n\tvalue = datetime.datetime.fromtimestamp(time)\n\tNormal = value.strftime('%Y-%m-%d %H:%M:%S')\n\tprint(normal)\n\treturn normal",
"def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\n return float(pcr_t2-pcr_t1)/90000.0 + offset",
"def to_deltatime(self,\n epoch: str | tu... | [
"0.6507025",
"0.6423904",
"0.6152986",
"0.60294515",
"0.5935391",
"0.5886159",
"0.58696276",
"0.585755",
"0.58195716",
"0.58072734",
"0.5757571",
"0.5749442",
"0.56640947",
"0.5653533",
"0.56484276",
"0.56360996",
"0.56360996",
"0.5627376",
"0.5626698",
"0.55913216",
"0.55352... | 0.73310125 | 0 |
Calculate the time in units since ``epoch`` from calendar dates | def convert_calendar_dates(
year: np.ndarray,
month: np.ndarray,
day: np.ndarray,
hour: np.ndarray | float = 0.0,
minute: np.ndarray | float = 0.0,
second: np.ndarray | float = 0.0,
epoch: tuple | list | np.datetime64 = _tide_epoch,
scale: float = 1.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epoch_time(when):\n if not when: return 0\n epoch = datetime.utcfromtimestamp(0)\n delta = when - epoch\n return int(delta.total_seconds())",
"def epoch_seconds(date):\r\n td = date - epoch\r\n return td.days * 86400 + td.seconds + (float(td.microseconds) / 1000000)",
"def epoch_seconds(d... | [
"0.65011543",
"0.6338023",
"0.6319791",
"0.6319791",
"0.63163614",
"0.6262128",
"0.62227833",
"0.61993825",
"0.61317724",
"0.6127495",
"0.61181426",
"0.6072212",
"0.60007864",
"0.59639204",
"0.59409183",
"0.59142095",
"0.58571243",
"0.58349025",
"0.5826222",
"0.5819649",
"0.5... | 0.5271708 | 56 |
Converts from calendar date into decimal years taking into account leap years | def convert_calendar_decimal(
year: np.ndarray,
month: np.ndarray,
day: np.ndarray,
hour: np.ndarray | float | None = None,
minute: np.ndarray | float | None = None,
second: np.ndarray | float | None = None,
DofY: np.ndarray | float | None = None,
) -> np.ndar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def days_to_years(datum):\n return datum/DAYS_PER_YEAR",
"def _days_before_year(year):\n y = year - 1\n return y * 365 + y // 4 - y // 100 + y // 400",
"def year(self) -> int:\n if self.is_old_style:\n yy = int(self.split('/', 1)[1][0:2])\n else:\n yy = int(self[:2])... | [
"0.8203957",
"0.71250075",
"0.7108617",
"0.7105648",
"0.69998467",
"0.69553566",
"0.6881788",
"0.6873216",
"0.68200904",
"0.6782167",
"0.67277336",
"0.6661865",
"0.6608123",
"0.65985143",
"0.65974677",
"0.65909606",
"0.65848035",
"0.6561672",
"0.6542898",
"0.6496585",
"0.6490... | 0.0 | -1 |
Converts from Julian day to calendar date and time | def convert_julian(JD: np.ndarray, **kwargs):
# set default keyword arguments
kwargs.setdefault('astype', None)
kwargs.setdefault('format', 'dict')
# raise warnings for deprecated keyword arguments
deprecated_keywords = dict(ASTYPE='astype', FORMAT='format')
for old,new in deprecated_keywords.it... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def JulianDay(self):\n a = (14 - self._month) // 12\n y = self._year + 4800 - a\n m = self._month + (12 * a) - 3\n return (self._day + (153 * m + 2) // 5 + 365 * y +\n y // 4 - y // 100 + y // 400 - 32045)",
"def _gregorian_to_julian_day(year, month, day):\n if month... | [
"0.6966466",
"0.6876087",
"0.6870243",
"0.68287796",
"0.67212313",
"0.6684041",
"0.6644245",
"0.664008",
"0.66230804",
"0.65871185",
"0.6576862",
"0.6546014",
"0.6470467",
"0.645271",
"0.645271",
"0.64524555",
"0.64404553",
"0.6387761",
"0.63858074",
"0.62827337",
"0.6244979"... | 0.6714327 | 5 |
Converts a delta time array and into a ``timescale`` object | def from_deltatime(self,
delta_time: np.ndarray,
epoch: str | tuple | list | np.ndarray,
standard: str = 'UTC'
):
# assert delta time is an array
delta_time = np.atleast_1d(delta_time)
# calculate leap seconds if specified
if (standard.upper() ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_delta_time(\n delta_time: np.ndarray,\n epoch1: str | tuple | list | np.datetime64 | None = None,\n epoch2: str | tuple | list | np.datetime64 | None = None,\n scale: float = 1.0\n ):\n # convert epochs to datetime variables\n if isinstance(epoch1, (tuple, list)):\n... | [
"0.70219845",
"0.70219845",
"0.617282",
"0.5939533",
"0.5779774",
"0.5593302",
"0.55432564",
"0.5536148",
"0.5521312",
"0.53766155",
"0.53602535",
"0.527159",
"0.5263677",
"0.5244214",
"0.5233275",
"0.52244824",
"0.5211894",
"0.51791227",
"0.5178882",
"0.51320446",
"0.5113183... | 0.5494914 | 9 |
Reads a ``datetime`` array and converts into a ``timescale`` object | def from_datetime(self, dtime: np.ndarray):
# convert delta time array from datetime object
# to days relative to 1992-01-01T00:00:00
self.MJD = convert_datetime(dtime, epoch=_mjd_epoch)/self.day
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _datenums_to_datetime(timearr):\n def convert(dn):\n # ref: https://stackoverflow.com/questions/13965740/converting-matlabs-datenum-format-to-python\n _dtg = datetime.fromordinal(int(dn)) + timedelta(days=dn % 1) - timedelta(days=366)\n return _dtg\n\n # return quickly if float (not ... | [
"0.6680321",
"0.6339166",
"0.622429",
"0.6137414",
"0.6017892",
"0.58920026",
"0.5789863",
"0.57523423",
"0.5700324",
"0.567803",
"0.5672263",
"0.56458503",
"0.56321234",
"0.55204177",
"0.55177724",
"0.5458993",
"0.5448575",
"0.5430145",
"0.5427152",
"0.5418572",
"0.54000634"... | 0.5191718 | 31 |
Convert a ``timescale`` object to a delta time array | def to_deltatime(self,
epoch: str | tuple | list | np.ndarray,
scale: float = 1.0
):
# convert epochs to numpy datetime variables
epoch1 = np.datetime64(datetime.datetime(*_mjd_epoch))
if isinstance(epoch, (tuple, list)):
epoch = np.datetime64(datetime... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_delta_time(\n delta_time: np.ndarray,\n epoch1: str | tuple | list | np.datetime64 | None = None,\n epoch2: str | tuple | list | np.datetime64 | None = None,\n scale: float = 1.0\n ):\n # convert epochs to datetime variables\n if isinstance(epoch1, (tuple, list)):\n... | [
"0.64878637",
"0.64878637",
"0.61043775",
"0.5972427",
"0.5885216",
"0.58361775",
"0.5752255",
"0.5551825",
"0.55293506",
"0.55140555",
"0.5505703",
"0.5482155",
"0.5378903",
"0.5345492",
"0.5293476",
"0.52068985",
"0.516708",
"0.51591724",
"0.5147998",
"0.51271814",
"0.51263... | 0.5759867 | 6 |
Convert a ``timescale`` object to a ``datetime`` array Returns | def to_datetime(self):
# convert Modified Julian Day epoch to datetime variable
epoch = np.datetime64(datetime.datetime(*_mjd_epoch))
# use nanoseconds to keep as much precision as possible
delta_time = np.atleast_1d(self.MJD*self.day*1e9).astype(np.int64)
# return the datetime a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _datenums_to_datetime(timearr):\n def convert(dn):\n # ref: https://stackoverflow.com/questions/13965740/converting-matlabs-datenum-format-to-python\n _dtg = datetime.fromordinal(int(dn)) + timedelta(days=dn % 1) - timedelta(days=366)\n return _dtg\n\n # return quickly if float (not ... | [
"0.6838105",
"0.6681591",
"0.66007125",
"0.65673816",
"0.64083326",
"0.6393032",
"0.6225149",
"0.60525537",
"0.60447085",
"0.5981337",
"0.59587187",
"0.59361076",
"0.5913841",
"0.58931285",
"0.58422744",
"0.5785199",
"0.57421887",
"0.57266754",
"0.57106245",
"0.5692391",
"0.5... | 0.57221293 | 18 |
Calculates the sum of a polynomial function of time | def polynomial_sum(self, coefficients: list | np.ndarray, t: np.ndarray):
# convert time to array if importing a single value
t = np.atleast_1d(t)
return np.sum([c * (t ** i) for i, c in enumerate(coefficients)], axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polynomial(a, x):\n\n sum = 0\n\n for i in range(len(a)):\n sum += a[i] * x**i\n return sum",
"def evaluate_poly(poly: Sequence[float], x: float) -> float:\n return sum(c * (x**i) for i, c in enumerate(poly))",
"def evaluate_poly(poly, x):\n exp = 0\n total = 0\n for coef in pol... | [
"0.69386065",
"0.6748726",
"0.65859747",
"0.657982",
"0.6418515",
"0.63866585",
"0.6333331",
"0.6205636",
"0.61954945",
"0.61891437",
"0.61560464",
"0.61277664",
"0.6109031",
"0.60706145",
"0.60396737",
"0.6031695",
"0.60197645",
"0.6016289",
"0.59671974",
"0.5960084",
"0.593... | 0.7166109 | 0 |
Earth Rotation Angle (ERA) in degrees | def era(self):
# earth rotation angle using Universal Time
J = self.MJD - 51544.5
fraction = np.mod(J, self.turn)
theta = np.mod(0.7790572732640 + 0.00273781191135448*J, self.turn)
return self.turndeg*np.mod(theta + fraction, self.turn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_attitude_angle(self):\n return np.arctan(np.pi * (1 - self.eccentricity_ratio ** 2) / (4 * self.eccentricity_ratio))",
"def _altaz_rotation(self, jd):\n R_lon = rot_z(- self.longitude.radians - jd.gast * TAU / 24.0)\n return einsum('ij...,jk...,kl...->il...', self.R_lat, R_lon,... | [
"0.674512",
"0.6602822",
"0.65989155",
"0.6557351",
"0.64846647",
"0.6468571",
"0.64416575",
"0.6428505",
"0.64205354",
"0.6386489",
"0.63785654",
"0.63539183",
"0.63338894",
"0.6282171",
"0.6258052",
"0.6255307",
"0.62220407",
"0.6206311",
"0.6206153",
"0.6204205",
"0.618560... | 0.83793527 | 0 |
Greenwich Hour Angle (GHA) in degrees | def gha(self):
return np.mod(self.gmst*self.turndeg +
self.turndeg*self.T*self.century +
self.turndeg/2.0, self.turndeg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hpa(self):\n return HPAngle(gon2hp(self.gon_angle))",
"def get_local_hour_angle(self):\n LHA = self.Calculations.local_hour_angle(self.Longitude, self.right_ascension)\n self.LHA = LHA\n return LHA",
"def getH(self):\n\t\thAngle = (math.atan2(self.y,self.x))/(2*math.pi)\n\t\tif ... | [
"0.6866496",
"0.68414015",
"0.67737657",
"0.66491437",
"0.6601375",
"0.65256166",
"0.640311",
"0.63629305",
"0.6301536",
"0.6282773",
"0.62634754",
"0.62258744",
"0.61544293",
"0.6149261",
"0.61482656",
"0.60767734",
"0.60743266",
"0.6058337",
"0.60410094",
"0.60410094",
"0.6... | 0.75936776 | 0 |
Greenwich Mean Sidereal Time (GMST) in fractions of day | def gmst(self):
GMST = np.array([24110.54841, 8640184.812866, 9.3104e-2, -6.2e-6])
# convert from seconds to fractions of day
return np.mod(self.polynomial_sum(GMST, self.T)/self.day, self.turn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_GMST(self, date):\n jd = self.julian_date(date)\n T = (jd - 2451545.0)/36525.0\n gmstdeg = 280.46061837+(360.98564736629*(jd-2451545.0))+(0.000387933*T*T)-(T*T*T/38710000.0)\n gmst = ephem.degrees(gmstdeg*np.pi/180.0)\n return gmst",
"def MJD2GMST(MJD):\n # GMST = 2... | [
"0.75275975",
"0.7122444",
"0.70665514",
"0.6129707",
"0.602409",
"0.57152545",
"0.566555",
"0.55894446",
"0.5582507",
"0.55749035",
"0.5572051",
"0.5566701",
"0.5546085",
"0.55289936",
"0.5466619",
"0.5463478",
"0.53989863",
"0.53863674",
"0.53379256",
"0.5330827",
"0.530122... | 0.7240699 | 1 |
Greenwich Mean Sidereal Time (GMST) in fractions of a day from the Equinox Method | def st(self):
# sidereal time polynomial coefficients in arcseconds
sidereal_time = np.array([0.014506, 4612.156534, 1.3915817, -4.4e-7,
-2.9956e-05, -3.68e-08])
ST = self.polynomial_sum(sidereal_time, self.T)
# get earth rotation angle and convert to arcseconds
retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_GMST(self, date):\n jd = self.julian_date(date)\n T = (jd - 2451545.0)/36525.0\n gmstdeg = 280.46061837+(360.98564736629*(jd-2451545.0))+(0.000387933*T*T)-(T*T*T/38710000.0)\n gmst = ephem.degrees(gmstdeg*np.pi/180.0)\n return gmst",
"def gmst(self):\n GMST = np... | [
"0.7580178",
"0.7263052",
"0.6985743",
"0.6871786",
"0.5782016",
"0.56890565",
"0.5673886",
"0.5630641",
"0.5608682",
"0.5593219",
"0.555187",
"0.5504932",
"0.5493797",
"0.5489374",
"0.5472424",
"0.5406448",
"0.5394932",
"0.5379389",
"0.53495014",
"0.5342813",
"0.534229",
"... | 0.61608785 | 4 |
Dynamic Time (TT) as Julian Days | def tt(self):
return self.MJD + self.tt_ut1 + 2400000.5 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_julian_date(cls, year, month, day, tp='miladi'):\n cal = Calverter()\n if tp == 'miladi':\n return cal.gregorian_to_jd(year, month, day)\n return cal.jalali_to_jd(year, month, day)",
"def JulianDay(self):\n a = (14 - self._month) // 12\n y = self._year + 4800... | [
"0.65697944",
"0.644693",
"0.6362859",
"0.635199",
"0.63276625",
"0.6300114",
"0.6296536",
"0.62951887",
"0.6267511",
"0.62593186",
"0.62149376",
"0.60694706",
"0.6047973",
"0.6033596",
"0.6023847",
"0.6016421",
"0.60082954",
"0.5991778",
"0.59857446",
"0.59478116",
"0.594044... | 0.64475 | 1 |
Difference between universal time (UT) and dynamical time (TT) | def tt_ut1(self):
# return the delta time for the input date converted to days
return interpolate_delta_time(_delta_file, self.tide) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tt(self):\n return self.MJD + self.tt_ut1 + 2400000.5",
"def FromTerrestrialTime(tt):\n return Time(_UniversalTime(tt), tt)",
"def Tt(s_c, point, system):\n Tx = tra(s_c, point, system)\n Tx.get_time()\n return Tx.time",
"def time(self, u):\n return self._ll_tree.get_time(u)... | [
"0.67252356",
"0.6356437",
"0.6324151",
"0.6247634",
"0.6235292",
"0.6177706",
"0.6114084",
"0.60345054",
"0.6016289",
"0.5991008",
"0.5976588",
"0.5966939",
"0.5965875",
"0.5953034",
"0.59318453",
"0.59278727",
"0.5925871",
"0.59051293",
"0.5900001",
"0.58759505",
"0.5874289... | 0.6015316 | 9 |
Universal Time (UT) as Julian Days | def ut1(self):
return self.MJD + 2400000.5 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_juldate():\n import time\n mjd = time.time()/86400.0 + 40587.0\n return mjd + 2400000.5",
"def JulianDay(self):\n a = (14 - self._month) // 12\n y = self._year + 4800 - a\n m = self._month + (12 * a) - 3\n return (self._day + (153 * m + 2) // 5 + 365 * y +\n ... | [
"0.715137",
"0.71111745",
"0.69940096",
"0.6913078",
"0.68461066",
"0.6762256",
"0.66047966",
"0.6559268",
"0.64414185",
"0.634221",
"0.630194",
"0.6293434",
"0.6263928",
"0.6248005",
"0.6168659",
"0.61454284",
"0.6137253",
"0.6083866",
"0.6073943",
"0.6063152",
"0.60316104",... | 0.64695466 | 8 |
Arcseconds in a full turn | def turnasec(self):
return self.turndeg*self.deg2asec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle(self, angle: int, time: int = 0, /) -> None:",
"def check_angle_of_arcs(self):\n\n if self.thin_arc_start_angle >= 3600:\n self.thin_arc_start_angle %= 360\n self.thin_arc_start_angle += 360\n\n elif self.thin_arc_start_angle <= -3600:\n self.thin_arc_star... | [
"0.64920294",
"0.63348496",
"0.58788353",
"0.5837889",
"0.5771139",
"0.5746486",
"0.57345754",
"0.5653401",
"0.560239",
"0.55476874",
"0.5514553",
"0.54789144",
"0.5433282",
"0.5392291",
"0.53804815",
"0.53746235",
"0.53291017",
"0.53141046",
"0.5307146",
"0.52814186",
"0.526... | 0.56465614 | 8 |
Main data type of ``timescale`` object | def dtype(self):
return self.MJD.dtype | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_timescale(self, text=False):\n if text:\n return text_timescale[self.timescale]\n return self.timescale",
"def get_timescale_stringlist(self):\n return text_timescale",
"def __init__(self, data, t0=None, sampling_interval=None,\r\n sampling_rate=None, dur... | [
"0.6369052",
"0.6242251",
"0.6028106",
"0.5987445",
"0.5969164",
"0.58626974",
"0.58576125",
"0.5832977",
"0.58100027",
"0.5673811",
"0.56607765",
"0.5654231",
"0.5586185",
"0.5580415",
"0.5573964",
"0.5555997",
"0.5511585",
"0.5502394",
"0.5484541",
"0.54606164",
"0.5453321"... | 0.0 | -1 |
Dimensions of ``timescale`` object | def shape(self):
return np.shape(self.MJD) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDimensions():",
"def n(self):\n return self._time_axis.size",
"def getDimensions(self):\n\t\tprint \"Returning\",self.x,self.y,self.slicesPerTimepoint\n\t\treturn (self.x, self.y, self.slicesPerTimepoint)",
"def dimensions():",
"def getDimensions(self):\n return self._majax, se... | [
"0.73101234",
"0.6850362",
"0.684556",
"0.68177414",
"0.67772055",
"0.6557291",
"0.6495714",
"0.64714515",
"0.63878226",
"0.63554513",
"0.62954503",
"0.6271409",
"0.6236604",
"0.61936814",
"0.6155894",
"0.61523",
"0.6115309",
"0.6110591",
"0.6087786",
"0.6087386",
"0.6053563"... | 0.61676913 | 14 |
Number of dimensions in ``timescale`` object | def ndim(self):
return np.ndim(self.MJD) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n(self):\n return self._time_axis.size",
"def dimensions():",
"def get_dimension_length(self):\n pass",
"def getDimensions():",
"def getNumDimensions(self):\n return len(self.di.keys())",
"def dimension(self):",
"def dimension_count(self):\n return self._dimensionCount",... | [
"0.78763264",
"0.7570268",
"0.7397859",
"0.73891526",
"0.7375963",
"0.7257082",
"0.7176224",
"0.7130662",
"0.7108869",
"0.7108869",
"0.70566756",
"0.7014534",
"0.697521",
"0.6970627",
"0.69629836",
"0.6949205",
"0.69482416",
"0.694623",
"0.6916043",
"0.6906494",
"0.6903032",
... | 0.6858557 | 27 |
Number of time values | def __len__(self):
return len(np.atleast_1d(self.MJD)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def N(self):\n return len(self.time)",
"def n_timesteps(self) -> int:\n return len(self.time)",
"def count(time):\n \n return len(events(time))",
"def n(self):\n return self._time_axis.size",
"def getTimes():",
"def getTimes():",
"def getTimes():",
"def num_timesteps(self):... | [
"0.79427326",
"0.75147057",
"0.71630573",
"0.7151795",
"0.70408595",
"0.70408595",
"0.70408595",
"0.6885139",
"0.6813407",
"0.6734885",
"0.6663376",
"0.6615941",
"0.65652144",
"0.652506",
"0.6489599",
"0.6446774",
"0.64028627",
"0.63700676",
"0.6368978",
"0.63495255",
"0.6324... | 0.573078 | 77 |
Iterate over time values | def __iter__(self):
self.__index__ = 0
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTimes():",
"def getTimes():",
"def getTimes():",
"def with_time(self):\n if self.time_slices is None:\n raise FeatureError(\"Feature has no time reference.\")\n\n for i, datum in enumerate(self.data[self.name]):\n yield (self.time_slices[i], datum)",
"def time_ite... | [
"0.65052223",
"0.65052223",
"0.65052223",
"0.6386225",
"0.6376932",
"0.63017094",
"0.62274367",
"0.6165275",
"0.6150198",
"0.61159486",
"0.6094333",
"0.6039249",
"0.5973911",
"0.59392756",
"0.59242696",
"0.59179634",
"0.58911586",
"0.58628047",
"0.58271235",
"0.5775612",
"0.5... | 0.0 | -1 |
Get the next time step | def __next__(self):
temp = timescale()
try:
temp.MJD = np.atleast_1d(self.MJD)[self.__index__].copy()
except IndexError as exc:
raise StopIteration from exc
# add to index
self.__index__ += 1
return temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_step(self):\n if self.time_point + 1 >= len(self.data):\n print(\"Error: at last time point\")\n else:\n self.time_point = self.time_point + 1\n self.load_frame()",
"def current_time_step(self) -> ts.TimeStep:\n return self._current_time_step",
"def ge... | [
"0.72337455",
"0.71042407",
"0.7086954",
"0.68511105",
"0.6833489",
"0.67276645",
"0.6641585",
"0.6626885",
"0.6626885",
"0.6606148",
"0.6534634",
"0.65241814",
"0.6494662",
"0.6401727",
"0.6401727",
"0.6401727",
"0.6401727",
"0.63689667",
"0.63552856",
"0.63552856",
"0.63526... | 0.0 | -1 |
Calculates the difference between universal time (UT) and dynamical time (TT) | def interpolate_delta_time(
delta_file: str | pathlib.Path | None,
idays: np.ndarray,
):
# read delta time file
delta_file = pathlib.Path(delta_file).expanduser().absolute()
dinput = np.loadtxt(delta_file)
# calculate Julian days and then convert to days since 1992-01-01T00:00:00
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tt_utc_diff(jd_ut):\n prev_offset = None\n for start, offset in TAI_UTC_DIFF:\n if jd_ut < start:\n if prev_offset is None:\n t = jd_ut - JD_AT_1_JAN_2000 / DAYS_PER_CENTURY\n return 64.184 + 59 * t - 51.2 * t ** 2 - 67.1 * t ** 3 - 16.4 * t ** 4\n ... | [
"0.6853588",
"0.6493911",
"0.6304295",
"0.6261032",
"0.623478",
"0.62195843",
"0.61908835",
"0.6168742",
"0.6116449",
"0.61082405",
"0.60489404",
"0.6018364",
"0.5994444",
"0.5990104",
"0.5952031",
"0.5927282",
"0.5924082",
"0.5922242",
"0.5910568",
"0.59104574",
"0.5907921",... | 0.0 | -1 |
Counts the number of leap seconds between a given GPS time and UTC | def count_leap_seconds(
GPS_Time: np.ndarray | float,
truncate: bool = True
):
# get the valid leap seconds
leaps = get_leap_seconds(truncate=truncate)
# number of leap seconds prior to GPS_Time
n_leaps = np.zeros_like(GPS_Time,dtype=np.float64)
for i,leap in enumerate(leaps):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def utctoweekseconds(utc, leapseconds=18):\n datetimeformat = \"%Y-%m-%d %H:%M:%S\"\n epoch = datetime.datetime.strptime(\"1980-01-06 00:00:00\", datetimeformat)\n tdiff = utc - epoch + datetime.timedelta(seconds=leapseconds)\n gpsweek = tdiff.days // 7\n gpsdays = tdiff.days - 7 * gpsweek\n gpss... | [
"0.65216655",
"0.5833346",
"0.57278067",
"0.56890005",
"0.56728673",
"0.5596442",
"0.5512546",
"0.54993033",
"0.53895235",
"0.53806776",
"0.5326265",
"0.5325846",
"0.52866095",
"0.52589804",
"0.51825666",
"0.51720935",
"0.5155383",
"0.5153672",
"0.511898",
"0.51158345",
"0.50... | 0.714384 | 0 |
Gets a list of GPS times for when leap seconds occurred | def get_leap_seconds(truncate: bool = True):
leap_secs = pyTMD.utilities.get_data_path(['data','leap-seconds.list'])
# find line with file expiration as delta time
with leap_secs.open(mode='r', encoding='utf8') as fid:
secs, = [re.findall(r'\d+',i).pop() for i in fid.read().splitlines()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_leap_seconds(truncate: bool = True):\n leap_secs = icesat2_toolkit.utilities.get_data_path(['data','leap-seconds.list'])\n # find line with file expiration as delta time\n with leap_secs.open(mode='r', encoding='utf8') as fid:\n secs, = [re.findall(r'\\d+',i).pop() for i in fid.read().split... | [
"0.6766767",
"0.63627315",
"0.62256587",
"0.6170549",
"0.6149021",
"0.6144678",
"0.6141739",
"0.6091225",
"0.5989345",
"0.59563494",
"0.59563494",
"0.59563494",
"0.5944765",
"0.5895257",
"0.5883905",
"0.5882115",
"0.5879913",
"0.5851446",
"0.5811208",
"0.57886726",
"0.5767137... | 0.66635275 | 1 |
Connects to servers to download leapseconds.list files from NIST servers | def update_leap_seconds(
timeout: int | None = 20,
verbose: bool = False,
mode: oct = 0o775
):
# local version of file
FILE = 'leap-seconds.list'
LOCAL = pyTMD.utilities.get_data_path(['data',FILE])
HASH = pyTMD.utilities.get_hash(LOCAL)
# try downloading from NIST ftp s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createFileListHTTP(self, server, directory):\r\n conn = httplib.HTTPConnection(server)\r\n conn.request(\"GET\",directory)\r\n r1 = conn.getresponse()\r\n '''if r1.status==200:\r\n print \"status200 received ok\"\r\n else:\r\n print \"oh no = status=%d %... | [
"0.6307467",
"0.587883",
"0.57380795",
"0.5727244",
"0.57012963",
"0.5671404",
"0.5524113",
"0.5523881",
"0.54859656",
"0.5447411",
"0.53791904",
"0.5360122",
"0.53399926",
"0.5324205",
"0.5295918",
"0.52778655",
"0.5270903",
"0.5259758",
"0.52502596",
"0.52469534",
"0.520906... | 0.54354 | 10 |
Connects to servers to download historic_deltat.data and deltat.data files Reads IERS BulletinA produced iers_deltat.data files Creates a merged file combining the historic, monthly and daily files Longterm Delta T | def merge_delta_time(
username: str | None = None,
password: str | None = None,
verbose: bool = False,
mode: oct = 0o775
):
# retrieve history delta time files
pull_deltat_file('historic_deltat.data',
username=username, password=password,
verbose=verbose, mode... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_bulletin_a_files(\n username: str | None = None,\n password: str | None = None,\n verbose: bool = False,\n mode: oct = 0o775\n ):\n # if complete: replace previous version of file\n LOCAL = pyTMD.utilities.get_data_path(['data','iers_deltat.data'])\n COPY = pyTMD.u... | [
"0.62587607",
"0.6221167",
"0.61745095",
"0.61631536",
"0.6151757",
"0.60941243",
"0.60340184",
"0.59688264",
"0.59580076",
"0.5948104",
"0.5947647",
"0.5916482",
"0.5913912",
"0.5892256",
"0.58449537",
"0.5821589",
"0.5820833",
"0.5816526",
"0.5759664",
"0.57588494",
"0.5733... | 0.6115502 | 5 |
Appends merged delta time file with values from latest BulletinA file | def append_delta_time(verbose: bool = False, mode: oct = 0o775):
# append to merged file
merged_file = pyTMD.utilities.get_data_path(['data','merged_deltat.data'])
fid = merged_file.open(mode='a', encoding='utf8')
logging.info(str(merged_file))
file_format = ' {0:4.0f} {1:2.0f} {2:2.0f} {3:7.4f}'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_delta_time(\n username: str | None = None,\n password: str | None = None,\n verbose: bool = False,\n mode: oct = 0o775\n ):\n # retrieve history delta time files\n pull_deltat_file('historic_deltat.data',\n username=username, password=password,\n verbose... | [
"0.7121708",
"0.6431268",
"0.61592096",
"0.60849315",
"0.5973292",
"0.5875328",
"0.5809496",
"0.5783088",
"0.5770004",
"0.5732891",
"0.5731816",
"0.57240766",
"0.5704416",
"0.5630994",
"0.55934423",
"0.55868226",
"0.55500346",
"0.5529764",
"0.54655296",
"0.5397741",
"0.538316... | 0.7002459 | 1 |
Attempt to connects to the IERS server and the CDDIS Earthdata server to download and merge BulletinA files Reads the IERS BulletinA files and calculates the daily delta times Servers and Mirrors | def merge_bulletin_a_files(
username: str | None = None,
password: str | None = None,
verbose: bool = False,
mode: oct = 0o775
):
# if complete: replace previous version of file
LOCAL = pyTMD.utilities.get_data_path(['data','iers_deltat.data'])
COPY = pyTMD.utilities.get_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n # the url for african daily and global daily\n african_dialy_url = \"https://data.chc.ucsb.edu/products/CHIRPS-2.0/africa_daily/tifs/p25/\"\n global_daily_url = \"https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_daily/tifs/p25/\"\n\n\n each_year_list = GetRasterYears(url=african_dial... | [
"0.6011542",
"0.5969287",
"0.58123285",
"0.5759039",
"0.57266366",
"0.57164097",
"0.570907",
"0.55923307",
"0.5591778",
"0.54952574",
"0.5478434",
"0.5473248",
"0.5473054",
"0.5455511",
"0.5453085",
"0.54324836",
"0.5404204",
"0.5393854",
"0.5364291",
"0.5353479",
"0.5330724"... | 0.6489078 | 0 |
Connects to the IERS ftp server to download BulletinA files | def iers_ftp_delta_time(
daily_file: str | pathlib.Path,
timeout: int | None = 120,
verbose: bool = False,
mode: oct = 0o775
):
# connect to ftp host for IERS bulletins
HOST = ['ftp.iers.org','products','eop','rapid','bulletina']
pyTMD.utilities.check_ftp_connection(HOST[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self):\r\n self.ftp = ftplib.FTP(self.host)\r\n self.ftp.set_debuglevel(1)\r\n self.ftp.set_pasv(True)\r\n self.ftp.login(self.login, self.passwd)\r\n if self.directory:\r\n self.ftp.cwd(self.directory)\r\n # optimize socket params for download task\... | [
"0.67025596",
"0.6390615",
"0.6259813",
"0.62463236",
"0.6128868",
"0.6115838",
"0.6099415",
"0.6080519",
"0.594889",
"0.588877",
"0.5813595",
"0.5800462",
"0.57651263",
"0.5740128",
"0.57006925",
"0.5670138",
"0.56504744",
"0.5615159",
"0.55837226",
"0.558215",
"0.55641663",... | 0.0 | -1 |
Connects to the IERS server to download BulletinA files | def iers_delta_time(
daily_file: str | pathlib.Path,
timeout: int | None = 120,
verbose: bool = False,
mode: oct = 0o775
):
# open output daily delta time file
daily_file = pathlib.Path(daily_file).expanduser().absolute()
fid = daily_file.open(mode='w', encoding='utf8')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_files(self):",
"def run(self):\n download(self.attempt)",
"def do_GET(self):\n server_ip = Setup.parse_options()['ip_address']\n uri = \"http://\" + server_ip + self.path\n response = urllib.urlopen(uri)\n self.copyfile(response, self.wfile)\n headers = se... | [
"0.62916917",
"0.61809975",
"0.6116133",
"0.6015992",
"0.59609467",
"0.59609467",
"0.59313524",
"0.58174115",
"0.57494986",
"0.5647868",
"0.56020874",
"0.55884147",
"0.55876315",
"0.55622876",
"0.5517662",
"0.5517662",
"0.5517662",
"0.5517662",
"0.5517662",
"0.5517662",
"0.55... | 0.0 | -1 |
Connects to the CDDIS Earthdata server to download BulletinA files Reads the IERS BulletinA files and calculates the daily delta times Servers and Mirrors | def cddis_delta_time(
daily_file: str | pathlib.Path,
username: str | None = None,
password: str | None = None,
verbose: bool = False,
mode: oct = 0o775
):
# connect to CDDIS Earthdata host for IERS bulletins
HOST = ['https://cddis.nasa.gov','archive','products','iers... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_data(origin_time, net, sta, loc, chan):\n \n dataDir_get = '/import/netapp-m-02-bay200/mseed_online/archive/'\n \n fileName = \".\".join((net, sta, \".\" + chan + \".D\",\n origin_time.strftime(\"%Y.%j\")))\n filePath = os.path.join(dataDir_get, origin_time.s... | [
"0.624917",
"0.62240523",
"0.61129135",
"0.6103739",
"0.6064117",
"0.5956849",
"0.5899511",
"0.5891214",
"0.58396065",
"0.5826257",
"0.58234257",
"0.5810777",
"0.5795678",
"0.57836735",
"0.57829314",
"0.5700951",
"0.5677488",
"0.56742716",
"0.56424415",
"0.5566769",
"0.556380... | 0.6056532 | 5 |
Read a weekly IERS BulletinA file and calculate the delta times (TT UT1) | def read_iers_bulletin_a(fileID):
# read contents from input file object
file_contents = fileID.read().decode('utf8').splitlines()
# parse header text to find time offsets
# TT-TAI
TT_TAI = 0
# TAI-UTC
TAI_UTC = 0
# counts the number of lines in the header
count = 0
HEADER = Fal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iers_delta_time(\n daily_file: str | pathlib.Path,\n timeout: int | None = 120,\n verbose: bool = False,\n mode: oct = 0o775\n ):\n # open output daily delta time file\n daily_file = pathlib.Path(daily_file).expanduser().absolute()\n fid = daily_file.open(mode='w', encod... | [
"0.5857724",
"0.576605",
"0.5764671",
"0.56473726",
"0.55392706",
"0.5518946",
"0.55164355",
"0.5499296",
"0.5458036",
"0.54435945",
"0.5402892",
"0.53991205",
"0.53944993",
"0.53934467",
"0.5388948",
"0.53689307",
"0.53484637",
"0.53417957",
"0.53347313",
"0.5307582",
"0.530... | 0.7188088 | 0 |
Connects to IERS Rapid Service/Prediction Center (RS/PC) and downloads latest BulletinA file | def update_bulletin_a(
timeout: int | None = 20,
verbose: bool = False,
mode: oct = 0o775
):
# local version of file
LOCAL = pyTMD.utilities.get_data_path(['data','ser7.dat'])
HASH = pyTMD.utilities.get_hash(LOCAL)
# try downloading from IERS Rapid Service/Prediction Center ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n # the url for african daily and global daily\n african_dialy_url = \"https://data.chc.ucsb.edu/products/CHIRPS-2.0/africa_daily/tifs/p25/\"\n global_daily_url = \"https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_daily/tifs/p25/\"\n\n\n each_year_list = GetRasterYears(url=african_dial... | [
"0.60492426",
"0.60171604",
"0.5783168",
"0.57165664",
"0.5605315",
"0.55862594",
"0.55782974",
"0.55782306",
"0.5566327",
"0.5501453",
"0.5471493",
"0.54270077",
"0.5419344",
"0.54091036",
"0.54085934",
"0.54044515",
"0.53976905",
"0.538624",
"0.53831536",
"0.5377734",
"0.53... | 0.5849966 | 2 |
Connects to servers and downloads delta time files Servers and Mirrors | def pull_deltat_file(
FILE: str,
username: str | None = None,
password: str | None = None,
timeout: int | None = 20,
verbose: bool = False,
mode: oct = 0o775
):
# local version of file
LOCAL = pyTMD.utilities.get_data_path(['data',FILE])
HASH = pyTMD.utili... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sync_with_server(self):\n response = self.conn_mng.dispatch_request('get_server_snapshot', '')\n if response is None:\n self.stop(1, '\\nReceived bad snapshot. Server down?\\n')\n\n server_timestamp = response['server_timestamp']\n files = response['files']\n\n syn... | [
"0.65158635",
"0.6249137",
"0.6246897",
"0.62433285",
"0.6172768",
"0.5878187",
"0.5850852",
"0.5845232",
"0.5677957",
"0.5639966",
"0.5639966",
"0.56367874",
"0.56188345",
"0.5617929",
"0.56096303",
"0.56053394",
"0.5603972",
"0.5597561",
"0.55865276",
"0.55839694",
"0.55655... | 0.56571853 | 9 |
Sets attributes to use later for processing files into a batch. Arguments | def set_processing_attrs(self,
image_data_generator,
target_size,
color_mode,
data_format,
interpolation,
tfrecord,
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_attributes(self):",
"def set_attr(self):\n\n # Create a new array\n self.fileh.create_array('/', 'array', self.a1)\n for i in range(self.nobjects):\n # Set an attribute\n setattr(self.fileh.root.array.attrs, \"attr\" + str(i), str(self.a1))\n # Put a... | [
"0.663226",
"0.65376776",
"0.6433505",
"0.63417685",
"0.63057846",
"0.62907225",
"0.62907225",
"0.62907225",
"0.62564075",
"0.6250395",
"0.61584836",
"0.6117828",
"0.61080635",
"0.6101694",
"0.6066144",
"0.60353273",
"0.60230213",
"0.59905666",
"0.5890181",
"0.585173",
"0.578... | 0.52937835 | 87 |
writes data to tfrecord file | def write_tfrecord(self):
# build batch of image data
# self.filepaths is dynamic, is better to call it once outside the loop
filepaths = self.filepaths
labels = self.labels
tfrecord = self.tfrecord
with tf.io.TFRecordWriter(tfrecord) as writer:
for fpath, lab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_tfrecords_file(data, output_file):\n with tf.io.TFRecordWriter(str(output_file)) as writer:\n for image, sign in data:\n with tf.io.gfile.GFile(image, \"rb\") as f:\n image_string = f.read()\n feature = {\n \"image\": tf.train.Feature(\n bytes_list=tf.train.By... | [
"0.7325877",
"0.73068726",
"0.7304733",
"0.7111031",
"0.70561475",
"0.70471674",
"0.70471674",
"0.70045257",
"0.68853045",
"0.6885133",
"0.6868757",
"0.6831078",
"0.68181723",
"0.67123234",
"0.6695657",
"0.66853046",
"0.6652954",
"0.66398877",
"0.66188484",
"0.65502214",
"0.6... | 0.6723572 | 13 |
Calculates the MD5 sum of a file. | def md5_sum_file(path):
with open(path, 'rb') as f:
m = hashlib.md5()
while True:
data = f.read(8192)
if not data:
break
m.update(data)
return m.hexdigest() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def md5sum(file_name):\n f = open(file_name, mode='rb')\n h = hashlib.md5()\n h.update(f.read())\n return h.hexdigest()",
"def calculate_md5sum_of_a_file(context, file_name, file_path):\n command = \"md5sum \" + file_path + \"/\" + file_name + \" | awk {'print $1'}\"\n return context.cme_sessio... | [
"0.8501577",
"0.8366398",
"0.8354866",
"0.83091176",
"0.82591504",
"0.8246826",
"0.81144214",
"0.7983357",
"0.79745054",
"0.7973922",
"0.79374063",
"0.7884534",
"0.78658235",
"0.78574777",
"0.78492963",
"0.7834824",
"0.77871597",
"0.77637947",
"0.7742572",
"0.7533376",
"0.752... | 0.8164291 | 6 |
Reads a MD5 checksum file and returns hashes as a dictionary. | def readmd5_sum_file(path):
with open(path, "r") as f:
hashes = {}
while True:
line = f.readline()
if not line:
break
h, name = line.rstrip().split(' ', 1)
hashes[name] = h
return hashes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_md5_lookup(filename):\n lookup = {}\n\n with open(filename) as f:\n for row in f:\n (md5, sha256) = row.strip().split(\",\")\n lookup[md5] = sha256\n\n return lookup",
"def data_checksum(self, node):\n cmd = f\"find {RedpandaService.DATA_DIR} -type f -exec md5... | [
"0.6960468",
"0.6812591",
"0.6801497",
"0.6614257",
"0.6598387",
"0.6572755",
"0.65507716",
"0.6542189",
"0.6502235",
"0.64885104",
"0.6479202",
"0.646785",
"0.6450681",
"0.6447718",
"0.64337075",
"0.640807",
"0.6402168",
"0.63971865",
"0.6393921",
"0.6386618",
"0.63784134",
... | 0.8217127 | 0 |
Return index array matching criteria | def _filter_column(array, col, criteria):
# Raise an error if the column does not exist. This is the only way to
# test it across all possible types (pandas, recarray...)
try:
array[col]
except:
raise KeyError('Filtering criterion %s does not exist' % col)
if (not isinstance(criteri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_indexes(from_list, find_list):\n\n df_find = pd.DataFrame(find_list, columns=['value'])\n df_from = pd.DataFrame(list(zip(from_list, np.arange(len(from_list)))), columns=['value', 'index'])\n indexes = pd.merge(df_from, df_find, on='value', how='inner')['index'].values\n return indexes",
"def... | [
"0.648662",
"0.63990045",
"0.6351997",
"0.6327967",
"0.6317841",
"0.6282272",
"0.62778795",
"0.62594384",
"0.62156016",
"0.61883366",
"0.6183509",
"0.61677086",
"0.61461943",
"0.6115965",
"0.6113757",
"0.6105369",
"0.60910106",
"0.6073242",
"0.60502017",
"0.6050009",
"0.60446... | 0.0 | -1 |
Return indices of recarray entries that match criteria. | def filter_columns(array, filters, combination='and'):
if combination == 'and':
fcomb = np.logical_and
mask = np.ones(array.shape[0], dtype=np.bool)
elif combination == 'or':
fcomb = np.logical_or
mask = np.zeros(array.shape[0], dtype=np.bool)
else:
raise ValueError('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getIndexes(self, val):\n # Find where this value is listed. \n valNdx = (self.values == val).nonzero()[0]\n \n # If this value is not actually in those listed, then we \n # must return empty indexes\n if len(valNdx) == 0:\n start = 0\n end = 0\n ... | [
"0.66991407",
"0.6451458",
"0.6383022",
"0.63413405",
"0.62079084",
"0.61890465",
"0.6104715",
"0.60981125",
"0.60734594",
"0.6064704",
"0.60335106",
"0.6032053",
"0.6005462",
"0.6005365",
"0.59307843",
"0.5874397",
"0.58559686",
"0.5853381",
"0.583678",
"0.58103853",
"0.5805... | 0.0 | -1 |
Takes an iterable, and puts into the expected format of a tuple if triplet tuples. | def reformat_files(cls, files):
common_path = None # src base
out_files = []
for fil in files:
if isinstance(fil, string_types):
if len(files) == 1:
common_prefix = op.dirname(fil) + '/'
elif common_path is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_as_tuple(iterable):\n return tuple(chain(*iterable))",
"def strtuple(iterable): \n string = ''\n function = type(strtuple)\n for i in iterable:\n if isinstance(i , function):\n string += i.__name__ + ', '\n else:\n string += str(i) + ', '\n string = ... | [
"0.6921011",
"0.68820137",
"0.67969006",
"0.66930157",
"0.65410215",
"0.65340674",
"0.6524488",
"0.6501052",
"0.64999217",
"0.6474179",
"0.64328927",
"0.638195",
"0.634732",
"0.63379496",
"0.62362045",
"0.6152484",
"0.6152422",
"0.6125659",
"0.6123165",
"0.6112711",
"0.611111... | 0.0 | -1 |
generate the input data dict for ONNXinferenceSession run | def get_next(self) -> dict:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_inputs_for_inference(builder, conf):\r\n\r\n inputs = dict()\r\n\r\n inputs[\"mel_spec_input\"] = builder.addInputTensor(popart.TensorInfo(_get_popart_type(conf.precision),\r\n [conf.samples_per_device,\r\n ... | [
"0.6266671",
"0.6177044",
"0.61287516",
"0.60989565",
"0.60571",
"0.60435206",
"0.6002842",
"0.5988043",
"0.59797364",
"0.59707093",
"0.5946096",
"0.5901443",
"0.58849496",
"0.58652824",
"0.58643454",
"0.58619016",
"0.58595145",
"0.5857554",
"0.5846563",
"0.58404577",
"0.5838... | 0.0 | -1 |
reset the execution providers to execute the collect_data. It triggers to recreating inference session. | def set_execution_providers(self, execution_providers=["CPUExecutionProvider"]): # noqa: B006
self.execution_providers = execution_providers
self.create_inference_session() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n for provider in self.providers.values():\n provider.reset()\n\n for observation in self.observations.values():\n observation.reset()",
"def on_reset_after_execution(self):\n pass",
"def interactive_reset(self):\n # Set the initial state\n\n ... | [
"0.6323081",
"0.58850425",
"0.58387077",
"0.5724095",
"0.57188416",
"0.56691223",
"0.5652778",
"0.5533942",
"0.5513653",
"0.55113894",
"0.55113894",
"0.55113894",
"0.5511064",
"0.55093247",
"0.54930425",
"0.54805976",
"0.54596144",
"0.5457072",
"0.54517335",
"0.5450865",
"0.5... | 0.6150363 | 1 |
create an OnnxRuntime InferenceSession. | def create_inference_session(self):
sess_options = onnxruntime.SessionOptions()
sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_DISABLE_ALL
self.infer_session = onnxruntime.InferenceSession(
self.augmented_model_path,
sess_options=sess_optio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_ort_session(self, onnx_path):\n # Setup options for optimization\n sess_options = ort.SessionOptions()\n sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL\n sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL\n\n self.ort_sessio... | [
"0.64287347",
"0.63863736",
"0.6347452",
"0.5931692",
"0.5925455",
"0.58672893",
"0.5637707",
"0.5620587",
"0.5582713",
"0.55574703",
"0.550082",
"0.5489399",
"0.547671",
"0.54669124",
"0.5439374",
"0.54066926",
"0.5406201",
"0.53796494",
"0.5331371",
"0.5314776",
"0.5209954"... | 0.82782066 | 0 |
select input/output tensors of candidate nodes to calibrate. | def select_tensors_to_calibrate(self, model: ModelProto):
value_infos = {vi.name: vi for vi in model.graph.value_info}
value_infos.update({ot.name: ot for ot in model.graph.output})
value_infos.update({it.name: it for it in model.graph.input})
initializer = {init.name for init in model.g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learning_Utility(self):\n # Shape the input that we give to the neural network with the value of sensors, the previous actions the life of the agent \n # Get the results from the sensors according the different movement executed by the agent \n sensors_result_N = self.agent.sensors(self, d... | [
"0.5132529",
"0.5103128",
"0.50717694",
"0.50447917",
"0.5014779",
"0.50001043",
"0.49974504",
"0.49860495",
"0.49711442",
"0.49643132",
"0.49161378",
"0.49030358",
"0.49007672",
"0.48981002",
"0.48850143",
"0.485468",
"0.48339158",
"0.48284072",
"0.48257983",
"0.47925872",
"... | 0.5722057 | 0 |
Adds ReduceMin and ReduceMax nodes to all quantization_candidates op type nodes in model and ensures their outputs are stored as part of the graph output | def augment_graph(self):
tensors, _ = self.select_tensors_to_calibrate(self.model)
reshape_shape_name = str(uuid.uuid4())
reshape_shape = numpy_helper.from_array(np.array([1], dtype=np.int64), reshape_shape_name)
self.model.graph.initializer.append(reshape_shape)
def add_reduce_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_reduce(g, op, block):\n\n op_map = {\n \"reduce_all\": \"all\",\n \"reduce_any\": \"any\",\n \"reduce_max\": \"max\",\n \"reduce_min\": \"min\",\n \"reduce_prod\": \"prod\",\n \"reduce_sum\": \"sum\",\n \"reduce_mean\": \"mean\",\n }\n op_name =... | [
"0.5645855",
"0.53501433",
"0.5246339",
"0.52274525",
"0.5080488",
"0.50688004",
"0.5044712",
"0.49589333",
"0.4905664",
"0.4891885",
"0.48683834",
"0.48381573",
"0.48108053",
"0.4800535",
"0.47633642",
"0.47312012",
"0.47288904",
"0.471117",
"0.47105142",
"0.4692214",
"0.468... | 0.56021696 | 1 |
Compute the minmax range of tensor | def compute_data(self) -> TensorsData:
if len(self.intermediate_outputs) == 0:
return self.calibrate_tensors_range
output_names = [self.infer_session.get_outputs()[i].name for i in range(len(self.intermediate_outputs[0]))]
output_dicts_list = [
dict(zip(output_names, in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\n device = tensor.device\n tensor = tensor.detach().cpu()\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\n mn /= numpy.prod(tensor.shape[1:])\n q = alpha * (1 - mn) * 50\n n_samples = tensor.shape[0]\n add_view = [1] * (tensor.... | [
"0.7547379",
"0.7123834",
"0.7107737",
"0.7107506",
"0.7039821",
"0.6998676",
"0.6972081",
"0.6958474",
"0.69525874",
"0.69308096",
"0.68104637",
"0.6738522",
"0.6683714",
"0.6664642",
"0.6625571",
"0.66234326",
"0.6614864",
"0.6614411",
"0.65762603",
"0.6518506",
"0.6502009"... | 0.0 | -1 |
make all quantization_candidates op type nodes as part of the graph output. | def augment_graph(self):
self.tensors_to_calibrate, value_infos = self.select_tensors_to_calibrate(self.model)
for tensor in self.tensors_to_calibrate:
if tensor not in self.model_original_outputs:
self.model.graph.output.append(value_infos[tensor])
onnx.save(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _collect_ipt_and_opt_nodes(self):\n for name, node in self._nodes_collection.items():\n if node.in_degree == 0:\n # NOTICE: what's usage of `scope`?\n self._input_nodes.append(name)\n\n if node.out_degree == 0:\n self._output_nodes.appen... | [
"0.58436275",
"0.54256326",
"0.53823584",
"0.5308641",
"0.5279758",
"0.5254585",
"0.5193188",
"0.51130235",
"0.5092685",
"0.50865275",
"0.5085475",
"0.50561804",
"0.504065",
"0.500407",
"0.4975025",
"0.49684238",
"0.49679667",
"0.49663618",
"0.49435312",
"0.49369988",
"0.4936... | 0.0 | -1 |
Entropy Calibrator collects operators' tensors as well as generates tensor histogram for each operator. | def collect_data(self, data_reader: CalibrationDataReader):
while True:
inputs = data_reader.get_next()
if not inputs:
break
self.intermediate_outputs.append(self.infer_session.run(None, inputs))
if len(self.intermediate_outputs) == 0:
rai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(self, **kwargs) -> TensorType:",
"def entropy(self, **kwargs) -> TensorType:",
"def _make_histogram_ops(self, model):\n # only make histogram summary op if it hasn't already been made\n if self.histogram_freq and self.merged is None:\n for weight in self.model.trainable_var... | [
"0.6375051",
"0.6375051",
"0.5747862",
"0.5734022",
"0.57108384",
"0.5705662",
"0.56487167",
"0.55760294",
"0.5560576",
"0.55325216",
"0.5517932",
"0.54343194",
"0.541528",
"0.5407086",
"0.53932786",
"0.53651863",
"0.53597933",
"0.5357408",
"0.5326563",
"0.5320264",
"0.531402... | 0.0 | -1 |
Compute the minmax range of tensor | def compute_data(self) -> TensorsData:
if not self.collector:
raise ValueError("No collector created and can't generate calibration data.")
if isinstance(self, EntropyCalibrater):
cal = CalibrationMethod.Entropy
elif isinstance(self, PercentileCalibrater):
ca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_min_max(tensor: Tensor, alpha: float = 0.09) -> Tensor:\n device = tensor.device\n tensor = tensor.detach().cpu()\n mn = (tensor == 0).sum(dim=(1, 2, 3)).float()\n mn /= numpy.prod(tensor.shape[1:])\n q = alpha * (1 - mn) * 50\n n_samples = tensor.shape[0]\n add_view = [1] * (tensor.... | [
"0.75467235",
"0.7126264",
"0.7105955",
"0.7104534",
"0.70395917",
"0.6998385",
"0.69723856",
"0.69567525",
"0.6950661",
"0.6929797",
"0.6809948",
"0.6738251",
"0.66825795",
"0.66631263",
"0.6628244",
"0.6626751",
"0.6614928",
"0.66133803",
"0.6575226",
"0.65187347",
"0.65003... | 0.0 | -1 |
Generate informative data based on given data. | def collect(self, name_to_arr):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_data(sim_attr_generator):\n#TODO description\n if Args.data_to_show == 'dprime':\n show_dprime(sim_attr_generator)",
"def generate_ta(data):\n raise NotImplementedError",
"def format_data(self, data):",
"def _construct(self, data):\n logging.info(\"overall constructing (enter)\")\n... | [
"0.6068046",
"0.5998432",
"0.5993212",
"0.5823532",
"0.58189803",
"0.5803318",
"0.568087",
"0.5674967",
"0.56731486",
"0.5647276",
"0.5622952",
"0.56198436",
"0.5607101",
"0.55947775",
"0.55919886",
"0.5589899",
"0.5589657",
"0.5586132",
"0.55597925",
"0.5534209",
"0.5532182"... | 0.0 | -1 |
Get the optimal result among collection data. | def compute_collection_result(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetPts(self):\n return self.best",
"def getResults():",
"def _compute_best_value(self):\n reduced_cs = []\n concerned_vars = set()\n\n for c in self.utilities:\n asgt = filter_assignment_dict(self._neighbors_values, c.dimensions)\n reduced_cs.append(c.slice(asg... | [
"0.6284819",
"0.62337065",
"0.61745787",
"0.61052895",
"0.60609734",
"0.60476875",
"0.6004349",
"0.59691477",
"0.5940262",
"0.59164304",
"0.5862893",
"0.5773496",
"0.57638365",
"0.5753932",
"0.574135",
"0.57389337",
"0.5737159",
"0.57235175",
"0.5709042",
"0.56935674",
"0.567... | 0.6996528 | 0 |
Collect histogram on absolute value | def collect_absolute_value(self, name_to_arr):
for tensor, data_arr in name_to_arr.items():
data_arr = np.asarray(data_arr) # noqa: PLW2901
data_arr = data_arr.flatten() # noqa: PLW2901
if data_arr.size > 0:
min_value = np.min(data_arr)
max_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_histogram(self):\n\n for bin in range(self.bins.size):\n bin_inf = self.bins[bin]\n try: bin_sup = self.bins[bin + 1]\n except IndexError: bin_sup = self.vmax\n self.hist[bin] = np.sum(\n (self.values >= bin_inf)*(self.values < bin_sup))\n\n... | [
"0.6780593",
"0.6637294",
"0.6636672",
"0.6386098",
"0.6373501",
"0.6371298",
"0.6316349",
"0.6257009",
"0.62314403",
"0.6217895",
"0.6184364",
"0.6180108",
"0.614731",
"0.6107375",
"0.60950774",
"0.6084479",
"0.60823816",
"0.6082355",
"0.60809517",
"0.607641",
"0.60702395",
... | 0.7000032 | 0 |
Collect histogram on real value | def collect_value(self, name_to_arr):
for tensor, data_arr in name_to_arr.items():
data_arr = np.asarray(data_arr) # noqa: PLW2901
data_arr = data_arr.flatten() # noqa: PLW2901
if data_arr.size > 0:
min_value = np.min(data_arr)
max_value = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def just_histogram(*args, **kwargs):\n return np.histogram(*args, **kwargs)[0].astype(float)",
"def add_histogram(self, tag, values, global_step=None, bins='tensorflow'):\n values = make_np(values)\n self.vis.histogram(make_np(values), opts={'title': tag})",
"def get_histogram(self):\n... | [
"0.73119396",
"0.7298664",
"0.72432923",
"0.7087078",
"0.70734334",
"0.7008626",
"0.69554347",
"0.6877622",
"0.6859786",
"0.6762288",
"0.6739682",
"0.6714061",
"0.6659528",
"0.6620292",
"0.6579403",
"0.657029",
"0.65458226",
"0.6535959",
"0.6534714",
"0.6524735",
"0.6502923",... | 0.0 | -1 |
Given a dataset, find the optimal threshold for quantizing it. The reference distribution is `q`, and the candidate distribution is `p`. `q` is a truncated version of the original distribution. | def get_entropy_threshold(self, histogram, num_quantized_bins):
import copy
from scipy.stats import entropy
hist = histogram[0]
hist_edges = histogram[1]
num_bins = hist.size
zero_bin_index = num_bins // 2
num_half_quantized_bin = num_quantized_bins // 2
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Quantile(data, q, precision=1.0):\n N, bins = np.histogram(data, bins=precision*np.sqrt(len(data)))\n norm_cumul = 1.0*N.cumsum() / len(data)\n\n for i in range(0, len(norm_cumul)):\n if norm_cumul[i] > q:\n return bins[i]",
"def data_quality(dset):\n dq_threshold = config.tech[... | [
"0.6154804",
"0.60241234",
"0.5915163",
"0.5851482",
"0.5744234",
"0.56960785",
"0.5515238",
"0.54940593",
"0.5455812",
"0.5423219",
"0.5397638",
"0.53936654",
"0.5350975",
"0.53223306",
"0.52922076",
"0.52854943",
"0.52854943",
"0.52854943",
"0.5275716",
"0.5255272",
"0.5224... | 0.0 | -1 |
Computes entropyregularized optimal transport between x and y | def compute(self, x, y, u=None, grad=False):
assert_histograms(x, y)
if u is not None:
self.__u = u
else:
self.__u = rescale(self.__u)
self.__assert_correct_size(x, y)
self.__compute(x, y)
obj = self.__ground_metric.gamma * (x.T.dot(log_with_zeros... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfer_entropy(X, Y):\n coords = Counter(zip(Y[1:], X[:-1], Y[:-1]))\n\n p_dist = np.zeros((config.NUM_STATES, config.NUM_STATES, config.NUM_STATES))\n for y_f, x_p, y_p in coords.keys():\n p_dist[y_p, y_f, x_p] = coords[(y_f, x_p, y_p)] / (len(X) - 1)\n\n p_yp = p_dist.sum(axis=2).sum(axi... | [
"0.6386833",
"0.6281865",
"0.6155928",
"0.6110233",
"0.59215057",
"0.59209555",
"0.58993256",
"0.5835102",
"0.5834109",
"0.58311456",
"0.58072424",
"0.5790104",
"0.5757953",
"0.57465935",
"0.57386595",
"0.56911635",
"0.5677439",
"0.5672302",
"0.5649353",
"0.5635235",
"0.56268... | 0.0 | -1 |
Find the line that contains or matches substr since line ``start``. | def find_line(lines: List[str], substr: Predicate, start: int = 0) -> int:
if isinstance(substr, str):
pred = _string_contains
elif isinstance(substr, tuple):
pred = _pattern_value_match
else:
pred = _apply_func
for i in range(start, len(lines)):
if pred(lines[i], substr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _match_start_get_remaining(self, start, text):\n if not text.startswith(start):\n return\n return text[len(start):]",
"def _get_prev_line_having_substr(substr):\n last_occ_idx = vim.eval(SEARCH_LAST_CMD.format(substr=substr))\n if last_occ_idx == 0:\n return\n line_co... | [
"0.6829045",
"0.6382696",
"0.6371454",
"0.6307071",
"0.62964875",
"0.60427123",
"0.60387963",
"0.6038122",
"0.60191697",
"0.59272146",
"0.59037364",
"0.5864446",
"0.5817685",
"0.58130187",
"0.58130187",
"0.58130187",
"0.5806736",
"0.5797243",
"0.5758163",
"0.5758163",
"0.5746... | 0.73265594 | 0 |
Extract the lines between the line containing ``begin`` and the line containing ``end`` (excluding both lines) in ``parent``. | def extract_lines(parent: str, begin: Predicate, end: Predicate) -> str:
lines = parent.splitlines()
begin_line = find_line(lines, begin)
end_line = find_line(lines, end, begin_line+1)
new_lines = lines[begin_line+1:end_line]
return "\n".join(new_lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def section(fle, begin, end):\n with open(fle) as f:\n for line in f:\n # found start of section so start iterating from next line\n if line.startswith(begin):\n for line in f: \n # found end so end function\n if line.startswith(e... | [
"0.58529377",
"0.5581693",
"0.54582626",
"0.5362531",
"0.5349962",
"0.5346175",
"0.53401434",
"0.51990694",
"0.5192469",
"0.5124478",
"0.49769285",
"0.49085382",
"0.48960736",
"0.48947686",
"0.48660842",
"0.48560873",
"0.48549527",
"0.485269",
"0.4845138",
"0.48439127",
"0.48... | 0.81444484 | 0 |
Replace the lines between the line containing ``begin`` and the line containing ``end`` (excluding both lines) in ``parent`` with ``generated``. | def inject_lines(parent: str, begin: Predicate, end: Predicate, generated: str) -> str:
lines = parent.splitlines()
begin_line = find_line(lines, begin)
end_line = find_line(lines, end, begin_line+1)
new_lines = lines[:begin_line+1] + generated.splitlines() + lines[end_line:]
return "\n".join(new... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_new_file(file, new_content):\n with open(file, 'r') as f:\n old_content = f.read()\n\n try:\n before, begin_marker, _, end_marker, after = re.split(r'(// GENERATED-MARKER\\n)', old_content, flags=re.MULTILINE | re.DOTALL)\n except ValueError:\n raise RuntimeError(\"Failed... | [
"0.5403601",
"0.51225114",
"0.49107388",
"0.48132256",
"0.48054352",
"0.47870225",
"0.47572523",
"0.47332415",
"0.4713576",
"0.4713462",
"0.4688489",
"0.46581972",
"0.46474382",
"0.46446952",
"0.46335268",
"0.4598963",
"0.4561457",
"0.45551708",
"0.4552287",
"0.454125",
"0.45... | 0.71948594 | 0 |
Setters for _grilleCSV We read the csv file and copy it into _grilleCSV | def _set_grille_csv(self):
with open(self.csvPath, "r") as csvFile:
fileRead = csv.reader(csvFile, delimiter=",")
#We read each row of the csv file
for row in fileRead:
rowSplitted = row[0].split(";")
self._grilleCSV.append(rowSplitted) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv_file(self):\n pass",
"def read_csv():",
"def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n ... | [
"0.6927725",
"0.69130695",
"0.6871285",
"0.6801644",
"0.6744654",
"0.6588532",
"0.6566736",
"0.64618015",
"0.6455032",
"0.6349118",
"0.63289684",
"0.63281035",
"0.6291599",
"0.628651",
"0.6254619",
"0.6231155",
"0.62277955",
"0.62180835",
"0.62180835",
"0.62067026",
"0.620670... | 0.84458977 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.