diff --git a/GPy/core/parameterization/param.py b/GPy/core/parameterization/param.py index e49dbe2e..75d9faf2 100644 --- a/GPy/core/parameterization/param.py +++ b/GPy/core/parameterization/param.py @@ -221,7 +221,9 @@ class Param(ObservableArray, Constrainable, Gradcheckable, Indexable, Parentable def _description_str(self): if self.size <= 1: return ["%f" % self] else: return [str(self.shape)] - def parameter_names(self, add_name=False): + def parameter_names(self, add_self=False, adjust_for_printing=False): + if adjust_for_printing: + return [adjust_name_for_printing(self.name)] return [self.name] @property def flattened_parameters(self): @@ -240,7 +242,7 @@ class Param(ObservableArray, Constrainable, Gradcheckable, Indexable, Parentable return [t._short() for t in self._tied_to_] or [''] def __repr__(self, *args, **kwargs): name = "\033[1m{x:s}\033[0;0m:\n".format( - x=self.name_hirarchical) + x=self.hirarchy_name()) return name + super(Param, self).__repr__(*args, **kwargs) def _ties_for(self, rav_index): # size = sum(p.size for p in self._tied_to_) @@ -274,7 +276,7 @@ class Param(ObservableArray, Constrainable, Gradcheckable, Indexable, Parentable gen = map(lambda x: " ".join(map(str, x)), gen) return reduce(lambda a, b:max(a, len(b)), gen, len(header)) def _max_len_values(self): - return reduce(lambda a, b:max(a, len("{x:=.{0}g}".format(__precision__, x=b))), self.flat, len(self.name_hirarchical)) + return reduce(lambda a, b:max(a, len("{x:=.{0}g}".format(__precision__, x=b))), self.flat, len(self.hirarchy_name())) def _max_len_index(self, ind): return reduce(lambda a, b:max(a, len(str(b))), ind, len(__index_name__)) def _short(self): @@ -302,8 +304,8 @@ class Param(ObservableArray, Constrainable, Gradcheckable, Indexable, Parentable if lp is None: lp = self._max_len_names(prirs, __tie_name__) sep = '-' header_format = " {i:{5}^{2}s} | \033[1m{x:{5}^{1}s}\033[0;0m | {c:{5}^{0}s} | {p:{5}^{4}s} | {t:{5}^{3}s}" - if only_name: header = header_format.format(lc, lx, li, lt, lp, ' ', x=self.name_hirarchical, c=sep*lc, i=sep*li, t=sep*lt, p=sep*lp) # nice header for printing - else: header = header_format.format(lc, lx, li, lt, lp, ' ', x=self.name_hirarchical, c=__constraints_name__, i=__index_name__, t=__tie_name__, p=__priors_name__) # nice header for printing + if only_name: header = header_format.format(lc, lx, li, lt, lp, ' ', x=self.hirarchy_name(), c=sep*lc, i=sep*li, t=sep*lt, p=sep*lp) # nice header for printing + else: header = header_format.format(lc, lx, li, lt, lp, ' ', x=self.hirarchy_name(), c=__constraints_name__, i=__index_name__, t=__tie_name__, p=__priors_name__) # nice header for printing if not ties: ties = itertools.cycle(['']) return "\n".join([header] + [" {i!s:^{3}s} | {x: >{1}.{2}g} | {c:^{0}s} | {p:^{5}s} | {t:^{4}s} ".format(lc, lx, __precision__, li, lt, lp, x=x, c=" ".join(map(str, c)), p=" ".join(map(str, p)), t=(t or ''), i=i) for i, x, c, t, p in itertools.izip(indices, vals, constr_matrix, ties, prirs)]) # return all the constraints with right indices # except: return super(Param, self).__str__() diff --git a/GPy/core/parameterization/parameter_core.py b/GPy/core/parameterization/parameter_core.py index 2b2283c2..9a10f317 100644 --- a/GPy/core/parameterization/parameter_core.py +++ b/GPy/core/parameterization/parameter_core.py @@ -88,10 +88,12 @@ class Nameable(Parentable): self._name = name if self.has_parent(): self._direct_parent_._name_changed(self, from_name) - def hirarchy_name(self): + def hirarchy_name(self, adjust_for_printing=True): + if adjust_for_printing: adjust = lambda x: adjust_name_for_printing(x) + else: adjust = lambda x: x if self.has_parent(): - return self._direct_parent_.hirarchy_name() + "." + adjust_name_for_printing(self.name) - return adjust_name_for_printing(self.name) + return self._direct_parent_.hirarchy_name() + "." + adjust(self.name) + return adjust(self.name) class Parameterizable(Parentable): def __init__(self, *args, **kwargs): @@ -100,10 +102,13 @@ class Parameterizable(Parentable): _parameters_ = ParamList() self._added_names_ = set() - def parameter_names(self, add_name=False): - if add_name: - return [adjust_name_for_printing(self.name) + "." + xi for x in self._parameters_ for xi in x.parameter_names(add_name=True)] - return [xi for x in self._parameters_ for xi in x.parameter_names(add_name=True)] + def parameter_names(self, add_self=False, adjust_for_printing=False, recursive=True): + if adjust_for_printing: adjust = lambda x: adjust_name_for_printing(x) + else: adjust = lambda x: x + if recursive: names = [xi for x in self._parameters_ for xi in x.parameter_names(add_self=True, adjust_for_printing=adjust_for_printing)] + else: names = [adjust(x.name) for x in self._parameters_] + if add_self: names = map(lambda x: adjust(self.name) + "." + x, names) + return names def _add_parameter_name(self, param): pname = adjust_name_for_printing(param.name) diff --git a/GPy/core/parameterization/parameterized.py b/GPy/core/parameterization/parameterized.py index f510d330..12bf936c 100644 --- a/GPy/core/parameterization/parameterized.py +++ b/GPy/core/parameterization/parameterized.py @@ -305,13 +305,11 @@ class Parameterized(Constrainable, Pickleable, Observable, Gradcheckable, Parame """ if not isinstance(regexp, _pattern_type): regexp = compile(regexp) found_params = [] - for p in self.flattened_parameters: - if regexp.match(p.hirarchy_name()) is not None: + for n, p in itertools.izip(self.parameter_names(False, False, True), self.flattened_parameters): + if regexp.match(n) is not None: found_params.append(p) - if isinstance(p, Parameterized): - found_params.extend(p.grep_param_names(regexp)) return found_params - return [param for param in self._parameters_ if regexp.match(param.name) is not None] + def __getitem__(self, name, paramlist=None): if paramlist is None: paramlist = self.grep_param_names(name) @@ -323,26 +321,16 @@ class Parameterized(Constrainable, Pickleable, Observable, Gradcheckable, Parame return ParamConcatenation(paramlist) return paramlist[-1] return ParamConcatenation(paramlist) + def __setitem__(self, name, value, paramlist=None): try: param = self.__getitem__(name, paramlist) except AttributeError as a: raise a param[:] = value -# def __getattr__(self, name): -# return self.__getitem__(name) -# def __getattribute__(self, name): -# #try: -# return object.__getattribute__(self, name) - # except AttributeError: - # _, a, tb = sys.exc_info() - # try: - # return self.__getitem__(name) - # except AttributeError: - # raise AttributeError, a.message, tb def __setattr__(self, name, val): - # override the default behaviour, if setting a param, so broadcasting can by used - if hasattr(self, "_parameters_"): - paramlist = self.grep_param_names(name) - if len(paramlist) == 1: self.__setitem__(name, val, paramlist); return + # override the default behaviour, if setting a param, so broadcasting can by used + if hasattr(self, '_parameters_'): + pnames = self.parameter_names(False, adjust_for_printing=True, recursive=False) + if name in pnames: self._parameters_[pnames.index(name)][:] = val; return object.__setattr__(self, name, val); #=========================================================================== # Printing: