def from_params(cls, amplitude: float = 1, phase: float = 0, period: float = 2 * np.pi): amplitude = Parameter('amplitude', amplitude, min=0) phase = Parameter('phase', phase) period = Parameter('period', period, min=0, max=2 * np.pi) return cls(amplitude, phase, period)
def setup_pars(): d = { 'name': 'test', 'par1': Parameter('p1', 0.1, fixed=True), 'des1': Descriptor('d1', 0.1), 'par2': Parameter('p2', 0.1), 'des2': Descriptor('d2', 0.1), 'par3': Parameter('p3', 0.1), } return d
def __init__(self, m: Optional[Union[Parameter, float]] = None, c: Optional[Union[Parameter, float]] = None): super(Line, self).__init__("line", m=Parameter("m", 1.), c=Parameter("c", 0.)) if m is not None: self.m = m if c is not None: self.c = c
def setup_pars(): d = { "name": "test", "par1": Parameter("p1", 0.1, fixed=True), "des1": Descriptor("d1", 0.1), "par2": Parameter("p2", 0.1), "des2": Descriptor("d2", 0.1), "par3": Parameter("p3", 0.1), } return d
def test_baseCollection_constraints(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p2', 2) from easyCore.Fitting.Constraints import ObjConstraint p2.user_constraints['testing'] = ObjConstraint(p2, '2*', p1) obj = cls(name, p1, p2) cons: List[ObjConstraint] = obj.constraints assert len(cons) == 1
def test_baseCollection_iterator(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p2', 2) p3 = Parameter('p3', 3) p4 = Parameter('p4', 4) l_object = [p1, p2, p3, p4] obj = cls(name, *l_object) for index, item in enumerate(obj): assert item == l_object[index]
def test_baseCollection_iterator_dict(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p2', 2) p3 = Parameter('p3', 3) p4 = Parameter('p4', 4) l_object = [p1, p2, p3, p4] obj = cls(name, *l_object) d = obj.as_dict() obj2 = cls.from_dict(d) for index, item in enumerate(obj2): assert item.raw_value == l_object[index].raw_value
class Line(BaseObj): _defaults = [Parameter('m', 1), Parameter('c', 0)] def __init__(self, interface=None): super().__init__(self.__class__.__name__, *self._defaults) self.interface = interface if self.interface: for parameter in self.get_fit_parameters(): name = parameter.name setattr(self.__class__.__dict__[name], '_callback', property(self.__gitem(name), self.__sitem(self, name))) @property def gradient(self): if self.interface: return self.interface.get_value('m') else: return self.m.raw_value @property def intercept(self): if self.interface: return self.interface.get_value('c') else: return self.c.raw_value def fit_func(self, x: np.ndarray) -> np.ndarray: if self.interface: return self.interface.fit_func(x) else: raise NotImplementedError def __repr__(self): return f'Line: m={self.m}, c={self.c}' @staticmethod def __gitem(key: str) -> Callable: def inner(obj): obj.interface.get_value(key) return lambda obj: inner(obj) @staticmethod def __sitem(obj, key): def inner(value): obj.interface.set_value(key, value) return inner
def test_Base_GETSET_v3(): class A(BaseObj): a: ClassVar[Parameter] def __init__(self, a: Parameter): super(A, self).__init__("a", a=a) @classmethod def from_pars(cls, a: float): return cls(a=Parameter("a", a)) a_start = 5 a_end = 10 a = A.from_pars(a_start) graph = a._borg.map def get_key(obj): return graph.convert_id_to_key(obj) assert a.a.raw_value == a_start assert len(graph.get_edges(a)) == 1 a_ = Parameter("a", a_end) assert get_key(a.a) in graph.get_edges(a) a__ = a.a setattr(a, "a", a_) assert a.a.raw_value == a_end assert len(graph.get_edges(a)) == 1 assert get_key(a_) in graph.get_edges(a) assert get_key(a__) not in graph.get_edges(a)
def test_BaseCreation(): class A(BaseObj): def __init__(self, a: Optional[Union[Parameter, float]] = None): super(A, self).__init__("A", a=Parameter("a", 1.)) if a is not None: self.a = a a = A() assert a.a.raw_value == 1. a = A(2.) assert a.a.raw_value == 2. a = A(Parameter("a", 3.)) assert a.a.raw_value == 3. a.a = 4. assert a.a.raw_value == 4. class B(BaseObj): def __init__(self, b: Optional[Union[A, Parameter, float]] = None): super(B, self).__init__("B", b=A()) if b is not None: if isinstance(b, (float, Parameter)): b = A(b) self.b = b b = B() assert b.b.a.raw_value == 1. b = B(2.) assert b.b.a.raw_value == 2. b = B(A(3.)) assert b.b.a.raw_value == 3. b.b.a = 4. assert b.b.a.raw_value == 4.
def test_baseCollection_repr(cls): name = 'test' p1 = Parameter('p1', 1) obj = cls(name, p1) test_str = str(obj) ref_str = f'{cls.__name__} `{name}` of length 1' assert test_str == ref_str
def test_baseCollection_sort(cls): name = 'test' v = [1, 4, 3, 2, 5] expected = [1, 2, 3, 4, 5] d = cls(name, *[Parameter(f'p{i}', v[i]) for i in range(len(v))]) d.sort(lambda x: x.raw_value) for i, item in enumerate(d): assert item.value == expected[i]
def test_baseCollection_sameName(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p1', 2) p3 = Parameter('p3', 3) p4 = Parameter('p4', 4) l_object = [p1, p2, p3, p4] obj = cls(name, *l_object) assert len(l_object) == len(obj) for index, item in enumerate(obj): assert item == l_object[index] obj12 = obj['p1'] assert len(obj12) == 2 for index, item in enumerate(obj12): assert item == l_object[index]
def test_baseCollection_set_index(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p1', 2) p3 = Parameter('p3', 3) p4 = Parameter('p4', 4) l_object = [p1, p2, p3] obj = cls(name, *l_object) idx = 1 assert obj[idx] == p2 obj[idx] = p4 assert obj[idx] == p4 edges = obj._borg.map.get_edges(obj) assert len(edges) == len(obj) for item in obj: assert obj._borg.map.convert_id_to_key(item) in edges assert obj._borg.map.convert_id_to_key(p2) not in edges
class Line(BaseObj): """ Simple descriptor of a line. """ _defaults = [Parameter("m", 1), Parameter("c", 0)] def __init__(self, interface_factory: InterfaceFactory = None): """ Create a line and add an interface if requested :param interface_factory: interface controller object :type interface_factory: InterfaceFactory """ super().__init__(self.__class__.__name__, *self._defaults) self.interface = interface_factory self._set_interface() def _set_interface(self): if self.interface: # If an interface is given, generate bindings for parameter in self.get_fit_parameters(): name = parameter.name self.interface.generate_bindings(name) @property def gradient(self): if self.interface: return self.interface().get_value("m") else: return self.m.raw_value @property def intercept(self): if self.interface: return self.interface().get_value("c") else: return self.c.raw_value def __repr__(self): return f"Line: m={self.m}, c={self.c}"
def test_baseobj__add_component(setup_pars): name = setup_pars["name"] del setup_pars["name"] obj = BaseObj(name, **setup_pars) p = Parameter("added_par", 1) new_item_name = "Added" obj._add_component(new_item_name, p) assert hasattr(obj, new_item_name) a = getattr(obj, new_item_name) assert isinstance(a, Parameter)
def test_baseCollection_set_index_based(cls): name = 'test' p1 = Parameter('p1', 1) p2 = Parameter('p1', 2) p3 = Parameter('p3', 3) p4 = Parameter('p4', 4) p5 = Parameter('p5', 5) d = cls('testing', p1, p2) l_object = [p3, p4, p5] obj = cls(name, *l_object) idx = 1 assert obj[idx] == p4 obj[idx] = d assert obj[idx] == d edges = obj._borg.map.get_edges(obj) assert len(edges) == len(obj) for item in obj: assert obj._borg.map.convert_id_to_key(item) in edges assert obj._borg.map.convert_id_to_key(p4) not in edges
def test_baseCollection_append_base(cls, setup_pars): name = setup_pars['name'] del setup_pars['name'] new_item_name = 'boo' new_item_value = 100 new_item = Parameter(new_item_name, new_item_value) coll = cls(name, **setup_pars) n_before = len(coll) coll.append(new_item) assert len(coll) == n_before + 1 assert coll[-1].name == new_item_name assert coll[-1].value == new_item_value
def __init__(self, name: str = "polynomial", coefficients: Optional[Union[Iterable[Union[float, Parameter]], BaseCollection]] = None): super(Polynomial, self).__init__(name, coefficients=BaseCollection("coefficients")) if coefficients is not None: if issubclass(type(coefficients), BaseCollection): self.coefficients = coefficients elif isinstance(coefficients, Iterable): for index, item in enumerate(coefficients): if issubclass(type(item), Parameter): self.coefficients.append(item) elif isinstance(item, float): self.coefficients.append( Parameter(name="c{}".format(index), value=item)) else: raise TypeError( "Coefficients must be floats or Parameters") else: raise TypeError( "coefficients must be a list or a BaseCollection")
def from_pars(cls, A: float = 1, f: float = 1, p: float = 0): A = Parameter('Amplitude', A) f = Parameter('Frequency', f) p = Parameter('Phase', p) return cls(A, f, p)
""" Constraints example =================== This example shows the usages of the different constraints. """ from easyCore.Fitting import Constraints from easyCore.Objects.ObjectClasses import Parameter p1 = Parameter('p1', 1) constraint = Constraints.NumericConstraint(p1, '<', 5) p1.user_constraints['c1'] = constraint for value in range(4, 7): p1.value = value print(f'Set Value: {value}, Parameter Value: {p1}') #%% # To include embedded rST, use a line of >= 20 ``#``'s or ``#%%`` between your # rST and your code. This separates your example # into distinct text and code blocks. You can continue writing code below the # embedded rST text block:
def __init__(self, a: Optional[Union[Parameter, float]] = None): super(A, self).__init__("A", a=Parameter("a", 1.)) if a is not None: self.a = a
def from_pars(cls, a: float): return cls(a=Parameter("a", a))
x = np.linspace(x_min, x_max, num=int(nx)) d.easyCore.add_coordinate('x', x) d.easyCore.add_coordinate('y', x + 1) d.easyCore.add_variable( 'z', ['x', 'y'], np.sin(2 * np.pi * (x + sin_offest)).reshape( (-1, 1)) * np.cos(2 * np.pi * (x + cos_offset)).reshape( (1, -1)) + 2 * (0.5 - np.random.random(size=(int(nx), int(nx))))) s_off_start_point = 0 c_off_start_point = 0 b = BaseObj('line', s_off=Parameter('s_off', s_off_start_point), c_off=Parameter('c_off', c_off_start_point)) def fit_fun(x, *args, **kwargs): # In the real case we would gust call the evaluation fn without reference to the BaseObj return np.sin(2 * np.pi * (x[:, 0] + b.s_off.raw_value)) * np.cos( 2 * np.pi * (x[:, 1] + b.c_off.raw_value)) f = Fitter() f.initialize(b, fit_fun) print('Performing fit - No dask') t = time.time() f_res = d['z'].easyCore.fit(f)
def from_pars(cls, m, c, diff): m = Parameter("m", m) c = Parameter("c", c) diff = Parameter("diff", diff) return cls(m, c, diff)
def _defaults(self): return [Parameter('m', self._m), Parameter('c', self._c)]
__author__ = 'github.com/wardsimon' __version__ = '0.1.0' from easyCore import np from easyCore.Datasets.xarray import xr import matplotlib.pyplot as plt from easyCore.Objects.ObjectClasses import Parameter, BaseObj from easyCore.Fitting.Fitting import Fitter d = xr.Dataset() b = BaseObj('line', m=Parameter('m', 1), c=Parameter('c', 1)) def fit_fun(x, *args, **kwargs): # In the real case we would gust call the evaluation fn without reference to the BaseObj return b.c.raw_value + b.m.raw_value * x f = Fitter() f.initialize(b, fit_fun) nx = 1E3 x_min = 0 x_max = 100 x = np.linspace(x_min, x_max, num=int(nx)) y = 2*x - 1 + 5*(np.random.random(size=x.shape) - 0.5)
__author__ = 'github.com/wardsimon' __version__ = '0.1.0' from easyCore import np from easyCore.Datasets.xarray import xr from easyCore.Objects.ObjectClasses import Parameter, BaseObj from easyCore.Fitting.Fitting import Fitter import matplotlib.pyplot as plt d = xr.Dataset() b = BaseObj('line', m=Parameter('m', 1), c=Parameter('c', 1)) def fit_fun(x, *args, **kwargs): # In the real case we would gust call the evaluation fn without reference to the BaseObj return b.c.raw_value + b.m.raw_value * x f = Fitter() f.initialize(b, fit_fun) nx = 1E3 x_min = 0 x_max = 100 x = np.linspace(x_min, x_max, num=int(nx)) y1 = 2 * x - 1 + 5 * (np.random.random(size=x.shape) - 0.5) x2 = x + 20 y2 = 2 * x2 - 1 + 5 * (np.random.random(size=x2.shape) - 0.5)
__version__ = '0.1.0' from easyCore import np from easyCore.Datasets.xarray import xr import matplotlib.pyplot as plt from easyCore.Objects.ObjectClasses import Parameter, BaseObj from easyCore.Fitting.Fitting import Fitter d = xr.Dataset() m_starting_point = 1 c_starting_point = 1 b = BaseObj('line', m=Parameter('m', m_starting_point), c=Parameter('c', c_starting_point)) def fit_fun(x, *args, **kwargs): # In the real case we would gust call the evaluation fn without reference to the BaseObj return b.c.raw_value + b.m.raw_value * x nx = 1E3 x_min = 0 x_max = 100 x = np.linspace(x_min, x_max, num=int(nx)) y = 2*x - 1 + 5*(np.random.random(size=x.shape) - 0.5)