def __init__(self, params): """ Parameter concatenation for convenience of printing regular expression matched arrays you can index this concatenation as if it was the flattened concatenation of all the parameters it contains, same for setting parameters (Broadcasting enabled). See :py:class:`GPy.core.parameter.Param` for more details on constraining. """ # self.params = params from lists_and_dicts import ArrayList self.params = ArrayList([]) for p in params: for p in p.flattened_parameters: if p not in self.params: self.params.append(p) self._param_sizes = [p.size for p in self.params] startstops = numpy.cumsum([0] + self._param_sizes) self._param_slices_ = [slice(start, stop) for start,stop in zip(startstops, startstops[1:])] parents = dict() for p in self.params: if p.has_parent(): parent = p._parent_ level = 0 while parent is not None: if parent in parents: parents[parent] = max(level, parents[parent]) else: parents[parent] = level level += 1 parent = parent._parent_ import operator self.parents = map(lambda x: x[0], sorted(parents.iteritems(), key=operator.itemgetter(1)))
def __init__(self, params): """ Parameter concatenation for convenience of printing regular expression matched arrays you can index this concatenation as if it was the flattened concatenation of all the parameters it contains, same for setting parameters (Broadcasting enabled). See :py:class:`GPy.core.parameter.Param` for more details on constraining. """ # self.params = params from lists_and_dicts import ArrayList self.params = ArrayList([]) for p in params: for p in p.flattened_parameters: if p not in self.params: self.params.append(p) self._param_sizes = [p.size for p in self.params] startstops = numpy.cumsum([0] + self._param_sizes) self._param_slices_ = [ slice(start, stop) for start, stop in zip(startstops, startstops[1:]) ] parents = dict() for p in self.params: if p.has_parent(): parent = p._parent_ level = 0 while parent is not None: if parent in parents: parents[parent] = max(level, parents[parent]) else: parents[parent] = level level += 1 parent = parent._parent_ import operator self.parents = map( lambda x: x[0], sorted(parents.iteritems(), key=operator.itemgetter(1)))
class ParamConcatenation(object): def __init__(self, params): """ Parameter concatenation for convenience of printing regular expression matched arrays you can index this concatenation as if it was the flattened concatenation of all the parameters it contains, same for setting parameters (Broadcasting enabled). See :py:class:`GPy.core.parameter.Param` for more details on constraining. """ # self.params = params from lists_and_dicts import ArrayList self.params = ArrayList([]) for p in params: for p in p.flattened_parameters: if p not in self.params: self.params.append(p) self._param_sizes = [p.size for p in self.params] startstops = numpy.cumsum([0] + self._param_sizes) self._param_slices_ = [ slice(start, stop) for start, stop in zip(startstops, startstops[1:]) ] parents = dict() for p in self.params: if p.has_parent(): parent = p._parent_ level = 0 while parent is not None: if parent in parents: parents[parent] = max(level, parents[parent]) else: parents[parent] = level level += 1 parent = parent._parent_ import operator self.parents = map( lambda x: x[0], sorted(parents.iteritems(), key=operator.itemgetter(1))) #=========================================================================== # Get/set items, enable broadcasting #=========================================================================== def __getitem__(self, s): ind = numpy.zeros(sum(self._param_sizes), dtype=bool) ind[s] = True params = [ p.param_array.flat[ind[ps]] for p, ps in zip(self.params, self._param_slices_) if numpy.any(p.param_array.flat[ind[ps]]) ] if len(params) == 1: return params[0] return ParamConcatenation(params) def __setitem__(self, s, val, update=True): if isinstance(val, ParamConcatenation): val = val.values() ind = numpy.zeros(sum(self._param_sizes), dtype=bool) ind[s] = True vals = self.values() vals[s] = val for p, ps in zip(self.params, self._param_slices_): p.flat[ind[ps]] = vals[ps] if update: self.update_all_params() def values(self): return numpy.hstack([p.param_array.flat for p in self.params]) #=========================================================================== # parameter operations: #=========================================================================== def update_all_params(self): for par in self.parents: par.notify_observers() def constrain(self, constraint, warning=True): [ param.constrain(constraint, trigger_parent=False) for param in self.params ] self.update_all_params() constrain.__doc__ = Param.constrain.__doc__ def constrain_positive(self, warning=True): [ param.constrain_positive(warning, trigger_parent=False) for param in self.params ] self.update_all_params() constrain_positive.__doc__ = Param.constrain_positive.__doc__ def constrain_fixed(self, value=None, warning=True, trigger_parent=True): [ param.constrain_fixed(value, warning, trigger_parent) for param in self.params ] constrain_fixed.__doc__ = Param.constrain_fixed.__doc__ fix = constrain_fixed def constrain_negative(self, warning=True): [ param.constrain_negative(warning, trigger_parent=False) for param in self.params ] self.update_all_params() constrain_negative.__doc__ = Param.constrain_negative.__doc__ def constrain_bounded(self, lower, upper, warning=True): [ param.constrain_bounded(lower, upper, warning, trigger_parent=False) for param in self.params ] self.update_all_params() constrain_bounded.__doc__ = Param.constrain_bounded.__doc__ def unconstrain(self, *constraints): [param.unconstrain(*constraints) for param in self.params] unconstrain.__doc__ = Param.unconstrain.__doc__ def unconstrain_negative(self): [param.unconstrain_negative() for param in self.params] unconstrain_negative.__doc__ = Param.unconstrain_negative.__doc__ def unconstrain_positive(self): [param.unconstrain_positive() for param in self.params] unconstrain_positive.__doc__ = Param.unconstrain_positive.__doc__ def unconstrain_fixed(self): [param.unconstrain_fixed() for param in self.params] unconstrain_fixed.__doc__ = Param.unconstrain_fixed.__doc__ unfix = unconstrain_fixed def unconstrain_bounded(self, lower, upper): [param.unconstrain_bounded(lower, upper) for param in self.params] unconstrain_bounded.__doc__ = Param.unconstrain_bounded.__doc__ def untie(self, *ties): [param.untie(*ties) for param in self.params] def checkgrad(self, verbose=0, step=1e-6, tolerance=1e-3): return self.params[0]._highest_parent_._checkgrad( self, verbose, step, tolerance) #checkgrad.__doc__ = Gradcheckable.checkgrad.__doc__ __lt__ = lambda self, val: self.values() < val __le__ = lambda self, val: self.values() <= val __eq__ = lambda self, val: self.values() == val __ne__ = lambda self, val: self.values() != val __gt__ = lambda self, val: self.values() > val __ge__ = lambda self, val: self.values() >= val def __str__(self, *args, **kwargs): def f(p): ind = p._raveled_index() return p.constraints.properties_for(ind), p._ties_for( ind), p.priors.properties_for(ind) params = self.params constr_matrices, ties_matrices, prior_matrices = zip(*map(f, params)) indices = [p._indices() for p in params] lc = max([ p._max_len_names(cm, __constraints_name__) for p, cm in itertools.izip(params, constr_matrices) ]) lx = max([p._max_len_values() for p in params]) li = max( [p._max_len_index(i) for p, i in itertools.izip(params, indices)]) lt = max([ p._max_len_names(tm, __tie_name__) for p, tm in itertools.izip(params, ties_matrices) ]) lp = max([ p._max_len_names(pm, __constraints_name__) for p, pm in itertools.izip(params, prior_matrices) ]) strings = [] start = True for p, cm, i, tm, pm in itertools.izip(params, constr_matrices, indices, ties_matrices, prior_matrices): strings.append( p.__str__(constr_matrix=cm, indices=i, prirs=pm, ties=tm, lc=lc, lx=lx, li=li, lp=lp, lt=lt, only_name=(1 - start))) start = False return "\n".join(strings) def __repr__(self): return "\n".join(map(repr, self.params)) def __ilshift__(self, *args, **kwargs): self[:] = np.ndarray.__ilshift__(self.values(), *args, **kwargs) def __irshift__(self, *args, **kwargs): self[:] = np.ndarray.__irshift__(self.values(), *args, **kwargs) def __ixor__(self, *args, **kwargs): self[:] = np.ndarray.__ixor__(self.values(), *args, **kwargs) def __ipow__(self, *args, **kwargs): self[:] = np.ndarray.__ipow__(self.values(), *args, **kwargs) def __ifloordiv__(self, *args, **kwargs): self[:] = np.ndarray.__ifloordiv__(self.values(), *args, **kwargs) def __isub__(self, *args, **kwargs): self[:] = np.ndarray.__isub__(self.values(), *args, **kwargs) def __ior__(self, *args, **kwargs): self[:] = np.ndarray.__ior__(self.values(), *args, **kwargs) def __itruediv__(self, *args, **kwargs): self[:] = np.ndarray.__itruediv__(self.values(), *args, **kwargs) def __idiv__(self, *args, **kwargs): self[:] = np.ndarray.__idiv__(self.values(), *args, **kwargs) def __iand__(self, *args, **kwargs): self[:] = np.ndarray.__iand__(self.values(), *args, **kwargs) def __imod__(self, *args, **kwargs): self[:] = np.ndarray.__imod__(self.values(), *args, **kwargs) def __iadd__(self, *args, **kwargs): self[:] = np.ndarray.__iadd__(self.values(), *args, **kwargs) def __imul__(self, *args, **kwargs): self[:] = np.ndarray.__imul__(self.values(), *args, **kwargs)
class ParamConcatenation(object): def __init__(self, params): """ Parameter concatenation for convenience of printing regular expression matched arrays you can index this concatenation as if it was the flattened concatenation of all the parameters it contains, same for setting parameters (Broadcasting enabled). See :py:class:`GPy.core.parameter.Param` for more details on constraining. """ # self.params = params from lists_and_dicts import ArrayList self.params = ArrayList([]) for p in params: for p in p.flattened_parameters: if p not in self.params: self.params.append(p) self._param_sizes = [p.size for p in self.params] startstops = numpy.cumsum([0] + self._param_sizes) self._param_slices_ = [slice(start, stop) for start,stop in zip(startstops, startstops[1:])] parents = dict() for p in self.params: if p.has_parent(): parent = p._parent_ level = 0 while parent is not None: if parent in parents: parents[parent] = max(level, parents[parent]) else: parents[parent] = level level += 1 parent = parent._parent_ import operator self.parents = map(lambda x: x[0], sorted(parents.iteritems(), key=operator.itemgetter(1))) #=========================================================================== # Get/set items, enable broadcasting #=========================================================================== def __getitem__(self, s): ind = numpy.zeros(sum(self._param_sizes), dtype=bool); ind[s] = True; params = [p.param_array.flat[ind[ps]] for p,ps in zip(self.params, self._param_slices_) if numpy.any(p.param_array.flat[ind[ps]])] if len(params)==1: return params[0] return ParamConcatenation(params) def __setitem__(self, s, val, update=True): if isinstance(val, ParamConcatenation): val = val.values() ind = numpy.zeros(sum(self._param_sizes), dtype=bool); ind[s] = True; vals = self.values(); vals[s] = val for p, ps in zip(self.params, self._param_slices_): p.flat[ind[ps]] = vals[ps] if update: self.update_all_params() def values(self): return numpy.hstack([p.param_array.flat for p in self.params]) #=========================================================================== # parameter operations: #=========================================================================== def update_all_params(self): for par in self.parents: par.notify_observers() def constrain(self, constraint, warning=True): [param.constrain(constraint, trigger_parent=False) for param in self.params] self.update_all_params() constrain.__doc__ = Param.constrain.__doc__ def constrain_positive(self, warning=True): [param.constrain_positive(warning, trigger_parent=False) for param in self.params] self.update_all_params() constrain_positive.__doc__ = Param.constrain_positive.__doc__ def constrain_fixed(self, value=None, warning=True, trigger_parent=True): [param.constrain_fixed(value, warning, trigger_parent) for param in self.params] constrain_fixed.__doc__ = Param.constrain_fixed.__doc__ fix = constrain_fixed def constrain_negative(self, warning=True): [param.constrain_negative(warning, trigger_parent=False) for param in self.params] self.update_all_params() constrain_negative.__doc__ = Param.constrain_negative.__doc__ def constrain_bounded(self, lower, upper, warning=True): [param.constrain_bounded(lower, upper, warning, trigger_parent=False) for param in self.params] self.update_all_params() constrain_bounded.__doc__ = Param.constrain_bounded.__doc__ def unconstrain(self, *constraints): [param.unconstrain(*constraints) for param in self.params] unconstrain.__doc__ = Param.unconstrain.__doc__ def unconstrain_negative(self): [param.unconstrain_negative() for param in self.params] unconstrain_negative.__doc__ = Param.unconstrain_negative.__doc__ def unconstrain_positive(self): [param.unconstrain_positive() for param in self.params] unconstrain_positive.__doc__ = Param.unconstrain_positive.__doc__ def unconstrain_fixed(self): [param.unconstrain_fixed() for param in self.params] unconstrain_fixed.__doc__ = Param.unconstrain_fixed.__doc__ unfix = unconstrain_fixed def unconstrain_bounded(self, lower, upper): [param.unconstrain_bounded(lower, upper) for param in self.params] unconstrain_bounded.__doc__ = Param.unconstrain_bounded.__doc__ def untie(self, *ties): [param.untie(*ties) for param in self.params] def checkgrad(self, verbose=0, step=1e-6, tolerance=1e-3): return self.params[0]._highest_parent_._checkgrad(self, verbose, step, tolerance) #checkgrad.__doc__ = Gradcheckable.checkgrad.__doc__ __lt__ = lambda self, val: self.values() < val __le__ = lambda self, val: self.values() <= val __eq__ = lambda self, val: self.values() == val __ne__ = lambda self, val: self.values() != val __gt__ = lambda self, val: self.values() > val __ge__ = lambda self, val: self.values() >= val def __str__(self, *args, **kwargs): def f(p): ind = p._raveled_index() return p.constraints.properties_for(ind), p._ties_for(ind), p.priors.properties_for(ind) params = self.params constr_matrices, ties_matrices, prior_matrices = zip(*map(f, params)) indices = [p._indices() for p in params] lc = max([p._max_len_names(cm, __constraints_name__) for p, cm in itertools.izip(params, constr_matrices)]) lx = max([p._max_len_values() for p in params]) li = max([p._max_len_index(i) for p, i in itertools.izip(params, indices)]) lt = max([p._max_len_names(tm, __tie_name__) for p, tm in itertools.izip(params, ties_matrices)]) lp = max([p._max_len_names(pm, __constraints_name__) for p, pm in itertools.izip(params, prior_matrices)]) strings = [] start = True for p, cm, i, tm, pm in itertools.izip(params,constr_matrices,indices,ties_matrices,prior_matrices): strings.append(p.__str__(constr_matrix=cm, indices=i, prirs=pm, ties=tm, lc=lc, lx=lx, li=li, lp=lp, lt=lt, only_name=(1-start))) start = False return "\n".join(strings) def __repr__(self): return "\n".join(map(repr,self.params)) def __ilshift__(self, *args, **kwargs): self[:] = np.ndarray.__ilshift__(self.values(), *args, **kwargs) def __irshift__(self, *args, **kwargs): self[:] = np.ndarray.__irshift__(self.values(), *args, **kwargs) def __ixor__(self, *args, **kwargs): self[:] = np.ndarray.__ixor__(self.values(), *args, **kwargs) def __ipow__(self, *args, **kwargs): self[:] = np.ndarray.__ipow__(self.values(), *args, **kwargs) def __ifloordiv__(self, *args, **kwargs): self[:] = np.ndarray.__ifloordiv__(self.values(), *args, **kwargs) def __isub__(self, *args, **kwargs): self[:] = np.ndarray.__isub__(self.values(), *args, **kwargs) def __ior__(self, *args, **kwargs): self[:] = np.ndarray.__ior__(self.values(), *args, **kwargs) def __itruediv__(self, *args, **kwargs): self[:] = np.ndarray.__itruediv__(self.values(), *args, **kwargs) def __idiv__(self, *args, **kwargs): self[:] = np.ndarray.__idiv__(self.values(), *args, **kwargs) def __iand__(self, *args, **kwargs): self[:] = np.ndarray.__iand__(self.values(), *args, **kwargs) def __imod__(self, *args, **kwargs): self[:] = np.ndarray.__imod__(self.values(), *args, **kwargs) def __iadd__(self, *args, **kwargs): self[:] = np.ndarray.__iadd__(self.values(), *args, **kwargs) def __imul__(self, *args, **kwargs): self[:] = np.ndarray.__imul__(self.values(), *args, **kwargs)