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)
