def _setattr_helper__(self, name, value): if hasattr(self, name): # get target class targetClass=getattr(self,name).__class__ # convert class to native representation return name,to_native_class_converter(givenValue=value,nativeClass=targetClass) else: raise NameError("%s has no attribute named \'%s\' , the parameter attributes are : %s " % (str(solverParamClass),str(name),str(self.getParameterNames()) ))
def get_cpp_parameter(cls, operator, accumulator, parameter): _meta_parameter = parameter # get hyper parameter (as minStCut for graphcut, or the subsolver for # dualdec.) hyperParamKeywords = inferenceClasses.hyperParameterKeywords numHyperParams = len(hyperParamKeywords) userHyperParams = [None]*numHyperParams collectedHyperParameters = 0 # get the users hyper parameter ( if given) if(_meta_parameter is not None): for hpIndex, hyperParamKeyword in enumerate(hyperParamKeywords): if hyperParamKeyword in _meta_parameter.kwargs: userHyperParams[hpIndex] = _meta_parameter.kwargs.pop( hyperParamKeyword) collectedHyperParameters += 1 # check if ZERO or ALL hyperParamerts have been collected if collectedHyperParameters != 0 and collectedHyperParameters != numHyperParams: raise RuntimeError("All or none hyper-parameter must be given") # check if the WHOLE tuple of hyperParameters is allowed if collectedHyperParameters != 0: if tuple(str(x) for x in userHyperParams) not in inferenceClasses.implDict: raise RuntimeError("%s is not an allowed hyperParameter\nAllowed hyperParameters are %s" % ( repr(userHyperParams), repr(inferenceClasses.implDict.keys()))) else: userHyperParams = defaultHyperParams #try: # get the selected inference class and the parameter if(numHyperParams == 0): _selectedInfClass, _selectedInfParamClass = inferenceClasses.implDict[ "__NONE__"][(operator, accumulator)] else: hp = tuple(str(x) for x in userHyperParams) _selectedInfClass, _selectedInfParamClass = inferenceClasses.implDict[ hp][(operator, accumulator)] #except: # dictStr=str(inferenceClasses.implDict) # raise RuntimeError("given seminring (operator = %s ,accumulator = %s) is not implemented for this solver\n %s" % \ # (operator, accumulator,dictStr)) if _meta_parameter is None: cppParam = self._selectedInfClass._parameter() cppParam.set() else: cppParam = to_native_class_converter( givenValue=_meta_parameter, nativeClass=_selectedInfParamClass) assert cppParam is not None return cppParam
def _setattr_helper__(self, name, value): if hasattr(self, name): # get target class targetClass = getattr(self, name).__class__ # convert class to native representation return name, to_native_class_converter(givenValue=value, nativeClass=targetClass) else: raise NameError( "%s has no attribute named \'%s\' , the parameter attributes are : %s " % (str(solverParamClass), str(name), str(self.getParameterNames())))
def inference_init(self, gm, accumulator=None, parameter=None): # self._old_init() # set up basic properties self.gm = gm self.operator = gm.operator if accumulator is None: self.accumulator = defaultAccumulator(gm) else: self.accumulator = accumulator self._meta_parameter = parameter # get hyper parameter (as minStCut for graphcut, or the subsolver for # dualdec.) hyperParamKeywords = self._infClasses.hyperParameterKeywords numHyperParams = len(hyperParamKeywords) userHyperParams = [None] * numHyperParams collectedHyperParameters = 0 # get the users hyper parameter ( if given) if (self._meta_parameter is not None): for hpIndex, hyperParamKeyword in enumerate(hyperParamKeywords): if hyperParamKeyword in self._meta_parameter.kwargs: userHyperParams[hpIndex] = self._meta_parameter.kwargs.pop( hyperParamKeyword) collectedHyperParameters += 1 # check if ZERO or ALL hyperParamerts have been collected if collectedHyperParameters != 0 and collectedHyperParameters != numHyperParams: raise RuntimeError("All or none hyper-parameter must be given") # check if the WHOLE tuple of hyperParameters is allowed if collectedHyperParameters != 0: if tuple( str(x) for x in userHyperParams) not in inferenceClasses.implDict: raise RuntimeError( "%s is not an allowed hyperParameter\nAllowed hyperParameters are %s" % (repr(userHyperParams), repr(inferenceClasses.implDict.keys()))) else: userHyperParams = defaultHyperParams try: # get the selected inference class and the parameter if (numHyperParams == 0): self._selectedInfClass, self._selectedInfParamClass = inferenceClasses.implDict[ "__NONE__"][(self.operator, self.accumulator)] else: hp = tuple(str(x) for x in userHyperParams) self._selectedInfClass, self._selectedInfParamClass = inferenceClasses.implDict[ hp][(self.operator, self.accumulator)] except: dictStr = str(inferenceClasses.implDict) raise RuntimeError("given seminring (operator = %s ,accumulator = %s) is not implemented for this solver\n %s" % \ (self.operator, self.accumulator,dictStr)) if self._meta_parameter is None: self.parameter = self._selectedInfClass._parameter() self.parameter.set() else: self.parameter = to_native_class_converter( givenValue=self._meta_parameter, nativeClass=self._selectedInfParamClass) assert self.parameter is not None self.inference = self._selectedInfClass(self.gm, self.parameter)
def inference_init(self, gm, accumulator=None, parameter=None): # self._old_init() # set up basic properties self.gm = gm self.operator = gm.operator if accumulator is None: self.accumulator = defaultAccumulator(gm) else: self.accumulator = accumulator self._meta_parameter = parameter # get hyper parameter (as minStCut for graphcut, or the subsolver for # dualdec.) hyperParamKeywords = self._infClasses.hyperParameterKeywords numHyperParams = len(hyperParamKeywords) userHyperParams = [None]*numHyperParams collectedHyperParameters = 0 # get the users hyper parameter ( if given) if(self._meta_parameter is not None): for hpIndex, hyperParamKeyword in enumerate(hyperParamKeywords): if hyperParamKeyword in self._meta_parameter.kwargs: userHyperParams[hpIndex] = self._meta_parameter.kwargs.pop( hyperParamKeyword) collectedHyperParameters += 1 # check if ZERO or ALL hyperParamerts have been collected if collectedHyperParameters != 0 and collectedHyperParameters != numHyperParams: raise RuntimeError("All or none hyper-parameter must be given") # check if the WHOLE tuple of hyperParameters is allowed if collectedHyperParameters != 0: if tuple(str(x) for x in userHyperParams) not in inferenceClasses.implDict: raise RuntimeError("%s is not an allowed hyperParameter\nAllowed hyperParameters are %s" % ( repr(userHyperParams), repr(inferenceClasses.implDict.keys()))) else: userHyperParams = defaultHyperParams try: # get the selected inference class and the parameter if(numHyperParams == 0): self._selectedInfClass, self._selectedInfParamClass = inferenceClasses.implDict[ "__NONE__"][(self.operator, self.accumulator)] else: hp = tuple(str(x) for x in userHyperParams) self._selectedInfClass, self._selectedInfParamClass = inferenceClasses.implDict[ hp][(self.operator, self.accumulator)] except: dictStr=str(inferenceClasses.implDict) raise RuntimeError("given seminring (operator = %s ,accumulator = %s) is not implemented for this solver\n %s" % \ (self.operator, self.accumulator,dictStr)) if self._meta_parameter is None: self.parameter = self._selectedInfClass._parameter() self.parameter.set() else: self.parameter = to_native_class_converter( givenValue=self._meta_parameter, nativeClass=self._selectedInfParamClass) assert self.parameter is not None self.inference = self._selectedInfClass(self.gm, self.parameter)